Wolfram Language Paclet Repository
Community-contributed installable additions to the Wolfram Language
Connecting to QPU Services
Connecting to QPU Services
The Wolfram Quantum Framework lets you build, simulate and analyze quantum circuits symbolically and numerically. The same circuit object can also be sent to real quantum processing units (QPUs) hosted in the cloud. This tutorial covers the three pieces you need for that: OpenQASM, the portable text format that QPUs speak; the IBM Quantum platform; and Amazon Braket, which exposes several hardware vendors through a single service.
Everything in the OpenQASM section runs locally with no account. The hardware sections need credentials with the respective provider, and those cells are marked so you can read the tutorial without running them. For help, write to quantum@wolfram.com.
In[1]:=
<<Wolfram`QuantumFramework`
OpenQASM: the common language of QPUs
OpenQASM: the common language of QPUs
A quantum circuit built in the Wolfram Language is a symbolic object. To run it on hardware it has to be expressed in a format the device understands, and the de facto standard is OpenQASM. Both IBM and Amazon Braket accept OpenQASM, so it is the bridge between a and the cloud.
QuantumCircuitOperator
Build a small reference circuit that we reuse throughout: a three-qubit GHZ state , followed by a quantum Fourier transform and a measurement of all three qubits.
|GHZ〉=(|000〉+|111〉)
1
2
In[2]:=
qc=
[{"GHZ","Fourier"[3],{1,2,3}}];qc["Diagram"]
 | QuantumCircuitOperator |
QuantumQASM
In[3]:=
QuantumQASM[qc]
The hub is also an importer: handing OpenQASM source (or a file) back to reconstructs the circuit, again with no external dependency. The round trip recovers a circuit equal to the original:
.qasm
QuantumCircuitOperator
In[4]:=
 | QuantumCircuitOperator |
