QiliSim

El backend QiliSim és el simulador de CPU per defecte desenvolupat per Qilimanjaro i escrit en C++. Implementa tots els funcionals primitius de manera nativa, suporta un model de soroll en totes les rutes d’execució i s’inclou amb la instal·lació principal de qilisdk — no requereix cap dependència ni maquinari addicional.

Instal·lació

QiliSim s’inclou amb la instal·lació principal de qilisdk, per la qual cosa no cal cap paquet addicional.

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 — escull l’estratègia de simulació digital i els seus hiperparàmetres.
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.variational_annealing()`	Recuit variacional	Només disponible per a schedules de recuit de X a Z. Es pot utilitzar per simular sistemes grans (és a dir, 60+ qubits) a costa de la precisió. Establiu order=1 per a una simulació més ràpida però menys precisa. Augmentar els escalfaments també pot millorar la precisió a costa del temps.
`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	Pot oferir un escalat decent per a Hamiltonians dispersos grans; ajusteu `dim` per a la mida del subespai de Krylov.
`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:

from qilisdk.backends import AnalogMethod, QiliSim

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

Mètodes de simulació digital

Digital execution is currently always state-vector based; the DigitalMethod configuration tunes its performance characteristics rather than choosing a different algorithm:

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`	Fusiona portes d’un sol qubit adjacents en una única operació abans de propagar. Desactivat si s’utilitza soroll específic de porta.
`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 (default) lets the simulator use every physical core.
seed=None (default) draws a fresh random seed at construction time; pass an integer for reproducibility.
monte_carlo=MonteCarloConfig(trajectories=N) enables stochastic trajectory sampling for noise models that admit a Monte Carlo unraveling; leave it None for deterministic master-equation evolution.
measurement_collapse controls whether measurements collapse the statevector in place (relevant for mid-circuit measurement and reservoir computing); defaults to 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,
    ),
)

Suport del model de soroll

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)