DEV Community: Malcolm Low

Quantum Teleportation, and Why It Isn't Cloning

Malcolm Low — Wed, 24 Jun 2026 11:04:09 +0000

Part of the Techucation Quantum Series.

Teleportation is the most over-sold word in quantum computing. It conjures Star Trek transporters and faster-than-light messaging, and almost every popular account quietly implies you end up with a copy of the original. You do not. Quantum teleportation moves an unknown quantum state from one qubit to another while destroying the original, and that destruction is not an incidental detail. It is the mechanism that keeps the protocol on the right side of the no-cloning theorem.

A quick word on no-cloning

This whole protocol is haunted by the no-cloning theorem: there is no operation that copies an arbitrary unknown quantum state. I worked through the proof and its consequences in a recent post, The No-Cloning Theorem in Quantum Computing: Why You Can't Copy a Qubit, so I won't re-derive it here.

The single fact we need: you cannot deterministically duplicate an unknown qubit. The qualifiers matter, because teleportation lives in the gaps between them. The theorem forbids copying unknown states (a known state you can re-prepare at will), it forbids deterministic, perfect copies, and it is a statement about unitary operations — and measurement, which teleportation leans on at the decisive moment, is not unitary.

Why teleportation isn't cloning

The distinction in one sentence: cloning would leave |ψ⟩ in two places; teleportation leaves it in exactly one.

Partway through the protocol, Alice's message qubit is measured. Measurement collapses it into a classical basis state — a plain |0⟩ or |1⟩ carrying none of the original amplitudes. By the time Bob's qubit holds |ψ⟩, Alice's qubit demonstrably does not. The state was relocated, and the accounting is exact: one copy in, one copy out. No moment ever exists where two qubits both carry |ψ⟩, so there is nothing for the no-cloning theorem to object to.

This also kills the faster-than-light fantasy. The protocol forces Alice to send Bob two ordinary classical bits. Until they arrive, Bob's qubit is information-free — we will see that fall out of the algebra below.

The complete circuit

Read it left to right; the protocol splits into three stages. The message qubit q0 starts in the unknown state |ψ⟩, while q1 and q2 both start in |0⟩. In the diagram, * marks a control and (+) a CNOT target.

Stage 1 — Bell pair. Alice and Bob share an entangled pair: an H on q1 followed by a CNOT from q1 onto q2 prepares (|00⟩ + |11⟩)/√2 across the two halves.

Stage 2 — Alice measures. Alice folds her message into the pair (a CNOT from q0 onto q1, then an H on q0) and measures both of her qubits, collapsing them to two classical bits.

Stage 3 — Bob corrects. Depending on those two bits, Bob applies an X and/or a Z to q2 — the X controlled by Alice's q1 bit, the Z by her q0 bit — and q2 emerges as |ψ⟩.

The protocol in bra-ket and tensor form

Three qubits: q0 carries |ψ⟩ = α|0⟩ + β|1⟩, q1 is Alice's half of the Bell pair, and q2 is Bob's half. They pre-share |Φ+⟩ = (|00⟩ + |11⟩)/√2 on q1 q2.

Step 1 — the starting state. Tensor the message against the Bell pair:

|ψ⟩ = α|0⟩ + β|1⟩            (the unknown message on q0)

|ψ⟩ ⊗ |Φ+⟩ = (α|0⟩ + β|1⟩) ⊗ (|00⟩ + |11⟩)/√2
           = (1/√2) [ α|000⟩ + α|011⟩ + β|100⟩ + β|111⟩ ]

Step 2 — Alice's CNOT (control q0, target q1):

CNOT (control q0, target q1)  flips q1 wherever q0 = 1:

= (1/√2) [ α|000⟩ + α|011⟩ + β|110⟩ + β|101⟩ ]

Step 3 — Alice's Hadamard on q0. Substitute |0⟩ → (|0⟩+|1⟩)/√2 and |1⟩ → (|0⟩−|1⟩)/√2, then collect by the value of (q0 q1):

H on q0, then collect by the pair Alice will measure (q0 q1):

= (1/2) [ |00⟩ (α|0⟩ + β|1⟩)    ← case A
        + |01⟩ (α|1⟩ + β|0⟩)    ← case B
        + |10⟩ (α|0⟩ − β|1⟩)    ← case C
        + |11⟩ (α|1⟩ − β|0⟩) ]  ← case D

Each bracketed q2 state is the original |ψ⟩ acted on by a known Pauli. Alice measures, gets one of four outcomes (each with probability 1/4), sends the two bits to Bob, and Bob undoes the Pauli. The Case column ties each row back to the matching line in Step 3:

 Case | Alice measures (q0 q1) | Bob holds on q2 | Relation to |ψ⟩ | Bob applies 
------+------------------------+-----------------+-----------------+-------------
 A    | 00                     | α|0⟩ + β|1⟩     | I |ψ⟩           | nothing     
 B    | 01                     | α|1⟩ + β|0⟩     | X |ψ⟩           | X           
 C    | 10                     | α|0⟩ − β|1⟩     | Z |ψ⟩           | Z           
 D    | 11                     | α|1⟩ − β|0⟩     | ZX |ψ⟩          | X then Z

Bob applies Z^m0 X^m1 — an X if m1 = 1, then a Z if m0 = 1 — and every branch lands back on α|0⟩ + β|1⟩ = |ψ⟩.

Qiskit — classical feed-forward

This version measures mid-circuit and uses real classical conditioning via if_test. The verification trick: rather than read out Bob's state, apply the inverse of the preparation to q2. If teleportation worked, that must collapse q2 to |0⟩ on every shot.

import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, transpile
from qiskit.circuit.library import StatePreparation
from qiskit.quantum_info import random_statevector
from qiskit_aer import AerSimulator

# Unknown state to teleport (StatePreparation is unitary -> invertible)
psi  = random_statevector(2)
prep = StatePreparation(psi)

q   = QuantumRegister(3, "q")     # q0 message, q1 Alice, q2 Bob
mz  = ClassicalRegister(1, "mz")  # q0 result -> drives Z
mx  = ClassicalRegister(1, "mx")  # q1 result -> drives X
out = ClassicalRegister(1, "out") # verification bit
qc  = QuantumCircuit(q, mz, mx, out)

qc.append(prep, [0]); qc.barrier()        # 1. load |ψ⟩ onto q0
qc.h(1); qc.cx(1, 2); qc.barrier()        # 2. Bell pair on (q1,q2)
qc.cx(0, 1); qc.h(0)                      # 3. Alice's basis change
qc.measure(0, mz); qc.measure(1, mx); qc.barrier()

with qc.if_test((mx, 1)):                 # 4. Bob's corrections
    qc.x(2)
with qc.if_test((mz, 1)):
    qc.z(2)
qc.barrier()

qc.append(prep.inverse(), [2])            # 5. un-prepare on Bob: must read 0
qc.measure(2, out)

counts = AerSimulator().run(transpile(qc, AerSimulator()), shots=4000).result().get_counts()
clean  = all(k.split()[0] == "0" for k in counts)   # leftmost bit = out
print(counts); print("Teleportation verified:", clean)

The out bit comes back 0 on 100% of shots regardless of the random (mx, mz) branch — exactly the claim that Bob reconstructs |ψ⟩ in every case.

No faster-than-light, and the takeaway

Before Bob learns (m0, m1), his qubit is an equal mixture of the four branch states. Averaging the four projectors gives the Pauli twirl:

ρ_Bob = (1/4)( |ψ⟩⟨ψ| + X|ψ⟩⟨ψ|X
              + Z|ψ⟩⟨ψ|Z + XZ|ψ⟩⟨ψ|ZX )  =  I/2   for every |ψ⟩

for any |ψ⟩. Bob's local state is identical no matter what Alice sent, so no information has reached him yet. The classical bits are not a formality — they are the only thing that carries the state across, and they travel no faster than light.

Takeaway. No-cloning forbids duplicating an unknown qubit (proof here). Teleportation never attempts a copy: it entangles the message with a shared Bell pair, measures the original out of existence, and ships two classical bits naming which of four Pauli corrections rebuilds the state on the other end. Exactly one copy before, exactly one after. No-cloning is not a bug the protocol works around — it is the reason the protocol has to look the way it does.

Originally published at malcolmlow.com. Built with Qiskit. This article was written with the assistance of Claude by Anthropic.

Move Your WordPress.com Domain to Cloudflare and Halve the Renewal

Malcolm Low — Thu, 11 Jun 2026 04:33:59 +0000

This post was originally published on Techucation, my blog at malcolmlow.com. Cross-posted here for the dev.to community.

My WordPress.com domain renewal notice came in at £16/year, with auto-renew switched off and the expiry only a couple of days away. That is a fine price for convenience, but the same name sits on Cloudflare Registrar at wholesale cost with no markup. This post walks through the move end to end, including the one step that quietly breaks things if you rush it, and lays out the real cost difference.

The short version: you do not "renew at Cloudflare". You transfer the domain to Cloudflare, which extends the registration by a year in the process. The saving is real, but the order of operations matters.

1. The cost case

Cloudflare Registrar charges exactly what the registry charges them, with zero markup, and bundles WHOIS privacy for free. Retail registrars add a margin on top. For a .net the difference looks like this:

Item	WordPress.com	Cloudflare Registrar
.net renewal (1 yr)	£16 (approx US$20)	approx US$10.44 (at cost)
Markup	Retail margin	None (wholesale pass-through)
WHOIS privacy	Included	Included, free
Approx 5-year cost	approx US$100	approx US$52

Figures are indicative for mid-2026. Because Cloudflare is at cost, your renewal tracks the registry wholesale rate, so it moves up if the registry (Verisign for .net) raises prices. The trade-off: Cloudflare requires the domain to run on Cloudflare DNS.

2. The gotcha: transfer, not renew, and DNS moves first

Two things trip people up:

You cannot renew a domain at a registrar where it is not registered. To get Cloudflare pricing you transfer the domain in. A gTLD transfer (.com, .net, .org) automatically adds one year, so it replaces the renewal rather than stacking on top of it.

Cloudflare will not let you transfer the registration until the domain is already running on Cloudflare DNS. So the real sequence is DNS first, registrar second, with any redirect rebuilt in the middle so the site never goes dark.

