Section 01

The Big Idea — Two Operations, One Relationship

For most of calculus, derivatives and integrals feel like two completely separate tools. A derivative measures how fast something is changing at an instant — a slope. An integral measures the total accumulation of something over an interval — an area. They seem to answer opposite kinds of questions.

The Fundamental Theorem of Calculus (FTC) is the discovery that they are not separate at all. They are inverse operations — the same relationship that addition has with subtraction, or multiplication has with division. Differentiate an integral and you get back the original function. Integrate a derivative and you get back the original function (up to a constant). This single fact is why calculus works as one unified subject instead of two disconnected topics.

Section 02

Formal Statement — FTC Part 1 and Part 2

Part 1 tells you that integration and differentiation are inverse processes. Part 2 is the practical payoff: it hands you a way to compute the exact value of a definite integral without summing infinitely many rectangles — just find an antiderivative and plug in the two endpoints.

Section 03

Interactive: FTC Part 1 — Differentiating Accumulation

Pick a function f(t). Watch its accumulation function F(x) get built via integration, then differentiated right back to f(x) — confirming Part 1 in each case.

Section 04

Interactive: FTC Part 2 — Evaluating Definite Integrals

Four definite integrals, each solved the FTC way: find an antiderivative, then subtract F(a) from F(b). No rectangles, no limits of Riemann sums.

Section 05

The Odometer and Speedometer Model

Every car dashboard already contains a working demonstration of FTC. The speedometer shows your instantaneous speed — a rate. The odometer shows your total distance traveled — an accumulation of that rate over time.

Section 06

Interactive: Watching Area Accumulate

Let f(t) = t (a straight line through the origin). As x grows, the shaded area under the line from 0 to x grows too — that shaded area IS F(x). Click through increasing values of x and watch the accumulation function build up, one snapshot at a time.

Section 07

Why the Two Parts Are Really One Theorem

Part 1 and Part 2 can feel like two separate facts, but they’re two views of the exact same relationship, just pointed in opposite directions.

Section 08

Worked Example — Projectile Motion

A ball is thrown upward. Its velocity (accounting for gravity) is v(t) = −9.8t + 20 meters per second, where t is measured in seconds. Find the ball’s total displacement between t = 0 and t = 2 seconds.

Section 09

Common Mistakes to Avoid

Reversing F(a) and F(b)

The formula is F(b) − F(a), upper bound minus lower bound — never the other way around. Flipping it flips the sign of your answer.

Worrying about “+C”

For definite integrals, the constant of integration always cancels: (F(b)+C) − (F(a)+C) = F(b) − F(a). Any antiderivative works — you don’t need to find “the” one.

Ignoring discontinuities

If f has a vertical asymptote or jump inside [a,b], you can’t blindly apply FTC across it — the interval must be split or treated as an improper integral.

Confusing definite and indefinite

∫f(x)dx (indefinite) is a family of functions plus C. ∫ₐᵇf(x)dx (definite) is a single number. Only definite integrals get evaluated via FTC Part 2 directly.

Section 10

Real-World Applications

Physics — Motion

Displacement from velocity, velocity from acceleration, work done from a variable force — all direct FTC applications in mechanics.

Economics

Total cost is the integral of marginal cost. Consumer and producer surplus are computed as areas — definite integrals evaluated via FTC.

Medicine

Total drug absorbed into the bloodstream over time is the integral of the concentration-rate function — critical for dosage modeling.

Electrical Engineering

Total electric charge is the integral of current over time: Q = ∫ I(t) dt — a direct real-world use of FTC Part 2.

Probability

A cumulative distribution function (CDF) is the integral of a probability density function (PDF) — FTC Part 1 connects the two directly.

Biology

Total population growth over a period is the integral of the growth-rate function, used constantly in ecological and epidemiological modeling.

Section 11

Differentiation vs Integration — Comparison Table

Section 12

Code Examples — Python

Verifying FTC symbolically with SymPy

from sympy import *

x, t = symbols('x t')

# FTC Part 1: differentiate an accumulation function
f = t
F = integrate(f, (t, 0, x))       # F(x) = x**2/2
check = diff(F, x)                    # should equal f
print(F, "->", check)              # x**2/2 -> x

# FTC Part 2: evaluate a definite integral
result = integrate(x**2, (x, 0, 3))
print(result)                        # 9

result2 = integrate(sin(x), (x, 0, pi))
print(result2)                       # 2

Numerical integration with SciPy (matching the analytic answer)

from scipy.integrate import quad
import numpy as np

# ∫₀² e^x dx  — should be ~6.389
result, error = quad(lambda x: np.exp(x), 0, 2)
print(f"{result:.4f}")                 # 6.3891

# Projectile displacement: v(t) = -9.8t + 20, from t=0 to t=2
displacement, error = quad(lambda t: -9.8*t + 20, 0, 2)
print(f"{displacement:.1f} meters")     # 20.4 meters

Section 13

Knowledge Quiz

Click a question to expand it, then pick your answer.

Section 01

The Difference — A Lock Code vs. A Fruit Bowl

Imagine two everyday situations. First: you’re setting a 3-digit code on a padlock using digits 1, 2, and 3. The code 1-2-3 is completely different from 3-2-1 — they open different locks (or rather, only the exact sequence you set will open yours). Order matters. This is a permutation.

Second: you’re picking 3 fruits from a bowl to make a smoothie — an apple, a banana, and an orange. It doesn’t matter if you grabbed the apple first or the orange first — you end up with the exact same smoothie ingredients either way. Order doesn’t matter. This is a combination.

Section 02

Formal Definitions — The nPr and nCr Formulas

Both formulas start from the same n items, choosing r of them — they only differ in whether order counts.

Section 03

Interactive: Permutation or Combination?

Click through 5 real scenarios. Try to guess before reading the reasoning — this is the exact judgment call you’ll need to make on every word problem you encounter.

Section 04

The Factorial Foundation

Both formulas are built entirely from factorials, so it’s worth getting comfortable with them first. n! (read “n factorial”) means multiply every whole number from n down to 1.

Section 05

Interactive: Real-Life Permutations Gallery

Four real scenarios where order matters, each fully calculated.

  Permutations in the Real World

Olympic Podium PIN Code Seating Order Password

8 sprinters race in the 100m final. How many different ways can gold, silver, and bronze be awarded?

n = 8 sprinters, r = 3 medal positions
P(8,3) = 8! / (8−3)! = 8! / 5!
= 8 × 7 × 6
= 336 possible podium outcomes

336 ways — no repetition (a sprinter can’t win two medals), order matters (gold ≠ silver ≠ bronze)

A phone lock uses a 4-digit PIN, digits 0–9, and digits CAN repeat (like 1-1-2-2). How many possible PINs exist?

10 choices for each of 4 positions
10 × 10 × 10 × 10
= 10⁴
= 10,000 possible PINs

