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])