QiliSim Backend

The QiliSim backend is the default CPU simulator developed by Qilimanjaro and written in C++. It implements every primitive functional natively, supports a noise model on all execution paths, and is included with the core qilisdk installation — no extra dependency or hardware is required.

Instal·lació

QiliSim is bundled with the core qilisdk installation, so no extra package is required.

Inici ràpid

import numpy as np
from qilisdk.digital import Circuit, H, CNOT
from qilisdk.backends import QiliSim
from qilisdk.functionals import DigitalPropagation
from qilisdk.readout import Readout

# Build a simple circuit
circuit = Circuit(5)
circuit.add(H(0))
circuit.add(CNOT(0, 1))

# Create DigitalPropagation functional
functional = DigitalPropagation(circuit)

# Execute with the QiliSim backend
backend = QiliSim()
result = backend.execute(functional, Readout().with_sampling(nshots=500))
print(result.get_samples())

Suport de funcionals

QiliSim suporta de manera nativa tots els funcionals primitius mitjançant rutines dedicades en C++:

Funcional	Suport	Notes
`DigitalPropagation`	✅	Simulació basada en vector d’estat, configurable mitjançant `DigitalMethod`.
`AnalogEvolution`	✅	Múltiples esquemes d’integració, configurables mitjançant `AnalogMethod`.
`QuantumReservoir`	✅	Implementació nativa en C++; suporta tant passos Circuit com Schedule del reservori.
`VariationalProgram`	✅	Reutilitza els manejadors de funcionals primitius anteriors a cada pas d’optimització.

Configuració

QiliSim es configura en el moment de la construcció mitjançant tres seccions ortogonals, totes definides a qilisdk.backends.backend_config:

AnalogMethod — escull l’esquema d’evolució temporal analògica i els seus hiperparàmetres.
DigitalMethod — chooses the digital simulation strategy and its hyperparameters.
ExecutionConfig — controls globals d’execució (fils, llavor aleatòria, trajectòries de Monte Carlo, comportament del col·lapse de mesura).

from qilisdk.backends import (
    AnalogMethod,
    DigitalMethod,
    ExecutionConfig,
    MonteCarloConfig,
    QiliSim,
)

backend = QiliSim(
    analog_simulation_method=AnalogMethod.arnoldi(dim=16, num_substeps=2),
    digital_simulation_method=DigitalMethod.statevector(
        matrix_free=True,
        max_cache_size=2_000,
        combine_single_qubit_gates=True,
    ),
    execution_config=ExecutionConfig(
        num_threads=4,
        seed=42,
        monte_carlo=MonteCarloConfig(trajectories=200),
        measurement_collapse=False,
    ),
)

Si s’omet qualsevol argument, QiliSim recau en:

AnalogMethod.integrator() (RK4 sense matriu),
DigitalMethod.statevector(),
un ExecutionConfig per defecte (tots els nuclis, llavor aleatòria, Monte Carlo desactivat).

Mètodes de simulació analògica

Utilitzeu els mètodes de classe de AnalogMethod per triar com s’integra el schedule:

Constructor	Esquema subjacent	Quan utilitzar-lo
`AnalogMethod.integrator(matrix_free=True)`	RK4	Per defecte. Runge-Kutta 4 amb pas fix; sense matriu és més ràpid per a Hamiltonians dispersos.
`AnalogMethod.adaptive_integrator(tol=1e-2)`	Dormand-Prince RK4/5	Mida de pas adaptativa; `tol` limita l’error de fidelitat entre les estimacions RK4 i RK5.
`AnalogMethod.arnoldi(dim=10, num_substeps=1)`	Krylov / Arnoldi	Can offer decent scaling for large sparse Hamiltonians; tune `dim` for the Krylov subspace size.
`AnalogMethod.direct()`	Exponencial de matriu	Esquema de referència per a sistemes petits; el cost creix ràpidament amb el nombre de qubits.

Exemple, utilitzant l’integrador adaptatiu per a un schedule més rígid:

from qilisdk.backends import AnalogMethod, QiliSim

backend = QiliSim(analog_simulation_method=AnalogMethod.adaptive_integrator(tol=1e-2))

Mètodes de simulació digital

L’execució digital es basa actualment sempre en vector d’estat; la configuració DigitalMethod ajusta les seves característiques de rendiment en lloc de triar un algoritme diferent:

Opció	Significat
`matrix_free`	Aplica les portes directament al vector d’estat en lloc de construir matrius denses. Per defecte `True`.
`max_cache_size`	Nombre màxim de matrius de porta precomputades emmagatzemades en memòria cau entre execucions.
`combine_single_qubit_gates`	Merge adjacent single-qubit gates into a single operation before propagating. Disabled if gate-specific noise is used.
`normalize_after_each_gate`	Renormalitza el vector d’estat després de cada porta per mitigar la deriva numèrica, amb un cost de temps d’execució.

from qilisdk.backends import DigitalMethod, QiliSim

backend = QiliSim(
    digital_simulation_method=DigitalMethod.statevector(
        matrix_free=False,
        normalize_after_each_gate=True,
    ),
)

Execució i Monte Carlo

ExecutionConfig controla els fils, l’aleatorietat i el mostreig opcional de trajectòries de Monte Carlo per a simulacions de sistemes oberts.

num_threads=0 (per defecte) permet al simulador utilitzar tots els nuclis físics.
seed=None (per defecte) genera una nova llavor aleatòria en el moment de la construcció; passeu un enter per a reproducibilitat.
monte_carlo=MonteCarloConfig(trajectories=N) activa el mostreig estocàstic de trajectòries per a models de soroll que admeten un unraveling de Monte Carlo; deixeu-ho a None per a una evolució determinista de l’equació mestra.
measurement_collapse controla si les mesures col·lapsen el vector d’estat in situ (rellevant per a mesures a mig circuit i computació de reservoris); per defecte False.

from qilisdk.backends import ExecutionConfig, MonteCarloConfig, QiliSim

backend = QiliSim(
    execution_config=ExecutionConfig(
        num_threads=8,
        seed=1234,
        monte_carlo=MonteCarloConfig(trajectories=500),
        measurement_collapse=True,
    ),
)

Noise model support

Qualsevol NoiseModel acceptat pel SDK es pot passar directament al constructor; QiliSim l’aplica dins del solver de C++, de manera que les execucions digitals, analògiques i de reservori veuen totes els mateixos canals de soroll:

from qilisdk.backends import QiliSim
from qilisdk.noise import NoiseModel, Depolarizing

nm = NoiseModel()
nm.add(Depolarizing(probability=1e-3))

backend = QiliSim(noise_model=nm)