QiliSim Backend

El backend QiliSim es el simulador de CPU por defecto desarrollado por Qilimanjaro y escrito en C++. Implementa todos los funcionales primitivos de forma nativa, soporta un modelo de ruido en todas las rutas de ejecución y se incluye con la instalación principal de qilisdk — no requiere dependencias ni hardware adicionales.

Instalación

QiliSim se incluye con la instalación principal de qilisdk, por lo que no se necesita ningún paquete adicional.

Inicio rápido

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

Soporte de funcionales

QiliSim soporta de forma nativa todos los funcionales primitivos mediante rutinas dedicadas en C++:

Funcional	Soporte	Notas
`DigitalPropagation`	✅	Simulación basada en vector de estado, configurable mediante `DigitalMethod`.
`AnalogEvolution`	✅	Múltiples esquemas de integración, configurables mediante `AnalogMethod`.
`QuantumReservoir`	✅	Implementación nativa en C++; soporta tanto pasos Circuit como Schedule del reservorio.
`VariationalProgram`	✅	Reutiliza los manejadores de funcionales primitivos anteriores en cada paso de optimización.

Configuración

QiliSim se configura en el momento de la construcción a través de tres secciones ortogonales, todas definidas en qilisdk.backends.backend_config:

AnalogMethod — elige el esquema de evolución temporal analógica y sus hiperparámetros.
DigitalMethod — elige la estrategia de simulación digital y sus hiperparámetros.
ExecutionConfig — controles globales de ejecución (hilos, semilla aleatoria, trayectorias de Monte Carlo, comportamiento del colapso de medición).

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 se omite algún argumento, QiliSim recurre a:

AnalogMethod.integrator() (RK4 sin matriz),
DigitalMethod.statevector(),
un ExecutionConfig por defecto (todos los núcleos, semilla aleatoria, Monte Carlo desactivado).

Métodos de simulación analógica

Utilice los métodos de clase de AnalogMethod para elegir cómo se integra el schedule:

Constructor	Esquema subyacente	Cuándo utilizarlo
`AnalogMethod.integrator(matrix_free=True)`	RK4	Default. Fixed-step Runge-Kutta 4; matrix-free is faster for sparse Hamiltonians.
`AnalogMethod.adaptive_integrator(tol=1e-2)`	Dormand-Prince RK4/5	Tamaño de paso adaptativo; `tol` acota el error de fidelidad entre las estimaciones RK4 y RK5.
`AnalogMethod.arnoldi(dim=10, num_substeps=1)`	Krylov / Arnoldi	Puede ofrecer un escalado decente para Hamiltonianos dispersos grandes; ajuste `dim` para el tamaño del subespacio de Krylov.
`AnalogMethod.direct()`	Exponencial de matriz	Esquema de referencia para sistemas pequeños; el coste crece rápidamente con el número de qubits.

Example, using the adaptive integrator for a stiffer schedule:

from qilisdk.backends import AnalogMethod, QiliSim

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

Métodos de simulación digital

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

Opción	Significado
`matrix_free`	Aplica las puertas directamente al vector de estado en lugar de construir matrices densas. Por defecto `True`.
`max_cache_size`	Número máximo de matrices de puerta precomputadas almacenadas en caché entre ejecuciones.
`combine_single_qubit_gates`	Fusiona puertas de un solo qubit adyacentes en una única operación antes de propagar. Desactivado si se utiliza ruido específico de puerta.
`normalize_after_each_gate`	Renormaliza el vector de estado tras cada puerta para mitigar la deriva numérica, con un coste de tiempo de ejecución.

from qilisdk.backends import DigitalMethod, QiliSim

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

Ejecución y Monte Carlo

ExecutionConfig controla los hilos, la aleatoriedad y el muestreo opcional de trayectorias Monte Carlo para simulaciones de sistemas abiertos.

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

Soporte del modelo de ruido

Cualquier NoiseModel aceptado por el SDK se puede pasar directamente al constructor; QiliSim lo aplica dentro del solver de C++, de modo que las ejecuciones digitales, analógicas y de reservorio ven todos los mismos canales de ruido:

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

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

backend = QiliSim(noise_model=nm)