def test_initializer_and_getters(self):
# preparation work
focus_in = [_random_operation(1, 2), _random_operation(2, 3)]
context_in = transform.TransformationContext(circuit.Circuit(5, None),
circuit.Circuit(5, None),
circuit.Circuit(5, None))
locations_in = (0, 1)
perform_rule = lambda operation_in: [operation_in]
rule_id = object()
# initialize the PairTransformation
transformation = transform.PairTransformation(
attention_circ=transform.AttentionCircuit(focus=focus_in,
context=context_in,
locations=locations_in),
perform_rule=perform_rule,
rule_id=rule_id)
# check type and value transformation.focus()
focus_out = transformation.focus()
self.assertIs(type(focus_out), tuple)
self.assertTrue(_elementwise_is(focus_out, focus_in))
# check transformation.context()
self.assertIs(transformation.context(), context_in)
# check type and value transformation.locations()
locations_out = transformation.locations()
self.assertIs(type(locations_out), tuple)
self.assertTrue(_elementwise_is(locations_out, locations_in))
# check transformation.context()
self.assertIs(transformation.rule_id(), rule_id)
def test_initializer_circ_type_error(self):
circ = circuit.Circuit(5, None)
perform_rule = lambda operation_in: [operation_in]
with self.assertRaisesRegex(
TypeError,
r'attention_circ is not an AttentionCircuit \(found type: Circuit\)'):
transform.PairTransformation(circ, perform_rule, None)
def transformations_from_scanner(self, scanner):
# implements abstract method from parent class TransformationRule
for attention_circ in scanner.operation_pairs():
if len(attention_circ) != 2:
raise RuntimeError() # cmp. TODO at the beginning of this file
operation_first, operation_second = attention_circ.focus()
if self.accept(operation_first, operation_second):
yield transform.PairTransformation(attention_circ, self.perform, self)
def test_initializer_focus_size_error(self):
attention_circ = transform.AttentionCircuit(
focus=[_random_operation(2)],
context=transform.TransformationContext(circuit.Circuit(5, None),
circuit.Circuit(5, None),
circuit.Circuit(5, None)))
perform_rule = lambda operation_in: [operation_in]
with self.assertRaisesRegex(
ValueError,
r'focus of attention_circ for PairTransformation must have size 2'
r' \(found: 1\)'):
transform.PairTransformation(attention_circ, perform_rule, None)
def test_initializer_redundant_transformation_error(self):
attention_circ = transform.AttentionCircuit(
focus=[_random_operation(2, 3),
_random_operation(5)],
context=transform.TransformationContext(circuit.Circuit(5, None),
circuit.Circuit(5, None),
circuit.Circuit(5, None)))
perform_rule = lambda operation_in: [operation_in]
with self.assertRaisesRegex(
ValueError,
r'transformation redundant because operations trivially commute'
):
transform.PairTransformation(attention_circ, perform_rule, None)
def test_perform(self):
# preparation work
num_qubits = 5
operation_before1 = _random_operation(0)
operation_before2 = _random_operation(1)
operation_before3 = _random_operation(2)
operation_between1 = _random_operation(0)
operation_between2 = _random_operation(1)
operation_after = _random_operation(1)
operation_in1 = _random_operation(1)
operation_in2 = _random_operation(1)
operations_out_first1 = _random_operation(1)
operations_out_first2 = _random_operation(1)
operations_out_second1 = _random_operation(1)
operations_out_second2 = _random_operation(1)
operations_out_second3 = _random_operation(1)
# define the transformation rule
def perform_rule(operation_first, operation_second):
# check operation_first and operation_second
self.assertIs(operation_first, operation_in1)
self.assertIs(operation_second, operation_in2)
# return the modified operations
operations_out_first = [
operations_out_first1,
operations_out_first2
]
operations_out_second = [
operations_out_second1,
operations_out_second2,
operations_out_second3
]
return operations_out_first, operations_out_second
# initialize the PointTransformation
transformation = transform.PairTransformation(
attention_circ=transform.AttentionCircuit(
focus=[operation_in1, operation_in2],
context=transform.TransformationContext(
circuit.Circuit(num_qubits, [
operation_before1,
operation_before2,
operation_before3
]),
circuit.Circuit(num_qubits, [
operation_between1,
operation_between2
]),
circuit.Circuit(num_qubits, [
operation_after
])
)
),
perform_rule=perform_rule,
rule_id=None
)
# call the method to be tested
circ_out = transformation.perform()
# check type for circ_out
self.assertIs(type(circ_out), circuit.Circuit)
# check the value for circ_out
self.assertTrue(_elementwise_is(
circ_out.get_operation_sequence(),
[
operation_before1,
operation_before2,
operation_before3,
operations_out_first1,
operations_out_first2,
operation_between1,
operation_between2,
operations_out_second1,
operations_out_second2,
operations_out_second3,
operation_after
]
))
