In this presentation, I will introduce pytket, an algorithm development kit for quantum computers from Cambridge Quantum Computing. In this article, we will introduce pytket, an algorithm development kit for quantum computers from Cambridge Quantum Computing, and show how to use it to run the Variational Quantum Eigensolver (VQE), one of the variational quantum algorithms. This pytket, like blueqat, can use various backends, and unusually can submit jobs to Honeywell machines. However, the specification of this pytket changes two or three times with each version update, so the previous writing style will soon no longer work. In this article, we will show the results of the calculations in these environments. python environment: python3.9.10 (64-bit)pytket version: pytket0.17.0, pytket-qiskit0.20.0Runtime environment: Visual Studio 2017 In pytket, a quantum circuit is described as follows. <pre class="ql-syntax" spellcheck="false">from pytket import Circuit
from pytket.extensions.qiskit.backends import AerBackend, IBMQBackend, AerStateBackend
</pre> In this version, the backend is written as follows, and the result of the circuit execution is retrieved like this. <pre class="ql-syntax" spellcheck="false">circ = Circuit(2, 2)
circ.Rx(0.3, 0).Ry(0.5, 1).Rz(-0.6, 1).measure_all()

b = AerBackend()
bs = AerStateBackend()
b.compile_circuit(circ)        # performs the minimal compilation to satisfy the device/simulator constraints
handle = b.process_circuit(circ, 1024)   # run the circuit 1024 times
bs.compile_circuit(circ)
from pytket.utils import probs_from_counts
print(b.get_result(handle))
print(bs)
state = bs.process_circuit(circ).get_state()
nvector = state.round(16)
print(probs_from_counts(b.get_result(handle).get_counts())) # retrieve and return the readouts
print(nvector)
</pre> By changing the backend, it is possible to run the calculation on various quantum computers and their simulators. However, unfortunately, it is not possible to do calculations without it, as in blueqat. I will explain how to run VQE from here. If you are not familiar with VQE, please see <a href="https://blueqat.com/H.Wakaura/bdc1d1a8-b3f7-473f-a50d-c143e0f03fb2" rel="noopener noreferrer" target="_blank">here</a>. The following is the source code distributed by the official source on <a href="https://github.com/CQCL/pytket/blob/main/examples/ucc_vqe.ipynb" rel="noopener noreferrer" target="_blank">GitHub</a>, which calculates the ground energy of molecular hydrogen with an interatomic distance of 0.75 (Å). The Hamiltonian is from openfermion, and the basis is STO-3G. The clusters are from UCCSD, and the three variables are two one-electron excitations and one two-electron excitation. Line 120 registers them in the circuit, and line 122 is the part that calculates the energy from the circuit and returns the sum of the Coulomb repulsion potentials. <pre class="ql-syntax" spellcheck="false">from pytket import Circuit
from pytket.extensions.qiskit.backends import AerBackend, IBMQBackend, AerStateBackend
import sys
from openfermion import *
from scipy import *
from scipy.optimize import minimize as scipy_minimizer
from scipy import interpolate
import numpy as np
import numpy as np
import copy
from collections import Counter, defaultdict
from functools import reduce
import itertools
import random
import warnings
import time
import csv


# # VQE for Unitary Coupled Cluster using tket


# In this tutorial, we will focus on:
# - building parameterised ansätze for variational algorithms;
# - compilation tools for UCC-style ansätze.


# This example assumes the reader is familiar with the Variational Quantum Eigensolver and its application to electronic structure problems through the Unitary Coupled Cluster approach.
#
# To run this example, you will need `pytket` and `pytket-qiskit`, as well as `openfermion`, `scipy`, and `sympy`.
#
# We will start with a basic implementation and then gradually modify it to make it faster, more general, and less noisy. The final solution is given in full at the bottom of the notebook.
#
# Suppose we have some electronic configuration problem, expressed via a physical Hamiltonian. (The Hamiltonian and excitations in this example were obtained using `qiskit-aqua` version 0.5.2 and `pyscf` for H2, bond length 0.75A, sto3g basis, Jordan-Wigner encoding, with no qubit reduction or orbital freezing.)


from openfermion import QubitOperator


from openfermion import QubitOperator
from scipy.optimize import minimize
from sympy import symbols


from pytket.extensions.qiskit import AerBackend
from pytket.circuit import Circuit, Qubit
from pytket.partition import PauliPartitionStrat
from pytket.passes import GuidedPauliSimp, FullPeepholeOptimise
from pytket.pauli import Pauli, QubitPauliString
from pytket.utils import get_operator_expectation_value, gen_term_sequence_circuit
from pytket.utils.operators import QubitPauliOperator


# Obtain electronic Hamiltonian:


hamiltonian = (
    -0.8153001706270075 * QubitOperator(&#34;&#34;)
    + 0.16988452027940318 * QubitOperator(&#34;Z0&#34;)
    + -0.21886306781219608 * QubitOperator(&#34;Z1&#34;)
    + 0.16988452027940323 * QubitOperator(&#34;Z2&#34;)
    + -0.2188630678121961 * QubitOperator(&#34;Z3&#34;)
    + 0.12005143072546047 * QubitOperator(&#34;Z0 Z1&#34;)
    + 0.16821198673715723 * QubitOperator(&#34;Z0 Z2&#34;)
    + 0.16549431486978672 * QubitOperator(&#34;Z0 Z3&#34;)
    + 0.16549431486978672 * QubitOperator(&#34;Z1 Z2&#34;)
    + 0.1739537877649417 * QubitOperator(&#34;Z1 Z3&#34;)
    + 0.12005143072546047 * QubitOperator(&#34;Z2 Z3&#34;)
    + 0.04544288414432624 * QubitOperator(&#34;X0 X1 X2 X3&#34;)
    + 0.04544288414432624 * QubitOperator(&#34;X0 X1 Y2 Y3&#34;)
    + 0.04544288414432624 * QubitOperator(&#34;Y0 Y1 X2 X3&#34;)
    + 0.04544288414432624 * QubitOperator(&#34;Y0 Y1 Y2 Y3&#34;)
)
nuclear_repulsion_energy = 0.70556961456


hamiltonian_op = QubitPauliOperator.from_OpenFermion(hamiltonian)


# Obtain terms for single and double excitations:


q = [Qubit(i) for i in range(4)]
xyii = QubitPauliString([q[0], q[1]], [Pauli.X, Pauli.Y])
yxii = QubitPauliString([q[0], q[1]], [Pauli.Y, Pauli.X])
iixy = QubitPauliString([q[2], q[3]], [Pauli.X, Pauli.Y])
iiyx = QubitPauliString([q[2], q[3]], [Pauli.Y, Pauli.X])
xxxy = QubitPauliString(q, [Pauli.X, Pauli.X, Pauli.X, Pauli.Y])
xxyx = QubitPauliString(q, [Pauli.X, Pauli.X, Pauli.Y, Pauli.X])
xyxx = QubitPauliString(q, [Pauli.X, Pauli.Y, Pauli.X, Pauli.X])
yxxx = QubitPauliString(q, [Pauli.Y, Pauli.X, Pauli.X, Pauli.X])
yyyx = QubitPauliString(q, [Pauli.Y, Pauli.Y, Pauli.Y, Pauli.X])
yyxy = QubitPauliString(q, [Pauli.Y, Pauli.Y, Pauli.X, Pauli.Y])
yxyy = QubitPauliString(q, [Pauli.Y, Pauli.X, Pauli.Y, Pauli.Y])
xyyy = QubitPauliString(q, [Pauli.X, Pauli.Y, Pauli.Y, Pauli.Y])


# Symbolic UCC ansatz generation:


syms = symbols(&#34;p0 p1 p2&#34;)
singles_syms = {xyii: syms[0], yxii: -syms[0], iixy: syms[1], iiyx: -syms[1]}
doubles_syms = {
    xxxy: 0.25 * syms[2],
    xxyx: -0.25 * syms[2],
    xyxx: 0.25 * syms[2],
    yxxx: -0.25 * syms[2],
    yyyx: -0.25 * syms[2],
    yyxy: 0.25 * syms[2],
    yxyy: -0.25 * syms[2],
    xyyy: 0.25 * syms[2],
}
print(singles_syms, doubles_syms)
excitation_op = QubitPauliOperator({**singles_syms, **doubles_syms})
ucc_ref = Circuit(4).X(0).X(2)
ucc = gen_term_sequence_circuit(excitation_op, ucc_ref)


# Circuit simplification:


GuidedPauliSimp().apply(ucc)
FullPeepholeOptimise().apply(ucc)


# Connect to a simulator/device:


backend = AerBackend()


# Objective function:




def objective(params):
    circ = ucc.copy()
    sym_map = dict(zip(syms, params)) #assign parameters.
    circ.symbol_substitution(sym_map)
    return (
        get_operator_expectation_value(
            circ,
            hamiltonian_op,
            backend,
            n_shots=4000,
            partition_strat=PauliPartitionStrat.CommutingSets,
        )
        + nuclear_repulsion_energy
    ).real




# Optimise against the objective function:


initial_params = [1e-4, 1e-4, 4e-1]
result = minimize(objective, initial_params, method=&#34;Nelder-Mead&#34;)
print(&#34;Final parameter values&#34;, result.x)
print(&#34;Final energy value&#34;, result.fun)


# Exercises:
# - Replace the `get_operator_expectation_value` call with its implementation and use this to pull the analysis for measurement reduction outside of the objective function, so our circuits can be fully determined and compiled once. This means that the `symbol_substitution` method will need to be applied to each measurement circuit instead of just the state preparation circuit.
# - Use the `SpamCorrecter` class to add some mitigation of the measurement errors. Start by running the characterisation circuits first, before your main VQE loop, then apply the mitigation to each of the circuits run within the objective function.
# - Change the `backend` by passing in a `Qiskit` `NoiseModel` to simulate a noisy device. Compare the accuracy of the objective function both with and without the circuit simplification. Try running a classical optimiser over the objective function and compare the convergence rates with different noise models. If you have access to a QPU, try changing the `backend` to connect to that and compare the results to the simulator.






</pre> The result of doing this is roughly -1.13 (Hartree). In addition, there is a homework assignment at the end of this code. You can try it if you feel like it. I&#39;ll post the results of my calculations in the future.

VQE using pytket, the latest version of the 2021.

Hikaru Wakaura