Bernstein-Vazirani Algorithm

The Bernstein-Vazirani algorithm is a quantum algorithm that efficiently
determines a hidden bit string s using only one query to a quantum oracle.
It is a foundational example of quantum speedup over classical algorithms,
demonstrating how quantum circuits can solve specific problems more
efficiently than their classical counterparts.

This implementation builds the quantum circuit for the Bernstein-Vazirani
algorithm and executes it on a specified quantum backend.

The algorithm uses a quantum oracle Uf that computes f(x) = s·x (mod 2),
where s is the hidden string and x is the input bit string.

The algorithm requires only one query to the oracle to determine the hidden
string s, while classical algorithms would require n queries for an n-bit
string.

Deutsch Algorithm

The Deutsch algorithm is a quantum algorithm that determines whether a given
function f: {0,1} → {0,1} is constant (f(0) = f(1)) or balanced (f(0) ≠ f(1))
using only one quantum query, compared to 2 classical queries needed.

This implementation builds the quantum circuit for the Deutsch algorithm
and executes it on a specified quantum backend.

Grover's Search Algorithm

Grover's algorithm provides a quadratic speedup for searching unsorted databases.
For N items, classical search requires O(N) queries, while Grover's requires O(√N).
The number of Grover iterations is approximately π√N/4, where N is the size
of the search space.

This implementation builds the quantum circuit for Grover's algorithm and executes it
on a specified quantum backend.

The algorithm consists of:
1. Initializing a uniform superposition state |+⟩^⊗n
2. Repeating Grover iterations:
   a. Apply the oracle Uf to mark target states
   b. Apply the diffusion operator (inversion about average)
3. Measuring the final state to find the target item with high probability

The oracle function should take a computational basis state index and return
true for target states.

The diffusion operator applies inversion about the average amplitude.

HHL (Harrow-Hassidim-Lloyd) Algorithm

The HHL algorithm is a quantum algorithm for solving linear systems of equations 
of the form Ax = b, where A is a Hermitian matrix. It provides exponential speedup 
over classical algorithms for certain classes of linear systems.

The algorithm works by:
1. Encoding the vector b as a quantum state |b⟩
2. Using quantum phase estimation to find eigenvalues of A
3. Performing conditional rotation to compute A^(-1)
4. Amplitude amplification to extract the solution

This implementation is designed for production use with:
- General n×n Hermitian matrices
- Integration with existing quantum phase estimation
- Proper error handling and validation
- Configurable precision and success probability

Key functions:
- matrix-encoding-unitary: Encode Hermitian matrix as unitary evolution
- vector-preparation-circuit: Prepare |b⟩ state from classical vector
- hhl-circuit: Build complete HHL quantum circuit
- hhl-algorithm: Execute HHL algorithm with backend

Production-ready quantum arithmetic circuits with minimal resource usage.

This namespace provides a complete suite of quantum arithmetic operations
needed for algorithms like Shor's factoring, quantum period finding,
and other cryptographic quantum algorithms.

This implementation focuses on:
- Minimal qubit usage (qubits are sparse resources)
- Correct quantum arithmetic from the start
- Proper testing at each level
- Production-ready code that will work on real quantum hardware

All circuits are designed to be:
- Reversible (essential for quantum computation)
- Resource-efficient (minimizing ancilla qubits)
- Fault-tolerant ready (structured for error correction)
- Modular and composable

Quantum period finding algorithm for Shor's algorithm.

This algorithm is a specialized application of quantum phase estimation (QPE)
to find the period of the modular exponentiation function f(x) = a^x mod N.

Instead of reimplementing QPE, this module leverages the existing quantum-phase-estimation
algorithm and adapts it for period finding by:
1. Setting up the appropriate unitary operator (modular exponentiation)
2. Using QPE to estimate the phase
3. Converting phase estimates to period estimates using continued fractions

This follows the DRY principle and maintains a clean separation of concerns.

Version 2.0: Now uses the comprehensive quantum arithmetic module for
production-ready modular exponentiation circuits.

Quantum Phase Estimation (QPE) algorithm implementation.

The Quantum Phase Estimation algorithm is a fundamental quantum algorithm that estimates
the eigenvalue of a unitary operator. Given a unitary operator U and one of its 
eigenstates |ψ⟩ such that U|ψ⟩ = e^(iφ)|ψ⟩, QPE estimates the phase φ.

Algorithm Overview:
1. Initialize precision qubits in superposition (|+⟩ states)
2. Prepare eigenstate qubit in a known eigenstate of U
3. Apply controlled-U^(2^k) operations for k = 0 to n-1
4. Apply inverse Quantum Fourier Transform to precision qubits
5. Measure precision qubits to extract phase estimate

