Quantum Circuits — Building Quantum Programs Step by Step

# quantum_circuit_sim.py
import numpy as np

class QuantumCircuit:
    def __init__(self, n_qubits):
        self.n_qubits = n_qubits
        self.dim = 2 ** n_qubits
        self.state = np.zeros(self.dim, dtype=complex)
        self.state[0] = 1  # Start in |0...0⟩
        self.gates = []

    def apply_gate(self, gate_matrix, target_qubits):
        """
        Apply a gate to specific qubits.
        gate_matrix: 2^k × 2^k unitary matrix (k = len(target_qubits))
        """
        self.gates.append((gate_matrix.copy(), target_qubits.copy()))
        # Build full operator using tensor products
        full_op = self._build_operator(gate_matrix, target_qubits)
        self.state = full_op @ self.state

    def _build_operator(self, gate_matrix, target_qubits):
        """Build the full 2^n × 2^n operator from a gate on specific qubits."""
        n = self.n_qubits
        k = len(target_qubits)

        # Start with identity
        op = np.array([[1]], dtype=complex)

        # Build qubit by qubit
        qubit_idx = 0
        for q in range(n):
            if qubit_idx < k and q == target_qubits[qubit_idx]:
                # This qubit is involved in the gate
                # Determine which part of the gate matrix applies
                slice_size = 2 ** (k - 1 - qubit_idx)
                # Actually, we need to handle this differently
                qubit_idx += 1
                continue
            else:
                op = np.kron(op, np.eye(2))

        # Simplified approach: use permutation
        return self._permutation_operator(gate_matrix, target_qubits)

    def _permutation_operator(self, gate_matrix, target_qubits):
        """Build the operator by permuting qubits."""
        n = self.n_qubits
        dim = 2 ** n
        full_op = np.eye(dim, dtype=complex)

        # For each basis state, apply the gate to the relevant qubits
        for i in range(dim):
            # Extract the bits involved
            bits = [(i >> (n - 1 - q)) & 1 for q in range(n)]
            target_bits = [bits[q] for q in target_qubits]

            # Convert target bits to index in gate matrix
            gate_idx = sum(b << (len(target_qubits) - 1 - j) for j, b in enumerate(target_bits))

            # Apply gate to this subset
            new_target_bits = self._apply_to_bits(target_bits, gate_matrix)
            new_bits = bits.copy()
            for j, q in enumerate(target_qubits):
                new_bits[q] = new_target_bits[j]

            # Reconstruct full index
            new_idx = sum(new_bits[n - 1 - q] << q for q in range(n))
            # Wait, this is getting complex. Let's use a simpler approach.

        return full_op

    def _apply_to_bits(self, bits, gate_matrix):
        """Apply gate to a list of bits and return new bits."""
        idx = sum(b << (len(bits) - 1 - j) for j, b in enumerate(bits))
        new_state = gate_matrix[:, idx]
        # Find the output index
        for j, val in enumerate(new_state):
            if abs(val) > 1e-10:
                out_bits = [(j >> (len(bits) - 1 - k)) & 1 for k in range(len(bits))]
                return out_bits
        return bits

    def measure_all(self, shots=1024):
        """Simulate measurement of all qubits."""
        probs = np.abs(self.state) ** 2
        outcomes = np.random.choice(self.dim, size=shots, p=probs)
        counts = {}
        for outcome in outcomes:
            bitstring = format(outcome, f'0{self.n_qubits}b')
            counts[bitstring] = counts.get(bitstring, 0) + 1
        return counts

    def __str__(self):
        return f"QuantumCircuit({self.n_qubits} qubits, {len(self.gates)} gates)"

# simple_circuit.py
import numpy as np

