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 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 test_diagonal_ctrl():
"""Test ctrl on diagonal gates."""
with QuantumTape() as tape:
ctrl(qml.DiagonalQubitUnitary, 1)(np.array([-1.0, 1.0j]), wires=0)
tape = expand_tape(tape, 3, stop_at=lambda op: not isinstance(op, ControlledOperation))
assert_equal_operations(
tape.operations, [qml.DiagonalQubitUnitary(np.array([1.0, 1.0, -1.0, 1.0j]), wires=[1, 0])]
)
def op(op_name):
ops_list = {
"RX": qml.RX(0.123, wires=0),
"RY": qml.RY(1.434, wires=0),
"RZ": qml.RZ(2.774, wires=0),
"S": qml.S(wires=0),
"SX": qml.SX(wires=0),
"T": qml.T(wires=0),
"CNOT": qml.CNOT(wires=[0, 1]),
"CZ": qml.CZ(wires=[0, 1]),
"CY": qml.CY(wires=[0, 1]),
"SWAP": qml.SWAP(wires=[0, 1]),
"ISWAP": qml.ISWAP(wires=[0, 1]),
"SISWAP": qml.SISWAP(wires=[0, 1]),
"SQISW": qml.SQISW(wires=[0, 1]),
"CSWAP": qml.CSWAP(wires=[0, 1, 2]),
"PauliRot": qml.PauliRot(0.123, "Y", wires=0),
"IsingXX": qml.IsingXX(0.123, wires=[0, 1]),
"IsingXY": qml.IsingXY(0.123, wires=[0, 1]),
"IsingYY": qml.IsingYY(0.123, wires=[0, 1]),
"IsingZZ": qml.IsingZZ(0.123, wires=[0, 1]),
"Identity": qml.Identity(wires=0),
"Rot": qml.Rot(0.123, 0.456, 0.789, wires=0),
"Toffoli": qml.Toffoli(wires=[0, 1, 2]),
"PhaseShift": qml.PhaseShift(2.133, wires=0),
"ControlledPhaseShift": qml.ControlledPhaseShift(1.777, wires=[0, 2]),
"CPhase": qml.CPhase(1.777, wires=[0, 2]),
"MultiRZ": qml.MultiRZ(0.112, wires=[1, 2, 3]),
"CRX": qml.CRX(0.836, wires=[2, 3]),
"CRY": qml.CRY(0.721, wires=[2, 3]),
"CRZ": qml.CRZ(0.554, wires=[2, 3]),
"Hadamard": qml.Hadamard(wires=0),
"PauliX": qml.PauliX(wires=0),
"PauliY": qml.PauliY(wires=0),
"PauliZ": qml.PauliZ(wires=0),
"CRot": qml.CRot(0.123, 0.456, 0.789, wires=[0, 1]),
"DiagonalQubitUnitary": qml.DiagonalQubitUnitary(np.array([1.0, 1.0j]), wires=1),
"ControlledQubitUnitary": qml.ControlledQubitUnitary(
np.eye(2) * 1j, wires=[0], control_wires=[2]
),
"MultiControlledX": qml.MultiControlledX(wires=(0, 1, 2), control_values="01"),
"SingleExcitation": qml.SingleExcitation(0.123, wires=[0, 3]),
"SingleExcitationPlus": qml.SingleExcitationPlus(0.123, wires=[0, 3]),
"SingleExcitationMinus": qml.SingleExcitationMinus(0.123, wires=[0, 3]),
"DoubleExcitation": qml.DoubleExcitation(0.123, wires=[0, 1, 2, 3]),
"DoubleExcitationPlus": qml.DoubleExcitationPlus(0.123, wires=[0, 1, 2, 3]),
"DoubleExcitationMinus": qml.DoubleExcitationMinus(0.123, wires=[0, 1, 2, 3]),
"QFT": qml.QFT(wires=0),
"QubitSum": qml.QubitSum(wires=[0, 1, 2]),
"QubitCarry": qml.QubitCarry(wires=[0, 1, 2, 3]),
"QubitUnitary": qml.QubitUnitary(np.eye(2) * 1j, wires=0),
}
return ops_list.get(op_name)
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 circuit():
qml.DiagonalQubitUnitary(np.array([1.0, 1.0]), wires=0)
return qml.sample(qml.PauliZ(wires=0))
Benchmark for a circuit of the Instantaneous Quantum Polynomial-time (IQP) complexity class.
"""
# pylint: disable=invalid-name
import math
import random
import numpy as np
import pennylane as qml
import benchmark_utils as bu
CCZ_diag = np.array([1, 1, 1, 1, 1, 1, 1, -1])
CCZ_matrix = np.diag(CCZ_diag)
if hasattr(qml, "DiagonalQubitUnitary"):
CCZ = lambda wires: qml.DiagonalQubitUnitary(CCZ_diag, wires=wires)
else:
CCZ = lambda wires: qml.QubitUnitary(CCZ_matrix, wires=wires)
def random_iqp_wires(n_wires):
"""Create a random set of IQP wires.
Returns a list of either 1, 2, or 3 distinct integers
in the range of n_wires.
Args:
n_wires (int): Number of wires of the device.
Returns:
List[int]: The IQP wires.
# ==========================================================
# Some useful global variables
# gates for which device support is tested
ops = {
"BasisState": qml.BasisState(np.array([0]), wires=[0]),
"CNOT": qml.CNOT(wires=[0, 1]),
"CRX": qml.CRX(0, wires=[0, 1]),
"CRY": qml.CRY(0, wires=[0, 1]),
"CRZ": qml.CRZ(0, wires=[0, 1]),
"CRot": qml.CRot(0, 0, 0, wires=[0, 1]),
"CSWAP": qml.CSWAP(wires=[0, 1, 2]),
"CZ": qml.CZ(wires=[0, 1]),
"CY": qml.CY(wires=[0, 1]),
"DiagonalQubitUnitary": qml.DiagonalQubitUnitary(np.array([1, 1]), wires=[0]),
"Hadamard": qml.Hadamard(wires=[0]),
"MultiRZ": qml.MultiRZ(0, wires=[0]),
"PauliX": qml.PauliX(wires=[0]),
"PauliY": qml.PauliY(wires=[0]),
"PauliZ": qml.PauliZ(wires=[0]),
"PhaseShift": qml.PhaseShift(0, wires=[0]),
"ControlledPhaseShift": qml.ControlledPhaseShift(0, wires=[0, 1]),
"QubitStateVector": qml.QubitStateVector(np.array([1.0, 0.0]), wires=[0]),
"QubitUnitary": qml.QubitUnitary(np.eye(2), wires=[0]),
"ControlledQubitUnitary": qml.ControlledQubitUnitary(np.eye(2), control_wires=[1], wires=[0]),
"MultiControlledX": qml.MultiControlledX(control_wires=[1, 2], wires=[0]),
"RX": qml.RX(0, wires=[0]),
"RY": qml.RY(0, wires=[0]),
"RZ": qml.RZ(0, wires=[0]),
"Rot": qml.Rot(0, 0, 0, wires=[0]),
qml.PauliX(wires=control_wires[wire])
qml.ControlledQubitUnitary(U,
control_wires=control_wires,
wires=wires)
for wire in x_locations:
qml.PauliX(wires=control_wires[wire])
return qml.state()
mixed_polarity_state = circuit_mixed_polarity()
pauli_x_state = circuit_pauli_x()
assert np.allclose(mixed_polarity_state, pauli_x_state)
label_data = [
(qml.QubitUnitary(X, wires=0), "U"),
(qml.DiagonalQubitUnitary([1, 1], wires=1), "U"),
(qml.ControlledQubitUnitary(X, control_wires=0, wires=1), "U"),
]
@pytest.mark.parametrize("op, label", label_data)
def test_label(op, label):
assert op.label() == label
assert op.label(decimals=5) == label
op.inv()
assert op.label() == label + "⁻¹"
# ==========================================================
# Some useful global variables
# gates for which device support is tested
ops = {
"BasisState": qml.BasisState(np.array([0]), wires=[0]),
"CNOT": qml.CNOT(wires=[0, 1]),
"CRX": qml.CRX(0, wires=[0, 1]),
"CRY": qml.CRY(0, wires=[0, 1]),
"CRZ": qml.CRZ(0, wires=[0, 1]),
"CRot": qml.CRot(0, 0, 0, wires=[0, 1]),
"CSWAP": qml.CSWAP(wires=[0, 1, 2]),
"CZ": qml.CZ(wires=[0, 1]),
"CY": qml.CY(wires=[0, 1]),
"DiagonalQubitUnitary": qml.DiagonalQubitUnitary(np.eye(2), wires=[0]),
"Hadamard": qml.Hadamard(wires=[0]),
"MultiRZ": qml.MultiRZ(0, wires=[0]),
"PauliX": qml.PauliX(wires=[0]),
"PauliY": qml.PauliY(wires=[0]),
"PauliZ": qml.PauliZ(wires=[0]),
"PhaseShift": qml.PhaseShift(0, wires=[0]),
"QubitStateVector": qml.QubitStateVector(np.array([1.0, 0.0]), wires=[0]),
"QubitUnitary": qml.QubitUnitary(np.eye(2), wires=[0]),
"RX": qml.RX(0, wires=[0]),
"RY": qml.RY(0, wires=[0]),
"RZ": qml.RZ(0, wires=[0]),
"Rot": qml.Rot(0, 0, 0, wires=[0]),
"S": qml.S(wires=[0]),
"SWAP": qml.SWAP(wires=[0, 1]),
"T": qml.T(wires=[0]),
