Beispiel #1
0
    def test2_abstract_variables(self):
        """
        Tests the translation of abstract variables and
        ArithExpression into Qiskit via qlm_to_qiskit()
        """
        prog = Program()
        qubits = prog.qalloc(1)
        var2 = prog.new_var(float, "param2")
        var3 = prog.new_var(float, "param3")
        var4 = 1.0 + 3.14 + var2 - var3
        var5 = 1.0 * 3.14 * (var2 + 4.54) * var3
        var6 = -var5 * var4
        var7 = var4 / (var2 - 7)
        prog.apply(RX(1.0), qubits[0])
        prog.apply(RX(3.14), qubits[0])
        prog.apply(RX(var2), qubits[0])
        prog.apply(RX(var3), qubits[0])
        prog.apply(RX(var4), qubits[0])
        prog.apply(RX(var5), qubits[0])
        prog.apply(RX(var6), qubits[0])
        prog.apply(RX(var7), qubits[0])
        qlm_circ = prog.to_circ()
        qiskit_circ = qlm_to_qiskit(qlm_circ)
        LOGGER.debug("Parameters gotten:")
        for gate_op in qiskit_circ.data:
            for param in gate_op[0]._params:
                LOGGER.debug(param)

        qreg = QuantumRegister(1)
        circ = QuantumCircuit(qreg)
        param2 = Parameter("param2")
        param3 = Parameter("param3")
        param4 = 1.0 + 3.14 + param2 - param3
        param5 = 1.0 * 3.14 * (param2 + 4.54) * param3
        param6 = -param5 * param4
        param7 = param4 / (param2 - 7.0)
        circ.rx(1.0, 0)
        circ.rx(3.14, 0)
        circ.rx(param2, 0)
        circ.rx(param3, 0)
        circ.rx(param4, 0)
        circ.rx(param5, 0)
        circ.rx(param6, 0)
        circ.rx(param7, 0)
        LOGGER.debug("Parameters expected:")
        for gate_op in circ.data:
            for param in gate_op[0]._params:
                LOGGER.debug(param)

        for gotten, expected in zip(qiskit_circ.data, circ.data):
            self.assertEqual(str(gotten[0]._params[0]),
                             str(expected[0]._params[0]))
Beispiel #2
0
from qiskit.circuit import Parameter

LOGGER = logging.getLogger()
# Set level to logging.DEBUG in order to see more information
LOGGER.setLevel(logging.WARNING)

# redirects log writing to terminal
STREAM_HANDLER = logging.StreamHandler()
STREAM_HANDLER.setLevel(logging.DEBUG)
LOGGER.addHandler(STREAM_HANDLER)

PYGATES_1QB = [
    X, Y, Z, I, S, T,
    S.dag(),
    T.dag(), H,
    RX(3.14),
    RY(3.14),
    RZ(3.14),
    U2(3.14, 3.14),
    R(3.14, 3.14),
    U3(3.14, 3.14, 3.14)
]
PYGATES_2QB = [
    SWAP, CNOT,
    Y.ctrl(),
    Z.ctrl(),
    H.ctrl(),
    RZ(3.14).ctrl(),
    RXX(3.14),
    RZZ(3.14)
]
    def test1_abstract_variables(self):
        """
        Tests the conversion of Parameter objects from Qiskit into
        abstract Variable objects in QLM via qiskit_to_qlm.
        """
        qreg = QuantumRegister(1)
        circ = QuantumCircuit(qreg)
        param0 = Parameter("param0")
        param1 = Parameter("param1")
        param2 = Parameter("param2")
        param3 = Parameter("param3")
        param0.expr = 1
        param1.expr = 3.14
        param4 = param0 + param1 + param2 - param3
        param5 = param0 * param1 * (param2 + 4.54) * param3
        param6 = param5 * param4
        param7 = param4 / (param2 - 7)
        circ.rx(param0, 0)
        circ.rx(param1, 0)
        circ.rx(param2, 0)
        circ.rx(param3, 0)
        circ.rx(param4, 0)
        circ.rx(param5, 0)
        circ.rx(param6, 0)
        circ.rx(param7, 0)
        qlm_circ = qiskit_to_qlm(circ)
        i = 0
        for _, params, _ in qlm_circ.iterate_simple():
            for param in params:
                LOGGER.debug(param.to_thrift())
                if i == 0:
                    self.assertEqual(param.to_thrift(), "param0")
                if i == 1:
                    self.assertEqual(param.to_thrift(), "param1")
                if i == 2:
                    self.assertEqual(param.to_thrift(), "param2")
                if i == 3:
                    self.assertEqual(param.to_thrift(), "param3")
                if i == 4:
                    self.assertEqual(
                        param.to_thrift(),
                        "+ + + * -1.0 param3 param2 param0 param1")
                if i == 5:
                    self.assertEqual(
                        param.to_thrift(),
                        "* * * + 4.54 param2 param0 param1 param3")
                if i == 6:
                    self.assertEqual(
                        param.to_thrift(),
                        "* * * * + + + * -1.0 param3 param2 param0 param1 " +
                        "+ 4.54 param2 param0 param1 param3")
                if i == 7:
                    self.assertEqual(
                        param.to_thrift(),
                        "* + + + * -1.0 param3 param2 param0 param1" +
                        " ** + -7.0 param2 -1.0")
            i += 1

        prog = Program()
        qubits = prog.qalloc(1)
        var0 = prog.new_var(float, "param0")
        var1 = prog.new_var(float, "param1")
        var2 = prog.new_var(float, "param2")
        var3 = prog.new_var(float, "param3")
        var4 = var0 + var1 + var2 - var3
        var5 = var0 * var1 * (var2 + 4.54) * var3
        var6 = var5 * var4
        var7 = var4 / (var2 - 7)
        prog.apply(RX(var0), qubits[0])
        prog.apply(RX(var1), qubits[0])
        prog.apply(RX(var2), qubits[0])
        prog.apply(RX(var3), qubits[0])
        prog.apply(RX(var4), qubits[0])
        prog.apply(RX(var5), qubits[0])
        prog.apply(RX(var6), qubits[0])
        prog.apply(RX(var7), qubits[0])
        qlm_circ_expected = prog.to_circ()
        qlm_circ_expected(var0=1)
        qlm_circ_expected(var1=3.14)
        for _, params, _ in qlm_circ_expected.iterate_simple():
            for param in params:
                LOGGER.debug(param.to_thrift())