CNOT and Quantum Vectors

2. CNOT, State Vectors, and the Jump to Quantum

CNOT’s classical skeleton

CNOT (controlled-NOT) takes a control bit C and a target bit T:

        T=0   T=1
C=0    [00]  [01]     T unchanged
C=1    [11]  [10]     T flipped

Read it as: control=0 → do nothing; control=1 → flip the target. Unlike OR/XOR/AND, CNOT isn’t a single-bit-output table — it’s a permutation of four states.

In update-rule form:

new T = C ⊕ T      (XOR of control and target, stored in target)
new C = C           (control passed through unchanged, for reversibility)

CNOT is XOR wearing a reversible-gate costume, plus a copy of C kept around so the operation can be undone.

Naming the four states

Numbering the grid’s corners in row-major order gives the standard convention used in every quantum textbook:

Grid cell (A,B)     →   Named state   →   Ket notation
(0,0)                →   State 1      →   |00⟩
(0,1)                →   State 2      →   |01⟩
(1,0)                →   State 3      →   |10⟩
(1,1)                →   State 4      →   |11⟩

With this numbering, CNOT becomes a permutation matrix:

        S1  S2  S3  S4
S1  [    1   0   0   0  ]
S2  [    0   1   0   0  ]
S3  [    0   0   0   1  ]
S4  [    0   0   1   0  ]

Each row is a one-hot vector showing where that state lands. States 1 and 2 are fixed; states 3 and 4 swap — the same “flip the bottom-right block” move visible in the original grid sketches.

AND / OR / XOR with the same indexing

State   Bits   AND  OR  XOR
  1     00      0    0   0
  2     01      0    1   1
  3     10      0    1   1
  4     11      1    1   0

AND and XOR only agree at State 1. OR’s column is AND’s column with States 2 and 3 also lit — the “everything except the origin” rule from Document 1, now written as a state list instead of a shaded grid.

Why AND/OR/XOR need only a state list, and CNOT needs a full matrix: AND/OR/XOR are irreversible — you can’t always recover A and B from the output — so they map state → bit, not state → state. CNOT is reversible: every input state must land on exactly one distinct output state, hence a permutation matrix instead of a column.

From state list to vector

A general 2-qubit state is a weighted mix of all four basis states — a column vector of amplitudes:

|ψ⟩ = [a, b, c, d]ᵀ    (a, b, c, d can be complex numbers)

Amplitudes are not probabilities. Squaring their magnitude gives one:

P(State 1) = |a|²
P(State 2) = |b|²
P(State 3) = |c|²
P(State 4) = |d|²

|a|² + |b|² + |c|² + |d|² = 1

CNOT’s 4×4 matrix acts on this vector by multiplication:

CNOT · [a, b, c, d]ᵀ = [a, b, d, c]ᵀ

It swaps the amplitude in slot 3 with the one in slot 4 — the same “flip the bottom block” move, now acting on complex numbers instead of shaded cells.

Entanglement

If the control qubit is a definite 0 or 1, CNOT behaves exactly like the classical table. If the control is in superposition — e.g. C = (|0⟩+|1⟩)/√2, T = |0⟩ — CNOT produces:

(|00⟩ + |11⟩) / √2      — the Bell state

This state cannot be factored back into “a state of C” times “a state of T.” The two qubits are entangled: measuring one instantly determines the other, even though neither had a fixed value beforehand. This is the mechanism behind why CNOT shows up in nearly every quantum circuit — it’s the standard tool for wiring qubits together.

Related Research: The quantum gate exploration here connects to Algebraic Balance: A Unified Mathematical Framework for Physical Systems which discusses stabilizer formalism and universal gate sets in quantum computing.