Instalación

QiliSDK and its optional extras are distributed via PyPI. Install the core package first, then add any backend or feature modules you need.

Paquete base

pip install qilisdk

Extras opcionales

Aceleración CUDA (soporte de GPU NVIDIA con CudaBackend):
```
pip install qilisdk[cuda]
```
Backend CPU de Qutip (simulación por CPU con QutipBackend):
```
pip install qilisdk[qutip]
```
SpeQtrum (envío a la nube a través de speqtrum):
```
pip install qilisdk[speqtrum]
```

Puede combinar extras:

pip install qilisdk[cuda,qutip,speqtrum]

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 CudaBackend, CudaSamplingMethod
from qilisdk.functionals import Sampling

# 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 Sampling functional
sampling = Sampling(circuit=circuit, nshots=500)

# 3. Execute on GPU
backend = CudaBackend(sampling_method=CudaSamplingMethod.STATE_VECTOR)
results = backend.execute(sampling)

print("Counts:", results.probabilities)

Analog Time Evolution Example

Define two Hamiltonians, build a linear interpolation schedule, and run on Qutip:

import numpy as np
from qilisdk.analog import Schedule, X, Z
from qilisdk.common import ket, tensor_prod
from qilisdk.functionals import TimeEvolution
from qilisdk.backends import QutipBackend

# Total time and step
T, dt = 5.0, 0.1
times = np.linspace(0, T, int(T/dt) + 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))

# Linear schedule: start with H1, end with H2
sched_map = {
    idx: {"h1": 1 - t/T, "h2": t/T}
    for idx, t in enumerate(times)
}
schedule = Schedule(
    T=T,
    dt=dt,
    hamiltonians={"h1": H1, "h2": H2},
    schedule=sched_map,
)

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

# TimeEvolution functional
tevo = TimeEvolution(
    schedule=schedule,
    initial_state=psi0,
    observables=[Z(0)],
    nshots=100,
    store_intermediate_results=True,
)

# Execute on CPU
results = QutipBackend().execute(tevo)
print(results)

Next Steps

Once you’ve confirmed everything works, explore:

Core primitives (Common) 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.
SpeQtrum cloud (SpeQtrum) for account setup, calibration-aware jobs, and result retrieval.
Example gallery (Code Examples) for end-to-end notebooks you can adapt to your workflow.

Happy quantum coding!