Qubit State:
|ψ⟩ = α|0⟩ + β|1⟩

Where:
- |0⟩ = [1, 0]^T (basis state 0)
- |1⟩ = [0, 1]^T (basis state 1)
- α, β ∈ ℂ (complex amplitudes)
- |α|² + |β|² = 1 (normalization condition)
- |α|² = Probability of measuring |0⟩
- |β|² = Probability of measuring |1⟩

Quantum Gates:
1. Hadamard (H): Creates superposition
   H|0⟩ = (|0⟩ + |1⟩)/√2
   H|1⟩ = (|0⟩ - |1⟩)/√2

2. Pauli-X (X): Quantum NOT gate
   X|0⟩ = |1⟩
   X|1⟩ = |0⟩

3. Pauli-Y (Y): Rotation around Y-axis
   Y|0⟩ = i|1⟩
   Y|1⟩ = -i|0⟩

4. Pauli-Z (Z): Phase flip
   Z|0⟩ = |0⟩
   Z|1⟩ = -|1⟩

5. CNOT: Controlled-NOT (entangling gate)
   CNOT|00⟩ = |00⟩
   CNOT|01⟩ = |01⟩
   CNOT|10⟩ = |11⟩
   CNOT|11⟩ = |10⟩

import numpy as np

class QuantumCircuit:
    """
    Basic quantum circuit simulator
    """
    def __init__(self, n_qubits):
        self.n_qubits = n_qubits
        self.state = np.zeros(2**n_qubits, dtype=complex)
        self.state[0] = 1  # Initialize to |0...0⟩
    
    def apply_gate(self, gate, qubits):
        """
        Apply quantum gate to specified qubits
        """
        # Construct full unitary matrix
        n = self.n_qubits
        full_gate = np.eye(2**n, dtype=complex)
        
        # Apply gate to specified qubits
        # This is a simplified implementation
        for i in range(len(gate)):
            for j in range(len(gate)):
                bitstring = format(i, f'0{len(qubits)}b')
                full_gate[i, j] = gate[i, j]
        
        # Apply to state
        self.state = np.dot(full_gate, self.state)
    
    def hadamard(self, qubit):
        """
        Apply Hadamard gate
        """
        H = np.array([[1, 1], [1, -1]]) / np.sqrt(2)
        self.apply_gate(H, [qubit])
    
    def x_gate(self, qubit):
        """
        Apply Pauli-X gate
        """
        X = np.array([[0, 1], [1, 0]])
        self.apply_gate(X, [qubit])
    
    def y_gate(self, qubit):
        """
        Apply Pauli-Y gate
        """
        Y = np.array([[0, -1j], [1j, 0]])
        self.apply_gate(Y, [qubit])
    
    def z_gate(self, qubit):
        """
        Apply Pauli-Z gate
        """
        Z = np.array([[1, 0], [0, -1]])
        self.apply_gate(Z, [qubit])
    
    def cnot(self, control, target):
        """
        Apply CNOT gate
        """
        CNOT = np.array([
            [1, 0, 0, 0],
            [0, 1, 0, 0],
            [0, 0, 0, 1],
            [0, 0, 1, 0]
        ])
        self.apply_gate(CNOT, [control, target])
    
    def measure(self, qubit):
        """
        Measure specified qubit
        """
        # Calculate probability of |1⟩
        prob_1 = 0
        for i in range(2**self.n_qubits):
            if (i >> qubit) & 1:
                prob_1 += abs(self.state[i])**2
        
        # Collapse state
        if np.random.random() < prob_1:
            # Measure |1⟩
            for i in range(2**self.n_qubits):
                if not ((i >> qubit) & 1):
                    self.state[i] = 0
            # Normalize
            norm = np.sqrt(prob_1)
            for i in range(2**self.n_qubits):
                if (i >> qubit) & 1:
                    self.state[i] /= norm
            return 1
        else:
            # Measure |0⟩
            for i in range(2**self.n_qubits):
                if (i >> qubit) & 1:
                    self.state[i] = 0
            # Normalize
            norm = np.sqrt(1 - prob_1)
            for i in range(2**self.n_qubits):
                if not ((i >> qubit) & 1):
                    self.state[i] /= norm
            return 0
    
    def get_statevector(self):
        """
        Get current state vector
        """
        return self.state