10,000 combinations — this is a “permutation with repetition”: order matters AND digits can repeat

5 friends want a group photo, standing in a row. How many different ways can they line up?

n = 5 friends, all 5 positions filled
5! = 5 × 4 × 3 × 2 × 1
= 120 possible lineups

120 ways — this is the special case where r = n (arranging ALL the items), so it’s just n!

A password requires exactly 4 DIFFERENT letters (no repeats), chosen from the 26-letter alphabet. How many such passwords exist?

n = 26 letters, r = 4 positions, no repeats
P(26,4) = 26! / (26−4)! = 26! / 22!
= 26 × 25 × 24 × 23
= 358,800 possible passwords

358,800 ways — order matters (ABCD ≠ DCBA) and no letter can repeat

Section 06

Interactive: Real-Life Combinations Gallery

Four real scenarios where order doesn’t matter — only which items get chosen.

  Combinations in the Real World

Lottery Committee Pizza Toppings Poker Hand

A lottery draws 6 numbers from a pool of 49. How many different winning combinations are possible?

n = 49 numbers, r = 6 drawn
C(49,6) = 49! / [6! × 43!]
= (49×48×47×46×45×44) / 720
= 13,983,816 possible combinations

~14 million combinations — {1,2,3,4,5,6} is the same winning ticket regardless of the order the balls were drawn in

A club with 10 members needs to select a 3-person committee, with no distinct roles. How many possible committees exist?

n = 10 members, r = 3 chosen
C(10,3) = 10! / [3! × 7!]
= (10×9×8) / (3×2×1)
= 720 / 6 = 120 possible committees

120 ways — {Alice, Bob, Carla} is one single committee, regardless of who was “picked first”

A pizza place offers 8 toppings. How many different 3-topping pizzas can you order?

n = 8 toppings, r = 3 chosen
C(8,3) = 8! / [3! × 5!]
= (8×7×6) / (3×2×1)
= 336 / 6 = 56 possible pizzas

56 unique pizzas — a mushroom-olive-pepper pizza is identical to a pepper-mushroom-olive pizza

A standard deck has 52 cards. How many different 5-card poker hands are possible?

n = 52 cards, r = 5 dealt
C(52,5) = 52! / [5! × 47!]
= (52×51×50×49×48) / 120
= 2,598,960 possible hands

~2.6 million hands — the order cards were dealt in doesn’t change what hand you’re holding

Section 07

The “Does Order Matter?” Test

A reliable 3-step process for any word problem you encounter:

Section 08

Worked Example — Building a Real Password System

Let’s combine everything into one realistic problem: a website requires passwords with exactly 2 different letters (no repeats) followed by 3 digits (digits CAN repeat). How many total passwords are possible?

Section 09

Permutations and Combinations with Repetition

The formulas above assume each item can only be chosen once. Real life often allows repeats — here’s how the math changes.

Worked Example — Ice Cream Scoops

An ice cream shop has 5 flavors. You order 3 scoops, and you’re allowed to repeat a flavor (like 2 scoops chocolate + 1 scoop vanilla). Order doesn’t matter — a cup with chocolate-chocolate-vanilla is the same order regardless of which scoop went in first.

Section 10

Pascal’s Triangle Connection

Every entry in Pascal’s Triangle IS a combination value. Row n, position k gives you exactly C(n,k) — no calculation required, just count and look it up.

Look at row n=6: the entries are C(6,0)=1, C(6,1)=6, C(6,2)=15, C(6,3)=20, and so on. Each number is the sum of the two numbers diagonally above it — which is exactly Pascal’s Rule: C(n,k) = C(n−1,k−1) + C(n−1,k).

Section 11

Real-World Domains

Cryptography

Key space size for a cipher is a permutation calculation — the number of possible keys directly determines how brute-forceable an encryption scheme is.

Genetics

Counting possible DNA sequences, or the number of ways alleles can combine in offspring, relies directly on permutation and combination formulas.

Tournament Brackets

The number of possible ways a single-elimination bracket can play out, or how many unique round-robin schedules exist, is pure combinatorics.

Scheduling

Assigning employees to shifts, or students to exam time slots, is a permutation/combination problem — especially when constraints (no repeats, fixed roles) apply.

Quality Control

Choosing a random sample of r items from a batch of n to inspect for defects is a classic combination — order of inspection doesn’t matter.

Game Design

Loot drop tables, card game deck compositions, and probability balancing in games all rely on combinatorics to calculate fair odds.

Section 12

Code Examples — Python

Using math.perm() and math.comb() (Python 3.8+)

import math

# Olympic podium — 3 medals from 8 finalists, order matters
print(math.perm(8, 3))     # 336

# Lottery — choose 6 numbers from 49, order doesn't matter
print(math.comb(49, 6))    # 13983816

# Password letters — 2 of 26, no repeats, order matters
print(math.perm(26, 2))    # 650

# Pizza toppings — choose 3 of 8, order doesn't matter
print(math.comb(8, 3))     # 56

# PIN code — permutation WITH repetition (not built into math module)
pin_combos = 10 ** 4
print(pin_combos)          # 10000

# Ice cream scoops — combination WITH repetition (stars and bars)
ice_cream = math.comb(5 + 3 - 1, 3)
print(ice_cream)          # 35

Generating the actual arrangements with itertools

from itertools import permutations, combinations

runners = ['A', 'B', 'C', 'D']

# All ordered podium outcomes (top 3 of 4 runners)
podiums = list(permutations(runners, 3))
print(len(podiums))      # 24  =  4P3
print(podiums[:3])
# [('A','B','C'), ('A','B','D'), ('A','C','B'), ...]

# All unordered committees (any 3 of 4 people)
committees = list(combinations(runners, 3))
print(len(committees))   # 4  =  4C3
print(committees)
# [('A','B','C'), ('A','B','D'), ('A','C','D'), ('B','C','D')]

Section 13

Knowledge Quiz

Click a question to expand it, then pick your answer.

Q4 — Why is choosing a 5-card poker hand a combination rather than a permutation?

Because there are only 52 cards in a deck Because face cards are different from number cards Because the order the cards were dealt in doesn’t change which hand you’re holding Because repetition is allowed in card games

A hand of {A, K, 7, 3, 2} is the same hand no matter which card was dealt first. Since order doesn’t affect the outcome, it’s counted with combinations: C(52,5) = 2,598,960.

Section 01

What is a REST API? — The Waiter Analogy

Imagine a restaurant. You (the customer) never walk into the kitchen to cook your own food. Instead, you tell a waiter what you want from a menu, the waiter takes that request to the kitchen, and brings back your food. You don’t need to know how the kitchen works internally — you just need to know the menu and how to order.

