](https://account.qbraid.com?gitHubUrl=https://github.com/qBraid/qbraid-lab-demo.git)
-qBraid is a cloud-based platform for quantum computing.
+## Contents
+
+This repository features tutorials and examples for the following:
+
+- [**qBraid-SDK**](https://docs.qbraid.com/sdk/): Learn how to interact with quantum devices using the qBraid Runtime framework.
+- [**qBraid-QIR**](https://docs.qbraid.com/qir/): Explore qBraid's Quantum Intermediate Representation (QIR) interface using familiar frameworks like OpenQASM 3 and Cirq.
+- [**qBraid-CLI**](https://docs.qbraid.com/cli/): Understand how to manage quantum jobs and resources using qBraid's Command Line Interface.
+- [**qBraid-Lab**](https://docs.qbraid.com/lab/) Integration:
+ - [**Quantum Jobs**](https://docs.qbraid.com/lab/user-guide/quantum-jobs): Learn how to submit and manage quantum jobs in qBraid Lab.
+ - [**GPUs**](https://docs.qbraid.com/lab/user-guide/gpus): Learn how to accelerate your quantum simulations using GPUs available through qBraid Lab.
+
+## Documentation and Resources
+
+For more information on qBraid and its tools, check out:
+
+- **qBraid Platform Documentation**: Comprehensive user guides and resources at [docs.qbraid.com](https://docs.qbraid.com/).
+- **qBraid Software API Reference**: Detailed API documentation for the qBraid-SDK at [sdk.qbraid.com](https://sdk.qbraid.com/).
+- **qBraid GitHub Community**: Join the discussion and contribute at [GitHub Community Page](https://github.com/qBraid/community).
-This repository provides demos and tutorials on using the [qBraid SDK](https://github.com/qBraid/qBraid), [qBraid CLI](https://docs.qbraid.com/projects/cli/en/latest/cli/qbraid.html), and qBraid Lab features including [Quantum Jobs](https://docs.qbraid.com/projects/lab/en/latest/lab/quantum_jobs.html), and [GPUs](https://docs.qbraid.com/projects/lab/en/latest/lab/gpu.html).
+## Contribution
-For more resources and reference material, see [qBraid Docs](https://docs.qbraid.com/en/latest/).
+Contributions to this repository are welcome! If you encounter any issues or would like to contribute improvements or new examples, please open an issue or submit a pull request.
diff --git a/algorithms/quantum_opt_rl/QCO.ipynb b/algorithms/quantum_opt_rl/QCO.ipynb
index bce0d12..754614f 100644
--- a/algorithms/quantum_opt_rl/QCO.ipynb
+++ b/algorithms/quantum_opt_rl/QCO.ipynb
@@ -230,9 +230,7 @@
"# Adjust the optimization level to see how the number of passes changes\n",
"pass_manager = generate_preset_pass_manager(3, backend)\n",
"\n",
- "print(\n",
- " f\"The pass manager for {FakeGuadalupeV2.backend_name} has the following passes: \\n\"\n",
- ")\n",
+ "print(f\"The pass manager for {FakeGuadalupeV2.backend_name} has the following passes: \\n\")\n",
"\n",
"# Print out the passes in the pass manager\n",
"for i, pass_ in enumerate(pass_manager.passes()):\n",
@@ -406,9 +404,7 @@
"optimization_levels = [0, 1, 2, 3]\n",
"\n",
"\n",
- "def optimize_circuits(\n",
- " circuit: QuantumCircuit, optimization_levels: List[int]\n",
- ") -> List[float]:\n",
+ "def optimize_circuits(circuit: QuantumCircuit, optimization_levels: List[int]) -> List[float]:\n",
" \"\"\"Optimize the circuit at each optimization level\"\"\"\n",
" # Create an empty list to store the times\n",
" times = []\n",
@@ -856,9 +852,7 @@
],
"source": [
"# 1q gate optimization\n",
- "commutative_cancellation = PassManager(\n",
- " [CommutativeCancellation(basis_gates=[\"cx\", \"u\", \"id\"])]\n",
- ")\n",
+ "commutative_cancellation = PassManager([CommutativeCancellation(basis_gates=[\"cx\", \"u\", \"id\"])])\n",
"\n",
"# Get the result circuit\n",
"result = commutative_cancellation.run(circuit)\n",
@@ -1366,11 +1360,11 @@
"metadata": {},
"outputs": [],
"source": [
- "sub_batch_size = 64 # cardinality of the sub-samples gathered from the current data in the inner loop\n",
- "num_epochs = 10 # optimization steps per batch of data collected\n",
- "clip_epsilon = (\n",
- " 0.2 # clip value for PPO loss: see the equation in the intro for more context.\n",
+ "sub_batch_size = (\n",
+ " 64 # cardinality of the sub-samples gathered from the current data in the inner loop\n",
")\n",
+ "num_epochs = 10 # optimization steps per batch of data collected\n",
+ "clip_epsilon = 0.2 # clip value for PPO loss: see the equation in the intro for more context.\n",
"gamma = 0.99\n",
"lmbda = 0.95\n",
"entropy_eps = 1e-4"
@@ -1623,9 +1617,7 @@
],
"source": [
"actor_net = agent.model\n",
- "policy_module = TensorDictModule(\n",
- " actor_net, in_keys=[\"observation\"], out_keys=[\"loc\", \"scale\"]\n",
- ")\n",
+ "policy_module = TensorDictModule(actor_net, in_keys=[\"observation\"], out_keys=[\"loc\", \"scale\"])\n",
"print(env.action_spec.shape[-1])\n",
"\n",
"policy_module = ProbabilisticActor(\n",
@@ -1767,9 +1759,7 @@
}
],
"source": [
- "advantage_module = GAE(\n",
- " gamma=gamma, lmbda=lmbda, value_network=value_module, average_gae=True\n",
- ")\n",
+ "advantage_module = GAE(gamma=gamma, lmbda=lmbda, value_network=value_module, average_gae=True)\n",
"print(advantage_module.__dict__)\n",
"lr = 3e-4\n",
"\n",
@@ -1789,9 +1779,7 @@
"# loss_module = loss_module.set_keys\n",
"\n",
"optim = torch.optim.Adam(loss_module.parameters(), lr)\n",
- "scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(\n",
- " optim, total_frames // frames_per_batch, 0.0\n",
- ")"
+ "scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optim, total_frames // frames_per_batch, 0.0)"
]
},
{
@@ -1828,9 +1816,7 @@
" subdata = replay_buffer.sample(sub_batch_size)\n",
" loss_vals = loss_module(subdata.to(device))\n",
" loss_value = (\n",
- " loss_vals[\"loss_objective\"]\n",
- " + loss_vals[\"loss_critic\"]\n",
- " + loss_vals[\"loss_entropy\"]\n",
+ " loss_vals[\"loss_objective\"] + loss_vals[\"loss_critic\"] + loss_vals[\"loss_entropy\"]\n",
" )\n",
"\n",
" # Optimization: backward, grad clipping and optimization step\n",
@@ -1843,9 +1829,7 @@
"\n",
" logs[\"reward\"].append(tensordict_data[\"next\", \"reward\"].mean().item())\n",
" pbar.update(tensordict_data.numel() * frame_skip)\n",
- " cum_reward_str = (\n",
- " f\"average reward={logs['reward'][-1]: 4.4f} (init={logs['reward'][0]: 4.4f})\"\n",
- " )\n",
+ " cum_reward_str = f\"average reward={logs['reward'][-1]: 4.4f} (init={logs['reward'][0]: 4.4f})\"\n",
" logs[\"step_count\"].append(tensordict_data[\"step_count\"].max().item())\n",
" stepcount_str = f\"step count (max): {logs['step_count'][-1]}\"\n",
" logs[\"lr\"].append(optim.param_groups[0][\"lr\"])\n",
@@ -1861,9 +1845,7 @@
" # execute a rollout with the trained policy\n",
" eval_rollout = env.rollout(1000, policy_module)\n",
" logs[\"eval reward\"].append(eval_rollout[\"next\", \"reward\"].mean().item())\n",
- " logs[\"eval reward (sum)\"].append(\n",
- " eval_rollout[\"next\", \"reward\"].sum().item()\n",
- " )\n",
+ " logs[\"eval reward (sum)\"].append(eval_rollout[\"next\", \"reward\"].sum().item())\n",
" logs[\"eval step_count\"].append(eval_rollout[\"step_count\"].max().item())\n",
" eval_str = (\n",
" f\"eval cumulative reward: {logs['eval reward (sum)'][-1]: 4.4f} \"\n",
diff --git a/algorithms/quantum_opt_rl/gym-examples/gym_examples/envs/quantum_env.py b/algorithms/quantum_opt_rl/gym-examples/gym_examples/envs/quantum_env.py
index 8a979d5..5fc87f8 100644
--- a/algorithms/quantum_opt_rl/gym-examples/gym_examples/envs/quantum_env.py
+++ b/algorithms/quantum_opt_rl/gym-examples/gym_examples/envs/quantum_env.py
@@ -89,12 +89,8 @@ def create_random_circuit(self, seed: Optional[int] = None) -> QuantumCircuit:
"""
if seed is not None:
np.random.seed(seed)
- qc_1 = random_circuit(
- self.num_qubits, np.random.randint(self.min_depth, self.max_depth)
- )
- qc_2 = random_circuit(
- self.num_qubits, np.random.randint(self.min_depth, self.max_depth)
- )
+ qc_1 = random_circuit(self.num_qubits, np.random.randint(self.min_depth, self.max_depth))
+ qc_2 = random_circuit(self.num_qubits, np.random.randint(self.min_depth, self.max_depth))
qc_1.compose(qc_2, inplace=True)
@@ -121,9 +117,7 @@ def _create_tensor_from_circuit(self, circuit: QuantumCircuit) -> torch.Tensor:
"""
# The tensor is of shape (num_qubits, num_gates, num_params)
- circuit_tensor = torch.zeros(
- (circuit.num_qubits, len(self.qiskit_gates), self.num_actions)
- )
+ circuit_tensor = torch.zeros((circuit.num_qubits, len(self.qiskit_gates), self.num_actions))
for _, op in enumerate(circuit):
name = op.operation.name
@@ -142,9 +136,7 @@ def _create_tensor_from_circuit(self, circuit: QuantumCircuit) -> torch.Tensor:
def get_qiskit_gates(self, seed: Optional[int] = None):
"""Returns a dictionary of all qiskit gates with random parameters"""
qiskit_gates = {
- attr: None
- for attr in dir(standard_gates)
- if attr[0] in string.ascii_uppercase
+ attr: None for attr in dir(standard_gates) if attr[0] in string.ascii_uppercase
}
# Add random parameters to gates for circuit generation
@@ -156,9 +148,7 @@ def get_qiskit_gates(self, seed: Optional[int] = None):
]
params = self._generate_params(varnames, seed=seed)
qiskit_gates[gate] = getattr(standard_gates, gate)(**params)
- qiskit_gates = OrderedDict(
- {v.name: v for _, v in qiskit_gates.items() if v is not None}
- )
+ qiskit_gates = OrderedDict({v.name: v for _, v in qiskit_gates.items() if v is not None})
# Add iSwap gate
qiskit_gates["iswap"] = iSwapGate()
return qiskit_gates
diff --git a/qbraid_lab/fire_opal/get-started.ipynb b/qbraid_lab/fire_opal/get-started.ipynb
index 415953e..934aa90 100644
--- a/qbraid_lab/fire_opal/get-started.ipynb
+++ b/qbraid_lab/fire_opal/get-started.ipynb
@@ -354,9 +354,7 @@
"metadata": {},
"outputs": [],
"source": [
- "supported_devices = fireopal.show_supported_devices(credentials=credentials)[\n",
- " \"supported_devices\"\n",
- "]\n",
+ "supported_devices = fireopal.show_supported_devices(credentials=credentials)[\"supported_devices\"]\n",
"for name in supported_devices:\n",
" print(name)"
]
@@ -501,9 +499,7 @@
],
"source": [
"print(f\"Success probability: {100 * bitstring_results[0]['11111111111']:.2f}%\")\n",
- "plot_bv_results(\n",
- " bitstring_results[0], hidden_string=\"11111111111\", title=f\"Fire Opal ($n=11$)\"\n",
- ")"
+ "plot_bv_results(bitstring_results[0], hidden_string=\"11111111111\", title=f\"Fire Opal ($n=11$)\")"
]
},
{
@@ -552,15 +548,11 @@
"circuit_qiskit = qiskit.QuantumCircuit.from_qasm_str(circuit_qasm)\n",
"ibm_result = sampler.run(circuit_qiskit).result()\n",
"ibm_probabilities = (\n",
- " ibm_result.quasi_dists[0]\n",
- " .nearest_probability_distribution()\n",
- " .binary_probabilities(num_bits=11)\n",
+ " ibm_result.quasi_dists[0].nearest_probability_distribution().binary_probabilities(num_bits=11)\n",
")\n",
"\n",
"print(f\"Success probability: {100 * ibm_probabilities['11111111111']:.2f}%\")\n",
- "plot_bv_results(\n",
- " ibm_probabilities, hidden_string=\"11111111111\", title=f\"{backend_name} ($n=11$)\"\n",
- ")"
+ "plot_bv_results(ibm_probabilities, hidden_string=\"11111111111\", title=f\"{backend_name} ($n=11$)\")"
]
},
{
diff --git a/qbraid_lab/gpu/cirq_VQE_cuQuantum.ipynb b/qbraid_lab/gpu/cirq_VQE_cuQuantum.ipynb
index d2afd5b..591cbbf 100644
--- a/qbraid_lab/gpu/cirq_VQE_cuQuantum.ipynb
+++ b/qbraid_lab/gpu/cirq_VQE_cuQuantum.ipynb
@@ -444,9 +444,7 @@
"def energy_func(length, h, jr, jc):\n",
" def energy(measurements):\n",
" # Reshape measurement into array that matches grid shape.\n",
- " meas_list_of_lists = [\n",
- " measurements[i * length : (i + 1) * length] for i in range(length)\n",
- " ]\n",
+ " meas_list_of_lists = [measurements[i * length : (i + 1) * length] for i in range(length)]\n",
" # Convert true/false to +1/-1.\n",
" pm_meas = 1 - 2 * np.array(meas_list_of_lists).astype(np.int32)\n",
"\n",
diff --git a/qbraid_lab/gpu/lightning_gpu_benchmark.ipynb b/qbraid_lab/gpu/lightning_gpu_benchmark.ipynb
index 4bc5129..5853c9c 100644
--- a/qbraid_lab/gpu/lightning_gpu_benchmark.ipynb
+++ b/qbraid_lab/gpu/lightning_gpu_benchmark.ipynb
@@ -177,9 +177,7 @@
" qml.CNOT(wires=[i, (i + 1) % n_wires])\n",
"\n",
" # Measure all qubits\n",
- " observables = [qml.PauliZ(n_wires - 1)] + [\n",
- " qml.Identity(i) for i in range(n_wires - 1)\n",
- " ]\n",
+ " observables = [qml.PauliZ(n_wires - 1)] + [qml.Identity(i) for i in range(n_wires - 1)]\n",
" return qml.expval(qml.operation.Tensor(*observables))"
]
},
diff --git a/qbraid_lab/quantum_jobs/aws_iqm_quantum_jobs.ipynb b/qbraid_lab/quantum_jobs/aws_iqm_quantum_jobs.ipynb
index 200a5f7..0c76ab0 100644
--- a/qbraid_lab/quantum_jobs/aws_iqm_quantum_jobs.ipynb
+++ b/qbraid_lab/quantum_jobs/aws_iqm_quantum_jobs.ipynb
@@ -106,9 +106,7 @@
"\n",
"# The IQM Garnet device\n",
"device = AwsDevice(\"arn:aws:braket:eu-north-1::device/qpu/iqm/Garnet\")\n",
- "supported_gates = device.properties.action[\n",
- " \"braket.ir.openqasm.program\"\n",
- "].supportedOperations\n",
+ "supported_gates = device.properties.action[\"braket.ir.openqasm.program\"].supportedOperations\n",
"# print the supported gate set\n",
"print(\"Gate set supported by the IQM device:\\n\", supported_gates)"
]
diff --git a/qbraid_qir/autoqasm_deutsch_jozsa.ipynb b/qbraid_qir/autoqasm_deutsch_jozsa.ipynb
new file mode 100644
index 0000000..fbdf957
--- /dev/null
+++ b/qbraid_qir/autoqasm_deutsch_jozsa.ipynb
@@ -0,0 +1,323 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Deutsch-Jozsa Algorithm with Imperative Computation (AutoQASM)\n",
+ "\n",
+ "This notebook will introduce the Deutsch-Joszsa problem and solution. We then implement the quantum solution with AutoQASM, demonstrating it's success by submitting quantum jobs to qBraid's QIR simulator."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Introduction\n",
+ "\n",
+ "### The Problem\n",
+ "We are given a hidden decision function $f: \\mathbb \\{0, 1\\}^n \\to \\{0, 1\\}$. For this problem, we assume any such $f$ is either \"balanced\" or \"constant\". \n",
+ "- Balanced: $f$ returns $0$'s on exactly $2^{n-1}$ of the possible inputs, and $1$'s on the other $2^{n-1}$.\n",
+ "- Constant: $f(x) = 0$ or $f(x) = 1$ for all $x \\in \\{0, 1\\}^n$. \n",
+ "\n",
+ "The Deutch-Jozsa problem is to determine, given a function $f$, to determine whether it is in fact balanced or constant."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### The Classical Deterministic Solution\n",
+ "\n",
+ "By doing a worst-case analysis on the problem, it is easy to see that we would require $2^{n-1} + 1$ calls to $f$ to solve this problem. There are probabilistic classical alternatives that use less calls."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### The Classical Probabilistic Solution\n",
+ "\n",
+ "Given that a function is balanced where the inputs are uniformly chosen to have output $0$ or $1$, there is a $\\dfrac{1}{2^{n-1}}$ probability that we actually have to query $f$ $2^{n-1}+1$ times. This hints at a probabilistic solution to the problem.\n",
+ "\n",
+ "The solution is the choose $k$ random inputs, from which we can derive $$P_{\\text{constant}}(k) = 1- \\frac{1}{2^{k-1}}.$$\n",
+ "\n",
+ "Basically, we can run the classical deterministic solution and just break whenever we have, say, $p$ probability of confidence."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### The Quantum Solution\n",
+ "\n",
+ "A quantum computer can solve the Deutsch-Jozsa problem with 100% confidence with only ***one*** call to $f$. The actual circuit has $n+1$ qubits ($n \\ket{0}$ 's and $1 \\ket{1}$) and is split into four main parts:\n",
+ "1. Preparing the quantum registers: The first $n$-qubit register are set to $\\ket{0}^{\\otimes n}$ and the second as $\\ket 1$: $$\\ket {\\psi_0} = \\ket 0 ^{\\otimes n} \\ket 1.$$\n",
+ "2. Applying a Hadamard gate to all qubits: $$\\ket{\\psi_{1}} = \\frac{1}{\\sqrt{2^{n+1}}} \\sum_{x=0}^{2^n-1} \\ket x (\\ket 0 - \\ket 1).$$\n",
+ "3. Appling the quantum oracle $U_f: \\ket x \\ket y \\mapsto \\ket x \\ket{y \\oplus f(x)}$: $$\\ket{\\psi_2} = \\frac{1}{\\sqrt{2^n+1}} \\sum_{x=0}^{2^n-1} (-1)^{f(x)}\\ket x (\\ket 0 - \\ket 1)$$\n",
+ "4. Applying a Hadamard gate to the first $n$ qubits: $$\\ket{\\psi_3} = \\frac{1}{2^n} \\sum_{y=0}^{2^n-1} \\left[\\sum_{x=0}^{2^n-1} (-1)^{f(x)} (-1)^{x\\cdot y}\\right] \\ket y $$\n",
+ "\n",
+ "Now, we just measure the first register. We see that: $$P(\\ket{0}^{\\otimes n}) = \\left| \\frac{1}{2^n} \\sum_{x=0}^{2^n - 1} (-1)^{f(x)} \\right|^2,$$\n",
+ "which is 1 *if and only if* $f$ is constant. This suffices to show correctness of our solution."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### The Oracle\n",
+ "**Constant Oracle**\n",
+ "\n",
+ "When a oracle is constant, it has no effect on the input qubits. So step 4 reverses step 2, giving us the same vector we had after step 1. \n",
+ "\n",
+ "**Balanced Oracle**\n",
+ "\n",
+ "Step 2 gives us an $x$ that is an equal superposition of all states in the $n$-qubit basis. A balanced oracle has a phase kickback that gives negative phase to exactly half of the states. The state after applying the oracle is orthogonal to the prior state, meaning applying $n$ Hadamard gates yields a state orthogonal to $\\ket{00\\ldots 0}$. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## AutoQASM Implementation\n",
+ "\n",
+ "We start by importing the relevant libraries."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "%pip install qbraid \\\n",
+ " qbraid-qir \\\n",
+ " autoqasm \\\n",
+ " matplotlib --quiet"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import autoqasm as aq\n",
+ "import autoqasm.instructions as ins\n",
+ "\n",
+ "from qbraid.runtime import QbraidProvider\n",
+ "from qbraid.visualization import plot_histogram"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Constant Example\n",
+ "\n",
+ "For this example, we're gonna use a four qubit example. We start by identifying that the oracle is going to just be the identity, as a valid $U_f: \\ket x \\ket y \\mapsto \\ket x \\ket{y \\oplus 0} = \\ket x \\ket y$ is the identity mapping."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "n = 4"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def constant_f(x):\n",
+ " return 0\n",
+ "\n",
+ "\n",
+ "@aq.gate\n",
+ "def constant_oracle(q1: aq.Qubit, q2: aq.Qubit, q3: aq.Qubit, q4: aq.Qubit, q5: aq.Qubit):\n",
+ " pass\n",
+ "\n",
+ "\n",
+ "@aq.main(num_qubits=n + 1)\n",
+ "def deutch_jozsa_constant():\n",
+ " ins.x(4)\n",
+ " for i in range(n + 1):\n",
+ " ins.h(i)\n",
+ "\n",
+ " constant_oracle(*range(n + 1))\n",
+ "\n",
+ " for i in range(n + 1):\n",
+ " ins.h(i)\n",
+ "\n",
+ " for i in range(n):\n",
+ " ins.measure(i)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## qBraid Instructions\n",
+ "\n",
+ "qBraid providers a QIR Simulator for quantum jobs. To demonstrate its usage, we'll be using it to simulate the Deutsch-Jozsa algorithm."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "provider = QbraidProvider()\n",
+ "\n",
+ "device = provider.get_device(\"qbraid_qir_simulator\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "job = device.run(deutch_jozsa_constant, shots=1000)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "| Runtime | \n", + "20 microsecs | \n", + "\n",
+ " Total runtime\n",
+ " \n", + " This is a runtime estimate for the execution time of the algorithm. In general, the execution time corresponds to the duration of one logical cycle (2,000 nanosecs) multiplied by the 10 logical cycles to run the algorithm. If however the duration of a single T factory (here: 0 nanosecs) is larger than the algorithm runtime, we extend the number of logical cycles artificially in order to exceed the runtime of a single T factory. \n", + " | \n",
+ "
| rQOPS | \n", + "15.00M | \n", + "\n",
+ " Reliable quantum operations per second\n",
+ " \n", + " The value is computed as the number of logical qubits after layout (30) (with a logical error rate of 1.67e-4) multiplied by the clock frequency (500,000.00), which is the number of logical cycles per second. \n", + " | \n",
+ "
| Physical qubits | \n", + "1.50k | \n", + "\n",
+ " Number of physical qubits\n",
+ " \n", + " This value represents the total number of physical qubits, which is the sum of 1,500 physical qubits to implement the algorithm logic, and 0 physical qubits to execute the T factories that are responsible to produce the T states that are consumed by the algorithm. \n", + " | \n",
+ "
| Logical algorithmic qubits | \n", + "30 | \n", + "\n",
+ " Number of logical qubits for the algorithm after layout\n",
+ " \n", + " Laying out the logical qubits in the presence of nearest-neighbor constraints requires additional logical qubits. In particular, to layout the $Q_{\\rm alg} = 10$ logical qubits in the input algorithm, we require in total $2 \\cdot Q_{\\rm alg} + \\lceil \\sqrt{8 \\cdot Q_{\\rm alg}}\\rceil + 1 = 30$ logical qubits. \n", + " | \n",
+ "
| Algorithmic depth | \n", + "10 | \n", + "\n",
+ " Number of logical cycles for the algorithm\n",
+ " \n", + " To execute the algorithm using Parallel Synthesis Sequential Pauli Computation (PSSPC), operations are scheduled in terms of multi-qubit Pauli measurements, for which assume an execution time of one logical cycle. Based on the input algorithm, we require one multi-qubit measurement for the 10 single-qubit measurements, the 0 arbitrary single-qubit rotations, and the 0 T gates, three multi-qubit measurements for each of the 0 CCZ and 0 CCiX gates in the input program, as well as No rotations in algorithm multi-qubit measurements for each of the 0 non-Clifford layers in which there is at least one single-qubit rotation with an arbitrary angle rotation. \n", + " | \n",
+ "
| Logical depth | \n", + "10 | \n", + "\n",
+ " Number of logical cycles performed\n",
+ " \n", + " This number is usually equal to the logical depth of the algorithm, which is 10. However, in the case in which a single T factory is slower than the execution time of the algorithm, we adjust the logical cycle depth to exceed the T factory's execution time. \n", + " | \n",
+ "
| Clock frequency | \n", + "500.00k | \n", + "\n",
+ " Number of logical cycles per second\n",
+ " \n", + " This is the number of logical cycles that can be performed within one second. The logical cycle time is 2 microsecs. \n", + " | \n",
+ "
| Number of T states | \n", + "0 | \n", + "\n",
+ " Number of T states consumed by the algorithm\n",
+ " \n", + " To execute the algorithm, we require one T state for each of the 0 T gates, four T states for each of the 0 CCZ and 0 CCiX gates, as well as No rotations in algorithm for each of the 0 single-qubit rotation gates with arbitrary angle rotation. \n", + " | \n",
+ "
| Number of T factories | \n", + "0 | \n", + "\n",
+ " Number of T factories capable of producing the demanded 0 T states during the algorithm's runtime\n",
+ " \n", + " The total number of T factories 0 that are executed in parallel is computed as $\\left\\lceil\\dfrac{\\text{T states}\\cdot\\text{T factory duration}}{\\text{T states per T factory}\\cdot\\text{algorithm runtime}}\\right\\rceil = \\left\\lceil\\dfrac{0 \\cdot 0\\;\\text{ns}}{0 \\cdot 20,000\\;\\text{ns}}\\right\\rceil$ \n", + " | \n",
+ "
| Number of T factory invocations | \n", + "0 | \n", + "\n",
+ " Number of times all T factories are invoked\n",
+ " \n", + " In order to prepare the 0 T states, the 0 copies of the T factory are repeatedly invoked 0 times. \n", + " | \n",
+ "
| Physical algorithmic qubits | \n", + "1.50k | \n", + "\n",
+ " Number of physical qubits for the algorithm after layout\n",
+ " \n", + " The 1,500 are the product of the 30 logical qubits after layout and the 50 physical qubits that encode a single logical qubit. \n", + " | \n",
+ "
| Physical T factory qubits | \n", + "0 | \n", + "\n",
+ " Number of physical qubits for the T factories\n",
+ " \n", + " Each T factory requires 0 physical qubits and we run 0 in parallel, therefore we need $0 = 0 \\cdot 0$ qubits. \n", + " | \n",
+ "
| Required logical qubit error rate | \n", + "1.67e-4 | \n", + "\n",
+ " The minimum logical qubit error rate required to run the algorithm within the error budget\n",
+ " \n", + " The minimum logical qubit error rate is obtained by dividing the logical error probability 5.00e-2 by the product of 30 logical qubits and the total cycle count 10. \n", + " | \n",
+ "
| Required logical T state error rate | \n", + "No T states in algorithm | \n", + "\n",
+ " The minimum T state error rate required for distilled T states\n",
+ " \n", + " The minimum T state error rate is obtained by dividing the T distillation error probability 0.00e0 by the total number of T states 0. \n", + " | \n",
+ "
| Number of T states per rotation | \n", + "No rotations in algorithm | \n", + "\n",
+ " Number of T states to implement a rotation with an arbitrary angle\n",
+ " \n", + " The number of T states to implement a rotation with an arbitrary angle is $\\lceil 0.53 \\log_2(0 / 0) + 5.3\\rceil$ [arXiv:2203.10064]. For simplicity, we use this formula for all single-qubit arbitrary angle rotations, and do not distinguish between best, worst, and average cases. \n", + " | \n",
+ "
| QEC scheme | \n", + "surface_code | \n", + "\n",
+ " Name of QEC scheme\n",
+ " \n", + " You can load pre-defined QEC schemes by using the name | \n",
+ "
| Code distance | \n", + "5 | \n", + "\n",
+ " Required code distance for error correction\n",
+ " \n", + " The code distance is the smallest odd integer greater or equal to $\\dfrac{2\\log(0.03 / 0.0001666666666666667)}{\\log(0.01/0.001)} - 1$ \n", + " | \n",
+ "
| Physical qubits | \n", + "50 | \n", + "\n",
+ " Number of physical qubits per logical qubit\n",
+ " \n", + " The number of physical qubits per logical qubit are evaluated using the formula 2 * codeDistance * codeDistance that can be user-specified. \n", + " | \n",
+ "
| Logical cycle time | \n", + "2 microsecs | \n", + "\n",
+ " Duration of a logical cycle in nanoseconds\n",
+ " \n", + " The runtime of one logical cycle in nanoseconds is evaluated using the formula (4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance that can be user-specified. \n", + " | \n",
+ "
| Logical qubit error rate | \n", + "3.00e-5 | \n", + "\n",
+ " Logical qubit error rate\n",
+ " \n", + " The logical qubit error rate is computed as $0.03 \\cdot \\left(\\dfrac{0.001}{0.01}\\right)^\\frac{5 + 1}{2}$ \n", + " | \n",
+ "
| Crossing prefactor | \n", + "0.03 | \n", + "\n",
+ " Crossing prefactor used in QEC scheme\n",
+ " \n", + " The crossing prefactor is usually extracted numerically from simulations when fitting an exponential curve to model the relationship between logical and physical error rate. \n", + " | \n",
+ "
| Error correction threshold | \n", + "0.01 | \n", + "\n",
+ " Error correction threshold used in QEC scheme\n",
+ " \n", + " The error correction threshold is the physical error rate below which the error rate of the logical qubit is less than the error rate of the physical qubit that constitute it. This value is usually extracted numerically from simulations of the logical error rate. \n", + " | \n",
+ "
| Logical cycle time formula | \n", + "(4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance | \n", + "\n",
+ " QEC scheme formula used to compute logical cycle time\n",
+ " \n", + " This is the formula that is used to compute the logical cycle time 2,000 ns. \n", + " | \n",
+ "
| Physical qubits formula | \n", + "2 * codeDistance * codeDistance | \n", + "\n",
+ " QEC scheme formula used to compute number of physical qubits per logical qubit\n",
+ " \n", + " This is the formula that is used to compute the number of physical qubits per logical qubits 50. \n", + " | \n",
+ "
| Logical qubits (pre-layout) | \n", + "10 | \n", + "\n",
+ " Number of logical qubits in the input quantum program\n",
+ " \n", + " We determine 30 algorithmic logical qubits from this number by assuming to align them in a 2D grid. Auxiliary qubits are added to allow for sufficient space to execute multi-qubit Pauli measurements on all or a subset of the logical qubits. \n", + " | \n",
+ "
| T gates | \n", + "0 | \n", + "\n",
+ " Number of T gates in the input quantum program\n",
+ " \n", + " This includes all T gates and adjoint T gates, but not T gates used to implement rotation gates with arbitrary angle, CCZ gates, or CCiX gates. \n", + " | \n",
+ "
| Rotation gates | \n", + "0 | \n", + "\n",
+ " Number of rotation gates in the input quantum program\n",
+ " \n", + " This is the number of all rotation gates. If an angle corresponds to a Pauli, Clifford, or T gate, it is not accounted for in this number. \n", + " | \n",
+ "
| Rotation depth | \n", + "0 | \n", + "\n",
+ " Depth of rotation gates in the input quantum program\n",
+ " \n", + " This is the number of all non-Clifford layers that include at least one single-qubit rotation gate with an arbitrary angle. \n", + " | \n",
+ "
| CCZ gates | \n", + "0 | \n", + "\n",
+ " Number of CCZ-gates in the input quantum program\n",
+ " \n", + " This is the number of CCZ gates. \n", + " | \n",
+ "
| CCiX gates | \n", + "0 | \n", + "\n",
+ " Number of CCiX-gates in the input quantum program\n",
+ " \n", + " This is the number of CCiX gates, which applies $-iX$ controlled on two control qubits [1212.5069]. \n", + " | \n",
+ "
| Measurement operations | \n", + "10 | \n", + "\n",
+ " Number of single qubit measurements in the input quantum program\n",
+ " \n", + " This is the number of single qubit measurements in Pauli basis that are used in the input program. Note that all measurements are counted, however, the measurement result is is determined randomly (with a fixed seed) to be 0 or 1 with a probability of 50%. \n", + " | \n",
+ "
| Total error budget | \n", + "5.00e-2 | \n", + "\n",
+ " Total error budget for the algorithm\n",
+ " \n", + " The total error budget sets the overall allowed error for the algorithm, i.e., the number of times it is allowed to fail. Its value must be between 0 and 1 and the default value is 0.001, which corresponds to 0.1%, and means that the algorithm is allowed to fail once in 1000 executions. This parameter is highly application specific. For example, if one is running Shor's algorithm for factoring integers, a large value for the error budget may be tolerated as one can check that the output are indeed the prime factors of the input. On the other hand, a much smaller error budget may be needed for an algorithm solving a problem with a solution which cannot be efficiently verified. This budget $\\epsilon = \\epsilon_{\\log} + \\epsilon_{\\rm dis} + \\epsilon_{\\rm syn}$ is uniformly distributed and applies to errors $\\epsilon_{\\log}$ to implement logical qubits, an error budget $\\epsilon_{\\rm dis}$ to produce T states through distillation, and an error budget $\\epsilon_{\\rm syn}$ to synthesize rotation gates with arbitrary angles. Note that for distillation and rotation synthesis, the respective error budgets $\\epsilon_{\\rm dis}$ and $\\epsilon_{\\rm syn}$ are uniformly distributed among all T states and all rotation gates, respectively. If there are no rotation gates in the input algorithm, the error budget is uniformly distributed to logical errors and T state errors. \n", + " | \n",
+ "
| Logical error probability | \n", + "5.00e-2 | \n", + "\n",
+ " Probability of at least one logical error\n",
+ " \n", + " This is one third of the total error budget 5.00e-2 if the input algorithm contains rotation with gates with arbitrary angles, or one half of it, otherwise. \n", + " | \n",
+ "
| T distillation error probability | \n", + "0.00e0 | \n", + "\n",
+ " Probability of at least one faulty T distillation\n",
+ " \n", + " This is one third of the total error budget 5.00e-2 if the input algorithm contains rotation with gates with arbitrary angles, or one half of it, otherwise. \n", + " | \n",
+ "
| Rotation synthesis error probability | \n", + "0.00e0 | \n", + "\n",
+ " Probability of at least one failed rotation synthesis\n",
+ " \n", + " This is one third of the total error budget 5.00e-2. \n", + " | \n",
+ "
| Qubit name | \n", + "qubit_gate_ns_e3 | \n", + "\n",
+ " Some descriptive name for the qubit model\n",
+ " \n", + " You can load pre-defined qubit parameters by using the names | \n",
+ "
| Instruction set | \n", + "GateBased | \n", + "\n",
+ " Underlying qubit technology (gate-based or Majorana)\n",
+ " \n", + " When modeling the physical qubit abstractions, we distinguish between two different physical instruction sets that are used to operate the qubits. The physical instruction set can be either gate-based or Majorana. A gate-based instruction set provides single-qubit measurement, single-qubit gates (incl. T gates), and two-qubit gates. A Majorana instruction set provides a physical T gate, single-qubit measurement and two-qubit joint measurement operations. \n", + " | \n",
+ "
| Single-qubit measurement time | \n", + "100 ns | \n", + "\n",
+ " Operation time for single-qubit measurement (t_meas) in ns\n",
+ " \n", + " This is the operation time in nanoseconds to perform a single-qubit measurement in the Pauli basis. \n", + " | \n",
+ "
| Single-qubit gate time | \n", + "50 ns | \n", + "\n",
+ " Operation time for single-qubit gate (t_gate) in ns\n",
+ " \n", + " This is the operation time in nanoseconds to perform a single-qubit Clifford operation, e.g., Hadamard or Phase gates. \n", + " | \n",
+ "
| Two-qubit gate time | \n", + "50 ns | \n", + "\n",
+ " Operation time for two-qubit gate in ns\n",
+ " \n", + " This is the operation time in nanoseconds to perform a two-qubit Clifford operation, e.g., a CNOT or CZ gate. \n", + " | \n",
+ "
| T gate time | \n", + "50 ns | \n", + "\n",
+ " Operation time for a T gate\n",
+ " \n", + " This is the operation time in nanoseconds to execute a T gate. \n", + " | \n",
+ "
| Single-qubit measurement error rate | \n", + "0.001 | \n", + "\n",
+ " Error rate for single-qubit measurement\n",
+ " \n", + " This is the probability in which a single-qubit measurement in the Pauli basis may fail. \n", + " | \n",
+ "
| Single-qubit error rate | \n", + "0.001 | \n", + "\n",
+ " Error rate for single-qubit Clifford gate (p)\n",
+ " \n", + " This is the probability in which a single-qubit Clifford operation, e.g., Hadamard or Phase gates, may fail. \n", + " | \n",
+ "
| Two-qubit error rate | \n", + "0.001 | \n", + "\n",
+ " Error rate for two-qubit Clifford gate\n",
+ " \n", + " This is the probability in which a two-qubit Clifford operation, e.g., CNOT or CZ gates, may fail. \n", + " | \n",
+ "
| T gate error rate | \n", + "0.001 | \n", + "\n",
+ " Error rate to prepare single-qubit T state or apply a T gate (p_T)\n",
+ " \n", + " This is the probability in which executing a single T gate may fail. \n", + " | \n",
+ "
| Logical depth factor | \n", + "constraint not set | \n", + "\n",
+ " Factor, the initial number of logical cycles is multiplied by\n",
+ " \n", + " This is the factor takes into account a potential overhead to the initial number of logical cycles. \n", + " | \n",
+ "
| Maximum number of T factories | \n", + "constraint not set | \n", + "\n",
+ " The maximum number of T factories can be utilized during the algorithm's runtime\n",
+ " \n", + " This is the maximum number of T factories used for producing the demanded T states, which can be created and executed by the algorithm in parallel. \n", + " | \n",
+ "
| Maximum runtime duration | \n", + "constraint not set | \n", + "\n",
+ " The maximum runtime duration allowed for the algorithm runtime\n",
+ " \n", + " This is the maximum time allowed to the algorithm. If specified, the estimator targets to minimize the number of physical qubits consumed by the algorithm for runtimes under the maximum allowed. \n", + " | \n",
+ "
| Maximum number of physical qubits | \n", + "constraint not set | \n", + "\n",
+ " The maximum number of physical qubits allowed for utilization to the algorith\n",
+ " \n", + " This is the maximum number of physical qubits available to the algorithm. If specified, the estimator targets to minimize the runtime of the algorithm with number of physical qubits consumed not exceeding this maximum. \n", + " | \n",
+ "
More details on the following lists of assumptions can be found in the paper Accessing requirements for scaling quantum computers and their applications.
Uniform independent physical noise. We assume that the noise on physical qubits and physical qubit operations is the standard circuit noise model. In particular we assume error events at different space-time locations are independent and that error rates are uniform across the system in time and space.
Efficient classical computation. We assume that classical overhead (compilation, control, feedback, readout, decoding, etc.) does not dominate the overall cost of implementing the full quantum algorithm.
Extraction circuits for planar quantum ISA. We assume that stabilizer extraction circuits with similar depth and error correction performance to those for standard surface and Hastings-Haah code patches can be constructed to implement all operations of the planar quantum ISA (instruction set architecture).
Uniform independent logical noise. We assume that the error rate of a logical operation is approximately equal to its space-time volume (the number of tiles multiplied by the number of logical time steps) multiplied by the error rate of a logical qubit in a standard one-tile patch in one logical time step.
Negligible Clifford costs for synthesis. We assume that the space overhead for synthesis and space and time overhead for transport of magic states within magic state factories and to synthesis qubits are all negligible.
Smooth magic state consumption rate. We assume that the rate of T state consumption throughout the compiled algorithm is almost constant, or can be made almost constant without significantly increasing the number of logical time steps for the algorithm.
az login to make sure your Azure credentials are stored.\n",
+ "