Utilize the pytket compilation passes to decrease the number of two-qubit gates¶

1. Generate a random circuit using qiskit random_circuit.
2. Use Qiskit's IBMProvider to fetch and set up the IBMQ Jakarta backend with the QiskitRuntimeService account.
3. Transpile the circuit using Qiskit's transpile function at the highest optimization level, which is level 3.
4. Convert the qiskit circuit to a pytket circuit using qiskit_to_tk.
5. Use TKET's IBMQBackend to fetch and set up the IBMQ Jakarta backend.
6. Compile the circuit using TKET's default compilation pass get_compiled_circuit.
7. Convert the pytket circuit back to a qiskit circuit using tk_to_qiskit.

Requirments:

• pytket
• matplotlib
• pytket-qiskit

In [1]:

import warnings

warnings.filterwarnings('ignore')

import warnings warnings.filterwarnings('ignore')

In [2]:

# setup IBMQ Jakarta backend
from qiskit_ibm_provider import IBMProvider
provider = IBMProvider()
backend = provider.get_backend("ibmq_jakarta")

# import function to create random quantum circuit
from qiskit.circuit.random import random_circuit

# create a random circuit
qc = random_circuit(num_qubits=7, depth=9, max_operands=3, measure=True, seed=0)
qc.draw(output='mpl')  #The 'pylatexenc' library is required to use 'MatplotlibDrawer'

# setup IBMQ Jakarta backend from qiskit_ibm_provider import IBMProvider provider = IBMProvider() backend = provider.get_backend("ibmq_jakarta") # import function to create random quantum circuit from qiskit.circuit.random import random_circuit # create a random circuit qc = random_circuit(num_qubits=7, depth=9, max_operands=3, measure=True, seed=0) qc.draw(output='mpl') #The 'pylatexenc' library is required to use 'MatplotlibDrawer'

---------------------------------------------------------------------------
AccountNotFoundError                      Traceback (most recent call last)
Input In [2], in <cell line: 3>()
      1 # setup IBMQ Jakarta backend
      2 from qiskit_ibm_provider import IBMProvider
----> 3 provider = IBMProvider()
      4 backend = provider.get_backend("ibmq_jakarta")
      6 # import function to create random quantum circuit

File ~/opt/anaconda3/lib/python3.9/site-packages/qiskit_ibm_provider/ibm_provider.py:158, in IBMProvider.__init__(self, token, url, name, instance, proxies, verify)
    135 """IBMProvider constructor
    136 
    137 Args:
   (...)
    155 
    156 """
    157 super().__init__()
--> 158 self._account = self._discover_account(
    159     token=token,
    160     url=url,
    161     instance=instance,
    162     name=name,
    163     proxies=ProxyConfiguration(**proxies) if proxies else None,
    164     verify=verify,
    165 )
    167 self._client_params = ClientParameters(
    168     token=self._account.token,
    169     url=self._account.url,
   (...)
    172     verify=self._account.verify,
    173 )
    174 self._auth_client = self._authenticate_ibm_quantum_account(self._client_params)

File ~/opt/anaconda3/lib/python3.9/site-packages/qiskit_ibm_provider/ibm_provider.py:217, in IBMProvider._discover_account(token, url, instance, name, proxies, verify)
    213         if url:
    214             logger.warning(
    215                 "Loading default ibm_quantum account. Input 'url' is ignored."
    216             )
--> 217         account = AccountManager.get(channel="ibm_quantum")
    219 if account is None:
    220     account = AccountManager.get()

File ~/opt/anaconda3/lib/python3.9/site-packages/qiskit_ibm_provider/accounts/management.py:154, in AccountManager.get(cls, name, channel)
    149     saved_account = read_config(
    150         filename=cls._default_account_config_json_file,
    151         name=cls._default_account_name_ibm_quantum,
    152     )
    153     if saved_account is None:
--> 154         raise AccountNotFoundError(f"No default {channel} account saved.")
    155     return Account.from_saved_format(saved_account)
    157 all_config = read_config(filename=cls._default_account_config_json_file)

AccountNotFoundError: 'No default ibm_quantum account saved.'

In [5]:

# import the transpile function that performs the transpilation
from qiskit import transpile
transpiled_qc = transpile(qc, backend=backend, optimization_level=3)

transpiled_qc.count_ops()

# import the transpile function that performs the transpilation from qiskit import transpile transpiled_qc = transpile(qc, backend=backend, optimization_level=3) transpiled_qc.count_ops()

Out[5]:

OrderedDict([('rz', 106),
             ('cx', 104),
             ('sx', 51),
             ('x', 10),
             ('measure', 7),
             ('barrier', 1)])

In [6]:

#transpiled_qc.draw(output='mpl',idle_wires=False)