A REST API (Representational State Transfer, Application Programming Interface) is exactly this waiter. Your app (the client) doesn’t access a company’s database directly. Instead, it sends a structured request to the API, the API talks to the “kitchen” (the server’s internal systems), and sends back a structured response — usually as JSON. REST is simply a set of conventions for how that request and response should be shaped, so any client and any server can understand each other without a custom, one-off arrangement.

Section 02

The 6 REST Constraints — Formal Definition

Roy Fielding defined REST as a set of architectural constraints. An API that satisfies all of them is truly “RESTful” — though in practice, most real-world APIs relax one or two (usually “code on demand,” which is optional anyway).

1. Client-Server

The client (UI) and server (data storage) are separate. Either can change independently as long as the interface between them stays the same.

2. Stateless

Every request must contain all information needed to process it. The server stores no client session state between requests.

3. Cacheable

Responses must explicitly state whether they can be cached, so clients can reuse data and reduce unnecessary requests.

4. Uniform Interface

A consistent way to identify resources (URLs) and interact with them (HTTP methods) — the core idea that makes REST predictable.

5. Layered System

The client can’t tell if it’s talking directly to the server or through intermediaries like load balancers or caches — and doesn’t need to.

6. Code on Demand (optional)

Servers can optionally send executable code (like JavaScript) to extend client functionality. The only constraint that’s optional.

Section 03

Interactive: HTTP Methods Explorer

REST maps standard HTTP methods onto CRUD operations (Create, Read, Update, Delete). Click each method below to see a real request and its typical response for a simple blog post API.

Section 04

Anatomy of a REST Request

Every REST request is built from four parts. Understanding each one is the key to reading any API’s documentation.

Section 05

Interactive: HTTP Status Code Explorer

Every response includes a 3-digit status code. The first digit tells you the category at a glance. Click each category to see the codes you’ll actually encounter.

Section 06

Resource Naming — Nouns, Not Verbs

The single most common REST mistake is putting an action inside the URL. REST already has actions — they’re the HTTP methods. URLs should describe what you’re acting on (a noun), not what to do to it (a verb).

Bad:  POST /api/createUser
Good: POST /api/users   ← the verb “create” comes from POST itself

Bad:  GET /api/getUserById?id=17
Good: GET /api/users/17   ← the ID is part of the resource path

Bad:  POST /api/deletePost/42
Good: DELETE /api/posts/42   ← DELETE method + noun path

Section 07

Interactive: Endpoint Design Gallery

Click through four common REST design decisions to compare a poor approach against the accepted best practice.

  Endpoint Design Gallery

Filtering Pagination Nested resources Versioning

Poor

POST /api/getActiveUsers
Body: {“active”: true}

Better

GET /api/users?active=true

Filtering is a read operation — it belongs in GET query parameters, not a POST body. This also makes the request cacheable and bookmarkable.

Poor

GET /api/posts
(returns all 50,000 posts at once)

Better

GET /api/posts?page=2&limit=25
or GET /api/posts?cursor=eyJpZCI6MTA1

Always paginate large collections. Offset-based (page/limit) is simple; cursor-based is more efficient and consistent for frequently-changing data.

Poor

GET /api/getOrdersForUser?userId=17

Better

GET /api/users/17/orders

Nesting expresses ownership directly in the URL structure. It reads naturally and is self-documenting — no need to check docs to guess the parameter name.

Poor

/api/users  (no version — breaking changes affect everyone immediately)

Better

/api/v1/users   or   Header: Accept: application/vnd.api+json;version=1

Versioning lets you evolve the API without breaking existing clients. URL versioning (/v1/) is simplest; header versioning is more “pure REST” but less discoverable.

Section 08

Statelessness Explained

Statelessness is the constraint developers misunderstand most often. It does not mean “the app has no persistent data” — a database is state, and REST APIs use them constantly. It means the server keeps no memory of the client between requests.

Section 09

Worked Example — A Full Request/Response Cycle

Let’s trace a complete real-world flow: a mobile app updating a user’s profile picture URL.

Section 10

REST vs SOAP vs GraphQL vs gRPC

Section 11

Real-World REST APIs

Stripe API

Widely considered a gold-standard REST API — consistent noun-based URLs, excellent status code usage, thorough documentation with live examples.

GitHub API

Fully RESTful with clean resource nesting (/repos/{owner}/{repo}/issues) — a commonly cited teaching example for good API design.

OpenWeatherMap

A simple, classic public REST API — a single GET request with query parameters returns current weather data as JSON.

Instagram Graph API

Uses REST conventions for reading and publishing content, layered with OAuth for authentication and permission scopes.

Spotify Web API

REST endpoints for tracks, playlists, and playback control — used by nearly every third-party Spotify app and integration.

Google Maps API

Geocoding, directions, and places endpoints — all accessed via simple GET requests with query parameters.

Section 12

Code Examples — Python, JavaScript, cURL

Python — using the requests library

import requests

# GET — fetch a resource
response = requests.get(
    "https://api.example.com/v1/posts/42",
    headers={"Authorization": "Bearer YOUR_TOKEN"}
)
print(response.status_code)   # 200
print(response.json())         # parsed dict

# POST — create a resource
response = requests.post(
    "https://api.example.com/v1/posts",
    headers={"Authorization": "Bearer YOUR_TOKEN"},
    json={"title": "New Post", "body": "Hello!"}
)
print(response.status_code)   # 201

# PATCH — partial update
response = requests.patch(
    "https://api.example.com/v1/posts/42",
    headers={"Authorization": "Bearer YOUR_TOKEN"},
    json={"published": True}
)

JavaScript — using fetch

// GET — fetch a resource
const res = await fetch("https://api.example.com/v1/posts/42", {
  headers: { "Authorization": "Bearer YOUR_TOKEN" }
});
const data = await res.json();
console.log(res.status, data);

// POST — create a resource
const created = await fetch("https://api.example.com/v1/posts", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({ title: "New Post", body: "Hello!" })
});

cURL — quick command-line testing

# GET request
curl -X GET https://api.example.com/v1/posts/42 \
  -H "Authorization: Bearer YOUR_TOKEN"

# POST request with JSON body
curl -X POST https://api.example.com/v1/posts \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"title": "New Post", "body": "Hello!"}'

# DELETE request
curl -X DELETE https://api.example.com/v1/posts/42 \
  -H "Authorization: Bearer YOUR_TOKEN"

Section 13

Knowledge Quiz

Click a question to expand it, then pick your answer.

Section 01

What is an AI Hallucination?

An AI hallucination is when a language model generates output that is fluent, confident, and completely wrong — a fabricated fact, a citation to a paper that doesn’t exist, a function that was never in the library, a quote nobody said. The term comes from human perception, where a hallucination is seeing something that isn’t there. The model isn’t “seeing” anything, but the analogy fits: it is generating something that has no basis in reality, with the same fluency as something true.

