# Creating a superposition state in Qiskit
from qiskit import QuantumCircuit

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

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

# The qubit is now in superposition: 1/√2(|0⟩ + |1⟩)

# Creating different superposition states
qc = QuantumCircuit(1)

# Starting with |0⟩
qc.reset(0)

# Equal superposition
qc.h(0)  # 1/√2(|0⟩ + |1⟩)

# Biased superposition favoring |1⟩
qc.reset(0)
qc.ry(2.0, 0)  # Rotation around Y-axis changes amplitudes

# Creating an entangled Bell pair in Qiskit
from qiskit import QuantumCircuit

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

# Put first qubit in superposition
qc.h(0)

# Entangle using CNOT gate
qc.cx(0, 1)

# Now qubits are in the Bell state: 1/√2(|00⟩ + |11⟩)

# Creating different types of entangled states
qc = QuantumCircuit(2)

# Bell state Φ+ = 1/√2(|00⟩ + |11⟩)
qc.h(0)
qc.cx(0, 1)

# Bell state Φ- = 1/√2(|00⟩ - |11⟩)
qc.reset_all()
qc.h(0)
qc.cx(0, 1)
qc.z(1)

# Creating GHZ state with three qubits: 1/√2(|000⟩ + |111⟩)
qc = QuantumCircuit(3)
qc.h(0)
qc.cx(0, 1)
qc.cx(0, 2)

# Demonstrating interference in Qiskit
from qiskit import QuantumCircuit

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

# Apply Hadamard to get superposition
qc.h(0)  # 1/√2(|0⟩ + |1⟩)

# Apply Hadamard again
qc.h(0)  # Back to |0⟩ due to interference

# The second Hadamard causes interference that cancels out,
# deterministically returning the qubit to |0⟩

# Quantum phase estimation uses interference to determine eigenvalues
from qiskit import QuantumCircuit

# Simplified quantum Fourier transform (QFT) example
qc = QuantumCircuit(3)
# Put all qubits in superposition
for qubit in range(3):
    qc.h(qubit)
    
# Add phase shifts
qc.p(3.14/2, 1)
qc.p(3.14/4, 2)

# Inverse QFT uses interference to extract phase information
# (simplified here)
qc.h(0)
qc.cx(0, 1)
qc.h(1)
qc.cx(0, 2)
qc.cx(1, 2)
qc.h(2)

# Qiskit installation (first time only)
!pip install qiskit

# Basic imports
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
import matplotlib.pyplot as plt

# Create quantum circuit
qc = QuantumCircuit(1, 1)   # 1 qubit, 1 measurement bit
qc.h(0)                     # Hadamard gate to create superposition
qc.measure(0, 0)            # Measure qubit 0 to classical bit 0

# Run on simulator
backend = Aer.get_backend('qasm_simulator')
job = execute(qc, backend=backend, shots=1000)
result = job.result()
counts = result.get_counts()

# Visualize output
print("Measurement results:", counts)
plot_histogram(counts)
plt.show()

from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
import matplotlib.pyplot as plt

qc = QuantumCircuit(2, 2)
qc.h(0)         # Put first qubit in superposition
qc.cx(0, 1)     # Create entanglement
qc.measure([0, 1], [0, 1])

backend = Aer.get_backend('qasm_simulator')
result = execute(qc, backend, shots=1000).result()
counts = result.get_counts()

print("Entanglement measurement results:", counts)
plot_histogram(counts)
plt.show()

# Simplified conceptual implementation of Shor's Algorithm
from qiskit import QuantumCircuit, Aer, execute
import numpy as np

