def __init__(self, gate: raw_types.Gate,
qubits: Sequence[raw_types.Qid]) -> None:
"""
Args:
gate: The gate to apply.
qubits: The qubits to operate on.
"""
gate.validate_args(qubits)
self._gate = gate
self._qubits = tuple(qubits)
def __init__(self, gate: raw_types.Gate,
qubits: Sequence[raw_types.Qid]) -> None:
"""
Args:
gate: the gate to apply
qubits: lists of lists of qubits to apply the gate to.
"""
if gate.num_qubits() != 1:
raise ValueError("gate must be a single qubit gate")
if len(set(qubits)) != len(qubits):
raise ValueError("repeated qubits are not allowed")
for qubit in qubits:
gate.validate_args([qubit])
self._gate = gate
self._qubits = tuple(qubits)
def test_transform_leaves():
gs = [Gate() for _ in range(10)]
operations = [
Operation(gs[i], [NamedQubit(str(i))])
for i in range(10)
]
expected = [
Operation(gs[i], [NamedQubit(str(i) + 'a')])
for i in range(10)
]
def move_left(op):
return Operation(op.gate,
[NamedQubit(q.name + 'a') for q in op.qubits])
def move_tree_left_freeze(root):
return op_tree.freeze_op_tree(
op_tree.transform_op_tree(root, move_left))
# Empty tree.
assert move_tree_left_freeze([[[]]]) == (((),),)
# Just an item.
assert move_tree_left_freeze(operations[0]) == expected[0]
# Flat list.
assert move_tree_left_freeze(operations) == tuple(expected)
# Tree.
assert (
move_tree_left_freeze(
(operations[0], operations[1:5], operations[5:])) ==
(expected[0], tuple(expected[1:5]), tuple(expected[5:])))
def test_freeze_op_tree():
operations = [
Operation(Gate(), [NamedQubit(str(i))])
for i in range(10)
]
# Empty tree.
assert op_tree.freeze_op_tree([[[]]]) == (((),),)
# Just an item.
assert op_tree.freeze_op_tree(operations[0]) == operations[0]
# Flat list.
assert op_tree.freeze_op_tree(operations) == tuple(operations)
# Tree.
assert (
op_tree.freeze_op_tree(
(operations[0], (operations[i] for i in range(1, 5)),
operations[5:])) ==
(operations[0], tuple(operations[1:5]), tuple(operations[5:])))
# Bad trees.
with pytest.raises(TypeError):
op_tree.freeze_op_tree(None)
with pytest.raises(TypeError):
op_tree.freeze_op_tree(5)
with pytest.raises(TypeError):
_ = op_tree.freeze_op_tree([operations[0], (4,)])
def test_flatten_op_tree():
operations = [
Operation(Gate(), [NamedQubit(str(i))])
for i in range(10)
]
# Empty tree.
assert list(op_tree.flatten_op_tree([[[]]])) == []
# Just an item.
assert list(op_tree.flatten_op_tree(operations[0])) == operations[:1]
# Flat list.
assert list(op_tree.flatten_op_tree(operations)) == operations
# Tree.
assert list(op_tree.flatten_op_tree((operations[0],
operations[1:5],
operations[5:]))) == operations
# Bad trees.
with pytest.raises(TypeError):
_ = list(op_tree.flatten_op_tree(None))
with pytest.raises(TypeError):
_ = list(op_tree.flatten_op_tree(5))
with pytest.raises(TypeError):
_ = list(op_tree.flatten_op_tree([operations[0], (4,)]))
def test_transform_internal_nodes():
operations = [
Operation(Gate(), [NamedQubit(str(2 * i))])
for i in range(10)
]
def skip_first(op):
first = True
for item in op:
if not first:
yield item
first = False
def skip_tree_freeze(root):
return op_tree.freeze_op_tree(
op_tree.transform_op_tree(root, iter_transformation=skip_first))
# Empty tree.
assert skip_tree_freeze([[[]]]) == ()
assert skip_tree_freeze([[[]], [[], []]]) == (((),),)
# Just an item.
assert skip_tree_freeze(operations[0]) == operations[0]
# Flat list.
assert skip_tree_freeze(operations) == tuple(operations[1:])
# Tree.
assert (
skip_tree_freeze((operations[1:5], operations[0], operations[5:])) ==
(operations[0], tuple(operations[6:])))
def test_transform_bad_tree():
with pytest.raises(TypeError):
_ = list(op_tree.transform_op_tree(None))
with pytest.raises(TypeError):
_ = list(op_tree.transform_op_tree(5))
with pytest.raises(TypeError):
_ = list(op_tree.flatten_op_tree(op_tree.transform_op_tree([
Operation(Gate(), [QubitId()]), (4,)
])))
def _is_compatible(self, gate: raw_types.Gate) -> bool:
return (self.num_qubits() is None
or self.num_qubits() == gate.num_qubits())
def with_gate(self, new_gate: raw_types.Gate) -> 'raw_types.Operation':
return new_gate.on(*self.qubits)
def with_gate(self, new_gate: raw_types.Gate) -> 'GateOperation':
return new_gate.on(*self.qubits)