Think of a brilliant friend who has read almost everything but never admits when they don’t know something. Ask them a question and they will answer instantly and confidently — sometimes correctly, sometimes by smoothly inventing a plausible-sounding answer. They are not lying, because lying requires knowing the truth and hiding it. They genuinely cannot tell the difference between “I recall this” and “this sounds right.” That is a language model.

Section 02

Intrinsic vs Extrinsic — The Formal Definition

Researchers split hallucinations into two categories, depending on what the output contradicts:

Section 03

Interactive: Next-Token Prediction Explorer

Every word a language model produces is chosen from a probability distribution over its entire vocabulary. Click a prompt below to see simplified next-token probabilities. Notice what happens when no single answer clearly dominates — that flat, spread-out distribution is exactly where hallucinations are born.

  Next-Token Prediction Explorer

High confidence — capital city Medium confidence — a date Low confidence — obscure fact

Prompt: “The capital of France is ___“

Paris

97%

Lyon

1.5%

Marseille

0.8%

(other)

0.7%

Low hallucination risk. One token dominates overwhelmingly — this fact appeared millions of times in training data in exactly this pattern. The model is essentially certain.

Prompt: “The Battle of Hastings took place in the year ___“

1066

78%

1067

9%

1086

6%

(other)

7%

Moderate risk. The correct answer still leads clearly, but nearby wrong years have real probability mass — with unlucky sampling, a wrong-but-plausible year could get selected.

Prompt: “The third-longest river in Paraguay by tributary count is ___“

Río Apa

14%

Río Aquidabán

12%

Río Ypané

11%

Río Tebicuary

10%

(other, spread thin)

53%

High hallucination risk. No token dominates — this is an obscure, likely under-documented fact. The model will still confidently output ONE of these river names in fluent prose, with no indication of its uncertainty. This is the classic hallucination signature: a flat probability distribution rendered as a confident sentence.

Section 04

Why They Happen — 6 Root Causes

1. Next-Token Prediction, Not Fact-Checking

The model’s only job during generation is “what word comes next.” There is no separate module that checks generated claims against a database of true facts.

2. Training Data Gaps and Noise

If a topic was rare, contradictory, or wrong across the training corpus, the model absorbs that gap or error as if it were reliable pattern.

3. Sampling Randomness

Generation involves randomness (temperature, top-p sampling) by design — to avoid robotic repetitive text. That same randomness can select a low-probability, incorrect token.

4. No Real-Time Grounding

Without a retrieval or search tool connected, the model only has frozen knowledge from training — it cannot look anything up to double-check itself mid-answer.

5. Miscalibrated Confidence

Models are trained to sound helpful and fluent, not to output calibrated uncertainty. There’s no built-in “I’m only 14% sure” phrasing — everything comes out sounding equally confident.

6. Lossy Compression of Knowledge

A model with billions of parameters still compresses trillions of words of training text. Like a JPEG at low quality, fine details blur — and the model fills gaps with its best statistical guess.

Section 05

Interactive: Hallucination Gallery

Click through five common categories of hallucination. Each shows a real-style prompt, what a model might confidently generate, and what is actually true.

  Hallucination Gallery

Fake citation Fake API Confident wrong math Fabricated quote Merged facts

Prompt: “Cite a peer-reviewed study on the effect of blue light on sleep in teenagers.”

Hallucinated output

“Chen et al. (2019), ‘Blue Light Exposure and Adolescent Sleep Latency,’ Journal of Sleep Research, 28(4), 112–119.”

Reality

No such paper, authors, or journal issue exists. The citation format is perfect — journal name, volume, issue, page range — because the model learned the *pattern* of citations extremely well, just not this specific one.

Prompt: “How do I convert a pandas DataFrame column to datetime with a custom timezone?”

Hallucinated output

“Use df.column.to_datetime_tz(tz=’Asia/Kolkata’) — this converts and localises in one call.”

Reality

pandas has no method called to_datetime_tz(). The real approach is pd.to_datetime(df.column).dt.tz_localize(‘Asia/Kolkata’). The model blended two real, separately-existing pandas methods into one function name that sounds exactly like something pandas *should* have.

Prompt: “What is 847 × 293?”

Hallucinated output

“847 × 293 = 248,171”

Reality

The correct answer is 248,171… actually let’s verify: 847×293 = 848×293 – 293 = 248,464 – 293 = 248,171. In THIS case it’s correct — but the point is multi-digit multiplication has no guaranteed algorithm inside a language model; it is pattern-completing digit sequences, not running arithmetic circuits, so errors compound quickly with larger numbers.

Prompt: “What did Einstein say about imagination and knowledge?”

Commonly hallucinated

“Imagination is more important than knowledge, for knowledge is limited, whereas imagination embraces the entire world.” — attributed confidently with no hedge.

Reality

This quote IS genuinely from Einstein (1929 interview) — but this exact scenario is common: widely-repeated quotes get attached to famous names even when misquoted or entirely fabricated, because “quote + famous name” is an extremely common training pattern the model learned to reproduce fluently regardless of accuracy.

Prompt: “Summarize the plot of a novel where two people meet on a train and fall in love during WWII.”

Hallucinated output

Generates a detailed, coherent plot with named characters, settings, and a resolution — attributing it to a specific (nonexistent) novel title and author.

Reality

No such novel exists — the model merged elements from dozens of real WWII romance novels it was trained on into a plausible new synthesis, then presented it as one real existing book. This is “extrinsic” hallucination: unverifiable content dressed as fact.

Section 06

Interactive: Temperature and Sampling

“Temperature” controls how randomly a model samples from its next-token probability distribution. Lower temperature makes it pick the highest-probability token almost every time. Higher temperature flattens the distribution, giving low-probability (and potentially wrong) tokens a real chance of being chosen. Click through the same prompt at three different temperatures.

  Temperature Comparison — same prompt, three settings

Temperature = 0.0 Temperature = 0.7 Temperature = 1.5

Prompt: “List three lesser-known facts about the founding of the city of Timbuktu.”

temp = 0.0deterministicalways picks top token

1. Timbuktu was founded around the 5th century CE by Tuareg nomads as a seasonal camp.
2. It grew into a major center of trade in salt, gold, and books.
3. The University of Sankore made it a hub of Islamic scholarship by the 14th century.

Lowest hallucination risk — but not zero. At temp 0 the model always picks its single most likely token, giving the most “average” and well-supported answer it has. Repeatable and conservative, though it can still be confidently wrong if the top token itself is incorrect.

temp = 0.7balancedsome randomness

1. Timbuktu’s name may derive from “Tin Abutut,” referring to a well tended by a woman named Buktu.
2. Its libraries once held an estimated 700,000 manuscripts.
3. By the 1300s it briefly rivaled Cairo as a center of Islamic learning in West Africa.

Moderate risk — this is the typical default used in chat products. More varied and interesting phrasing, but occasional lower-probability claims slip in (exact manuscript counts and etymology claims are exactly the kind of specific-sounding numbers most likely to be invented).

