Why 1 + 1 is not always 2

In the previous lesson, we saw why the wave collapses. Now, let's look at the Math that predicts where it collapses.

In classical probability, if you flip two coins, the probability of getting "Heads, Heads" is $0.5 \times 0.5 = 0.25$. The probabilities always multiply and add up to 100%.

In Quantum probability, we don't work with "Probabilities" directly. We work with Amplitudes.

---

1. The Square of the Amplitude (The Born Rule)

As we've mentioned before, the state of a Qubit is: $$|\psi\rangle = \alpha|0\rangle + \beta|1\rangle$$

But here is the weird part: $\alpha$ and $\beta$ aren't probabilities. To get the probability, you must Square them.

• If $\alpha = 0.7$, the probability of 0 is $0.7^2 = 0.49$ (49%).
• If $\beta = 0.3$, the probability of 1 is $0.3^2 = 0.09$ (Wait, $0.49 + 0.09$ isn't 1... we need to adjust our amplitudes!)

The normalization constraint: $|\alpha|^2 + |\beta|^2 = 1.0$.

---

2. Why "Squaring" Matters (Interference)

Why do we bother with "Amplitudes" if we just want probabilities? Because Amplitudes can be Negative.

• Path A Amplitude: $+0.5$
• Path B Amplitude: $-0.5$
• Total Amplitude: $0.5 + (-0.5) = 0$.
• Total Probability: $0^2 = 0$.

If these were "Normal" probabilities ($0.25$ and $0.25$), you would add them and get $0.5$ (50%). In Quantum, because the amplitudes are "Waves," they can Cancel each other out. This is why we can design algorithms that effectively "Delete" certain realities.

graph TD
    subgraph Classical_Stats
    A[Path 1: 50%] --- B[Path 2: 50%]
    B --- C[Result: 100%]
    end
    
    subgraph Quantum_Amplitudes
    D[Path 1: +0.7 Amplitude] --- E[Path 2: -0.7 Amplitude]
    E --- F[Result: 0 Amplitude / 0% Probability]
    end

---

3. The "Phase" Circle

You can visualize the amplitude as an Arrow on a clock.

• A positive amplitude is an arrow pointing UP.
• A negative amplitude is an arrow pointing DOWN.
• Measurement just looks at the Length of the arrow.

If two arrows point opposite ways and you "Add" them, you get zero length. This is "Destructive Interference." If they point the same way, you get "Constructive Interference."

---

4. Summary: Managing the Odds

Quantum computing is the business of Amplitude Engineering. Your job as a quantum programmer is to move the "Arrows" around so that for the answer you want, all the arrows point the same way (Constructive), and for the answers you don't want, the arrows point in opposite directions (Destructive).

---

Exercise: The "Born" Calculator

1. The State: $|\psi\rangle = (1/\sqrt2)|0\rangle + (1/\sqrt2)|1\rangle$.
2. The Calc:
   • Square of $1/\sqrt2 = 1/2$.
   • Probability of 0 = 0.5.
   • Probability of 1 = 0.5.
3. The Challenge: $|\psi\rangle = (0.8 + 0.6i)|0\rangle$. (Ignore the 'i' for now, just square the 0.8 and 0.6).
4. Reflect: As we change the coefficients, we are "Weighting" the reality of the future.

Conceptual Code (The 'Amplitude' Logic):

import numpy as np

def calculate_probabilities(amplitudes):
    # Sum of squares must be 1.0
    probs = np.abs(amplitudes)**2
    
    if not np.isclose(np.sum(probs), 1.0):
        print("⚠️ Warning: Non-normalized state!")
        
    return probs

# Perfect 50/50 state
h_amplitudes = np.array([1/np.sqrt(2), 1/np.sqrt(2)])
print(f"H-Gate Probabilities: {calculate_probabilities(h_amplitudes)}")

# Negative interference state
# (Notice how amplitude is negative but probability is positive)
neg_amplitudes = np.array([0.707, -0.707])
print(f"Neg Amplitude Prob: {calculate_probabilities(neg_amplitudes)}")

Reflect: Is your strategy relying on "Adding up small wins" (Classical) or "Canceling out big risks" (Quantum)?