Mind the expiry window. Do not start this within a few days of expiry and then walk away. A transfer left to auto-complete can take up to 5 days. If you are close to the date, expedite it (see step 6) rather than waiting out the clock.

3. Step by step

The full order of operations:

1  Unlock the domain at WordPress.com, get the EPP / auth code
2  Add the domain as a Free zone in Cloudflare
3  Stage the redirect in Cloudflare (before flipping nameservers)
4  Change nameservers at WordPress.com to Cloudflare's pair
5  Wait for the Cloudflare zone to go Active
6  Initiate the transfer in Cloudflare, paste the EPP code, pay
7  Approve / expedite the transfer on the WordPress.com side
8  Verify: registrar, new expiry, redirect, DNSSEC

Step 1. In WordPress.com under Upgrades > Domains, open the domain, turn off Transfer lock, then start the transfer-out flow far enough to reveal the EPP / auth code. Copy it. Do not let WordPress walk you all the way through its own wizard, you only want the code.

Step 2. In the Cloudflare dashboard, Add a domain, choose the Free plan. Cloudflare scans existing DNS and assigns you two nameservers like name.ns.cloudflare.com. Note them.

Step 3. If the domain is a redirect (common when it just points at another site of yours), rebuild that redirect in Cloudflare now while it sits idle. See section 4.

Step 4. Back at WordPress.com, switch the nameservers from WordPress to the two Cloudflare nameservers.

Step 5. Cloudflare flips the zone to Active once it sees the nameserver change, usually under an hour. The transfer option stays greyed out until then.

Step 6. Once Active, go to Domain Registration > Transfer Domains, select the domain, paste the EPP code, and pay the at-cost fee. This payment includes the added year.

Step 7. Watch for the confirmation from the losing registrar. WordPress.com surfaces a Transfer Management page with an Accept Transfer button. Clicking it skips the 5-day wait and completes the transfer in minutes.

Done: the registry should now show the registrar as Cloudflare, status Active, and the expiry rolled forward by a year.

4. The redirect-only trap

