submit test case for legacy cases.

Author: tencentqlab

tests/0.1_qem_and_lib.py

@@ -0,0 +1,67 @@
+import sys
+import os
+import matplotlib.pyplot as plt
+
+# Add the directory containing your module to Python's search path
+module_path = ".."
+sys.path.insert(0, module_path)
+
+import tensorcircuit as tc
+from tensorcircuit.cloud.apis import submit_task, get_device, set_provider, set_token
+from library.adder import gen_adder_circ
+from library.aqft import gen_aqft_circ
+from library.bv import gen_bv_circ
+from library.grover import gen_grover_circ
+from library.qft_adder import qft_adder
+from library.uccsd  import gen_uccsd
+from library.hwea  import gen_hwea_circ
+
+set_token(os.getenv("TOKEN"))
+shots = 8192
+mit = tc.results.rem.ReadoutMit('tianji_s2?o=7') 
+mit.cals_from_system(13, shots, method='local')
+set_provider("tencent")
+d = get_device("tianji_s2")
+submit_task(
+    circuit=gen_adder_circ(3),
+    shots=shots,
+    device=d
+)
+submit_task(
+    circuit=gen_grover_circ(3),
+    shots=shots,
+    device=d
+)
+# submit_task(
+#     circuit=dynamics_circuit(4, 1.0, 0.1, 3),
+#     shots=shots,
+#     device=get_device("tianji_s2"),
+# )
+submit_task(
+    circuit=gen_bv_circ(9, 4),
+    shots=shots,
+    device=d
+)
+submit_task(
+    circuit=gen_uccsd(4),
+    shots=shots,
+    device=d
+)
+qc = qft_adder(3, 2, 5)
+print(qc)
+submit_task(
+    circuit=qc,
+    shots=shots,
+    device=d
+)
+submit_task(
+    circuit=gen_hwea_circ(4, 2),
+    shots=shots,
+    device=d
+)   
+submit_task(
+    circuit=gen_aqft_circ(4),
+    shots=shots, 
+    device=d
+)
+print("✅ TEST FILE DONE")

tests/library/adder.py

