Quantum Computing for Developers: Complete Guide

┌─────────────────────────────────────────────────────────────────┐
│              Classical vs Quantum Computing                         │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   CLASSICAL BIT                  QUANTUM QUBIT                  │
│   ─────────────                 ────────────────                  │
│                                                                  │
│       0    or    1              |0⟩   and   |1⟩  (superposition)│
│                                                                  │
│       ○                         ●──○                            │
│                               /    \                              │
│   Deterministic               Probabilistic                       │
│                                                                  │
│   ──────────────────          ────────────────────                │
│                                                                  │
│   Operations:                 Operations:                         │
│   • AND, OR, NOT             • Hadamard (H)                    │
│   • NAND                     • Pauli (X, Y, Z)                 │
│   • XOR                      • CNOT                             │
│   • CCNOT                    • Phase (S, T)                     │
│                              • Measurement                       │
│                                                                  │
│   Example: 8 bits = 1 state    Example: 8 qubits = 256 states   │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

# Quantum circuit visualization
# |0⟩ → H → X → M
# Result: 50% chance |0⟩, 50% chance |1⟩

namespace QuantumHelloWorld {
    
    @EntryPoint()
    operation HelloQ() : Result {
        // Allocate a single qubit
        use q = Qubit();
        
        // Apply Hadamard gate to create superposition
        H(q);
        
        // Measure the qubit
        let result = M(q);
        
        // Return measurement result
        return result;
    }
}

namespace QuantumBasics {
    
    // Quantum teleportation
    operation Teleport(
        message : Qubit,
        target : Qubit,
        helper : Qubit
    ) : () {
        // Create entanglement between target and helper
        CNOT(target, helper);
        H(target);
        
        // Bell measurement
        CNOT(message, target);
        H(message);
        let m1 = M(message);
        let m2 = M(target);
        
        // Correction based on measurement
        if (m2 == One) { Z(target); }
        if (m1 == One) { X(target); }
        
        // Entangle helper and target (effectively teleport)
        CNOT(helper, target);
        H(helper);
    }
}

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

# Create a quantum circuit with 2 qubits
qc = QuantumCircuit(2)

# Apply Hadamard gate to first qubit (create superposition)
qc.h(0)

# Apply CNOT (entangle qubits)
qc.cx(0, 1)

# Apply X gate to second qubit
qc.x(1)

# Draw circuit
print(qc.draw())

# Execute on simulator
from qiskit import transpile
from qiskit_aer import AerSimulator

simulator = AerSimulator()
compiled = transpile(qc, simulator)
result = simulator.run(compiled).result()

# Get counts
counts = result.get_counts()
print(f"Measurement results: {counts}")

# Plot histogram
plot_histogram(counts)

def qft_rotations(circuit, n):
    """Apply QFT rotations."""
    if n == 0:
        return
    
    circuit.h(n - 1)
    for qubit in range(n - 1):
        circuit.cp(np.pi / 2**(n - 1 - qubit), qubit, n - 1)