class QuantumAmplitudeEstimation:
    """
    Quantum Amplitude Estimation for Monte Carlo speedup
    """
    def __init__(self, n_qubits=4):
        self.n_qubits = n_qubits
        self.circuit = None
    
    def build_amplitude_oracle(self, payoff_function):
        """
        Build amplitude oracle for payoff function
        """
        # In practice, this would be a quantum circuit
        # Here we simulate the effect
        def oracle(state):
            amplitude = payoff_function(state)
            return amplitude * state
        return oracle
    
    def estimate_expectation(self, payoff_function, n_iterations=10):
        """
        Estimate expectation using QAE
        """
        # Classical equivalent of QAE
        # QAE provides quadratic speedup over classical MC
        
        # Number of evaluations
        n_eval = 2**n_iterations
        
        # Simulate quantum measurement
        samples = []
        for _ in range(n_eval):
            # Simulate quantum superposition
            # In practice, this would be quantum hardware
            state = np.random.uniform(0, 1)
            payoff = payoff_function(state)
            samples.append(payoff)
        
        # Estimate expectation
        expectation = np.mean(samples)
        return expectation

class QAOA:
    """
    Quantum Approximate Optimization Algorithm for portfolio optimization
    """
    def __init__(self, n_qubits, p_layers=2):
        self.n_qubits = n_qubits
        self.p_layers = p_layers
        self.params = np.random.uniform(0, 2*np.pi, 2*p_layers)
    
    def build_hamiltonian(self, costs):
        """
        Build Ising Hamiltonian from cost function
        """
        # Convert portfolio optimization to Ising model
        H = np.zeros((2**self.n_qubits, 2**self.n_qubits), dtype=complex)
        
        for i in range(2**self.n_qubits):
            # Convert binary representation to asset allocation
            allocation = [int(bit) for bit in format(i, f'0{self.n_qubits}b')]
            # Calculate cost
            cost = self.calculate_cost(allocation, costs)
            H[i, i] = cost
        
        return H
    
    def calculate_cost(self, allocation, costs):
        """
        Calculate cost for given allocation
        """
        # Simplified portfolio cost
        return np.sum(np.array(allocation) * np.array(costs))
    
    def optimize(self, costs, n_iterations=100):
        """
        Optimize portfolio using QAOA
        """
        # Build Hamiltonian
        H = self.build_hamiltonian(costs)
        
        # Classical optimization loop
        best_params = None
        best_cost = float('inf')
        
        for iteration in range(n_iterations):
            # Simulate quantum circuit
            cost = self.evaluate_circuit(self.params, H)
            
            # Update parameters (gradient descent)
            # In practice, this would use quantum gradient estimation
            self.params += np.random.normal(0, 0.1, len(self.params))
            
            if cost < best_cost:
                best_cost = cost
                best_params = self.params.copy()
        
        # Get optimal allocation
        optimal_allocation = self.get_optimal_allocation(best_params)
        
        return optimal_allocation, best_cost
    
    def evaluate_circuit(self, params, H):
        """
        Evaluate quantum circuit
        """
        # Simulate expectation value
        # In practice, this would run on quantum hardware
        state = np.zeros(2**self.n_qubits, dtype=complex)
        state[0] = 1
        
        # Apply QAOA circuit
        for layer in range(self.p_layers):
            # Apply phase separator (C)
            gamma = params[2*layer]
            state = self.apply_phase_separator(state, H, gamma)
            
            # Apply mixer (B)
            beta = params[2*layer + 1]
            state = self.apply_mixer(state, beta)
        
        # Calculate expectation
        expectation = np.real(np.dot(state.conj(), np.dot(H, state)))
        
        return expectation
    
    def apply_phase_separator(self, state, H, gamma):
        """
        Apply phase separator operator
        """
        # U_C(γ) = exp(-iγH)
        U = np.exp(-1j * gamma * H)
        return np.dot(U, state)
    
    def apply_mixer(self, state, beta):
        """
        Apply mixer operator
        """
        # U_B(β) = exp(-iβΣX_i)
        X_total = np.zeros((2**self.n_qubits, 2**self.n_qubits), dtype=complex)
        for i in range(self.n_qubits):
            X_i = np.eye(2**self.n_qubits, dtype=complex)
            # Apply Pauli-X to qubit i
            # Simplified implementation
            for j in range(2**self.n_qubits):
                if (j >> i) & 1:
                    X_i[j, j ^ (1 << i)] = 1
                else:
                    X_i[j, j | (1 << i)] = 1
            X_total += X_i
        
        U = np.exp(-1j * beta * X_total)
        return np.dot(U, state)
    
    def get_optimal_allocation(self, params):
        """
        Extract optimal allocation from quantum state
        """
        # Simulate measurement
        state = np.zeros(2**self.n_qubits, dtype=complex)
        state[0] = 1
        
        # Apply QAOA with optimal parameters
        for layer in range(self.p_layers):
            gamma = params[2*layer]
            beta = params[2*layer + 1]
            # Apply phase separator and mixer
            # (using simplified simulation)
        
        # Measure to get allocation
        probabilities = np.abs(state)**2
        most_likely = np.argmax(probabilities)
        allocation = [int(bit) for bit in format(most_likely, f'0{self.n_qubits}b')]
        
        return allocation

