Inicio rápido

A continuación se muestran ejemplos mínimos para poner en marcha circuitos digitales y evoluciones analógicas.

Ejemplo de Circuito Digital

Construya un circuito de 2 qubits, muestréelo e inspeccione los recuentos de medición:

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

# 1. Define a simple 2‑qubit circuit
circuit = Circuit(2)
circuit.add(H(0))
circuit.add(RX(1, theta=np.pi / 2))
circuit.add(CNOT(0, 1))

# 2. Wrap it in a DigitalPropagation functional
propagation = DigitalPropagation(circuit=circuit)

# 3. Execute on GPU with sampling readout
backend = QiliSim()
results = backend.execute(propagation, Readout().with_sampling(nshots=500))

print("Counts:", results.get_probabilities())

Ejemplo de Evolución Analógica

Defina dos Hamiltonianos, construya una programación de interpolación basada en intervalos y simule:

from qilisdk.analog import Schedule, X, Z
from qilisdk.core import ket, tensor_prod
from qilisdk.functionals import AnalogEvolution
from qilisdk.backends import QiliSim
from qilisdk.readout import Readout

# Total time and step
T, dt = 5.0, 0.1

# Hamiltonians H1 = ∑ X, H2 = ∑ Z
n = 1
H1 = sum(X(i) for i in range(n))
H2 = sum(Z(i) for i in range(n))

# Define coefficients over the full interval with automatic sampling
schedule = Schedule(
    hamiltonians={"h1": H1, "h2": H2},
    coefficients={
        "h1": {(0.0, T): lambda t: 1 - t / T},
        "h2": {(0.0, T): lambda t: t / T},
    },
    dt=dt,
)

# Initial state |+⟩
psi0 = tensor_prod([(ket(0) - ket(1)).unit() for _ in range(n)]).unit()

# AnalogEvolution functional
evolution = AnalogEvolution(
    schedule=schedule,
    initial_state=psi0,
    store_intermediate_results=True,
)

# Execute on CPU with expectation readout
results = QiliSim().execute(
    evolution,
    Readout().with_expectation(observables=[Z(0)]).with_state_tomography(),
)
print(results)

Próximos pasos

Una vez que haya confirmado que todo funciona, explore la sección de tutoriales o consulte cada módulo para obtener más detalles:

• Primitivas del núcleo (Core) para vectores de estado, operadores y abstracciones compartidas.

• Flujos de trabajo digitales (Digital) que cubren la construcción de circuitos, barridos de parámetros y exportación QASM.

• Flujos de trabajo analógicos (Analog) para constructores de Hamiltonianos, programaciones y utilidades de evolución temporal.

• Funcionales (Functionals) para ver cómo los experimentos conectan modelos con backends de ejecución.

• Objetivos de ejecución (Backends) para comparar los tiempos de ejecución de Qutip (CPU) y CUDA (CPU/GPU).

• Noise (Noise) to simulate hardware effects in both digital and analog contexts.

• Funciones de coste (Cost Functions) para objetivos de optimización y métricas comunes.

• Nube SpeQtrum (SpeQtrum) para la configuración de cuentas, trabajos con calibración y recuperación de resultados.

¡Feliz programación cuántica!