def test_defgate():
# regression test for https://github.com/rigetti/pyquil/issues/1059
theta = np.pi / 2
U = np.array([[1, 0, 0, 0], [0, 1, 0, 0],
[0, 0, np.cos(theta / 2), -1j * np.sin(theta / 2)],
[0, 0, -1j * np.sin(theta / 2),
np.cos(theta / 2)]])
gate_definition = DefGate('U_test', U)
U_test = gate_definition.get_constructor()
p = Program()
p += gate_definition
p += X(1)
p += U_test(1, 0)
qam = PyQVM(n_qubits=2, quantum_simulator_type=NumpyWavefunctionSimulator)
qam.execute(p)
wf1 = qam.wf_simulator.wf
should_be = np.zeros((2, 2), dtype=np.complex128)
one_over_sqrt2 = 1 / np.sqrt(2)
should_be[0, 1] = one_over_sqrt2
should_be[1, 1] = -1j * one_over_sqrt2
np.testing.assert_allclose(wf1, should_be)
# Ensure the output of the custom U_test gate matches the standard RX gate. Something like
# RX(theta, 0).controlled(1) would be a more faithful reproduction of U_test, but
# NumpyWavefunctionSimulator doesn't (yet) support gate modifiers, so just apply the RX gate
# unconditionally.
p = Program()
p += X(1)
p += RX(theta, 0)
qam = PyQVM(n_qubits=2, quantum_simulator_type=NumpyWavefunctionSimulator)
qam.execute(p)
wf2 = qam.wf_simulator.wf
np.testing.assert_allclose(wf1, wf2)
def test_defgate():
dg = DefGate("TEST", np.array([[1., 0.],
[0., 1.]]))
assert dg.out() == "DEFGATE TEST:\n 1.0, 0.0\n 0.0, 1.0\n"
test = dg.get_constructor()
tg = test(DirectQubit(1), DirectQubit(2))
assert tg.out() == "TEST 1 2"
def test_defgate():
dg = DefGate("TEST", np.array([[0 + 0.5j, 0.5], [0.5, 0 - 0.5j]]))
assert dg.out(
) == "DEFGATE TEST:\n 0.0+0.5i, 0.5+0.0i\n 0.5+0.0i, 0.0-0.5i\n"
test = dg.get_constructor()
tg = test(DirectQubit(1), DirectQubit(2))
assert tg.out() == "TEST 1 2"
def controlled_sY(program):
csy = np.array([[1., 0., 0., 0.], [0., 1., 0., 0.], [0., 0., 0., -1.j],
[0., 0., 1.j, 0.]])
dg = DefGate('CSY', csy)
program.inst(dg)
return dg.get_constructor()
def controlled_i_X(n, a, b):
theta = Parameter('theta')
cirx = controlled_i(
np.array([[quil_cos(theta / 2), -1j * quil_sin(theta / 2)],
[-1j * quil_sin(theta / 2),
quil_cos(theta / 2)]]))
CIRX = DefGate('CIRX', cirx, [theta])
return str(CIRX) + '\n' + str(CIRX.get_constructor()(n)(a, b))
def test_dagger():
# these gates are their own inverses
p = Program().inst(I(0), X(0), Y(0), Z(0),
H(0), CNOT(0, 1), CCNOT(0, 1, 2),
SWAP(0, 1), CSWAP(0, 1, 2))
assert p.dagger().out() == 'CSWAP 0 1 2\nSWAP 0 1\n' \
'CCNOT 0 1 2\nCNOT 0 1\nH 0\n' \
'Z 0\nY 0\nX 0\nI 0\n'
# these gates require negating a parameter
p = Program().inst(PHASE(pi, 0), RX(pi, 0), RY(pi, 0),
RZ(pi, 0), CPHASE(pi, 0, 1),
CPHASE00(pi, 0, 1), CPHASE01(pi, 0, 1),
CPHASE10(pi, 0, 1), PSWAP(pi, 0, 1))
assert p.dagger().out() == 'PSWAP(-pi) 0 1\n' \
'CPHASE10(-pi) 0 1\n' \
'CPHASE01(-pi) 0 1\n' \
'CPHASE00(-pi) 0 1\n' \
'CPHASE(-pi) 0 1\n' \
'RZ(-pi) 0\n' \
'RY(-pi) 0\n' \
'RX(-pi) 0\n' \
'PHASE(-pi) 0\n'
# these gates are special cases
p = Program().inst(S(0), T(0), ISWAP(0, 1))
assert p.dagger().out() == 'PSWAP(pi/2) 0 1\n' \
'RZ(pi/4) 0\n' \
'PHASE(-pi/2) 0\n'
# must invert defined gates
G = np.array([[0, 1], [0 + 1j, 0]])
p = Program().defgate("G", G).inst(("G", 0))
assert p.dagger().out() == 'DEFGATE G-INV:\n' \
' 0.0, -i\n' \
' 1.0, 0.0\n\n' \
'G-INV 0\n'
# can also pass in a list of inverses
inv_dict = {"G": "J"}
p = Program().defgate("G", G).inst(("G", 0))
assert p.dagger(inv_dict=inv_dict).out() == 'J 0\n'
# defined parameterized gates cannot auto generate daggered version https://github.com/rigetticomputing/pyquil/issues/304
theta = Parameter('theta')
gparam_matrix = np.array([[quil_cos(theta / 2), -1j * quil_sin(theta / 2)],
[-1j * quil_sin(theta / 2), quil_cos(theta / 2)]])
g_param_def = DefGate('GPARAM', gparam_matrix, [theta])
p = Program(g_param_def)
with pytest.raises(TypeError):
p.dagger()
# defined parameterized gates should passback parameters https://github.com/rigetticomputing/pyquil/issues/304
GPARAM = g_param_def.get_constructor()
p = Program(GPARAM(pi)(1, 2))
assert p.dagger().out() == 'GPARAM-INV(pi) 1 2\n'
def controlled_Ry(program):
theta = Parameter('theta')
cry = np.array([[1., 0., 0., 0.], [0., 1., 0., 0.],
[0., 0.,
quil_cos(0.5 * theta),
quil_sin(0.5 * theta)],
[0., 0., -quil_sin(0.5 * theta),
quil_cos(0.5 * theta)]])
dg = DefGate('CRY', cry, [theta])
program.inst(dg)
return dg.get_constructor()
def get_combined_gate(matrix: np.ndarray, name: str) -> Gate:
"""
:param matrix: The matrix of the combined gate
:param name: The of the combined gate
:return: A Gate (matrix, noisy_name) corresponding to the representation [matrix, name]
:rtype: Gate
"""
p = Program()
combined_gate_definition = DefGate(name, matrix)
p.inst(combined_gate_definition)
combined_gate = combined_gate_definition.get_constructor()
return combined_gate
def test_def_gate_with_parameters():
theta = Parameter('theta')
rx = np.array([[quil_cos(theta / 2), -1j * quil_sin(theta / 2)],
[-1j * quil_sin(theta / 2), quil_cos(theta / 2)]])
p = Program().defgate("RX", rx, [theta])
assert p.out() == 'DEFGATE RX(%theta):\n' \
' cos(%theta/2), -i*sin(%theta/2)\n' \
' -i*sin(%theta/2), cos(%theta/2)\n\n'
dg = DefGate('MY_RX', rx, [theta])
MY_RX = dg.get_constructor()
p = Program().inst(MY_RX(np.pi)(0))
assert p.out() == 'MY_RX(pi) 0\n'
def test_def_gate_with_parameters():
theta = Parameter("theta")
rx = np.array([
[quil_cos(theta / 2), -1j * quil_sin(theta / 2)],
[-1j * quil_sin(theta / 2),
quil_cos(theta / 2)],
])
p = Program().defgate("RX", rx, [theta])
assert (p.out() == "DEFGATE RX(%theta):\n"
" COS(%theta/2), -i*SIN(%theta/2)\n"
" -i*SIN(%theta/2), COS(%theta/2)\n\n")
dg = DefGate("MY_RX", rx, [theta])
MY_RX = dg.get_constructor()
p = Program().inst(MY_RX(np.pi)(0))
assert p.out() == "MY_RX(pi) 0\n"
def state_two_prep(state, qubits):
if not isinstance(state, Program):
print("The input *state* must be in the form of a PyQuil Program")
# Define the new gate from a matrix
theta = Parameter('theta')
crtest = np.array([[1, 0, 0, 0], [0, 1, 0, 0],
[0, 0, quil_cos(theta / 2), -quil_sin(theta / 2)],
[0, 0, quil_sin(theta / 2),
quil_cos(theta / 2)]])
gate_definition = DefGate('CRTEST', crtest, [theta])
CRTEST = gate_definition.get_constructor()
state += gate_definition
state += H(qubits[0])
state += Z(qubits[0])
state += CRTEST(np.pi / 42)(qubits[0], qubits[1])
return state
def u2_replacement(phi: float, lam: float):
""" implemented with a custom gate """
# implemented with X90 pulse: https://qiskit.org/documentation/stubs/qiskit.circuit.library.U2Gate.html
# p = Program()
# p += RZ(phi + np.pi/2, 0)
# p += RX(np.pi/2, 0)
# p += RZ(lam - np.pi/2, 0)
phi_param = Parameter('phi')
lam_param = Parameter('lam')
matrix = np.array(
[[1 / np.sqrt(2), -quil_exp(1j * lam_param) * 1 / np.sqrt(2)],
[
quil_exp(1j * phi_param) * 1 / np.sqrt(2),
quil_exp(1j * (phi_param + lam_param)) * 1 / np.sqrt(2)
]])
definition = DefGate('U2', matrix, [phi_param, lam_param])
U2 = definition.get_constructor()
p = Program()
p += definition
p += U2(phi, lam)(0)
return p
def u3_replacement(theta: float, phi: float, lam: float):
""" implemented with a custom gate """
# implemented with two X90 pulse: https://arxiv.org/pdf/1707.03429.pdf
# p = Program()
# p += RZ(phi + 3*np.pi, 0)
# p += RX(np.pi/2, 0)
# p += RZ(np.pi + theta, 0)
# p += RX(np.pi/2, 0)
# p += RZ(lam, 0)
# formula from https://qiskit.org/documentation/stubs/qiskit.circuit.library.U3Gate.html (13.07.2020) gives wrong results
# p = Program()
# p += RZ(phi - np.pi/2, 0)
# p += RX(np.pi/2, 0)
# p += RZ(np.pi - theta, 0)
# p += RX(np.pi/2, 0)
# p += RZ(lam - np.pi/2, 0)
theta_param = Parameter('theta')
phi_param = Parameter('phi')
lam_param = Parameter('lam')
matrix = np.array(
[[
quil_cos(theta_param / 2),
-quil_exp(1j * lam_param) * quil_sin(theta_param / 2)
],
[
quil_exp(1j * phi_param) * quil_sin(theta_param / 2),
quil_exp(1j * (phi_param + lam_param)) * quil_cos(theta_param / 2)
]])
definition = DefGate('U3', matrix, [theta_param, phi_param, lam_param])
U3 = definition.get_constructor()
p = Program()
p += definition
p += U3(theta, phi, lam)(0)
return p
def test_defgate_param():
dgp = DefGate("TEST", [[1.0, 0.0], [0.0, 1.0]])
assert dgp.out() == "DEFGATE TEST:\n 1.0, 0\n 0, 1.0\n"
test = dgp.get_constructor()
tg = test(Qubit(1))
assert tg.out() == "TEST 1"
qvm = QVMConnection()
k = Parameter('k')
ccrk = np.array([
[1, 0, 0, 0, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 0, 0,
quil_exp((2 * np.pi * 1j) / (2**k))],
])
ccrk_gate_def = DefGate('CCRK', ccrk, [k])
CCRK = ccrk_gate_def.get_constructor()
crk = np.array([
[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, quil_exp((2 * np.pi * 1j) / (2**k))],
])
crk_gate_def = DefGate('CRK', crk, [k])
CRK = crk_gate_def.get_constructor()
rk = np.array([
[1, 0],
[0, quil_exp((2 * np.pi * 1j) / (2**k))],
])
rk_gate_def = DefGate('RK', rk, [k])
from pyquil.quil import Program
from pyquil.gates import *
from pyquil.parameters import Parameter, quil_sin, quil_cos
from pyquil.quilbase import DefGate
#from pyquil.api import QVMConnection
from referenceqvm.api import QVMConnection
import numpy as np
theta = Parameter('theta')
cry = np.array([[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, quil_cos(
theta / 2), -1 * quil_sin(theta / 2)], [0.0, 0.0, quil_sin(theta / 2), quil_cos(theta / 2)]])
dg = DefGate('CRY', cry, [theta])
CRY = dg.get_constructor()
p = Program()
p.inst(dg)
p.inst(X(0))
p.inst(X(1))
p.inst(CRY(4.304)(0, 2))
qvm = QVMConnection()
wf = qvm.wavefunction(p)
print(wf)
from pyquil.quil import Program
from pyquil.gates import *
from pyquil.parameters import Parameter, quil_sin, quil_cos
from pyquil.quilbase import DefGate
#from pyquil.api import QVMConnection
from referenceqvm.api import QVMConnection
import numpy as np
theta = Parameter('theta')
cry = np.array([[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0],
[0.0, 0.0,
quil_cos(theta / 2), -1 * quil_sin(theta / 2)],
[0.0, 0.0, quil_sin(theta / 2),
quil_cos(theta / 2)]])
dg = DefGate('CRY', cry, [theta])
CRY = dg.get_constructor()
p = Program()
p.inst(dg)
p.inst(X(0))
p.inst(X(1))
p.inst(CRY(4.304)(0, 2))
qvm = QVMConnection()
wf = qvm.wavefunction(p)
print(wf)
def forward_prop(weights, initialization=None):
LOGGER.info("Connecting to the QVM...")
qvm = QVMConnection()
LOGGER.info("... done")
LOGGER.info(" ")
LOGGER.info("Initialising quantum program...")
p = Program()
LOGGER.info("... defining custom gates")
LOGGER.info("... controlled Ry")
CRY = controlled_Ry(p)
LOGGER.info("... controlled sY")
CSY = controlled_sY(p)
LOGGER.info("... done")
LOGGER.info(" ")
a = -1
rotation = 0.5 * np.pi * (a + 1)
gamma = 1 / NUM_INPUT
W1 = weights[:NUM_INPUT * NUM_HIDDEN].reshape((NUM_INPUT, NUM_HIDDEN))
b1 = weights[NUM_INPUT * NUM_HIDDEN]
W2 = weights[NUM_INPUT * NUM_HIDDEN + 1:NUM_INPUT * NUM_HIDDEN + 1 +
NUM_HIDDEN * NUM_OUTPUT].reshape(NUM_HIDDEN, NUM_OUTPUT)
b2 = weights[-1]
# INITIALISE INPUT
if initialization == None:
EDI = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0,
1]])
dg = DefGate("EDI", EDI)
EDI = dg.get_constructor()
p.inst(dg)
p.inst(H(0))
p.inst(H(1))
p.inst(EDI(0, 1))
if initialization == "test":
# p.inst(X(1)) # |01>
p.inst(X(0)) # |10>
# pass
# INTIALISE LABELS
p.inst(H(NUM_INPUT + NUM_HIDDEN + NUM_OUTPUT))
classical_flag_register = ANCILLARY_BIT + 1
# Write out the loop initialization and body programs:
for n in range(NUM_HIDDEN):
loop_body = Program()
for w in range(NUM_INPUT):
loop_body.inst(CRY(4. * gamma * W1[w, n])(w, ANCILLARY_BIT))
loop_body.inst(RY(2. * gamma * b1)(ANCILLARY_BIT))
loop_body.inst(CSY(ANCILLARY_BIT, NUM_INPUT + n))
loop_body.inst(RZ(-0.5 * np.pi)(ANCILLARY_BIT))
for w in range(NUM_INPUT):
loop_body.inst(CRY(-4. * gamma * W1[w, n])(w, ANCILLARY_BIT))
loop_body.inst(RY(-2. * gamma * b1)(ANCILLARY_BIT))
loop_body.measure(ANCILLARY_BIT, classical_flag_register)
then_branch = Program(RY(-0.5 * np.pi)(NUM_INPUT + n))
then_branch.inst(X(ANCILLARY_BIT))
else_branch = Program()
# Add the conditional branching:
loop_body.if_then(classical_flag_register, then_branch, else_branch)
init_register = Program(TRUE([classical_flag_register]))
loop_prog = init_register.while_do(classical_flag_register, loop_body)
p.inst(loop_prog)
# Write out the loop initialization and body programs:
for n in range(NUM_OUTPUT):
loop_body = Program()
for w in range(NUM_HIDDEN):
loop_body.inst(CRY(4. * gamma * W2[w, n])(w, ANCILLARY_BIT))
loop_body.inst(RY(2. * gamma * b2)(ANCILLARY_BIT))
loop_body.inst(CSY(ANCILLARY_BIT, NUM_INPUT + NUM_HIDDEN + n))
loop_body.inst(RZ(-0.5 * np.pi)(ANCILLARY_BIT))
for w in range(NUM_HIDDEN):
loop_body.inst(CRY(-4. * gamma * W2[w, n])(w, ANCILLARY_BIT))
loop_body.inst(RY(-2. * gamma * b1)(ANCILLARY_BIT))
loop_body.measure(ANCILLARY_BIT, classical_flag_register)
then_branch = Program(RY(-0.5 * np.pi)(NUM_INPUT + NUM_HIDDEN + n))
then_branch.inst(X(ANCILLARY_BIT))
else_branch = Program()
# Add the conditional branching:
loop_body.if_then(classical_flag_register, then_branch, else_branch)
init_register = Program(TRUE([classical_flag_register]))
loop_prog = init_register.while_do(classical_flag_register, loop_body)
p.inst(loop_prog)
p.measure(NUM_INPUT + NUM_HIDDEN, 0)
LOGGER.info("... executing on the QVM")
classical_regs = [0]
output = qvm.run(p, classical_regs)
LOGGER.info("... %s", output)
LOGGER.info("")
return output[0][0]
def compute_circuit(angles_vector_in_degrees_str):
rotation_deg_of_freedom = 28
a = [0] * rotation_deg_of_freedom
for i in range(rotation_deg_of_freedom):
a[i] = radians(float(angles_vector_in_degrees_str[i]))
theta = Parameter('theta')
anot = np.array([[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]])
aary = np.array(
[[quil_cos(theta / 2), -1 * quil_sin(theta / 2), 0, 0, 0, 0, 0, 0],
[quil_sin(theta / 2),
quil_cos(theta / 2), 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 0, 0, 1]])
ccry = np.array(
[[1, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0,
0], [0, 0, 0, 1, 0, 0, 0,
0],
[0, 0, 0, 0, 1, 0, 0,
0], [0, 0, 0, 0, 0, 1, 0,
0],
[0, 0, 0, 0, 0, 0,
quil_cos(theta / 2), -1 * quil_sin(theta / 2)],
[0, 0, 0, 0, 0, 0,
quil_sin(theta / 2),
quil_cos(theta / 2)]])
#TODO: Ascertain what kind of gates this is?
cary = np.array(
[[1, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0,
0, 0],
[0, 0, 0,
quil_cos(theta / 2), -1 * quil_sin(theta / 2), 0, 0, 0],
[0, 0, 0, quil_sin(theta / 2),
quil_cos(theta / 2), 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 0, 1]])
dg_anot = DefGate('ANOT', anot)
dg_aary = DefGate('AARY', aary, [theta])
dg_ccry = DefGate('CCRY', ccry, [theta])
dg_cary = DefGate('CARY', cary, [theta])
ANOT = dg_anot.get_constructor()
AARY = dg_aary.get_constructor()
CCRY = dg_ccry.get_constructor()
CARY = dg_cary.get_constructor()
qvm = api.QVMConnection()
p = pq.Program()
p.inst(dg_anot)
p.inst(dg_aary)
p.inst(dg_ccry)
p.inst(dg_cary)
#p.inst(X(0))
#p.inst(X(1))
#p.inst(X(2))
# CD rotation
p.inst(AARY(a[0] * 2)(2, 1, 0))
# CE rotation
p.inst(AARY(a[1] * 2)(2, 0, 1))
# CF rotation
p.inst(CNOT(1, 0))
p.inst(AARY(a[2] * 2)(0, 2, 1))
p.inst(CNOT(1, 0))
# CG rotation
p.inst(AARY(a[3] * 2)(0, 1, 2))
# CA rotation
p.inst(CNOT(2, 0))
p.inst(AARY(a[4] * 2)(0, 1, 2))
p.inst(CNOT(2, 0))
# CB rotation
p.inst(CNOT(2, 1))
p.inst(AARY(a[5] * 2)(0, 1, 2))
p.inst(CNOT(2, 1))
# CC' rotation
p.inst(CNOT(1, 0))
p.inst(CNOT(1, 2))
p.inst(AARY(a[6] * 2)(0, 2, 1))
p.inst(CNOT(1, 2))
p.inst(CNOT(1, 0))
# DE rotation
p.inst(ANOT(1, 0))
p.inst(AARY(a[7] * 2)(0, 2, 1))
p.inst(ANOT(1, 0))
# DF rotation
p.inst(X(2))
p.inst(CCRY(a[8] * 2)(0, 2, 1))
p.inst(X(2))
# DG rotation
p.inst(ANOT(2, 0))
p.inst(AARY(a[9] * 2)(0, 1, 2))
p.inst(ANOT(2, 0))
# DA rotation
p.inst(X(1))
p.inst(CCRY(a[10] * 2)(0, 1, 2))
p.inst(X(1))
# DB rotation
p.inst(CNOT(1, 0))
p.inst(ANOT(1, 2))
p.inst(CCRY(a[11] * 2)(0, 2, 1))
p.inst(ANOT(1, 2))
p.inst(CNOT(1, 0))
# DC' rotation
p.inst(ANOT(1, 2))
p.inst(CCRY(a[12] * 2)(0, 2, 1))
p.inst(ANOT(1, 2))
# EF rotation
p.inst(X(2))
p.inst(CCRY(a[13] * 2)(1, 2, 0))
p.inst(X(2))
# EG rotation
p.inst(ANOT(2, 1))
p.inst(AARY(a[14] * 2)(0, 1, 2))
p.inst(ANOT(2, 1))
# EA rotation
p.inst(CNOT(0, 1))
p.inst(ANOT(0, 2))
p.inst(CCRY(a[15] * 2)(1, 2, 0))
p.inst(ANOT(0, 2))
p.inst(CNOT(0, 1))
# EB rotation
p.inst(X(0))
p.inst(CCRY(a[16] * 2)(0, 1, 2))
p.inst(X(0))
# EC' rotation
p.inst(ANOT(0, 2))
p.inst(CCRY(a[17] * 2)(1, 2, 0))
p.inst(ANOT(0, 2))
# FG rotation
p.inst(CARY(a[18] * 2)(2, 1, 0))
# FA rotation
p.inst(CNOT(2, 1))
p.inst(CCRY(a[19] * 2)(0, 1, 2))
p.inst(CNOT(2, 1))
# FB rotation
p.inst(CNOT(2, 0))
p.inst(CCRY(a[20] * 2)(0, 1, 2))
p.inst(CNOT(2, 0))
# FC' rotation
p.inst(CCRY(a[21] * 2)(0, 1, 2))
# GA rotation
p.inst(X(1))
p.inst(CCRY(a[22] * 2)(1, 2, 0))
p.inst(X(1))
# GB rotation
p.inst(X(0))
p.inst(CCRY(a[23] * 2)(0, 2, 1))
p.inst(X(0))
# GC' rotation
p.inst(ANOT(1, 0))
p.inst(CCRY(a[24] * 2)(0, 2, 1))
p.inst(ANOT(1, 0))
# AB rotation
p.inst(CNOT(1, 0))
p.inst(CCRY(a[25] * 2)(0, 2, 1))
p.inst(CNOT(1, 0))
# AC' rotation
p.inst(CCRY(a[26] * 2)(0, 2, 1))
# BC' rotation
p.inst(CCRY(a[27] * 2)(1, 2, 0))
wavefunction = qvm.wavefunction(p)
print(wavefunction)
return p
def controlled_X(n, a, b):
theta = Parameter('theta')
crx = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, quil_cos(theta / 2), -1j * quil_sin(theta / 2)], [0, 0, -1j * quil_sin(theta / 2), quil_cos(theta / 2)]])
CRX = DefGate('CRX', crx, [theta])
return str(CRX) + '\n' + str(CRX.get_constructor()(n)(a, b))
theta = Parameter('theta')
cry = np.array([[1, 0, 0, 0], [0, 1, 0, 0],
[0, 0, quil_cos(theta / 2), -quil_sin(theta / 2)],
[0, 0, quil_sin(theta / 2),
quil_cos(theta / 2)]])
crx = np.array([[1, 0, 0, 0], [0, 1, 0, 0],
[0, 0, quil_cos(theta / 2), -1j * quil_sin(theta / 2)],
[0, 0, -1j * quil_sin(theta / 2),
quil_cos(theta / 2)]])
crz = np.array([[1, 0, 0, 0], [0, 1, 0, 0],
[0, 0, quil_cos(theta / 2) - 1j * quil_sin(theta / 2), 0],
[0, 0, 0,
quil_cos(theta / 2) + 1j * quil_sin(theta / 2)]])
cy = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0 - 1j],
[0, 0, 0 + 1j, 0]])
dg_cry = DefGate("CRY", cry, [theta])
dg_crx = DefGate("CRX", crx, [theta])
dg_crz = DefGate("CRZ", crz, [theta])
dg_cy = DefGate("CY", cy)
# print(type(dg_cry))
# print(dg_cry)
CRY = dg_cry.get_constructor()
CRX = dg_crx.get_constructor()
CRZ = dg_crz.get_constructor()
CY = dg_cy.get_constructor()
# Using the cartesian rotation gate of the form:
from pyquil.parameters import Parameter, quil_sin, quil_cos
from pyquil.quilbase import DefGate
from pyquil.gates import *
from math import pi
import numpy as np
theta = Paramter('theta')
crx = np.array([[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, quil_cos(theta/2), -1j * quil_sin(theta/2)],
[0, 0, -1j * quil_sin(theta/2), quil_cos(theta/2)]])
dg = DefGate('CRX', crx, [theta])
CRX = dg.get_constructor()
# Would it make more sense to use QFT? Depends on how entanglement is used?
def qft3(q0, q1, q2):
p = Program()
p.inst( H(q2),
CPHASE(pi/2.0, q1, q2),
H(q1),
CPHASE(pi/4.0, q0, q2),
CPHASE(pi/2, q0, q1),
H(q0),
SWAP(q0, q2) )
return p
def test_prog_merge():
prog_0 = Program(X(0))
prog_1 = Program(Y(0))
assert merge_programs([prog_0, prog_1]).out() == (prog_0 + prog_1).out()
test_def = DefGate("test", np.eye(2))
TEST = test_def.get_constructor()
prog_0.inst(test_def)
prog_0.inst(TEST(0))
prog_1.inst(test_def)
prog_1.inst(TEST(0))
assert (merge_programs([prog_0, prog_1]).out() == """DEFGATE test:
1.0, 0
0, 1.0
X 0
test 0
Y 0
test 0
""")
perm_def = DefPermutationGate("PERM", [0, 1, 3, 2])
PERM = perm_def.get_constructor()
prog_0.inst(perm_def)
prog_0.inst(PERM(0, 1))
prog_1.inst(perm_def)
prog_1.inst(PERM(1, 0))
assert (merge_programs([prog_0,
prog_1]).out() == """DEFGATE PERM AS PERMUTATION:
0, 1, 3, 2
DEFGATE test:
1.0, 0
0, 1.0
X 0
test 0
PERM 0 1
Y 0
test 0
PERM 1 0
""")
assert (merge_programs([
Program("DECLARE ro BIT[1]"),
Program("H 0"),
Program("MEASURE 0 ro[0]")
]).out() == """DECLARE ro BIT[1]
H 0
MEASURE 0 ro[0]
""")
q0 = QubitPlaceholder()
q0_str = "{" + str(q0) + "}"
p0 = Program(X(q0))
p1 = Program(Z(q0))
merged = merge_programs([p0, p1])
assert (str(merged) == f"""X {q0_str}
Z {q0_str}
""")
assert (address_qubits(merged, {q0: 1}).out() == """X 1
Z 1
""")
q1 = QubitPlaceholder()
p2 = Program(Z(q1))
assert (address_qubits(merge_programs([p0, p2]), {
q0: 1,
q1: 2
}).out() == """X 1
Z 2
""")
p0 = address_qubits(p0, {q0: 2})
p1 = address_qubits(p1, {q0: 1})
assert (merge_programs([p0, p1]).out() == """X 2
Z 1
""")
from pyquil import Program
from pyquil.parameters import Parameter, quil_sin, quil_cos
from pyquil.quilbase import DefGate
from pyquil.gates import *
import numpy as np
thetaParameter = Parameter('theta')
controlledRx = np.array(
[[1, 0, 0, 0], [0, 1, 0, 0],
[0, 0,
quil_cos(thetaParameter / 2), -1j * quil_sin(thetaParameter / 2)],
[0, 0, -1j * quil_sin(thetaParameter / 2),
quil_cos(thetaParameter / 2)]])
gate_definition = DefGate('CRX', controlledRx, [thetaParameter])
CONTROLRX = gate_definition.get_constructor()
program = Program()
program = program + gate_definition
program = program + H(0)
program = program + CONTROLRX(np.pi / 2)(0, 1)
print(program)
