Introduction to Quantum Computing: Beyond Classical Bits

|0⟩ = [1]  (0 state)
|1⟩ = [0]  (1 state)

Superposition: α|0⟩ + β|1⟩ where |α|² + |β|² = 1

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

Example: 50/50 superposition
|ψ⟩ = 1/√2 |0⟩ + 1/√2 |1⟩

Bell State: |Φ+⟩ = 1/√2 (|00⟩ + |11⟩)

from qiskit import QuantumCircuit

# Create circuit with 1 qubit
qc = QuantumCircuit(1)

# Apply Hadamard gate
qc.h(0)

# Measure
qc.measure_all()

# Draw circuit
print(qc)

from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
import numpy as np

# Hadamard gate effect
qc = QuantumCircuit(1)
qc.h(0)

state = Statevector(qc)
print(f"State after H: {state}")  # 1/√2 (|0⟩ + |1⟩)

# Bloch sphere representation
theta = 2 * np.arccos(np.sqrt(0.5))  # 90 degrees
print(f"Bloch sphere angle: {np.degrees(theta):.0f}° from |0⟩")

def bell_state_circuit():
    """Create a Bell state: 1/√2 (|00⟩ + |11⟩)"""
    qc = QuantumCircuit(2, 2)
    qc.h(0)      # First qubit into superposition
    qc.cx(0, 1)  # CNOT: entangle both qubits
    qc.measure([0, 1], [0, 1])
    return qc

bell = bell_state_circuit()
print(bell.draw())

# Bell state measurement outcomes
# Result: 50% |00⟩, 50% |11⟩ (perfectly correlated)

def toffoli_and_gate(a, b):
    """Implement classical AND using Toffoli gate."""
    qc = QuantumCircuit(3, 1)
    # Initialize inputs
    if a:
        qc.x(0)
    if b:
        qc.x(1)
    # Toffoli
    qc.ccx(0, 1, 2)
    # Measure result
    qc.measure(2, 0)
    return qc

# AND(1, 1) = 1
circuit = toffoli_and_gate(1, 1)
print("Toffoli AND(1,1):", circuit.draw())

def quantum_circuit_demo():
    """Demonstrate quantum circuit execution."""
    from qiskit import QuantumCircuit, transpile
    from qiskit_aer import AerSimulator

    # 3-qubit circuit
    qc = QuantumCircuit(3, 3)

    # Layer 1: Superposition
    qc.h(0)
    qc.h(1)

    # Layer 2: Entanglement
    qc.cx(0, 2)
    qc.cx(1, 2)

    # Layer 3: Phase
    qc.t(0)
    qc.s(1)

    # Measure all
    qc.measure_all()

    # Simulate 1000 shots
    simulator = AerSimulator()
    compiled = transpile(qc, simulator)
    result = simulator.run(compiled, shots=1000).result()
    counts = result.get_counts()

    print(f"Measurement distribution: {counts}")
    # Qubits exhibit correlated probabilities
    # due to entanglement

quantum_circuit_demo()

def generate_bell_state(bell_type='phi_plus'):
    """Generate any of the four Bell states."""
    qc = QuantumCircuit(2)

    if bell_type == 'phi_plus':    # |Φ+⟩ = 1/√2(|00⟩ + |11⟩)
        qc.h(0); qc.cx(0, 1)
    elif bell_type == 'phi_minus':  # |Φ-⟩ = 1/√2(|00⟩ - |11⟩)
        qc.h(0); qc.cx(0, 1); qc.z(0)
    elif bell_type == 'psi_plus':   # |Ψ+⟩ = 1/√2(|01⟩ + |10⟩)
        qc.h(0); qc.cx(0, 1); qc.x(0)
    elif bell_type == 'psi_minus':  # |Ψ-⟩ = 1/√2(|01⟩ - |10⟩)
        qc.h(0); qc.cx(0, 1); qc.x(0); qc.z(0)

    return qc

bell = generate_bell_state('phi_plus')
print(bell.draw())

def quantum_advantage_example():
    """Demonstrate a problem where quantum may excel."""
    # Classically hard: sampling from random circuit
    # or simulating quantum chemistry
    from qiskit import QuantumCircuit
    from qiskit_aer import AerSimulator

    # Random circuit sampling (Google supremacy benchmark)
    n_qubits = 20
    depth = 20
    qc = QuantumCircuit(n_qubits, n_qubits)

    for d in range(depth):
        for q in range(n_qubits):
            import random
            gate = random.choice(['h', 'x', 'y', 'z', 't'])
            getattr(qc, gate)(q)
        for q in range(0, n_qubits - 1, 2):
            qc.cx(q, q + 1)

    qc.measure_all()
    print(f"Circuit depth: {depth}, Qubits: {n_qubits}")
    print("Classical simulation cost: O(2^n)")

quantum_advantage_example()

from qiskit_ibm_runtime import QiskitRuntimeService

def run_on_ibm_quantum():
    """Run a circuit on real IBM quantum hardware."""
    service = QiskitRuntimeService()
    backend = service.least_busy(
        operational=True,
        simulator=False,
        min_num_qubits=5
    )
    print(f"Using backend: {backend.name}")
    print(f"Queue size: {backend.status().pending_jobs}")

    qc = QuantumCircuit(2)
    qc.h(0)
    qc.cx(0, 1)
    qc.measure_all()

    from qiskit import transpile
    compiled = transpile(qc, backend)
    job = backend.run(compiled, shots=1024)
    print(f"Job ID: {job.job_id()}")
    result = job.result()
    print(f"Counts: {result.get_counts()}")