Beispiel #1
0
def main():

    # parameters for generating random state: |psi>
    alpha, beta, gamma = random.random(), random.random(), random.random()

    # reference state: T|psi>
    qs_expect = QState(1)
    qs_expect.rz(0, phase=alpha).rx(0, phase=beta).rz(0, phase=gamma).t(0)

    # prepare initial state
    qs = QState(3)
    qs.h(0).s(0)  # |Y>
    qs.h(1).t(1)  # |A>
    qs.rz(2, phase=alpha).rx(2, phase=beta).rz(2, phase=gamma)  # |psi>

    # T gate (only with X,Z,H,CNOT and measurement)
    qs.cx(1, 2)
    mval = qs.m(qid=[2]).last
    if mval == '1':
        qs.cx(1, 0).h(0).cx(1, 0).h(0)
        qs.x(1).z(1)
    qs_actual = qs.partial(qid=[1])

    # show the result
    print("== expect ==")
    qs_expect.show()
    print("== actual ==")
    qs_actual.show()
    print("== fidelity ==")
    print("{:.6f}".format(qs_actual.fidelity(qs_expect)))
Beispiel #2
0
def main():

    a = random.uniform(0.0, 1.0)
    b = random.uniform(0.0, 1.0)
    phi = random.uniform(0.0, 1.0)
    print("a,b = {0:.4f}, {1:.4f}".format(a,b))
    print("phi = {0:.4f}".format(phi))

    print("** one-way quantum computing")

    # graph state
    qs_oneway = QState(2)
    qs_oneway.ry(0, phase=a).rz(0, phase=b)  # input state (random)
    qs_oneway.h(1)
    qs_oneway.cz(0,1)

    # measurement
    s = qs_oneway.m([0], shots=1, angle=0.5, phase=phi)

    # result state
    qs_oneway.show([1])

    print("** conventianal quantum gate")

    qs_gate = QState(1)
    qs_gate.ry(0, phase=a).rz(0, phase=b)  # input state (random)
    qs_gate.rz(0, phase=-phi).h(0)
    qs_gate.show()
Beispiel #3
0
    def test_measure_random(self):
        """test 'random'
        """

        a, b, c = random.random(), random.random(), random.random()
        d, e, f = random.random(), random.random(), random.random()

        qc = QCirc()
        qc.rz(0, phase=a).rx(0, phase=b).rz(0, phase=c).h(0).cx(0, 1)
        qc.rz(1, phase=d).rx(1, phase=e).rz(1, phase=f).h(0).cx(0, 1)
        qc.measure(qid=[0, 1], cid=[0, 1])

        qs = QState(qubit_num=2)
        qs.rz(0, phase=a).rx(0, phase=b).rz(0, phase=c).h(0).cx(0, 1)
        qs.rz(1, phase=d).rx(1, phase=e).rz(1, phase=f).h(0).cx(0, 1)

        value = evaluate(qc, qs)
        self.assertEqual(value < EPS, True)
Beispiel #4
0
def cost(phi):

    qs = QState(2)

    qs.rx(0, phase=phi[0])
    qs.rz(0, phase=phi[1])
    qs.rx(1, phase=phi[2])
    qs.rz(1, phase=phi[3])
    qs.cx(1, 0)
    qs.rz(1, phase=phi[4])
    qs.rx(1, phase=phi[5])

    exp = ExpectVal(M, qs)

    # qs.free()

    return exp