Divi
Local Simulation

Local Simulation

Divi provides two local simulation backends:

Backend Description
MaestroSimulator Default local backend powered by Maestro — supports state vector, MPS, and auto-routing based on circuit size
QiskitSimulator Qiskit Aer-based simulation — supports noise models, fake backends, and exact expectation values

MaestroSimulator (Default)

MaestroSimulator is Divi’s default local simulation backend. It uses the Maestro engine and automatically selects the best simulation strategy (state vector for small circuits, MPS for larger ones).

from divi.backends import MaestroSimulator

backend = MaestroSimulator()

QiskitSimulator

QiskitSimulator wraps Qiskit Aer for local simulation. Use it when you need noise models or Qiskit fake backends.

from divi.backends import QiskitSimulator

backend = QiskitSimulator()

Configuration Options 

backend = QiskitSimulator(
    simulation_seed=42,        # Deterministic results for reproducibility
    qiskit_backend="auto",     # Or specify: "aer_simulator", "aer_simulator_statevector"
)

Example: Local VQE 

import numpy as np
from divi.backends import MaestroSimulator
from divi.qprog import VQE, HartreeFockAnsatz
from divi.qprog.optimizers import ScipyOptimizer, ScipyMethod
from pennylane import qchem

molecule = qchem.Molecule(
    symbols=["H", "H"],
    coordinates=np.array([(0.0, 0.0, 0.0), (0.0, 0.0, 0.5)]),
)

vqe = VQE(
    molecule=molecule,
    ansatz=HartreeFockAnsatz(),
    optimizer=ScipyOptimizer(ScipyMethod.L_BFGS_B),
    max_iterations=10,
    backend=MaestroSimulator(),
)

vqe.run()
print(f"Energy: {min(vqe.losses[-1].values()):.4f}")

Features

Noisy Simulation

Enable noise models for realistic simulation (QiskitSimulator only):

from qiskit_aer.noise import NoiseModel, depolarizing_error

noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(depolarizing_error(0.01, 1), ['rx', 'ry', 'rz'])
noise_model.add_all_qubit_quantum_error(depolarizing_error(0.02, 2), ['cx'])

backend = QiskitSimulator(noise_model=noise_model)

Alternatively, use a Qiskit fake backend to inherit a realistic noise profile:

from qiskit_ibm_runtime.fake_provider import FakeAuckland

backend = QiskitSimulator(qiskit_backend=FakeAuckland())

This is useful for testing error mitigation techniques like ZNE.

Deterministic Mode

Set a simulation seed for reproducible results (QiskitSimulator):

backend = QiskitSimulator(simulation_seed=1997)

Circuit Depth Tracking

Track circuit depths during execution:

backend = MaestroSimulator()
# ... run algorithms ...
print(f"Circuit depths: {backend.circuit_depths}")

When to Use Each Backend

MaestroSimulator (default):

  • Development and testing with fast iteration
  • Auto-routing between state vector and MPS based on circuit size
  • Large circuits (MPS scales beyond state vector limits)

QiskitSimulator:

  • Noisy simulation with custom noise models or Qiskit fake backends
  • Reproducibility with deterministic seeds
  • Error mitigation testing (ZNE development)
Cloud Simulation