class SimpleCircuit:
    """A simple quantum circuit simulator with built-in gates."""

    GATES = {
        'H': (1/np.sqrt(2)) * np.array([[1, 1], [1, -1]], dtype=complex),
        'X': np.array([[0, 1], [1, 0]], dtype=complex),
        'Y': np.array([[0, -1j], [1j, 0]], dtype=complex),
        'Z': np.array([[1, 0], [0, -1]], dtype=complex),
    }

    def __init__(self, n_qubits):
        self.n_qubits = n_qubits
        self.dim = 2 ** n_qubits
        self.state = np.zeros(self.dim, dtype=complex)
        self.state[0] = 1.0

    def h(self, qubit):
        """Apply Hadamard to a single qubit."""
        self._apply_single(self.GATES['H'], qubit)

    def x(self, qubit):
        """Apply Pauli-X to a single qubit."""
        self._apply_single(self.GATES['X'], qubit)

    def y(self, qubit):
        """Apply Pauli-Y to a single qubit."""
        self._apply_single(self.GATES['Y'], qubit)

    def z(self, qubit):
        """Apply Pauli-Z to a single qubit."""
        self._apply_single(self.GATES['Z'], qubit)

    def cx(self, control, target):
        """Apply CNOT with given control and target qubits."""
        # Build CNOT on these specific qubits
        n = self.n_qubits
        op = np.eye(self.dim, dtype=complex)

        # Iterate over all basis states
        for i in range(self.dim):
            control_bit = (i >> (n - 1 - control)) & 1
            target_bit = (i >> (n - 1 - target)) & 1
            if control_bit == 1:
                # Flip target bit
                j = i ^ (1 << (n - 1 - target))
                op[i, i] = 0
                op[i, j] = 1
        self.state = op @ self.state

    def _apply_single(self, gate, qubit):
        """Apply a single-qubit gate to a specific qubit."""
        n = self.n_qubits
        dim = 2 ** n
        op = np.eye(dim, dtype=complex)

        for i in range(dim):
            bit = (i >> (n - 1 - qubit)) & 1
            other = i & ~(1 << (n - 1 - qubit))

            # Apply gate to this bit
            for new_bit in [0, 1]:
                if abs(gate[new_bit, bit]) > 1e-15:
                    j = other | (new_bit << (n - 1 - qubit))
                    op[j, i] = gate[new_bit, bit]
        self.state = op @ self.state

    def measure(self, shots=1024):
        """Measure all qubits and return counts."""
        probs = np.abs(self.state) ** 2
        outcomes = np.random.choice(self.dim, size=shots, p=probs)
        counts = {}
        for outcome in outcomes:
            bits = format(outcome, f'0{self.n_qubits}b')
            counts[bits] = counts.get(bits, 0) + 1
        return counts

    def state_vector(self):
        return self.state.copy()

# bell_state_circuit.py
import numpy as np
from simple_circuit import SimpleCircuit

# Create a 2-qubit circuit
qc = SimpleCircuit(2)

print("=== Bell State Circuit ===")
print("Initial: |00⟩")

# Step 1: Hadamard on qubit 0
qc.h(0)
print("After H on q0: creating superposition")

# Step 2: CNOT with control=0, target=1
qc.cx(0, 1)
print("After CNOT: entangling q0 and q1")

# Show final state
state = qc.state_vector()
print(f"\nFinal state vector: {state}")

# Verify it's the Bell state
print(f"Expected: (|00⟩ + |11⟩)/√2")

# Measure
counts = qc.measure(4096)
print(f"\nMeasurement results (4096 shots):")
for bits, count in sorted(counts.items()):
    print(f"  |{bits}⟩: {count} ({count/4096*100:.1f}%)")

# ghz_circuit.py
from simple_circuit import SimpleCircuit

# Create a 3-qubit GHZ state
qc = SimpleCircuit(3)

print("=== GHZ State Circuit ===")

# H on qubit 0, then cascading CNOTs
qc.h(0)
qc.cx(0, 1)
qc.cx(0, 2)

state = qc.state_vector()
print(f"Final state: {state}")

counts = qc.measure(4096)
print(f"\nMeasurement results (4096 shots):")
for bits, count in sorted(counts.items()):
    if count > 0:
        print(f"  |{bits}⟩: {count} ({count/4096*100:.1f}%)")

# quantum_rng.py
from simple_circuit import SimpleCircuit
import numpy as np

def quantum_random_bit():
    """Generate a single random bit using quantum superposition."""
    qc = SimpleCircuit(1)
    qc.h(0)  # Create superposition
    counts = qc.measure(1)
    outcome = list(counts.keys())[0]
    return int(outcome)

def quantum_random_integer(min_val, max_val):
    """Generate a random integer in a range using quantum randomness."""
    range_size = max_val - min_val + 1
    num_bits = int(np.ceil(np.log2(range_size)))
    n_qubits = num_bits
    qc = SimpleCircuit(n_qubits)

    # Apply Hadamard to all qubits
    for q in range(n_qubits):
        qc.h(q)

    counts = qc.measure(1)
    outcome = int(list(counts.keys())[0], 2)
    return min_val + (outcome % range_size)

print("=== Quantum Random Number Generator ===")
print("10 random bits:")
bits = [quantum_random_bit() for _ in range(10)]
print(f"  {''.join(str(b) for b in bits)}")

print("\n10 random integers (1-100):")
nums = [quantum_random_integer(1, 100) for _ in range(10)]
print(f"  {nums}")

def teleport_circuit():
    """Build and simulate a quantum teleportation circuit.
    
    Qubit 0: message state (to be teleported)
    Qubit 1: Alice's half of Bell pair
    Qubit 2: Bob's half of Bell pair
    
    Outcome: Qubit 2 should end up in the original state of qubit 0
    """
    pass