Quantum Computing for Developers: Complete Guide

# 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')