Quick Start

BlueQubit Python SDK is a quantum computing SDK that lets you build, optimize, and run quantum circuits on BlueQubit platform from Python. Whether you need quantum simulation on large CPU/GPU devices or quantum circuit optimization at scale, this quantum development kit has you covered.

  1. Register on https://app.bluequbit.io and copy the API token.

  2. Install the quantum computing Python package from PyPI:

pip install bluequbit

  1. Import and initialize the quantum Python SDK (importing also Qiskit for circuit building):

import qiskit

import bluequbit

bq_client = bluequbit.init("<token>")

  1. Quick example of how to run a quantum circuit using the quantum SDK:

qc_qiskit = qiskit.QuantumCircuit(2)
qc_qiskit.h(0)
qc_qiskit.x(1)

job_result = bq_client.run(qc_qiskit, job_name="testing_1")

state_vector = job_result.get_statevector()
# returns a NumPy array of [0. +0.j 0. +0.j 0.70710677+0.j 0.70710677+0.j]

More Examples

  1. Here is an example to run the previous code asynchronously:

# This line is non-blocking.
job = bq_client.run(qc_qiskit, job_name="testing_1", asynchronous=True)

# This line blocks until the job is completed.
job_result = bq_client.wait(job.job_id)

# If you want to cancel a pending job.
bq_client.cancel(job.job_id)

  1. This is how you can use our mps.cpu device for quantum simulation:

# a 40 qubit GHZ state
num_qubits = 40
qc = qiskit.QuantumCircuit(num_qubits)
qc.h(0)
for i in range(num_qubits - 1):
     qc.cx(i, i+1)

qc.measure_all()

options = {
    "mps_bond_dimension": 2,
}
result = bq_client.run(qc, device="mps.cpu", options=options) # should take ~30seconds
print(result.get_counts())

The mps.gpu device can be used in the same way for accelerated quantum simulation. Note that while mps.gpu is faster, you need to have a certain amount of minimal balance to be able to use it.

  1. To run our Pauli Path simulation for computing observable expectations:

# Only Qiskit Circuits are supported
qc = qiskit.QuantumCircuit(3)
qc.h(0)
qc.h(1)
qc.h(2)
qc.ry(0.3, 0)
qc.rz(0.6, 1)
qc.rx(0.7, 2)

pauli_sum = [
    ("XYZ", 0.5),
    ("XXX", 0.2),
    ("XII", 0.3),
    ("III", 0.4),
]

options = {
    "pauli_path_truncation_threshold": 0.1,
}
result = bq_client.run(qc, device="pauli-path", pauli_sum=pauli_sum, options=options)
print(result.expectation_value)
# compare with "mps.cpu"
result_mps = bq_client.run(qc, device="mps.cpu", pauli_sum=pauli_sum)
print(result_mps.expectation_value) # exact

  1. An example of how to run a Pennylane circuit using the SDK:

import pennylane as qml
from pennylane import numpy as np

# use "bluequbit.cpu" device name to run on CPU
dev = qml.device("bluequbit.cpu", wires=1, token="<token>")
# use "bluequbit.gpu" device name to run on GPU
# dev = qml.device("bluequbit.gpu", wires=1, token="<token>")

@qml.qnode(dev)
def circuit(angle):
    qml.RY(angle, wires=0)
    return qml.probs(wires=0)


probabilities = circuit(np.pi / 4)
# returns a NumPy array of [0.85355339 0.14644661]

To use the Pennylane plugin, you must have pennylane version 0.39 or above installed. bluequbit.cpu supports Pennylane circuits with up to 32 qubits (wires). bluequbit.gpu supports Pennylane circuits with up to 33 qubits (wires).

  1. This SDK requires Python versions 3.10 or above. The package is tested extensively on Python 3.10.

Questions and Issues

Please submit questions and issues to info@bluequbit.io.