Fire Opal Monte Carlo integration

Fire Opal's integrate_monte_carlo function provides an end-to-end workflow for estimating expected values using quantum computers. It brings practical Monte Carlo calculations to today’s quantum hardware by fusing quantum signal processing and classical post-processing with Fire Opal’s advanced error suppression.

Our integrate_monte_carlo function supports users with different levels of quantum expertise. Quantum specialists can supply their own amplitude-estimation circuits for greater control, while quantitative analysts can describe their problem using a probability distribution and an objective function. Fire Opal then constructs the required quantum circuits automatically. This enables practitioners to tackle expectation-value estimation problems across finance, chemistry, and physics with a potential quadratic speedup over state-of-the-art classical techniques, without requiring quantum computing expertise.

Introduction to Monte Carlo integration

Classical Monte Carlo integration is a computational method that relies on repeated random sampling to simulate millions of possible future outcomes for complex, unpredictable financial systems. It has been the go-to technique for quantitative analysts because it efficiently handles high-dimensional problems (like pricing exotic derivatives with dozens of underlying assets) where exact mathematical formulas do not exist. Its accuracy improves reliably regardless of how many variables or market conditions are introduced.

While powerful, classical Monte Carlo has a fundamental statistical convergence rate, meaning it estimates expected values by sampling random paths, with root-mean-square estimation error decreasing as $O(1/\sqrt{N})$ for N independent samples. This means that reducing the statistical error by one decimal place typically requires approximately 100 times as many samples.

Quantum Amplitude Estimation (QAE) enables an improved asymptotic scaling. In the ideal setting, QAE can achieve estimation error scaling as $O(1/N)$ . This means the same 10 times reduction in error requires approximately 10 times as many oracle queries.

Hardware	Scaling	Samples required for 10 times precision improvement
Classical computers	$O(1/\sqrt{N})$	100 times
Quantum devices	$O(1/N)$	10 times

Canonical QAE relies on deep circuits involving quantum phase estimation and controlled Grover operations, making it poorly suited to today’s noisy quantum hardware. This is where Quantum Signal Processing (QSP) comes in. QSP provides a way to construct controlled transformations of an encoded quantity. In finance, this is the value (such as portfolio risk) that we want to estimate.

In our implementation, integrate_monte_carlo encodes the probability distribution and objective function into a state-preparation circuit, while QSP-based polynomial measurements extract information about the resulting expectation. Fire Opal adaptively selects these measurements based on the information collected so far, then uses Bayesian inference to update its estimate of both the target expectation and residual hardware noise.

This approach provides a tunable trade-off between circuit depth and repeated measurements, allowing the estimator to target the query-complexity advantage of amplitude estimation using circuits better suited to physical quantum processors.

Quantum amplitude estimation has massive potential, however, turning the algorithmic promise into a useful calculation on quantum hardware is challenging. It requires:

• encoding probability distributions and objective functions into quantum operations,
• constructing amplitude estimation circuits,
• managing circuit depth,
• accounting for hardware errors, and
• combining the resulting quantum measurements into a final estimate.

The Fire Opal integrate_monte_carlo function manages these steps within a single workflow.

Performance Benefits

Available directly in the Fire Opal Python client, integrate_monte_carlo provides a high-level interface for running Monte Carlo integration on physical quantum hardware. Whether you’re a quantitative analyst with defined objective functions or a quantum researcher designing your own custom circuits, integrate_monte_carlo will support your use case.

• Scale beyond toy-scale demonstrations: Many Monte Carlo demonstrations on quantum devices have focused on small problem instances useful for validating algorithms but limited in scale due to noisy hardware. With Fire Opal, we have demonstrated integrate_monte_carlo using 27 data qubits, a 4x increase from the previous record high. This enables substantially more complex estimation problems, moving the workflow beyond the proof-of-concept regime.

• Reduce the quantum circuit depth: Quantum amplitude estimation typically requires deep circuits, making straightforward implementations difficult to run on current quantum processors. Our integrate_monte_carlo function uses a hybrid quantum-classical approach that combines quantum signal processing techniques with classical computation. This approach reduces the depth of the quantum circuits, enabling successful estimation for larger and more complex use cases.

• Automatically suppress hardware errors: Running a quantum algorithm on real hardware introduces errors that can significantly impact the quality of the result. Our integrate_monte_carlo function integrates directly with Fire Opal's automated error suppression pipeline. Circuits are deployed to hardware using this pipeline, which maximizes algorithmic performance. This means users do not need to build or manage a separate error suppression workflow around their Monte Carlo calculation.

Built for Quantum Experts and Quantitative Analysts Alike

The integrate_monte_carlo function supports two ways to define a problem, depending on how much control you need over the underlying quantum implementation.

Provide your own quantum circuits

For users with quantum computing expertise, our integrate_monte_carlo function accepts a single quantum circuit that combines state preparation, distribution loading, and objective-function encoding. The circuit must encode the value to be estimated as the amplitude of an ancilla qubit. This ancilla should be a single-qubit register named target or output.

This configuration provides greater control over how the problem is encoded and is well suited to those who have developed custom approches for state-preparation, distribution loading, and objective-function encoding. Fire Opal then manages the amplitude estimation workflow, error suppression, hardware execution, and classical post-processing required to obtain the final estimate.

Let Fire Opal construct the circuits

For users who want to work at the application level, Fire Opal can construct the required quantum circuits automatically. Instead of designing circuits, users define their problem using the supported distribution and objective-function constructors listed below.

Fire Opal uses these objects to build the corresponding quantum circuit and configure the amplitude estimation workflow. This allows practitioners to use Monte Carlo without needing expertise in quantum circuit construction or low-level quantum algorithm design.

To make problem setup easier, Fire Opal natively supports several constructors for commonly used distributions and objective functions.

Distribution constructors:

• fireopal.make_lognormal_distribution
• fireopal.make_normal_distribution
• fireopal.make_uniform_distribution
• fireopal.make_gci_model_distribution

Objective function constructors:

• fireopal.make_european_call_delta_objective
• fireopal.make_european_call_pricing_objective
• fireopal.make_fixed_income_pricing_objective

Now that you've learned about Fire Opal's Monte Carlo integrator and its techniques, try it out yourself by running the tutorial Price european options using Monte Carlo integration on quantum devices.