def test_convert_program_with_inverses(self):
"""Test that a program with inverses is properly converted."""
program = pyquil.Program()
program += g.H(0)
program += g.RZ(0.34, 1).dagger()
program += g.CNOT(0, 3).dagger()
program += g.H(2)
program += g.H(7).dagger().dagger()
program += g.X(7).dagger()
program += g.X(7)
program += g.Y(1)
program += g.RZ(0.34, 1)
with OperationRecorder() as rec:
load_program(program)(wires=range(5))
expected_queue = [
qml.Hadamard(0),
qml.RZ(0.34, wires=[1]).inv(),
qml.CNOT(wires=[0, 3]).inv(),
qml.Hadamard(2),
qml.Hadamard(4),
qml.PauliX(4).inv(),
qml.PauliX(4),
qml.PauliY(1),
qml.RZ(0.34, wires=[1]),
]
for converted, expected in zip(rec.queue, expected_queue):
assert converted.name == expected.name
assert converted.wires == expected.wires
assert converted.params == expected.params
def test_convert_simple_program(self):
"""Test that a simple program in a quil file is properly converted."""
cur_dir = os.path.dirname(os.path.abspath(__file__))
with OperationRecorder() as rec:
load_quil_from_file(os.path.join(
cur_dir, "simple_program.quil"))(wires=range(5))
# The wires should be assigned as
# 0 1 2 3 7
# 0 1 2 3 4
expected_queue = [
qml.Hadamard(0),
qml.RZ(0.34, wires=[1]),
qml.CNOT(wires=[0, 3]),
qml.Hadamard(2),
qml.Hadamard(4),
qml.PauliX(4),
qml.PauliY(1),
qml.RZ(0.34, wires=[1]),
]
for converted, expected in zip(rec.queue, expected_queue):
assert converted.name == expected.name
assert converted.wires == expected.wires
assert converted.params == expected.params
def test_convert_simple_program(self):
"""Test that a simple program is properly converted."""
quil_str = textwrap.dedent("""
H 0
RZ(0.34) 1
CNOT 0 3
H 2
H 7
X 7
Y 1
RZ(0.34) 1
""")
with OperationRecorder() as rec:
load_quil(quil_str)(wires=range(5))
# The wires should be assigned as
# 0 1 2 3 7
# 0 1 2 3 4
expected_queue = [
qml.Hadamard(0),
qml.RZ(0.34, wires=[1]),
qml.CNOT(wires=[0, 3]),
qml.Hadamard(2),
qml.Hadamard(4),
qml.PauliX(4),
qml.PauliY(1),
qml.RZ(0.34, wires=[1]),
]
for converted, expected in zip(rec.queue, expected_queue):
assert converted.name == expected.name
assert converted.wires == expected.wires
assert converted.params == expected.params
def test_convert_program_with_defpermutationgates(self):
"""Test that a program with gates defined via DefPermutationGate is
properly converted."""
program = pyquil.Program()
expected_matrix = np.eye(4)
expected_matrix = expected_matrix[:, [1, 0, 3, 2]]
x_plus_x_definition = pyquil.quil.DefPermutationGate(
"X+X", [1, 0, 3, 2])
X_plus_X = x_plus_x_definition.get_constructor()
program += x_plus_x_definition
program += g.CNOT(0, 1)
program += X_plus_X(0, 1)
program += g.CNOT(0, 1)
with OperationRecorder() as rec:
load_program(program)(wires=range(2))
expected_queue = [
qml.CNOT(wires=[0, 1]),
qml.QubitUnitary(expected_matrix, wires=[0, 1]),
qml.CNOT(wires=[0, 1]),
]
for converted, expected in zip(rec.queue, expected_queue):
assert converted.name == expected.name
assert converted.wires == expected.wires
assert np.array_equal(converted.params, expected.params)
def test_convert_simple_program_wire_assignment(self):
"""Test that the assignment of qubits to wires works as expected."""
program = pyquil.Program()
program += g.H(0)
program += g.RZ(0.34, 1)
program += g.CNOT(0, 3)
program += g.H(2)
program += g.H(7)
program += g.X(7)
program += g.Y(1)
program += g.RZ(0.34, 1)
with OperationRecorder() as rec:
load_program(program)(wires=[3, 6, 4, 9, 1])
# The wires should be assigned as
# 0 1 2 3 7
# 3 6 4 9 1
expected_queue = [
qml.Hadamard(3),
qml.RZ(0.34, wires=[6]),
qml.CNOT(wires=[3, 9]),
qml.Hadamard(4),
qml.Hadamard(1),
qml.PauliX(1),
qml.PauliY(6),
qml.RZ(0.34, wires=[6]),
]
for converted, expected in zip(rec.queue, expected_queue):
assert converted.name == expected.name
assert converted.wires == expected.wires
assert converted.params == expected.params
def test_load_quil_via_entry_point(self):
"""Test that a quil string can be loaded via the load entrypoint."""
quil_str = textwrap.dedent("""
H 0
RZ(0.34) 1
CNOT 0 3
H 2
H 7
X 7
Y 1
RZ(0.34) 1
""")
with OperationRecorder() as rec:
qml.load(quil_str, format="quil")(wires=range(5))
# The wires should be assigned as
# 0 1 2 3 7
# 0 1 2 3 4
expected_queue = [
qml.Hadamard(0),
qml.RZ(0.34, wires=[1]),
qml.CNOT(wires=[0, 3]),
qml.Hadamard(2),
qml.Hadamard(4),
qml.PauliX(4),
qml.PauliY(1),
qml.RZ(0.34, wires=[1]),
]
for converted, expected in zip(rec.queue, expected_queue):
assert converted.name == expected.name
assert converted.wires == expected.wires
assert converted.params == expected.params
def test_convert_simple_program(self):
"""Test that a simple program is properly converted."""
program = pyquil.Program()
program += g.H(0)
program += g.RZ(0.34, 1)
program += g.CNOT(0, 3)
program += g.H(2)
program += g.H(7)
program += g.X(7)
program += g.Y(1)
program += g.RZ(0.34, 1)
with OperationRecorder() as rec:
load_program(program)(wires=range(5))
# The wires should be assigned as
# 0 1 2 3 7
# 0 1 2 3 4
expected_queue = [
qml.Hadamard(0),
qml.RZ(0.34, wires=[1]),
qml.CNOT(wires=[0, 3]),
qml.Hadamard(2),
qml.Hadamard(4),
qml.PauliX(4),
qml.PauliY(1),
qml.RZ(0.34, wires=[1]),
]
for converted, expected in zip(rec.queue, expected_queue):
assert converted.name == expected.name
assert converted.wires == expected.wires
assert converted.params == expected.params
def test_load_quil_file_via_entry_point(self):
"""Test that a quil file can be loaded via the load entrypoint."""
cur_dir = os.path.dirname(os.path.abspath(__file__))
with OperationRecorder() as rec:
qml.load(os.path.join(cur_dir, "simple_program.quil"),
format="quil_file")(wires=range(5))
# The wires should be assigned as
# 0 1 2 3 7
# 0 1 2 3 4
expected_queue = [
qml.Hadamard(0),
qml.RZ(0.34, wires=[1]),
qml.CNOT(wires=[0, 3]),
qml.Hadamard(2),
qml.Hadamard(4),
qml.PauliX(4),
qml.PauliY(1),
qml.RZ(0.34, wires=[1]),
]
for converted, expected in zip(rec.queue, expected_queue):
assert converted.name == expected.name
assert converted.wires == expected.wires
assert converted.params == expected.params
def test_load_program_via_entry_point(self):
"""Test that a pyquil Program instance can be loaded via the load entrypoint."""
program = pyquil.Program()
program += g.H(0)
program += g.RZ(0.34, 1)
program += g.CNOT(0, 3)
program += g.H(2)
program += g.H(7)
program += g.X(7)
program += g.Y(1)
program += g.RZ(0.34, 1)
with OperationRecorder() as rec:
qml.load(program, format="pyquil_program")(wires=range(5))
# The wires should be assigned as
# 0 1 2 3 7
# 0 1 2 3 4
expected_queue = [
qml.Hadamard(0),
qml.RZ(0.34, wires=[1]),
qml.CNOT(wires=[0, 3]),
qml.Hadamard(2),
qml.Hadamard(4),
qml.PauliX(4),
qml.PauliY(1),
qml.RZ(0.34, wires=[1]),
]
for converted, expected in zip(rec.queue, expected_queue):
assert converted.name == expected.name
assert converted.wires == expected.wires
assert converted.params == expected.params
def test_convert_program_with_classical_control_flow(self):
"""Test that a program with classical control flow is properly converted."""
quil_str = textwrap.dedent("""
DECLARE flag_register BIT[1]
MOVE flag_register 1
LABEL @START1
JUMP-UNLESS @END2 flag_register
X 0
H 0
MEASURE 0 flag_register
JUMP @START1
LABEL @END2
""")
flag = 0.0
with OperationRecorder() as rec:
load_quil(quil_str)(wires=[0],
parameter_map={
"flag_register": flag
})
expected_queue = [qml.PauliX(0), qml.Hadamard(0)]
for converted, expected in zip(rec.queue, expected_queue):
assert converted.name == expected.name
assert converted.wires == expected.wires
assert converted.params == expected.params
def test_convert_program_with_defgates(self):
"""Test that a program with defined gates is properly converted."""
quil_str = textwrap.dedent("""
DEFGATE SQRT-X:
0.5+0.5i, 0.5-0.5i
0.5-0.5i, 0.5+0.5i
H 0
CNOT 0 1
SQRT-X 0
SQRT-X 1
H 1
CONTROLLED SQRT-X 0 1
""")
sqrt_x = np.array([[0.5 + 0.5j, 0.5 - 0.5j], [0.5 - 0.5j, 0.5 + 0.5j]])
c_sqrt_x = np.eye(4, dtype=complex)
c_sqrt_x[2:, 2:] = sqrt_x
with OperationRecorder() as rec:
load_quil(quil_str)(wires=range(2))
expected_queue = [
qml.Hadamard(0),
qml.CNOT(wires=[0, 1]),
qml.QubitUnitary(sqrt_x, wires=[0]),
qml.QubitUnitary(sqrt_x, wires=[1]),
qml.Hadamard(1),
qml.QubitUnitary(c_sqrt_x, wires=[0, 1]),
]
for converted, expected in zip(rec.queue, expected_queue):
assert converted.name == expected.name
assert converted.wires == expected.wires
assert np.array_equal(converted.params, expected.params)
def test_convert_program_with_controlled_operations(self):
"""Test that a program with controlled operations is properly converted."""
program = pyquil.Program()
program += g.RZ(0.34, 1)
program += g.RY(0.2, 3).controlled(2)
program += g.RX(0.4, 2).controlled(0)
program += g.CNOT(1, 4)
program += g.CNOT(1, 6).controlled(3)
program += g.X(3).controlled(4).controlled(1)
with OperationRecorder() as rec:
load_program(program)(wires=range(6))
expected_queue = [
qml.RZ(0.34, wires=[1]),
qml.CRY(0.2, wires=[2, 3]),
qml.CRX(0.4, wires=[0, 2]),
qml.CNOT(wires=[1, 4]),
plf.ops.CCNOT(wires=[3, 1, 5]),
plf.ops.CCNOT(wires=[1, 4, 3]),
]
for converted, expected in zip(rec.queue, expected_queue):
assert converted.name == expected.name
assert converted.wires == expected.wires
assert converted.params == expected.params
def test_convert_operation(self, pyquil_operation, expected_pl_operation):
"""Test that single pyquil gates are properly converted."""
program = pyquil.Program()
program += pyquil_operation
with OperationRecorder() as rec:
loader = load_program(program)
loader(wires=range(len(loader.defined_qubits)))
assert rec.queue[0].name == expected_pl_operation.name
assert rec.queue[0].wires == expected_pl_operation.wires
assert rec.queue[0].params == expected_pl_operation.params
def test_convert_program_with_controlled_defgates(self, tol):
"""Test that a program with controlled defined gates is properly
converted."""
program = pyquil.Program()
sqrt_x = np.array([[0.5 + 0.5j, 0.5 - 0.5j], [0.5 - 0.5j, 0.5 + 0.5j]])
sqrt_x_t2 = np.kron(sqrt_x, sqrt_x)
c_sqrt_x = np.eye(4, dtype=complex)
c_sqrt_x[2:, 2:] = sqrt_x
c_sqrt_x_t2 = np.eye(8, dtype=complex)
c_sqrt_x_t2[4:, 4:] = sqrt_x_t2
sqrt_x_definition = pyquil.quil.DefGate("SQRT-X", sqrt_x)
SQRT_X = sqrt_x_definition.get_constructor()
sqrt_x_t2_definition = pyquil.quil.DefGate("SQRT-X-T2", sqrt_x_t2)
SQRT_X_T2 = sqrt_x_t2_definition.get_constructor()
program += sqrt_x_definition
program += sqrt_x_t2_definition
program += g.CNOT(0, 1)
program += SQRT_X(0).controlled(1)
program += SQRT_X_T2(1, 2).controlled(0)
program += g.X(0).controlled(1)
program += g.RX(0.4, 0)
with OperationRecorder() as rec:
load_program(program)(wires=range(3))
expected_queue = [
qml.CNOT(wires=[0, 1]),
qml.QubitUnitary(c_sqrt_x, wires=[1, 0]),
qml.QubitUnitary(c_sqrt_x_t2, wires=[0, 1, 2]),
qml.CNOT(wires=[1, 0]),
qml.RX(0.4, wires=[0]),
]
for converted, expected in zip(rec.queue, expected_queue):
assert converted.name == expected.name
assert converted.wires == expected.wires
assert np.allclose(converted.params,
expected.params,
atol=tol,
rtol=0)
def test_convert_simple_program_with_parameters_mixed_keys(self):
"""Test that a parametrized program is properly converted when
the variable map contains mixed key types."""
program = pyquil.Program()
alpha = program.declare("alpha", "REAL")
beta = program.declare("beta", "REAL")
gamma = program.declare("gamma", "REAL")
delta = program.declare("delta", "REAL")
program += g.H(0)
program += g.CNOT(0, 1)
program += g.RX(alpha, 1)
program += g.RZ(beta, 1)
program += g.RX(gamma, 1)
program += g.CNOT(0, 1)
program += g.RZ(delta, 0)
program += g.H(0)
a, b, c, d = 0.1, 0.2, 0.3, 0.4
parameter_map = {
"alpha": a,
beta: b,
gamma: c,
"delta": d,
}
with OperationRecorder() as rec:
load_program(program)(wires=range(2), parameter_map=parameter_map)
expected_queue = [
qml.Hadamard(0),
qml.CNOT(wires=[0, 1]),
qml.RX(0.1, wires=[1]),
qml.RZ(0.2, wires=[1]),
qml.RX(0.3, wires=[1]),
qml.CNOT(wires=[0, 1]),
qml.RZ(0.4, wires=[0]),
qml.Hadamard(0),
]
for converted, expected in zip(rec.queue, expected_queue):
assert converted.name == expected.name
assert converted.wires == expected.wires
assert converted.params == expected.params
def test_convert_program_with_defgates(self):
"""Test that a program that defines its own gates is properly converted."""
program = pyquil.Program()
sqrt_x = np.array([[0.5 + 0.5j, 0.5 - 0.5j], [0.5 - 0.5j, 0.5 + 0.5j]])
sqrt_x_t2 = np.kron(sqrt_x, sqrt_x)
sqrt_x_t3 = np.kron(sqrt_x, sqrt_x_t2)
sqrt_x_definition = pyquil.quil.DefGate("SQRT-X", sqrt_x)
SQRT_X = sqrt_x_definition.get_constructor()
sqrt_x_t2_definition = pyquil.quil.DefGate("SQRT-X-T2", sqrt_x_t2)
SQRT_X_T2 = sqrt_x_t2_definition.get_constructor()
sqrt_x_t3_definition = pyquil.quil.DefGate("SQRT-X-T3", sqrt_x_t3)
SQRT_X_T3 = sqrt_x_t3_definition.get_constructor()
program += sqrt_x_definition
program += sqrt_x_t2_definition
program += sqrt_x_t3_definition
program += g.CNOT(0, 1)
program += SQRT_X(0)
program += SQRT_X_T2(1, 2)
program += SQRT_X_T3(1, 0, 2)
program += g.CNOT(0, 1)
program += g.CNOT(1, 2)
program += g.CNOT(2, 0)
with OperationRecorder() as rec:
load_program(program)(wires=range(3))
expected_queue = [
qml.CNOT(wires=[0, 1]),
qml.QubitUnitary(sqrt_x, wires=[0]),
qml.QubitUnitary(sqrt_x_t2, wires=[1, 2]),
qml.QubitUnitary(sqrt_x_t3, wires=[1, 0, 2]),
qml.CNOT(wires=[0, 1]),
qml.CNOT(wires=[1, 2]),
qml.CNOT(wires=[2, 0]),
]
for converted, expected in zip(rec.queue, expected_queue):
assert converted.name == expected.name
assert converted.wires == expected.wires
assert converted.params == expected.params
def test_convert_program_with_parameters_and_measurements(self):
"""Test that a program with parameters and measurements is properly converted."""
quil_str = textwrap.dedent("""
DECLARE alpha REAL[1]
DECLARE beta REAL[1]
DECLARE gamma REAL[1]
DECLARE ro BIT[2]
H 0
CNOT 0 1
RX(alpha) 1
RZ(beta) 1
RX(gamma) 1
CNOT 0 1
H 0
MEASURE 0 ro[0]
MEASURE 1 ro[1]
""")
a, b, c = 0.1, 0.2, 0.3
parameter_map = {
"alpha": a,
"beta": b,
"gamma": c,
}
with OperationRecorder() as rec:
load_quil(quil_str)(wires=range(2), parameter_map=parameter_map)
expected_queue = [
qml.Hadamard(0),
qml.CNOT(wires=[0, 1]),
qml.RX(0.1, wires=[1]),
qml.RZ(0.2, wires=[1]),
qml.RX(0.3, wires=[1]),
qml.CNOT(wires=[0, 1]),
qml.Hadamard(0),
]
for converted, expected in zip(rec.queue, expected_queue):
assert converted.name == expected.name
assert converted.wires == expected.wires
assert converted.params == expected.params
def test_convert_program_with_pragmas(self):
"""Test that a program with pragmas is properly converted."""
quil_str = textwrap.dedent("""
PRAGMA INITIAL_REWIRING "GREEDY"
PRAGMA PRESERVE_BLOCK
I 0
I 1
PRAGMA END_PRESERVE_BLOCK
PRAGMA COMMUTING_BLOCKS
PRAGMA BLOCK
CNOT 0 1
RZ(0.4) 1
CNOT 0 1
PRAGMA END_BLOCK
PRAGMA BLOCK
CNOT 1 2
RZ(0.6) 2
CNOT 1 2
PRAGMA END_BLOCK
PRAGMA END_COMMUTING_BLOCKS
H 0
""")
with OperationRecorder() as rec:
load_quil(quil_str)(wires=range(3))
expected_queue = [
qml.Identity(wires=[0]),
qml.Identity(wires=[1]),
qml.CNOT(wires=[0, 1]),
qml.RZ(0.4, wires=[1]),
qml.CNOT(wires=[0, 1]),
qml.CNOT(wires=[1, 2]),
qml.RZ(0.6, wires=[2]),
qml.CNOT(wires=[1, 2]),
qml.Hadamard(0),
]
for converted, expected in zip(rec.queue, expected_queue):
assert converted.name == expected.name
assert converted.wires == expected.wires
assert converted.params == expected.params
def test_convert_simple_program_with_parameters(self):
"""Test that a simple program with parameters is properly converted."""
program = pyquil.Program()
alpha = program.declare("alpha", "REAL")
beta = program.declare("beta", "REAL")
gamma = program.declare("gamma", "REAL")
program += g.H(0)
program += g.CNOT(0, 1)
program += g.RX(alpha, 1)
program += g.RZ(beta, 1)
program += g.RX(gamma, 1)
program += g.CNOT(0, 1)
program += g.H(0)
a, b, c = 0.1, 0.2, 0.3
parameter_map = {
"alpha": a,
"beta": b,
"gamma": c,
}
with OperationRecorder() as rec:
load_program(program)(wires=range(2), parameter_map=parameter_map)
expected_queue = [
qml.Hadamard(0),
qml.CNOT(wires=[0, 1]),
qml.RX(0.1, wires=[1]),
qml.RZ(0.2, wires=[1]),
qml.RX(0.3, wires=[1]),
qml.CNOT(wires=[0, 1]),
qml.Hadamard(0),
]
for converted, expected in zip(rec.queue, expected_queue):
assert converted.name == expected.name
assert converted.wires == expected.wires
assert converted.params == expected.params
def test_convert_program_with_controlled_dagger_operations(self):
"""Test that a program that combines controlled and daggered operations
is properly converted."""
program = pyquil.Program()
program += g.CNOT(0, 1).controlled(2)
program += g.CNOT(0, 1).dagger().controlled(2)
program += g.CNOT(0, 1).controlled(2).dagger()
program += g.CNOT(0, 1).dagger().controlled(2).dagger()
program += g.RX(0.3, 3).controlled(4)
program += g.RX(0.2, 3).controlled(4).dagger()
program += g.RX(0.3, 3).dagger().controlled(4)
program += g.RX(0.2, 3).dagger().controlled(4).dagger()
program += g.X(2).dagger().controlled(4).controlled(1).dagger()
program += g.X(0).dagger().controlled(4).controlled(1)
program += g.X(0).dagger().controlled(4).dagger().dagger().controlled(
1).dagger()
with OperationRecorder() as rec:
load_program(program)(wires=range(5))
expected_queue = [
plf.ops.CCNOT(wires=[2, 0, 1]),
plf.ops.CCNOT(wires=[2, 0, 1]).inv(),
plf.ops.CCNOT(wires=[2, 0, 1]).inv(),
plf.ops.CCNOT(wires=[2, 0, 1]),
qml.CRX(0.3, wires=[4, 3]),
qml.CRX(0.2, wires=[4, 3]).inv(),
qml.CRX(0.3, wires=[4, 3]).inv(),
qml.CRX(0.2, wires=[4, 3]),
plf.ops.CCNOT(wires=[1, 4, 2]),
plf.ops.CCNOT(wires=[1, 4, 0]).inv(),
plf.ops.CCNOT(wires=[1, 4, 0]),
]
for converted, expected in zip(rec.queue, expected_queue):
assert converted.name == expected.name
assert converted.wires == expected.wires
assert converted.params == expected.params
def test_convert_complex_program(self):
"""Test that a more complicated program is properly converted."""
quil_str = textwrap.dedent("""
H 0
DAGGER RZ(0.34) 1
CNOT 0 3
H 2
CONTROLLED S 1 7
DAGGER CONTROLLED X 3 7
DAGGER DAGGER Y 1
RZ(0.34) 1
""")
with OperationRecorder() as rec:
load_quil(quil_str)(wires=range(5))
# The wires should be assigned as
# 0 1 2 3 7
# 0 1 2 3 4
CS_matrix = np.eye(4, dtype=complex)
CS_matrix[3, 3] = 1j
expected_queue = [
qml.Hadamard(0),
qml.RZ(0.34, wires=[1]).inv(),
qml.CNOT(wires=[0, 3]),
qml.Hadamard(2),
qml.QubitUnitary(CS_matrix, wires=[1, 4]),
qml.CNOT(wires=[3, 4]).inv(),
qml.PauliY(1),
qml.RZ(0.34, wires=[1]),
]
for converted, expected in zip(rec.queue, expected_queue):
assert converted.name == expected.name
assert converted.wires == expected.wires
assert np.array_equal(converted.params, expected.params)
def test_convert_program_with_controlled_operations_not_in_pl_core(
self, tol):
"""Test that a program with controlled operations out of scope of PL core/PLF
is properly converted, i.e. the operations are replaced with controlled operations."""
program = pyquil.Program()
CS_matrix = np.eye(4, dtype=complex)
CS_matrix[3, 3] = 1j
CCT_matrix = np.eye(8, dtype=complex)
CCT_matrix[7, 7] = np.exp(1j * np.pi / 4)
program += g.CNOT(0, 1)
program += g.S(0).controlled(1)
program += g.S(1).controlled(0)
program += g.T(0).controlled(1).controlled(2)
program += g.T(1).controlled(0).controlled(2)
program += g.T(2).controlled(1).controlled(0)
with OperationRecorder() as rec:
load_program(program)(wires=range(3))
expected_queue = [
qml.CNOT(wires=[0, 1]),
qml.QubitUnitary(CS_matrix, wires=[1, 0]),
qml.QubitUnitary(CS_matrix, wires=[0, 1]),
qml.QubitUnitary(CCT_matrix, wires=[2, 1, 0]),
qml.QubitUnitary(CCT_matrix, wires=[2, 0, 1]),
qml.QubitUnitary(CCT_matrix, wires=[0, 1, 2]),
]
for converted, expected in zip(rec.queue, expected_queue):
assert converted.name == expected.name
assert converted.wires == expected.wires
assert np.allclose(converted.params,
expected.params,
atol=tol,
rtol=0)
def decomposition(n, wires):
with OperationRecorder() as rec:
BasisStatePreparation(n, wires)
return rec.queue
def decomposition(state, wires):
with OperationRecorder() as rec:
MottonenStatePreparation(state, wires)
return rec.queue
def wrapper(*args, **kwargs):
with OperationRecorder() as rec:
func(*args, **kwargs)
return rec.queue
