org.soulspace.qclojure.application.error-mitigation.zero-noise — org.soulspace/qclojure 0.9.0

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

execute-circuit-with-backend clj

(execute-circuit-with-backend backend
                              circuit
                              noise-model
                              scale-factor
                              num-shots)

Execute a quantum circuit using the backend protocol with noise scaling support.

This function provides a protocol-compliant way to execute quantum circuits while supporting noise model scaling for Zero Noise Extrapolation. It handles the complete workflow of circuit submission, job monitoring, and result retrieval through the QuantumBackend protocol.

Backend Protocol Integration: The function uses the standard QuantumBackend protocol methods:

1. :submit-circuit - Submit the circuit for execution
2. :get-job-status - Monitor job execution progress
3. :get-job-result - Retrieve measurement results when complete
4. :cancel-job - Handle cleanup if needed

Noise Model Scaling: For backends that support configurable noise models (like the noisy-simulator), the function can scale noise parameters before circuit execution. This enables ZNE to systematically amplify errors for extrapolation analysis.

The noise scaling is applied to the backend's execution options rather than modifying the circuit itself, ensuring compatibility with all backend types.

Parameters:

• backend: QuantumBackend implementation (simulator, noisy-simulator, cloud backend)
• circuit: Quantum circuit specification from org.soulspace.qclojure.domain.circuit
• noise-model: Base noise model configuration map
• scale-factor: Noise amplification factor (1.0 = baseline, >1.0 = amplified)
• num-shots: Number of measurement shots for statistical sampling

Returns: Map containing execution results compatible with ZNE analysis:

• :measurement-results - Map of quantum state strings to measurement counts
• :job-id - Backend job identifier for tracking
• :execution-time-ms - Time spent executing the circuit
• :job-status - Final job status (should be :completed for success)
• :backend-info - Information about the backend used
• :scaled-noise-model - The noise model configuration used for this execution

Error Handling:

• Graceful handling of backend unavailability
• Timeout protection for long-running jobs
• Fallback strategies for failed executions
• Comprehensive error reporting with diagnostic information

Usage in ZNE: This function replaces direct simulation calls in ZNE workflows, ensuring that all circuit executions go through the proper backend protocols. This enables ZNE to work seamlessly with real quantum hardware, cloud services, and various simulator implementations.

extract-expectation-value clj

(extract-expectation-value measurement-results ideal-states)

Extract quantum expectation values from measurement results for Zero Noise Extrapolation analysis.

This function computes quantum observable expectation values from measurement count data, providing the essential input for ZNE fitting and extrapolation. It supports various types of quantum observables and success metrics commonly used in quantum algorithms and error mitigation studies.

Quantum Observable Theory: In quantum mechanics, expectation values represent the average measurement outcomes for quantum observables. For discrete measurement data, the expectation value is:

⟨O⟩ = Σᵢ pᵢ ⟨i|O|i⟩

where pᵢ = nᵢ/N is the measured probability for state |i⟩, nᵢ is the count for state |i⟩, and N is the total number of measurements.

Common observables in ZNE applications:

1. Success Probability: P(success) = Σᵢ∈S pᵢ where S is the set of success states

   • Used in quantum algorithms with well-defined success criteria
   • Examples: Grover's algorithm, quantum optimization, chemistry calculations

2. Parity Expectation: ⟨P⟩ = Σᵢ (-1)^|i| pᵢ where |i| is the Hamming weight

   • Measures quantum coherence and phase information
   • Sensitive to decoherence and gate errors

3. Custom Observables: User-defined quantum operators and measurements

   • Pauli string expectation values (⟨σᵢ ⊗ σⱼ ⊗ ...⟩)
   • Energy expectation values in quantum chemistry
   • Correlation functions and entanglement witnesses

Implementation Features:

• Flexible observable specification through ideal states
• Robust handling of sparse measurement data
• Numerical stability for small count numbers
• Support for weighted and correlated measurements
• Extensible framework for custom observables

Statistical Considerations:

• Accounts for finite sampling effects and Poisson statistics
• Provides uncertainty estimates based on shot noise
• Handles zero-count states and missing measurements
• Supports confidence interval calculations
• Compatible with Bayesian inference methods

Parameters:

• measurement-results: Map of quantum state strings to measurement counts e.g., {"00" 450, "01" 25, "10" 30, "11" 495} where keys are computational basis states and values are counts
• ideal-states: Vector/set of state strings representing the ideal success states Examples: - ["00" "11"] for Bell state preparation - ["000"] for quantum algorithm success - ["101" "010"] for specific computational outcomes - Can be any subset of the computational basis

Returns: Numerical expectation value in the range [0,1] representing:

• Success probability when ideal-states represent algorithm success criteria
• Observable expectation value for quantum mechanical measurements
• Fidelity estimate when ideal-states represent target quantum states
• Custom metric based on the specified ideal state definition

The returned value should decrease with increasing noise for effective ZNE.

Example: (extract-expectation-value {"00" 450 "01" 25 "10" 30 "11" 495} ["00" "11"]) ;=> 0.945 ; (450 + 495) / (450 + 25 + 30 + 495) = 945/1000

Usage in ZNE: This function is called at each noise scaling level to compute the observable values that will be fitted and extrapolated. The choice of ideal-states determines what quantum property is being error-mitigated through ZNE.

Observable Selection Guidelines:

• Choose observables that are sensitive to the errors you want to mitigate
• Ensure the observable decreases monotonically with noise for reliable fitting
• Use algorithm-specific success criteria for practical applications
• Consider using multiple observables for comprehensive error analysis

fit-exponential-decay clj

(fit-exponential-decay data-points)

Fit exponential decay model to Zero Noise Extrapolation data for robust error mitigation.

This function implements the core mathematical analysis of ZNE by fitting expectation value measurements to an exponential decay model as a function of noise scaling. The fitting process enables extrapolation to the zero-noise limit to recover ideal quantum computation results.

Mathematical Foundation: The fundamental ZNE model assumes that quantum expectation values degrade exponentially with noise scaling:

f(λ) = A exp(-γλ) + C

where:

• λ is the noise scaling factor (x-axis)
• f(λ) is the measured expectation value (y-axis)
• A is the amplitude (difference between ideal and asymptotic values)
• γ is the decay rate (characterizes error susceptibility)
• C is the offset (accounts for systematic errors and finite sampling)

The zero-noise extrapolated value is: f(0) = A + C

Implementation Strategy: For robust production use, this implementation provides:

1. Linear Approximation: For small datasets or initial analysis

   • Uses linear least squares fitting in log space
   • Computationally efficient and numerically stable
   • Provides good approximation for moderate noise ranges

2. Extensible Framework: Designed for multiple fitting models

   • Linear model: f(λ) = mλ + b (current implementation)
   • Exponential model: f(λ) = A exp(-γλ) + C (future extension)
   • Polynomial models: For complex error behavior
   • Machine learning approaches: For large datasets

Statistical Considerations:

• Handles noisy measurement data with finite sampling
• Provides goodness-of-fit metrics for model validation
• Detects outliers and statistical anomalies
• Estimates uncertainty in extrapolated values
• Supports weighted fitting for heteroscedastic data

Numerical Stability:

• Avoids division by zero and numerical overflow
• Handles edge cases (single data point, identical values)
• Uses robust algorithms for ill-conditioned problems
• Provides diagnostic information for troubleshooting

Parameters:

• data-points: Vector of measurement data points with structure: [{:x noise-scale, :y expectation-value}, ...] where: - :x values are noise scaling factors (≥ 0, typically 1.0-5.0) - :y values are measured expectation values [0,1] or observable values - Points should span sufficient noise range for reliable fitting - Minimum 2 points required, 4-6 points recommended for robustness

Returns: Comprehensive fitting analysis map:

• :extrapolated-value - Zero-noise limit estimate (primary ZNE result)
• :slope - Linear model slope parameter (error rate characterization)
• :model-type - Fitting model used (:linear, :exponential, :single-point)
• :goodness-of-fit - Statistical quality metrics (R², χ², p-value)
• :uncertainty - Confidence intervals and error bounds
• :outliers - Detected anomalous data points
• :diagnostics - Numerical analysis and warning flags

Example: (fit-exponential-decay [{:x 1.0, :y 0.95} {:x 1.5, :y 0.89} {:x 2.0, :y 0.82} {:x 3.0, :y 0.68}]) ;=> {:extrapolated-value 1.02, :slope -0.11, :model-type :linear, ; :goodness-of-fit {:r-squared 0.98}, :uncertainty {...}}

Model Selection Guidelines:

• Linear model: Fast, robust, good for initial analysis and small datasets
• Exponential model: More accurate for true ZNE behavior, requires more data
• Polynomial models: For complex error dependencies, risk of overfitting
• Choose based on data quality, statistical requirements, and computational constraints

scale-noise-model clj

(scale-noise-model noise-model scale-factor)

Scale noise parameters in a quantum noise model by a specified amplification factor for ZNE.

This function implements the fundamental noise scaling operation required for Zero Noise Extrapolation. It systematically amplifies all noise parameters in a quantum noise model while preserving the relative error structure and maintaining physical constraints.

Physical Rationale: Noise scaling is based on the principle that quantum errors can be artificially amplified while maintaining their characteristic behavior. This allows ZNE to probe how quantum observables degrade with increasing noise strength, enabling extrapolation to the zero-noise limit.

The scaling preserves:

• Relative error ratios between different gate types
• Physical bounds (probabilities ≤ 1.0)
• Noise model structure and parameter relationships
• Hardware-specific error characteristics

Scaling Strategy:

• Gate Noise: All gate error rates are multiplied by the scale factor
• Readout Errors: Measurement error probabilities are scaled with saturation
• Coherence Times: Effective T₁ and T₂ times are reduced proportionally
• Crosstalk: Correlated errors maintain their relative strengths

Implementation Details: The function handles various noise model formats and ensures that:

• Probability values are clamped to [0, 1] to maintain physical validity
• Missing or nil parameters are handled gracefully
• Complex noise model structures are preserved
• Scale factor bounds are enforced for numerical stability

Parameters:

• noise-model: Map containing quantum noise parameters with structure: {:gate-noise {gate-type {:noise-strength value, :t1-time time, :t2-time time}} :readout-error {:prob-0-to-1 prob, :prob-1-to-0 prob} :crosstalk {...} }
• scale-factor: Positive numerical factor for noise amplification (typically 1.0-10.0) - 1.0 = baseline noise (no amplification) - >1.0 = amplified noise for extrapolation - <1.0 = reduced noise (for validation studies)

Returns: Modified noise model map with scaled parameters:

• All :noise-strength values multiplied by scale-factor
• Readout error probabilities scaled with saturation at 1.0
• Original structure and non-noise parameters preserved
• Physical constraints maintained throughout scaling

Example: (scale-noise-model {:gate-noise {:h {:noise-strength 0.01} :cnot {:noise-strength 0.02}} :readout-error {:prob-0-to-1 0.05 :prob-1-to-0 0.03}} 2.0) ;=> {:gate-noise {:h {:noise-strength 0.02} ; :cnot {:noise-strength 0.04}} ; :readout-error {:prob-0-to-1 0.10 :prob-1-to-0 0.06}}

Usage in ZNE: ZNE typically uses scale factors like [1.0, 1.5, 2.0, 3.0] to create a series of increasingly noisy quantum circuits for extrapolation analysis.

simulate-circuit-execution clj

(simulate-circuit-execution circuit noise-model num-shots)

Simulate realistic quantum circuit execution under noise for Zero Noise Extrapolation studies.

This function provides a sophisticated quantum circuit simulation that accurately models the complex interplay of multiple error sources present in real quantum hardware. It is specifically designed to support ZNE by generating measurement data that reflects realistic error behavior and scaling properties.

Physical Error Modeling: The simulation incorporates multiple error mechanisms found in quantum hardware:

1. Gate-Dependent Errors: Different gate types have characteristic error rates

   • Single-qubit gates: Lower error rates (0.1-1%)
   • Two-qubit gates: Higher error rates (0.5-5%)
   • Multi-qubit gates: Scaled error accumulation

2. Error Accumulation: Errors compound throughout circuit execution

   • Coherent errors add linearly with gate count
   • Incoherent errors accumulate stochastically
   • Depth penalty reflects increased decoherence time

3. Decoherence Effects: Time-dependent quantum state degradation

   • T₁ relaxation (amplitude damping)
   • T₂* dephasing (phase randomization)
   • Circuit depth penalty modeling extended execution time

4. Readout Errors: Measurement classification errors

   • False positive rates (|0⟩ → |1⟩ misclassification)
   • False negative rates (|1⟩ → |0⟩ misclassification)
   • Correlated readout errors between qubits

Simulation Algorithm:

1. Analyze circuit structure and gate composition
2. Calculate accumulated gate errors with type-dependent scaling
3. Apply circuit depth penalty for decoherence
4. Compute ideal state fidelity using exponential decay model
5. Generate measurement distribution based on error model
6. Apply readout errors to final measurement statistics
7. Return comprehensive simulation results with diagnostics

Error Scaling Properties: The simulation ensures that errors scale predictably for ZNE:

• Coherent errors scale linearly with noise amplification
• Decoherence follows exponential scaling laws
• Statistical fluctuations are properly modeled
• Hardware-specific error correlations are preserved

Parameters:

• circuit: Quantum circuit specification map containing: - :operations - Vector of gate operations to execute - :num-qubits - Number of qubits in the quantum system - :initial-state - Initial quantum state (optional)
• noise-model: Comprehensive noise characterization map: - :gate-noise - Per-gate-type error specifications - :readout-error - Measurement error probabilities - :coherence-times - T₁ and T₂ decoherence parameters - :crosstalk - Inter-qubit error correlations
• num-shots: Number of measurement shots for statistical sampling (≥1000 recommended)

Returns: Comprehensive simulation results map:

• :measurement-results - Map of quantum state strings to measurement counts
• :ideal-fidelity - Computed fidelity after error accumulation [0,1]
• :total-coherent-error - Total accumulated coherent error magnitude
• :circuit-depth - Number of gates executed (proxy for execution time)
• :readout-error-strength - Combined readout error magnitude
• :error-breakdown - Detailed analysis of error source contributions
• :statistical-metrics - Sampling statistics and confidence estimates

Example: (simulate-circuit-execution bell-circuit {:gate-noise {:h {:noise-strength 0.01} :cnot {:noise-strength 0.02}} :readout-error {:prob-0-to-1 0.05 :prob-1-to-0 0.03}} 1000) ;=> {:measurement-results {"00" 425 "11" 450 "01" 65 "10" 60} ; :ideal-fidelity 0.94, :total-coherent-error 0.062, ...}

Usage in ZNE: This function is called at each noise scaling level to generate measurement data for extrapolation. The realistic error modeling ensures that ZNE fitting captures the true error scaling behavior of quantum hardware.

zero-noise-extrapolation clj

(zero-noise-extrapolation circuit backend noise-scales ideal-states num-shots)

Apply comprehensive Zero Noise Extrapolation to mitigate quantum errors in production environments.

This function implements a complete Zero Noise Extrapolation workflow for quantum error mitigation, providing production-ready error mitigation capabilities for quantum algorithms and hardware characterization. ZNE is one of the most effective error mitigation techniques available for near-term quantum computers.

ZNE Methodology: Zero Noise Extrapolation works by systematically amplifying quantum errors and observing how quantum observables degrade, then extrapolating back to the zero-noise limit to recover ideal quantum results. This approach is effective because:

1. Systematic Error Scaling: Many quantum errors scale predictably with noise strength
2. Hardware Agnostic: Works across different quantum computing platforms
3. Algorithm Independent: Applicable to any quantum algorithm or circuit
4. Real-time Capable: Can be implemented in real-time quantum control systems

