// No backend parameter = automatic LocalBackend creation
match GraphColoring.solve problem 3 None with
| Ok solution -> (* ... *)
What happens:
Builder creates LocalBackend() automatically
Simulates quantum circuit using state vectors
≤16 qubits supported (larger problems fail with error)
Explicit Cloud Backend
// Create Azure Quantum backend
let backend = BackendAbstraction.createIonQBackend(
connectionString = "YOUR_CONNECTION_STRING",
targetId = "ionq.simulator" // or "ionq.qpu" for hardware
)
// Pass to solver
match GraphColoring.solve problem 3 (Some backend) with
| Ok solution ->
printfn "Backend used: %s" solution.BackendName
Backend Comparison
// Small problem: Use local simulation
let smallProblem = MaxCut.createProblem ["A"; "B"; "C"] [("A","B",1.0)]
let result1 = MaxCut.solve smallProblem None // Fast, free
// Large problem: Use cloud backend
let largeProblem = MaxCut.createProblem
[for i in 1..20 -> sprintf "V%d" i]
[for i in 1..19 -> (sprintf "V%d" i, sprintf "V%d" (i+1), 1.0)]
let backend = BackendAbstraction.createIonQBackend(conn, "ionq.simulator")
let result2 = MaxCut.solve largeProblem (Some backend) // Scalable, paid
🔄 OpenQASM 2.0 Support
Import and export quantum circuits to IBM Qiskit, Cirq, and other OpenQASM-compatible platforms.
Why OpenQASM?
OpenQASM (Open Quantum Assembly Language) is the industry-standard text format for quantum circuits:
✅ IBM Qiskit - Primary format (6.7k GitHub stars)
✅ Amazon Braket - Native support
✅ Google Cirq - Import/export compatibility
✅ Interoperability - Share circuits between platforms
Export Circuits to OpenQASM
F# API:
open FSharp.Azure.Quantum
open FSharp.Azure.Quantum.CircuitBuilder
// Build circuit using F# circuit builder
let circuit =
CircuitBuilder.empty 2
|> CircuitBuilder.addGate (H 0)
|> CircuitBuilder.addGate (CNOT (0, 1))
|> CircuitBuilder.addGate (RZ (0, System.Math.PI / 4.0))
// Export to OpenQASM 2.0 string
let qasmCode = OpenQasm.export circuit
printfn "%s" qasmCode
// Export to .qasm file
OpenQasm.exportToFile circuit "bell_state.qasm"
Output (bell_state.qasm):
OPENQASM 2.0;
include "qelib1.inc";
qreg q[2];
h q[0];
cx q[0],q[1];
rz(0.7853981634) q[0];
Import Circuits from OpenQASM
F# API:
open FSharp.Azure.Quantum
open System.IO
// Parse OpenQASM string
let qasmCode = """
OPENQASM 2.0;
include "qelib1.inc";
qreg q[3];
h q[0];
cx q[0],q[1];
cx q[1],q[2];
"""
match OpenQasmImport.parse qasmCode with
| Ok circuit ->
printfn "Loaded %d-qubit circuit with %d gates"
circuit.QubitCount circuit.Gates.Length
// Use circuit with LocalBackend or export to another format
| Error msg ->
printfn "Parse error: %s" msg
// Import from file
match OpenQasmImport.parseFromFile "grover.qasm" with
| Ok circuit -> (* use circuit *)
| Error msg -> printfn "Error: %s" msg
C# API
using FSharp.Azure.Quantum;
using FSharp.Azure.Quantum.CircuitBuilder;
// Export circuit to OpenQASM
var circuit = CircuitBuilder.empty(2)
.AddGate(Gate.NewH(0))
.AddGate(Gate.NewCNOT(0, 1));
var qasmCode = OpenQasm.export(circuit);
File.WriteAllText("circuit.qasm", qasmCode);
// Import from OpenQASM
var qasmInput = File.ReadAllText("qiskit_circuit.qasm");
var result = OpenQasmImport.parse(qasmInput);
if (result.IsOk) {
var imported = result.ResultValue;
Console.WriteLine($"Loaded {imported.QubitCount}-qubit circuit");
}
Supported Gates
All standard OpenQASM 2.0 gates supported:
Category
Gates
Pauli
X, Y, Z, H
Phase
S, S†, T, T†
Rotation
RX(θ), RY(θ), RZ(θ)
Two-qubit
CNOT (CX), CZ, SWAP
Three-qubit
CCX (Toffoli)
Workflow: Qiskit → F# → IonQ
Full interoperability workflow:
// 1. Load circuit from Qiskit
let qiskitCircuit = OpenQasmImport.parseFromFile "qiskit_algorithm.qasm"
match qiskitCircuit with
| Ok circuit ->
// 2. Run on LocalBackend for testing
let localBackend = BackendAbstraction.createLocalBackend()
let testResult = LocalSimulator.QaoaSimulator.simulate circuit 1000
printfn "Local test: %d samples" testResult.Shots
// 3. Transpile for IonQ hardware
let transpiled = GateTranspiler.transpileForBackend "ionq.qpu" circuit
// 4. Execute on IonQ
let ionqBackend = BackendAbstraction.createIonQBackend(
connectionString,
"ionq.qpu"
)
// 5. Export results back to Qiskit format
OpenQasm.exportToFile transpiled "results_ionq.qasm"
| Error msg ->
printfn "Import failed: %s" msg
Round-Trip Compatibility
Circuits are preserved through export/import:
// Original circuit
let original = { QubitCount = 3; Gates = [H 0; CNOT (0, 1); RZ (1, 1.5708)] }
// Export → Import → Compare
let qasm = OpenQasm.export original
let imported = OpenQasmImport.parse qasm
match imported with
| Ok circuit ->
assert (circuit.QubitCount = original.QubitCount)
assert (circuit.Gates.Length = original.Gates.Length)
printfn "✅ Round-trip successful"
| Error msg ->
printfn "❌ Round-trip failed: %s" msg
Use Cases
Share algorithms - Export F# quantum algorithms to IBM Qiskit community
Import research - Load published Qiskit papers/benchmarks into F# for analysis
Multi-provider - Develop in F#, run on IBM Quantum, Amazon Braket, IonQ
Education - Students learn quantum with type-safe F#, export to standard format
Validation - Cross-check results between F# LocalBackend and IBM simulators
See:tests/OpenQasmIntegrationTests.fs for comprehensive examples
🛡️ Error Mitigation
Reduce quantum noise and improve result accuracy by 30-90% with production-ready error mitigation techniques.
Why Error Mitigation?
Quantum computers are noisy (NISQ era). Error mitigation improves results without requiring error-corrected qubits:
FSharp.Azure.Quantum is a quantum-first library - NO classical algorithms.
Why?
✅ Clear identity: Purpose-built for quantum optimization
✅ No architectural confusion: Pure quantum algorithm library
✅ Complements classical libraries: Use together with classical solvers when needed
✅ Educational value: Learn quantum algorithms without classical fallbacks
What this means:
// ✅ QUANTUM: QAOA-based optimization
GraphColoring.solve problem 3 None
// ❌ NO CLASSICAL FALLBACK: If quantum fails, returns Error
// Users should use dedicated classical libraries for that use case
Clean API Layers
High-Level Builders: Business domain APIs (register allocation, portfolio optimization)
No leaky abstractions - Each layer has clear responsibilities.
📚 Educational Algorithms
Note: The following algorithms are provided for quantum computing education and research. They are NOT optimization solvers and should not be used for production optimization tasks. For production optimization, use the Problem Builders or HybridSolver above.
In addition to the production-ready optimization solvers above, the library includes foundational quantum algorithms for education and research:
Grover's Search Algorithm
Quantum search algorithm for finding elements in unsorted databases.
open FSharp.Azure.Quantum.GroverSearch
// Search for item satisfying predicate
let searchConfig = {
MaxIterations = Some 10
SuccessThreshold = 0.9
OptimizeIterations = true
Shots = 1000
RandomSeed = Some 42
}
// Search 8-item space for items where f(x) = true
let predicate x = x = 3 || x = 5 // Looking for indices 3 or 5
match Search.searchWithPredicate 3 predicate searchConfig with
| Ok result ->
printfn "Found solutions: %A" result.Solutions
printfn "Success probability: %.2f%%" (result.SuccessProbability * 100.0)
printfn "Iterations: %d" result.IterationsApplied
| Error msg ->
printfn "Search failed: %s" msg
Features:
✅ Automatic optimal iteration calculation
✅ Amplitude amplification for multiple solutions
✅ Direct LocalSimulator integration (no IBackend)
✅ Educational/research tool (not production optimizer)
Location:src/FSharp.Azure.Quantum/Algorithms/ Status: Experimental - Research and education purposes
Note: Grover's algorithm is a standalone quantum search primitive, separate from the QAOA-based optimization builders. It does not use the IBackend abstraction and is optimized for specific search problems rather than general combinatorial optimization.
Amplitude Amplification
Generalization of Grover's algorithm for custom initial states.
Amplitude amplification extends Grover's algorithm to work with arbitrary initial state preparations (not just uniform superposition). This enables quantum speedups for problems beyond simple database search.
Key Insight: Grover's algorithm is a special case where:
Initial state = uniform superposition H^⊗n|0⟩
Reflection operator = Grover diffusion operator
Amplitude amplification allows:
Custom initial state preparation A|0⟩
Reflection about A|0⟩ (automatically generated)
Local Simulation Example:
open FSharp.Azure.Quantum.GroverSearch.AmplitudeAmplification
// Custom state preparation (W-state: equal superposition of single-excitation states)
let wState = wStatePreparation 3 // (|100⟩ + |010⟩ + |001⟩)/√3
// Configure amplitude amplification
let config = {
NumQubits = 3
StatePreparation = wState
Oracle = myOracle
ReflectionOperator = None // Auto-generate from state preparation
Iterations = 5
}
// Execute amplitude amplification
match execute config with
| Ok result ->
printfn "Success probability: %.2f%%" (result.SuccessProbability * 100.0)
printfn "Iterations applied: %d" result.IterationsApplied
| Error msg ->
printfn "Amplification failed: %s" msg
Backend Execution (NEW - Cloud/Hardware Support):
open FSharp.Azure.Quantum.GroverSearch.AmplitudeAmplificationAdapter
open FSharp.Azure.Quantum.Core.BackendAbstraction
// Execute amplitude amplification on quantum hardware backend
let backend = createIonQBackend(connectionString, "ionq.simulator")
// Define oracle (marks solution states)
let oracle = StateOracle(fun state -> state = 3 || state = 5)
// Configure amplitude amplification
let config = {
NumQubits = 3
StatePreparation = UniformSuperposition // or BasisState(n), PartialSuperposition(states)
Oracle = oracle
Iterations = 2 // Optimal iterations for 2 solutions in 8-element space
}
match executeWithBackend config backend 1000 with
| Ok measurementCounts ->
printfn "Amplitude amplification executed on quantum hardware"
measurementCounts
|> Map.iter (fun state count -> printfn " |%d⟩: %d counts" state count)
| Error msg ->
printfn "Backend execution failed: %s" msg
// Convenience functions
executeUniformAmplification 3 oracle 2 backend 1000 // Uniform initial state
executeBasisStateAmplification 3 5 oracle 2 backend 1000 // Start from |5⟩
Features:
✅ Custom state preparation (W-states, partial superpositions, arbitrary states)
Status: Production-ready - Full backend support (as of Nov 2025)
Quantum Fourier Transform (QFT)
Quantum analog of the discrete Fourier transform - foundational building block for many quantum algorithms.
The QFT transforms computational basis states into frequency basis with exponential speedup over classical FFT:
Classical FFT: O(n·2^n) operations
Quantum QFT: O(n²) quantum gates
Mathematical Transform:
QFT: |j⟩ → (1/√N) Σₖ e^(2πijk/N) |k⟩
Local Simulation Example:
open FSharp.Azure.Quantum.GroverSearch.QuantumFourierTransform
// Initialize state |5⟩ (computational basis)
let state = StateVector.init 3 // 3 qubits
// ... prepare |5⟩ = |101⟩
// Apply QFT (local simulation)
match execute config state with
| Ok result ->
printfn "QFT applied successfully"
printfn "Gate count: %d" result.GateCount
printfn "Final state transformed to frequency basis"
| Error msg ->
printfn "QFT failed: %s" msg
Backend Execution (NEW - Cloud/Hardware Support):
open FSharp.Azure.Quantum.GroverSearch.QFTBackendAdapter
open FSharp.Azure.Quantum.Core.BackendAbstraction
// Execute QFT on quantum hardware backend
let backend = createIonQBackend(connectionString, "ionq.simulator")
let config = { NumQubits = 5; ApplySwaps = true; Inverse = false }
match executeQFTWithBackend config backend 1000 None with
| Ok measurementCounts ->
printfn "QFT executed on quantum hardware"
measurementCounts
|> Map.iter (fun state count -> printfn " |%d⟩: %d counts" state count)
| Error msg ->
printfn "Backend execution failed: %s" msg
// Convenience functions
executeStandardQFT 5 backend 1000 // Standard QFT with swaps
executeInverseQFT 5 backend 1000 // Inverse QFT (QFT†)
executeQFTOnState 5 7 backend 1000 // QFT on specific input state |7⟩
Features:
✅ O(n²) gate complexity (exponential speedup over classical)
