phase_shift = lambda phi: np.array([[1, 0], [0, np.exp(1j * phi)]])
rx = lambda theta: np.cos(theta / 2) * I + 1j * np.sin(-theta / 2) * X
ry = lambda theta: np.cos(theta / 2) * I + 1j * np.sin(-theta / 2) * Y
rz = lambda theta: np.cos(theta / 2) * I + 1j * np.sin(-theta / 2) * Z
crz = lambda theta: np.array([
[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, np.exp(-1j * theta / 2), 0],
[0, 0, 0, np.exp(1j * theta / 2)],
])
# list of all non-parametrized single-qubit gates,
# along with the PennyLane operation name
single_qubit = [
(qml.PauliX(wires=0), X),
(qml.PauliY(wires=0), Y),
(qml.PauliZ(wires=0), Z),
(qml.Hadamard(wires=0), H),
(qml.S(wires=0), S),
(qml.T(wires=0), T),
(qml.PauliX(wires=0).inv(), X.conj().T),
(qml.PauliY(wires=0).inv(), Y.conj().T),
(qml.PauliZ(wires=0).inv(), Z.conj().T),
(qml.Hadamard(wires=0).inv(), H.conj().T),
(qml.S(wires=0).inv(), S.conj().T),
(qml.T(wires=0).inv(), T.conj().T),
]
# list of all parametrized single-qubit gates
single_qubit_param = [
(qml.RX(0, wires=0), rx),
def circuit(a, b, c):
ansatz(a, b, c)
return sample(qml.PauliX(0) @ qml.PauliY(2))
def circuit(a, b, c):
ansatz(a, b, c)
return expval(qml.PauliX(0) @ qml.PauliY(2))
def circuit(x):
qml.RX(x, wires=0)
return qml.expval(qml.PauliY(0))
op_SWAP12 = qml.SWAP(wires=[1, 2])
op_X0 = qml.PauliX(0)
op_CRX20 = qml.CRX(2.3, wires=[2, 0])
op_Z3 = qml.PauliZ(3)
dummy_raw_operation_grid = [
[None, op_SWAP03, op_X0, op_CRX20],
[op_CNOT21, op_SWAP12, None, None],
[op_CNOT21, op_SWAP12, None, op_CRX20],
[op_Z3, op_SWAP03, None, None],
]
dummy_raw_observable_grid = [
[qml.sample(qml.Hermitian(2 * np.eye(2), wires=[0]))],
[None],
[qml.expval(qml.PauliY(wires=[2]))],
[qml.var(qml.Hadamard(wires=[3]))],
]
@pytest.fixture
def dummy_circuit_drawer():
"""A dummy CircuitDrawer instance."""
return CircuitDrawer(dummy_raw_operation_grid, dummy_raw_observable_grid)
def assert_nested_lists_equal(list1, list2):
"""Assert that two nested lists are equal.
Args:
list1 (list[list[Any]]): The first list to be compared
def circuit(params):
ansatz(params)
return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliY(1))
def circuit_rotated():
qml.PauliX(wires=0)
qml.PauliZ(wires=1)
qml.PauliY(wires=2)
qml.PauliZ(wires=3)
operation(wires=wire).diagonalizing_gates()
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))
from flaky import flaky
import pennylane as qml
pytestmark = pytest.mark.skip_unsupported
# ==========================================================
# Some useful global variables
# observables for which device support is tested
obs = {
"Identity": qml.Identity(wires=[0]),
"Hadamard": qml.Hadamard(wires=[0]),
"Hermitian": qml.Hermitian(np.eye(2), wires=[0]),
"PauliX": qml.PauliX(wires=[0]),
"PauliY": qml.PauliY(wires=[0]),
"PauliZ": qml.PauliZ(wires=[0]),
"Projector": qml.Projector(np.array([1]), wires=[0]),
}
all_obs = obs.keys()
# single qubit Hermitian observable
A = np.array([[1.02789352, 1.61296440 - 0.3498192j],
[1.61296440 + 0.3498192j, 1.23920938 + 0j]])
class TestSupportedObservables:
"""Test that the device can implement all observables that it supports."""
@pytest.mark.parametrize("observable", all_obs)
def test_supported_observables_can_be_implemented(self, device_kwargs,
class TestRepresentationResolver:
"""Test the RepresentationResolver class."""
@pytest.mark.parametrize(
"list,element,index,list_after",
[
([1, 2, 3], 2, 1, [1, 2, 3]),
([1, 2, 2, 3], 2, 1, [1, 2, 2, 3]),
([1, 2, 3], 4, 3, [1, 2, 3, 4]),
],
)
def test_index_of_array_or_append(self, list, element, index, list_after):
"""Test the method index_of_array_or_append."""
assert RepresentationResolver.index_of_array_or_append(element,
list) == index
assert list == list_after
@pytest.mark.parametrize("par,expected", [
(3, "3"),
(5.236422, "5.236"),
])
def test_single_parameter_representation(self,
unicode_representation_resolver,
par, expected):
"""Test that single parameters are properly resolved."""
assert unicode_representation_resolver.single_parameter_representation(
par) == expected
def test_single_parameter_representation_variable(
self, unicode_representation_resolver, variable):
"""Test that variables are properly resolved."""
assert unicode_representation_resolver.single_parameter_representation(
variable) == "2"
def test_single_parameter_representation_kwarg_variable(
self, unicode_representation_resolver, kwarg_variable):
"""Test that kwarg variables are properly resolved."""
assert (unicode_representation_resolver.
single_parameter_representation(kwarg_variable) == "1")
@pytest.mark.parametrize("par,expected", [
(3, "3"),
(5.236422, "5.236"),
])
def test_single_parameter_representation_varnames(
self, unicode_representation_resolver_varnames, par, expected):
"""Test that single parameters are properly resolved when show_variable_names is True."""
assert (unicode_representation_resolver_varnames.
single_parameter_representation(par) == expected)
def test_single_parameter_representation_variable_varnames(
self, unicode_representation_resolver_varnames, variable):
"""Test that variables are properly resolved when show_variable_names is True."""
assert (unicode_representation_resolver_varnames.
single_parameter_representation(variable) == "test")
def test_single_parameter_representation_kwarg_variable_varnames(
self, unicode_representation_resolver_varnames, kwarg_variable):
"""Test that kwarg variables are properly resolved when show_variable_names is True."""
assert (
unicode_representation_resolver_varnames.
single_parameter_representation(kwarg_variable) == "kwarg_test")
@pytest.mark.parametrize(
"op,wire,target",
[
(qml.PauliX(wires=[1]), 1, "X"),
(qml.CNOT(wires=[0, 1]), 1, "X"),
(qml.CNOT(wires=[0, 1]), 0, "C"),
(qml.Toffoli(wires=[0, 2, 1]), 1, "X"),
(qml.Toffoli(wires=[0, 2, 1]), 0, "C"),
(qml.Toffoli(wires=[0, 2, 1]), 2, "C"),
(qml.CSWAP(wires=[0, 2, 1]), 1, "SWAP"),
(qml.CSWAP(wires=[0, 2, 1]), 2, "SWAP"),
(qml.CSWAP(wires=[0, 2, 1]), 0, "C"),
(qml.PauliY(wires=[1]), 1, "Y"),
(qml.PauliZ(wires=[1]), 1, "Z"),
(qml.CZ(wires=[0, 1]), 1, "Z"),
(qml.CZ(wires=[0, 1]), 0, "C"),
(qml.Identity(wires=[1]), 1, "I"),
(qml.Hadamard(wires=[1]), 1, "H"),
(qml.CRX(3.14, wires=[0, 1]), 1, "RX(3.14)"),
(qml.CRX(3.14, wires=[0, 1]), 0, "C"),
(qml.CRY(3.14, wires=[0, 1]), 1, "RY(3.14)"),
(qml.CRY(3.14, wires=[0, 1]), 0, "C"),
(qml.CRZ(3.14, wires=[0, 1]), 1, "RZ(3.14)"),
(qml.CRZ(3.14, wires=[0, 1]), 0, "C"),
(qml.CRot(3.14, 2.14, 1.14, wires=[0, 1
]), 1, "Rot(3.14, 2.14, 1.14)"),
(qml.CRot(3.14, 2.14, 1.14, wires=[0, 1]), 0, "C"),
(qml.PhaseShift(3.14, wires=[0]), 0, "Rϕ(3.14)"),
(qml.Beamsplitter(1, 2, wires=[0, 1]), 1, "BS(1, 2)"),
(qml.Beamsplitter(1, 2, wires=[0, 1]), 0, "BS(1, 2)"),
(qml.Squeezing(1, 2, wires=[1]), 1, "S(1, 2)"),
(qml.TwoModeSqueezing(1, 2, wires=[0, 1]), 1, "S(1, 2)"),
(qml.TwoModeSqueezing(1, 2, wires=[0, 1]), 0, "S(1, 2)"),
(qml.Displacement(1, 2, wires=[1]), 1, "D(1, 2)"),
(qml.NumberOperator(wires=[1]), 1, "n"),
(qml.Rotation(3.14, wires=[1]), 1, "R(3.14)"),
(qml.ControlledAddition(3.14, wires=[0, 1]), 1, "X(3.14)"),
(qml.ControlledAddition(3.14, wires=[0, 1]), 0, "C"),
(qml.ControlledPhase(3.14, wires=[0, 1]), 1, "Z(3.14)"),
(qml.ControlledPhase(3.14, wires=[0, 1]), 0, "C"),
(qml.ThermalState(3, wires=[1]), 1, "Thermal(3)"),
(
qml.GaussianState(
np.array([1, 2]), np.array([[2, 0], [0, 2]]), wires=[1]),
1,
"Gaussian(M0,M1)",
),
(qml.QuadraticPhase(3.14, wires=[1]), 1, "P(3.14)"),
(qml.RX(3.14, wires=[1]), 1, "RX(3.14)"),
(qml.S(wires=[2]), 2, "S"),
(qml.T(wires=[2]), 2, "T"),
(qml.RX(3.14, wires=[1]), 1, "RX(3.14)"),
(qml.RY(3.14, wires=[1]), 1, "RY(3.14)"),
(qml.RZ(3.14, wires=[1]), 1, "RZ(3.14)"),
(qml.Rot(3.14, 2.14, 1.14, wires=[1]), 1, "Rot(3.14, 2.14, 1.14)"),
(qml.U1(3.14, wires=[1]), 1, "U1(3.14)"),
(qml.U2(3.14, 2.14, wires=[1]), 1, "U2(3.14, 2.14)"),
(qml.U3(3.14, 2.14, 1.14, wires=[1]), 1, "U3(3.14, 2.14, 1.14)"),
(qml.BasisState(np.array([0, 1, 0]), wires=[1, 2, 3]), 1, "|0⟩"),
(qml.BasisState(np.array([0, 1, 0]), wires=[1, 2, 3]), 2, "|1⟩"),
(qml.BasisState(np.array([0, 1, 0]), wires=[1, 2, 3]), 3, "|0⟩"),
(qml.QubitStateVector(np.array([0, 1, 0, 0]),
wires=[1, 2]), 1, "QubitStateVector(M0)"),
(qml.QubitStateVector(np.array([0, 1, 0, 0]),
wires=[1, 2]), 2, "QubitStateVector(M0)"),
(qml.QubitUnitary(np.eye(2), wires=[1]), 1, "U0"),
(qml.QubitUnitary(np.eye(4), wires=[1, 2]), 2, "U0"),
(qml.Kerr(3.14, wires=[1]), 1, "Kerr(3.14)"),
(qml.CrossKerr(3.14, wires=[1, 2]), 1, "CrossKerr(3.14)"),
(qml.CrossKerr(3.14, wires=[1, 2]), 2, "CrossKerr(3.14)"),
(qml.CubicPhase(3.14, wires=[1]), 1, "V(3.14)"),
(qml.Interferometer(np.eye(4), wires=[1, 3
]), 1, "Interferometer(M0)"),
(qml.Interferometer(np.eye(4), wires=[1, 3
]), 3, "Interferometer(M0)"),
(qml.CatState(3.14, 2.14, 1,
wires=[1]), 1, "CatState(3.14, 2.14, 1)"),
(qml.CoherentState(3.14, 2.14,
wires=[1]), 1, "CoherentState(3.14, 2.14)"),
(
qml.FockDensityMatrix(np.kron(np.eye(4), np.eye(4)),
wires=[1, 2]),
1,
"FockDensityMatrix(M0)",
),
(
qml.FockDensityMatrix(np.kron(np.eye(4), np.eye(4)),
wires=[1, 2]),
2,
"FockDensityMatrix(M0)",
),
(
qml.DisplacedSqueezedState(3.14, 2.14, 1.14, 0.14, wires=[1]),
1,
"DisplacedSqueezedState(3.14, 2.14, 1.14, 0.14)",
),
(qml.FockState(7, wires=[1]), 1, "|7⟩"),
(qml.FockStateVector(np.array([4, 5, 7]), wires=[1, 2, 3
]), 1, "|4⟩"),
(qml.FockStateVector(np.array([4, 5, 7]), wires=[1, 2, 3
]), 2, "|5⟩"),
(qml.FockStateVector(np.array([4, 5, 7]), wires=[1, 2, 3
]), 3, "|7⟩"),
(qml.SqueezedState(3.14, 2.14,
wires=[1]), 1, "SqueezedState(3.14, 2.14)"),
(qml.Hermitian(np.eye(4), wires=[1, 2]), 1, "H0"),
(qml.Hermitian(np.eye(4), wires=[1, 2]), 2, "H0"),
(qml.X(wires=[1]), 1, "x"),
(qml.P(wires=[1]), 1, "p"),
(qml.FockStateProjector(np.array([4, 5, 7]),
wires=[1, 2, 3]), 1, "|4,5,7╳4,5,7|"),
(
qml.PolyXP(np.array([1, 2, 0, -1.3, 6]), wires=[1]),
2,
"1+2x₀-1.3x₁+6p₁",
),
(
qml.PolyXP(np.array([[1.2, 2.3, 4.5], [-1.2, 1.2, -1.5],
[-1.3, 4.5, 2.3]]),
wires=[1]),
1,
"1.2+1.1x₀+3.2p₀+1.2x₀²+2.3p₀²+3x₀p₀",
),
(
qml.PolyXP(
np.array([
[1.2, 2.3, 4.5, 0, 0],
[-1.2, 1.2, -1.5, 0, 0],
[-1.3, 4.5, 2.3, 0, 0],
[0, 2.6, 0, 0, 0],
[0, 0, 0, -4.7, -1.0],
]),
wires=[1],
),
1,
"1.2+1.1x₀+3.2p₀+1.2x₀²+2.3p₀²+3x₀p₀+2.6x₀x₁-p₁²-4.7x₁p₁",
),
(qml.QuadOperator(3.14, wires=[1]), 1, "cos(3.14)x+sin(3.14)p"),
],
)
def test_operator_representation_unicode(self,
unicode_representation_resolver,
op, wire, target):
"""Test that an Operator instance is properly resolved."""
assert unicode_representation_resolver.operator_representation(
op, wire) == target
@pytest.mark.parametrize(
"op,wire,target",
[
(qml.PauliX(wires=[1]), 1, "X"),
(qml.CNOT(wires=[0, 1]), 1, "X"),
(qml.CNOT(wires=[0, 1]), 0, "C"),
(qml.Toffoli(wires=[0, 2, 1]), 1, "X"),
(qml.Toffoli(wires=[0, 2, 1]), 0, "C"),
(qml.Toffoli(wires=[0, 2, 1]), 2, "C"),
(qml.CSWAP(wires=[0, 2, 1]), 1, "SWAP"),
(qml.CSWAP(wires=[0, 2, 1]), 2, "SWAP"),
(qml.CSWAP(wires=[0, 2, 1]), 0, "C"),
(qml.PauliY(wires=[1]), 1, "Y"),
(qml.PauliZ(wires=[1]), 1, "Z"),
(qml.CZ(wires=[0, 1]), 1, "Z"),
(qml.CZ(wires=[0, 1]), 0, "C"),
(qml.Identity(wires=[1]), 1, "I"),
(qml.Hadamard(wires=[1]), 1, "H"),
(qml.CRX(3.14, wires=[0, 1]), 1, "RX(3.14)"),
(qml.CRX(3.14, wires=[0, 1]), 0, "C"),
(qml.CRY(3.14, wires=[0, 1]), 1, "RY(3.14)"),
(qml.CRY(3.14, wires=[0, 1]), 0, "C"),
(qml.CRZ(3.14, wires=[0, 1]), 1, "RZ(3.14)"),
(qml.CRZ(3.14, wires=[0, 1]), 0, "C"),
(qml.CRot(3.14, 2.14, 1.14, wires=[0, 1
]), 1, "Rot(3.14, 2.14, 1.14)"),
(qml.CRot(3.14, 2.14, 1.14, wires=[0, 1]), 0, "C"),
(qml.PhaseShift(3.14, wires=[0]), 0, "Rϕ(3.14)"),
(qml.Beamsplitter(1, 2, wires=[0, 1]), 1, "BS(1, 2)"),
(qml.Beamsplitter(1, 2, wires=[0, 1]), 0, "BS(1, 2)"),
(qml.Squeezing(1, 2, wires=[1]), 1, "S(1, 2)"),
(qml.TwoModeSqueezing(1, 2, wires=[0, 1]), 1, "S(1, 2)"),
(qml.TwoModeSqueezing(1, 2, wires=[0, 1]), 0, "S(1, 2)"),
(qml.Displacement(1, 2, wires=[1]), 1, "D(1, 2)"),
(qml.NumberOperator(wires=[1]), 1, "n"),
(qml.Rotation(3.14, wires=[1]), 1, "R(3.14)"),
(qml.ControlledAddition(3.14, wires=[0, 1]), 1, "X(3.14)"),
(qml.ControlledAddition(3.14, wires=[0, 1]), 0, "C"),
(qml.ControlledPhase(3.14, wires=[0, 1]), 1, "Z(3.14)"),
(qml.ControlledPhase(3.14, wires=[0, 1]), 0, "C"),
(qml.ThermalState(3, wires=[1]), 1, "Thermal(3)"),
(
qml.GaussianState(
np.array([1, 2]), np.array([[2, 0], [0, 2]]), wires=[1]),
1,
"Gaussian(M0,M1)",
),
(qml.QuadraticPhase(3.14, wires=[1]), 1, "P(3.14)"),
(qml.RX(3.14, wires=[1]), 1, "RX(3.14)"),
(qml.S(wires=[2]), 2, "S"),
(qml.T(wires=[2]), 2, "T"),
(qml.RX(3.14, wires=[1]), 1, "RX(3.14)"),
(qml.RY(3.14, wires=[1]), 1, "RY(3.14)"),
(qml.RZ(3.14, wires=[1]), 1, "RZ(3.14)"),
(qml.Rot(3.14, 2.14, 1.14, wires=[1]), 1, "Rot(3.14, 2.14, 1.14)"),
(qml.U1(3.14, wires=[1]), 1, "U1(3.14)"),
(qml.U2(3.14, 2.14, wires=[1]), 1, "U2(3.14, 2.14)"),
(qml.U3(3.14, 2.14, 1.14, wires=[1]), 1, "U3(3.14, 2.14, 1.14)"),
(qml.BasisState(np.array([0, 1, 0]), wires=[1, 2, 3]), 1, "|0>"),
(qml.BasisState(np.array([0, 1, 0]), wires=[1, 2, 3]), 2, "|1>"),
(qml.BasisState(np.array([0, 1, 0]), wires=[1, 2, 3]), 3, "|0>"),
(qml.QubitStateVector(np.array([0, 1, 0, 0]),
wires=[1, 2]), 1, "QubitStateVector(M0)"),
(qml.QubitStateVector(np.array([0, 1, 0, 0]),
wires=[1, 2]), 2, "QubitStateVector(M0)"),
(qml.QubitUnitary(np.eye(2), wires=[1]), 1, "U0"),
(qml.QubitUnitary(np.eye(4), wires=[1, 2]), 2, "U0"),
(qml.Kerr(3.14, wires=[1]), 1, "Kerr(3.14)"),
(qml.CrossKerr(3.14, wires=[1, 2]), 1, "CrossKerr(3.14)"),
(qml.CrossKerr(3.14, wires=[1, 2]), 2, "CrossKerr(3.14)"),
(qml.CubicPhase(3.14, wires=[1]), 1, "V(3.14)"),
(qml.Interferometer(np.eye(4), wires=[1, 3
]), 1, "Interferometer(M0)"),
(qml.Interferometer(np.eye(4), wires=[1, 3
]), 3, "Interferometer(M0)"),
(qml.CatState(3.14, 2.14, 1,
wires=[1]), 1, "CatState(3.14, 2.14, 1)"),
(qml.CoherentState(3.14, 2.14,
wires=[1]), 1, "CoherentState(3.14, 2.14)"),
(
qml.FockDensityMatrix(np.kron(np.eye(4), np.eye(4)),
wires=[1, 2]),
1,
"FockDensityMatrix(M0)",
),
(
qml.FockDensityMatrix(np.kron(np.eye(4), np.eye(4)),
wires=[1, 2]),
2,
"FockDensityMatrix(M0)",
),
(
qml.DisplacedSqueezedState(3.14, 2.14, 1.14, 0.14, wires=[1]),
1,
"DisplacedSqueezedState(3.14, 2.14, 1.14, 0.14)",
),
(qml.FockState(7, wires=[1]), 1, "|7>"),
(qml.FockStateVector(np.array([4, 5, 7]), wires=[1, 2, 3
]), 1, "|4>"),
(qml.FockStateVector(np.array([4, 5, 7]), wires=[1, 2, 3
]), 2, "|5>"),
(qml.FockStateVector(np.array([4, 5, 7]), wires=[1, 2, 3
]), 3, "|7>"),
(qml.SqueezedState(3.14, 2.14,
wires=[1]), 1, "SqueezedState(3.14, 2.14)"),
(qml.Hermitian(np.eye(4), wires=[1, 2]), 1, "H0"),
(qml.Hermitian(np.eye(4), wires=[1, 2]), 2, "H0"),
(qml.X(wires=[1]), 1, "x"),
(qml.P(wires=[1]), 1, "p"),
(qml.FockStateProjector(np.array([4, 5, 7]),
wires=[1, 2, 3]), 1, "|4,5,7X4,5,7|"),
(
qml.PolyXP(np.array([1, 2, 0, -1.3, 6]), wires=[1]),
2,
"1+2x_0-1.3x_1+6p_1",
),
(
qml.PolyXP(np.array([[1.2, 2.3, 4.5], [-1.2, 1.2, -1.5],
[-1.3, 4.5, 2.3]]),
wires=[1]),
1,
"1.2+1.1x_0+3.2p_0+1.2x_0^2+2.3p_0^2+3x_0p_0",
),
(
qml.PolyXP(
np.array([
[1.2, 2.3, 4.5, 0, 0],
[-1.2, 1.2, -1.5, 0, 0],
[-1.3, 4.5, 2.3, 0, 0],
[0, 2.6, 0, 0, 0],
[0, 0, 0, -4.7, 0],
]),
wires=[1],
),
1,
"1.2+1.1x_0+3.2p_0+1.2x_0^2+2.3p_0^2+3x_0p_0+2.6x_0x_1-4.7x_1p_1",
),
(qml.QuadOperator(3.14, wires=[1]), 1, "cos(3.14)x+sin(3.14)p"),
],
)
def test_operator_representation_ascii(self, ascii_representation_resolver,
op, wire, target):
"""Test that an Operator instance is properly resolved."""
assert ascii_representation_resolver.operator_representation(
op, wire) == target
@pytest.mark.parametrize(
"obs,wire,target",
[
(qml.expval(qml.PauliX(wires=[1])), 1, "⟨X⟩"),
(qml.expval(qml.PauliY(wires=[1])), 1, "⟨Y⟩"),
(qml.expval(qml.PauliZ(wires=[1])), 1, "⟨Z⟩"),
(qml.expval(qml.Hadamard(wires=[1])), 1, "⟨H⟩"),
(qml.expval(qml.Hermitian(np.eye(4), wires=[1, 2])), 1, "⟨H0⟩"),
(qml.expval(qml.Hermitian(np.eye(4), wires=[1, 2])), 2, "⟨H0⟩"),
(qml.expval(qml.NumberOperator(wires=[1])), 1, "⟨n⟩"),
(qml.expval(qml.X(wires=[1])), 1, "⟨x⟩"),
(qml.expval(qml.P(wires=[1])), 1, "⟨p⟩"),
(
qml.expval(
qml.FockStateProjector(np.array([4, 5, 7]),
wires=[1, 2, 3])),
1,
"⟨|4,5,7╳4,5,7|⟩",
),
(
qml.expval(qml.PolyXP(np.array([1, 2, 0, -1.3, 6]), wires=[1
])),
2,
"⟨1+2x₀-1.3x₁+6p₁⟩",
),
(
qml.expval(
qml.PolyXP(np.array([[1.2, 2.3, 4.5], [-1.2, 1.2, -1.5],
[-1.3, 4.5, 2.3]]),
wires=[1])),
1,
"⟨1.2+1.1x₀+3.2p₀+1.2x₀²+2.3p₀²+3x₀p₀⟩",
),
(qml.expval(qml.QuadOperator(
3.14, wires=[1])), 1, "⟨cos(3.14)x+sin(3.14)p⟩"),
(qml.var(qml.PauliX(wires=[1])), 1, "Var[X]"),
(qml.var(qml.PauliY(wires=[1])), 1, "Var[Y]"),
(qml.var(qml.PauliZ(wires=[1])), 1, "Var[Z]"),
(qml.var(qml.Hadamard(wires=[1])), 1, "Var[H]"),
(qml.var(qml.Hermitian(np.eye(4), wires=[1, 2])), 1, "Var[H0]"),
(qml.var(qml.Hermitian(np.eye(4), wires=[1, 2])), 2, "Var[H0]"),
(qml.var(qml.NumberOperator(wires=[1])), 1, "Var[n]"),
(qml.var(qml.X(wires=[1])), 1, "Var[x]"),
(qml.var(qml.P(wires=[1])), 1, "Var[p]"),
(
qml.var(
qml.FockStateProjector(np.array([4, 5, 7]),
wires=[1, 2, 3])),
1,
"Var[|4,5,7╳4,5,7|]",
),
(
qml.var(qml.PolyXP(np.array([1, 2, 0, -1.3, 6]), wires=[1])),
2,
"Var[1+2x₀-1.3x₁+6p₁]",
),
(
qml.var(
qml.PolyXP(np.array([[1.2, 2.3, 4.5], [-1.2, 1.2, -1.5],
[-1.3, 4.5, 2.3]]),
wires=[1])),
1,
"Var[1.2+1.1x₀+3.2p₀+1.2x₀²+2.3p₀²+3x₀p₀]",
),
(qml.var(qml.QuadOperator(
3.14, wires=[1])), 1, "Var[cos(3.14)x+sin(3.14)p]"),
(qml.sample(qml.PauliX(wires=[1])), 1, "Sample[X]"),
(qml.sample(qml.PauliY(wires=[1])), 1, "Sample[Y]"),
(qml.sample(qml.PauliZ(wires=[1])), 1, "Sample[Z]"),
(qml.sample(qml.Hadamard(wires=[1])), 1, "Sample[H]"),
(qml.sample(qml.Hermitian(np.eye(4), wires=[1, 2
])), 1, "Sample[H0]"),
(qml.sample(qml.Hermitian(np.eye(4), wires=[1, 2
])), 2, "Sample[H0]"),
(qml.sample(qml.NumberOperator(wires=[1])), 1, "Sample[n]"),
(qml.sample(qml.X(wires=[1])), 1, "Sample[x]"),
(qml.sample(qml.P(wires=[1])), 1, "Sample[p]"),
(
qml.sample(
qml.FockStateProjector(np.array([4, 5, 7]),
wires=[1, 2, 3])),
1,
"Sample[|4,5,7╳4,5,7|]",
),
(
qml.sample(qml.PolyXP(np.array([1, 2, 0, -1.3, 6]), wires=[1
])),
2,
"Sample[1+2x₀-1.3x₁+6p₁]",
),
(
qml.sample(
qml.PolyXP(np.array([[1.2, 2.3, 4.5], [-1.2, 1.2, -1.5],
[-1.3, 4.5, 2.3]]),
wires=[1])),
1,
"Sample[1.2+1.1x₀+3.2p₀+1.2x₀²+2.3p₀²+3x₀p₀]",
),
(qml.sample(qml.QuadOperator(
3.14, wires=[1])), 1, "Sample[cos(3.14)x+sin(3.14)p]"),
(
qml.expval(
qml.PauliX(wires=[1]) @ qml.PauliY(wires=[2])
@ qml.PauliZ(wires=[3])),
1,
"⟨X ⊗ Y ⊗ Z⟩",
),
(
qml.expval(
qml.FockStateProjector(np.array([4, 5, 7]),
wires=[1, 2, 3])
@ qml.X(wires=[4])),
1,
"⟨|4,5,7╳4,5,7| ⊗ x⟩",
),
(
qml.expval(
qml.FockStateProjector(np.array([4, 5, 7]),
wires=[1, 2, 3])
@ qml.X(wires=[4])),
2,
"⟨|4,5,7╳4,5,7| ⊗ x⟩",
),
(
qml.expval(
qml.FockStateProjector(np.array([4, 5, 7]),
wires=[1, 2, 3])
@ qml.X(wires=[4])),
3,
"⟨|4,5,7╳4,5,7| ⊗ x⟩",
),
(
qml.expval(
qml.FockStateProjector(np.array([4, 5, 7]),
wires=[1, 2, 3])
@ qml.X(wires=[4])),
4,
"⟨|4,5,7╳4,5,7| ⊗ x⟩",
),
(
qml.sample(
qml.Hermitian(np.eye(4), wires=[1, 2]) @ qml.Hermitian(
np.eye(4), wires=[0, 3])),
0,
"Sample[H0 ⊗ H0]",
),
(
qml.sample(
qml.Hermitian(np.eye(4), wires=[1, 2]) @ qml.Hermitian(
2 * np.eye(4), wires=[0, 3])),
0,
"Sample[H0 ⊗ H1]",
),
],
)
def test_output_representation_unicode(self,
unicode_representation_resolver,
obs, wire, target):
"""Test that an Observable instance with return type is properly resolved."""
assert unicode_representation_resolver.output_representation(
obs, wire) == target
def test_fallback_output_representation_unicode(
self, unicode_representation_resolver):
"""Test that an Observable instance with return type is properly resolved."""
obs = qml.PauliZ(0)
obs.return_type = "TestReturnType"
assert unicode_representation_resolver.output_representation(
obs, 0) == "TestReturnType[Z]"
@pytest.mark.parametrize(
"obs,wire,target",
[
(qml.expval(qml.PauliX(wires=[1])), 1, "<X>"),
(qml.expval(qml.PauliY(wires=[1])), 1, "<Y>"),
(qml.expval(qml.PauliZ(wires=[1])), 1, "<Z>"),
(qml.expval(qml.Hadamard(wires=[1])), 1, "<H>"),
(qml.expval(qml.Hermitian(np.eye(4), wires=[1, 2])), 1, "<H0>"),
(qml.expval(qml.Hermitian(np.eye(4), wires=[1, 2])), 2, "<H0>"),
(qml.expval(qml.NumberOperator(wires=[1])), 1, "<n>"),
(qml.expval(qml.X(wires=[1])), 1, "<x>"),
(qml.expval(qml.P(wires=[1])), 1, "<p>"),
(
qml.expval(
qml.FockStateProjector(np.array([4, 5, 7]),
wires=[1, 2, 3])),
1,
"<|4,5,7X4,5,7|>",
),
(
qml.expval(qml.PolyXP(np.array([1, 2, 0, -1.3, 6]), wires=[1
])),
2,
"<1+2x_0-1.3x_1+6p_1>",
),
(
qml.expval(
qml.PolyXP(np.array([[1.2, 2.3, 4.5], [-1.2, 1.2, -1.5],
[-1.3, 4.5, 2.3]]),
wires=[1])),
1,
"<1.2+1.1x_0+3.2p_0+1.2x_0^2+2.3p_0^2+3x_0p_0>",
),
(qml.expval(qml.QuadOperator(
3.14, wires=[1])), 1, "<cos(3.14)x+sin(3.14)p>"),
(qml.var(qml.PauliX(wires=[1])), 1, "Var[X]"),
(qml.var(qml.PauliY(wires=[1])), 1, "Var[Y]"),
(qml.var(qml.PauliZ(wires=[1])), 1, "Var[Z]"),
(qml.var(qml.Hadamard(wires=[1])), 1, "Var[H]"),
(qml.var(qml.Hermitian(np.eye(4), wires=[1, 2])), 1, "Var[H0]"),
(qml.var(qml.Hermitian(np.eye(4), wires=[1, 2])), 2, "Var[H0]"),
(qml.var(qml.NumberOperator(wires=[1])), 1, "Var[n]"),
(qml.var(qml.X(wires=[1])), 1, "Var[x]"),
(qml.var(qml.P(wires=[1])), 1, "Var[p]"),
(
qml.var(
qml.FockStateProjector(np.array([4, 5, 7]),
wires=[1, 2, 3])),
1,
"Var[|4,5,7X4,5,7|]",
),
(
qml.var(qml.PolyXP(np.array([1, 2, 0, -1.3, 6]), wires=[1])),
2,
"Var[1+2x_0-1.3x_1+6p_1]",
),
(
qml.var(
qml.PolyXP(np.array([[1.2, 2.3, 4.5], [-1.2, 1.2, -1.5],
[-1.3, 4.5, 2.3]]),
wires=[1])),
1,
"Var[1.2+1.1x_0+3.2p_0+1.2x_0^2+2.3p_0^2+3x_0p_0]",
),
(qml.var(qml.QuadOperator(
3.14, wires=[1])), 1, "Var[cos(3.14)x+sin(3.14)p]"),
(qml.sample(qml.PauliX(wires=[1])), 1, "Sample[X]"),
(qml.sample(qml.PauliY(wires=[1])), 1, "Sample[Y]"),
(qml.sample(qml.PauliZ(wires=[1])), 1, "Sample[Z]"),
(qml.sample(qml.Hadamard(wires=[1])), 1, "Sample[H]"),
(qml.sample(qml.Hermitian(np.eye(4), wires=[1, 2
])), 1, "Sample[H0]"),
(qml.sample(qml.Hermitian(np.eye(4), wires=[1, 2
])), 2, "Sample[H0]"),
(qml.sample(qml.NumberOperator(wires=[1])), 1, "Sample[n]"),
(qml.sample(qml.X(wires=[1])), 1, "Sample[x]"),
(qml.sample(qml.P(wires=[1])), 1, "Sample[p]"),
(
qml.sample(
qml.FockStateProjector(np.array([4, 5, 7]),
wires=[1, 2, 3])),
1,
"Sample[|4,5,7X4,5,7|]",
),
(
qml.sample(qml.PolyXP(np.array([1, 2, 0, -1.3, 6]), wires=[1
])),
2,
"Sample[1+2x_0-1.3x_1+6p_1]",
),
(
qml.sample(
qml.PolyXP(np.array([[1.2, 2.3, 4.5], [-1.2, 1.2, -1.5],
[-1.3, 4.5, 2.3]]),
wires=[1])),
1,
"Sample[1.2+1.1x_0+3.2p_0+1.2x_0^2+2.3p_0^2+3x_0p_0]",
),
(qml.sample(qml.QuadOperator(
3.14, wires=[1])), 1, "Sample[cos(3.14)x+sin(3.14)p]"),
(
qml.expval(
qml.PauliX(wires=[1]) @ qml.PauliY(wires=[2])
@ qml.PauliZ(wires=[3])),
1,
"<X @ Y @ Z>",
),
(
qml.expval(
qml.FockStateProjector(np.array([4, 5, 7]),
wires=[1, 2, 3])
@ qml.X(wires=[4])),
1,
"<|4,5,7X4,5,7| @ x>",
),
(
qml.expval(
qml.FockStateProjector(np.array([4, 5, 7]),
wires=[1, 2, 3])
@ qml.X(wires=[4])),
2,
"<|4,5,7X4,5,7| @ x>",
),
(
qml.expval(
qml.FockStateProjector(np.array([4, 5, 7]),
wires=[1, 2, 3])
@ qml.X(wires=[4])),
3,
"<|4,5,7X4,5,7| @ x>",
),
(
qml.expval(
qml.FockStateProjector(np.array([4, 5, 7]),
wires=[1, 2, 3])
@ qml.X(wires=[4])),
4,
"<|4,5,7X4,5,7| @ x>",
),
(
qml.sample(
qml.Hermitian(np.eye(4), wires=[1, 2]) @ qml.Hermitian(
np.eye(4), wires=[0, 3])),
0,
"Sample[H0 @ H0]",
),
(
qml.sample(
qml.Hermitian(np.eye(4), wires=[1, 2]) @ qml.Hermitian(
2 * np.eye(4), wires=[0, 3])),
0,
"Sample[H0 @ H1]",
),
],
)
def test_output_representation_ascii(self, ascii_representation_resolver,
obs, wire, target):
"""Test that an Observable instance with return type is properly resolved."""
assert ascii_representation_resolver.output_representation(
obs, wire) == target
def test_element_representation_none(self,
unicode_representation_resolver):
"""Test that element_representation properly handles None."""
assert unicode_representation_resolver.element_representation(None,
0) == ""
def test_element_representation_str(self, unicode_representation_resolver):
"""Test that element_representation properly handles strings."""
assert unicode_representation_resolver.element_representation(
"Test", 0) == "Test"
def test_element_representation_calls_output(
self, unicode_representation_resolver):
"""Test that element_representation calls output_representation for returned observables."""
unicode_representation_resolver.output_representation = Mock()
obs = qml.sample(qml.PauliX(3))
wire = 3
unicode_representation_resolver.element_representation(obs, wire)
assert unicode_representation_resolver.output_representation.call_args[
0] == (obs, wire)
def test_element_representation_calls_operator(
self, unicode_representation_resolver):
"""Test that element_representation calls operator_representation for all operators that are not returned."""
unicode_representation_resolver.operator_representation = Mock()
op = qml.PauliX(3)
wire = 3
unicode_representation_resolver.element_representation(op, wire)
assert unicode_representation_resolver.operator_representation.call_args[
0] == (op, wire)
def f():
qml.QubitStateVector(rnd_state, wires=range(n_all_wires))
qml.MultiControlledX(control_wires=control_wires, wires=target_wire).inv()
for op in tape.operations:
op.queue()
return qml.state()
assert np.allclose(f(), rnd_state)
spy.assert_called()
label_data = [
(qml.Identity(0), "I", "I"),
(qml.Hadamard(0), "H", "H"),
(qml.PauliX(0), "X", "X"),
(qml.PauliY(0), "Y", "Y"),
(qml.PauliZ(0), "Z", "Z"),
(qml.S(wires=0), "S", "S⁻¹"),
(qml.T(wires=0), "T", "T⁻¹"),
(qml.SX(wires=0), "SX", "SX⁻¹"),
(qml.CNOT(wires=(0, 1)), "⊕", "⊕"),
(qml.CZ(wires=(0, 1)), "Z", "Z"),
(qml.CY(wires=(0, 1)), "Y", "Y"),
(qml.SWAP(wires=(0, 1)), "SWAP", "SWAP⁻¹"),
(qml.ISWAP(wires=(0, 1)), "ISWAP", "ISWAP⁻¹"),
(qml.SISWAP(wires=(0, 1)), "SISWAP", "SISWAP⁻¹"),
(qml.SQISW(wires=(0, 1)), "SISWAP", "SISWAP⁻¹"),
(qml.CSWAP(wires=(0, 1, 2)), "SWAP", "SWAP"),
(qml.Toffoli(wires=(0, 1, 2)), "⊕", "⊕"),
(qml.MultiControlledX(control_wires=(0, 1, 2), wires=(3)), "⊕", "⊕"),
(qml.Barrier(0), "||", "||"),
class TestMixerHamiltonians:
"""Tests that the mixer Hamiltonians are being generated correctly"""
def test_x_mixer_output(self):
"""Tests that the output of the Pauli-X mixer is correct"""
wires = range(4)
mixer_hamiltonian = qaoa.x_mixer(wires)
mixer_coeffs = mixer_hamiltonian.coeffs
mixer_ops = [i.name for i in mixer_hamiltonian.ops]
mixer_wires = [i.wires[0] for i in mixer_hamiltonian.ops]
assert mixer_coeffs == [1, 1, 1, 1]
assert mixer_ops == ["PauliX", "PauliX", "PauliX", "PauliX"]
assert mixer_wires == [0, 1, 2, 3]
def test_xy_mixer_type_error(self):
"""Tests that the XY mixer throws the correct error"""
graph = [(0, 1), (1, 2)]
with pytest.raises(
ValueError,
match=r"Input graph must be a nx.Graph object, got list"):
qaoa.xy_mixer(graph)
@pytest.mark.parametrize(
("graph", "target_hamiltonian"),
[
(
Graph([(0, 1), (1, 2), (2, 3)]),
qml.Hamiltonian(
[0.5, 0.5, 0.5, 0.5, 0.5, 0.5],
[
qml.PauliX(0) @ qml.PauliX(1),
qml.PauliY(0) @ qml.PauliY(1),
qml.PauliX(1) @ qml.PauliX(2),
qml.PauliY(1) @ qml.PauliY(2),
qml.PauliX(2) @ qml.PauliX(3),
qml.PauliY(2) @ qml.PauliY(3),
],
),
),
(
Graph((np.array([0, 1]), np.array([1, 2]), np.array([2, 0]))),
qml.Hamiltonian(
[0.5, 0.5, 0.5, 0.5, 0.5, 0.5],
[
qml.PauliX(0) @ qml.PauliX(1),
qml.PauliY(0) @ qml.PauliY(1),
qml.PauliX(0) @ qml.PauliX(2),
qml.PauliY(0) @ qml.PauliY(2),
qml.PauliX(1) @ qml.PauliX(2),
qml.PauliY(1) @ qml.PauliY(2),
],
),
),
(
graph,
qml.Hamiltonian(
[0.5, 0.5, 0.5, 0.5],
[
qml.PauliX(0) @ qml.PauliX(1),
qml.PauliY(0) @ qml.PauliY(1),
qml.PauliX(1) @ qml.PauliX(2),
qml.PauliY(1) @ qml.PauliY(2),
],
),
),
(
non_consecutive_graph,
qml.Hamiltonian(
[0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5],
[
qml.PauliX(0) @ qml.PauliX(4),
qml.PauliY(0) @ qml.PauliY(4),
qml.PauliX(0) @ qml.PauliX(2),
qml.PauliY(0) @ qml.PauliY(2),
qml.PauliX(4) @ qml.PauliX(3),
qml.PauliY(4) @ qml.PauliY(3),
qml.PauliX(2) @ qml.PauliX(1),
qml.PauliY(2) @ qml.PauliY(1),
],
),
),
],
)
def test_xy_mixer_output(self, graph, target_hamiltonian):
"""Tests that the output of the XY mixer is correct"""
mixer_hamiltonian = qaoa.xy_mixer(graph)
mixer_coeffs = mixer_hamiltonian.coeffs
mixer_ops = [i.name for i in mixer_hamiltonian.ops]
mixer_wires = [i.wires for i in mixer_hamiltonian.ops]
target_coeffs = target_hamiltonian.coeffs
target_ops = [i.name for i in target_hamiltonian.ops]
target_wires = [i.wires for i in target_hamiltonian.ops]
assert mixer_coeffs == target_coeffs
assert mixer_ops == target_ops
assert mixer_wires == target_wires
def test_bit_flip_mixer_errors(self):
"""Tests that the bit-flip mixer throws the correct errors"""
graph = [(0, 1), (1, 2)]
with pytest.raises(ValueError,
match=r"Input graph must be a nx.Graph object"):
qaoa.bit_flip_mixer(graph, 0)
n = 2
with pytest.raises(ValueError, match=r"'b' must be either 0 or 1"):
qaoa.bit_flip_mixer(Graph(graph), n)
@pytest.mark.parametrize(
("graph", "n", "target_hamiltonian"),
[(Graph([(0, 1)]), 1,
qml.Hamiltonian([0.5, -0.5, 0.5, -0.5], [
qml.PauliX(0),
qml.PauliX(0) @ qml.PauliZ(1),
qml.PauliX(1),
qml.PauliX(1) @ qml.PauliZ(0)
])),
(Graph([(0, 1), (1, 2)]), 0,
qml.Hamiltonian([0.5, 0.5, 0.25, 0.25, 0.25, 0.25, 0.5, 0.5], [
qml.PauliX(0),
qml.PauliX(0) @ qml.PauliZ(1),
qml.PauliX(1),
qml.PauliX(1) @ qml.PauliZ(2),
qml.PauliX(1) @ qml.PauliZ(0),
qml.PauliX(1) @ qml.PauliZ(0) @ qml.PauliZ(2),
qml.PauliX(2),
qml.PauliX(2) @ qml.PauliZ(1)
])),
(Graph([("b", 1), (1, 0.3), (0.3, "b")]), 1,
qml.Hamiltonian([
0.25, -0.25, -0.25, 0.25, 0.25, -0.25, -0.25, 0.25, 0.25, -0.25,
-0.25, 0.25
], [
qml.PauliX("b"),
qml.PauliX("b") @ qml.PauliZ(0.3),
qml.PauliX("b") @ qml.PauliZ(1),
qml.PauliX("b") @ qml.PauliZ(1) @ qml.PauliZ(0.3),
qml.PauliX(1),
qml.PauliX(1) @ qml.PauliZ(0.3),
qml.PauliX(1) @ qml.PauliZ("b"),
qml.PauliX(1) @ qml.PauliZ("b") @ qml.PauliZ(0.3),
qml.PauliX(0.3),
qml.PauliX(0.3) @ qml.PauliZ("b"),
qml.PauliX(0.3) @ qml.PauliZ(1),
qml.PauliX(0.3) @ qml.PauliZ(1) @ qml.PauliZ("b")
]))])
def test_bit_flip_mixer_output(self, graph, n, target_hamiltonian):
"""Tests that the output of the bit-flip mixer is correct"""
mixer_hamiltonian = qaoa.bit_flip_mixer(graph, n)
assert decompose_hamiltonian(
mixer_hamiltonian) == decompose_hamiltonian(target_hamiltonian)
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"""
with qml.tape.QuantumTape() as tape:
queue = [
qml.PauliX(wires=0),
qml.PauliY(wires=1),
qml.PauliZ(wires=2)
]
observables = [qml.expval(qml.PauliZ(0)), qml.var(qml.PauliZ(1))]
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(tape)
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"""
with qml.tape.QuantumTape() as tape:
queue = [
qml.PauliX(wires=0),
qml.PauliY(wires=1),
qml.Hadamard(wires=2)
]
observables = [qml.expval(qml.PauliZ(0)), qml.var(qml.PauliZ(1))]
with pytest.raises(DeviceError,
match="Gate Hadamard not supported on device"):
dev = mock_qubit_device_with_paulis_and_methods()
dev.execute(tape)
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]),
],
]
observables = [[qml.PauliZ(0)], [qml.PauliX(0)], [qml.PauliY(0)]]
@pytest.mark.parametrize("observables", observables)
@pytest.mark.parametrize("queue", numeric_queues)
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"""
with qml.tape.QuantumTape() as tape:
for op in queue + observables:
op.queue()
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(tape, hash=tape.graph.hash)
len(call_history.items()) == 1
call_history["hash"] = tape.graph.hash
def _partial_cycle_mixer(graph: Union[nx.DiGraph, rx.PyDiGraph],
edge: Tuple) -> Hamiltonian:
r"""Calculates the partial cycle-mixer Hamiltonian for a specific edge.
For an edge :math:`(i, j)`, this function returns:
.. math::
\sum_{k \in V, k\neq i, k\neq j, (i, k) \in E, (k, j) \in E}\left[
X_{ij}X_{ik}X_{kj} + Y_{ij}Y_{ik}X_{kj} + Y_{ij}X_{ik}Y_{kj} - X_{ij}Y_{ik}Y_{kj}\right]
Args:
graph (nx.DiGraph or rx.PyDiGraph): the directed graph specifying possible edges
edge (tuple): a fixed edge
Returns:
qml.Hamiltonian: the partial cycle-mixer Hamiltonian
"""
if not isinstance(graph, (nx.DiGraph, rx.PyDiGraph)):
raise ValueError(
f"Input graph must be a nx.DiGraph or rx.PyDiGraph, got {type(graph).__name__}"
)
coeffs = []
ops = []
is_rx = isinstance(graph, rx.PyDiGraph)
edges_to_qubits = edges_to_wires(graph)
graph_nodes = graph.node_indexes() if is_rx else graph.nodes
graph_edges = sorted(graph.edge_list()) if is_rx else graph.edges
# In RX each node is assigned to an integer index starting from 0;
# thus, we use the following lambda function to get node-values.
get_nvalues = lambda T: (graph.nodes().index(T[0]), graph.nodes().index(T[
1])) if is_rx else T
for node in graph_nodes:
out_edge = (edge[0], node)
in_edge = (node, edge[1])
if node not in edge and out_edge in graph_edges and in_edge in graph_edges:
wire = edges_to_qubits[get_nvalues(edge)]
out_wire = edges_to_qubits[get_nvalues(out_edge)]
in_wire = edges_to_qubits[get_nvalues(in_edge)]
t = qml.PauliX(wires=wire) @ qml.PauliX(
wires=out_wire) @ qml.PauliX(wires=in_wire)
ops.append(t)
t = qml.PauliY(wires=wire) @ qml.PauliY(
wires=out_wire) @ qml.PauliX(wires=in_wire)
ops.append(t)
t = qml.PauliY(wires=wire) @ qml.PauliX(
wires=out_wire) @ qml.PauliY(wires=in_wire)
ops.append(t)
t = qml.PauliX(wires=wire) @ qml.PauliY(
wires=out_wire) @ qml.PauliY(wires=in_wire)
ops.append(t)
coeffs.extend([0.25, 0.25, 0.25, -0.25])
return Hamiltonian(coeffs, ops)
def circuit():
qml.RX(0.54, wires=0)
return qml.sample(qml.PauliZ(0)), qml.expval(
qml.PauliX(1)), qml.var(qml.PauliY(2))
def circuit():
qml.RX(theta, wires=[0])
qml.RX(phi, wires=[1])
qml.CNOT(wires=[0, 1])
return qml.expval(qml.PauliY(wires=0)), qml.expval(
qml.PauliY(wires=1))
def func():
qml.Hadamard(wires=1)
qml.PauliY(wires=0)
return density_matrix([0, 1])
def my_circuit(x, wires):
circuit(x, wires)
return qml.expval(qml.PauliY(0))
def circuit_rsel(params,
generators=None
): # generators will be passed as a keyword arg
ansatz_rsel(params, generators)
return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliY(1))
class TestDecomposition:
"""Tests that the template defines the correct decomposition."""
@pytest.mark.parametrize(
("time", "hamiltonian", "steps", "expected_queue"),
[
(
2,
qml.Hamiltonian([1, 1],
[qml.PauliX(0), qml.PauliX(1)]),
2,
[
qml.PauliRot(2.0, "X", wires=[0]),
qml.PauliRot(2.0, "X", wires=[1]),
qml.PauliRot(2.0, "X", wires=[0]),
qml.PauliRot(2.0, "X", wires=[1]),
],
),
(
2,
qml.Hamiltonian(
[2, 0.5],
[qml.PauliX("a"),
qml.PauliZ("b") @ qml.PauliX("a")]),
2,
[
qml.PauliRot(4.0, "X", wires=["a"]),
qml.PauliRot(1.0, "ZX", wires=["b", "a"]),
qml.PauliRot(4.0, "X", wires=["a"]),
qml.PauliRot(1.0, "ZX", wires=["b", "a"]),
],
),
(
2,
qml.Hamiltonian(
[1, 1], [qml.PauliX(0),
qml.Identity(0) @ qml.Identity(1)]),
2,
[
qml.PauliRot(2.0, "X", wires=[0]),
qml.PauliRot(2.0, "X", wires=[0])
],
),
(
2,
qml.Hamiltonian(
[2, 0.5, 0.5],
[
qml.PauliX("a"),
qml.PauliZ(-15) @ qml.PauliX("a"),
qml.Identity(0) @ qml.PauliY(-15),
],
),
1,
[
qml.PauliRot(8.0, "X", wires=["a"]),
qml.PauliRot(2.0, "ZX", wires=[-15, "a"]),
qml.PauliRot(2.0, "IY", wires=[0, -15]),
],
),
],
)
def test_evolution_operations(self, time, hamiltonian, steps,
expected_queue):
"""Tests that the sequence of gates implemented in the ApproxTimeEvolution template is correct"""
op = qml.templates.ApproxTimeEvolution(hamiltonian, time, steps)
queue = op.expand().operations
for expected_gate, gate in zip(expected_queue, queue):
prep = [gate.parameters, gate.wires]
target = [expected_gate.parameters, expected_gate.wires]
assert prep == target
@pytest.mark.parametrize(
("time", "hamiltonian", "steps", "expectation"),
[
(np.pi, qml.Hamiltonian(
[1, 1], [qml.PauliX(0), qml.PauliX(1)]), 2, [1.0, 1.0]),
(
np.pi / 2,
qml.Hamiltonian(
[0.5, 1], [qml.PauliY(0),
qml.Identity(0) @ qml.PauliX(1)]),
1,
[0.0, -1.0],
),
(
np.pi / 4,
qml.Hamiltonian([1, 1, 1], [
qml.PauliX(0),
qml.PauliZ(0) @ qml.PauliZ(1),
qml.PauliX(1)
]),
1,
[0.0, 0.0],
),
(
1,
qml.Hamiltonian([1, 1],
[qml.PauliX(0), qml.PauliX(1)]),
2,
[-0.41614684, -0.41614684],
),
(
2,
qml.Hamiltonian(
[1, 1, 1, 1],
[
qml.PauliX(0),
qml.PauliY(0),
qml.PauliZ(0) @ qml.PauliZ(1),
qml.PauliY(1)
],
),
2,
[-0.87801124, 0.51725747],
),
],
)
def test_evolution_output(self, time, hamiltonian, steps, expectation):
"""Tests that the output from the ApproxTimeEvolution template is correct"""
n_wires = 2
dev = qml.device("default.qubit", wires=n_wires)
@qml.qnode(dev)
def circuit():
qml.templates.ApproxTimeEvolution(hamiltonian, time, steps)
return [qml.expval(qml.PauliZ(wires=i)) for i in range(n_wires)]
assert np.allclose(circuit(), expectation)
def test_custom_wire_labels(self, tol):
"""Test that template can deal with non-numeric, nonconsecutive wire labels."""
hamiltonian = qml.Hamiltonian(
[1, 1, 1],
[qml.PauliX(0), qml.PauliX(1),
qml.PauliX(2)])
hamiltonian2 = qml.Hamiltonian(
[1, 1, 1], [qml.PauliX("z"),
qml.PauliX("a"),
qml.PauliX("k")])
dev = qml.device("default.qubit", wires=3)
dev2 = qml.device("default.qubit", wires=["z", "a", "k"])
@qml.qnode(dev)
def circuit():
qml.templates.ApproxTimeEvolution(hamiltonian, 0.5, 2)
return qml.expval(qml.Identity(0))
@qml.qnode(dev2)
def circuit2():
qml.templates.ApproxTimeEvolution(hamiltonian2, 0.5, 2)
return qml.expval(qml.Identity("z"))
circuit()
circuit2()
assert np.allclose(dev.state, dev2.state, atol=tol, rtol=0)
##############################################################################
# At the optimum of the generator, the probability for the discriminator
# to be fooled should be close to 1.
print("Prob(fake classified as real): ",
prob_fake_true(gen_weights, disc_weights).numpy())
##############################################################################
# At the joint optimum the discriminator cost will be close to zero,
# indicating that the discriminator assigns equal probability to both real and
# generated data.
print("Discriminator cost: ", disc_cost(disc_weights).numpy())
##############################################################################
# The generator has successfully learned how to simulate the real data
# enough to fool the discriminator.
#
# Let's conclude by comparing the states of the real data circuit and the generator. We expect
# the generator to have learned to be in a state that is very close to the one prepared in the
# real data circuit. An easy way to access the state of the first qubit is through its
# `Bloch sphere <https://en.wikipedia.org/wiki/Bloch_sphere>`__ representation:
obs = [qml.PauliX(0), qml.PauliY(0), qml.PauliZ(0)]
bloch_vector_real = qml.map(real, obs, dev, interface="tf")
bloch_vector_generator = qml.map(generator, obs, dev, interface="tf")
print("Real Bloch vector: {}".format(bloch_vector_real([phi, theta, omega])))
print("Generator Bloch vector: {}".format(bloch_vector_generator(gen_weights)))
def test_id(self):
"""Tests that the id attribute can be set."""
h = qml.Hamiltonian([1, 1], [qml.PauliX(0), qml.PauliY(0)])
template = qml.templates.ApproxTimeEvolution(h, 2, 3, id="a")
assert template.id == "a"
qml.RZ(i * x, wires=0)
return qml.var(qml.PauliZ(0)), qml.sample(qml.PauliX(1))
with qml.tape.OperationRecorder() as recorder:
template(3)
assert str(recorder) == expected_output
test_observables = [
qml.PauliZ(0) @ qml.PauliZ(1),
qml.operation.Tensor(qml.PauliZ(0), qml.PauliX(1)),
qml.operation.Tensor(qml.PauliZ(0), qml.PauliX(1)) @ qml.Hadamard(2),
qml.Hamiltonian(
[0.1, 0.2, 0.3], [qml.PauliZ(0) @ qml.PauliZ(1), qml.PauliY(1), qml.Identity(2)]
),
]
class TestApplyOp:
"""Tests for the apply function"""
def test_error(self):
"""Test that applying an operation without an active
context raises an error"""
with pytest.raises(RuntimeError, match="No queuing context"):
qml.apply(qml.PauliZ(0))
def test_default_queue_operation_inside(self):
"""Test applying an operation instantiated within the queuing
#####################################################
# Hamiltonians
H_ONE_QUBIT = np.array([[1.0, 0.5j], [-0.5j, 2.5]])
H_TWO_QUBITS = np.array(
[[0.5, 1.0j, 0.0, -3j], [-1.0j, -1.1, 0.0, -0.1], [0.0, 0.0, -0.9, 12.0], [3j, -0.1, 12.0, 0.0]]
)
COEFFS = [(0.5, 1.2, -0.7), (2.2, -0.2, 0.0), (0.33,)]
OBSERVABLES = [
(qml.PauliZ(0), qml.PauliY(0), qml.PauliZ(1)),
(qml.PauliX(0) @ qml.PauliZ(1), qml.PauliY(0) @ qml.PauliZ(1), qml.PauliZ(1)),
(qml.Hermitian(H_TWO_QUBITS, [0, 1]),),
]
JUNK_INPUTS = [None, [], tuple(), 5.0, {"junk": -1}]
valid_hamiltonians = [
((1.0,), (qml.Hermitian(H_TWO_QUBITS, [0, 1]),)),
((-0.8,), (qml.PauliZ(0),)),
((0.5, -1.6), (qml.PauliX(0), qml.PauliY(1))),
((0.5, -1.6), (qml.PauliX(1), qml.PauliY(1))),
((1.1, -0.4, 0.333), (qml.PauliX(0), qml.Hermitian(H_ONE_QUBIT, 2), qml.PauliZ(2))),
((-0.4, 0.15), (qml.Hermitian(H_TWO_QUBITS, [0, 2]), qml.PauliZ(1))),
([1.5, 2.0], [qml.PauliZ(0), qml.PauliY(2)]),
(np.array([-0.1, 0.5]), [qml.Hermitian(H_TWO_QUBITS, [0, 1]), qml.PauliY(0)]),
def qfunc():
qml.PauliX(0)
qml.PauliX(5)
qml.Toffoli(wires=[5, 1, 0])
return [qml.expval(qml.PauliY(0)), qml.probs(wires=[1, 2, 4])]
"""Resets the random seed with every test"""
np.random.seed(0)
#####################################################
# Hamiltonians
H_ONE_QUBIT = np.array([[1.0, 0.5j], [-0.5j, 2.5]])
H_TWO_QUBITS = np.array([[0.5, 1.0j, 0.0, -3j], [-1.0j, -1.1, 0.0, -0.1],
[0.0, 0.0, -0.9, 12.0], [3j, -0.1, 12.0, 0.0]])
COEFFS = [(0.5, 1.2, -0.7), (2.2, -0.2, 0.0), (0.33, )]
OBSERVABLES = [
(qml.PauliZ(0), qml.PauliY(0), qml.PauliZ(1)),
(qml.PauliX(0) @ qml.PauliZ(1), qml.PauliY(0) @ qml.PauliZ(1),
qml.PauliZ(1)),
(qml.Hermitian(H_TWO_QUBITS, [0, 1]), ),
]
JUNK_INPUTS = [None, [], tuple(), 5.0, {"junk": -1}]
valid_hamiltonians = [
((1.0, ), (qml.Hermitian(H_TWO_QUBITS, [0, 1]), )),
((-0.8, ), (qml.PauliZ(0), )),
((0.6, ), (qml.PauliX(0) @ qml.PauliX(1), )),
((0.5, -1.6), (qml.PauliX(0), qml.PauliY(1))),
((0.5, -1.6), (qml.PauliX(1), qml.PauliY(1))),
((0.5, -1.6), (qml.PauliX("a"), qml.PauliY("b"))),
((1.1, -0.4, 0.333), (qml.PauliX(0), qml.Hermitian(H_ONE_QUBIT,
def circuit(a, b, c):
ansatz(a, b, c)
return sample(qml.PauliZ(0) @ qml.Hadamard(1) @ qml.PauliY(2))
"""Resets the random seed with every test"""
np.random.seed(0)
#####################################################
# Hamiltonians
H_ONE_QUBIT = np.array([[1.0, 0.5j], [-0.5j, 2.5]])
H_TWO_QUBITS = np.array([[0.5, 1.0j, 0.0, -3j], [-1.0j, -1.1, 0.0, -0.1],
[0.0, 0.0, -0.9, 12.0], [3j, -0.1, 12.0, 0.0]])
COEFFS = [(0.5, 1.2, -0.7), (2.2, -0.2, 0.0), (0.33, )]
OBSERVABLES = [
(qml.PauliZ(0), qml.PauliY(0), qml.PauliZ(1)),
(qml.PauliX(0) @ qml.PauliZ(1), qml.PauliY(0) @ qml.PauliZ(1),
qml.PauliZ(1)),
(qml.Hermitian(H_TWO_QUBITS, [0, 1]), ),
]
OBSERVABLES_NO_HERMITIAN = [
(qml.PauliZ(0), qml.PauliY(0), qml.PauliZ(1)),
(qml.PauliX(0) @ qml.PauliZ(1), qml.PauliY(0) @ qml.PauliZ(1),
qml.PauliZ(1)),
]
JUNK_INPUTS = [None, [], tuple(), 5.0, {"junk": -1}]
hamiltonians_with_expvals = [
((-0.6, ), (qml.PauliZ(0), ), [-0.6 * 1.0]),
def circuit(a, b):
qml.RY(a, wires=0)
qml.RX(b, wires=1)
qml.CNOT(wires=[0, 1])
return [qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliY(1))]
First, let's import NumPy and PennyLane, and define our Hamiltonian.
"""
import numpy as np
import pennylane as qml
# set the random seed
np.random.seed(2)
coeffs = [2, 4, -1, 5, 2]
obs = [
qml.PauliX(1),
qml.PauliZ(1),
qml.PauliX(0) @ qml.PauliX(1),
qml.PauliY(0) @ qml.PauliY(1),
qml.PauliZ(0) @ qml.PauliZ(1)
]
##############################################################################
# We can now create our quantum device (let's use the ``default.qubit`` simulator),
# and begin constructing some QNodes to evaluate each observable. For our ansatz, we'll use the
# :class:`~.pennylane.templates.layers.StronglyEntanglingLayers`.
from pennylane import expval
from pennylane.init import strong_ent_layers_uniform
from pennylane.templates.layers import StronglyEntanglingLayers
num_layers = 2
num_wires = 2