from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator

# Create a 2-qubit, 2-classical-bit circuit
circuit = QuantumCircuit(2, 2)

# Put qubit 0 in superposition
circuit.h(0)  # Hadamard gate: |0⟩ → (|0⟩ + |1⟩)/√2

# Entangle qubit 0 with qubit 1
circuit.cx(0, 1)  # CNOT gate: if q0=1, flip q1

# Measure both qubits
circuit.measure([0, 1], [0, 1])

# Draw the circuit
print(circuit.draw())
#      ┌───┐      ░ ┌─┐   
# q_0: ┤ H ├──■──░─┤M├───
#      └───┘┌─┴─┐░ └╥┘┌─┐
# q_1: ─────┤ X ├░──╫─┤M├
#           └───┘░  ║ └╥┘
# c: 2/══════════════╩══╩═
#                    0  1

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

print(counts)
# {'00': 503, '11': 497} — Never '01' or '10' — that's entanglement!

from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator

def deutsch_jozsa(oracle: QuantumCircuit, n: int) -> str:
    """
    Determine if an oracle is constant or balanced in one query.
    Returns "constant" or "balanced"
    """
    # n input qubits + 1 ancilla qubit
    circuit = QuantumCircuit(n + 1, n)
    
    # Initialize ancilla in |1⟩
    circuit.x(n)
    
    # Apply Hadamard to all qubits
    circuit.h(range(n + 1))
    circuit.barrier()
    
    # Apply oracle
    circuit.compose(oracle, inplace=True)
    circuit.barrier()
    
    # Apply Hadamard to input qubits
    circuit.h(range(n))
    
    # Measure input qubits
    circuit.measure(range(n), range(n))
    
    # Simulate
    sim = AerSimulator()
    job = sim.run(transpile(circuit, sim), shots=1)
    result = job.result().get_counts()
    
    # If all qubits measure 0, function is constant; otherwise balanced
    measurement = list(result.keys())[0]
    return "constant" if measurement == "0" * n else "balanced"

# Build a constant oracle (always returns 0)
def constant_oracle(n: int) -> QuantumCircuit:
    return QuantumCircuit(n + 1)

# Build a balanced oracle (XOR of inputs)
def balanced_oracle(n: int) -> QuantumCircuit:
    oracle = QuantumCircuit(n + 1)
    for qubit in range(n):
        oracle.cx(qubit, n)  # CNOT each input qubit with ancilla
    return oracle

n = 4  # 4-bit function
print(deutsch_jozsa(constant_oracle(n), n))  # "constant"
print(deutsch_jozsa(balanced_oracle(n), n))  # "balanced"
# Each determination: 1 oracle query (vs 9 classically in worst case)

from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
import numpy as np

def grovers_algorithm(target: str) -> dict:
    """
    Find `target` (binary string) in an unsorted database.
    Returns measurement counts showing the target has highest probability.
    """
    n = len(target)
    num_iterations = int(np.pi / 4 * np.sqrt(2**n))
    
    circuit = QuantumCircuit(n, n)
    
    # Initialize uniform superposition
    circuit.h(range(n))
    
    # Grover iterations
    for _ in range(num_iterations):
        # Oracle: mark the target state with a phase flip
        # This is a simplified oracle for demonstration
        for i, bit in enumerate(reversed(target)):
            if bit == "0":
                circuit.x(i)
        
        circuit.h(n - 1)
        circuit.mcx(list(range(n - 1)), n - 1)  # Multi-controlled X
        circuit.h(n - 1)
        
        for i, bit in enumerate(reversed(target)):
            if bit == "0":
                circuit.x(i)
        
        # Diffusion operator (amplifies marked state)
        circuit.h(range(n))
        circuit.x(range(n))
        circuit.h(n - 1)
        circuit.mcx(list(range(n - 1)), n - 1)
        circuit.h(n - 1)
        circuit.x(range(n))
        circuit.h(range(n))
    
    circuit.measure(range(n), range(n))
    
    sim = AerSimulator()
    job = sim.run(transpile(circuit, sim), shots=1000)
    return job.result().get_counts()

target = "1011"
counts = grovers_algorithm(target)
# Most common result will be "1011" with ~97% probability
most_common = max(counts, key=counts.get)
print(f"Found: {most_common} (target: {target})")
print(f"Probability: {counts[most_common] / 1000:.1%}")

