](https://account.qbraid.com?gitHubUrl=https://github.com/qBraid/qbraid-lab-demo.git&utm_source=github&redirectUrl=README.md)
7 |
8 | ## Contents
9 |
10 | This repository features tutorials and examples for the following:
11 |
12 | - [**qBraid-SDK**](https://docs.qbraid.com/sdk/): Learn how to interact with quantum devices using the qBraid Runtime framework.
13 | - [**qBraid-QIR**](https://docs.qbraid.com/qir/): Explore qBraid's Quantum Intermediate Representation (QIR) interface using familiar frameworks like OpenQASM 3 and Cirq.
14 | - [**PyQASM**](https://docs.qbraid.com/pyqasm/): Discover new ways to integrate with OpenQASM, featuring methods for program validation, compilation, inlining, and unrolling.
15 | - [**qBraid-CLI**](https://docs.qbraid.com/cli/): Understand how to manage quantum jobs and resources using qBraid's Command Line Interface.
16 | - [**qBraid-Lab**](https://docs.qbraid.com/lab/) Integration:
17 | - [**Quantum Jobs**](https://docs.qbraid.com/lab/user-guide/quantum-jobs): Learn how to submit and manage quantum jobs in qBraid Lab.
18 | - [**GPUs**](https://docs.qbraid.com/lab/user-guide/gpus): Learn how to accelerate your quantum simulations using GPUs available through qBraid Lab.
19 |
20 | ## Documentation and Resources
21 |
22 | For more information on qBraid and its tools, check out:
23 |
24 | - **qBraid Platform Documentation**: Comprehensive user guides and resources at [docs.qbraid.com](https://docs.qbraid.com/).
25 | - **qBraid Software API Reference**: Detailed API documentation for the qBraid-SDK at [sdk.qbraid.com](https://sdk.qbraid.com/).
26 | - **qBraid GitHub Community**: Join the discussion and contribute at [GitHub Community Page](https://github.com/qBraid/community).
27 |
28 | ## Contribution
29 |
30 | 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.
31 |
--------------------------------------------------------------------------------
/algorithms/quantum_opt_rl/gym-examples/.pre-commit-config.yaml:
--------------------------------------------------------------------------------
1 | ---
2 | repos:
3 | - repo: https://github.com/python/black
4 | rev: 22.3.0
5 | hooks:
6 | - id: black
7 |
--------------------------------------------------------------------------------
/algorithms/quantum_opt_rl/gym-examples/README.md:
--------------------------------------------------------------------------------
1 | This repository is no longer maintained, as Gym is not longer maintained and all future maintenance of it will occur in the replacing [Gymnasium](https://github.com/Farama-Foundation/Gymnasium) library. You can contribute Gymnasium examples to the Gymnasium repository and docs directly if you would like to. If you'd like to learn more about the transition from Gym to Gymnasium, you can read more about it [here](https://farama.org/Announcing-The-Farama-Foundation).
2 |
3 | # Gym Examples
4 | Some simple examples of Gym environments and wrappers.
5 | For some explanations of these examples, see the [Gym documentation](https://gymnasium.farama.org).
6 |
7 | ### Environments
8 | This repository hosts the examples that are shown [on the environment creation documentation](https://gymnasium.farama.org/tutorials/environment_creation/).
9 | - `GridWorldEnv`: Simplistic implementation of gridworld environment
10 |
11 | ### Wrappers
12 | This repository hosts the examples that are shown [on wrapper documentation](https://gymnasium.farama.org/api/wrappers/).
13 | - `ClipReward`: A `RewardWrapper` that clips immediate rewards to a valid range
14 | - `DiscreteActions`: An `ActionWrapper` that restricts the action space to a finite subset
15 | - `RelativePosition`: An `ObservationWrapper` that computes the relative position between an agent and a target
16 | - `ReacherRewardWrapper`: Allow us to weight the reward terms for the reacher environment
17 |
18 | ### Contributing
19 | If you would like to contribute, follow these steps:
20 | - Fork this repository
21 | - Clone your fork
22 | - Set up pre-commit via `pre-commit install`
23 |
24 | PRs may require accompanying PRs in [the documentation repo](https://github.com/Farama-Foundation/Gymnasium/tree/main/docs).
25 |
--------------------------------------------------------------------------------
/algorithms/quantum_opt_rl/gym-examples/gym_examples/__init__.py:
--------------------------------------------------------------------------------
1 | from gymnasium.envs.registration import register
2 |
3 | register(
4 | id="gym_examples/Quantum-v0",
5 | entry_point="gym_examples.envs:QuantumEnv",
6 | )
7 |
--------------------------------------------------------------------------------
/algorithms/quantum_opt_rl/gym-examples/gym_examples/envs/__init__.py:
--------------------------------------------------------------------------------
1 | from gym_examples.envs.quantum_env import QuantumEnv
2 |
--------------------------------------------------------------------------------
/algorithms/quantum_opt_rl/gym-examples/gym_examples/envs/quantum_env.py:
--------------------------------------------------------------------------------
1 | import string
2 | import time
3 | from collections import OrderedDict
4 | from typing import List, Optional, Tuple
5 |
6 | import numpy as np
7 | import torch
8 | from gymnasium import Env
9 | from gymnasium.spaces import Box, Discrete
10 | from qiskit import QuantumCircuit
11 | from qiskit.circuit.library import iSwapGate, standard_gates
12 | from qiskit.circuit.random import random_circuit
13 | from qiskit.converters import circuit_to_dag
14 | from qiskit.quantum_info import Statevector
15 | from qiskit.transpiler import PassManager
16 | from qiskit.transpiler.passes import CommutativeCancellation # Unroller,
17 | from qiskit.transpiler.passes import (
18 | CommutativeInverseCancellation,
19 | CXCancellation,
20 | Optimize1qGatesDecomposition,
21 | UnitarySynthesis,
22 | )
23 | from qiskit.visualization import dag_drawer
24 | from torch.utils.tensorboard import SummaryWriter
25 |
26 |
27 | class QuantumEnv(Env):
28 | def __init__(
29 | self,
30 | basis=["cx", "u3", "u", "id"],
31 | num_qubits=12,
32 | actions=None,
33 | render=False,
34 | min_depth=500,
35 | max_depth=600,
36 | ):
37 | """Initializes a quantum environment
38 |
39 | Args:
40 | basis (list, optional): The basis gates to decompose to. Defaults to ["cx", "u3", "u", "id"].
41 | num_qubits (int, optional) The number of qubits in the circuit. Defaults to 12.
42 | actions (_type_, optional): The dict of otpimization that can be performed. Defaults to None.
43 | render (bool, optional): Boolean to set render. Defaults to False.
44 | min_depth (int, optional): Minimum depth in random circuit. Defaults to 30.
45 | max_depth (int, optional): Maximum depth in random circuit. Defaults to 90.
46 | """
47 |
48 | self.device = "cpu" if not torch.has_cuda else "cuda:0"
49 | self.basis = basis
50 | self.num_qubits = num_qubits
51 | self.actions = (
52 | {
53 | 0: Optimize1qGatesDecomposition(),
54 | 1: CommutativeInverseCancellation(),
55 | 2: CommutativeCancellation(basis_gates=basis),
56 | 3: CXCancellation(),
57 | 4: UnitarySynthesis(basis_gates=basis),
58 | }
59 | if actions is None
60 | else actions
61 | )
62 | self.num_actions = len(self.actions.keys())
63 | self.min_depth = min_depth
64 | self.max_depth = max_depth
65 | self.circuit = self.create_random_circuit() # Starting circuit
66 | self.counts_ops = sum(list(self.circuit.count_ops().values()))
67 | self.qiskit_gates = self.get_qiskit_gates()
68 | self.state = self._create_tensor_from_circuit(self.circuit)
69 | self.observation_space = Box(
70 | low=0,
71 | high=len(self.qiskit_gates),
72 | shape=(self.num_qubits, len(self.qiskit_gates), 5),
73 | dtype=np.float32,
74 | )
75 | self.action_space = Discrete(self.num_actions)
76 | self.alpha = 1 # Gate count weight
77 | self.beta = 0.2 # Depth weight
78 | self.circuit_score_array = []
79 | self.render_true = render
80 |
81 | def create_random_circuit(self, seed: Optional[int] = None) -> QuantumCircuit:
82 | """Creates a random circuit
83 |
84 | Args:
85 | seed (int, optional): Seed for random circuit. Defaults to None.
86 |
87 | Returns:
88 | QuantumCircuit: A random quantum circuit
89 | """
90 | if seed is not None:
91 | np.random.seed(seed)
92 | qc_1 = random_circuit(self.num_qubits, np.random.randint(self.min_depth, self.max_depth))
93 | qc_2 = random_circuit(self.num_qubits, np.random.randint(self.min_depth, self.max_depth))
94 |
95 | qc_1.compose(qc_2, inplace=True)
96 |
97 | return qc_1
98 |
99 | def _generate_params(self, varnames: List[str], seed: Optional[int] = None):
100 | """Returns a dictionary of random parameters for a given list of variable names"""
101 | if seed is not None:
102 | np.random.seed(seed)
103 | params = {
104 | ra: np.random.rand() * 2 * np.pi
105 | for ra in ["theta", "phi", "lam", "gamma"]
106 | if ra in varnames
107 | }
108 | if "num_ctrl_qubits" in varnames:
109 | params["num_ctrl_qubits"] = np.random.randint(1, 7)
110 | if "phase" in varnames:
111 | params["phase"] = np.random.rand() * 2 * np.pi
112 | return params
113 |
114 | def _create_tensor_from_circuit(self, circuit: QuantumCircuit) -> torch.Tensor:
115 | """Returns a tensor representation of a quantum circuit
116 | The matrix consists of ("num_qubits, all_gates, num_gates, 2)
117 | """
118 |
119 | # The tensor is of shape (num_qubits, num_gates, num_params)
120 | circuit_tensor = torch.zeros((circuit.num_qubits, len(self.qiskit_gates), self.num_actions))
121 |
122 | for _, op in enumerate(circuit):
123 | name = op.operation.name
124 | # TODO Add barrier index similar to moments in cirq.
125 | qubits = [qubit.index for qubit in list(op.qubits)]
126 | # Get the index of the gate
127 | gate_index = self.qiskit_gates.keys()
128 | gate_index = list(gate_index).index(name)
129 | # Add operation parameters
130 | if op.operation.params:
131 | for idx, param in enumerate(op.operation.params):
132 | circuit_tensor[qubits, gate_index, 1 + idx] = param
133 | circuit_tensor[qubits, gate_index, 0] += 1
134 | return circuit_tensor
135 |
136 | def get_qiskit_gates(self, seed: Optional[int] = None):
137 | """Returns a dictionary of all qiskit gates with random parameters"""
138 | qiskit_gates = {
139 | attr: None for attr in dir(standard_gates) if attr[0] in string.ascii_uppercase
140 | }
141 |
142 | # Add random parameters to gates for circuit generation
143 | for gate in qiskit_gates:
144 | varnames = [
145 | v
146 | for v in getattr(standard_gates, gate).__init__.__code__.co_varnames
147 | if v != "self"
148 | ]
149 | params = self._generate_params(varnames, seed=seed)
150 | qiskit_gates[gate] = getattr(standard_gates, gate)(**params)
151 | qiskit_gates = OrderedDict({v.name: v for _, v in qiskit_gates.items() if v is not None})
152 | # Add iSwap gate
153 | qiskit_gates["iswap"] = iSwapGate()
154 | return qiskit_gates
155 |
156 | def compute_reward(
157 | self, optimized_circuit: QuantumCircuit, prior_circuit: QuantumCircuit
158 | ) -> float:
159 | """Computes the reward for the optimized circuit.
160 |
161 | Args:
162 | optimized_circuit (QuantumCircuit): The circuit which has been optimized by an action.
163 | prior_circuit (QuantumCircuit): The circuit before optimization.
164 |
165 | Returns:
166 | float: The reward for the optimized circuit.
167 | """
168 |
169 | # Assert the original and optimized circuit are equivalent.
170 | if Statevector.from_instruction(optimized_circuit).equiv(
171 | Statevector.from_instruction(prior_circuit)
172 | ):
173 | # Cacluate gate count and depth of optimized circuit
174 | depth = optimized_circuit.depth()
175 | gate_len = sum(dict(optimized_circuit.count_ops()).values())
176 | score = self.alpha * depth + self.beta * gate_len
177 | # Calculate the gate count and depth of the prior circuit
178 | prior_depth = prior_circuit.depth()
179 | prior_gate_len = sum(dict(prior_circuit.count_ops()).values())
180 |
181 | prior_score = self.alpha * prior_depth + self.beta * prior_gate_len
182 | score_diff = -(score - prior_score)
183 | return score_diff
184 |
185 | else:
186 | return (
187 | -1
188 | ) # Penalize the circuit if it is not equivalent to the prior circuit could be throw as an assertion error
189 |
190 | def step(self, action: float) -> Tuple[torch.Tensor, float, bool, dict]:
191 | """Run one timestep of the environment's dynamics.
192 |
193 | Args:
194 | action (tensor): An action provided by the environment
195 |
196 | Returns:
197 | Tuple[torch.Tensor, float, bool, dict]: observation, reward, done, info
198 | """
199 |
200 | transformation = self.actions[int(action)]
201 | init = PassManager([transformation])
202 | self.prior_circuit = self.circuit
203 | if self.render_true:
204 | # Render the circuit and DAG
205 | self.render(self.circuit)
206 | self.circuit = init.run(self.circuit)
207 |
208 | # In the original paper, "soft" and "hard" transformations are applied.
209 | # It is possible to add hard transformations and modify the actions.
210 |
211 | # Compute the reward
212 | reward = self.compute_reward(self.circuit, self.prior_circuit)
213 | self.circuit_score_array.append(reward)
214 | # Set done to true if the circuit is optimized
215 | # This is a hacky way to exit the optimization loop, there are plenty of better ways to do this.
216 | if (np.average(self.circuit_score_array[-5:])) < 0.1:
217 | done = True
218 |
219 | else:
220 | done = False
221 |
222 | # Convert the circuit to a tensor
223 | self.state = self._create_tensor_from_circuit(self.circuit)
224 |
225 | # Set placeholder for info
226 | info = {}
227 | return self.state, reward, done, info
228 |
229 | def render(self, circuit: QuantumCircuit) -> QuantumCircuit:
230 | """Renders the circuit and DAG
231 |
232 | Args:
233 | circuit (QuantumCircuit): The circuit to render
234 |
235 | Returns:
236 | QuantumCircuit: The rendered circuit
237 | """
238 | # Render the cirq circuit
239 | dag = circuit_to_dag(circuit)
240 | dag_drawer(dag, scale=0.7, filename=f"./run/images/dag-{time.time()}.png")
241 | circuit.draw(output="mpl", filename=f"./run/images/circuit-{time.time()}.png")
242 | # SummaryWriter().add_figure("Circuit", dag_drawer(dag, scale=0.7, filename=f"./run/images/{dag.name}.png"))
243 | return circuit
244 |
245 | def reset(self, seed: int = None, options=None) -> Tuple[torch.Tensor, dict]:
246 | """Resets the environment to the initial state
247 |
248 | Args:
249 | seed (int, optional): Set a specific seed. Defaults to None.
250 | options (optional): Other options. Defaults to None.
251 |
252 | Returns:
253 | torch.Tensor, dict: The initial state and info
254 | """
255 | super().reset(seed=seed, options=options)
256 |
257 | # Return the initial state
258 | self.circuit = self.create_random_circuit()
259 | info = {}
260 | observation = self._create_tensor_from_circuit(self.circuit)
261 | self.state = observation
262 | return observation, info
263 |
264 | def close(self):
265 | pass
266 |
--------------------------------------------------------------------------------
/algorithms/quantum_opt_rl/gym-examples/gym_examples/wrappers/__init__.py:
--------------------------------------------------------------------------------
1 | from gym_examples.wrappers.clip_reward import ClipReward
2 | from gym_examples.wrappers.discrete_actions import DiscreteActions
3 | from gym_examples.wrappers.reacher_weighted_reward import ReacherRewardWrapper
4 | from gym_examples.wrappers.relative_position import RelativePosition
5 |
--------------------------------------------------------------------------------
/algorithms/quantum_opt_rl/gym-examples/gym_examples/wrappers/clip_reward.py:
--------------------------------------------------------------------------------
1 | import gym
2 | import numpy as np
3 |
4 |
5 | class ClipReward(gym.RewardWrapper):
6 | def __init__(self, env, min_reward, max_reward):
7 | super().__init__(env)
8 | self.min_reward = min_reward
9 | self.max_reward = max_reward
10 | self.reward_range = (min_reward, max_reward)
11 |
12 | def reward(self, reward):
13 | return np.clip(reward, self.min_reward, self.max_reward)
14 |
--------------------------------------------------------------------------------
/algorithms/quantum_opt_rl/gym-examples/gym_examples/wrappers/discrete_actions.py:
--------------------------------------------------------------------------------
1 | import gym
2 | from gym.spaces import Discrete
3 |
4 |
5 | class DiscreteActions(gym.ActionWrapper):
6 | def __init__(self, env, disc_to_cont):
7 | super().__init__(env)
8 | self.disc_to_cont = disc_to_cont
9 | self.action_space = Discrete(len(disc_to_cont))
10 |
11 | def action(self, act):
12 | return self.disc_to_cont[act]
13 |
--------------------------------------------------------------------------------
/algorithms/quantum_opt_rl/gym-examples/gym_examples/wrappers/reacher_weighted_reward.py:
--------------------------------------------------------------------------------
1 | import gym
2 |
3 |
4 | class ReacherRewardWrapper(gym.Wrapper):
5 | def __init__(self, env, reward_dist_weight, reward_ctrl_weight):
6 | super().__init__(env)
7 | self.reward_dist_weight = reward_dist_weight
8 | self.reward_ctrl_weight = reward_ctrl_weight
9 |
10 | def step(self, action):
11 | obs, _, terminated, truncated, info = self.env.step(action)
12 | reward = (
13 | self.reward_dist_weight * info["reward_dist"]
14 | + self.reward_ctrl_weight * info["reward_ctrl"]
15 | )
16 | return obs, reward, terminated, truncated, info
17 |
--------------------------------------------------------------------------------
/algorithms/quantum_opt_rl/gym-examples/gym_examples/wrappers/relative_position.py:
--------------------------------------------------------------------------------
1 | import gym
2 | import numpy as np
3 | from gym.spaces import Box
4 |
5 |
6 | class RelativePosition(gym.ObservationWrapper):
7 | def __init__(self, env):
8 | super().__init__(env)
9 | self.observation_space = Box(shape=(2,), low=-np.inf, high=np.inf)
10 |
11 | def observation(self, obs):
12 | return obs["target"] - obs["agent"]
13 |
--------------------------------------------------------------------------------
/algorithms/quantum_opt_rl/gym-examples/setup.py:
--------------------------------------------------------------------------------
1 | from setuptools import setup
2 |
3 | setup(
4 | name="gym_examples",
5 | version="0.0.1",
6 | install_requires=[
7 | "gymnasium",
8 | "qiskit",
9 | "torch",
10 | "numpy",
11 | "matplotlib",
12 | "tensorboard",
13 | ],
14 | )
15 |
--------------------------------------------------------------------------------
/algorithms/quantum_opt_rl/images/input_tensor.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qBraid/qbraid-lab-demo/e3ebac3e181894128da8f8f4ec3c3487246c2be8/algorithms/quantum_opt_rl/images/input_tensor.png
--------------------------------------------------------------------------------
/algorithms/quantum_opt_rl/images/mario.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/qBraid/qbraid-lab-demo/e3ebac3e181894128da8f8f4ec3c3487246c2be8/algorithms/quantum_opt_rl/images/mario.png
--------------------------------------------------------------------------------
/pyqasm/deutsch_josza_unroll.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "### Unrolling the Deutsch-Jozsa Algorithm \n",
8 | "In this notebook, we will see how a quantum program implementing the [Deutsch-Jozsa algorithm](https://en.wikipedia.org/wiki/Deutsch%E2%80%93Jozsa_algorithm) can be unrolled into a sequence of elementary quantum operations. "
9 | ]
10 | },
11 | {
12 | "cell_type": "code",
13 | "execution_count": null,
14 | "metadata": {},
15 | "outputs": [],
16 | "source": [
17 | "%pip install pyqasm --quiet"
18 | ]
19 | },
20 | {
21 | "cell_type": "code",
22 | "execution_count": 1,
23 | "metadata": {},
24 | "outputs": [
25 | {
26 | "data": {
27 | "text/plain": [
28 | "'0.1.0'"
29 | ]
30 | },
31 | "execution_count": 1,
32 | "metadata": {},
33 | "output_type": "execute_result"
34 | }
35 | ],
36 | "source": [
37 | "import pyqasm\n",
38 | "\n",
39 | "pyqasm.__version__"
40 | ]
41 | },
42 | {
43 | "cell_type": "code",
44 | "execution_count": 2,
45 | "metadata": {},
46 | "outputs": [],
47 | "source": [
48 | "from pyqasm import dumps, loads"
49 | ]
50 | },
51 | {
52 | "cell_type": "markdown",
53 | "metadata": {},
54 | "source": [
55 | "- We define a 4-qubit quantum circuit that implements the Deutsch-Jozsa algorithm for a given oracle."
56 | ]
57 | },
58 | {
59 | "cell_type": "code",
60 | "execution_count": 3,
61 | "metadata": {},
62 | "outputs": [],
63 | "source": [
64 | "qasm = \"\"\"\n",
65 | "// A program containing the Deutsch-Josza algorithm in OpenQASM 3\n",
66 | "OPENQASM 3;\n",
67 | "include \"stdgates.inc\";\n",
68 | "\n",
69 | "// Define a custom gate for the Hadamard operation\n",
70 | "gate hgate q {\n",
71 | " h q;\n",
72 | "}\n",
73 | "\n",
74 | "// Define a custom gate for the X operation\n",
75 | "gate xgate q {\n",
76 | " x q;\n",
77 | "}\n",
78 | "\n",
79 | "const int[32] N = 4;\n",
80 | "qubit[4] q;\n",
81 | "qubit ancilla;\n",
82 | "\n",
83 | "\n",
84 | "// Define the Deutsch-Josza algorithm\n",
85 | "def deutsch_jozsa(qubit[N] q_func, qubit[1] ancilla_q) {\n",
86 | "\n",
87 | " // Initialize the ancilla qubit to |1>\n",
88 | " xgate ancilla_q;\n",
89 | "\n",
90 | " // Apply Hadamard gate to all qubits\n",
91 | " for int i in [0:N-1] {\n",
92 | " hgate q_func[i];\n",
93 | " }\n",
94 | "\n",
95 | " hgate ancilla_q;\n",
96 | "\n",
97 | " // Apply the oracle \n",
98 | " for int i in [0:N-1] {\n",
99 | " cx q_func[i], ancilla_q;\n",
100 | " }\n",
101 | "\n",
102 | " // Apply Hadamard gate to all qubits again\n",
103 | " for int i in [0:N-1] {\n",
104 | " hgate q_func[i];\n",
105 | " }\n",
106 | "}\n",
107 | "\n",
108 | "\n",
109 | "// Run the Deutsch-Josza algorithm for N qubits\n",
110 | "deutsch_jozsa(q, ancilla);\n",
111 | "\n",
112 | "// Measure the results \n",
113 | "bit[4] result;\n",
114 | "result = measure q;\n",
115 | "\"\"\""
116 | ]
117 | },
118 | {
119 | "cell_type": "code",
120 | "execution_count": 4,
121 | "metadata": {},
122 | "outputs": [],
123 | "source": [
124 | "program = loads(qasm)\n",
125 | "\n",
126 | "program.unroll()"
127 | ]
128 | },
129 | {
130 | "cell_type": "code",
131 | "execution_count": 5,
132 | "metadata": {},
133 | "outputs": [
134 | {
135 | "name": "stdout",
136 | "output_type": "stream",
137 | "text": [
138 | "OPENQASM 3.0;\n",
139 | "include \"stdgates.inc\";\n",
140 | "qubit[4] q;\n",
141 | "qubit[1] ancilla;\n",
142 | "x ancilla[0];\n",
143 | "h q[0];\n",
144 | "h q[1];\n",
145 | "h q[2];\n",
146 | "h q[3];\n",
147 | "h ancilla[0];\n",
148 | "cx q[0], ancilla[0];\n",
149 | "cx q[1], ancilla[0];\n",
150 | "cx q[2], ancilla[0];\n",
151 | "cx q[3], ancilla[0];\n",
152 | "h q[0];\n",
153 | "h q[1];\n",
154 | "h q[2];\n",
155 | "h q[3];\n",
156 | "bit[4] result;\n",
157 | "result[0] = measure q[0];\n",
158 | "result[1] = measure q[1];\n",
159 | "result[2] = measure q[2];\n",
160 | "result[3] = measure q[3];\n",
161 | "\n"
162 | ]
163 | }
164 | ],
165 | "source": [
166 | "print(dumps(program))"
167 | ]
168 | },
169 | {
170 | "cell_type": "code",
171 | "execution_count": null,
172 | "metadata": {},
173 | "outputs": [],
174 | "source": []
175 | }
176 | ],
177 | "metadata": {
178 | "kernelspec": {
179 | "display_name": "sdk311",
180 | "language": "python",
181 | "name": "python3"
182 | },
183 | "language_info": {
184 | "codemirror_mode": {
185 | "name": "ipython",
186 | "version": 3
187 | },
188 | "file_extension": ".py",
189 | "mimetype": "text/x-python",
190 | "name": "python",
191 | "nbconvert_exporter": "python",
192 | "pygments_lexer": "ipython3",
193 | "version": "3.11.9"
194 | }
195 | },
196 | "nbformat": 4,
197 | "nbformat_minor": 2
198 | }
199 |
--------------------------------------------------------------------------------
/pyqasm/qasm_processing.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "### The Capabilities of PyQASM \n",
8 | "Besides unrolling and semantic validation, PyQASM also provides a variety of functionalities to help users analyse and transform their quantum programs. We will highlight them by taking a look at a simple example. \n",
9 | "\n",
10 | "For detailed documentation, please refer to the [official PyQASM documentation](https://sdk.qbraid.com/projects/pyqasm/en/stable/api/pyqasm.html)."
11 | ]
12 | },
13 | {
14 | "cell_type": "code",
15 | "execution_count": null,
16 | "metadata": {},
17 | "outputs": [],
18 | "source": [
19 | "%pip install pyqasm --quiet"
20 | ]
21 | },
22 | {
23 | "cell_type": "code",
24 | "execution_count": 1,
25 | "metadata": {},
26 | "outputs": [
27 | {
28 | "data": {
29 | "text/plain": [
30 | "'0.1.0'"
31 | ]
32 | },
33 | "execution_count": 1,
34 | "metadata": {},
35 | "output_type": "execute_result"
36 | }
37 | ],
38 | "source": [
39 | "import pyqasm\n",
40 | "\n",
41 | "pyqasm.__version__"
42 | ]
43 | },
44 | {
45 | "cell_type": "code",
46 | "execution_count": 2,
47 | "metadata": {},
48 | "outputs": [],
49 | "source": [
50 | "from pyqasm import loads, dumps"
51 | ]
52 | },
53 | {
54 | "cell_type": "code",
55 | "execution_count": 3,
56 | "metadata": {},
57 | "outputs": [],
58 | "source": [
59 | "qasm_str = \"\"\"\n",
60 | "OPENQASM 3.0;\n",
61 | "include \"stdgates.inc\";\n",
62 | "\n",
63 | "// define qubits and random ops \n",
64 | "qubit[10] q;\n",
65 | "bit[10] c;\n",
66 | "\n",
67 | "h q[0];\n",
68 | "h q[1];\n",
69 | "\n",
70 | "cx q[0], q[1];\n",
71 | "\n",
72 | "rx(0.5) q[3:6];\n",
73 | "ccx q[0], q[1], q[2];\n",
74 | "\n",
75 | "barrier q[:5];\n",
76 | "\n",
77 | "c[:5] = measure q[:5]; \n",
78 | "\"\"\""
79 | ]
80 | },
81 | {
82 | "cell_type": "code",
83 | "execution_count": 4,
84 | "metadata": {},
85 | "outputs": [],
86 | "source": [
87 | "module = loads(qasm_str)"
88 | ]
89 | },
90 | {
91 | "cell_type": "markdown",
92 | "metadata": {},
93 | "source": [
94 | "- Let's start by validating our quantum program."
95 | ]
96 | },
97 | {
98 | "cell_type": "code",
99 | "execution_count": 5,
100 | "metadata": {},
101 | "outputs": [],
102 | "source": [
103 | "module.validate()"
104 | ]
105 | },
106 | {
107 | "cell_type": "markdown",
108 | "metadata": {},
109 | "source": [
110 | "- Next, we will get the qubit and classical register information. Post this, we will unroll the program and print it."
111 | ]
112 | },
113 | {
114 | "cell_type": "code",
115 | "execution_count": 6,
116 | "metadata": {},
117 | "outputs": [
118 | {
119 | "data": {
120 | "text/plain": [
121 | "(10, 10)"
122 | ]
123 | },
124 | "execution_count": 6,
125 | "metadata": {},
126 | "output_type": "execute_result"
127 | }
128 | ],
129 | "source": [
130 | "module.num_qubits, module.num_clbits"
131 | ]
132 | },
133 | {
134 | "cell_type": "code",
135 | "execution_count": 7,
136 | "metadata": {},
137 | "outputs": [
138 | {
139 | "data": {
140 | "text/plain": [
141 | "['OPENQASM 3.0;',\n",
142 | " 'include \"stdgates.inc\";',\n",
143 | " 'qubit[10] q;',\n",
144 | " 'bit[10] c;',\n",
145 | " 'h q[0];',\n",
146 | " 'h q[1];',\n",
147 | " 'cx q[0], q[1];',\n",
148 | " 'rx(0.5) q[3];',\n",
149 | " 'rx(0.5) q[4];',\n",
150 | " 'rx(0.5) q[5];',\n",
151 | " 'ccx q[0], q[1], q[2];',\n",
152 | " 'barrier q[0];',\n",
153 | " 'barrier q[1];',\n",
154 | " 'barrier q[2];',\n",
155 | " 'barrier q[3];',\n",
156 | " 'barrier q[4];',\n",
157 | " 'c[0] = measure q[0];',\n",
158 | " 'c[1] = measure q[1];',\n",
159 | " 'c[2] = measure q[2];',\n",
160 | " 'c[3] = measure q[3];',\n",
161 | " 'c[4] = measure q[4];']"
162 | ]
163 | },
164 | "execution_count": 7,
165 | "metadata": {},
166 | "output_type": "execute_result"
167 | }
168 | ],
169 | "source": [
170 | "module.unroll()\n",
171 | "\n",
172 | "dumps(module).splitlines()"
173 | ]
174 | },
175 | {
176 | "cell_type": "code",
177 | "execution_count": 8,
178 | "metadata": {},
179 | "outputs": [
180 | {
181 | "data": {
182 | "text/plain": [
183 | "5"
184 | ]
185 | },
186 | "execution_count": 8,
187 | "metadata": {},
188 | "output_type": "execute_result"
189 | }
190 | ],
191 | "source": [
192 | "module.depth()"
193 | ]
194 | },
195 | {
196 | "cell_type": "markdown",
197 | "metadata": {},
198 | "source": [
199 | "- Let us now remove the idle qubits from our qasm program and get back the optimized qasm code.\n",
200 | "- Note that `q[6]` to `q[9]` are idle qubits in the above qasm code."
201 | ]
202 | },
203 | {
204 | "cell_type": "code",
205 | "execution_count": 9,
206 | "metadata": {},
207 | "outputs": [
208 | {
209 | "data": {
210 | "text/plain": [
211 | "az login to make sure your Azure credentials are stored.\n",
80 | "┌───┐┌───┐ ┌───┐ ┌─────────┐ ┌────┐ \n", 132 | "q_0: ┤ H ├┤ X ├─┤ S ├─┤ Rx(π/4) ├───┤ √X ├───X────────■────\n", 133 | " ├───┤├───┤┌┴───┴┐├─────────┤ ┌┴────┴┐ │ ┌─┴─┐ \n", 134 | "q_1: ┤ H ├┤ X ├┤ Sdg ├┤ Ry(π/2) ├──┤ √Xdg ├──┼──X───┤ X ├──\n", 135 | " ├───┤├───┤└┬───┬┘├─────────┴┐┌┴──────┴┐ │ │ └───┘ \n", 136 | "q_2: ┤ H ├┤ Y ├─┤ T ├─┤ Rz(3π/4) ├┤0 ├─X──┼──■───────\n", 137 | " ├───┤├───┤┌┴───┴┐└┬────────┬┘│ Iswap │ │ │P(π/4) \n", 138 | "q_3: ┤ H ├┤ Z ├┤ Tdg ├─┤ P(π/8) ├─┤1 ├────X──■───────\n", 139 | " └───┘└───┘└─────┘ └────────┘ └────────┘" 140 | ], 141 | "text/plain": [ 142 | " ┌───┐┌───┐ ┌───┐ ┌─────────┐ ┌────┐ \n", 143 | "q_0: ┤ H ├┤ X ├─┤ S ├─┤ Rx(π/4) ├───┤ √X ├───X────────■────\n", 144 | " ├───┤├───┤┌┴───┴┐├─────────┤ ┌┴────┴┐ │ ┌─┴─┐ \n", 145 | "q_1: ┤ H ├┤ X ├┤ Sdg ├┤ Ry(π/2) ├──┤ √Xdg ├──┼──X───┤ X ├──\n", 146 | " ├───┤├───┤└┬───┬┘├─────────┴┐┌┴──────┴┐ │ │ └───┘ \n", 147 | "q_2: ┤ H ├┤ Y ├─┤ T ├─┤ Rz(3π/4) ├┤0 ├─X──┼──■───────\n", 148 | " ├───┤├───┤┌┴───┴┐└┬────────┬┘│ Iswap │ │ │P(π/4) \n", 149 | "q_3: ┤ H ├┤ Z ├┤ Tdg ├─┤ P(π/8) ├─┤1 ├────X──■───────\n", 150 | " └───┘└───┘└─────┘ └────────┘ └────────┘ " 151 | ] 152 | }, 153 | "execution_count": 4, 154 | "metadata": {}, 155 | "output_type": "execute_result" 156 | } 157 | ], 158 | "source": [ 159 | "qiskit_circuit = test_circuit()\n", 160 | "qiskit_circuit.draw()" 161 | ] 162 | }, 163 | { 164 | "cell_type": "code", 165 | "execution_count": 5, 166 | "id": "7f1ef479", 167 | "metadata": {}, 168 | "outputs": [ 169 | { 170 | "name": "stdout", 171 | "output_type": "stream", 172 | "text": [ 173 | "T : │ 0 │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │\n", 174 | " ┌───┐ ┌───┐ ┌───┐ ┌──────────┐ ┌───┐ \n", 175 | "q0 : ─┤ H ├─┤ X ├─┤ S ├───┤ Rx(0.79) ├─────┤ V ├──────x─────────────────────●────────\n", 176 | " └───┘ └───┘ └───┘ └──────────┘ └───┘ │ │ \n", 177 | " ┌───┐ ┌───┐ ┌────┐ ┌──────────┐ ┌────┐ │ ┌─┴─┐ \n", 178 | "q1 : ─┤ H ├─┤ X ├─┤ Si ├──┤ Ry(1.57) ├────┤ Vi ├──────┼────────x──────────┤ X ├──────\n", 179 | " └───┘ └───┘ └────┘ └──────────┘ └────┘ │ │ └───┘ \n", 180 | " ┌───┐ ┌───┐ ┌───┐ ┌──────────┐ ┌───────┐ │ │ \n", 181 | "q2 : ─┤ H ├─┤ Y ├─┤ T ├───┤ Rz(2.36) ├───┤ ISWAP ├────x────────┼────────────●────────\n", 182 | " └───┘ └───┘ └───┘ └──────────┘ └───┬───┘ │ │ \n", 183 | " ┌───┐ ┌───┐ ┌────┐ ┌─────────────┐ ┌───┴───┐ │ ┌──────┴──────┐ \n", 184 | "q3 : ─┤ H ├─┤ Z ├─┤ Ti ├─┤ PHASE(0.39) ├─┤ ISWAP ├─────────────x─────┤ PHASE(0.79) ├─\n", 185 | " └───┘ └───┘ └────┘ └─────────────┘ └───────┘ └─────────────┘ \n", 186 | "T : │ 0 │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │\n" 187 | ] 188 | } 189 | ], 190 | "source": [ 191 | "braket_circuit = transpile(qiskit_circuit, \"braket\")\n", 192 | "print(braket_circuit)" 193 | ] 194 | }, 195 | { 196 | "cell_type": "code", 197 | "execution_count": 6, 198 | "id": "2a6eb7e7", 199 | "metadata": {}, 200 | "outputs": [ 201 | { 202 | "name": "stdout", 203 | "output_type": "stream", 204 | "text": [ 205 | "q_0: ───H───X───S──────Rx(0.25π)───X^0.5────────────────×───────@────────\n", 206 | " │ │\n", 207 | "q_1: ───H───X───S^-1───Ry(0.5π)────X^-0.5───────────────┼───×───X────────\n", 208 | " │ │\n", 209 | "q_2: ───H───Y───T──────Rz(0.75π)───S────────H───@───X───×───┼───@────────\n", 210 | " │ │ │ │\n", 211 | "q_3: ───H───Z───T^-1───Z^(1/8)─────S────────────X───@───H───×───@^0.25───\n" 212 | ] 213 | } 214 | ], 215 | "source": [ 216 | "cirq_circuit = transpile(qiskit_circuit, \"cirq\")\n", 217 | "print(cirq_circuit)" 218 | ] 219 | }, 220 | { 221 | "cell_type": "markdown", 222 | "id": "0963d29d", 223 | "metadata": {}, 224 | "source": [ 225 | "Qubit indexing varies between packages, so some circuit diagrams appear flipped, but the matrix representations are equivalent.\n", 226 | "\n", 227 | "To verify, we'll use the sdk's `circuits_allclose` function, which applies the agnostic `qbraid.interface.to_unitary` function to each of two input circuits, checks the matricies against `np.allclose`, and returns the result." 228 | ] 229 | }, 230 | { 231 | "cell_type": "code", 232 | "execution_count": 7, 233 | "id": "665c6c0b", 234 | "metadata": {}, 235 | "outputs": [ 236 | { 237 | "data": { 238 | "text/plain": [ 239 | "True" 240 | ] 241 | }, 242 | "execution_count": 7, 243 | "metadata": {}, 244 | "output_type": "execute_result" 245 | } 246 | ], 247 | "source": [ 248 | "circuits_allclose(qiskit_circuit, braket_circuit) and circuits_allclose(\n", 249 | " braket_circuit, cirq_circuit\n", 250 | ")" 251 | ] 252 | }, 253 | { 254 | "cell_type": "markdown", 255 | "id": "5359d22b", 256 | "metadata": {}, 257 | "source": [ 258 | "## Stress-testing against randomly generated circuits" 259 | ] 260 | }, 261 | { 262 | "cell_type": "markdown", 263 | "id": "31a3cbc8", 264 | "metadata": {}, 265 | "source": [ 266 | "For a second example, we'll generate some even larger circuits, and do so randomly, to test the limits of the transpiler.\n", 267 | "\n", 268 | "The qBraid-SDK has its own `random_circuit` function that takes in any supported package as an argument, but to show that there's no pre-processing or filtering going on behind the scenes, we'll use functions from cirq's testing module to generate circuits and to check equivalance after transpiling." 269 | ] 270 | }, 271 | { 272 | "cell_type": "code", 273 | "execution_count": 8, 274 | "id": "afe95c34", 275 | "metadata": {}, 276 | "outputs": [ 277 | { 278 | "name": "stdout", 279 | "output_type": "stream", 280 | "text": [ 281 | "num_qubits: 10\n", 282 | "depth: 10\n", 283 | "op_density: 0.85\n", 284 | "matrix dimension: (1024, 1024)\n", 285 | "\n", 286 | " ┌──┐ ┌──┐ ┌──────────┐ ┌────┐ ┌───────┐ ┌───┐ ┌───┐ ┌────┐ ┌────────┐\n", 287 | "0: ─────×─────Z──────@─────────────@───────@───────────────────@──────@───────@───────────────────\n", 288 | " │ │ │ │ │ │ │\n", 289 | "1: ────Y┼─────T──────┼────iSwap────┼─────×─┼──────×────────────┼──────┼───────┼X───────×──────────\n", 290 | " │ │ │ │ │ │ │ │ │ ││ │\n", 291 | "2: ────Z┼────────────┼────iSwap────X─────┼×┼─────X┼────────────┼──────┼@─────×┼┼───────┼iSwap─────\n", 292 | " │ │ │││ ││ │ ││ │││ ││\n", 293 | "3: ────T┼─────@──────X─────────────S────S┼┼┼─────┼┼iSwap──────×┼─────Z┼┼─────┼┼┼T──────┼┼─────────\n", 294 | " │ │ │││ │││ ││ ││ │││ ││\n", 295 | "4: ────Z┼─────┼@─────iSwap─────────Y────Z┼┼┼─────@┼┼─────────Z┼┼─────X┼┼─────┼@┼───────┼┼────×────\n", 296 | " │ ││ │ │││ ││ ││ ││ │ │ ││ │\n", 297 | "5: ────T┼─────┼X─────┼────X────────Y────H┼┼┼──────┼iSwap──────┼@─────H┼┼─────┼─┼──────Y┼┼────┼────\n", 298 | " │ │ │ │ │││ │ │ ││ │ │ ││ │\n", 299 | "6: ─────┼─────@──────┼────┼────────X─────×┼┼──────┼───────────┼───────┼@─────×─┼───────┼┼────×────\n", 300 | " │ │ │ ││ │ │ │ │ ││\n", 301 | "7: ─────×────────────┼────@────────Z──────┼X─────T┼───────────×──────@┼──────Y─┼───────┼iSwap─────\n", 302 | " │ │ │ ││ │ │\n", 303 | "8: ────Y──────T──────┼────T────────X────T─┼───────┼──────────X───────X┼────────┼───────×──────────\n", 304 | " │ │ │ │ │ │ │\n", 305 | "9: ───────────Z──────iSwap─────────@──────×───────×──────────@────────@────────@──────H───────────\n", 306 | " └──┘ └──┘ └──────────┘ └────┘ └───────┘ └───┘ └───┘ └────┘ └────────┘\n" 307 | ] 308 | } 309 | ], 310 | "source": [ 311 | "import cirq\n", 312 | "\n", 313 | "kwargs = {\n", 314 | " \"num_qubits\": np.random.randint(8, 11),\n", 315 | " \"depth\": np.random.randint(8, 11),\n", 316 | " \"op_density\": np.random.randint(80, 100) / 100,\n", 317 | " \"random_state\": np.random.randint(1, 11),\n", 318 | "}\n", 319 | "\n", 320 | "circuit_start = random_circuit(\"cirq\", **kwargs)\n", 321 | "start_u = circuit_start.unitary()\n", 322 | "print(\"num_qubits:\", len(circuit_start.all_qubits()))\n", 323 | "print(\"depth:\", len(circuit_start))\n", 324 | "print(\"op_density:\", kwargs[\"op_density\"])\n", 325 | "print(f\"matrix dimension: {start_u.shape}\\n\")\n", 326 | "print(circuit_start)" 327 | ] 328 | }, 329 | { 330 | "cell_type": "markdown", 331 | "id": "5818071d", 332 | "metadata": {}, 333 | "source": [ 334 | "Starting with this randomly generated circuit, we'll repeatedly apply the qbraid circuit wrapper and transpile from one supported package to the next until we arrive all the way back at a cirq circuit." 335 | ] 336 | }, 337 | { 338 | "cell_type": "code", 339 | "execution_count": 9, 340 | "id": "bbe4be5f", 341 | "metadata": {}, 342 | "outputs": [ 343 | { 344 | "name": "stdout", 345 | "output_type": "stream", 346 | "text": [ 347 | "