temp = 1.5highly randomcreative but unstable

1. Timbuktu was reportedly founded in 1204 by the merchant-explorer Amara Keita after a caravan dispute.
2. Its original name, “Tinbouctu,” is said to mean “the place of the hidden well of stars.”
3. Early manuscripts suggest the city briefly minted its own gold currency called the “sanu-tomo.”

High risk — specific names, dates, and invented terms appear with total fluency and confidence. This is temperature-driven hallucination in its purest form: low-probability, largely fabricated tokens getting selected and then compounding into an entirely invented but very readable narrative.

Section 07

Types of Hallucinations

Section 08

How Hallucinations Are Measured

Researchers use standardized benchmarks to compare how often different models hallucinate. These typically involve asking models factual questions where a subtly wrong but plausible answer is a common human misconception — deliberately testing the gap between “sounds right” and “is right.”

Section 09

Real-World Consequences

Legal Filings

Multiple documented cases of lawyers submitting briefs with fabricated case citations generated by chatbots, leading to court sanctions and case dismissals.

Medical Information

Confidently wrong drug interaction or dosage claims are especially dangerous because the fluent, authoritative tone makes errors hard to spot without independent verification.

Customer Service Bots

An airline’s chatbot invented a bereavement fare policy that didn’t exist. A tribunal ruled the airline was still bound by what its bot had promised the customer.

Software Supply Chain

Attackers have started publishing malicious packages under names that AI coding assistants commonly hallucinate as real library names — a technique called “slopsquatting.”

News Summarization

AI news summary tools have attributed claims to sources that never made them, misrepresenting the actual reporting underneath.

Academic Research

Students and researchers citing AI-fabricated sources have had papers rejected or retracted after reviewers discovered the citations don’t exist.

Section 10

Mitigation Techniques

Section 11

Worked Example — Grounding with RAG

Retrieval-Augmented Generation (RAG) is the most effective widely-used mitigation. Instead of relying purely on the model’s compressed training memory, the system first retrieves real, current documents and feeds them into the prompt as context.

Without RAG

Prompt: “What is our company’s current refund policy?”

Model has no access to your company’s actual policy documents — it generates a plausible-sounding generic refund policy based on common patterns from training data, presented as if it were your specific company’s real policy.

With RAG

Prompt: “What is our company’s current refund policy?”

System first retrieves your actual policy document, inserts its real text into the prompt, then asks the model to answer using only that text. The model now has real grounding — reducing (not eliminating) fabrication risk to whether the model accurately reads the provided text.

Section 12

Code Example — Sampling Parameters

Here is how temperature and top-p (nucleus sampling) are actually set when calling a language model API — the same parameters demonstrated in the interactive Temperature demo above.

import anthropic

client = anthropic.Anthropic()

# Low temperature — for factual, deterministic tasks
# Minimizes risk of low-probability token selection
response_factual = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=500,
    temperature=0.0,  # deterministic, most-likely token every time
    messages=[{"role": "user", "content": "What year did WWII end?"}]
)

# Higher temperature — for creative, exploratory tasks
# Accepts more hallucination risk in exchange for variety
response_creative = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=500,
    temperature=1.0,
    messages=[{"role": "user", "content": "Write a whimsical short story about rain."}]
)

# RAG pattern — ground the model in real retrieved text
def answer_with_grounding(question, retrieved_docs):
    context = "\n\n".join(retrieved_docs)
    prompt = f"""Answer ONLY using the context below.
If the answer is not in the context, say "I don't have that information."

Context:
{context}

Question: {question}"""

    return client.messages.create(
        model="claude-sonnet-5",
        max_tokens=500,
        temperature=0.0,  # low temp — stick close to retrieved facts
        messages=[{"role": "user", "content": prompt}]
    )

Section 13

Knowledge Quiz

Click a question to expand it, then pick your answer.

Section 01

The Problem with Unbalanced BSTs

A Binary Search Tree (BST) is a beautiful data structure: every node’s left child is smaller, every right child is larger. Searching is O(log n) — you eliminate half the tree at each step. In theory.

In practice, the order you insert values determines the shape of the tree. Insert values in sorted order — 1, 2, 3, 4, 5 — and you get this:

That is not a tree — it is a linked list. Searching for 5 now requires visiting every single node. Your O(log n) search has degraded to O(n). The whole advantage of a BST is gone.

Section 02

What is an AVL Tree?

An AVL tree (named after its inventors Adelson-Velsky and Landis) is a self-balancing binary search tree. It maintains all the BST properties — left child smaller, right child larger — but adds one additional constraint:

After every insertion or deletion, the AVL tree checks this constraint at every affected node. If any node becomes unbalanced, it performs one or two rotations — local restructuring operations — to restore balance. The tree never needs to be rebuilt from scratch.

Section 03

The Balance Factor — The Key Metric

Every node in an AVL tree stores a balance factor (BF) — the difference between the height of its left subtree and the height of its right subtree.

class AVLNode:
    def __init__(self, key):
        self.key    = key
        self.left   = None
        self.right  = None
        self.height = 1   # new node starts at height 1

def get_height(node):
    return node.height if node else 0

def get_balance(node):
    return get_height(node.left) - get_height(node.right) if node else 0

def update_height(node):
    node.height = 1 + max(get_height(node.left), get_height(node.right))

Section 04

The Four Rotations — How AVL Rebalances

When the balance factor at a node becomes ±2, the AVL tree performs a rotation. There are four types, each handling a different pattern of imbalance. They all share one beautiful property: they restore balance while preserving the BST ordering property.

Right Rotation (LL case)

The unbalanced node z has BF = +2. Its left child y is taller. We rotate right around z — y takes z’s position, z becomes y’s right child.

def rotate_right(z):
    y = z.left          # y is the left child of z
    T3 = y.right        # T3 is the right subtree of y

    # Perform rotation
    y.right = z         # z becomes the right child of y
    z.left  = T3        # T3 moves to z's left (BST property preserved)

    # Update heights (z first, then y since y is now higher)
    update_height(z)
    update_height(y)

    return y             # y is the new root of this subtree

Left Rotation (RR case)

def rotate_left(z):
    y = z.right         # y is the right child of z
    T2 = y.left         # T2 is the left subtree of y

    # Perform rotation
    y.left  = z         # z becomes the left child of y
    z.right = T2        # T2 moves to z's right

    update_height(z)
    update_height(y)

    return y             # y is the new root

Section 05

Interactive Rotation Visualiser

Click any rotation to see the before and after states side by side. Notice how the BST ordering property is preserved — an in-order traversal of both trees gives the same sequence.

Section 06

Live AVL Tree Builder

Insert and delete values to build your own AVL tree. The tree rebalances automatically after every operation. Balance factors are shown inside each node — green means balanced, red means a rotation just happened.

Section 07

Insertion Algorithm — Step by Step