Complete ZNE Workflow:

1. Noise Scaling: Create multiple versions of the circuit with amplified noise
2. Execution: Run each scaled circuit on quantum hardware or simulator
3. Measurement: Collect measurement statistics at each noise level
4. Observable Extraction: Compute expectation values or success metrics
5. Model Fitting: Fit degradation model to expectation vs. noise data
6. Extrapolation: Estimate zero-noise limit from fitted model
7. Validation: Assess extrapolation quality and statistical confidence

Error Mitigation Effectiveness: ZNE can provide significant improvements in quantum algorithm performance:

• Typical improvement factors: 2-10× for near-term algorithms
• Best performance on coherent errors and systematic noise
• Complementary to other error mitigation techniques
• Particularly effective for variational quantum algorithms

Production Features:

• Robust error handling and recovery mechanisms
• Comprehensive statistical analysis and uncertainty quantification
• Performance optimization for large quantum circuits
• Integration with quantum cloud services and hardware backends
• Configurable noise scaling strategies and fitting models
• Real-time monitoring and adaptive parameter tuning
• Detailed diagnostic reporting and quality metrics

Integration Capabilities:

• Quantum backend abstraction for hardware independence
• Pluggable noise models for different quantum platforms
• Custom observable definitions for algorithm-specific metrics
• Batch processing for high-throughput quantum applications
• API compatibility with quantum software frameworks

Parameters:

• circuit: Quantum circuit specification map containing: - :operations - Vector of quantum gate operations - :num-qubits - Number of qubits in the quantum system - :metadata - Circuit compilation and optimization information
• backend: Quantum backend specification map: - :noise-model - Base noise characterization for the quantum device - :device-info - Hardware topology and capabilities - :execution-config - Backend-specific execution parameters
• noise-scales: Vector of noise amplification factors (typically [1.0, 1.5, 2.0, 3.0]) - Should span sufficient range for reliable extrapolation - Higher scales provide more data but may introduce non-linearities - Optimal range depends on circuit depth and noise characteristics
• ideal-states: Vector of quantum state strings representing success criteria - Algorithm-specific definition of ideal computational outcomes - Used to compute expectation values for extrapolation - Examples: ["+0" "-0"] for superposition, ["000"] for ground state
• num-shots: Number of measurement shots per noise level (≥1000 recommended) - Higher shot counts improve statistical precision - Balance between accuracy and computational cost - Should account for quantum decoherence timescales

Returns: Comprehensive ZNE analysis results map:

• :extrapolated-value - Primary result: error-mitigated expectation value
• :improvement-factor - Ratio of mitigated to baseline performance (>1.0 indicates improvement)
• :baseline-expectation - Unmitigated performance at natural noise level
• :noise-scales - Vector of noise scaling factors used in analysis
• :raw-results - Complete measurement data and simulation results for each noise level
• :data-points - Extracted expectation values vs. noise scaling data
• :fit-result - Statistical analysis of exponential decay fitting
• :quality-metrics - Extrapolation confidence and validation statistics
• :execution-time - Performance benchmarking and timing information
• :error - Detailed error information if ZNE fails (with graceful degradation)

Example: (zero-noise-extrapolation vqe-circuit {:noise-model ibm-noise-model} [1.0 1.5 2.0 3.0] ["000" "111"] 2000) ;=> {:extrapolated-value 0.94, :improvement-factor 1.8, :baseline-expectation 0.52, ; :fit-result {:model-type :exponential, :r-squared 0.96}, ...}

Usage Guidelines:

• Use 4-6 noise scaling points for robust extrapolation
• Ensure sufficient measurement statistics (≥1000 shots per point)
• Validate extrapolation quality before using results
• Consider circuit depth limitations for noise scaling
• Combine with other error mitigation techniques for maximum benefit

Performance Considerations:

• Computational cost scales linearly with number of noise scales
• Circuit simulation time depends on system size and noise model complexity
• Memory usage scales with measurement data storage requirements
• Parallelization opportunities for independent noise scale execution