OpenQASM 3.0 is the native and recommended target. For older toolchains that still require the legacy gate set, pass to emit OpenQASM 2.0. This path renders through Qiskit, so it needs the Python Qiskit stack configured:
qelib1.inc
"Version"->2
In[5]:=
QuantumQASM[qc,"Version"2]
IBM Quantum
IBM Quantum
Connecting to the IBM Quantum Platform
Connecting to the IBM Quantum Platform
Create an account at . From the dashboard you need two things: an IAM API key (the long secret string shown once when you create the key, not the key's display name) and the instance CRN (a string identifying your instance).
crn:v1:…
The API key is a secret and is stored in your encrypted system credential store. The CRN is read from a local symbol that the connection consults when it builds the request headers, so set both before connecting:
In[6]:=
api="XXX";LocalSymbol["ibm_crn"]="XXX";
Loading the Wolfram Quantum Framework registers the IBM Quantum Platform service automatically, so recognizes the name directly:
"IBMQuantumPlatform"
In[7]:=
ibm=ServiceConnect["IBMQuantumPlatform","New",Authentication{"apikey"api}]
A connected service object lists the QPUs your account can reach through . Submitting and retrieving jobs is handled for you by and the handle, shown below. List the available backends:
"Backends"
IBMJobSubmit
IBMJob
In[8]:=
ibm["Backends"]
Inspecting a backend
Inspecting a backend
Before committing a circuit to a device, you can see its live calibration as an error map: the qubit lattice with the gate error, the static crosstalk, the relaxation time , and the readout error painted on at once. This reads only the free metadata endpoints, so it runs no circuit and spends no quantum time.
cz
ZZ
T
1
In[9]:=
ibm["ErrorMap","Backend""ibm_fez"]
The same calibration is available as data through and its per-pair and per-qubit projections (, , , , , and the rest), which is how you compare devices before choosing one for . For the full picture see .
ibm["DeviceModel","Backend"->"ibm_fez"]
"CouplingMap"
"CZErrors"
"ZZ"
"ReadoutErrors"
"Coherence"
IBMJobSubmit
Building and checking a circuit
Building and checking a circuit
Using the circuit from the previous section, plot its exact output distribution: the noiseless ground truth a QPU run approximates, and the reference we overlay with the hardware counts:
qc
In[10]:=
qc[]["ProbabilityPlot"]
Before spending QPU time, you can sample the circuit on a local noiseless simulator. 's interface runs through a local Qiskit Aer simulator when no provider is given, returning a whose statistics converge to the exact distribution as the shot count grows (this needs the Python Qiskit stack):
QuantumCircuitOperator
"Qiskit"
QuantumMeasurement
In[11]:=
qc["Qiskit"]["Shots"4096]["ProbabilityPlot"]
Running on hardware
Running on hardware
With an active connection, is the one call that runs a circuit on a QPU. It transpiles the circuit against the backend's own error-aware (per-instruction error and duration), submits it through the primitive, and returns immediately with an asynchronous handle while the job sits in the queue. There is no manual OpenQASM, no raw request and no hex decoding of the classical register: the handle carries the per-bit to qubit map captured at transpile time, so results come back already in the Wolfram Language qubit order.
IBMJobSubmit
Target
SamplerV2
IBMJob
In[12]:=
job=IBMJobSubmit[qc,"ibm_fez"]
The handle reports the job's status. Poll it while the job is queued, or pass to to block until the job reaches a terminal status:
"Wait"->True
IBMJobSubmit
In[13]:=
job["Status"]
Refresh the handle to pull a fresh snapshot from the service. Once the status is , applying the handle returns the measurement reconstructed from the hardware counts, in the Wolfram Language qubit order:
"Completed"
In[14]:=
qpu=job["Refresh"][]
The same handle keeps every response IBM returns under and exposes curated accessors on top, so the run's metadata is one query away. For example, the billed quantum runtime:
"Raw"
In[15]:=
job["QuantumSeconds"]
Comparing exact and hardware results
Comparing exact and hardware results
Putting the exact distribution next to the hardware run shows the structure surviving the device noise: the dominant , and outcomes and the near-zero all come through, with the noise flattening the distribution. The hardware values below are from a recorded run:
000
001
111
100
qpu["Probabilities"]
ibm_fez
In[16]:=
exact=N[Values[KeySort[FullSimplify/@qc[]["Probabilities"]]]];hardware=Values@KeySort@{0,0,0}0.255,{0,0,1}0.197,{0,1,0}0.149,{0,1,1}0.054,{1,0,0}0.019,{1,0,1}0.035,{1,1,0}0.120,{1,1,1}0.171;BarChart[Transpose[{exact,hardware}],ChartLegends{"Exact WL","QPU ibm_fez"},ChartLabels{Tuples[{0,1},3],None},FrameTrue,AspectRatio1/2]
The differences are not in the queries but in device noise: each shot passes through a deep transpiled circuit on superconducting hardware, and the noise varies from job to job.
Amazon Braket
Amazon Braket
Amazon Braket is a quantum computing service on (AWS). Unlike IBM, which exposes its own superconducting devices, Braket fronts several vendors (IonQ, Rigetti, QuEra and others) and on-demand simulators through one API, which makes it convenient for comparing technologies side by side. The Wolfram Language reaches it through the standard AWS service connection.
Connecting to AWS
Connecting to AWS
Connect to AWS with your credentials (access key ID and secret access key); see the workflow for details on storing them:
In[17]:=
aws=ServiceConnect["AWS","New"]
Braket writes every task result to an S3 bucket, so you reach two AWS services through the connection: S3 for storage and Braket for the quantum tasks. If you do not have an S3 bucket yet, first:
In[18]:=
s3=ServiceExecute[aws,"GetService",{"Name""S3"}];braket=ServiceExecute[aws,"GetService",{"Name""Braket"}];
Finding devices
Finding devices
List the available devices, both simulators and QPUs:
In[19]:=
devices=braket["SearchDevices","Filters"{}]["Devices",All];devices[All,{"DeviceName","DeviceType","DeviceStatus"}]
Select one on-demand simulator (Amazon's state-vector simulator SV1) and one QPU by their Amazon Resource Names (ARNs), decoding each device's capabilities from JSON:
In[20]:=
sim=devices[SelectFirst[#DeviceArn"arn:aws:braket:::device/quantum-simulator/amazon/sv1"&],MapAt[ImportString[#,"RawJSON"]&,"DeviceCapabilities"]];qpu=devices[SelectFirst[StringContainsQ[#DeviceArn,"ionq"]&],MapAt[ImportString[#,"RawJSON"]&,"DeviceCapabilities"]];
Preparing the circuit as OpenQASM
Preparing the circuit as OpenQASM
Build the circuit, then express it as OpenQASM for submission. Braket accepts OpenQASM, so the native output is a good way to inspect exactly what will be sent:
QuantumQASM
In[21]:=
qc=
[{"GHZ","Fourier"[3],{1,2,3}}];QuantumQASM[qc]
| QuantumCircuitOperator |
For submission to a specific Braket backend it is safest to render the device dialect of OpenQASM, which maps the circuit onto that vendor's supported gate set. Passing to the Qiskit interface does this conversion (it needs the Python Qiskit and Braket providers configured):
"Provider"->"AWSBraket"
In[22]:=
qasm=qc["Qiskit"]["QASM","Provider""AWSBraket"];
Submitting a quantum task
Submitting a quantum task
A Braket job is a "quantum task". Submit the OpenQASM as the task action, naming the device ARN, the destination S3 bucket and the number of shots. Run it once on the simulator:
In[23]:=
taskSV1=braket["CreateQuantumTask","DeviceArn"sim["DeviceArn"],"Shots"100,"Action"braketSchemaHeadername"braket.ir.openqasm.program",version"1",sourceqasm,"OutputS3Bucket""amazon-braket-my-bucket","OutputS3KeyPrefix""tasks","RequestRegion""us-east-1"]
The same call against the QPU ARN queues a hardware run:
In[24]:=
taskIonQ=braket["CreateQuantumTask","DeviceArn"qpu["DeviceArn"],"Shots"100,"Action"braketSchemaHeadername"braket.ir.openqasm.program",version"1",sourceqasm,"OutputS3Bucket""amazon-braket-my-bucket","OutputS3KeyPrefix""tasks","RequestRegion""us-east-1"]
Checking status and fetching results
Checking status and fetching results
Query a task by its ARN. The simulator usually completes in seconds; a QPU task may sit until the device is available:
QUEUED
In[25]:=
braket["GetQuantumTask","QuantumTaskArn"taskSV1["quantumTaskArn"],"RequestRegion""us-east-1"]["status"]
The result is written to S3. Locate its directory, then read from the bucket:
results.json
In[26]:=
outputPath=braket["GetQuantumTask","QuantumTaskArn"taskSV1["quantumTaskArn"],"RequestRegion""us-east-1"]["outputS3Directory"];results=ImportByteArray[s3["GetObject","Bucket""amazon-braket-my-bucket","Key"FileNameJoin[{outputPath,"results.json"}],"RequestRegion""us-east-1"]["Body"],"RawJSON"];
Comparing exact and simulator results
Comparing exact and simulator results