def test_load_quil_file_via_entry_point(self):
"""Test that a quil file can be loaded via the load entrypoint."""
cur_dir = os.path.dirname(os.path.abspath(__file__))
with OperationRecorder() as rec:
qml.load(os.path.join(cur_dir, "simple_program.quil"),
format="quil_file")(wires=range(5))
# The wires should be assigned as
# 0 1 2 3 7
# 0 1 2 3 4
expected_queue = [
qml.Hadamard(0),
qml.RZ(0.34, wires=[1]),
qml.CNOT(wires=[0, 3]),
qml.Hadamard(2),
qml.Hadamard(4),
qml.PauliX(4),
qml.PauliY(1),
qml.RZ(0.34, wires=[1]),
]
for converted, expected in zip(rec.queue, expected_queue):
assert converted.name == expected.name
assert converted.wires == expected.wires
assert converted.params == expected.params
def test_load_quil_via_entry_point(self):
"""Test that a quil string can be loaded via the load entrypoint."""
quil_str = textwrap.dedent("""
H 0
RZ(0.34) 1
CNOT 0 3
H 2
H 7
X 7
Y 1
RZ(0.34) 1
""")
with OperationRecorder() as rec:
qml.load(quil_str, format="quil")(wires=range(5))
# The wires should be assigned as
# 0 1 2 3 7
# 0 1 2 3 4
expected_queue = [
qml.Hadamard(0),
qml.RZ(0.34, wires=[1]),
qml.CNOT(wires=[0, 3]),
qml.Hadamard(2),
qml.Hadamard(4),
qml.PauliX(4),
qml.PauliY(1),
qml.RZ(0.34, wires=[1]),
]
for converted, expected in zip(rec.queue, expected_queue):
assert converted.name == expected.name
assert converted.wires == expected.wires
assert converted.params == expected.params
def test_load_program_via_entry_point(self):
"""Test that a pyquil Program instance can be loaded via the load entrypoint."""
program = pyquil.Program()
program += g.H(0)
program += g.RZ(0.34, 1)
program += g.CNOT(0, 3)
program += g.H(2)
program += g.H(7)
program += g.X(7)
program += g.Y(1)
program += g.RZ(0.34, 1)
with OperationRecorder() as rec:
qml.load(program, format="pyquil_program")(wires=range(5))
# The wires should be assigned as
# 0 1 2 3 7
# 0 1 2 3 4
expected_queue = [
qml.Hadamard(0),
qml.RZ(0.34, wires=[1]),
qml.CNOT(wires=[0, 3]),
qml.Hadamard(2),
qml.Hadamard(4),
qml.PauliX(4),
qml.PauliY(1),
qml.RZ(0.34, wires=[1]),
]
for converted, expected in zip(rec.queue, expected_queue):
assert converted.name == expected.name
assert converted.wires == expected.wires
assert converted.params == expected.params
def test_converter_does_not_exist(self):
"""Test that the proper error is raised if the converter does not exist."""
with pytest.raises(
ValueError,
match=
"Converter does not exist. Make sure the required plugin is installed"
):
qml.load("Test", format="some_non_existing_format")
def test_differentiation_in_qnode(self, angle):
"""Test a quil string used in a QNode can be differentiated."""
quil_str = textwrap.dedent("""
DECLARE delta REAL[1]
RX(delta) 0
CNOT 0 1
""")
loader = qml.load(quil_str, format="quil")
dev = qml.device("default.qubit", wires=2)
@qml.qnode(dev)
def circuit(a):
loader(wires=[0, 1], parameter_map={"delta": a})
return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1))
@qml.qnode(dev)
def circuit_reg(a):
qml.RX(a, wires=[0])
qml.CNOT(wires=[0, 1])
return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1))
assert np.array_equal(circuit.jacobian([angle]),
circuit_reg.jacobian([angle]))
def test_quil_in_qnode(self, angle):
"""Test how a simple quil string is used inside a QNode."""
quil_str = textwrap.dedent("""
DECLARE delta REAL[1]
RX(delta) 0
CNOT 0 1
""")
loader = qml.load(quil_str, format="quil")
dev = qml.device("default.qubit", wires=2)
@qml.qnode(dev)
def circuit(a):
loader(wires=[0, 1], parameter_map={"delta": a})
return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1))
@qml.qnode(dev)
def circuit_reg(a):
qml.RX(a, wires=[0])
qml.CNOT(wires=[0, 1])
return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1))
assert np.array_equal(circuit(angle), circuit_reg(angle))
def test_program_in_qnode(self, angle):
"""Test how a simple program is used inside a QNode."""
program = pyquil.Program()
delta = program.declare("delta", "REAL")
program += g.RX(delta, 0)
program += g.CNOT(0, 1)
loader = qml.load(program, format="pyquil_program")
dev = qml.device("default.qubit", wires=2)
@qml.qnode(dev)
def circuit(a):
loader(wires=[0, 1], parameter_map={delta: a})
return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1))
@qml.qnode(dev)
def circuit_reg(a):
qml.RX(a, wires=[0])
qml.CNOT(wires=[0, 1])
return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1))
assert np.array_equal(circuit(angle), circuit_reg(angle))
def test_load_qiskit_circuit(self):
"""Test that the default load function works correctly."""
theta = qiskit.circuit.Parameter('θ')
qc = qiskit.QuantumCircuit(2)
qc.rx(theta, 0)
my_template = qml.load(qc, format='qiskit')
dev = qml.device('default.qubit', wires=2)
angles = np.array([0.53896774, 0.79503606, 0.27826503, 0.])
@qml.qnode(dev)
def loaded_quantum_circuit(angle):
my_template({theta: angle})
return qml.expval(qml.PauliZ(0))
@qml.qnode(dev)
def quantum_circuit(angle):
qml.RX(angle, wires=[0])
return qml.expval(qml.PauliZ(0))
for x in angles:
assert np.allclose(loaded_quantum_circuit(x), quantum_circuit(x))
def test_gradient(self, theta, phi, varphi, analytic, tol):
"""Test that the gradient works correctly"""
program = pyquil.Program()
delta1 = program.declare("delta1", "REAL")
delta2 = program.declare("delta2", "REAL")
delta3 = program.declare("delta3", "REAL")
program += g.RX(delta1, 0)
program += g.RX(delta2, 1)
program += g.RX(delta3, 2)
program += g.CNOT(0, 1)
program += g.CNOT(1, 2)
# Convert to a PennyLane circuit
program_pl = qml.load(program, format="pyquil_program")
dev = qml.device("default.qubit", wires=3, analytic=analytic)
@qml.qnode(dev)
def circuit(params):
program_pl(parameter_map={
delta1: params[0],
delta2: params[1],
delta3: params[2]
},
wires=range(len(program_pl.defined_qubits)))
return qml.expval(qml.PauliX(0) @ qml.PauliY(2))
dcircuit = qml.grad(circuit, 0)
res = dcircuit([theta, phi, varphi])
expected = [
np.cos(theta) * np.sin(phi) * np.sin(varphi),
np.sin(theta) * np.cos(phi) * np.sin(varphi),
np.sin(theta) * np.sin(phi) * np.cos(varphi)
]
assert np.allclose(res, expected, tol)