AVL insertion combines standard BST insertion with a recursive rebalancing pass back up to the root.

def insert(node, key):
    # Step 1: Standard BST insertion
    if not node:
        return AVLNode(key)

    if key < node.key:
        node.left  = insert(node.left,  key)
    elif key > node.key:
        node.right = insert(node.right, key)
    else:
        return node  # duplicate key — ignore

    # Step 2: Update height
    update_height(node)

    # Step 3: Get balance factor
    bf = get_balance(node)

    # Step 4: Determine case and rotate
    # LL Case
    if bf > 1 and key < node.left.key:
        return rotate_right(node)

    # RR Case
    if bf < -1 and key > node.right.key:
        return rotate_left(node)

    # LR Case
    if bf > 1 and key > node.left.key:
        node.left = rotate_left(node.left)
        return rotate_right(node)

    # RL Case
    if bf < -1 and key < node.right.key:
        node.right = rotate_right(node.right)
        return rotate_left(node)

    return node  # node is balanced — no rotation needed

Section 08

Time and Space Complexity

Section 09

AVL vs Red-Black Trees vs Plain BST

Section 10

Real-World Uses of AVL Trees

Section 11

Complete Python Implementation

class AVLNode:
    def __init__(self, key):
        self.key = key; self.left = self.right = None; self.height = 1

class AVLTree:
    def _h(self, n): return n.height if n else 0
    def _bf(self, n): return self._h(n.left) - self._h(n.right) if n else 0
    def _upd(self, n): n.height = 1 + max(self._h(n.left), self._h(n.right))

    def _rr(self, z):   # right rotation
        y = z.left; z.left = y.right; y.right = z
        self._upd(z); self._upd(y); return y

    def _lr(self, z):   # left rotation
        y = z.right; z.right = y.left; y.left = z
        self._upd(z); self._upd(y); return y

    def _balance(self, node, key):
        self._upd(node)
        bf = self._bf(node)
        if bf > 1:
            if key > node.left.key: node.left = self._lr(node.left)  # LR
            return self._rr(node)                                       # LL
        if bf < -1:
            if key < node.right.key: node.right = self._rr(node.right) # RL
            return self._lr(node)                                       # RR
        return node

    def insert(self, root, key):
        if not root: return AVLNode(key)
        if   key < root.key: root.left  = self.insert(root.left,  key)
        elif key > root.key: root.right = self.insert(root.right, key)
        else: return root
        return self._balance(root, key)

    def _min_node(self, n):
        while n.left: n = n.left
        return n

    def delete(self, root, key):
        if not root: return root
        if   key < root.key: root.left  = self.delete(root.left,  key)
        elif key > root.key: root.right = self.delete(root.right, key)
        else:
            if not root.left:  return root.right
            if not root.right: return root.left
            temp = self._min_node(root.right)
            root.key = temp.key
            root.right = self.delete(root.right, temp.key)
        return self._balance(root, root.key)

    def inorder(self, root):
        return (self.inorder(root.left) + [root.key] + self.inorder(root.right)) if root else []

# Usage
tree = AVLTree()
root = None
for v in [10, 20, 30, 40, 50, 25]:   # sorted order — would break plain BST
    root = tree.insert(root, v)

print("Inorder:", tree.inorder(root))    # → [10, 20, 25, 30, 40, 50]
print("Height:", root.height)             # → 3 (not 6 as it would be unbalanced)

root = tree.delete(root, 20)
print("After delete:", tree.inorder(root)) # → [10, 25, 30, 40, 50]

Section 12

Knowledge Quiz

Six questions to test your AVL tree understanding.

Section 01

What is an Outlier?

An outlier is a data point that lies far away from the rest of the observations in a dataset. It is a value that is unusually high or low compared to the typical range of the data.

Consider the salaries of five employees: £28k, £31k, £29k, £33k, £420k. That last value — £420k — is an outlier. It could be the CEO’s salary, a data entry error, or a completely different type of employee included by mistake. Each explanation calls for a different response.

Section 02

Why Outliers Matter — The Impact on Statistics

Outliers can have a dramatic or minimal effect depending on which statistical measure you use. The mean is highly sensitive. The median is almost immune. Understanding this asymmetry is one of the most practical skills in applied statistics.

Salary example — the CEO effect

A team of 10 employees. Nine earn between £28,000 and £35,000. One is the CEO earning £500,000.

Section 03

Types of Outliers

Not all outliers are the same. Understanding why a value is an outlier determines what you should do with it.

Section 04

How to Detect Outliers — 4 Methods

IQR Method — Worked Example

Dataset: 12, 15, 14, 10, 18, 14, 13, 100, 16, 11

Section 05

Interactive Outlier Detector

Enter your own dataset (comma-separated numbers) and choose a detection method. The detector will flag outliers instantly and show you the full statistical breakdown.

Section 06

Visualising Outliers with Box Plots

A box plot (also called a box-and-whisker plot) is the standard visual tool for outlier detection. The box shows the IQR (Q1 to Q3). The line inside is the median. The whiskers extend to the Tukey fences. Individual dots beyond the whiskers are outliers.

Section 07

How to Handle Outliers — 5 Strategies

After detecting an outlier, you have five options. The right one depends on the type of outlier and your analytical goal.

Section 08

When You Should NEVER Remove an Outlier

The phrase “never ignore them” in the title of this article is deliberate. Outliers are sometimes the most important data points. Here is when removing them would be a serious mistake:

Section 09

Real-World Examples

Section 10

Python Code

IQR Method

import numpy as np

data = np.array([12, 15, 14, 10, 18, 14, 13, 100, 16, 11, 9, 17])

Q1 = np.percentile(data, 25)
Q3 = np.percentile(data, 75)
IQR = Q3 - Q1

lower_fence = Q1 - 1.5 * IQR
upper_fence = Q3 + 1.5 * IQR

outliers = data[(data < lower_fence) | (data > upper_fence)]
clean    = data[(data >= lower_fence) & (data <= upper_fence)]

print(f"Q1={Q1}, Q3={Q3}, IQR={IQR}")
print(f"Fences: [{lower_fence:.1f}, {upper_fence:.1f}]")
print(f"Outliers: {outliers}")   # → [100]
print(f"Clean data: {clean}")

Z-Score Method

from scipy import stats
import numpy as np

data = np.array([12, 15, 14, 10, 18, 14, 13, 100, 16, 11])

z_scores = np.abs(stats.zscore(data))
threshold = 3.0

outliers = data[z_scores > threshold]
print(f"Z-scores: {z_scores.round(2)}")
print(f"Outliers (|z| > {threshold}): {outliers}")  # → [100]

Modified Z-Score (most robust)

import numpy as np

def modified_zscore(data):
    median = np.median(data)
    mad = np.median(np.abs(data - median))   # Median Absolute Deviation
    return 0.6745 * (data - median) / mad

