Probability basics

Rule 3: independence (the "and" rule)

Two events are independent if one happening doesn't change the chance of the other. Flip a coin and roll a die. Getting heads tells you nothing about the die.

For independent events, and only then, the chance that both happen is the two chances multiplied:

In plain words: if two things don't affect each other, the chance of both is one chance times the other. The dot $\cdot$ means "times".

A worked example: heads has probability 0.5. A six has probability 1/6, about 0.167. So heads and a six together has probability 0.5 × 1/6 = 1/12. That's about 0.083, or 1 time in 12.

p_heads = 0.5
p_six = 1 / 6
print(round(p_heads * p_six, 3))

It prints 0.083.

Independence is an assumption, so always ask whether it makes sense. Two different customers opening the same newsletter are roughly independent. One customer opening and the same customer clicking are not. You can't click a link in an email you never opened. Events that depend on each other are the topic of the next lesson.

"At least one"

Here's a question that comes up all the time. You have 5 leads. Each one converts with probability 0.1, and they don't affect each other. What's the chance that at least one converts?

The direct route is painful. You'd add up "exactly one converts", "exactly two", and so on up to five. The complement is much easier. "At least one converts" has a single opposite: "none converts".

1. Each lead fails with probability 1 − 0.1 = 0.9 (rule 1).
2. All five fail with probability 0.9 × 0.9 × 0.9 × 0.9 × 0.9, about 0.59 (rule 3).
3. So at least one converts with probability 1 − 0.59, about 0.41 (rule 1 again).

To write this as a formula, call the chance that one try succeeds $p$. Call the number of tries $n$.

In plain words: work out the chance that every try fails, then take that away from 1. The small raised $n$ means "multiply $(1 - p)$ by itself $n$ times". The wavy equals sign $\approx$ means "is about".

In Python, ** means "to the power of":

p = 0.1   # chance one lead converts
n = 5     # number of leads
print(round(1 - (1 - p) ** n, 2))

It prints 0.41.

Notice that 5 tries at 20% each don't add up to a sure thing. The chance of at least one success is 1 − 0.8⁵, about 0.67, not 100%.

The same formula explains why small error rates pile up. An AI agent that makes 20 tool calls, each with a 2% chance of going wrong, fails somewhere about a third of the time.

print(round(1 - 0.5 ** 3, 3))

Check it by simulation

Probability mistakes are easy to make and hard to spot. Here's a habit that catches many of them. Use random numbers to run the experiment thousands of times, then count what happened. If the share you count matches the formula, the formula (and your understanding) is right.

The trick works for any yes/no event. rng.random() gives a number anywhere between 0 and 1, with every value equally likely. Think of a spinner that can stop anywhere on a ruler from 0 to

1. It stops below 0.1 about 10% of the time. So "the number is below 0.1" behaves like a lead

that converts with probability 0.1.

The code below plays out 100,000 rounds of the 5-leads question. Each round is one row of 5 random numbers.

import numpy as np

rng = np.random.default_rng(42)
trials = 100_000
converted = rng.random((trials, 5)) < 0.1        # 5 leads per trial, each converts with p = 0.1
at_least_one = converted.any(axis=1)
print("simulated:", at_least_one.mean().round(4))
print("formula:  ", round(1 - 0.9 ** 5, 4))

Here's what each step did:

• np.random.default_rng(42) makes a random number generator. The 42 is a seed. It fixes the starting point, so you get the same "random" numbers on every run.
• rng.random((trials, 5)) < 0.1 builds a table with 100,000 rows and 5 columns. Each cell is True where that lead converted.
• .any(axis=1) asks of each row: is at least one cell True?
• .mean() of True/False values gives the share that are True, because True counts as 1 and False as 0.

The simulated share and the formula agree closely. Both are about 0.41.

Now the addition rule, with 10,000 email recipients. Each one opens with probability 0.30. Each one reads on mobile with probability 0.60. The two are drawn separately, so they are independent here.

import numpy as np

rng = np.random.default_rng(0)
opened = rng.random(10_000) < 0.30
on_mobile = rng.random(10_000) < 0.60                 # independent of opening here
either = opened | on_mobile
both = opened & on_mobile
print("P(open or mobile) simulated:", either.mean().round(3))
print("formula: 0.30 + 0.60 - 0.30 × 0.60 =", round(0.30 + 0.60 - 0.30 * 0.60, 3))
print("P(both):", both.mean().round(3))

In NumPy, | means "or" and & means "and", checked for each recipient. The formula line uses two rules at once. The overlap comes from rule 3: the events are independent, so the chance of both is 0.30 × 0.60 = 0.18. Then rule 2 gives 0.30 + 0.60 − 0.18 = 0.72.

The simulated "or" lands close to 0.72, and the simulated "both" lands close to 0.18. They won't match exactly. Random samples always wobble a little, and more trials make the wobble smaller.

p = 0.3   # chance one friend replies
n = 4     # number of friends
none = (1 - p) ** n
print("nobody replies:", round(none, 4))
print("at least one:  ", round(1 - none, 4))
print("all four reply:", round(p ** n, 4))