class QuantumMonteCarlo:
    """
    Quantum Monte Carlo for derivative pricing
    """
    def __init__(self, n_qubits=8, n_paths=256):
        self.n_qubits = n_qubits
        self.n_paths = n_paths
    
    def price_option_quantum(self, spot_price, strike_price, volatility, risk_free_rate, time_to_maturity, option_type='call'):
        """
        Price option using quantum Monte Carlo
        """
        # Classical MC for comparison
        classical_price = self.price_option_classical(
            spot_price, strike_price, volatility, risk_free_rate, time_to_maturity, option_type
        )
        
        # Quantum speedup simulation
        # Quantum MC provides quadratic speedup: O(1/ε) vs O(1/ε²)
        
        # Simulate quantum amplitude estimation
        quantum_price = self.simulate_quantum_pricing(
            spot_price, strike_price, volatility, risk_free_rate, time_to_maturity, option_type
        )
        
        return {
            'classical_price': classical_price,
            'quantum_price': quantum_price,
            'speedup': self.n_paths / 2**self.n_qubits
        }
    
    def price_option_classical(self, spot, strike, vol, rate, maturity, option_type):
        """
        Classical Black-Scholes pricing
        """
        from scipy.stats import norm
        
        d1 = (np.log(spot/strike) + (rate + 0.5*vol**2)*maturity) / (vol*np.sqrt(maturity))
        d2 = d1 - vol*np.sqrt(maturity)
        
        if option_type == 'call':
            price = spot*norm.cdf(d1) - strike*np.exp(-rate*maturity)*norm.cdf(d2)
        else:
            price = strike*np.exp(-rate*maturity)*norm.cdf(-d2) - spot*norm.cdf(-d1)
        
        return price
    
    def simulate_quantum_pricing(self, spot, strike, vol, rate, maturity, option_type):
        """
        Simulate quantum pricing (amplitude estimation)
        """
        # Quantum amplitude estimation simulates
        # n_paths = 2**n_qubits paths simultaneously
        
        # Generate price paths using geometric Brownian motion
        dt = maturity / self.n_paths
        price_paths = np.zeros(self.n_paths)
        
        for i in range(self.n_paths):
            # Random walk
            price = spot
            for _ in range(10):  # Steps per path
                z = np.random.normal(0, 1)
                price *= np.exp((rate - 0.5*vol**2)*dt + vol*np.sqrt(dt)*z)
            price_paths[i] = price
        
        # Calculate payoffs
        if option_type == 'call':
            payoffs = np.maximum(price_paths - strike, 0)
        else:
            payoffs = np.maximum(strike - price_paths, 0)
        
        # Discount
        price = np.exp(-rate*maturity) * np.mean(payoffs)
        
        # Quantum speedup reduces number of evaluations needed
        # For same accuracy, quantum needs O(1/ε) vs O(1/ε²)
        
        return price