If your domain only exists to redirect to another site, the imported records (the host's A records and a couple of CNAMEs) become redundant once you build a Cloudflare Redirect Rule. Tempting to delete them all for a tidy zone. Here is the trap:

A Cloudflare Redirect Rule only fires on traffic that reaches Cloudflare's edge. Traffic only reaches the edge if the hostname resolves to a proxied record (orange cloud). Delete every record and the name resolves to nothing, so the redirect goes dark.

The fix is to keep one proxied placeholder for the rule to attach to:

Type	Name	Value	Proxy
A	@	192.0.2.1	Proxied
CNAME	www	@	Proxied (only if you want www)
TXT	@	"google-site-verification=..."	DNS only

192.0.2.1 is a reserved TEST-NET address that never routes anywhere, which is exactly what you want: the proxy intercepts the request before that IP is ever used. Then a single Redirect Rule (Rules > Redirect Rules) handles the rest:

Field	Setting
When (match)	hostname ends with example.net
Then (action)	301 to https://example.com + path
Preserve query string	On

Keep the TXT verification record as DNS only. It does not need to resolve to anything, it just needs to exist.

5. After the transfer

Three things to settle once the registrar shows Cloudflare:

Auto-renew. Optional, but turning it on (Domain Registration > your domain) means you never repeat the two-days-from-expiry scramble. If you leave it off, set yourself a reminder a few weeks before the date.

DNSSEC. Worth enabling for the added integrity protection. Because Cloudflare is now both your DNS and your registrar, the DS record is published to the registry automatically, so it activates without you touching the registrar by hand. Give it from a few minutes up to a couple of hours to show as signed at the registry.

Registrar lock. On by default at Cloudflare, so that one is already handled.

One caution with DNSSEC: once the DS record is published, do not move nameservers away from Cloudflare or disable DNSSEC out of order. Breaking the signature chain is the classic way to make a domain go dark, because validating resolvers will reject it. As long as DNS stays on Cloudflare, you are fine.

Net result

Same domain, half the renewal cost, a year added, and the registrar consolidated with your DNS. The only part that needs care is the DNS-first ordering and not over-deleting the redirect records. Everything else is a few clicks and a short wait.

Deutsch Algorithm Revisited: Quantum vs Classical Implementation in Qiskit

Malcolm Low — Sun, 07 Jun 2026 10:12:11 +0000

In the previous post on the Deutsch algorithm, we covered the theory. Here we implement both the classical and quantum approaches in Qiskit so the quantum advantage is visible in working code: the same problem solved with fewer oracle queries than any classical method can manage.

The Challenge

Given a black-box function f: {0,1} → {0,1}, determine whether it is:

Constant: f(0) = f(1) (always returns 0, or always returns 1)
Balanced: f(0) ≠ f(1) (returns 0 for one input, 1 for the other)

The whole question is how many times you must query the function:

Approach	Queries required
Classical	2
Quantum	1

Complete Qiskit Implementation

Oracle functions

First, build the oracle functions representing all possible single-bit Boolean functions:

from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit_aer import AerSimulator

def create_constant_oracle(constant_value):
    """Creates a constant oracle (returns 0 or 1 for all inputs)"""
    oracle = QuantumCircuit(2, name=f"Constant_{constant_value}")
    if constant_value == 1:
        oracle.x(1)  # Flip the output qubit
    return oracle

def create_balanced_oracle(balance_type):
    """Creates a balanced oracle"""
    oracle = QuantumCircuit(2, name=f"Balanced_{balance_type}")
    if balance_type == 'identity':
        # f(x) = x
        oracle.cx(0, 1)
    elif balance_type == 'negation':
        # f(x) = NOT x
        oracle.x(0)
        oracle.cx(0, 1)
        oracle.x(0)
    return oracle

Classical approach: two queries required

The classical algorithm must query the oracle twice, once for f(0) and once for f(1):

def classical_deutsch_query1(oracle):
    """First query: Evaluate f(0)"""
    qr = QuantumRegister(2, 'q')
    cr = ClassicalRegister(1, 'c')
    qc = QuantumCircuit(qr, cr)

    # Input: x = 0 (already initialized to |0>)
    qc.barrier()
    qc.compose(oracle, inplace=True)
    qc.barrier()
    qc.measure(1, 0)  # Measure output to get f(0)

    return qc

def classical_deutsch_query2(oracle):
    """Second query: Evaluate f(1)"""
    qr = QuantumRegister(2, 'q')
    cr = ClassicalRegister(1, 'c')
    qc = QuantumCircuit(qr, cr)

    qc.x(0)  # Input: x = 1
    qc.barrier()
    qc.compose(oracle, inplace=True)
    qc.barrier()
    qc.measure(1, 0)  # Measure output to get f(1)

    return qc

Quantum approach: one query suffices

The quantum Deutsch algorithm uses superposition and interference to answer with a single oracle query:

def deutsch_algorithm(oracle):
    """Implements the Deutsch algorithm - requires only ONE query"""
    qr = QuantumRegister(2, 'q')
    cr = ClassicalRegister(1, 'c')
    qc = QuantumCircuit(qr, cr)

    # Step 1: Initialize q[1] to |1>
    qc.x(1)
    qc.barrier()

    # Step 2: Apply Hadamard gates (create superposition)
    qc.h(0)
    qc.h(1)
    qc.barrier()

    # Step 3: Apply the oracle (SINGLE QUERY!)
    qc.compose(oracle, inplace=True)
    qc.barrier()

    # Step 4: Apply Hadamard to input qubit
    qc.h(0)
    qc.barrier()

    # Step 5: Measure
    qc.measure(0, 0)

    return qc

Running the comparison

Now test all four possible oracles with both approaches:

oracles = [
    ("Constant 0", create_constant_oracle(0)),
    ("Constant 1", create_constant_oracle(1)),
    ("Balanced (Identity)", create_balanced_oracle('identity')),
    ("Balanced (Negation)", create_balanced_oracle('negation'))
]

simulator = AerSimulator()

for name, oracle in oracles:
    # Classical: 2 queries
    qc1 = classical_deutsch_query1(oracle)
    result1 = simulator.run(qc1, shots=1).result()
    f_0 = int(list(result1.get_counts().keys())[0])

    qc2 = classical_deutsch_query2(oracle)
    result2 = simulator.run(qc2, shots=1).result()
    f_1 = int(list(result2.get_counts().keys())[0])

    classical_result = "CONSTANT" if f_0 == f_1 else "BALANCED"

    # Quantum: 1 query
    qc_quantum = deutsch_algorithm(oracle)
    result_quantum = simulator.run(qc_quantum, shots=1000).result()
    counts = result_quantum.get_counts()

    quantum_result = "CONSTANT" if '0' in counts else "BALANCED"

    print(f"{name}: Classical={classical_result}, Quantum={quantum_result}")

Circuit Diagrams

The full figures are rendered in the original post; the structure of each is:

Classical Query 1, f(0): q[0] stays in |0⟩, the oracle processes the input, and q[1] is measured to read f(0).
Classical Query 2, f(1): an X gate flips q[0] to |1⟩, the oracle processes it, and q[1] is measured to read f(1).
Quantum Deutsch (single query): initialise |01⟩, Hadamards on both wires create superposition, a single oracle query, a final Hadamard on q[0], then measure q[0].

The key structural difference: the classical circuits measure the output qubit q[1] to read function values, while the quantum circuit measures the input qubit q[0] after interference. That is what lets a single query reveal a global property of the function.

Sample Output

======================================================================
Testing: Constant 0 Oracle
======================================================================

[CLASSICAL APPROACH - Requires 2 queries]
  Query 1: f(0) = 0
  Query 2: f(1) = 0
  Result: Function is CONSTANT
  Total queries needed: 2

[QUANTUM APPROACH - Requires only 1 query]
  Measurement results: {'0': 1000}
  Result: Function is CONSTANT
  Total queries needed: 1

  Both methods agree: True

======================================================================
Testing: Balanced (Identity) Oracle
======================================================================

[CLASSICAL APPROACH - Requires 2 queries]
  Query 1: f(0) = 0
  Query 2: f(1) = 1
  Result: Function is BALANCED
  Total queries needed: 2

[QUANTUM APPROACH - Requires only 1 query]
  Measurement results: {'1': 1000}
  Result: Function is BALANCED
  Total queries needed: 1

  Both methods agree: True

Understanding the Quantum Advantage

Classical approach: evaluate f(0), evaluate f(1), compare the two results. Two queries required; you must check both inputs individually.

Quantum approach: query with a superposition of both inputs, use interference to extract the global property, then measure. One query required; it exploits quantum parallelism.

The quantum algorithm queries the oracle with a superposition of both inputs simultaneously (|0⟩ + |1⟩), then uses interference to extract a global property of the function without evaluating it on individual inputs. The single measurement directly tells you whether the function is constant or balanced.

Measurement Interpretation

Measurement	Function type	Explanation
\|0⟩	Constant	Constructive interference, f(0) ⊕ f(1) = 0
\|1⟩	Balanced	Destructive interference, f(0) ⊕ f(1) = 1

Running the Code

Install Qiskit and Aer:

pip install qiskit qiskit-aer

Then run the comparison script; it outputs the result for all four oracle types.

Conclusion

This implementation shows the Deutsch advantage concretely: a 2x reduction in oracle queries (from 2 to 1), the first algorithm to demonstrate quantum advantage over classical, and a foundational technique introducing superposition, interference, and phase kickback. The speedup is modest for this toy problem, but the same idea (query with superposition, extract a global property through interference) scales up to Deutsch-Jozsa, Simon's algorithm, and Shor's factoring.

Part of the Quantum Series 2026. Originally published on Techucation.

Deutsch's Algorithm in Quantum Computing: The 4 Cases

Malcolm Low — Sun, 07 Jun 2026 10:11:35 +0000

Deutsch's Algorithm determines whether a function f(x) is constant or balanced using only a single query. Before getting to the quantum circuit, it helps to see how the four possible single-bit functions are physically built.

The 4 Possible Functions

With one input bit, there are exactly four Boolean functions. Two are constant (the output ignores the input) and two are balanced (the output depends on the input). In each oracle the bottom input is set to 0 so the output wire carries exactly f(x).

#	Name	Function	Type
1	Constant Zero	f(x) = 0	Constant (identity, no gates)
2	Constant One	f(x) = 1	Constant (X on the output wire)
3	Balanced ID	f(x) = x	Balanced (CNOT)
4	Balanced NOT	f(x) = ¬x	Balanced (X, CNOT, X)

The General Oracle (U_f)

Every oracle is wrapped in the standard reversible form. It leaves the input register alone and XORs f(x) into the output register:

U_f |x⟩|y⟩  =  |x⟩ |y ⊕ f(x)⟩

The Complete Circuit

To detect the function type in one shot, initialise the bottom wire to |1⟩ and use Hadamard gates to build superposition on both wires before and after the oracle:

|0⟩ ──[H]──╤═════╤──[H]──[M]
           │ U_f │
|1⟩ ──[H]──╧═════╧───────────

The top wire is the control, the bottom wire is the target prepared in |−⟩. The oracle's (−1)^f(x) phase is kicked back onto the top wire, and the final Hadamard converts that phase difference into a measurable 0 or 1.

Mathematical Proof

1. Initialisation:   |ψ₀⟩ = |0⟩|1⟩

2. Superposition:    |ψ₁⟩ = |+⟩|−⟩ = ½(|0⟩ + |1⟩)(|0⟩ − |1⟩)

3. The kickback:     U_f |x⟩|−⟩ = (−1)^f(x) |x⟩|−⟩
                     the function output is pushed into the phase of the top qubit.

4. Global state:     |ψ₂⟩ = (1/√2) [ (−1)^f(0)|0⟩ + (−1)^f(1)|1⟩ ] ⊗ |−⟩

Final Measurement

After the last Hadamard on the top qubit, the relative phase between the two terms decides the outcome:

If f(0) = f(1) (constant) the top qubit collapses to ±|+⟩, so the final H gives measure 0.
If f(0) ≠ f(1) (balanced) it collapses to ±|−⟩, so the final H gives measure 1.

A single oracle query distinguishes constant from balanced, where any classical approach needs two. That one-query advantage is the seed of Deutsch-Jozsa, Simon's, and ultimately Shor's algorithm.

Part of the Quantum Series 2026. Originally published on Techucation, where the circuit diagrams are rendered in full.

Understanding Phase Kickback in Quantum Computing

Malcolm Low — Sun, 07 Jun 2026 10:08:40 +0000

In standard classical logic, a control bit dictates what happens to a target. In quantum mechanics the relationship is symmetric. When the target qubit is in an eigenstate of the gate operator, the eigenvalue phase is kicked back onto the control qubit, leaving the target unchanged while flipping the relative phase of the control. This post derives that result from first principles using the CNOT gate on |+⟩ ⊗ |−⟩.

1 · The CNOT Circuit and the Kickback Setup

The circuit places the control qubit in superposition |+⟩ and the target qubit in |−⟩. Since |−⟩ is an eigenstate of X with eigenvalue −1, the kickback occurs.

control:
|+⟩
|−⟩
target:
|−⟩
+
|−⟩

Key observation: The target qubit is unchanged after the CNOT. The control qubit flips from |+⟩ to |−⟩. The phase was kicked back to the control, not forward to the target.

2 · Full Derivation: |+⟩ ⊗ |−⟩ through CNOT

Step 1 — Define the initial state

|ψ₀⟩ = |+⟩ ⊗ |−⟩
= (1/√2)(|0⟩ + |1⟩) ⊗ (1/√2)(|0⟩ − |1⟩)

Step 2 — Expand the tensor product

|ψ₀⟩ = (1/2)[ |00⟩ − |01⟩ + |10⟩ − |11⟩ ]

Step 3 — Apply the CNOT gate

|ψ₁⟩ = (1/2)[ |00⟩ − |01⟩ + |11⟩ − |10⟩ ]

Step 4 — Factor and identify the result

|ψ₁⟩ = (1/2)[ |0⟩(|0⟩ − |1⟩) − |1⟩(|0⟩ − |1⟩) ]
= (1/√2)(|0⟩ − |1⟩) ⊗ (1/√2)(|0⟩ − |1⟩)
= |−⟩ ⊗ |−⟩

The target qubit is still |−⟩ — unchanged by the CNOT. The control qubit changed from |+⟩ to |−⟩. The −1 eigenvalue of the target has been kicked back as a relative phase onto the control.

3 · Why Phase Kickback Matters

The math shows that while we applied a gate to the target, the relative phase of the control qubit changed from positive to negative. This is a structural property of controlled unitaries acting on their eigenstates, and it appears at the core of every major quantum algorithm.

Algorithm	How phase kickback is used
Deutsch’s Algorithm	The oracle kicks a −1 phase onto the control qubit to encode whether f is constant or balanced, extractable with a single H gate measurement.
Grover’s Algorithm	The oracle flips the sign of the target state’s amplitude by kicking a −1 phase back to the control register, enabling amplitude amplification.
Shor’s Algorithm	Quantum Phase Estimation relies entirely on phase kickback to transfer eigenvalue information from the target register to the control register.

The general rule: for any unitary U with eigenstate |u⟩ (so U|u⟩ = eⁱᵖ|u⟩), a controlled-U gate with the control in superposition kicks the phase eⁱᵖ back to the control qubit. The target is unchanged.

Part of the Quantum Series 2026. Originally published on Techucation.

Introduction to Quantum Computing: Qubits, Hadamard Gates, and Superposition

Malcolm Low — Sun, 07 Jun 2026 10:07:46 +0000

Classical computers store information in bits that are always exactly 0 or 1. Quantum computers exploit the principles of quantum mechanics to do something fundamentally different: they operate on qubits, which can exist in a superposition of both states simultaneously. The Hadamard gate is the simplest gate that creates this superposition, and understanding it from first principles is the entry point to every quantum algorithm that follows.

1 · The Qubit

A qubit is the fundamental unit of quantum information. Unlike a classical bit, a qubit can exist in a superposition of |0⟩ and |1⟩ simultaneously. We write its general state using Dirac (bra-ket) notation:

|ψ⟩ = α|0⟩ + β|1⟩

Here α and β are complex numbers called probability amplitudes. They must satisfy the normalisation condition:

|α|² + |β|² = 1

The two computational basis states are represented as column vectors:

|0⟩ =
1
0
|1⟩ =
0
1

When we measure the qubit in state |ψ⟩ = α|0⟩ + β|1⟩, we get |0⟩ with probability |α|² and |1⟩ with probability |β|². The act of measurement destroys the superposition and collapses the qubit to a definite classical state.

Key distinction: The superposition is not just ignorance about a hidden value. The qubit genuinely occupies both states until measured, and this physical reality is what quantum algorithms exploit.

2 · The Hadamard Gate

The Hadamard gate H is a 2×2 unitary matrix that maps each computational basis state to an equal superposition:

H = (1/√2)
+1 +1
+1 −1

Applying H to each basis state:

Input	H \|input⟩	Short name
\|0⟩	(1/√2)( \|0⟩ + \|1⟩ )	\|+⟩
\|1⟩	(1/√2)( \|0⟩ − \|1⟩ )	\|−⟩

Both outputs have equal amplitudes of 1/√2, giving a 50% measurement probability for each outcome. The sign difference between |+⟩ and |−⟩ is what drives interference later.

Unitarity check: H†H = I. Since H is real and symmetric, H† = H, so H² = I. The Hadamard gate is its own inverse.

3 · H² = I: Quantum Interference

Applying H twice to |0⟩ returns the qubit to |0⟩. The algebra shows exactly why the |1⟩ amplitudes cancel through destructive interference:

H(H|0⟩)
= H( (1/√2)(|0⟩ + |1⟩) )
= (1/√2)( H|0⟩ + H|1⟩ )
= (1/√2)( (1/√2)(|0⟩+|1⟩) + (1/√2)(|0⟩−|1⟩) )
= (1/2)( |0⟩ + |1⟩ + |0⟩ − |1⟩ )
= (1/2)( 2|0⟩ )
= |0⟩ ✓

The +|1⟩ and −|1⟩ terms cancel completely (destructive interference) while the |0⟩ terms add (constructive interference). This is the fundamental mechanism behind quantum algorithms: arranging amplitudes so wrong answers cancel and the correct answer survives.

4 · Single-Qubit Circuit: H–H–Measure

A single qubit routed through two Hadamard gates and then measured always returns 0 with 100% probability:

q_0:
H
H
M

Step	State	Notes
1. Initialise	\|ψ₀⟩ = \|0⟩	Ground state
2. First H	\|ψ₁⟩ = (1/√2)(\|0⟩+\|1⟩)	Superposition: 50/50
3. Second H	\|ψ₂⟩ = \|0⟩	Interference collapses back
4. Measure	Result = 0	100% probability

This is a concrete demonstration that superposition is not just probabilistic noise. The deterministic outcome of 0 is only possible because the two Hadamard gates interact through interference, a purely quantum effect with no classical analogue.

5 · Tensor Products and Multi-Qubit States

Multi-qubit systems are described using the tensor product (⊗). For two qubits, the four computational basis states are:

Ket	Tensor form	Column vector
\|00⟩	\|0⟩ ⊗ \|0⟩	[1, 0, 0, 0]ᵀ
\|01⟩	\|0⟩ ⊗ \|1⟩	[0, 1, 0, 0]ᵀ
\|10⟩	\|1⟩ ⊗ \|0⟩	[0, 0, 1, 0]ᵀ
\|11⟩	\|1⟩ ⊗ \|1⟩	[0, 0, 0, 1]ᵀ

The tensor product of two vectors is computed by multiplying each element of the first vector by the entire second vector and stacking the results. For |0⟩ ⊗ |1⟩:

|0⟩ ⊗ |1⟩
= [1, 0]ᵀ ⊗ [0, 1]ᵀ
= [ 1×[0,1]ᵀ ] = [0, 1, 0, 0]ᵀ = |01⟩
[ 0×[0,1]ᵀ ]

Dimension growth: n qubits span a 2ⁿ-dimensional Hilbert space. A 3-qubit system already has 8 basis states; a 50-qubit system has 2⁵⁰ ≈ 10¹⁵, impossible to store classically.

6 · Two-Qubit Superposition: H⊗H on |00⟩

Applying independent Hadamard gates to both qubits starting from |00⟩:

q_0:
H
q_1:
H

(H⊗H)|00⟩
= (H|0⟩) ⊗ (H|0⟩)
= (1/√2)(|0⟩+|1⟩) ⊗ (1/√2)(|0⟩+|1⟩)
= (1/2)( |00⟩ + |01⟩ + |10⟩ + |11⟩ )

All four two-qubit basis states appear with equal amplitude 1/2. Each has measurement probability (1/2)² = 25%. This is the two-qubit analogue of the uniform superposition that opens algorithms like Grover’s.

7 · Interference in a Two-Qubit H–H Circuit

Applying H⊗H twice to |00⟩ returns it to |00⟩. The interference analysis on each basis state shows the mechanism:

Input to 2nd H⊗H	After (H⊗H)
\|00⟩	(1/2)( \|00⟩ + \|01⟩ + \|10⟩ + \|11⟩ )
\|01⟩	(1/2)( \|00⟩ − \|01⟩ + \|10⟩ − \|11⟩ )
\|10⟩	(1/2)( \|00⟩ + \|01⟩ − \|10⟩ − \|11⟩ )
\|11⟩	(1/2)( \|00⟩ − \|01⟩ − \|10⟩ + \|11⟩ )

The initial superposition has equal weight 1/2 on each of the four states. Summing contributions to each output:

Output state	Amplitude sum (× 1/4)	Result
\|00⟩	+1 +1 +1 +1	4/4 = 1 ✓ constructive
\|01⟩	+1 −1 +1 −1	0 destructive
\|10⟩	+1 +1 −1 −1	0 destructive
\|11⟩	+1 −1 −1 +1	0 destructive

Only |00⟩ survives. This is the same interference structure that the Grover diffusion operator exploits at scale: constructive interference on the target state, destructive on all others.

8 · The H⊗H Matrix and Why It Matters

The combined H⊗H operator is a 4×4 Walsh-Hadamard matrix (scaled by 1/2). Its sign pattern is exactly the two-qubit case of the popcount rule derived in the Walsh-Hadamard post:

H⊗H = (1/2)
+1 +1 +1 +1
+1 −1 +1 −1
+1 +1 −1 −1
+1 −1 −1 +1

Every quantum algorithm that achieves a speedup over classical computation does so through the same three-phase structure:

Phase	Operation	Purpose
1. Open	Hadamard on all qubits	Create uniform superposition over all 2ⁿ states
2. Operate	Oracle / phase manipulation	Mark or bias the amplitude of the target answer
3. Close	Hadamard again (+ measurement)	Interference concentrates probability on the answer

The bottom line: the qubit and the Hadamard gate are the entry point to everything. Grover’s O(√N) search, Shor’s O((log N)³) factoring, and every other quantum speedup ultimately trace back to this interference mechanism operating at scale.

Part of the Quantum Series 2026. Originally published on Techucation.

Quantum Computing: CHSH Game Simulator and Bell's Inequality

Malcolm Low — Sun, 07 Jun 2026 10:07:43 +0000

Have you ever wondered how quantum mechanics defies everyday intuition? This project demonstrates one of the most striking phenomena in quantum physics: quantum entanglement and its ability to violate classical physics constraints through a playable cooperative game.

🎮 Try the CHSH Game Simulator |
📂 View on GitHub

1 · What Is the CHSH Game in Quantum Computing?

The CHSH (Clauser-Horne-Shimony-Holt) game is a cooperative thought experiment that reveals the strange power of quantum entanglement. Two players, Alice and Bob, cannot communicate during the game but may share a pre-agreed strategy or, crucially, a pair of entangled qubits.

Player	Receives from referee	Outputs
Alice	Random bit x	Bit a
Bob	Random bit y	Bit b

They win if and only if:

(a + b) mod 2 = x × y

With classical strategies, Alice and Bob can win at most 75% of the time. With a quantum strategy using entangled qubits, they can reach approximately 85.4%, violating the classical bound.

2 · Bell’s Inequality and the CHSH Value

In 1964, John Bell proved that no local hidden variable theory can reproduce all predictions of quantum mechanics. The CHSH inequality formalises Bell’s theorem as a single testable number S:

Theory	CHSH Value (S)	Win Rate
Classical (any local strategy)	`S ≤ 2`	75%
Quantum mechanics	`S = 2√2 ≈ 2.828`	~85.4%

This violation is not a loophole or a trick. It proves that the correlations produced by entangled qubits cannot be explained by any shared classical information, even with pre-agreed randomness. Loophole-free Bell test experiments confirm that quantum entanglement is a genuine physical phenomenon with no classical analogue.

3 · Measurement Angles and Quantum Correlation

The quantum advantage arises from choosing measurement bases at specific angles. For the standard |Φ+⟩ Bell state, the optimal angles are:

Player	Input bit	Measurement basis
Alice	x = 0	0°
Alice	x = 1	45°
Bob	y = 0	22.5°
Bob	y = 1	−22.5°

The probability that Alice and Bob produce the same outcome is:

P(same) = cos²(δ)

where δ is the angle between their chosen measurement bases. This quantum correlation is what enables them to exceed the 75% classical ceiling. Different Bell states exhibit either parallel correlation (|Φ+⟩, |Ψ+⟩: qubits tend to give the same outcome) or orthogonal correlation (|Φ−⟩, |Ψ−⟩: one qubit effectively rotated 90° relative to the other). The simulator adjusts its probability calculations accordingly for each state.

🧪 4 · The Four Bell States

The simulator supports all four maximally entangled Bell states. Each uses optimised measurement angles to achieve the theoretical quantum win rate of ~85%.

State	Definition	Correlation
\|Φ+⟩	(\|00⟩ + \|11⟩) / √2	Parallel
\|Φ−⟩	(\|00⟩ − \|11⟩) / √2	Orthogonal
\|Ψ+⟩	(\|01⟩ + \|10⟩) / √2	Parallel
\|Ψ−⟩	(\|01⟩ − \|10⟩) / √2	Orthogonal

🎯 5 · CHSH Game Simulator Features

Feature	Details
🎯 Interactive Visualization	Real-time p5.js visualization showing the entangled state, Alice’s measurement collapse, and Bob’s final measurement. Coloured basis quadrants and correlation indicators included.
🎮 Strategy Comparison	Switch between Classical (always outputs 0, max 75%) and Quantum (entangled qubits, ~85.4%) strategies in real time.
🎲 Flexible Input Controls	Set Alice’s x and Bob’s y to Random or Fixed (0 or 1) to test specific measurement configurations.
📊 Real-Time Statistics	Running totals for rounds played, wins, losses, and win percentage converging toward theoretical predictions.
🔄 Round History Navigation	Step through previous rounds to review specific outcomes and trace the quantum measurement process.

Built with: React, p5.js, and Claude Code

6 · Try the Quantum Entanglement Simulator

A suggested sequence to build intuition:

Open the simulator and select the Classical strategy. Run 100 rounds and watch the win rate converge toward 75%.
Switch to the Quantum strategy with the |Φ+⟩ Bell state. Run another 100 rounds and observe the rate climb toward 85%.
Try the other three Bell states. Note how each state’s correlation type (parallel vs orthogonal) affects the outcome distribution.
Set Alice and Bob’s inputs to Fixed values to test individual measurement configurations and trace the correlation manually.
Use Round History to step back through specific rounds and verify the win condition (a + b) mod 2 = x × y by hand.

7 · Open Source Code on GitHub

The complete source code is on GitHub. Contributions welcome: explore the code, report issues, suggest improvements, or fork it to build your own quantum visualisations.

Planned enhancements include a 3D Bloch sphere visualisation (Three.js), step-by-step animated transitions, an in-app educational tutorial, a mathematical deep-dive panel, and improved mobile layout.

The CHSH game demonstrates that quantum entanglement is not a mathematical abstraction but a measurable, observable phenomenon with no classical analogue. This simulator makes that phenomenon interactive and accessible to anyone curious about quantum mechanics.

Part of the Quantum Series 2026. Originally published on Techucation.

The No-Cloning Theorem in Quantum Computing: Why You Can't Copy a Qubit

Malcolm Low — Sun, 07 Jun 2026 09:58:46 +0000

Copying is so ordinary in classical computing that we never think about it. Every assignment, every memory write, every Ctrl+C duplicates a bit string perfectly and at will. Quantum mechanics flatly refuses to do the same for an unknown state. There is no machine, no clever circuit, no sequence of gates that takes an arbitrary qubit and hands you back two identical copies of it. This is the no-cloning theorem, and far from being a limitation we tolerate, it is the structural reason quantum key distribution is secure, the reason entanglement cannot be used to signal faster than light, and the reason quantum error correction had to be reinvented from scratch.

The proof is short. It falls out of two properties we have already relied on throughout this series: linearity of quantum evolution, and unitarity. Below we prove it both ways, clear up the very common confusion about CNOT "copying" a qubit, walk through the consequences, and then watch a cloning attempt fail in Qiskit.

1 · What "cloning" would actually mean

A cloning machine would be a single fixed unitary U together with a standard blank register |e⟩, such that for every possible input state |ψ⟩ it produces:

U ( |ψ⟩ ⊗ |e⟩ )  =  |ψ⟩ ⊗ |ψ⟩

Three pieces of that statement deserve unpacking, because the whole theorem turns on them.

What |e⟩ is, and what "blank" means. The register |e⟩ is simply the second slot, the one that will end up holding the copy. We call it "blank" by analogy with an empty sheet of paper or an uninitialised memory cell: before the operation it carries no information whatsoever about the input |ψ⟩. The conventional choice is |0⟩, or |0...0⟩ when the copy needs several qubits, but |e⟩ does not have to be the zero vector specifically. Any fixed pure state works equally well for the theorem. The property that actually matters is not its literal value but that it is independent of the unknown input. A register that already secretly equalled |ψ⟩ would not be blank, and you would not have copied anything, you would have been handed the answer.

What "fixed" means, for both U and |e⟩. Fixed means chosen in advance and identical on every run, never allowed to depend on which |ψ⟩ happens to come in. This is the condition that keeps the problem honest. If you were permitted to pick |e⟩ or U based on the input, you would first have to know what |ψ⟩ is, and at that point there is nothing left to clone: you could just prepare a second copy yourself. So the cloner gets one unitary and one starting register, and they must work for an arbitrary, unknown input. The claim of the theorem is that no such pair (U, |e⟩) exists.

Why cloning a known state is allowed, and how you do it. The theorem forbids copying an unknown arbitrary state. It says nothing about states you already understand, and there are two everyday ways such a state can be "known":

You know...	How you get two copies
The preparation recipe (the amplitudes, or the circuit that builds it)	Just run the preparation twice on two fresh \|0⟩ qubits. You are re-preparing from a known description, not copying an unknown state.
That the state is one of a known orthogonal set	Measure in the basis that distinguishes the set. Orthogonal states are eigenstates of that measurement, so they survive it undisturbed. Read off the label, then re-prepare as many copies as you like.

As a concrete example of the first route, if you are told the state is |ψ⟩ = Ry(θ)|0⟩ for a known angle θ, you simply apply Ry(θ) to two separate qubits. No universal device is involved, and no rule is broken. The contradiction in the next two sections appears only when no such side information exists, that is, when the same machine must handle a continuum of unknown inputs at once.

The one-line distinction: you can always re-prepare a state you know how to build, and you can copy states that act like classical labels. What you cannot do is build one fixed machine that duplicates an arbitrary, unknown state handed to you blind.

2 · Proof I: linearity forbids it

Assume, for contradiction, that a universal cloner U exists. Pick two arbitrary states |ψ⟩ and |φ⟩. By assumption U clones both of them:

U |ψ⟩|e⟩  =  |ψ⟩|ψ⟩
U |φ⟩|e⟩  =  |φ⟩|φ⟩

Now feed the machine a superposition of the two inputs, |χ⟩ = (1/√2)(|ψ⟩ + |φ⟩). Quantum evolution is linear, so U acts term by term on the input:

U |χ⟩|e⟩  =  (1/√2) ( U|ψ⟩|e⟩ + U|φ⟩|e⟩ )
          =  (1/√2) ( |ψ⟩|ψ⟩ + |φ⟩|φ⟩ )

But if U is genuinely a cloner, then by definition it must also clone |χ⟩ itself, producing |χ⟩|χ⟩. Expanding that out:

|χ⟩|χ⟩  =  (1/2) ( |ψ⟩ + |φ⟩ )( |ψ⟩ + |φ⟩ )
        =  (1/2) ( |ψ⟩|ψ⟩ + |ψ⟩|φ⟩ + |φ⟩|ψ⟩ + |φ⟩|φ⟩ )

The contradiction is the same one that powers most quantum no-go results: a device defined by its action on a basis is forced, by linearity, into a behaviour on superpositions that contradicts the original specification.

3 · Proof II: unitarity forbids it

The linearity argument shows cloning fails for superpositions. A second proof, often considered the cleaner one, uses the fact that unitary operations preserve inner products. Suppose again that U clones two states:

U |ψ⟩|e⟩  =  |ψ⟩|ψ⟩
U |φ⟩|e⟩  =  |φ⟩|φ⟩

The inner product is taken over the full two-register states that U acts on, not over |ψ⟩ and |φ⟩ on their own. Label the two inputs and their images under U:

Input A   = |ψ⟩|e⟩        Output UA  = |ψ⟩|ψ⟩
Input B   = |φ⟩|e⟩        Output UB  = |φ⟩|φ⟩

If U is unitary, then   ⟨A|B⟩  =  ⟨UA|UB⟩

That identity, ⟨A|B⟩ = ⟨UA|UB⟩, is the definition of a unitary: it preserves inner products. U never acts on the inner product itself, which is only a number; it acts on the states, and unitarity says doing so cannot change their overlap. Now evaluate both sides, using the tensor-product factorisation ⟨a|⟨b| · |c⟩|d⟩ = ⟨a|c⟩ ⟨b|d⟩ and ⟨e|e⟩ = 1:

⟨A|B⟩   = ⟨ψ|⟨e| · |φ⟩|e⟩  =  ⟨ψ|φ⟩ ⟨e|e⟩  =  ⟨ψ|φ⟩
⟨UA|UB⟩ = ⟨ψ|⟨ψ| · |φ⟩|φ⟩  =  ⟨ψ|φ⟩ ⟨ψ|φ⟩  =  ⟨ψ|φ⟩²

so   ⟨ψ|φ⟩  =  ⟨ψ|φ⟩²

Write x = ⟨ψ|φ⟩. The condition x = x² rearranges to x(x − 1) = 0, whose only solutions are x = 0 or x = 1. In other words, cloning is consistent only when the two states are orthogonal (x = 0) or identical (x = 1). Any pair of distinct, non-orthogonal states, the generic case, breaks the equality. No universal cloner can exist.

⟨ψ\|φ⟩	Relationship	Cloneable?
0	Orthogonal (a known basis set)	Yes, this is just classical copying
1	Identical (already known)	Yes, trivially
anything else	Distinct, non-orthogonal	No

Both proofs converge on the same boundary. Orthogonal states carry distinguishable classical labels and can be copied; overlapping quantum states cannot.

4 · "But doesn't CNOT copy a qubit?"

This is the single most common point of confusion, and it is worth resolving carefully. A CNOT with the input qubit as control and a fresh |0⟩ as target looks exactly like a copy operation. On computational basis states it behaves like one:

CNOT |0⟩|0⟩  =  |0⟩|0⟩
CNOT |1⟩|0⟩  =  |1⟩|1⟩

So far it really is copying: the second qubit ends up matching the first. The trouble appears the moment the control is a superposition. Take |ψ⟩ = a|0⟩ + b|1⟩ as control and |0⟩ as target:

CNOT ( a|0⟩ + b|1⟩ )|0⟩  =  a|00⟩ + b|11⟩

Compare that with what a true clone would have produced, namely |ψ⟩|ψ⟩:

|ψ⟩|ψ⟩  =  a²|00⟩ + ab|01⟩ + ab|10⟩ + b²|11⟩

These are different states. The CNOT output a|00⟩ + b|11⟩ is an entangled pair, not two independent copies. If you discard the original and look at the "copy" on its own, you do not find |ψ⟩; you find a mixed state that has lost the phase relationship between a and b entirely. CNOT copies the value in the computational basis but destroys the superposition structure that made the state quantum in the first place. That is exactly the gap between copying classical information, which is always allowed, and cloning a quantum state, which is not.

Rule of thumb: CNOT copies basis labels, not quantum states. The instant the input is in superposition, the "copy" is entanglement, not duplication.

5 · Why this single theorem matters so much

No-cloning is not a footnote. Three of the most important results in quantum information rest directly on it.

Quantum key distribution. In BB84, Alice sends qubits encoded in randomly chosen bases. An eavesdropper, Eve, would love to intercept each qubit, keep a copy, and forward the original untouched so she can measure her copies later once the bases are announced. No-cloning makes that impossible. Eve cannot duplicate an unknown qubit, so she is forced to measure in transit, and measuring in the wrong basis disturbs the state and injects a detectable error rate. The security of the protocol is the no-cloning theorem wearing a different hat.

No faster-than-light signalling. Entanglement correlates distant measurement outcomes, which has always tempted people into superluminal-communication schemes. Many of those schemes secretly assume Bob can clone his half of an entangled pair, make many copies, and read off the statistics to learn which basis Alice measured in. No-cloning closes that loophole and is one of the reasons quantum mechanics and relativity coexist without paradox.

Quantum error correction. Classical error correction leans on the simplest trick imaginable: copy the bit several times and take a majority vote. That is illegal in the quantum setting, because you cannot copy an unknown logical state. Quantum codes had to be built on a different principle, spreading logical information across many physical qubits using entanglement and measuring error syndromes without ever reading or duplicating the encoded state. The whole architecture of fault tolerance is shaped by the fact that the obvious classical fix is off the table.

A useful way to hold it in your head: no-cloning is what stops quantum information from behaving like classical information. Almost everything that makes quantum protocols both powerful and secure traces back to that one restriction.

6 · Watching a clone fail in Qiskit

The abstract proof is convincing, but it is satisfying to watch the failure happen numerically. We attempt the naive CNOT "clone" of the state |+⟩ = H|0⟩, then measure how badly it falls short by two yardsticks: fidelity against the intended |+⟩|+⟩, and the purity of the copy qubit on its own.

Three terms in plain language:

Fidelity is a similarity score between two quantum states, from 0 to 1. Think of it as a match percentage: 1.0 means identical, 0 means completely unrelated.
Reduced state is the honest description of one qubit when you ignore its partner. Picture two coins glued so they always land the same way: cover one and look at just the other, and that single coin looks like a plain 50/50 flip. The "match" information lived in the pair, not in either coin alone. Discarding the partner mathematically is called tracing it out.
Purity tells you whether a state is sharp and definite or a blurry random mixture. Purity 1 is a clean, definite state. For a single qubit the lowest value is 0.5, called maximally mixed, which is total randomness, the quantum version of a fair coin holding no information.

from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector, partial_trace, state_fidelity

qc = QuantumCircuit(2)
qc.h(0)        # prepare |+> on qubit 0 (the "original")
qc.cx(0, 1)    # naive "cloning" attempt via CNOT

state = Statevector(qc)
print(state)   # (|00> + |11>)/sqrt(2), a Bell state

target = Statevector.from_label('++')   # what we wanted: |+>|+>
print(state_fidelity(state, target))    # 0.5

rho_copy = partial_trace(state, [0])     # trace out the original
print(rho_copy.data)                     # I/2, maximally mixed
print(rho_copy.purity().real)            # 0.5

Running it gives:

Output state:           (√2/2)|00⟩ + (√2/2)|11⟩
Fidelity to |+⟩|+⟩:     0.5
Reduced state of copy:  [[0.5, 0], [0, 0.5]]
Purity of copy:         0.5

Every number tells the same story. The output is a maximally entangled Bell state, not the product |+⟩|+⟩ we were hoping for, and the fidelity to the intended clone is only 0.5. Trace out the original and the supposed "copy" is the maximally mixed state I/2, with purity 0.5 rather than 1. The copy retains no memory of the |+⟩ superposition at all; it is as good as a fair coin. The CNOT did precisely what the theorem says it must: it produced correlation, not duplication.

Try changing qc.h(0) to any other single-qubit rotation, say qc.ry(0.7, 0). The fidelity stays stubbornly below 1 for every non-basis input, which is the no-cloning theorem reproduced one statevector at a time.

Part of the Quantum Series 2026, built with Qiskit 1.x. Originally published on Techucation.

Publishing to WordPress with Claude and the WordPress MCP Connector

Malcolm Low — Wed, 27 May 2026 14:39:03 +0000

Originally published at malcolmlow.com.

Several posts on this blog — including Word Embeddings Explained, SingIDBot, and the OpenClaw Telegram integration guide — were written, styled, and published entirely through Claude on claude.ai, using the WordPress MCP connector. This post documents exactly how that workflow operates, what problems arise, and how to resolve them.

The combination of Claude's HTML generation capability and the WordPress MCP connector creates a surprisingly smooth authoring pipeline, provided you know the constraints WordPress imposes on custom HTML blocks. Those constraints are the non-obvious part, and they are addressed in detail below.

1. Prerequisites

Requirement	Details
Claude account on claude.ai	Free tier works; Pro gives longer contexts useful for large HTML posts.
WordPress.com site	The MCP connector works with WordPress.com-hosted blogs. Self-hosted WordPress.org is not directly supported.
WordPress MCP connector enabled	In claude.ai, go to Settings → Integrations and enable the WordPress.com connector. Authenticate with your WordPress.com account.

2. The Overall Workflow

The end-to-end process has three stages. Claude handles all of them in a single conversation.

Stage	Name	What happens
1	Draft & Style	Provide Claude with your content and request a WordPress HTML block with inline CSS only. No `<style>` tags.
2	Review Output	Preview the rendered HTML in claude.ai artifacts. Request edits until the post looks correct.
3	Publish via MCP	Ask Claude to post using the WordPress connector. It checks categories and tags, creates any missing ones, then submits as a draft for your review.

Prompt for Stage 1:

"Generate a WordPress post using a custom HTML block with inline CSS only. Do not use <style> tags, <script> tags, or SVG."

Prompt for Stage 3:

"Post this to myhlow.wordpress.com using the WordPress connector. Use appropriate categories and tags. Post as a draft first."

3. How the WordPress MCP Connector Works

The MCP connector gives Claude direct access to your WordPress.com REST API. When you ask Claude to post, it performs these operations internally:

Loads the connector, resolving the WordPress.com:wpcom-mcp-content-authoring tool.
Lists existing categories using categories.list to find IDs.
Lists existing tags using tags.list to find or create tags.
Creates missing terms using categories.create / tags.create if needed.
Creates the post using posts.create with the HTML content, title, IDs, and status (draft or publish).
Returns the preview and edit URLs so you can open the draft in WordPress immediately.

Post content must be wrapped in a wp:html block comment:

<!-- wp:html -->
<div style="...">...post content...</div>
<!-- /wp:html -->

4. Problems Encountered — and How They Were Solved

Problem 1: WordPress strips `<style>` blocks entirely

What happened: Early posts used a <style> tag defining CSS classes. WordPress silently removed it on save, stripping all styling.

Fix: Every CSS rule must be a style="..." attribute. Instruction: "Use inline CSS only. Do not use <style> tags."

Problem 2: WordPress strips SVG elements

What happened: Inline SVG circuit diagrams were stripped on save, leaving blank spaces.

Fix: Replace SVG with HTML-native layout using CSS flexbox. Instruction: "Do not use SVG."

Problem 3: `<script>` tags are blocked

What happened: JavaScript interactivity was silently discarded by WordPress content sanitisation.

Fix: Replace all interactivity with pure HTML/CSS alternatives.

Problem 4: API parameter case sensitivity

What happened: Passing "order": "DESC" returned a validation error.

Fix: Always use lowercase: "order": "desc".

Problem 5: Duplicate categories and tags

What happened: Claude created duplicate taxonomy terms without checking first.

Fix: Always call categories.list and tags.list before any creation step.

Problem 6: ` ` spacing and Unicode box-drawing characters break alignment

What happened: Characters and   spacing that looked correct in claude.ai artifacts misaligned in WordPress because the theme font renders them at inconsistent widths.

Fix: Replace character-based layout with CSS:

Single-wire gates: display:flex; align-items:center rows with inline-block wire spans and bordered gate boxes.
Column vectors: display:flex container with border-left/border-right bracket spans and <br> for rows.

Instruction: "Never use   for alignment or Unicode box-drawing characters."

Problem 7: Multi-wire circuits with vertical connectors require `position:absolute`

What happened: The CNOT gate required a vertical line connecting a control dot (●) to an XOR circle (⊕) on a separate wire. border-top/border-bottom on table cells produced horizontal bars; rowspan="2" was visually correct but the theme's CSS overrode <td> padding in ways inline styles couldn't fix.

Fix: Three-part solution:

Use <div style="display:table-cell"> instead of <td> to bypass theme CSS selectors.
Two separate display:flex; height:28px rows in a position:relative wrapper, with a position:absolute; width:2px connector div.
Asymmetric wire stubs: the control dot (12 px) needs 21 px stubs; the XOR circle (20 px) needs 17 px stubs — keeping both symbol centres at the same x-coordinate.

5. Step-by-Step: Posting via Claude and WordPress MCP

Step 1 — Enable the WordPress Connector in claude.ai

Go to claude.ai → Settings → Integrations. Find the WordPress.com connector, click Connect, and authorise with your WordPress.com account.

Step 2 — Prompt Claude with the constraint set

Generate a WordPress post as a custom HTML block.
Use inline CSS only — no <style> tags, no <script> tags, no SVG.
Never use &nbsp; for alignment or Unicode box-drawing characters.
Use display:flex and inline-block spans for diagrams and vectors.
For multi-wire circuits: use position:relative wrapper + position:absolute connector.
Match the styling of: [URL of a reference post]
Topic: [your content here]

Step 3 — Review the artifact in claude.ai

Verify layout, colours, and rendering. No <style> or <script> tags should appear.

Step 4 — Trigger the MCP posting

Post this to myhlow.wordpress.com using the WordPress connector.
Use appropriate categories and tags.
Status: draft

Claude calls categories.list and tags.list, creates any missing terms, executes posts.create, and returns the draft URLs.

Step 5 — Preview in WordPress and publish

Open the draft URL. If the Custom HTML block renders correctly, click Publish.

6. Installing the Workflow as a Reusable Skill

All the constraints from this guide are packaged as a downloadable Claude Skill. Once installed, the skill auto-loads every time you start a WordPress publishing task.

Enable Code Execution and File Creation — Settings → Capabilities → toggle on Code Execution and File Creation.
Open the Skills page — https://claude.ai/customize/skills (browser only, not the mobile app).
Upload the skill file — "+" → "+ Create skill" → "Upload a skill" → select wordpress-publish.skill → toggle it on.
Trigger in any new chat — Say "publish to WordPress" and Claude loads all constraints automatically.

7. Quick Reference: Dos and Don'ts

Do	Don't
Use `style="..."` on every element	Use `<style>` blocks or CSS classes
Use `display:flex` + `inline-block` for diagrams and vectors	Use ` ` or Unicode box-drawing characters for alignment
Use `position:relative` + `position:absolute` connector for multi-wire circuits	Use `border-top`/`border-bottom` on table cells to simulate vertical connectors
Use `<div style="display:table-cell">`	Rely on `<td>` padding — theme CSS may override it
Wrap content in `<!-- wp:html -->`	Use `<svg>` or `<script>` tags
Use lowercase `"order": "desc"` in API params	Use uppercase `"order": "DESC"`
Post as draft first and preview in WordPress	Publish directly without previewing
Let Claude auto-select categories and tags	Create taxonomy terms without checking for existing ones
Set table header styles on `<tr>`, not `<th>`	Apply background colours to `<th>` elements

Tip: Giving Claude the URL of an existing post and asking it to match the styling is the fastest way to maintain visual consistency across your blog. The Word Embeddings post and the SingIDBot guide were both created this way, borrowing section card layout, banner colours, and code block styles from earlier posts.

Say Goodbye to Finder. Meet Marta.

Malcolm Low — Sat, 16 May 2026 03:29:43 +0000

Originally published on malcolmlow.com

macOS Finder has served Mac users faithfully since 1984 — but its age is showing. For anyone who regularly moves files between folders, manages projects with complex directory structures, or simply wants a more keyboard-friendly workflow, Finder's single-pane design quickly becomes a bottleneck.

Marta is a modern, native macOS file manager that addresses every one of these frustrations. Best of all — it's free.

What is Marta?

Marta is a dual-pane, keyboard-driven file manager built exclusively for macOS. Developed by Yan Zhulanow, it borrows the powerful two-panel paradigm from classic file managers like Total Commander and Midnight Commander — but wraps it in a clean, native macOS interface.

It is highly customisable, supports themes, and has its own plugin and scripting ecosystem. But even out of the box, the difference is immediately noticeable.

How to Install Marta

Option A — Direct Download (Recommended)

Head to the official Marta website and download the latest release:
marta.sh

Option B — Install via Homebrew

brew install --cask marta

After installation, optionally grant Full Disk Access for unrestricted folder navigation:
System Settings → Privacy & Security → Full Disk Access → toggle Marta on

Why Marta Beats Finder

🪟 Dual-Pane Navigation — The Game Changer

The single biggest advantage: a side-by-side dual-pane view. Your screen is split into two independent file panels, each showing a different folder. You can see your source and destination simultaneously — copy or move files between them without ever losing your place or juggling multiple windows.

For power users — developers, academics, content creators — this alone is worth the switch.

📁 Create New Folders in Seconds

In Finder, creating a new folder means right-clicking through a context menu. In Marta, it's a single keyboard shortcut (⌘ + ⇧ + N) — a new folder appears inline, ready to be named. Your workflow never breaks stride.

⌨️ Fully Keyboard-Driven

Navigate, open, rename, copy, move, and delete files without ever touching the mouse. Marta's keyboard-first design means experienced users can fly through file operations far faster than any GUI-only workflow allows.

🗃️ Tabs & Bookmarks

Keep multiple folder locations open as tabs within each panel. Bookmark your most-used directories and jump to them instantly — particularly powerful for large project hierarchies.

🎨 Themeable & Configurable

Marta supports custom themes and a powerful configuration file (conf.marco). You can remap shortcuts, add plugins, and tailor the entire interface to your exact preferences.

The Verdict

Marta won't replace Finder for every macOS task — but as a daily driver for navigating, organising, and moving files, it is simply in a different league. The dual-pane view alone transforms how you work with files, and features like instant folder creation and keyboard navigation make it feel like a tool built for people who actually use their computer seriously.

If you've ever felt frustrated waiting on Finder's slow animations, losing track of copy destinations, or clicking through five menus just to create a folder — give Marta five minutes. You won't go back.

marta.sh →

The Cost of Garbage in Quantum Computing: Why You Must Clean Up Junk Bits

Malcolm Low — Sat, 16 May 2026 03:29:12 +0000

Originally published on malcolmlow.com

In quantum computing, anything that "knows" what a qubit is doing acts as a Witness. Leftover data (Junk Bits) on an ancilla qubit act as witnesses, destroying the interference your algorithm needs to work.

1 . The Observer Effect

Consider a simple circuit where a qubit passes through two Hadamard gates. Classically, two inversions cancel. Quantum mechanically, the same is true — only if no information leaks out between them.

Case A: Ideal — No Junk

q0: |0> --H-----------H-- => |0>  (100% probability)

The two Hadamard gates cancel perfectly. Measurement always yields |0>.

Case B: Broken — With Junk

q0: |0> --H----*-------H-- => |0> or |1>  (50/50 noise)
               |
q1: |0> -------X---------- => |junk>      (records q0's path)

The ancilla qubit q1 becomes entangled with q0. It now "knows" which path q0 took — and that knowledge destroys the interference.

2 . Mathematical Working

Ideal Case — interference works:

Start:    |0>
After H:  (1/sqrt2)(|0> + |1>)
After H:  (1/2)(|0> + |1> + |0> - |1>) = |0>   (cancel!)

The |1> terms cancel — constructive interference on |0>.

Junk Case — interference destroyed:

Start:          |0>|0>
After H on q0:  (1/sqrt2)(|0> + |1>)|0>
After CX:       (1/sqrt2)(|00> + |11>)    <- entangled!
After H on q0:  (1/2)(|00> + |10> + |01> - |11>)

The terms cannot cancel because q1 differs in each: |00> vs |10> are orthogonal states. Interference is destroyed.

3 . The Solution: Uncomputation

To restore interference, follow the Compute-Copy-Uncompute pattern:

q_in : |x> --[COMPUTE]--+--[UNCOMPUTE]-- |x>    (unchanged)
                        |
q_anc: |0> -------------+--[UNCOMPUTE]-- |0>     (cleaned)
                        |
q_out: |0> -------------+--------------- |f(x)>  (result)

Step by step:

Compute — apply your function gates, writing the result onto q_anc
Copy — CNOT the result from q_anc into q_out
Uncompute — run the compute gates in reverse, resetting q_anc to |0>

With q_anc back to |0>, the witness is gone and interference is fully restored.

4 . Qiskit Implementation

from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator

qc = QuantumCircuit(3)
# q0 = input, q1 = ancilla, q2 = output

qc.h(0)
qc.cx(0, 1)   # COMPUTE:    entangle q0 -> q1 (creates junk)
qc.cx(1, 2)   # COPY:       copy result q1 -> q2
qc.cx(0, 1)   # UNCOMPUTE:  reverse compute, reset q1 -> |0>
qc.h(0)       # Interference fully restored

qc.measure_all()
counts = AerSimulator().run(transpile(qc, AerSimulator())).result().get_counts()
print(f"Resulting state: {counts}")

The same circuit as a wire diagram (@ = control, X = target):

q0: |0> --H--@---------@--H-- M
             |         |
q1: |0> -----X----@----X----- M   (ancilla: |0> -> junk -> |0>)
                  |
q2: |0> ----------X---------- M   (output: holds f(x))

The second cx(0,1) exactly reverses the first, leaving q1 in |0>. With the witness removed, the final h(0) performs clean interference and q0 deterministically outputs |0>.

5 . Why This Matters in Practice

Uncomputation is not just a theoretical nicety. In real quantum algorithms:

Context	Why it matters
Grover's oracle	Must leave ancilla qubits clean after marking the target, or subsequent diffusion steps decohere
Arithmetic circuits	Reversible adders/multipliers accumulate garbage at every intermediate step — all must be uncomputed before measurement
Fault-tolerant circuits	Strict qubit budgets; junk bits consume physical qubits that could otherwise be used for error correction

The Compute-Copy-Uncompute pattern is the standard solution across all three contexts.

Quantum Series 2025 · Built with Qiskit 1.x

Quantum Computing: Grover's Algorithm — Inversion About the Mean

Malcolm Low — Sat, 16 May 2026 03:18:38 +0000

Originally published on malcolmlow.com

Grover's algorithm is a quantum search procedure that locates a marked item in an unsorted list of N items in O(√N) oracle queries — a quadratic speedup over any classical approach. For N = 8 (3 qubits), this means roughly ⌊π/4 × √8⌋ = 2 optimal iterations before the probability of measuring the target state peaks.

This walkthrough tracks the exact amplitude of every basis state through each gate operation for the 3-qubit case, with target state |101⟩. All arithmetic is shown so each step can be verified by hand.

Structure of each iteration (Grover operator G):

Oracle Uf — Phase-flips the target state: |x⟩ → −|x⟩ if f(x) = 1, otherwise |x⟩ → |x⟩
Diffusion operator D = H⊗n(2|0⟩⟨0| − I)H⊗n — Reflects all amplitudes about their mean, amplifying the marked state at the expense of the others

Key insight: The oracle introduces destructive interference at the target, which the diffusion operator converts into constructive interference by inverting amplitudes about their mean. Each iteration rotates the state vector by angle 2θ closer to the target, where sin(θ) = 1/√N.

Phase 0: Initialization

Apply H⊗3 to |000⟩ to create a uniform superposition over all 8 basis states:

|ψinit⟩ = (1/√8)[ |000⟩ + |001⟩ + |010⟩ + |011⟩
                 + |100⟩ + |101⟩ + |110⟩ + |111⟩ ]

Every state has amplitude +1/√8 ≈ 0.3535 and probability 12.5%.

Hadamard Reference (Standard Signs)

Element (i, j) has sign (−1)^popcount(i AND j). This table is used in every Hadamard step below — each row shows how an input basis state distributes into all 8 output states.

          |000⟩ |001⟩ |010⟩ |011⟩ |100⟩ |101⟩ |110⟩ |111⟩
          ─────────────────────────────────────────────────
H|000⟩ →    +     +     +     +     +     +     +     +
H|001⟩ →    +     −     +     −     +     −     +     −
H|010⟩ →    +     +     −     −     +     +     −     −
H|011⟩ →    +     −     −     +     +     −     −     +
H|100⟩ →    +     +     +     +     −     −     −     −
H|101⟩ →    +     −     +     −     −     +     −     +
H|110⟩ →    +     +     −     −     −     −     +     +
H|111⟩ →    +     −     −     +     −     +     +     −

Round 1: Oracle → Diffusion

Step 3 — Oracle Uf

The oracle recognises |101⟩ as the marked state and flips its amplitude from +1/√8 to −1/√8. All other amplitudes remain unchanged. The superposition is preserved — no measurement is made.

Step 4.1 — First H (mapping to Hadamard basis)

Each input state contributes ±1/8 to each output column via the sign table. The oracle-marked |101⟩ row is fully sign-inverted.

                  |000⟩  |001⟩  |010⟩  |011⟩  |100⟩  |101⟩  |110⟩  |111⟩
                  ──────────────────────────────────────────────────────────
+H|000⟩  (+1/√8)  +1/8   +1/8   +1/8   +1/8   +1/8   +1/8   +1/8   +1/8
+H|001⟩  (+1/√8)  +1/8   -1/8   +1/8   -1/8   +1/8   -1/8   +1/8   -1/8
+H|010⟩  (+1/√8)  +1/8   +1/8   -1/8   -1/8   +1/8   +1/8   -1/8   -1/8
+H|011⟩  (+1/√8)  +1/8   -1/8   -1/8   +1/8   +1/8   -1/8   -1/8   +1/8
+H|100⟩  (+1/√8)  +1/8   +1/8   +1/8   +1/8   -1/8   -1/8   -1/8   -1/8
-H|101⟩  (-1/√8)  -1/8   +1/8   -1/8   +1/8   +1/8   -1/8   +1/8   -1/8  ← oracle row
+H|110⟩  (+1/√8)  +1/8   +1/8   -1/8   -1/8   -1/8   -1/8   +1/8   +1/8
+H|111⟩  (+1/√8)  +1/8   -1/8   -1/8   +1/8   -1/8   +1/8   +1/8   -1/8
          ───────────────────────────────────────────────────────────────────
Net 4.1           +6/8   +2/8   -2/8   +2/8   +2/8   -2/8   +2/8   -2/8

Step 4.2 — Phase Flip (2|0⟩⟨0|−I)

Keep |000⟩ unchanged, negate all other states. This is the heart of inversion-about-the-mean.

         |000⟩  |001⟩  |010⟩  |011⟩  |100⟩  |101⟩  |110⟩  |111⟩
Post-Z:  +6/8   -2/8   +2/8   -2/8   -2/8   +2/8   -2/8   +2/8

Step 4.3 — Second H (back to computational basis)

                  |000⟩  |001⟩  |010⟩  |011⟩  |100⟩  |101⟩  |110⟩  |111⟩
Net R1 (exact):  +4/8√8 +4/8√8 +4/8√8 +4/8√8 +4/8√8 +20/8√8 +4/8√8 +4/8√8
Net R1 (decimal):  0.177  0.177  0.177  0.177  0.177   0.884  0.177  0.177

After Round 1, |101⟩ has been amplified from 0.354 to 0.884.

Round 2: Oracle → Diffusion

Step 5 — Oracle Uf

The oracle flips |101⟩ from +20/8√8 to −20/8√8. The 7 non-target states remain at +4/8√8. This large asymmetry drives even stronger constructive interference in the diffusion step.

Step 6.1 — First H

                      |000⟩   |001⟩   |010⟩   |011⟩   |100⟩   |101⟩   |110⟩   |111⟩
                      ──────────────────────────────────────────────────────────────────
+H|000⟩  (+4/8√8)    +4/64   +4/64   +4/64   +4/64   +4/64   +4/64   +4/64   +4/64
+H|001⟩  (+4/8√8)    +4/64   -4/64   +4/64   -4/64   +4/64   -4/64   +4/64   -4/64
+H|010⟩  (+4/8√8)    +4/64   +4/64   -4/64   -4/64   +4/64   +4/64   -4/64   -4/64
+H|011⟩  (+4/8√8)    +4/64   -4/64   -4/64   +4/64   +4/64   -4/64   -4/64   +4/64
+H|100⟩  (+4/8√8)    +4/64   +4/64   +4/64   +4/64   -4/64   -4/64   -4/64   -4/64
-H|101⟩  (-20/8√8)  -20/64  +20/64  -20/64  +20/64  +20/64  -20/64  +20/64  -20/64  ← oracle row
+H|110⟩  (+4/8√8)    +4/64   +4/64   -4/64   -4/64   -4/64   -4/64   +4/64   +4/64
+H|111⟩  (+4/8√8)    +4/64   -4/64   -4/64   +4/64   -4/64   +4/64   +4/64   -4/64
          ──────────────────────────────────────────────────────────────────────────────
Net 6.1              +8/64  +24/64  -24/64  +24/64  +24/64  -24/64  +24/64  -24/64

Step 6.2 — Phase Flip

         |000⟩   |001⟩   |010⟩   |011⟩   |100⟩   |101⟩   |110⟩   |111⟩
Post-Z:  +8/64  -24/64  +24/64  -24/64  -24/64  +24/64  -24/64  +24/64

Step 6.3 — Second H

                   |000⟩    |001⟩    |010⟩    |011⟩    |100⟩    |101⟩    |110⟩    |111⟩
Net R2 (exact):  -16/64√8 -16/64√8 -16/64√8 -16/64√8 -16/64√8 +176/64√8 -16/64√8 -16/64√8
Net R2 (decimal):  -0.088   -0.088   -0.088   -0.088   -0.088    +0.972   -0.088   -0.088

Success Probability after Round 2: P(|101⟩) = |0.972|² ≈ 94.5%

Round 2 is the optimal stopping point for 3-qubit Grover search — ⌊π/4 × √8⌋ = 2 iterations.

Round 3: The Overcooking Effect

Step 7 — Oracle Uf

With P(|101⟩) at 94.5%, one more iteration is one too many. The oracle flips |101⟩ from +176/64√8 to −176/64√8. The state vector has been rotated 2θ past its peak — a third diffusion step pushes it further away from the target, not closer.

Steps 8.1–8.3 — Diffusion

                   |000⟩    |001⟩    |010⟩    |011⟩    |100⟩    |101⟩    |110⟩    |111⟩
Net R3 (exact):  -448/512√8 (×7 non-target states)    +832/512√8 (target)
Net R3 (decimal):  -0.309   -0.309   -0.309   -0.309   -0.309    +0.575   -0.309   -0.309

P(|101⟩) = |0.575|² ≈ 33.0%

Summary: Amplitude Evolution Across Rounds

Round   Target |101⟩   Non-target states   P(|101⟩)
──────────────────────────────────────────────────────
Init       +0.354          +0.354            12.5%
R1         +0.884          +0.177            78.1%
R2         +0.972          -0.088            94.5%  ← optimal stop
R3         +0.575          -0.309            33.0%  ← overcooked

The state vector has rotated past the optimal angle. P(|101⟩) drops from 94.5% to 33.0% — a significant fall, but |101⟩ still has more than double the probability of any other state. The algorithm has not lost the answer; it has merely overshot the maximum.

Importantly, the target amplitude is still positive (+0.575) — the vector has not crossed zero, it has simply overshot past the maximum. The result comes directly from the Born rule: P(|101⟩) = |amplitude|² = |+0.575|² ≈ 0.330.

Quantum Series 2026 · Built with Qiskit 1.x

State	Definition	Correlation
\|Φ+⟩	(\|00⟩ + \|11⟩) / √2	Parallel
\|Φ−⟩	(\|00⟩ − \|11⟩) / √2	Orthogonal
\|Ψ+⟩	(\|01⟩ + \|10⟩) / √2	Parallel
\|Ψ−⟩	(\|01⟩ − \|10⟩) / √2	Orthogonal

DEV Community: Malcolm Low

Quantum Teleportation, and Why It Isn't Cloning

A quick word on no-cloning

Why teleportation isn't cloning

The complete circuit

The protocol in bra-ket and tensor form

Qiskit — classical feed-forward

No faster-than-light, and the takeaway

Move Your WordPress.com Domain to Cloudflare and Halve the Renewal

1. The cost case

2. The gotcha: transfer, not renew, and DNS moves first

3. Step by step

4. The redirect-only trap

5. After the transfer

Net result

Deutsch Algorithm Revisited: Quantum vs Classical Implementation in Qiskit

The Challenge

Complete Qiskit Implementation

Oracle functions

Classical approach: two queries required

Quantum approach: one query suffices

Running the comparison

Circuit Diagrams

Sample Output

Understanding the Quantum Advantage

Measurement Interpretation

Running the Code

Conclusion

Deutsch's Algorithm in Quantum Computing: The 4 Cases

The 4 Possible Functions

The General Oracle (U_f)

The Complete Circuit

Mathematical Proof

Final Measurement

Understanding Phase Kickback in Quantum Computing

1 · The CNOT Circuit and the Kickback Setup

2 · Full Derivation: |+⟩ ⊗ |−⟩ through CNOT

3 · Why Phase Kickback Matters

Introduction to Quantum Computing: Qubits, Hadamard Gates, and Superposition

1 · The Qubit

2 · The Hadamard Gate

3 · H² = I: Quantum Interference

4 · Single-Qubit Circuit: H–H–Measure

5 · Tensor Products and Multi-Qubit States

6 · Two-Qubit Superposition: H⊗H on |00⟩

7 · Interference in a Two-Qubit H–H Circuit

8 · The H⊗H Matrix and Why It Matters

Quantum Computing: CHSH Game Simulator and Bell's Inequality

1 · What Is the CHSH Game in Quantum Computing?

2 · Bell’s Inequality and the CHSH Value

3 · Measurement Angles and Quantum Correlation

🧪 4 · The Four Bell States

🎯 5 · CHSH Game Simulator Features

6 · Try the Quantum Entanglement Simulator

7 · Open Source Code on GitHub

The No-Cloning Theorem in Quantum Computing: Why You Can't Copy a Qubit

1 · What "cloning" would actually mean

2 · Proof I: linearity forbids it

3 · Proof II: unitarity forbids it

4 · "But doesn't CNOT copy a qubit?"

5 · Why this single theorem matters so much

6 · Watching a clone fail in Qiskit

Publishing to WordPress with Claude and the WordPress MCP Connector

1. Prerequisites

2. The Overall Workflow

3. How the WordPress MCP Connector Works

4. Problems Encountered — and How They Were Solved

Problem 1: WordPress strips <style> blocks entirely

Problem 2: WordPress strips SVG elements

Problem 3: <script> tags are blocked

Problem 4: API parameter case sensitivity

Problem 5: Duplicate categories and tags

Problem 6: &nbsp; spacing and Unicode box-drawing characters break alignment

Problem 7: Multi-wire circuits with vertical connectors require position:absolute

5. Step-by-Step: Posting via Claude and WordPress MCP

6. Installing the Workflow as a Reusable Skill

7. Quick Reference: Dos and Don'ts

Say Goodbye to Finder. Meet Marta.

What is Marta?

How to Install Marta

Problem 1: WordPress strips `<style>` blocks entirely

Problem 3: `<script>` tags are blocked

Problem 6: ` ` spacing and Unicode box-drawing characters break alignment

Problem 7: Multi-wire circuits with vertical connectors require `position:absolute`