def qft(circuit, n):
    """Quantum Fourier Transform."""
    for i in range(n):
        qft_rotations(circuit, n - i)
    
    # Swap qubits to reverse order
    for i in range(n // 2):
        circuit.swap(i, n - 1 - i)

# Create and apply QFT
qft_circuit = QuantumCircuit(4)
qft(qft_circuit, 4)
print(qft_circuit.draw())

def grovers_algorithm(n_qubits, marked_state):
    """
    Grover's search for marked quantum state.
    For n qubits, finds marked state in O(sqrt(2^n)) steps.
    """
    qc = QuantumCircuit(n_qubits, n_qubits)
    
    # Step 1: Initialize superposition
    for i in range(n_qubits):
        qc.h(i)
    
    # Step 2: Oracle + Diffusion (repeated)
    iterations = int(np.pi/4 * np.sqrt(2**n_qubits))
    
    for _ in range(iterations):
        # Oracle: mark the target state
        for i, bit in enumerate(marked_state):
            if bit == '0':
                qc.x(i)
        
        # Multi-controlled Z
        qc.h(n_qubits - 1)
        qc.mcx(list(range(n_qubits - 1)), n_qubits - 1)
        qc.h(n_qubits - 1)
        
        # Undo X gates
        for i, bit in enumerate(marked_state):
            if bit == '0':
                qc.x(i)
        
        # Diffusion operator
        for i in range(n_qubits):
            qc.h(i)
        for i in range(n_qubits):
            qc.x(i)
        
        qc.h(n_qubits - 1)
        qc.mcx(list(range(n_qubits - 1)), n_qubits - 1)
        qc.h(n_qubits - 1)
        
        for i in range(n_qubits):
            qc.x(i)
        for i in range(n_qubits):
            qc.h(i)
    
    # Step 3: Measure
    qc.measure(range(n_qubits), range(n_qubits))
    
    return qc

# Example: Search for |101⟩
circuit = grovers_algorithm(3, '101')

import cirq
import numpy as np

def cirq_teleportation():
    """Quantum teleportation circuit in Cirq."""
    alice, bob, message = cirq.LineQubit.range(3)

    circuit = cirq.Circuit([
        # Prepare message qubit in |1⟩
        cirq.X(message),

        # Create Bell pair between Alice and Bob
        cirq.H(alice),
        cirq.CNOT(alice, bob),

        # Alice's Bell measurement
        cirq.CNOT(message, alice),
        cirq.H(message),

        # Measure Alice's qubits
        cirq.measure(message, key='m1'),
        cirq.measure(alice, key='m2'),

        # Bob's corrections (classical feed-forward)
        cirq.CNOT(alice, bob),
        cirq.CZ(message, bob),
    ])

    simulator = cirq.Simulator()
    result = simulator.run(circuit, repetitions=100)
    print(f"Teleportation results: {result.histogram(key='m2')}")
    return circuit

cirq_teleportation()

import braket.aws as braket
from braket.circuits import Circuit

def run_on_braket():
    """Run circuit on AWS Braket devices."""
    aws_device = braket.AwsDevice("arn:aws:braket:us-west-1::device/qpu/ionq/ionQaria")

    circuit = Circuit()
    circuit.h(0)
    circuit.cnot(0, 1)
    circuit.state_vector()

    task = aws_device.run(circuit, shots=1000)
    result = task.result()
    print(f"IonQ results: {result.measurement_counts}")

from qiskit_aer.noise import NoiseModel
from qiskit_aer.noise.errors import depolarizing_error, thermal_relaxation_error

def create_realistic_noise_model():
    """Create noise model matching real IBM hardware."""
    noise_model = NoiseModel()

    # Depolarizing error on single-qubit gates
    depol_1q = depolarizing_error(0.001, 1)
    noise_model.add_all_qubit_quantum_error(depol_1q, ['h', 'x', 'y', 'z', 's', 't'])

    # Depolarizing error on two-qubit gates (higher)
    depol_2q = depolarizing_error(0.01, 2)
    noise_model.add_all_qubit_quantum_error(depol_2q, ['cx', 'cz'])

    # Thermal relaxation
    t1 = 100e-6  # 100 μs
    t2 = 70e-6   # 70 μs
    relax_err = thermal_relaxation_error(t1, t2, 0.1)
    noise_model.add_all_qubit_quantum_error(relax_err, ['measure'])

    return noise_model

def compare_noisy_vs_ideal():
    """Compare circuit behavior with and without noise."""
    from qiskit import QuantumCircuit, transpile
    from qiskit_aer import AerSimulator

    qc = QuantumCircuit(3, 3)
    for i in range(3):
        qc.h(i)
    qc.cx(0, 1)
    qc.cx(1, 2)
    qc.measure_all()

    # Ideal simulation
    ideal = AerSimulator()
    ideal_result = ideal.run(transpile(qc, ideal), shots=1000).result()

    # Noisy simulation
    noise_model = create_realistic_noise_model()
    noisy = AerSimulator(noise_model=noise_model)
    noisy_result = noisy.run(transpile(qc, noisy), shots=1000).result()

    print(f"Ideal: {ideal_result.get_counts()}")
    print(f"Noisy: {noisy_result.get_counts()}")

from qiskit.circuit.library import EfficientSU2
from qiskit_algorithms import VQE
from qiskit_algorithms.optimizers import COBYLA

def run_vqe():
    """Find ground state energy of H2 molecule."""
    from qiskit_nature.second_q.drivers import PySCFDriver
    from qiskit_nature.second_q.mappers import JordanWignerMapper
    from qiskit_nature.second_q.algorithms import GroundStateEigensolver

    driver = PySCFDriver(atom='H 0 0 0; H 0 0 0.735')
    problem = driver.run()

    mapper = JordanWignerMapper()
    ansatz = EfficientSU2(problem.num_spatial_orbitals * 2, reps=3)

    optimizer = COBYLA(maxiter=100)
    vqe = VQE(ansatz, optimizer, quantum_instance=AerSimulator())

    solver = GroundStateEigensolver(mapper, vqe)
    result = solver.solve(problem)

    print(f"Ground state energy: {result.eigenvalues[0]:.6f} Hartree")
    return result

def maxcut_qaoa(graph_edges, p_layers=2):
    """Solve MaxCut problem using QAOA."""
    from qiskit import QuantumCircuit
    from qiskit_algorithms import QAOA
    from qiskit_optimization.applications import Maxcut

    # Create MaxCut problem
    maxcut = Maxcut(graph_edges)
    qp = maxcut.to_quadratic_program()

    # QAOA configuration
    optimizer = COBYLA(maxiter=200)
    qaoa = QAOA(optimizer, reps=p_layers, quantum_instance=AerSimulator())

    result = qaoa.compute_minimum_eigenvalue(qp.to_ising()[1])
    best_cut = maxcut.interpret(result)

    print(f"Best cut found: {best_cut}")
    return best_cut

# Example: MaxCut on a 4-node graph
edges = [(0, 1), (1, 2), (2, 3), (3, 0), (0, 2)]
solution = maxcut_qaoa(edges, p_layers=2)

class HybridQuantumClassicalOptimizer:
    def __init__(self, quantum_backend, classical_optimizer):
        self.quantum = quantum_backend
        self.classical = classical_optimizer
        self.history = []

    def optimize(self, cost_function, initial_params, max_iter=50):
        params = initial_params.copy()

        for iteration in range(max_iter):
            # Quantum step: evaluate cost function
            cost = self.quantum_evaluate(cost_function, params)
            self.history.append((params.copy(), cost))

            # Classical step: update parameters
            gradient = self.compute_gradient(cost_function, params)
            params = self.classical.step(params, gradient, cost)

            if iteration % 10 == 0:
                print(f"Iteration {iteration}: cost = {cost:.6f}")

        return params, self.history

def list_available_quantum_devices():
    """List available quantum devices from IBM."""
    from qiskit_ibm_runtime import QiskitRuntimeService

    service = QiskitRuntimeService(channel='ibm_quantum')
    backends = service.backends()

    print("Available quantum devices:")
    for backend in backends:
        if not backend.configuration().simulator:
            print(f"  {backend.name}: {backend.configuration().num_qubits}"
                  f" qubits, queue: {backend.status().pending_jobs}")