from qiskit.circuit.library import QAOAAnsatz
from qiskit_ibm_runtime import EstimatorV2 as Estimator
from qiskit_ibm_runtime.fake_provider import FakeSherbrooke
from qiskit.quantum_info import SparsePauliOp
from scipy.optimize import minimize
import numpy as np

# Problem: MaxCut on a simple graph
# Partition nodes into two groups maximizing edges between groups
# Nodes: 0, 1, 2, 3
# Edges: (0,1), (1,2), (2,3), (3,0)

# MaxCut objective as Hamiltonian
edges = [(0, 1), (1, 2), (2, 3), (3, 0)]
n_qubits = 4

# Build the cost operator
pauli_terms = []
for i, j in edges:
    # Each edge contributes (I - Z_i Z_j) / 2 to the cost
    z_term = ["I"] * n_qubits
    z_term[i] = "Z"
    z_term[j] = "Z"
    pauli_terms.append(("".join(reversed(z_term)), -0.5))
    pauli_terms.append(("I" * n_qubits, 0.5))

cost_operator = SparsePauliOp.from_list(pauli_terms)

# QAOA ansatz with depth p=2
p = 2
ansatz = QAOAAnsatz(cost_operator, reps=p)

# Use fake backend for testing (replace with real IBM Quantum backend)
backend = FakeSherbrooke()
estimator = Estimator(mode=backend)

def objective(params):
    """Evaluate QAOA cost for given parameters"""
    job = estimator.run([(ansatz, cost_operator, params)])
    return job.result()[0].data.evs  # Expected value

# Classical optimizer
initial_params = np.random.uniform(0, 2*np.pi, ansatz.num_parameters)
result = minimize(objective, initial_params, method="COBYLA", options={"maxiter": 200})

print(f"Optimization result: {result.fun:.4f}")
print(f"Optimal parameters: {result.x}")

from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler
from qiskit import QuantumCircuit, transpile

# Save your credentials once
QiskitRuntimeService.save_account(
    channel="ibm_quantum",
    token="YOUR_IBM_QUANTUM_TOKEN",
    overwrite=True
)

service = QiskitRuntimeService(channel="ibm_quantum")

# Choose the least busy backend
backend = service.least_busy(
    operational=True,
    simulator=False,
    min_num_qubits=5
)

print(f"Running on: {backend.name}")
print(f"Queue depth: {backend.status().pending_jobs}")

# Build your circuit
circuit = QuantumCircuit(2, 2)
circuit.h(0)
circuit.cx(0, 1)
circuit.measure([0, 1], [0, 1])

# Transpile for the specific backend's topology and gate set
transpiled = transpile(circuit, backend=backend, optimization_level=3)

# Submit job
sampler = Sampler(mode=backend)
job = sampler.run([transpiled], shots=4000)

print(f"Job ID: {job.job_id()}")
print("Waiting for results...")

result = job.result()
counts = result[0].data.c.get_counts()
print(f"Real hardware results: {counts}")
# Expect mostly '00' and '11', but some '01' and '10' from noise

# Using liboqs-python — NIST-standardized post-quantum crypto
# pip install liboqs-python

import oqs

# ML-KEM (Kyber) — Key Encapsulation Mechanism
# Replaces RSA/ECDH for key exchange
kem_alg = "ML-KEM-768"

with oqs.KeyEncapsulation(kem_alg) as server:
    public_key = server.generate_keypair()
    
    # Client side: encapsulate a shared secret
    with oqs.KeyEncapsulation(kem_alg) as client:
        ciphertext, shared_secret_client = client.encap_secret(public_key)
    
    # Server side: decapsulate
    shared_secret_server = server.decap_secret(ciphertext)
    
    assert shared_secret_client == shared_secret_server
    print(f"Key exchange successful: {shared_secret_client.hex()[:32]}...")

# ML-DSA (Dilithium) — Digital Signature Algorithm
# Replaces RSA/ECDSA for signatures
sig_alg = "ML-DSA-65"

with oqs.Signature(sig_alg) as signer:
    public_key = signer.generate_keypair()
    message = b"This message is quantum-resistant"
    signature = signer.sign(message)

with oqs.Signature(sig_alg) as verifier:
    is_valid = verifier.verify(message, signature, public_key)
    print(f"Signature valid: {is_valid}")