def simplified_shor_factoring(N, a):
    """
    Very simplified conceptual representation of Shor's algorithm
    for factoring N using guess a (where 1 < a < N)
    """
    # Step 1: Create quantum circuit for period finding
    # (In a real implementation, this would be much more complex)
    qc = QuantumCircuit(8, 4)  # 8 qubits, 4 classical bits
    
    # Step 2: Initialize superposition
    for qubit in range(4):
        qc.h(qubit)
    
    # Step 3: Implement modular exponentiation
    # (This is a placeholder - actual implementation is complex)
    for i, qubit in enumerate(range(4)):
        if a % 2**i == 0:
            qc.cx(qubit, qubit+4)  
    
    # Step 4: Quantum Fourier Transform
    for qubit in range(4):
        qc.h(qubit)
    
    # Step 5: Measure
    qc.measure(range(4), range(4))
    
    # Execute on simulator
    simulator = Aer.get_backend('qasm_simulator')
    result = execute(qc, simulator, shots=1000).result()
    counts = result.get_counts()
    
    # Step 6: Classical post-processing
    # Find the period r from measurement results (simplified)
    most_common = max(counts, key=counts.get)
    measured_value = int(most_common, 2)
    
    # Calculate factors (simplified)
    r = 2 * measured_value  # This is a simplification
    if r % 2 == 0:
        factor1 = np.gcd(a**(r//2) + 1, N)
        factor2 = np.gcd(a**(r//2) - 1, N)
        return factor1, factor2
    return "Failed to find factors"

# Example usage (conceptual only)
N = 15  # Number to factor
a = 7   # Coprime to N
print(simplified_shor_factoring(N, a))

# Simplified implementation of Grover's Algorithm
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
import numpy as np
import matplotlib.pyplot as plt

def grover_search(marked_item, total_items):
    """
    Implementation of Grover's search for finding a marked item
    in an unsorted database.
    
    Args:
        marked_item: Item we're searching for (as an integer)
        total_items: Total number of items in database
    
    Returns:
        Quantum circuit with Grover's algorithm
    """
    # Calculate required qubits
    n = int(np.ceil(np.log2(total_items)))
    
    # Create quantum circuit
    qc = QuantumCircuit(n, n)
    
    # Step 1: Initialize superposition
    qc.h(range(n))
    
    # Number of iterations (optimal for single marked item)
    iterations = int(np.pi/4 * np.sqrt(total_items))
    
    for _ in range(iterations):
        # Step 2: Oracle - mark the solution
        # (In a real implementation, this would encode the search problem)
        # Here we just flip the phase of the marked item state
        marked_binary = format(marked_item, f'0{n}b')
        qc.barrier()
        
        # Implement simple oracle by applying Z to marked state
        # (For simplicity, we use X gates to flip bits where marked_binary has '0')
        for qubit, bit in enumerate(reversed(marked_binary)):
            if bit == '0':
                qc.x(qubit)
        
        # Multi-controlled Z gate (simplification)
        if n > 1:
            qc.h(n-1)
            qc.mcx(list(range(n-1)), n-1)
            qc.h(n-1)
        else:
            qc.z(0)
        
        # Flip bits back
        for qubit, bit in enumerate(reversed(marked_binary)):
            if bit == '0':
                qc.x(qubit)
        
        # Step 3: Diffusion operator (amplification)
        qc.barrier()
        qc.h(range(n))
        qc.x(range(n))
        
        # Apply controlled-Z
        if n > 1:
            qc.h(n-1)
            qc.mcx(list(range(n-1)), n-1)
            qc.h(n-1)
        else:
            qc.z(0)
        
        qc.x(range(n))
        qc.h(range(n))
    
    # Measure the result
    qc.measure(range(n), range(n))
    
    return qc

# Example usage
marked_item = 6  # The item we're searching for
total_items = 8  # Total items in database

# Create and run the circuit
qc = grover_search(marked_item, total_items)
simulator = Aer.get_backend('qasm_simulator')
result = execute(qc, simulator, shots=1024).result()
counts = result.get_counts()

# Display results
print(f"Searching for item {marked_item} among {total_items} items:")
print(f"Measurement results: {counts}")
most_common = max(counts, key=counts.get)
print(f"Found item: {int(most_common, 2)}")

# Implementation of Quantum Fourier Transform
from qiskit import QuantumCircuit
import numpy as np

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

def swap_registers(circuit, n):
    """Swap qubits for the correct output order"""
    for qubit in range(n//2):
        circuit.swap(qubit, n-qubit-1)
    return circuit

def qft(circuit, n):
    """Quantum Fourier Transform on n qubits"""
    qft_rotations(circuit, n)
    swap_registers(circuit, n)
    return circuit

# Example: 4-qubit QFT circuit
qc = QuantumCircuit(4)

# Prepare some non-trivial state
qc.x(0)
qc.x(2)

# Apply QFT
qft(qc, 4)

print("QFT Circuit:")
print(qc)

# Techniques for addressing quantum noise
from qiskit import QuantumCircuit
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter

def measurement_error_mitigation():
    """
    Demonstrate measurement error mitigation technique
    """
    # Create a calibration circuit
    qc = QuantumCircuit(2)
    
    # Generate calibration circuits
    meas_calibs, state_labels = complete_meas_cal(qubit_list=[0, 1], qr=qc.qregs[0])
    
    # Execute calibration circuits
    # In a real scenario, you would run these on actual quantum hardware
    from qiskit import Aer, execute
    simulator = Aer.get_backend('qasm_simulator')
    # Add artificial measurement error
    from qiskit.providers.aer.noise import NoiseModel
    noise_model = NoiseModel()
    noise_model.add_readout_error([[0.95, 0.05], [0.05, 0.95]], [0])
    noise_model.add_readout_error([[0.93, 0.07], [0.07, 0.93]], [1])
    
    cal_results = execute(meas_calibs, simulator, 
                         shots=1000, 
                         noise_model=noise_model).result()
    
    # Build the measurement error mitigator
    meas_fitter = CompleteMeasFitter(cal_results, state_labels)
    
    # Create a test circuit
    test_qc = QuantumCircuit(2, 2)
    test_qc.h(0)
    test_qc.cx(0, 1)
    test_qc.measure([0,1], [0,1])
    
    # Execute with noise
    test_results = execute(test_qc, simulator, 
                          shots=1000, 
                          noise_model=noise_model).result()
    test_counts = test_results.get_counts()
    
    # Apply measurement error mitigation
    mitigated_counts = meas_fitter.filter.apply(test_counts)
    
    print("Original noisy counts:", test_counts)
    print("Mitigated counts:", mitigated_counts)
    
    return mitigated_counts

# Run measurement error mitigation example
# measurement_error_mitigation()

# Techniques for debugging quantum circuits
from qiskit import QuantumCircuit, Aer, transpile
from qiskit.visualization import plot_state_city, plot_bloch_multivector

def quantum_circuit_debugging():
    """
    Demonstrate debugging techniques for quantum circuits
    """
    # Create a circuit with a bug
    qc = QuantumCircuit(2)
    qc.h(0)
    # Intentional "bug": missing CNOT gate for entanglement
    # qc.cx(0, 1)  # This line is commented out to create a bug
    
    # Debug technique 1: Statevector simulation
    simulator = Aer.get_backend('statevector_simulator')
    job = simulator.run(transpile(qc, simulator))
    result = job.result()
    statevector = result.get_statevector()
    
    print("Statevector after circuit execution:")
    print(statevector)
    # The statevector shows no entanglement (|+0⟩ state instead of Bell state)
    
    # Debug technique 2: Density matrix visualization
    # plot_state_city(statevector)
    
    # Debug technique 3: Bloch sphere visualization
    # plot_bloch_multivector(statevector)
    
    # Debug technique 4: Circuit transpilation inspection
    transpiled_qc = transpile(qc, basis_gates=['u1', 'u2', 'u3', 'cx'])
    print("Transpiled circuit operations:")
    print(transpiled_qc.count_ops())
    
    # Debug technique 5: Step-by-step execution
    step_qc = QuantumCircuit(2)
    
    # Step 1: Apply H gate and check state
    step_qc.h(0)
    step_result = simulator.run(transpile(step_qc, simulator)).result()
    step_state = step_result.get_statevector()
    print("State after H gate:", step_state)
    
    # Step 2: Now add the missing CNOT and check again
    step_qc.cx(0, 1)
    step_result = simulator.run(transpile(step_qc, simulator)).result()
    step_state = step_result.get_statevector()
    print("State after CNOT gate:", step_state)
    
    # Fix the original circuit
    fixed_qc = QuantumCircuit(2)
    fixed_qc.h(0)
    fixed_qc.cx(0, 1)  # Bug fixed by adding CNOT
    
    # Verify the fix
    fixed_result = simulator.run(transpile(fixed_qc, simulator)).result()
    fixed_state = fixed_result.get_statevector()
    print("Fixed circuit state:", fixed_state)
    
    return fixed_qc

# Run quantum debugging example
# quantum_circuit_debugging()

# Simplified Quantum Key Distribution (BB84 protocol)
from qiskit import QuantumCircuit, Aer, execute
import numpy as np
import random

def bb84_protocol(n_bits=8):
    """
    Simulate the BB84 quantum key distribution protocol
    
    Args:
        n_bits: Number of bits in the key
        
    Returns:
        Shared secret key
    """
    # Step 1: Alice prepares qubits in random bases with random values
    alice_bits = [random.randint(0, 1) for _ in range(n_bits)]
    alice_bases = [random.randint(0, 1) for _ in range(n_bits)]  # 0=Z basis, 1=X basis
    
    # Create circuits for each qubit
    circuits = []
    for bit, basis in zip(alice_bits, alice_bases):
        qc = QuantumCircuit(1, 1)
        
        # Prepare qubit according to bit value
        if bit == 1:
            qc.x(0)
            
        # Apply Hadamard if using X basis
        if basis == 1:
            qc.h(0)
            
        circuits.append(qc)
    
    # Step 2: Bob measures in random bases
    bob_bases = [random.randint(0, 1) for _ in range(n_bits)]
    
    # Bob's measurement
    bob_results = []
    for i, (qc, basis) in enumerate(zip(circuits, bob_bases)):
        # If Bob uses X basis, apply Hadamard before measurement
        if basis == 1:
            qc.h(0)
        
        qc.measure(0, 0)
        
        # Simulate the measurement
        simulator = Aer.get_backend('qasm_simulator')
        result = execute(qc, simulator, shots=1).result()
        counts = result.get_counts()
        measured_bit = int(list(counts.keys())[0])
        bob_results.append(measured_bit)
    
    # Step 3: Basis reconciliation (public discussion)
    matching_bases = []
    for i in range(n_bits):
        if alice_bases[i] == bob_bases[i]:
            matching_bases.append(i)
    
    # Step 4: Extract the key from positions with matching bases
    secret_key = [alice_bits[i] for i in matching_bases]
    
    # Print the protocol steps
    print(f"Alice's random bits: {alice_bits}")
    print(f"Alice's random bases: {['Z' if b==0 else 'X' for b in alice_bases]}")
    print(f"Bob's random bases: {['Z' if b==0 else 'X' for b in bob_bases]}")
    print(f"Bob's measured bits: {bob_results}")
    print(f"Positions with matching bases: {matching_bases}")
    print(f"Final shared secret key: {secret_key}")
    
    return secret_key

# Run the BB84 protocol simulation
bb84_protocol(16)

# Best practices for quantum circuit design
from qiskit import QuantumCircuit

# Good practice: Minimize circuit depth
qc = QuantumCircuit(3)
# Instead of multiple sequential gates:
qc.h([0, 1, 2])  # Apply H gates in parallel

# Good practice: Use barriers for clarity
qc.barrier()

# Good practice: Use specialized composite gates
# instead of decomposing into many basic gates
qc.ccx(0, 1, 2)  # Toffoli gate

# Example of zero-noise extrapolation
from qiskit import QuantumCircuit, transpile, Aer
from qiskit.providers.aer.noise import NoiseModel

# Create a simple circuit
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])

# Define noise scaling factors
scale_factors = [1.0, 2.0, 3.0]
results = []

# Create a simple noise model
noise_model = NoiseModel()
# Add depolarizing error to gates (simplified)
error_rate = 0.01
noise_model.add_all_qubit_quantum_error(error_rate, ['h', 'cx'])

# Run for each noise scale
for scale in scale_factors:
    # Scale the noise (simplified)
    scaled_model = NoiseModel()
    scaled_model.add_all_qubit_quantum_error(error_rate * scale, ['h', 'cx'])
    
    # Run the circuit
    simulator = Aer.get_backend('qasm_simulator')
    result = simulator.run(transpile(qc, simulator), 
                          noise_model=scaled_model, 
                          shots=1000).result()
    counts = result.get_counts()
    
    # Record expectation value (probability of |00⟩)
    p00 = counts.get('00', 0) / 1000
    results.append(p00)

# Extrapolate to zero noise (simplified linear extrapolation)
import numpy as np
from scipy.optimize import curve_fit

def linear_model(x, a, b):
    return a * x + b

# Fit and extrapolate
popt, _ = curve_fit(linear_model, scale_factors, results)
zero_noise_result = linear_model(0, *popt)

print(f"Noisy results: {results}")
print(f"Extrapolated zero-noise result: {zero_noise_result}")