@@ -0,0 +1,200 @@
+'''
+Teague Tomesh - 2/10/2020
+
+Implementation of an n-bit ripple-carry adder.
+
+Based on the specification given in Cuccaro, Draper, Kutin, Moulton.
+(https://arxiv.org/abs/quant-ph/0410184v1)
+'''
+
+from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
+import tensorcircuit as tc
+from .randinit import qc_randinit
+
+
+class RCAdder:
+    """
+    An n-bit ripple-carry adder can be generated using an instance of the
+    RCAdder class by calling the gen_circuit() method.
+
+    This adder circuit uses 1 ancilla qubit to add together two values
+        a = a_(n-1)...a_0    and   b = b_(n-1)...a_0
+    and store their sum
+        s = s_n...s_0
+    in the registers which initially held the b value.
+
+    The adder circuit uses 2 + binary_len(a) + binary_len(b) qubits.
+    The initial carry value is stored in the qubit at index = 0.
+    The binary value of a_i is stored in the qubit at index = 2*i + 2
+    The binary value of b_i is stored in the qubit at index = 2*i + 1
+    The high bit, s_n, is stored in the last qubit at index = num_qubits - 1
+
+    Attributes
+    ----------
+    nbits : int
+        size, in bits, of the numbers the adder can handle
+    nq : int
+        number of qubits needed to construct the adder circuit
+    a, b : int
+        optional parameters to specify the numbers the adder should add.
+        Will throw an exception if the length of the bitstring representations
+        of a or b are greater than nbits.
+    use_toffoli : bool
+        Should the toffoli gate be used in the generated circuit or should it
+        first be decomposed
+    barriers : bool
+        should barriers be included in the generated circuit
+    regname : str
+        optional string to name the quantum and classical registers. This
+        allows for the easy concatenation of multiple QuantumCircuits.
+    qr : QuantumRegister
+        Qiskit QuantumRegister holding all of the quantum bits
+    circ : QuantumCircuit
+        Qiskit QuantumCircuit that represents the uccsd circuit
+    """
+
+    def __init__(self, nbits=None, a=0, b=0, use_toffoli=False, barriers=False,
+                 measure=False, regname=None):
+
+        # number of bits the adder can handle
+        if nbits is None:
+            raise Exception('Number of bits must be specified')
+        else:
+            self.nbits = nbits
+
+        # given nbits, compute the number of qubits the adder will need
+        # number of qubits = 1 ancilla for the initial carry value
+        #                    + 2*nbits to hold both a and b
+        #                    + 1 more qubit to hold the high bit, s_n
+        self.nq = 1 + 2*nbits + 1
+
+        # set flags for circuit generation
+        if len('{0:b}'.format(a)) > nbits or len('{0:b}'.format(b)) > nbits:
+            raise Exception('Binary representations of a and b must be less than or equal to nbits')
+
+        self.a = a
+        self.b = b
+        self.use_toffoli = use_toffoli
+        self.barriers = barriers
+        self.measure = measure
+
+        # create a QuantumCircuit object
+        if regname is None:
+            self.qr = QuantumRegister(self.nq)
+        else:
+            self.qr = QuantumRegister(self.nq, name=regname)
+        self.circ = QuantumCircuit(self.qr)
+        qc_randinit(self.circ)
+
+        # add ClassicalRegister if measure is True
+        if self.measure:
+            self.cr = ClassicalRegister(self.nq)
+            self.circ.add_register(self.cr)
+
+
+    def _initialize_value(self, indices, value):
+        """
+        Initialize the qubits at indices to the given value
+
+        Parameters
+        ----------
+        indices : List[int]
+            List of qubit indices
+        value : int
+            The desired initial value
+        """
+        binstr = '{0:b}'.format(value)
+        for index, val in enumerate(reversed(binstr)):
+            if val is '1':
+                self.circ.x(indices[index])
+
+
+    def _toffoli(self, x, y, z):
+        """
+        Implement the toffoli gate using 1 and 2 qubit gates
+        """
+        self.circ.h(z)
+        self.circ.cx(y,z)
+        self.circ.tdg(z)
+        self.circ.cx(x,z)
+        self.circ.t(z)
+        self.circ.cx(y,z)
+        self.circ.t(y)
+        self.circ.tdg(z)
+        self.circ.cx(x,z)
+        self.circ.cx(x,y)
+        self.circ.t(z)
+        self.circ.h(z)
+        self.circ.t(x)
+        self.circ.tdg(y)
+        self.circ.cx(x,y)
+
+
+    def _MAJ(self, x, y, z):
+        """
+        Implement the MAJ (Majority) gate described in Cuccaro, Draper, Kutin,
+        Moulton.
+        """
+        self.circ.cx(z,y)
+        self.circ.cx(z,x)
+
+        if self.use_toffoli:
+            self.circ.ccx(x,y,z)
+        else:
+            # use a decomposed version of toffoli
+            self._toffoli(x,y,z)
+
+
+    def _UMA(self, x, y, z):
+        """
+        Implement the UMA (UnMajority and Add) gate described in Cuccaro,
+        Draper, Kutin, Moulton.
+        """
+        self.circ.x(y)
+        self.circ.cx(x,y)
+        if self.use_toffoli:
+            self.circ.ccx(x,y,z)
+        else:
+            # use a decomposed version of toffoli
+            self._toffoli(x,y,z)
+        self.circ.x(y)
+        self.circ.cx(z,x)
+        self.circ.cx(z,y)
+
+
+    def gen_circuit(self):
+        """
+        Create a circuit implementing the ripple-carry adder
+
+        Returns
+        -------
+        QuantumCircuit
+            QuantumCircuit object of size self.nq
+        """
+        high_bit_index = self.nq-1
+
+        # initialize the a and b registers
+        a_indices = [2*i+2 for i in range(self.nbits)]
+        b_indices = [2*i+1 for i in range(self.nbits)]
+        for index_list, value in zip([a_indices, b_indices], [self.a, self.b]):
+            self._initialize_value(index_list, value)
+
+        # compute the carry bits, c_i, in order using the MAJ ladder
+        for a_i in a_indices:
+            self._MAJ(a_i-2, a_i-1, a_i)
+
+        # write the final carry bit value to the high bit register
+        self.circ.cx(a_indices[-1], high_bit_index)
+
+        # erase the carry bits in reverse order using the UMA ladder
+        for a_i in reversed(a_indices):
+            self._UMA(a_i-2, a_i-1, a_i)
+
+        return self.circ
+
+
+def gen_adder_circ(nbits):
+    adder = RCAdder(nbits, a=0, b=0)
+    circ = adder.gen_circuit()
+    return tc.Circuit.from_qiskit(circ)
+