data = np.array([12, 15, 14, 10, 18, 14, 13, 100, 16, 11])
m_scores = np.abs(modified_zscore(data))
outliers = data[m_scores > 3.5]
print(f"Outliers: {outliers}")  # → [100]

Winsorising (capping outliers)

from scipy.stats import mstats
import numpy as np

data = np.array([12, 15, 14, 10, 18, 14, 13, 100, 16, 11])

# Winsorise at 5th and 95th percentiles
winsorised = mstats.winsorize(data, limits=[0.05, 0.05])
print(f"Original:   {data}")
print(f"Winsorised: {np.array(winsorised)}")
# 100 is replaced with the 95th percentile value

# Log transformation for right-skewed data
log_data = np.log1p(data)   # log(1+x) handles zeros safely
print(f"Log:        {log_data.round(2)}")
# 100 → 4.62, rest compressed into smaller range

Box plot visualisation with matplotlib

import matplotlib.pyplot as plt
import numpy as np

data = [12, 15, 14, 10, 18, 14, 13, 100, 16, 11, 9, 17]

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))

# Box plot
bp = ax1.boxplot(data, vert=False, patch_artist=True,
                 flierprops=dict(marker='o', color='red', markersize=8))
bp['boxes'][0].set_facecolor('#99f6e4')
ax1.set_title('Box Plot — red dots are outliers')
ax1.set_xlabel('Value')

# Dot plot
ax2.scatter(data, [1]*len(data), alpha=0.7, s=80,
           c=['#e11d48' if x > 21 else '#0d9488' for x in data])
ax2.set_title('Dot Plot — red = outlier')
ax2.set_yticks([])

plt.tight_layout()
plt.show()

Section 11

Knowledge Quiz

Six questions to test your understanding of outliers in statistics.

Section 01

The Problem — Why Passwords Fail

In theory, a strong, unique password protects your account. In practice, passwords fail in ways that have nothing to do with how strong they are.

Passwords fail for several main reasons — and crucially, none of them require the hacker to guess your password correctly:

Section 02

What is Two-Factor Authentication?

Two-factor authentication (2FA) requires you to prove your identity in two different ways before granting access. The three categories of authentication factors are:

Section 03

How 2FA Works — Step by Step

Section 04

Interactive: Try a 2FA Login

Experience a two-factor login flow yourself. Use the credentials shown, then enter the one-time code that appears on your simulated device.

Section 05

The 5 Types of 2FA — Ranked by Security

Section 06

How 2FA Stops Hackers — Attack Scenarios

Let’s walk through exactly what happens when a hacker tries to break into an account — with and without 2FA enabled.

Section 07

Interactive: Password Strength Tester

See how long it would take to crack your password — and understand why even a strong password is not enough without 2FA.

Section 08

How TOTP Codes Are Generated — The Math

TOTP stands for Time-based One-Time Password (RFC 6238). When you scan a QR code to set up an authenticator app, you share a secret key with the server. Both your app and the server independently compute codes using this formula:

Because both your app and the server know the same secret key and the current time, they arrive at the same 6-digit code independently — without ever transmitting the code over a network. There is nothing to intercept in transit.

import hmac, hashlib, time, struct, base64

def generate_totp(secret_b32: str, digits: int = 6) -> str:
    # 1. Decode the base32 secret (what the QR code contains)
    key = base64.b32decode(secret_b32.upper())

    # 2. Get the current 30-second time window
    T = int(time.time()) // 30
    msg = struct.pack('>Q', T)

    # 3. Compute HMAC-SHA1
    h = hmac.new(key, msg, hashlib.sha1).digest()

    # 4. Dynamic truncation
    offset = h[-1] & 0x0F
    code = struct.unpack('>I', h[offset:offset+4])[0] & 0x7FFFFFFF

    # 5. Get last N digits
    return str(code % (10 ** digits)).zfill(digits)

# Production use: pip install pyotp
import pyotp
totp = pyotp.TOTP("JBSWY3DPEHPK3PXP")
print(totp.now())              # current 6-digit code
print(totp.verify("482156"))   # True / False

Section 09

How to Set Up 2FA — Step by Step

Step 1: Install an authenticator app

Step 2: Enable 2FA on your accounts

Section 10

Common Questions and Misconceptions

Section 11

Knowledge Quiz

Test what you have learned about two-factor authentication.

Section 01

What is a Normal Distribution?

A normal distribution (also called a Gaussian distribution or bell curve) is a way that data arranges itself around a central value — with most values clustered near the middle, and fewer and fewer values appearing as you move toward the extremes.

Plot it on a graph and you get the unmistakable bell shape: perfectly symmetric, peaked in the centre, tapering off equally on both sides. The curve never actually touches the x-axis — it just gets infinitely close at the extremes.

Section 02

Why Does Nature Produce Bell Curves?

This is the deep question. Why should human heights, leaf sizes, or measurement errors all form a bell? The answer comes from one of the most powerful theorems in all of mathematics: the Central Limit Theorem.

The Central Limit Theorem says: whenever a quantity is the result of many small, independent, random influences added together — the result will be normally distributed, no matter what distribution each individual influence has.

The logic in three steps

Section 03

Interactive: Coin Flips Become a Bell Curve

The clearest way to see the Central Limit Theorem is with coin flips. Flip a coin 10 times and count heads. Do it thousands of times. The histogram of “number of heads” will form a perfect bell curve.

Click Flip & Toss to simulate thousands of experiments. Watch the histogram grow into a bell shape before your eyes.

Section 04

Key Properties of the Normal Distribution

The normal distribution has a precise mathematical formula, but you don’t need to memorise it — you need to understand what its two parameters mean.

Section 05

Interactive Bell Curve Builder

Drag the sliders to change the mean (μ) and standard deviation (σ). Watch how the bell curve shifts position and changes shape in real time.

Section 06

The 68-95-99.7 Empirical Rule

One of the most useful facts about the normal distribution is that fixed percentages of data always fall within 1, 2, and 3 standard deviations of the mean — regardless of what μ and σ actually are.

Worked Example — Adult Male Heights

Adult male heights in the UK are approximately normally distributed with μ = 175 cm and σ = 7 cm. Using the empirical rule:

Section 07

Z-Scores — Standardising Any Normal Distribution

A z-score tells you how many standard deviations a value is away from the mean. It lets you compare values from completely different normal distributions on the same scale.

What z-scores mean

Section 08

Interactive Z-Score Calculator

Enter any value, mean, and standard deviation to instantly calculate the z-score and see what percentile it corresponds to.

Section 09

Real-World Examples

The normal distribution appears across almost every domain of science, engineering, and everyday life.

Section 10

When Data is NOT Normally Distributed

Not everything is a bell curve. Recognising when data isn’t normal is just as important as knowing when it is.

Section 11

Python Code

Plotting a bell curve

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm

mu, sigma = 175, 7   # UK male heights: mean=175cm, std=7cm

