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, matrix_free=True),
    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, matrix_free=True)`	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

Actualment hi ha dos mètodes de simulació digital disponibles. El primer és un simulador de vector d’estat, que es pot configurar mitjançant les opcions:

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,
    ),
)

El segon és un simulador estabilitzador, que pot simular de manera eficient circuits compostos de portes de Clifford i mesures de Pauli, a costa de ser més lent si el circuit conté moltes portes no-Clifford. Té les següents opcions:

Opció	Significat
`max_states`	Nombre màxim de termes en la suma d’estabilitzadors. Augmentar-ho pot millorar la precisió a costa de memòria i temps d’execució.

from qilisdk.backends import DigitalMethod, QiliSim

backend = QiliSim(
    digital_simulation_method=DigitalMethod.stabilizer(max_states=100),
)

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 controla el nombre de fils utilitzats per a la paral·lelització; per defecte utilitza tots els nuclis disponibles.
seed controla la llavor del generador de nombres aleatoris; per defecte s’utilitza una llavor aleatòria. Les execucions posteriors incrementen la llavor automàticament.
monte_carlo=MonteCarloConfig(trajectories=N) activa el mostreig Monte Carlo amb N trajectòries; si s’omet, Monte Carlo queda desactivat.
measurement_collapse controla si les mesures col·lapsen el vector d’estat in situ (rellevant per a mesures a mig circuit i reservoris); per defecte False.
normalize_state controla si l’estat s’ha de renormalitzar; per defecte True.
gpu controla si s’utilitza l’acceleració per GPU si està disponible; per defecte False.

from qilisdk.backends import ExecutionConfig, MonteCarloConfig, QiliSim

backend = QiliSim(
    execution_config=ExecutionConfig(
        num_threads=8,
        seed=42,
        monte_carlo=MonteCarloConfig(trajectories=500),
        measurement_collapse=True,
        normalize_state=False,
        gpu=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)

Acceleració per GPU

Alguns mètodes de simulació de QiliSim suporten l’acceleració per GPU si hi ha disponible un dispositiu compatible amb CUDA. Aquests requereixen la instal·lació de l’extra cuda:

pip install qilisdk[cuda13]

pip install "qilisdk[cuda13]"

pip install qilisdk[cuda13]

Mètode	Suport de GPU
`AnalogMethod.direct()`	❌
`AnalogMethod.integrator()`	❌
`AnalogMethod.adaptive_integrator()`	❌
`AnalogMethod.arnoldi()`	❌
`AnalogMethod.variational_annealing()`	✅
`DigitalMethod.statevector()`	❌
`DigitalMethod.stabilizer()`	❌