#transpiled_qc.draw(output='mpl',idle_wires=False)

In [7]:

# import TKET backend
from pytket.extensions.qiskit import IBMQBackend
tket_backend = IBMQBackend('ibmq_jakarta')

# import Qiskt <=> TKET circuit rewrite
from pytket.extensions.qiskit import qiskit_to_tk, tk_to_qiskit

# convert already transpiled Qiskit circuit to TKET circuit
tket_qc = qiskit_to_tk(transpiled_qc)

from pytket.circuit.display import render_circuit_jupyter
render_circuit_jupyter(tket_qc)

# import TKET backend from pytket.extensions.qiskit import IBMQBackend tket_backend = IBMQBackend('ibmq_jakarta') # import Qiskt <=> TKET circuit rewrite from pytket.extensions.qiskit import qiskit_to_tk, tk_to_qiskit # convert already transpiled Qiskit circuit to TKET circuit tket_qc = qiskit_to_tk(transpiled_qc) from pytket.circuit.display import render_circuit_jupyter render_circuit_jupyter(tket_qc)

In [8]:

# use TKET default compilation (transpilation) pass
compiled_tket_qc = tket_backend.get_compiled_circuit(tket_qc,optimisation_level=2)

# convert TKET circuit to Qiskit circuit
compiled_qc = tk_to_qiskit(compiled_tket_qc)

compiled_qc.count_ops()

# use TKET default compilation (transpilation) pass compiled_tket_qc = tket_backend.get_compiled_circuit(tket_qc,optimisation_level=2) # convert TKET circuit to Qiskit circuit compiled_qc = tk_to_qiskit(compiled_tket_qc) compiled_qc.count_ops()

Out[8]:

OrderedDict([('cx', 93),
             ('rz', 90),
             ('sx', 49),
             ('x', 13),
             ('measure', 7),
             ('barrier', 1)])

Qiskit transpile (optimization level 3)

Gate	Count
cx	104
rz	106
sx	51
x	10

combined with TKET get.compiled (optimization level 2, default)

Gate	Count
cx	93
rz	90
sx	49
x	13

In [ ]:

compiled_qc = tk_to_qiskit(compiled_tket_qc)

compiled_qc = tk_to_qiskit(compiled_tket_qc)

By incorporating the TKET compiler into your workflow, you can potentially decrease the number of two-qubit gates in your circuit. This reduction can help mitigate errors during circuit execution.¶

Now compile to Quantinuum Devices

In [14]:

from pytket.extensions.quantinuum import QuantinuumBackend
from pytket.circuit import Circuit, OpType
machine = "H1-1E"
backend = QuantinuumBackend(device_name=machine, machine_debug=True)
import pytket.extensions.quantinuum.backends.quantinuum as qtm
qtm._GATE_SET.add(OpType.ZZPhase)

compiled_circuit = backend.get_compiled_circuit(tket_qc, optimisation_level=2)

from pytket.extensions.quantinuum import QuantinuumBackend from pytket.circuit import Circuit, OpType machine = "H1-1E" backend = QuantinuumBackend(device_name=machine, machine_debug=True) import pytket.extensions.quantinuum.backends.quantinuum as qtm qtm._GATE_SET.add(OpType.ZZPhase) compiled_circuit = backend.get_compiled_circuit(tket_qc, optimisation_level=2)

In [15]:

print("Total number of gates =", compiled_circuit.n_gates)
print("Number of two qubit gates =", compiled_circuit.n_2qb_gates())

print("Total number of gates =", compiled_circuit.n_gates) print("Number of two qubit gates =", compiled_circuit.n_2qb_gates())

Total number of gates = 104
Number of two qubit gates = 32

In [ ]:

OpenQASM¶

• Open quantum assembly language
• Can be used to write circuits
• Servers as a platform-independent method of storing circuits
• TKET has bidirectional conversion support for QASM

In [9]:

from pytket.qasm import circuit_from_qasm_str
from pytket.circuit.display import render_circuit_jupyter

openqasm = """
// Header
OPENQASM 2.0;
include "qelib1.inc";

// Registers
qreg q[2];
creg cr[2];

// Gates
h q[0];
CX q[0], q[1];

// Measurement
measure q -> cr;

"""

from pytket.qasm import circuit_from_qasm_str from pytket.circuit.display import render_circuit_jupyter openqasm = """ // Header OPENQASM 2.0; include "qelib1.inc"; // Registers qreg q[2]; creg cr[2]; // Gates h q[0]; CX q[0], q[1]; // Measurement measure q -> cr; """

In [10]:

circ = circuit_from_qasm_str(openqasm)
render_circuit_jupyter(circ)

circ = circuit_from_qasm_str(openqasm) render_circuit_jupyter(circ)

In [ ]: