ops = {
"BasisState": qml.BasisState(np.array([0]), wires=[0]),
"CNOT": qml.CNOT(wires=[0, 1]),
"CRX": qml.CRX(0, wires=[0, 1]),
"CRY": qml.CRY(0, wires=[0, 1]),
"CRZ": qml.CRZ(0, wires=[0, 1]),
"CRot": qml.CRot(0, 0, 0, wires=[0, 1]),
"CSWAP": qml.CSWAP(wires=[0, 1, 2]),
"CZ": qml.CZ(wires=[0, 1]),
"CY": qml.CY(wires=[0, 1]),
"DiagonalQubitUnitary": qml.DiagonalQubitUnitary(np.eye(2), wires=[0]),
"Hadamard": qml.Hadamard(wires=[0]),
"MultiRZ": qml.MultiRZ(0, wires=[0]),
"PauliX": qml.PauliX(wires=[0]),
"PauliY": qml.PauliY(wires=[0]),
"PauliZ": qml.PauliZ(wires=[0]),
"PhaseShift": qml.PhaseShift(0, wires=[0]),
"QubitStateVector": qml.QubitStateVector(np.array([1.0, 0.0]), wires=[0]),
"QubitUnitary": qml.QubitUnitary(np.eye(2), wires=[0]),
"RX": qml.RX(0, wires=[0]),
"RY": qml.RY(0, wires=[0]),
"RZ": qml.RZ(0, wires=[0]),
"Rot": qml.Rot(0, 0, 0, wires=[0]),
"S": qml.S(wires=[0]),
"SWAP": qml.SWAP(wires=[0, 1]),
"T": qml.T(wires=[0]),
"Toffoli": qml.Toffoli(wires=[0, 1, 2]),
}
all_ops = ops.keys()
def circuit(weights):
ArbitraryStatePreparation(weights, [0, 1, 2])
return qml.expval(qml.PauliZ(0))
def circuit(p):
qml.RX(3 * p[0], wires=0)
qml.RY(p[1], wires=0)
qml.RX(p[2] / 2, wires=0)
return qml.expval(qml.PauliZ(0))
def circuit(x):
qml.RX(x, wires=[0])
return qml.sample(qml.PauliZ(0)), qml.sample(qml.PauliX(1))
def circuit():
BasisStatePreparation(basis_state, wires)
# Pauli Z gates identify the basis state
return qml.expval(qml.PauliZ(0)), qml.expval(
qml.PauliZ(1)), qml.expval(qml.PauliZ(2))
def circuit(x, y, z):
qml.Rot(x, y, z, wires=[0])
return qml.expval(qml.PauliZ(0))
def circuit(x):
qml.BasisState(x, wires=[1])
return qml.expval(qml.PauliZ(0))
def circuit_Zmi():
qml.RX(np.pi, wires=qubit)
return qml.expval(qml.PauliZ(qubit))
def arbitrary_perm():
qml.Permute(permutation_order, wires=dev.wires)
return qml.expval(qml.PauliZ(0))
def circuit():
qml.Hadamard(0)
qml.CNOT(wires=[0, 1])
return qml.expval(qml.PauliZ(0) @ qml.PauliZ(1))
def circuit_Zpl():
qml.RX(0.0, wires=qubit)
return qml.expval(qml.PauliZ(qubit))
def circuit():
qml.RY(np.pi/2, wires=[0])
qml.CNOT(wires=[0, 1])
return qml.expval(qml.PauliZ(0) @ qml.Identity(1))
def decomp_circuit(theta):
qml.PauliRot.decomposition(theta, "XX", wires=[0, 1])
return qml.expval(qml.PauliZ(0))
def circuit(theta):
qml.PauliRot(theta, "XX", wires=[0, 1])
return qml.expval(qml.PauliZ(0))
def cost(p1, p2):
qml.RX(extra_param, wires=[0])
qml.RY(p1, wires=[0])
qml.RZ(p2, wires=[0])
qml.RX(p1, wires=[0])
return qml.expval(qml.PauliZ(0))
def subset_perm():
qml.Permute(permutation_order, wires=wire_subset)
return qml.expval(qml.PauliZ(0))
def circuit(x):
qml.Rot(0.3, x, -0.2, wires=[0])
return qml.expval(qml.PauliZ(0))
def identity_permutation():
qml.Permute([0, 1, 2, 3], wires=dev.wires)
return qml.expval(qml.PauliZ(0))
def circuit(x, y):
qml.RX(x, wires=[0])
return qml.expval(qml.PauliZ(0))
def permute_qubits():
qml.Permute(permutation_order, wires=dev.wires)
return qml.expval(qml.PauliZ(0))
def circuit(x, y, z):
qml.CNOT(wires=[0, 1])
return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliY(1))
def two_cycle():
qml.Permute(permutation_order, wires=dev.wires)
return qml.expval(qml.PauliZ(0))
def circuit(x):
qml.BasisState(np.array([x, 0]), wires=[0, 1]) # not differentiable
qml.RX(x, wires=[0])
return qml.expval(qml.PauliZ(0))
def circuit(weight):
qml.templates.DoubleExcitationUnitary(weight=weight,
wires1=wires1,
wires2=wires2)
return qml.expval(qml.PauliZ(0))
def circuit():
MottonenStatePreparation(state_vector, wires)
return qml.expval(qml.PauliZ(0)), qml.expval(
qml.PauliZ(1)), qml.expval(qml.PauliZ(2))
def circuit_template(weight):
qml.templates.DoubleExcitationUnitary(weight, wires1=[0, 1], wires2=[2, 3])
return qml.expval(qml.PauliZ(0))
class TestOperations:
"""Tests the logic related to operations"""
def test_op_queue_accessed_outside_execution_context(
self, mock_qubit_device):
"""Tests that a call to op_queue outside the execution context raises the correct error"""
with pytest.raises(
ValueError,
match=
"Cannot access the operation queue outside of the execution context!"
):
dev = mock_qubit_device()
dev.op_queue
def test_op_queue_is_filled_during_execution(
self, mock_qubit_device_with_paulis_and_methods, monkeypatch):
"""Tests that the op_queue is correctly filled when apply is called and that accessing
op_queue raises no error"""
queue = [qml.PauliX(wires=0), qml.PauliY(wires=1), qml.PauliZ(wires=2)]
observables = [
qml.expval(qml.PauliZ(0)),
qml.var(qml.PauliZ(1)),
qml.sample(qml.PauliZ(2))
]
circuit_graph = CircuitGraph(queue + observables, {}, Wires([0, 1, 2]))
call_history = []
with monkeypatch.context() as m:
m.setattr(
QubitDevice, "apply",
lambda self, x, **kwargs: call_history.extend(x + kwargs.get(
'rotations', [])))
m.setattr(QubitDevice, "analytic_probability", lambda *args: None)
dev = mock_qubit_device_with_paulis_and_methods()
dev.execute(circuit_graph)
assert call_history == queue
assert len(call_history) == 3
assert isinstance(call_history[0], qml.PauliX)
assert call_history[0].wires == Wires([0])
assert isinstance(call_history[1], qml.PauliY)
assert call_history[1].wires == Wires([1])
assert isinstance(call_history[2], qml.PauliZ)
assert call_history[2].wires == Wires([2])
def test_unsupported_operations_raise_error(
self, mock_qubit_device_with_paulis_and_methods):
"""Tests that the operations are properly applied and queued"""
queue = [
qml.PauliX(wires=0),
qml.PauliY(wires=1),
qml.Hadamard(wires=2)
]
observables = [
qml.expval(qml.PauliZ(0)),
qml.var(qml.PauliZ(1)),
qml.sample(qml.PauliZ(2))
]
circuit_graph = CircuitGraph(queue + observables, {}, Wires([0, 1, 2]))
with pytest.raises(DeviceError,
match="Gate Hadamard not supported on device"):
dev = mock_qubit_device_with_paulis_and_methods()
dev.execute(circuit_graph)
numeric_queues = [[qml.RX(0.3, wires=[0])],
[
qml.RX(0.3, wires=[0]),
qml.RX(0.4, wires=[1]),
qml.RX(0.5, wires=[2]),
]]
variable = Variable(1)
symbolic_queue = [
[qml.RX(variable, wires=[0])],
]
observables = [[qml.PauliZ(0)], [qml.PauliX(0)], [qml.PauliY(0)]]
@pytest.mark.parametrize("observables", observables)
@pytest.mark.parametrize("queue", numeric_queues + symbolic_queue)
def test_passing_keyword_arguments_to_execute(
self, mock_qubit_device_with_paulis_rotations_and_methods,
monkeypatch, queue, observables):
"""Tests that passing keyword arguments to execute propagates those kwargs to the apply()
method"""
circuit_graph = CircuitGraph(queue + observables, {}, Wires([0, 1, 2]))
call_history = {}
with monkeypatch.context() as m:
m.setattr(QubitDevice, "apply",
lambda self, x, **kwargs: call_history.update(kwargs))
dev = mock_qubit_device_with_paulis_rotations_and_methods()
dev.execute(circuit_graph, hash=circuit_graph.hash)
len(call_history.items()) == 1
call_history["hash"] = circuit_graph.hash
def circuit(a):
qml.RX(a, wires=0)
return qml.expval(qml.PauliZ(wires=0))
def circuit(x):
qml.RX(x[1], wires=0)
qml.Rot(x[0], x[1], x[2], wires=0)
return qml.expval(qml.PauliZ(0))
def circuit2(phi1, phi2):
qml.RX(phi1, wires=0)
qml.RY(phi2, wires=0)
return qml.expval(qml.PauliZ(0))