The precision of the phase estimate depends on the number of precision qubits used.
With n precision qubits, the phase can be estimated to within 2π/2^n.

Key Functions:
- quantum-phase-estimation-circuit: Build QPE circuit
- quantum-phase-estimation: Execute complete QPE algorithm
- parse-measurement-to-phase: Convert measurement results to phase estimates
- analyze-qpe-results: Analyze QPE measurement statistics

Example Usage:
(def simulator (create-simulator))
(def result (quantum-phase-estimation simulator (/ Math/PI 4) 3 :plus))
(:estimated-phase (:result result)) ; => ~0.7854 (π/4)

Simon's Algorithm

Simon's algorithm solves the hidden subgroup problem for the group (Z₂)ⁿ.
Given a function f: {0,1}ⁿ → {0,1}ⁿ that is either one-to-one or two-to-one,
and if two-to-one then f(x) = f(x ⊕ s) for some hidden string s ≠ 0ⁿ,
the algorithm finds s with exponential speedup over classical methods.

The algorithm requires only O(n) quantum operations to find the hidden period,
while classical algorithms would require O(2^(n/2)) queries to find s.

This implementation builds the quantum circuit for Simon's algorithm
and executes it on a specified quantum backend.

The algorithm uses a quantum oracle Uf that computes f(x) = f(x ⊕ s),
where s is the hidden period and x is the input bit string.

Variational Quantum Eigensolver (VQE) Algorithm Implementation

VQE is a quantum-classical hybrid algorithm for finding the ground state energy
of quantum systems. It uses a parameterized quantum circuit (ansatz) to prepare
trial states and classical optimization to minimize the energy expectation value.

Key Features:
- Multiple ansatz types (hardware-efficient, UCCSD-inspired, symmetry-preserving)
- Pauli string Hamiltonian representation with measurement grouping
- Integration with fastmath optimization for classical optimization
- Comprehensive analysis and convergence monitoring
- Support for both gate-based and measurement-based implementations

Algorithm Flow:
1. Initialize parameterized quantum circuit (ansatz)
2. Prepare trial state |ψ(θ)⟩ with parameters θ
3. Measure expectation value ⟨ψ(θ)|H|ψ(θ)⟩
4. Use classical optimizer to update parameters
5. Repeat until convergence

This implementation targets production use with real quantum hardware.

Implementation of fundamental quantum algorithms using the qclojure domain

Protocol and interface for quantum computing hardware backends.

This namespace defines the protocol for connecting to and executing
quantum circuits on real quantum hardware or simulators. It provides
a clean abstraction layer that allows the application to work with
different quantum computing providers and simulators.

Error mitigation strategies for quantum computing.

This namespace provides a comprehensive suite of error mitigation techniques
to improve the fidelity of quantum circuit execution on noisy hardware.

Key strategies implemented:
- Zero Noise Extrapolation (ZNE)
- Readout Error Mitigation  
- Symmetry Verification
- Virtual Distillation
- Circuit Optimization Integration

The mitigation pipeline analyzes circuits and noise models to automatically
select and apply the most effective strategies for each use case.

Readout error mitigation for quantum measurement correction.

This namespace provides functions for correcting measurement errors
that occur during quantum state readout. Readout errors are one of the
most significant sources of noise in current quantum hardware, and
proper mitigation can substantially improve algorithm fidelity.

Key capabilities:
- Single and multi-qubit readout error characterization
- Calibration matrix construction using tensor products
- Linear system solving for error correction
- Fidelity improvement measurement and analysis

The implementation supports arbitrary numbers of qubits (up to practical memory
limits) and uses proper mathematical techniques including matrix inversion
and probability normalization to ensure physically valid results.

Typical workflow:
1. Characterize readout errors using calibration experiments  
2. Create calibration matrix from error parameters
3. Apply mitigation to measured data using matrix inversion
4. Analyze improvement in measurement fidelity

Quantum symmetry verification for comprehensive error mitigation and circuit validation.

This namespace provides symmetry verification tools for quantum circuits, enabling
sophisticated error mitigation strategies through systematic symmetry analysis.
Symmetries in quantum circuits are fundamental for error detection and mitigation because
they provide expected invariant properties that should be preserved during ideal quantum
computation.

Key capabilities:
• Parity symmetry verification for circuits with parity-preserving operations
• Reflection symmetry analysis using bit-flip invariance properties
• Permutation symmetry detection for circuits with qubit exchange invariance
• Rotational symmetry analysis for systems with continuous rotational symmetry
• Statistical significance testing using chi-squared and confidence intervals
• Configurable thresholds and production-grade error reporting
• Comprehensive violation analysis with severity classification
• Automated corrective action recommendations

