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 ] ))