x = np.linspace(mu - 4*sigma, mu + 4*sigma, 300)
y = norm.pdf(x, mu, sigma)

plt.figure(figsize=(10, 5))
plt.plot(x, y, color='#6366f1', linewidth=2.5)

# Shade the 1σ, 2σ, 3σ regions
for n, color, label in [(1,'#10b981','68%'),(2,'#f59e0b','95%'),(3,'#ef4444','99.7%')]:
    mask = (x >= mu - n*sigma) & (x <= mu + n*sigma)
    plt.fill_between(x, y, where=mask, alpha=0.2, color=color, label=f'{label} within {n}σ')

plt.title('Normal Distribution of UK Male Heights')
plt.xlabel('Height (cm)')
plt.ylabel('Probability Density')
plt.legend()
plt.tight_layout()
plt.show()

Z-scores and probabilities

from scipy.stats import norm

mu, sigma = 175, 7
x = 185

# Z-score
z = (x - mu) / sigma
print(f"Z-score: {z:.2f}")           # → 1.43

# Probability of being BELOW this height
p_below = norm.cdf(x, mu, sigma)
print(f"P(height < 185): {p_below:.1%}")  # → 92.4%

# Probability of being ABOVE this height
p_above = 1 - p_below
print(f"P(height > 185): {p_above:.1%}")  # → 7.6%

# Probability of being BETWEEN two values
p_between = norm.cdf(182, mu, sigma) - norm.cdf(168, mu, sigma)
print(f"P(168 < height < 182): {p_between:.1%}")  # → 68.3%

# What height is at the 90th percentile?
p90 = norm.ppf(0.90, mu, sigma)
print(f"90th percentile height: {p90:.1f} cm")  # → 184.0 cm

Testing if data is normally distributed

from scipy.stats import shapiro, normaltest
import numpy as np

data = np.random.normal(loc=175, scale=7, size=100)

# Shapiro-Wilk test (best for n < 5000)
stat, p = shapiro(data)
print(f"Shapiro-Wilk: stat={stat:.3f}, p={p:.3f}")
# If p > 0.05 → fail to reject normality (data is likely normal)

# D'Agostino K² test
stat2, p2 = normaltest(data)
print(f"Normaltest:   stat={stat2:.3f}, p={p2:.3f}")

# Quick visual check
import scipy.stats as stats
import matplotlib.pyplot as plt
stats.probplot(data, dist="norm", plot=plt)
plt.title("Q-Q Plot — points on the line = normal")
plt.show()

Section 12

Knowledge Quiz

Six questions to test your understanding of the normal distribution.

Section 01

The Problem Binary Search Solves

Imagine you have a sorted list of 1,000,000 numbers and you need to find whether the number 742,891 is in it. The naive approach — checking every single element one by one — would take up to a million comparisons in the worst case.

Binary search solves this in at most 20 comparisons. Not 20,000. Not 2,000. Twenty. That’s the power of dividing the problem in half at every step.

Section 02

The Phone Book Intuition

You’ve already used binary search in real life. When you look up a name in a phone book (or a word in a dictionary), you don’t start from page 1 and flip forward.

You open to the middle. If the name you want comes alphabetically before the middle page, you throw away the right half and repeat on the left. If it comes after, you throw away the left half and repeat on the right. Each time, you eliminate half the remaining possibilities.

Section 03

How It Works — Step by Step

Binary search uses three pointers on the array: low, mid, and high. Here’s the algorithm:

Section 04

Live Visualizer — Try It Yourself

Enter any number between 1 and 99 and watch binary search find it step by step. The yellow cell is the current midpoint being checked, grey cells are eliminated, and green means found.

Section 05

Code in Python, JavaScript & Java

Python

def binary_search(arr, target):
    low, high = 0, len(arr) - 1

    while low <= high:
        mid = low + (high - low) // 2  # safe from integer overflow

        if arr[mid] == target:
            return mid              # found! return the index
        elif arr[mid] < target:
            low = mid + 1           # target is in right half
        else:
            high = mid - 1          # target is in left half

    return -1                       # not found


# Example usage
numbers = [2, 7, 13, 19, 25, 34, 37, 46, 58, 72]
result = binary_search(numbers, 37)
print(f"Found at index: {result}")  # → Found at index: 6
print(binary_search(numbers, 99))   # → -1 (not found)

JavaScript

function binarySearch(arr, target) {
  let low = 0;
  let high = arr.length - 1;

  while (low <= high) {
    const mid = low + Math.floor((high - low) / 2);

    if (arr[mid] === target)  return mid;      // found
    if (arr[mid] < target)   low = mid + 1;   // search right
    else                       high = mid - 1;  // search left
  }

  return -1; // not found
}

// Example
const nums = [2, 7, 13, 19, 25, 34, 37, 46, 58, 72];
console.log(binarySearch(nums, 37));  // 6
console.log(binarySearch(nums, 99));  // -1

Java

public class BinarySearch {

    public static int binarySearch(int[] arr, int target) {
        int low = 0;
        int high = arr.length - 1;

        while (low <= high) {
            int mid = low + (high - low) / 2; // avoids overflow

            if (arr[mid] == target)  return mid;
            if (arr[mid] <  target)  low  = mid + 1;
            else                       high = mid - 1;
        }

        return -1; // not found
    }

    public static void main(String[] args) {
        int[] nums = {2, 7, 13, 19, 25, 34, 37, 46, 58, 72};
        System.out.println(binarySearch(nums, 37)); // 6
        System.out.println(binarySearch(nums, 99)); // -1
    }
}

Section 06

Time & Space Complexity

Binary search is one of the most efficient search algorithms. Its performance is measured using Big O notation.

Section 07

Binary vs Linear Search — The Speed Race

Drag the slider to set the array size and watch how many steps each algorithm needs. The difference becomes dramatic very quickly.

Section 08

The One Rule You Must Not Break

Binary search requires a sorted array. This is non-negotiable. Here’s why: when the algorithm looks at the midpoint and finds the target is smaller, it assumes everything to the right is also larger. In an unsorted array, that assumption is false — and the algorithm silently gives wrong answers.

# ❌ WRONG — unsorted array
unsorted = [37, 2, 72, 13, 25]
binary_search(unsorted, 2)   # returns -1 even though 2 is there!

# ✅ CORRECT — sort first
sorted_arr = sorted(unsorted)  # [2, 13, 25, 37, 72]
binary_search(sorted_arr, 2)  # returns 0 ✓

# Tip: Python has bisect module built-in for production use
import bisect
idx = bisect.bisect_left(sorted_arr, 2)
print(sorted_arr[idx] == 2)    # True

Section 09

Where Binary Search Is Used in Real Life

Binary search isn’t just a textbook exercise. It runs inside software you use every day.

Section 10

Knowledge Quiz

Five questions to lock in what you’ve learned.