Symmetry Types Analyzed:

1. **Parity Symmetry**: For circuits containing only parity-preserving gates (H, S, T, Pauli, CNOT),
   the overall parity of measurement outcomes should be preserved. Violations indicate
   systematic measurement errors or decoherence effects.

2. **Reflection Symmetry**: Bit-flip symmetry where states |x⟩ and |x̄⟩ (bit-wise complement)
   should have equal measurement probabilities under certain circuit conditions.
   Critical for detecting calibration errors and crosstalk.

3. **Permutation Symmetry**: For circuits invariant under qubit permutations, measurement
   distributions should be equivalent when qubits are exchanged. Essential for
   validating hardware uniformity and detecting qubit-specific systematic errors.

4. **Rotational Symmetry**: For systems with continuous rotational invariance (e.g., 
   certain 3-qubit systems), measurement outcomes should be invariant under
   specific rotational transformations.

Physical Background:
Quantum error correction and mitigation rely heavily on symmetry properties because:
- Ideal quantum evolution preserves certain symmetries of the initial state and Hamiltonian
- Hardware noise and systematic errors often break these symmetries in characteristic ways
- Symmetry violations provide diagnostic information about error sources and magnitudes
- Statistical analysis of symmetry preservation enables quantitative error assessment

Production Features:
• Configurable statistical significance testing with proper multiple comparison corrections
• Scalable analysis algorithms for systems from 2 to 20+ qubits
• Comprehensive violation classification with actionable diagnostic information
• Performance optimization with sampling strategies for large Hilbert spaces
• Integration with measurement error mitigation and hardware characterization protocols

Virtual Distillation for quantum error mitigation through probabilistic error cancellation.

This namespace provides a production-ready implementation of Virtual Distillation,
an advanced quantum error mitigation technique that improves computation fidelity
by running multiple copies of quantum circuits and applying sophisticated post-processing
to extract high-fidelity results through probabilistic error cancellation.

Key capabilities:
• Multiple circuit copy execution with independent noise realizations
• Fidelity-weighted result aggregation for optimal error cancellation
• Probabilistic post-processing with statistical error suppression
• Production-grade noise model perturbation for realistic copy generation
• Comprehensive improvement estimation and validation metrics
• Integration with quantum backends and hardware characterization
• Scalable implementation for large quantum circuits
• Robust error handling and graceful degradation

Virtual Distillation Theory:

Virtual Distillation is based on the principle that quantum errors are often
stochastic and can be partially cancelled through ensemble averaging with
intelligent weighting. The technique exploits the fact that different copies
of the same quantum circuit, when run with slightly different noise realizations,
will have correlated systematic errors but uncorrelated random errors.

Mathematical Foundation:
If we have M copies of a quantum circuit, each producing a noisy state ρ_noisy^(i),
the virtual distillation procedure aims to construct an improved state:

ρ_distilled = Σᵢ wᵢ ρ_noisy^(i) / Σᵢ wᵢ

where wᵢ are fidelity-based weights that preferentially emphasize higher-quality results.
The key insight is that this weighted combination can have higher fidelity than
any individual copy:

F(ρ_distilled, ρ_ideal) > max{F(ρ_noisy^(i), ρ_ideal)}

Physical Principles:

Virtual Distillation is effective because:
- **Error Diversity**: Different circuit copies experience independent noise realizations
- **Statistical Averaging**: Random errors partially cancel through ensemble averaging
- **Quality Weighting**: Higher-fidelity results are given more influence in the final outcome
- **Systematic Error Correlation**: Coherent errors remain correlated and can be suppressed

The technique works by:
1. **Copy Generation**: Create multiple versions of the target circuit with perturbed noise
2. **Independent Execution**: Run each copy with its own noise realization
3. **Fidelity Estimation**: Assess the quality of each copy's results
4. **Weighted Aggregation**: Combine results using fidelity-based weights
5. **Statistical Enhancement**: Exploit ensemble properties for error suppression

Implementation Strategy:

• **Noise Perturbation**: Small random variations in noise parameters between copies
  to ensure diverse error realizations while maintaining realistic noise characteristics
• **Fidelity Weighting**: Sophisticated weighting schemes based on estimated fidelity
  to maximize the effectiveness of error cancellation
• **Statistical Processing**: Robust aggregation algorithms that handle outliers
  and maintain statistical validity of the final results
• **Resource Optimization**: Efficient allocation of measurement shots across copies
  to maximize information gain within computational budget constraints

Theoretical Advantages:
• Square-root improvement in error rates for incoherent errors
• Effective suppression of readout errors and measurement noise
• Complementary to other error mitigation techniques (ZNE, symmetry verification)
• No additional quantum resources required (classical post-processing only)
• Scalable to large quantum systems and complex algorithms

