🔐 Q# Programming Cheat Sheet for QKD

namespace QKD {
    open Microsoft.Quantum.Core;
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Canon;
    
    @EntryPoint()
    operation Main() : Unit {
        Message("Welcome to Quantum Key Distribution!");
        
        // Your quantum code here
        use qubit = Qubit() {
            H(qubit);                    // Create superposition
            let result = M(qubit);       // Measure qubit
            Message($"Measured: {result}");
            Reset(qubit);                // Always reset!
        }
    }
}

// Create |0⟩ state (default)
use qubit = Qubit();  // Automatically in |0⟩

// Create |1⟩ state
X(qubit);             // Apply NOT gate: |0⟩ → |1⟩

// Create superposition |+⟩ = (|0⟩ + |1⟩)/√2
H(qubit);             // Hadamard gate

// Create superposition |−⟩ = (|0⟩ − |1⟩)/√2
X(qubit);
H(qubit);

// Standard (Z-basis) measurement: measures |0⟩ or |1⟩
let result = M(qubit);

// X-basis measurement: measures |+⟩ or |−⟩
H(qubit);                    // Rotate to Z-basis
let result = M(qubit);       // Then measure

// Check measurement result
if result == Zero {
    Message("Measured 0");
} else {
    Message("Measured 1");
}

operation AlicePrepareQubits(bits : Bool[], bases : Bool[]) : Qubit[] {
    mutable qubits = [];
    
    for i in 0..Length(bits)-1 {
        use qubit = Qubit();
        
        // Prepare bit value (0 or 1)
        if bits[i] {
            X(qubit);  // Prepare |1⟩
        }
        // else qubit is already |0⟩
        
        // Choose basis (false = Z-basis, true = X-basis)
        if bases[i] {
            H(qubit);  // Rotate to X-basis
        }
        
        set qubits += [qubit];
    }
    
    return qubits;
}

operation BobMeasureQubits(qubits : Qubit[], bases : Bool[]) : Bool[] {
    mutable results = [];
    
    for i in 0..Length(qubits)-1 {
        // Choose measurement basis
        if bases[i] {
            H(qubits[i]);  // Measure in X-basis
        }
        // else measure in Z-basis (default)
        
        let result = M(qubits[i]);
        let bit = result == One;
        set results += [bit];
        
        Reset(qubits[i]);
    }
    
    return results;
}

operation GenerateRandomBit() : Bool {
    use qubit = Qubit() {
        H(qubit);                    // Create superposition
        let result = M(qubit);       // Random measurement
        Reset(qubit);
        return result == One;        // Convert to Bool
    }
}

operation GenerateRandomBits(count : Int) : Bool[] {
    mutable bits = [];
    for _ in 1..count {
        set bits += [GenerateRandomBit()];
    }
    return bits;
}

@EntryPoint()
operation BB84Demo() : Unit {
    let keyLength = 8;  // Short key for demo
    
    Message("=== BB84 Quantum Key Distribution Demo ===");
    
    // 1. Alice generates random bits and bases
    let aliceBits = GenerateRandomBits(keyLength);
    let aliceBases = GenerateRandomBits(keyLength);
    
    Message($"Alice's bits:  {aliceBits}");
    Message($"Alice's bases: {aliceBases}");
    
    // 2. Alice prepares qubits
    let qubits = AlicePrepareQubits(aliceBits, aliceBases);
    
    // 3. Bob chooses random measurement bases
    let bobBases = GenerateRandomBits(keyLength);
    Message($"Bob's bases:   {bobBases}");
    
    // 4. Bob measures qubits
    let bobBits = BobMeasureQubits(qubits, bobBases);
    Message($"Bob's bits:    {bobBits}");
    
    // 5. Extract secret key (matching bases only)
    let secretKey = ExtractSecretKey(aliceBits, bobBits, aliceBases, bobBases);
    
    Message($"Secret key:    {secretKey}");
    Message($"Key length:    {Length(secretKey)} bits");
}

// Print variable values
Message($"Current bit: {bit}");
Message($"Key length: {Length(secretKey)}");

// Print arrays
Message($"Alice's key: {aliceKey}");

// Simulator-only: Show quantum state
DumpMachine();  // Shows full quantum state

operation TestBB84() : Unit {
    // Test with known values
    let testBits = [true, false, true, false];
    let testBases = [false, false, true, true];  // Z, Z, X, X
    
    let qubits = AlicePrepareQubits(testBits, testBases);
    let results = BobMeasureQubits(qubits, testBases);  // Same bases
    
    // Results should match when bases are same
    for i in 0..Length(testBits)-1 {
        if testBits[i] != results[i] {
            Message($"ERROR: Bit {i} doesn't match!");
        }
    }
    
    Message("BB84 test completed!");
}

open Microsoft.Quantum.Math;

let randomFloat = RandomReal();         // Random [0,1)
let randomInt = RandomInt(10);          // Random [0,9]
let squareRoot = Sqrt(4.0);            // = 2.0

// Immutable binding (can't change)
let numberOfPhotons = 100;
let secretBit = true;

// Mutable variable (can change)
mutable matchingBases = 0;
set matchingBases = matchingBases + 1;

// Arrays
let aliceBits = [true, false, true, false];
mutable keyBits = [];
set keyBits += [true];  // Add element to array

// Process array of qubits
for i in 0..Length(qubits)-1 {
    H(qubits[i]);
    let result = M(qubits[i]);
    Message($"Qubit {i}: {result}");
}

// Repeat until condition
mutable attempts = 0;
repeat {
    // Try quantum operation
    set attempts = attempts + 1;
} until attempts >= maxAttempts;

// Single qubit measurement
let bit = M(qubit) == One;

// Multiple qubits at once
let results = MeasureEachZ(qubits);
let bits = ResultArrayAsBoolArray(results);

operation MeasureInRandomBasis(qubit : Qubit) : (Bool, Bool) {
    let basisChoice = GenerateRandomBit();  // Random basis
    
    if basisChoice {
        H(qubit);  // Measure in X-basis
    }
    // else measure in Z-basis
    
    let measurementResult = M(qubit) == One;
    Reset(qubit);
    
    return (measurementResult, basisChoice);
}