def test_non_gaussian_operation(self):
"""Test that a non-Gaussian operation succeeding
a differentiable Gaussian operation results in
numeric differentiation."""
with qml.tape.JacobianTape() as tape:
qml.Rotation(1.0, wires=[0])
qml.Rotation(1.0, wires=[1])
# Non-Gaussian
qml.Kerr(1.0, wires=[1])
qml.expval(qml.P(0))
qml.expval(qml.X(1))
# First rotation gate has no succeeding non-Gaussian operation
assert _grad_method(tape, 0) == "A"
# Second rotation gate does no succeeding non-Gaussian operation
assert _grad_method(tape, 1) == "F"
# Kerr gate does not support the parameter-shift rule
assert _grad_method(tape, 2) == "F"
with qml.tape.JacobianTape() as tape:
qml.Rotation(1.0, wires=[0])
qml.Rotation(1.0, wires=[1])
# entangle the modes
qml.Beamsplitter(1.0, 0.0, wires=[0, 1])
# Non-Gaussian
qml.Kerr(1.0, wires=[1])
qml.expval(qml.P(0))
qml.expval(qml.X(1))
# After entangling the modes, the Kerr gate now succeeds
# both initial rotations
assert _grad_method(tape, 0) == "F"
assert _grad_method(tape, 1) == "F"
assert _grad_method(tape, 2) == "F"
def layer(v):
""" Single layer of the quantum neural net.
Args:
v (array[float]): array of variables for one layer
"""
# Matrix multiplication of input layer
qml.Rotation(v[0], wires=0)
qml.Squeezing(v[1], 0., wires=0)
qml.Rotation(v[2], wires=0)
# Bias
qml.Displacement(v[3], 0., wires=0)
# Element-wise nonlinear transformation
qml.Kerr(v[4], wires=0)
#================================================
qml.Rotation(v[5], wires=1)
qml.Squeezing(v[6], 0., wires=1)
qml.Rotation(v[7], wires=1)
# Bias
qml.Displacement(v[8], 0., wires=1)
# Element-wise nonlinear transformation
qml.Kerr(v[9], wires=1)
qml.Beamsplitter(v[10],v[11], wires=[0,1])
qml.Beamsplitter(v[12],v[13], wires=[0,1])
def layer(v):
qml.Beamsplitter(v[0], v[1], wires=[0, 1])
qml.Beamsplitter(v[2], v[3], wires=[0, 2])
qml.Beamsplitter(v[4], v[5], wires=[0, 3])
qml.Beamsplitter(v[6], v[7], wires=[1, 2])
qml.Beamsplitter(v[8], v[9], wires=[1, 3])
qml.Beamsplitter(v[10], v[11], wires=[2, 3])
qml.Displacement(v[12], v[13], wires=0)
qml.Displacement(v[14], v[15], wires=1)
qml.Displacement(v[16], v[17], wires=2)
qml.Displacement(v[18], v[19], wires=3)
qml.Squeezing(v[20], v[21], wires=0)
qml.Squeezing(v[22], v[23], wires=1)
qml.Squeezing(v[24], v[25], wires=2)
qml.Squeezing(v[26], v[27], wires=3)
"""qml.CubicPhase(v[28],wires=0)
qml.CubicPhase(v[29],wires=1)
qml.CubicPhase(v[30],wires=2)
qml.CubicPhase(v[31],wires=3)"""
qml.Kerr(v[28], wires=0)
qml.Kerr(v[29], wires=1)
qml.Kerr(v[30], wires=2)
qml.Kerr(v[31], wires=3)
"""qml.Beamsplitter(v[32], v[33], wires=[0,1])
def expand(self):
with qml.tape.QuantumTape() as tape:
for l in range(self.n_layers):
qml.Interferometer(
theta=self.parameters[0][l],
phi=self.parameters[1][l],
varphi=self.parameters[2][l],
wires=self.wires,
)
for i in range(len(self.wires)):
qml.Squeezing(self.parameters[3][l, i],
self.parameters[4][l, i],
wires=self.wires[i])
qml.Interferometer(
theta=self.parameters[5][l],
phi=self.parameters[6][l],
varphi=self.parameters[7][l],
wires=self.wires,
)
for i in range(len(self.wires)):
qml.Displacement(self.parameters[8][l, i],
self.parameters[9][l, i],
wires=self.wires[i])
for i in range(len(self.wires)):
qml.Kerr(self.parameters[10][l, i], wires=self.wires[i])
return tape
def qf(x, y):
qml.Displacement(x, 0, wires=[0])
qml.Displacement(1.2, y, wires=[1])
qml.Beamsplitter(0.2, 1.7, wires=[0, 1])
qml.Rotation(1.9, wires=[0])
qml.Kerr(0.3, wires=[1]) # nongaussian succeeding both x and y due to the beamsplitter
return qml.expval(qml.X(0)), qml.expval(qml.X(1))
def layer(inputs, theta, phi, varphi, x, y, z):
qml.templates.DisplacementEmbedding(inputs, wires=range(wires))
qml.templates.Interferometer(theta, phi, varphi, wires=range(wires))
for i in range(wires):
qml.Displacement(x[i], 0, wires=i)
qml.Rotation(y[i], wires=i)
qml.Kerr(z[i], wires=i)
return [qml.expval(qml.X(wires=i)) for i in range(wires)]
def layer(self, v):
# Matrix multiplication of input layer
qml.Rotation(v[0], wires=0)
qml.Squeezing(v[1], 0.0, wires=0)
qml.Rotation(v[2], wires=0)
# Bias
qml.Displacement(v[3], 0.0, wires=0)
# Element-wise nonlinear transformation
qml.Kerr(v[4], wires=0)
def circuit_decomposed(*weights):
# Interferometer (replace with operation once this template is refactored)
qml.Beamsplitter(weights[0][0, 0], weights[1][0, 0], wires=[0, 1])
qml.Rotation(weights[2][0, 0], wires=0)
qml.Rotation(weights[2][0, 1], wires=1)
qml.Squeezing(weights[3][0, 0], weights[4][0, 0], wires=0)
qml.Squeezing(weights[3][0, 1], weights[4][0, 1], wires=1)
# Interferometer
qml.Beamsplitter(weights[5][0, 0], weights[6][0, 0], wires=[0, 1])
qml.Rotation(weights[7][0, 0], wires=0)
qml.Rotation(weights[7][0, 1], wires=1)
qml.Displacement(weights[8][0, 0], weights[9][0, 0], wires=0)
qml.Displacement(weights[8][0, 1], weights[9][0, 1], wires=1)
qml.Kerr(weights[10][0, 0], wires=0)
qml.Kerr(weights[10][0, 1], wires=1)
return qml.expval(qml.X(0))
def layer(theta, phi, wires):
M = len(wires)
phi_nonlinear = np.pi / 2
qml.templates.Interferometer(
theta, phi, np.zeros(M), wires=wires, mesh="triangular",
)
for i in wires:
qml.Kerr(phi_nonlinear, wires=i)
def quantum_neural_net(self, var=[], x=None):
# Encode input x into quantum state
qml.Displacement(x, 0.0, wires=0)
# "layer" subcircuits
for v in var:
# Matrix multiplication of input layer
qml.Rotation(v[0], wires=0)
qml.Squeezing(v[1], 0.0, wires=0)
qml.Rotation(v[2], wires=0)
# Bias
qml.Displacement(v[3], 0.0, wires=0)
# Element-wise nonlinear transformation
qml.Kerr(v[4], wires=0)
return qml.expval(qml.X(0))
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.24"),
],
)
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
@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.PauliRot(3.14, "XX", wires=[0, 1]), 1, "RX(3.14)"),
(qml.PauliRot(3.14, "YZ", wires=[0, 1]), 1, "RZ(3.14)"),
(qml.PauliRot(3.14, "IXYZI", wires=[0, 1, 2, 3, 4
]), 0, "RI(3.14)"),
(qml.PauliRot(3.14, "IXYZI", wires=[0, 1, 2, 3, 4
]), 1, "RX(3.14)"),
(qml.PauliRot(3.14, "IXYZI", wires=[0, 1, 2, 3, 4
]), 2, "RY(3.14)"),
(qml.PauliRot(3.14, "IXYZI", wires=[0, 1, 2, 3, 4
]), 3, "RZ(3.14)"),
(qml.PauliRot(3.14, "IXYZI", wires=[0, 1, 2, 3, 4
]), 4, "RI(3.14)"),
(qml.MultiRZ(3.14, wires=[0, 1]), 0, "RZ(3.14)"),
(qml.MultiRZ(3.14, wires=[0, 1]), 1, "RZ(3.14)"),
(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([[2, 0], [0, 2]]),
np.array([1, 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.InterferometerUnitary(
np.eye(4), wires=[1, 3]), 1, "InterferometerUnitary(M0)"),
(qml.InterferometerUnitary(
np.eye(4), wires=[1, 3]), 3, "InterferometerUnitary(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"),
(qml.PauliX(wires=[1]).inv(), 1, "X⁻¹"),
(qml.CNOT(wires=[0, 1]).inv(), 1, "X⁻¹"),
(qml.CNOT(wires=[0, 1]).inv(), 0, "C"),
(qml.Toffoli(wires=[0, 2, 1]).inv(), 1, "X⁻¹"),
(qml.Toffoli(wires=[0, 2, 1]).inv(), 0, "C"),
(qml.Toffoli(wires=[0, 2, 1]).inv(), 2, "C"),
(qml.measure.sample(wires=[0, 1]), 0,
"basis"), # not providing an observable in
(qml.measure.sample(wires=[0, 1]), 1,
"basis"), # sample gets displayed as raw
(two_wire_quantum_tape(), 0, "QuantumTape:T0"),
(two_wire_quantum_tape(), 1, "QuantumTape:T0"),
],
)
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([[2, 0], [0, 2]]),
np.array([1, 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.InterferometerUnitary(
np.eye(4), wires=[1, 3]), 1, "InterferometerUnitary(M0)"),
(qml.InterferometerUnitary(
np.eye(4), wires=[1, 3]), 3, "InterferometerUnitary(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"),
(qml.QuadOperator(3.14, wires=[1]), 1, "cos(3.14)x+sin(3.14)p"),
(qml.PauliX(wires=[1]).inv(), 1, "X^-1"),
(qml.CNOT(wires=[0, 1]).inv(), 1, "X^-1"),
(qml.CNOT(wires=[0, 1]).inv(), 0, "C"),
(qml.Toffoli(wires=[0, 2, 1]).inv(), 1, "X^-1"),
(qml.Toffoli(wires=[0, 2, 1]).inv(), 0, "C"),
(qml.Toffoli(wires=[0, 2, 1]).inv(), 2, "C"),
(qml.measure.sample(wires=[0, 1]), 0,
"basis"), # not providing an observable in
(qml.measure.sample(wires=[0, 1]), 1,
"basis"), # sample gets displayed as raw
(two_wire_quantum_tape(), 0, "QuantumTape:T0"),
(two_wire_quantum_tape(), 1, "QuantumTape:T0"),
],
)
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]",
),
(qml.probs([0]), 0, "Probs"),
(state(), 0, "State"),
],
)
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]",
),
(qml.probs([0]), 0, "Probs"),
(state(), 0, "State"),
],
)
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 circuit(x):
qml.Squeezing(x, 0, wires=[0])
qml.Beamsplitter(np.pi / 4, 0, wires=[0, 1])
qml.Kerr(0.54, wires=[1])
return qml.expval(qml.NumberOperator(1))
def circuit(x):
qml.Squeezing(x, 0, wires=[0])
qml.Kerr(0.54, wires=[1]) # nongaussian
qml.Beamsplitter(1.1, 0, wires=[0, 1])
return qml.expval(qml.NumberOperator(0))
def qf(x, y):
qml.Kerr(y, wires=[1])
qml.Displacement(x, 0, wires=[0])
qml.Beamsplitter(0.2, 1.7, wires=[0, 1])
return qml.expval(qml.X(0)), qml.expval(qml.X(1))
def ansatz(v):
qml.Rotation(v[0], wires=0)
qml.Squeezing(v[1], 0, wires=0)
qml.Rotation(v[2], wires=0)
qml.Displacement(v[3], 0, wires=0)
qml.Kerr(v[4], wires=0)
general_op_data = [
qml.RX(1.234, wires=0),
qml.Hadamard(0),
qml.S(wires=0),
qml.IsingXX(1.234, wires=(0, 1)),
qml.U3(1.234, 2.345, 3.456, wires=0),
# State Prep
qml.BasisState([0, 1, 0], wires=(0, 1, 2)),
### Templates
qml.QFT(wires=range(3)),
qml.Permute([4, 2, 0, 1, 3], wires=(0, 1, 2, 3, 4)),
qml.GroverOperator(wires=(0, 1, 2, 3, 4, 5)),
### Continuous Variable
qml.Kerr(1.234, wires=0),
qml.Beamsplitter(1.234, 2.345, wires=(0, 1)),
qml.Rotation(1.234, wires=0),
]
class TestGeneralOperations:
"""Tests general operations."""
width = 0.75 - 2 * 0.2
@pytest.mark.parametrize("op", general_op_data)
def test_general_operations(self, op):
"""Test that a variety of operations produce a rectangle across relevant wires
and a correct label text."""
def activation_layer(params, q):
N = len(q)
for i in range(N):
qml.Kerr(params[i], wires=q[i])