Practical Applications:
• Variational quantum algorithms (VQE, QAOA) with improved convergence
• Quantum chemistry calculations requiring high precision
• Quantum machine learning with enhanced training stability
• Quantum optimization problems with better solution quality
• Hardware benchmarking and characterization studies
• Quantum error correction protocol validation

Production Features:
• Configurable copy generation strategies for different noise models
• Adaptive weighting schemes optimized for specific error characteristics
• Comprehensive statistical analysis and uncertainty quantification
• Integration with quantum cloud services and hardware backends
• Performance monitoring and optimization recommendations
• Detailed diagnostic reporting for troubleshooting and validation

Zero Noise Extrapolation (ZNE) for quantum error mitigation in production environments.

This namespace provides an implementation of Zero Noise Extrapolation, a
powerful error mitigation technique that extrapolates quantum computation results
to the zero-noise limit. ZNE is particularly effective for mitigating coherent
errors and systematic noise that scales predictably with noise strength.

Key capabilities:
• Production-grade noise model scaling with realistic error accumulation
• Sophisticated circuit execution simulation incorporating multiple error sources
• Robust exponential decay fitting with multiple model support
• Flexible expectation value extraction for various quantum observables
• Comprehensive error handling and statistical analysis
• Integration with quantum backends and hardware characterization
• Performance optimization for large-scale quantum circuits
• Configurable extrapolation models and validation metrics

Zero Noise Extrapolation Theory:

ZNE exploits the fact that many quantum errors scale predictably with noise strength.
By artificially amplifying noise and measuring how expectation values degrade, we can
extrapolate back to the zero-noise limit to recover ideal quantum results.

The fundamental assumption is that expectation values follow an exponential decay:
⟨O⟩(λ) = ⟨O⟩₀ exp(-γλ) + offset

where:
- λ is the noise scaling factor
- ⟨O⟩(λ) is the measured expectation value at noise level λ
- ⟨O⟩₀ is the ideal (zero-noise) expectation value
- γ characterizes the error susceptibility
- offset accounts for systematic errors and finite sampling

Physical Background:

ZNE is effective because:
- Coherent errors often scale linearly with gate error rates
- Decoherence processes follow exponential decay laws
- Many hardware imperfections are systematic and predictable
- Statistical noise averages out with sufficient sampling

The technique works by:
1. **Noise Scaling**: Artificially amplifying noise in quantum circuits
2. **Measurement**: Running circuits at multiple noise levels
3. **Fitting**: Modeling expectation value degradation vs. noise
4. **Extrapolation**: Estimating the zero-noise limit value

Implementation Features:

• **Realistic Noise Models**: Incorporates gate-dependent errors, readout errors,
  decoherence effects, and circuit depth penalties
• **Multiple Scaling Methods**: Supports various noise amplification strategies
• **Robust Fitting**: Handles noisy data with outlier detection and model validation
• **Observable Flexibility**: Works with arbitrary quantum observables and success metrics
• **Production Integration**: Designed for real quantum hardware and cloud services
• **Performance Optimization**: Efficient algorithms for large quantum systems
• **Error Analysis**: Comprehensive uncertainty quantification and confidence intervals

Typical ZNE Workflow:
1. Define noise scaling factors (e.g., [1.0, 1.5, 2.0, 3.0])
2. Execute circuit at each noise level with sufficient statistics
3. Extract expectation values or success probabilities
4. Fit exponential decay model to the data
5. Extrapolate to zero noise to obtain error-mitigated result
6. Validate extrapolation quality and compute confidence bounds

Applications:
• Variational quantum algorithms (VQE, QAOA)
• Quantum chemistry and materials simulation
• Quantum optimization and machine learning
• Quantum error correction benchmarking
• Hardware characterization and validation

OpenQASM 3.0 conversion functions for quantum circuits.

This namespace provides conversion between quantum circuit data structures
and OpenQASM 3.0 format strings. QASM 3.0 is the latest version of the
OpenQASM quantum assembly language with improved syntax and features.

Hardware-specific optimization and topology management for quantum circuits.

This namespace provides functionality for optimizing quantum circuits
for specific hardware topologies, including qubit routing, SWAP insertion,
and topology-aware optimization strategies.

Quantum noise application layer providing high-level noise modeling functions.

This namespace contains advanced noise application functions that bridge the 
pure quantum mechanics in domain.channel with practical use cases like:
- Error mitigation algorithms
- Circuit fidelity estimation  
- Platform comparison and benchmarking
- Hardware-aware noise modeling

These functions were moved from the noisy simulator backend to make them
available for broader use cases throughout the quantum computing stack.