Struct Statevector 

pub struct Statevector {
    pub amplitudes: Vec<(f64, f64)>,
    pub n_qubits: usize,
}

N-qubit statevector: stores 2^n complex amplitudes as (re, im) pairs.

Qubit indexing convention: qubit 0 is the least significant bit. So the basis state |b_{n-1} … b_1 b_0⟩ corresponds to index b_0 + 2*b_1 + ... + 2^(n-1)*b_{n-1}.

Fields

amplitudes: Vec<(f64, f64)>

Complex amplitudes: amplitudes[k] = (re, im) for basis state |k⟩

n_qubits: usize

Number of qubits

Implementations

impl Statevector

pub fn zero_state(n: usize) -> QcResult<Self>

Create the zero state |0…0⟩ for n qubits.

pub fn norm_squared(&self) -> f64

Total norm squared: should remain 1.0 after any unitary operation.

pub fn norm(&self) -> f64

Total norm (Euclidean).

pub fn apply_hadamard(&mut self, qubit: usize) -> QcResult<()>

Apply Hadamard gate to qubit.

H = (1/√2) [[1, 1], [1, -1]]

Pairs basis states that differ only in bit qubit.

pub fn apply_rz(&mut self, qubit: usize, theta: f64) -> QcResult<()>

Apply Rz(θ) gate to qubit.

Rz(θ) = [[e^{-iθ/2}, 0], [0, e^{iθ/2}]]

States with bit qubit = 0 get phase e^{-iθ/2}; states with bit = 1 get phase e^{+iθ/2}.

pub fn apply_rx(&mut self, qubit: usize, theta: f64) -> QcResult<()>

Apply Rx(θ) gate to qubit.

Rx(θ) = [[cos(θ/2), -i·sin(θ/2)], [-i·sin(θ/2), cos(θ/2)]]

pub fn apply_ry(&mut self, qubit: usize, theta: f64) -> QcResult<()>

Apply Ry(θ) gate to qubit.

Ry(θ) = [[cos(θ/2), -sin(θ/2)], [sin(θ/2), cos(θ/2)]]

pub fn apply_cnot(&mut self, control: usize, target: usize) -> QcResult<()>

Apply CNOT gate with control qubit and target qubit.

Flips the target qubit when the control qubit is |1⟩.

pub fn apply_rzz(&mut self, q1: usize, q2: usize, theta: f64) -> QcResult<()>

Apply Rzz(θ) gate to qubits q1 and q2.

Rzz(θ) = e^{-iθ/2 · Z⊗Z}

For basis state |b1, b2⟩:

• If b1 XOR b2 = 0 (same bits): phase e^{-iθ/2}
• If b1 XOR b2 = 1 (different bits): phase e^{+iθ/2}

pub fn expectation_zz(&self, q1: usize, q2: usize) -> QcResult<f64>

Compute ⟨Z_i Z_j⟩ expectation value.

Z_i Z_j has eigenvalue +1 when bits i and j are equal, -1 otherwise.

pub fn expectation_z(&self, qubit: usize) -> QcResult<f64>

Compute ⟨Z_k⟩ expectation value.

Z_k has eigenvalue +1 when bit k is 0, and -1 when bit k is 1.

pub fn most_probable_state(&self) -> usize

Return the index of the basis state with the highest probability.

pub fn index_to_bits(&self, idx: usize) -> Vec<bool>

Decode a basis state index into a bitstring (qubit 0 = LSB).

impl Statevector

pub fn apply_x(&mut self, qubit: usize) -> QcResult<()>

Apply Pauli X (bit flip) to qubit.

pub fn apply_y(&mut self, qubit: usize) -> QcResult<()>

Apply Pauli Y to qubit.

Y = [[0, -i], [i, 0]] Y|0⟩ = i|1⟩, Y|1⟩ = -i|0⟩

pub fn apply_z(&mut self, qubit: usize) -> QcResult<()>

Apply Pauli Z (phase flip) to qubit.

Z|0⟩ = |0⟩, Z|1⟩ = -|1⟩

Trait Implementations

impl Clone for Statevector

fn clone(&self) -> Statevector

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Statevector

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.