def test_simple_circuits(self):
default_qubit = qml.device('default.qubit', wires=4)
for dev in self.devices:
gates = [
qml.PauliX(wires=0),
qml.PauliY(wires=1),
qml.PauliZ(wires=2),
qml.S(wires=3),
qml.T(wires=0),
qml.RX(2.3, wires=1),
qml.RY(1.3, wires=2),
qml.RZ(3.3, wires=3),
qml.Hadamard(wires=0),
qml.Rot(0.1, 0.2, 0.3, wires=1),
qml.CRot(0.1, 0.2, 0.3, wires=[2, 3]),
qml.Toffoli(wires=[0, 1, 2]),
qml.SWAP(wires=[1, 2]),
qml.CSWAP(wires=[1, 2, 3]),
qml.U1(1.0, wires=0),
qml.U2(1.0, 2.0, wires=2),
qml.U3(1.0, 2.0, 3.0, wires=3),
qml.CRX(0.1, wires=[1, 2]),
qml.CRY(0.2, wires=[2, 3]),
qml.CRZ(0.3, wires=[3, 1]),
qml.CZ(wires=[2, 3]),
qml.QubitUnitary(np.array([[1, 0], [0, 1]]), wires=2),
]
layers = 3
np.random.seed(1967)
gates_per_layers = [
np.random.permutation(gates).numpy() for _ in range(layers)
]
for obs in {
qml.PauliX(wires=0),
qml.PauliY(wires=0),
qml.PauliZ(wires=0),
qml.Identity(wires=0),
qml.Hadamard(wires=0)
}:
if obs.name in dev.observables:
def circuit():
"""4-qubit circuit with layers of randomly selected gates and random connections for
multi-qubit gates."""
qml.BasisState(np.array([1, 0, 0, 0]),
wires=[0, 1, 2, 3])
for gates in gates_per_layers:
for gate in gates:
if gate.name in dev.operations:
qml.apply(gate)
return qml.expval(obs)
qnode_default = qml.QNode(circuit, default_qubit)
qnode = qml.QNode(circuit, dev)
assert np.allclose(qnode(), qnode_default(), atol=1e-3)
def circuit(a, b, c):
qml.RX(a, wires=0)
qml.RY(b, wires=1)
qml.CNOT(wires=[1, 2])
qml.RX(c, wires=2)
qml.CNOT(wires=[0, 1])
qml.RZ(c, wires=2)
return qml.var(qml.PauliZ(0)), qml.expval(qml.PauliZ(1)), qml.var(qml.PauliZ(2))
def test_projectq_ops(self):
results = [-1.0, -1.0]
for i, dev in enumerate(self.devices[1:3]):
gates = [
qml.PauliX(wires=0),
qml.PauliY(wires=1),
qml.PauliZ(wires=2),
SqrtX(wires=0),
SqrtSwap(wires=[3, 0]),
]
layers = 3
np.random.seed(1967)
gates_per_layers = [
np.random.permutation(gates).numpy() for _ in range(layers)
]
def circuit():
"""4-qubit circuit with layers of randomly selected gates."""
for gates in gates_per_layers:
for gate in gates:
if gate.name in dev.operations:
qml.apply(gate)
return qml.expval(qml.PauliZ(0))
qnode = qml.QNode(circuit, dev)
assert np.allclose(qnode(), results[i], atol=1e-3)
def circuit(x, y, z):
qml.RX(x, wires=[0])
qml.RZ(y, wires=[0])
qml.CNOT(wires=[0, 1])
qml.RY(y, wires=[0])
qml.RX(z, wires=[0])
return qml.expval(qml.PauliY(0)), qml.expval(qml.PauliZ(1))
def circuit(x, c=None):
qml.RX(x, wires=0)
for i in range(c.val):
qml.RX(x, wires=i)
return qml.expval(qml.PauliZ(0))
def circuit():
"""4-qubit circuit with layers of randomly selected gates."""
for gates in gates_per_layers:
for gate in gates:
if gate.name in dev.operations:
qml.apply(gate)
return qml.expval(qml.PauliZ(0))
def classifier_circuit(in_data, x):
qml.RX(in_data, wires=[0])
qml.CNOT(wires=[0, 1])
qml.RY(-1.6, wires=[0])
qml.RY(in_data, wires=[1])
qml.CNOT(wires=[1, 0])
qml.RX(x, wires=[0])
qml.CNOT(wires=[0, 1])
return qml.expval(qml.PauliZ(0))
def circuit(*x):
"""Test quantum function"""
x = prep_par(x, op)
op(*x, wires=wires)
if issubclass(op, qml.operation.CV):
return qml.expval(qml.X(0))
return qml.expval(qml.PauliZ(0))
def circuit(x, y, z):
qml.RX(x, wires=[0])
qml.CNOT(wires=[0, 1])
qml.RY(-1.6, wires=[0])
qml.RY(y, wires=[1])
qml.CNOT(wires=[1, 0])
qml.RX(z, wires=[0])
qml.CNOT(wires=[0, 1])
return qml.expval(qml.PauliZ(0))
def circuit(w):
qml.RX(w[np.unravel_index(0, s)], wires=0) # b[0]
qml.RX(w[np.unravel_index(1, s)], wires=1) # b[1]
qml.RX(w[np.unravel_index(2, s)], wires=2) # ...
qml.RX(w[np.unravel_index(3, s)], wires=3)
qml.RX(w[np.unravel_index(4, s)], wires=4)
qml.RX(w[np.unravel_index(5, s)], wires=5)
qml.RX(w[np.unravel_index(6, s)], wires=6)
qml.RX(w[np.unravel_index(7, s)], wires=7)
return tuple(qml.expval(qml.PauliZ(idx)) for idx in range(len(b)))
def test_check_validity(self):
"""test that the check_validity method correctly
determines what operations/observables are supported."""
self.logTestName()
dev = qml.device('default.qubit', wires=2)
# overwrite the device supported operations and observables
dev._operation_map = {
'RX': 0,
'PauliX': 0,
'PauliY': 0,
'PauliZ': 0,
'Hadamard': 0
}
dev._observable_map = {'PauliZ': 0, 'Identity': 0}
# test a valid queue
queue = [
qml.RX(1., wires=0, do_queue=False),
qml.PauliY(wires=1, do_queue=False),
qml.PauliZ(wires=2, do_queue=False),
]
observables = [qml.expval(qml.PauliZ(0, do_queue=False))]
dev.check_validity(queue, observables)
# test an invalid operation
queue = [qml.RY(1., wires=0, do_queue=False)]
with self.assertRaisesRegex(qml.DeviceError, "Gate RY not supported"):
dev.check_validity(queue, observables)
# test an invalid observable with the same name
# as a valid operation
queue = [qml.PauliY(wires=0, do_queue=False)]
observables = [qml.expval(qml.PauliY(0, do_queue=False))]
with self.assertRaisesRegex(qml.DeviceError,
"Observable PauliY not supported"):
dev.check_validity(queue, observables)
def test_sample_attribute_error(self):
"""Check that an error is raised if a required attribute
is not present in a sampled observable"""
self.logTestName()
dev = qml.device('default.qubit', wires=2)
queue = [qml.RX(0.543, wires=[0], do_queue=False)]
# Make a sampling observable but delete its num_samples attribute
obs = qml.sample(qml.PauliZ(0, do_queue=False), n=10)
del obs.num_samples
obs = [obs]
with self.assertRaisesRegex(
qml.DeviceError,
"Number of samples not specified for observable"):
dev.execute(queue, obs)
def circuit(a, b):
qml.RX(a[0], wires=0)
qml.RX(a[1], wires=1)
qml.RX(b[2, 1], wires=2)
return qml.expval(qml.PauliZ(0)), qml.expval(
qml.PauliZ(1)), qml.expval(qml.PauliZ(2))
def qf(x):
qml.RX(x, wires=[0])
ev = qml.expval(qml.PauliZ(1))
qml.RY(0.5, wires=[0])
return ev
def circuit():
SomeOperation(wires=0)
return qml.expval(qml.PauliZ(0))
def qf(x):
qml.RX(x, wires=[0])
return qml.expval(qml.PauliZ(0)), 0.3
def qf(x):
qml.RX(x, wires=[0])
ex = qml.expval(qml.PauliZ(1))
return qml.expval(qml.PauliZ(0)), ex
def circuit(x):
qml.RX(x, wires=[0])
return qml.sample(qml.PauliZ(0), 1), qml.sample(qml.PauliX(1), 1)
def circuit_tfe(phi, theta):
qml.RX(phi[0], wires=0)
qml.RY(phi[1], wires=1)
qml.CNOT(wires=[0, 1])
qml.PhaseShift(theta[0], wires=0)
return qml.expval(qml.PauliZ(0))
def circuit(x, q=default_q):
qml.RY(x, wires=0)
return qml.expval(qml.PauliZ(q))
def circuit(w, x=None):
qml.RX(w, wires=[0])
qml.RX(x, wires=[1])
return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1))
def ansatz(x, y, z):
qml.QubitStateVector(np.array([1, 0, 1, 1])/np.sqrt(3), wires=[0, 1])
qml.Rot(x, y, z, wires=0)
qml.CNOT(wires=[0, 1])
return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliY(1))
def circuit(a):
qml.RX(a, wires=0)
return qml.var(qml.PauliZ(0))
def circuit(reused_param, other_param):
qml.RX(reused_param, wires=[0])
qml.RZ(other_param, wires=[0])
qml.RX(reused_param, wires=[0])
return qml.expval(qml.PauliZ(0))
def circuit(x):
qml.RZ(x, wires=[0])
return qml.expval(qml.PauliZ(0))
def qf(x):
qml.RX(x, wires=[0])
qml.CNOT(wires=[0, 2])
return qml.expval(qml.PauliZ(0))
def circuit4(a, b, c):
qml.RX(b, wires=0)
qml.RX(c, wires=1)
return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1))
def circuit(x, y, input_state=np.array([0, 0])):
qml.BasisState(input_state, wires=[0, 1])
qml.RX(x, wires=[0])
qml.RY(y, wires=[0])
return qml.expval(qml.PauliZ(0))
def qf(x):
qml.RX(x, wires=[0])
qml.Displacement(0.5, 0, wires=[0])
return qml.expval(qml.PauliZ(0))
def circuit(x,y,z):
qml.Rot(x,y,z, wires=[0])
return qml.expval(qml.PauliZ(0))
