def test_register_gate():
class _FooGate(Gate):
def __init__(self):
super().__init__(qubit_count=1, ascii_symbols=["foo"])
Gate.register_gate(_FooGate)
assert Gate._FooGate().name == _FooGate().name
def many_layers(n_qubits: int, n_layers: int) -> Circuit:
"""
Function to return circuit with many layers.
:param int n_qubits: number of qubits
:param int n_layers: number of layers
:return: Constructed easy circuit
:rtype: Circuit
"""
qubits = range(n_qubits)
circuit = Circuit() # instantiate circuit object
for q in range(n_qubits):
circuit.h(q)
for layer in range(n_layers):
if (layer + 1) % 100 != 0:
for qubit in range(len(qubits)):
angle = np.random.uniform(0, 2 * math.pi)
gate = np.random.choice(
[Gate.Rx(angle), Gate.Ry(angle), Gate.Rz(angle), Gate.H()], 1, replace=True
)[0]
circuit.add_instruction(Instruction(gate, qubit))
else:
for q in range(0, n_qubits, 2):
circuit.cnot(q, q + 1)
for q in range(1, n_qubits - 1, 2):
circuit.cnot(q, q + 1)
return circuit
def test_add_circuit_with_target_and_non_continuous_qubits():
widget = Circuit().h(5).h(50).h(100)
circ = Circuit().add_circuit(widget, target=[1, 3, 5])
expected = (Circuit().add_instruction(Instruction(
Gate.H(), 1)).add_instruction(Instruction(
Gate.H(), 3)).add_instruction(Instruction(Gate.H(), 5)))
assert circ == expected
def test_add_circuit_with_target(bell_pair):
circ = Circuit().add_circuit(bell_pair, target=[10, 11])
expected = (Circuit().add_instruction(Instruction(
Gate.H(),
10)).add_instruction(Instruction(Gate.CNot(),
[10, 11])).add_result_type(
ResultType.Probability([10, 11])))
assert circ == expected
def test_basis_rotation_instructions_multiple_result_types_same_targets():
circ = (Circuit().h(0).cnot(0, 1).expectation(
observable=Observable.H() @ Observable.X(),
target=[0, 1]).sample(observable=Observable.H() @ Observable.X(),
target=[0, 1]).variance(
observable=Observable.H() @ Observable.X(),
target=[0, 1]))
expected = [Instruction(Gate.Ry(-np.pi / 4), 0), Instruction(Gate.H(), 1)]
assert circ.basis_rotation_instructions == expected
def test_add_verbatim_box_no_preceding():
circ = Circuit().add_verbatim_box(Circuit().h(0)).cnot(2, 3)
expected = (Circuit().add_instruction(
Instruction(compiler_directives.StartVerbatimBox())).add_instruction(
Instruction(Gate.H(), 0)).add_instruction(
Instruction(
compiler_directives.EndVerbatimBox())).add_instruction(
Instruction(Gate.CNot(), [2, 3])))
assert circ == expected
def test_equality():
gate_1 = Gate(qubit_count=1, ascii_symbols=["foo"])
gate_2 = Gate(qubit_count=1, ascii_symbols=["bar"])
other_gate = Gate.Rx(angle=0.34)
non_gate = "non gate"
assert gate_1 == gate_2
assert gate_1 is not gate_2
assert gate_1 != other_gate
assert gate_1 != non_gate
def test_equality():
instr_1 = Instruction(Gate.H(), 0)
instr_2 = Instruction(Gate.H(), 0)
other_instr = Instruction(Gate.CNot(), [0, 1])
non_instr = "non instruction"
assert instr_1 == instr_2
assert instr_1 is not instr_2
assert instr_1 != other_instr
assert instr_1 != non_instr
def test_equality():
u1 = Gate.Unitary(np.array([[0 + 0j, 1 + 0j], [1 + 0j, 0 + 0j]]))
u2 = Gate.Unitary(np.array([[0, 1], [1, 0]], dtype=np.float32), display_name=["u2"])
other_gate = Gate.Unitary(np.array([[1, 0], [0, 1]]))
non_gate = "non gate"
assert u1 == u2
assert u1 is not u2
assert u1 != other_gate
assert u1 != non_gate
def test_free_param_equality():
param1 = FreeParameter("theta")
param2 = FreeParameter("phi")
rx1 = Gate.Rx(param1)
rx2 = Gate.Rx(param1)
other_gate = Gate.Rx(param2)
assert rx1 == rx2
assert rx1 is not rx2
assert rx1 != other_gate
assert rx1 != param1
def test_add_verbatim_box_different_qubits():
circ = Circuit().h(1).add_verbatim_box(Circuit().h(0)).cnot(3, 4)
expected = (Circuit().add_instruction(Instruction(
Gate.H(),
1)).add_instruction(Instruction(
compiler_directives.StartVerbatimBox())).add_instruction(
Instruction(Gate.H(), 0)).add_instruction(
Instruction(
compiler_directives.EndVerbatimBox())).add_instruction(
Instruction(Gate.CNot(), [3, 4])))
assert circ == expected
def test_basis_rotation_instructions_multiple_result_types_tensor_product_hermitian_qubit_count_2(
):
circ = (Circuit().h(0).cnot(0, 1).cnot(1, 2).expectation(
observable=Observable.I(), target=[1]).sample(
observable=Observable.Hermitian(matrix=np.eye(4)) @ Observable.H(),
target=[0, 1, 2]).variance(observable=Observable.H(),
target=[2]).expectation(
observable=Observable.I(),
target=[0]))
expected = [
Instruction(Gate.Unitary(matrix=np.eye(4)), target=[0, 1]),
Instruction(Gate.Ry(-np.pi / 4), 2),
]
assert circ.basis_rotation_instructions == expected
def test_add_verbatim_box_with_target(cnot):
circ = Circuit().add_verbatim_box(cnot, target=[10, 11])
expected = (Circuit().add_instruction(
Instruction(compiler_directives.StartVerbatimBox())).add_instruction(
Instruction(Gate.CNot(), [10, 11])).add_instruction(
Instruction(compiler_directives.EndVerbatimBox())))
assert circ == expected
def test_getters():
target = [0, 1]
operator = Gate.CNot()
instr = Instruction(operator, target)
assert instr.operator == operator
assert instr.target == QubitSet([0, 1])
def test_subroutine_returns_instruction():
@circuit.subroutine()
def foo(target):
return Instruction(Gate.H(), 0)
circ = Circuit().add(foo, 0)
assert circ == Circuit(Instruction(Gate.H(), 0))
def test_basis_rotation_instructions_multiple_result_types_different_hermitian_targets(
):
circ = (Circuit().h(0).cnot(0, 1).sample(
observable=Observable.Hermitian(matrix=np.array([[1, 0], [0, -1]])),
target=[1]).expectation(
observable=Observable.Hermitian(matrix=np.array([[0, 1], [1, 0]])),
target=[0]))
expected = [
Instruction(
Gate.Unitary(matrix=1.0 / np.sqrt(2.0) *
np.array([[1.0, 1.0], [1.0, -1.0]], dtype=complex)),
target=[0],
),
Instruction(Gate.Unitary(matrix=np.array([[0, 1], [1, 0]])),
target=[1]),
]
assert circ.basis_rotation_instructions == expected
def test_subroutine_returns_iterable():
@circuit.subroutine()
def foo(target):
for qubit in range(1):
yield Instruction(Gate.H(), qubit)
circ = Circuit().add(foo, 0)
assert circ == Circuit(Instruction(Gate.H(), 0))
def test_basis_rotation_instructions_multiple_result_types_tensor_product_probability(
):
circ = (Circuit().h(0).cnot(0, 1).cnot(1, 2).probability([0, 1]).sample(
observable=Observable.Z() @ Observable.Z() @ Observable.H(),
target=[0, 1, 2]).variance(observable=Observable.H(), target=[2]))
expected = [
Instruction(Gate.Ry(-np.pi / 4), 2),
]
assert circ.basis_rotation_instructions == expected
def test_subroutine_register():
# register a private method to avoid Sphinx docs picking this up
@circuit.subroutine(register=True)
def _foo(target):
"""this docstring will be added to the registered attribute"""
return Instruction(Gate.H(), target)
circ = Circuit()._foo(0)
assert circ == Circuit(Instruction(Gate.H(), 0))
assert Circuit._foo.__doc__ == _foo.__doc__
def test_basis_rotation_instructions_multiple_result_types_same_targets_hermitian(
):
circ = (Circuit().h(0).cnot(0, 1).sample(
observable=Observable.Hermitian(matrix=np.array([[1, 0], [0, -1]])),
target=[1]).expectation(observable=Observable.Hermitian(
matrix=np.array([[1, 0], [0, -1]])),
target=[1]))
expected = [
Instruction(Gate.Unitary(matrix=np.array([[0, 1], [1, 0]])),
target=[1])
]
assert circ.basis_rotation_instructions == expected
def test_subroutine_nested():
@circuit.subroutine()
def h(target):
for qubit in target:
yield Instruction(Gate.H(), qubit)
@circuit.subroutine()
def h_nested(target):
for qubit in target:
yield h(target)
circ = Circuit().add(h_nested, [0, 1])
expected = Circuit(
[Instruction(Gate.H(), j) for i in range(2) for j in range(2)])
assert circ == expected
def test_basis_rotation_instructions_multiple_result_types_tensor_product_hermitian(
):
circ = (Circuit().h(0).cnot(0, 1).cnot(1, 2).sample(
observable=Observable.Hermitian(matrix=np.array([[1, 0], [0, -1]]))
@ Observable.H(),
target=[0, 1],
).variance(
observable=Observable.Hermitian(matrix=np.array([[1, 0], [0, -1]]))
@ Observable.H(),
target=[0, 1],
).expectation(
observable=Observable.Hermitian(matrix=np.array([[0, 1], [1, 0]])),
target=[2]))
expected = [
Instruction(Gate.Unitary(matrix=np.array([[0, 1], [1, 0]])),
target=[0]),
Instruction(Gate.Ry(-np.pi / 4), 1),
Instruction(
Gate.Unitary(matrix=1.0 / np.sqrt(2.0) *
np.array([[1.0, 1.0], [1.0, -1.0]], dtype=complex)),
target=[2],
),
]
assert circ.basis_rotation_instructions == expected
def test_basis_rotation_instructions_tensor_product():
circ = (Circuit().h(0).cnot(0, 1).expectation(
observable=Observable.X() @ Observable.Y() @ Observable.Y(),
target=[0, 1, 2]))
expected = [
Instruction(Gate.H(), 0),
Instruction(Gate.Z(), 1),
Instruction(Gate.S(), 1),
Instruction(Gate.H(), 1),
Instruction(Gate.Z(), 2),
Instruction(Gate.S(), 2),
Instruction(Gate.H(), 2),
]
assert circ.basis_rotation_instructions == expected
def test_basis_rotation_instructions_all():
circ = Circuit().h(0).cnot(0, 1).sample(observable=Observable.Y())
expected = [
Instruction(Gate.Z(), 0),
Instruction(Gate.S(), 0),
Instruction(Gate.H(), 0),
Instruction(Gate.Z(), 1),
Instruction(Gate.S(), 1),
Instruction(Gate.H(), 1),
]
assert circ.basis_rotation_instructions == expected
def test_basis_rotation_instructions_identity():
circ = (Circuit().h(0).cnot(0, 1).cnot(1, 2).cnot(2, 3).cnot(
3, 4).expectation(observable=Observable.X(), target=[
0
]).expectation(observable=Observable.I(), target=[2]).expectation(
observable=Observable.I() @ Observable.Y(),
target=[1, 3]).expectation(observable=Observable.I(), target=[
0
]).expectation(observable=Observable.X() @ Observable.I(),
target=[1,
3]).expectation(observable=Observable.Y(),
target=[2]))
expected = [
Instruction(Gate.H(), 0),
Instruction(Gate.H(), 1),
Instruction(Gate.Z(), 2),
Instruction(Gate.S(), 2),
Instruction(Gate.H(), 2),
Instruction(Gate.Z(), 3),
Instruction(Gate.S(), 3),
Instruction(Gate.H(), 3),
]
assert circ.basis_rotation_instructions == expected
def bell_pair(prob):
return (Circuit().add_instruction(Instruction(
Gate.H(),
0)).add_instruction(Instruction(Gate.CNot(),
[0, 1])).add_result_type(prob))
def test_basis_rotation_instructions_target():
circ = Circuit().h(0).cnot(0, 1).expectation(observable=Observable.X(),
target=0)
expected = [Instruction(Gate.H(), 0)]
assert circ.basis_rotation_instructions == expected
def h_instr():
return Instruction(Gate.H(), 0)
def test_unitary_invalid_matrix(matrix):
Gate.Unitary(matrix=matrix)
def h():
return Circuit().add_instruction(Instruction(Gate.H(), 0))
