Quickstart

Below are minimal examples to get you running digital circuits and analog evolutions.

Digital Circuit Example

Build a 2-qubit circuit, sample it, and inspect measurement counts:

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

Analog Evolution Example

Define two Hamiltonians, build an interval-based interpolation schedule, and simulate:

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)

Next Steps

Once you’ve confirmed everything works, explore the tutorials section or check out each module for more details:

  • Core primitives (Core) for state vectors, operators, and shared abstractions.

  • Digital workflows (Digital) covering circuit construction, parameter sweeps, and QASM export.

  • Analog workflows (Analog) for Hamiltonian builders, schedules, and time-evolution utilities.

  • Functionals (Functionals) to see how experiments connect models with execution backends.

  • Execution targets (Backends) to compare Qutip (CPU) and CUDA (CPU/GPU) runtimes.

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

  • Cost functions (Cost Functions) for common optimization objectives and metrics.

  • SpeQtrum cloud (SpeQtrum) for account setup, calibration-aware jobs, and result retrieval.

Happy quantum coding!