class PostQuantumCryptography:
    """
    Post-Quantum Cryptography implementation
    """
    def __init__(self):
        self.key_size = 256  # Post-quantum key size (larger than classical)
        self.signature_schemes = {
            'dilithium': 'CRYSTALS-Dilithium',
            'kyber': 'CRYSTALS-Kyber',
            'falcon': 'Falcon',
            'sphincs': 'SPHINCS+'
        }
    
    def generate_key_pair(self, scheme='kyber'):
        """
        Generate post-quantum key pair
        """
        # Simulate key generation
        # In practice, this would use a post-quantum library
        
        import hashlib
        import base64
        
        # Generate random key material
        private_key = hashlib.sha256(np.random.bytes(1024)).digest()
        public_key = hashlib.sha256(private_key + b'public').digest()
        
        return {
            'private_key': base64.b64encode(private_key).decode(),
            'public_key': base64.b64encode(public_key).decode(),
            'scheme': scheme,
            'key_size': self.key_size
        }
    
    def sign_transaction(self, private_key, transaction_data):
        """
        Sign transaction with post-quantum signature
        """
        # Simulate post-quantum signing
        import hashlib
        import base64
        
        # Hash transaction
        tx_hash = hashlib.sha256(transaction_data.encode()).digest()
        
        # Combine with private key
        signature_input = tx_hash + base64.b64decode(private_key)
        signature = hashlib.sha512(signature_input).digest()
        
        return {
            'signature': base64.b64encode(signature).decode(),
            'algorithm': 'dilithium',
            'signature_size': 2420  # Dilithium signature size in bytes
        }
    
    def verify_signature(self, signature, transaction_data, public_key):
        """
        Verify post-quantum signature
        """
        # Simulate signature verification
        import hashlib
        import base64
        
        # Recreate signature
        tx_hash = hashlib.sha256(transaction_data.encode()).digest()
        signature_input = tx_hash + base64.b64decode(public_key)
        expected_signature = hashlib.sha512(signature_input).digest()
        
        # Compare
        actual_signature = base64.b64decode(signature)
        
        return actual_signature == expected_signature
    
    def get_security_level(self, scheme):
        """
        Get security level for post-quantum scheme
        """
        security_levels = {
            'dilithium': {'level': 'High', 'bits': 128},
            'kyber': {'level': 'High', 'bits': 128},
            'falcon': {'level': 'Medium', 'bits': 128},
            'sphincs': {'level': 'High', 'bits': 256}
        }
        
        return security_levels.get(scheme, {'level': 'Unknown', 'bits': 0})

