QiliSim

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, 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 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	Por defecto. Runge-Kutta 4 con paso fijo. Sin matriz es más rápido para Hamiltonianos dispersos.
`AnalogMethod.variational_annealing()`	Recocido variacional	Solo disponible para schedules de recocido de X a Z. Puede usarse para simular sistemas grandes (es decir, 60+ qubits) a costa de la precisión. Establezca order=1 para una simulación más rápida pero menos precisa. Aumentar los calentamientos también puede mejorar la precisión a costa del tiempo.
`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, matrix_free=True)`	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.

Ejemplo, utilizando el integrador adaptativo:

from qilisdk.backends import AnalogMethod, QiliSim

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

Métodos de simulación digital

Actualmente hay dos métodos de simulación digital disponibles. El primero es un simulador de vector de estado, que se puede configurar mediante las opciones:

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

El segundo es un simulador estabilizador, que puede simular de forma eficiente circuitos compuestos por puertas de Clifford y mediciones de Pauli, a costa de ser más lento si el circuito contiene muchas puertas no-Clifford. Tiene las siguientes opciones:

Opción	Significado
`max_states`	Número máximo de términos en la suma de estabilizadores. Aumentarlo puede mejorar la precisión a costa de memoria y tiempo de ejecución.

from qilisdk.backends import DigitalMethod, QiliSim

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

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 controla el número de hilos usados para la paralelización; por defecto usa todos los núcleos disponibles.
seed controla la semilla del generador de números aleatorios; por defecto se usa una semilla aleatoria. Las ejecuciones posteriores incrementan la semilla automáticamente.
monte_carlo=MonteCarloConfig(trajectories=N) activa el muestreo Monte Carlo con N trayectorias; si se omite, Monte Carlo queda desactivado.
measurement_collapse controla si las mediciones colapsan el vector de estado in situ (relevante para mediciones en mitad del circuito y reservorios); por defecto False.
normalize_state controla si el estado debe renormalizarse; por defecto True.
gpu controla si se usa la aceleración por GPU si está disponible; por defecto 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,
    ),
)

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)

Aceleración por GPU

Algunos métodos de simulación de QiliSim admiten la aceleración por GPU si hay disponible un dispositivo compatible con CUDA. Estos requieren instalar el extra cuda:

pip install qilisdk[cuda13]

pip install "qilisdk[cuda13]"

pip install qilisdk[cuda13]

Método	Soporte de GPU
`AnalogMethod.direct()`	❌
`AnalogMethod.integrator()`	❌
`AnalogMethod.adaptive_integrator()`	❌
`AnalogMethod.arnoldi()`	❌
`AnalogMethod.variational_annealing()`	✅
`DigitalMethod.statevector()`	❌
`DigitalMethod.stabilizer()`	❌