def circuit_aux(cparams):
diag = np.ones(2**num_wires)
diag[0] *= -1
# Initialization
init_circuit(cparams)
# Non-Boolean Amplitude Amplification go brrrrr
for k in range(1, K + 1):
# Act the oracle during odd iterations, or its inverse during
# the even iterations
if k % 2 == 1:
self.oracle(cparams, num_qparams)
else:
qml.inv(self.oracle(cparams, num_qparams))
# Diffusion operator
qml.inv(init_circuit(cparams))
# Evan: This is incredibly painful to implement with a standard
# gate decomposition, so we can't actually use Floq beyond this
# point...
qml.DiagonalQubitUnitary(diag, wires=range(num_wires))
init_circuit(cparams)
# Measurement of the control registers post amplification
return qml.probs(wires=range(self.num_qubits, num_wires))
def two_qubit_gate(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13,
p14, wires):
# This is a parametrization of an arbitrary two-qubit gate
# that is called the Cartan decomposition.
one_qubit_gate(p0, p1, p2, wires[0])
one_qubit_gate(p3, p4, p5, wires[1])
# Rxx
qml.Hadamard(wires=[wires[0]])
qml.Hadamard(wires=[wires[1]])
qml.MultiRZ(p6, wires=wires)
qml.Hadamard(wires=[wires[0]])
qml.Hadamard(wires=[wires[1]])
# Ryy
qml.inv(qml.S(wires=[wires[0]]))
qml.Hadamard(wires=[wires[0]])
qml.inv(qml.S(wires=[wires[1]]))
qml.Hadamard(wires=[wires[1]])
qml.MultiRZ(p7, wires=wires)
qml.Hadamard(wires=[wires[0]])
qml.S(wires=[wires[0]])
qml.Hadamard(wires=[wires[1]])
qml.S(wires=[wires[1]])
# Rzz
qml.MultiRZ(p8, wires=wires)
one_qubit_gate(p9, p10, p11, wires[0])
one_qubit_gate(p12, p13, p14, wires[1])
def test_warning(self):
"""Test that the warning is generated."""
with pytest.warns(
UserWarning,
match=r"Use of qml\.inv\(\) is deprecated and should be replaced with qml\.adjoint\(\)\.",
):
qml.inv(qml.Hadamard(wires=[0]))
def oracle(self, cparams, num_qparams):
diag = np.ones(2**self.num_qubits)
diag[0] *= -1
qml.inv(self.rand_circuit(cparams, num_qparams))
qml.DiagonalQubitUnitary(diag, wires=range(self.num_qubits))
self.rand_circuit(cparams, num_qparams)
qml.DiagonalQubitUnitary(diag, wires=range(self.num_qubits))
def oracle(self, cparams, num_qparams):
diag = np.ones(2**self.num_qubits)
diag[0] *= -1
qml.inv(self.rand_circuit(cparams, num_qparams))
if self.floq:
decomposed_oracle(self.num_qubits)
else:
qml.DiagonalQubitUnitary(diag, wires=range(self.num_qubits))
self.rand_circuit(cparams, num_qparams)
if self.floq:
decomposed_oracle(self.num_qubits)
else:
qml.DiagonalQubitUnitary(diag, wires=range(self.num_qubits))
def variational_ansatz2(params):
wires = range(len(H.wires))
n_qubits = len(wires)
n_rotations = len(params)
if n_rotations > 1:
n_layers = n_rotations // n_qubits
n_extra_rots = n_rotations - n_layers * n_qubits
# Alternating layers of unitary rotations on every qubit followed by a
# ring cascade of CNOTs.
for layer_idx in range(n_layers):
layer_params = params[layer_idx *
n_qubits:layer_idx * n_qubits +
n_qubits, :]
qml.broadcast(qml.Rot,
wires,
pattern="single",
parameters=layer_params)
qml.broadcast(qml.CNOT, wires, pattern="ring")
# There may be "extra" parameter sets required for which it's not necessarily
# to perform another full alternating cycle. Apply these to the qubits as needed.
extra_params = params[-n_extra_rots:, :]
extra_wires = wires[:n_qubits - 1 - n_extra_rots:-1]
qml.broadcast(qml.Rot,
extra_wires,
pattern="single",
parameters=extra_params)
else:
# For 1-qubit case, just a single rotation to the qubit
qml.Rot(*params[0], wires=wires[0])
qml.inv(
qml.templates.state_preparations.MottonenStatePreparation(
state0, wires))
projector = np.zeros((2**qubits, 2**qubits))
projector[0, 0] = 1
return qml.expval(qml.Hermitian(projector, wires=range(qubits)))
def circuit_aux(cparams):
diag = np.ones(2**num_wires)
diag[0] *= -1
# Initialization
init_circuit(cparams)
# Non-Boolean Amplitude Amplification go brrrrr
for k in range(1, K + 1):
# Act the oracle during odd iterations, or its inverse during
# the even iterations
if k % 2 == 1:
self.oracle(cparams, num_qparams)
else:
qml.inv(self.oracle(cparams, num_qparams))
# Diffusion operator
qml.inv(init_circuit(cparams))
qml.DiagonalQubitUnitary(diag, wires=range(num_wires))
init_circuit(cparams)
# Measurement of the control registers post amplification
return qml.probs(wires=range(self.num_qubits, num_wires))
def _decompose_queue(ops, device):
"""Recursively loop through a queue and decompose
operations that are not supported by a device.
Args:
ops (List[~.Operation]): operation queue
device (~.Device): a PennyLane device
"""
new_ops = []
for op in ops:
if device.supports_operation(op.name):
new_ops.append(op)
else:
decomposed_ops = op.decomposition(*op.data, wires=op.wires)
if op.inverse:
decomposed_ops = qml.inv(decomposed_ops)
decomposition = _decompose_queue(decomposed_ops, device)
new_ops.extend(decomposition)
return new_ops
@qml.qnode(dev)
def my_circuit():
adjoint(my_op)()
qml.Hadamard(wires=0)
adjoint(adjoint(my_op))()
return qml.state()
np.testing.assert_allclose(
my_circuit(), np.array([-0.995707, 0.068644 + 6.209710e-02j]), atol=1e-6, rtol=1e-6
)
test_functions = [
lambda fn, *args, **kwargs: adjoint(fn)(*args, **kwargs),
lambda fn, *args, **kwargs: qml.inv(fn(*args, **kwargs)),
]
@pytest.mark.parametrize("fn", test_functions)
class TestTemplateIntegration:
"""Test that templates work correctly with the adjoint transform"""
def test_angle_embedding(self, fn):
"""Test that the adjoint correctly inverts angle embedding"""
dev = qml.device("default.qubit", wires=3)
template = qml.templates.AngleEmbedding
@qml.qnode(dev)
def circuit(weights):
template(features=weights, wires=[0, 1, 2])
def kernel(x1, x2):
"""The quantum kernel."""
AngleEmbedding(x1, wires=range(n_qubits))
qml.inv(AngleEmbedding(x2, wires=range(n_qubits)))
return qml.expval(qml.Hermitian(projector, wires=range(n_qubits)))
def overlap2(params, wires):
variational_ansatz(fes_params, wires)
qml.inv(qml.template(variational_ansatz)(params, wires))
return qml.probs([0, 1, 2])
def overlap(params, wires):
variational_ansatz(gs_params, wires)
qml.inv(qml.template(variational_ansatz)(params, wires))
# obs = qml.expval(qml.PauliZ(0) @ qml.PauliZ(1) @ qml.PauliZ(2))
return qml.probs([0, 1, 2])
def overlap(params, shifted_params):
variational_circuit(shifted_params)
qml.inv(qml.template(variational_circuit)(params))
#obs = qml.expval(qml.PauliZ(0) @ qml.PauliZ(1) @ qml.PauliZ(2))
return qml.probs([0, 1, 2])
def back_to_org(params1, params2):
variational_circuit(params2)
qml.inv(variational_circuit2(params1))
return qml.probs(wires=[0, 1, 2])
