QHEAppE — Quantum-as-a-Service through HEAppE

Access IQM quantum hardware through the LEXIS Platform via HEAppE.

Documentation: https://it4innovations.github.io/quantum-as-a-service/

Requirements

• Python 3.12
• required Python packages: see dependencies in pyproject.toml

Architecture

Quick start

QHEAppE is available on PyPI, so you can install it easily using pip.

pip install qaas --extra-index-url https://opencode.it4i.eu/api/v4/projects/107/packages/pypi/simple

Alternatively, you can install the latest (development) version using:

pip install git+https://github.com/It4innovations/quantum-as-a-service.git@main --extra-index-url https://opencode.it4i.eu/api/v4/projects/107/packages/pypi/simple

Example usage:

from qaas import QProvider
from qiskit import QuantumCircuit

backend  = QProvider("my_project").get_backend("EQE1-CZ-P0001")
# Argument 'token' is optional
# from py4lexis.session import LexisSession
# token = LexisSession().get_access_token()
# backend  = QProvider("my_project", token=lexis_access_token).get_backend("EQE1-CZ-P0001")

qc = QuantumCircuit(2, 2)
qc.h(0); qc.cx(0, 1); qc.measure_all()

counts = backend.run(backend.transpile(qc), shots=1000).result().get_counts()
print(counts)

Also OpenQASM is supported on input:

from qaas import export_qasm3_with_custom_move as qasm3dumps

qc = QuantumCircuit(2, 2)
qc.h(0); qc.cx(0, 1); qc.measure_all()

qasm_transpiled_qc:str = qasm3dumps(backend.transpile(qc))

counts = backend.run([qasm_transpiled_qc], shots=1000).result().get_counts()
print(counts)

IQM Pulla

from qiskit import QuantumCircuit, visualization
from qiskit.compiler import transpile
from iqm.qiskit_iqm.iqm_transpilation import optimize_single_qubit_gates
from iqm.pulla.utils_qiskit import sweep_job_to_qiskit
from qaas.client import QProvider, QBackend
from qaas.client.qpulla import qiskit_to_pulla, QPullaBackendIQM

SHOTS = 100

provider = QProvider("my_project")
client = provider.get_client(lexis_resource_name)
dqa = client.get_dynamic_architecture()
compiler = p.get_standard_compiler()
# Create Pulla instance
p = provider.get_pulla(lexis_resource_name)
pulla_backend: QPullaBackendIQM = QPullaBackendIQM(dqa,p,compiler)

qc_transpiled = backend.transpile(
   qc,
   layout_method='sabre',
   optimization_level=0
)
# Optimize single-qubit gates
qc_optimized = optimize_single_qubit_gates(qc_transpiled)

circuits, compiler = qiskit_to_pulla(p, pulla_backend, [qc_optimized])

# Build settings for execution
settings = compiler.get_settings(circuits[0])
settings.set_shots(SHOTS) # optional
# Compile to playlist
run_definition, context = compiler.compile(circuits, settings=settings)

# Submit playlist returns SweepJob
job = p.submit_playlist(run_definition, context=context)
job.wait_for_completion()

# Get raw results
raw_results = job.result()

# Convert to Qiskit result format
qiskit_result = sweep_job_to_qiskit(
   job,
   shots=SHOTS
)
# Qiskit Counts
counts = qiskit_result.get_counts()

How to Fetch Calibration Data

Use the client to retrieve a calibration set by its UUID. To retrieve the default calibration set, pass None instead.

from uuid import UUID

from qaas.client import QProvider

provider = QProvider("my_project")
client = provider.get_client(lexis_resource_name)

calibration_set = client.get_calibration_set(
    UUID("3a83e2f3-c5a8-43b7-9aa1-e9738ca3204b")
)

default_calibration_set = client.get_calibration_set(None)

Authors

• Jan Swiatkowski (jan.swiatkowski@vsb.cz)
• Jakub Konvička (jakub.konvicka@vsb.cz)
• Jan Martinovič (jan.martinovic@vsb.cz)
• Ladislav Foltyn (ladislav.foltyn@vsb.cz)

License

Apache 2.0 — see LICENSE.