class QuantumNeuralNetwork:
    """
    Quantum Neural Network for financial prediction
    """
    def __init__(self, n_qubits, n_layers=2):
        self.n_qubits = n_qubits
        self.n_layers = n_layers
        self.params = np.random.uniform(0, 2*np.pi, n_qubits * n_layers * 3)
    
    def encode_data(self, data):
        """
        Encode classical data into quantum state
        """
        # Angle encoding
        encoded = np.zeros(2**self.n_qubits, dtype=complex)
        for i, val in enumerate(data[:self.n_qubits]):
            # Rotate qubit based on data
            angle = np.pi * val
            # Simplified encoding
            encoded[i] = np.cos(angle/2)
            encoded[i + 2**(self.n_qubits-1)] = np.sin(angle/2)
        
        # Normalize
        encoded = encoded / np.linalg.norm(encoded)
        
        return encoded
    
    def apply_quantum_circuit(self, state, params):
        """
        Apply parameterized quantum circuit
        """
        # Simplified quantum circuit simulation
        # In practice, this would run on quantum hardware
        
        for layer in range(self.n_layers):
            for qubit in range(self.n_qubits):
                # Apply rotation gates
                idx = layer * self.n_qubits * 3 + qubit * 3
                theta = params[idx]
                phi = params[idx + 1]
                lambda_ = params[idx + 2]
                
                # Apply U3 gate (simplified)
                U3 = np.array([
                    [np.cos(theta/2), -np.exp(1j*lambda_)*np.sin(theta/2)],
                    [np.exp(1j*phi)*np.sin(theta/2), np.exp(1j*(phi+lambda_))*np.cos(theta/2)]
                ])
                
                # Apply to state
                # (simplified: apply to single qubit)
                state = np.dot(U3, state.reshape(2, -1)).flatten()
        
        return state
    
    def measure(self, state):
        """
        Measure quantum state to get prediction
        """
        # Simplified measurement
        # In practice, this would be expectation value
        
        # Probability of measuring |1⟩ for each qubit
        probabilities = []
        for qubit in range(self.n_qubits):
            prob_1 = 0
            for i in range(2**self.n_qubits):
                if (i >> qubit) & 1:
                    prob_1 += abs(state[i])**2
            probabilities.append(prob_1)
        
        # Aggregate for prediction
        prediction = np.mean(probabilities)
        
        return prediction
    
    def predict(self, data):
        """
        Make prediction using quantum neural network
        """
        # Encode data
        state = self.encode_data(data)
        
        # Apply quantum circuit
        state = self.apply_quantum_circuit(state, self.params)
        
        # Measure
        prediction = self.measure(state)
        
        return prediction
    
    def train(self, X_train, y_train, n_epochs=10):
        """
        Train quantum neural network
        """
        # Simplified training (gradient-free)
        for epoch in range(n_epochs):
            total_loss = 0
            
            for i in range(len(X_train)):
                # Forward pass
                pred = self.predict(X_train[i])
                
                # Calculate loss
                loss = (pred - y_train[i])**2
                total_loss += loss
                
                # Update parameters (simplified)
                # In practice, this would use quantum gradient estimation
                self.params += np.random.normal(0, 0.01, len(self.params))
            
            # Print progress
            avg_loss = total_loss / len(X_train)
            print(f"Epoch {epoch+1}/{n_epochs}, Loss: {avg_loss:.4f}")

class QuantumFinanceUseCases:
    """
    Quantum computing applications in finance
    """
    def __init__(self):
        self.use_cases = {}
    
    def portfolio_optimization(self, n_assets=10, n_portfolios=1000):
        """
        Quantum portfolio optimization
        """
        # Generate random asset data
        np.random.seed(42)
        returns = np.random.normal(0.001, 0.02, (n_assets, 252))
        cov = np.cov(returns)
        expected_returns = np.mean(returns, axis=1)
        
        # Classical optimization (for comparison)
        # In practice, this would use QAOA
        
        # Simulate quantum advantage
        classical_time = n_portfolios * n_assets * 100  # μs
        quantum_time = n_portfolios * n_assets * 10   # μs (10x speedup)
        
        return {
            'classical_time': classical_time,
            'quantum_time': quantum_time,
            'speedup': classical_time / quantum_time,
            'algorithm': 'QAOA',
            'assets': n_assets
        }
    
    def derivative_pricing(self, n_paths=1000):
        """
        Quantum derivative pricing
        """
        # Classical MC: O(1/ε²)
        # Quantum MC: O(1/ε)
        
        classical_paths = n_paths
        quantum_paths = int(np.sqrt(n_paths))  # Quadratic speedup
        
        return {
            'classical_paths': classical_paths,
            'quantum_paths': quantum_paths,
            'speedup': classical_paths / quantum_paths,
            'algorithm': 'Quantum Amplitude Estimation'
        }
    
    def risk_analysis(self, n_risk_factors=10):
        """
        Quantum risk analysis
        """
        # Quantum advantage for high-dimensional risk
        classical_complexity = 2**n_risk_factors
        quantum_complexity = n_risk_factors**2  # Polynomial speedup
        
        return {
            'risk_factors': n_risk_factors,
            'classical_complexity': classical_complexity,
            'quantum_complexity': quantum_complexity,
            'speedup': classical_complexity / quantum_complexity
        }
    
    def fraud_detection(self, n_transactions=10000):
        """
        Quantum fraud detection
        """
        # Quantum advantage for pattern recognition
        # Quantum kernel methods for faster classification
        
        classical_time = n_transactions * 1000  # μs
        quantum_time = n_transactions * 100    # μs
        
        return {
            'transactions': n_transactions,
            'classical_time': classical_time,
            'quantum_time': quantum_time,
            'speedup': classical_time / quantum_time,
            'algorithm': 'Quantum SVM'     
}