tests/library/aqft.py

@@ -0,0 +1,117 @@
+import math
+import numpy as np
+import tensorcircuit as tc
+from .randinit import qc_randinit
+
+class QFT:
+    """
+    Class which generates the circuit to perform the Quantum Fourier
+    Transform (or its inverse) as described in Mike & Ike Chapter 5.
+
+    (Michael A Nielsen and Isaac L Chuang. Quantum computation and quantum
+     information (10th anniv. version), 2010.)
+
+    For another example see Figure 1 of Daniel E Browne 2007 New J. Phys. 9 146
+
+    A QFT or iQFT circuit can be generated with a given instance of the
+    QFT class by calling the gen_circuit() method.
+
+    Attributes
+    ----------
+    width : int
+        number of qubits
+    inverse : bool
+        Set to true to generate the inverse quantum fourier transform
+    kvals : bool
+        optional parameter that will change the angle of the controlled
+        rotations so that when the circuit is printed it will display
+        the same k values that are shown in Mike & Ike Chpt 5, Fig 5.1
+        (NOTE: the generated circuit will no longer be valid! This is
+         for visualization purposes only.)
+    barriers : bool
+        should barriers be included in the generated circuit
+    measure : bool
+        should a classical register & measurement be added to the circuit
+    regname : str
+        optional string to name the quantum and classical registers. This
+        allows for the easy concatenation of multiple QuantumCircuits.
+    qr : QuantumRegister
+        Qiskit QuantumRegister holding all of the quantum bits
+    cr : ClassicalRegister
+        Qiskit ClassicalRegister holding all of the classical bits
+    circ : QuantumCircuit
+        Qiskit QuantumCircuit that represents the uccsd circuit
+    """
+
+    def __init__(self, width, approximation_degree, inverse=False, kvals=False, barriers=True,
+                 measure=False, regname=None):
+
+        # number of qubits
+        self.nq = width
+        self.approximation_degree = approximation_degree
+
+        # set flags for circuit generation
+        self.inverse = inverse
+        self.kvals = kvals
+        self.barriers = barriers
+        self.measure = measure
+
+        # create a QuantumCircuit object
+        self.circ = tc.Circuit(self.nq)
+        qc_randinit(self.circ)
+    
+
+    def reg_qft(self):
+        """
+        Implement the QFT on self.circ
+
+        j ranges from 0   -> nq-1
+        k ranges from j+1 -> nq-1
+
+        For each j qubit, a controlled cu1 gate is applied with target=j,
+        control=k (for each k).
+
+        cu1 = 1  0
+              0  e^(2pi*i / 2^(k-j+1))
+        """
+
+        # CPHASE gate decompostion
+        def cu1(circ, theta, j, k):
+            circ.RZ(k, theta=theta)
+            circ.cnot(j, k)
+            circ.RZ(k, theta=-theta/2)
+            circ.cnot(j, k)
+            circ.RZ(k, theta=-theta/2)
+            circ.RZ(j, theta=-theta/2)
+
+        for j in range(self.nq):
+            self.circ.H(j)
+            for k in range(j+1,self.nq):
+                if k-j+1<=self.approximation_degree:
+                    cu1(self.circ, (2*np.pi)/(2**(k-j+1)), j, k)
+                    
+
+
+    def gen_circuit(self):
+        """
+        Create a circuit implementing the UCCSD ansatz
+
+        Given the number of qubits and parameters, construct the
+        ansatz as given in Whitfield et al.
+
+        Returns
+        -------
+        QuantumCircuit
+            QuantumCircuit object of size nq with no ClassicalRegister and
+            no measurements
+        """
+        self.reg_qft()
+
+        return self.circ
+
+
+def gen_aqft_circ(full_circ_size, approximation_degree=None):
+    if not approximation_degree:
+        approximation_degree=int(math.log(full_circ_size,2)+1)
+    full_circ = QFT(full_circ_size, approximation_degree).gen_circuit()
+    return full_circ