def test_sgate_int(self, n): """Test Sgate.power(n) method with n as integer.""" result = SGate().power(n) self.assertEqual(result.label, "s^%s" % n) self.assertIsInstance(result, UnitaryGate) self.assertEqual(Operator(result), Operator(SGate()).power(n))
def test_invariant2(self, n): """Test op^(n) * op^(-n) == I""" result = Operator(SGate()).power(n) & Operator(SGate()).power(-n) expected = Operator(eye(2)) self.assertEqual(len(result.data), len(expected.data)) self.assertEqual(result, expected)
def test_invariant1_int(self, n): """Test (op^(1/n))^(n) == op, integer n""" result = SGate().power(1 / n).power(n) self.assertEqual(result.label, "unitary^" + str(n)) self.assertEqual(len(result.definition), 1) self.assertIsInstance(result, Gate) self.assertTrue(Operator(SGate()), Operator(result))
def test_direct_root(self, degree): """Test nth root""" result = SGate().power(1 / degree) self.assertEqual(result.label, 's^' + str(1 / degree)) self.assertEqual(len(result.definition), 1) self.assertIsInstance(result, Gate) self.assertEqual(Operator(result).power(degree), Operator(SGate()))
def test_invariant2(self, n): """Test op^(n) * op^(-n) == I """ result = Operator(SGate().power(n)) @ Operator(SGate().power(-n)) expected = Operator(eye(2)) self.assertEqual(len(result.data), len(expected.data)) assert_array_almost_equal(result.data, expected.data)
def test_invariant1_int(self, n): """Test (op^(1/n))^(n) == op, integer n """ result = SGate().power(1 / n).power(n) self.assertEqual(result.label, 'unitary^' + str(n)) self.assertEqual(len(result.definition), 1) self.assertIsInstance(result, Gate) assert_allclose(SGate().to_matrix(), result.definition[0][0].to_matrix())
def test_sgate_int(self, n): """Test Sgate.power(n) method with n as integer. """ result = SGate().power(n) self.assertEqual(result.label, 's^%s' % n) self.assertIsInstance(result, UnitaryGate) assert_array_almost_equal(result.to_matrix(), matrix_power(SGate().to_matrix(), n))
def test_float_gt_one(self, exponent): """Test greater-than-one exponents""" result = SGate().power(exponent) self.assertEqual(result.label, "s^" + str(exponent)) self.assertEqual(len(result.definition), 1) self.assertIsInstance(result, Gate) # SGate().to_matrix() is diagonal so `**` is equivalent. self.assertEqual(Operator(SGate().to_matrix() ** exponent), Operator(result))
def test_sgate_float(self, n): """Test Sgate.power(<float>) method. """ result = SGate().power(n) expected = self.results[n] self.assertEqual(result.label, 's^%s' % n) self.assertIsInstance(result, UnitaryGate) assert_array_almost_equal(result.to_matrix(), expected)
def test_direct_root(self, degree): """Test nth root""" result = SGate().power(1 / degree) self.assertEqual(result.label, 's^' + str(1 / degree)) self.assertEqual(len(result.definition), 1) self.assertIsInstance(result, Gate) assert_allclose( matrix_power(result.definition[0][0].to_matrix(), degree), SGate().to_matrix())
def test_float_gt_one(self, exponent): """Test greater-than-one exponents """ result = SGate().power(exponent) self.assertEqual(result.label, 's^' + str(exponent)) self.assertEqual(len(result.definition), 1) self.assertIsInstance(result, Gate) # SGate().to_matrix() is diagonal so `**` is equivalent. assert_allclose(SGate().to_matrix()**exponent, result.definition[0][0].to_matrix())
def test_standard_1Q_one(self): """Test standard gate.repeat(1) method. """ qr = QuantumRegister(1, 'qr') expected_circ = QuantumCircuit(qr) expected_circ.append(SGate(), [qr[0]]) expected = expected_circ.to_instruction() result = SGate().repeat(1) self.assertEqual(result.name, 's*1') self.assertEqual(result.definition, expected.definition) self.assertIsInstance(result, Gate)
def generate_unitary_gate(gate_name: str) -> Gate: # Rx, Ry and Rz gates that look like 'Rx(pi/2) if gate_name[0] == 'R' and gate_name[2] == '(': angle = parse_angle(gate_name[3:-1]) if gate_name[1] == 'x': return RXGate(angle) elif gate_name[1] == 'y': return RYGate(angle) elif gate_name[1] == 'z': return RZGate(angle) else: unitary_gates = { "X": XGate(), "Y": YGate(), "S": SGate(), "Z": ZGate(), "H": HGate(), "T": TGate(), "I": IGate(), "W": WGate(), "Rz1": RZGate(-3 * np.pi / 8), "Rz2": RZGate(np.pi / 2), "Ry1": RYGate(np.pi / 2) } return unitary_gates[gate_name]
def test_generate_unitary_gate(): assert generate_unitary_gate("X") == XGate() assert generate_unitary_gate("Y") == YGate() assert generate_unitary_gate("S") == SGate() assert generate_unitary_gate("Z") == ZGate() assert generate_unitary_gate("H") == HGate() assert generate_unitary_gate("T") == TGate() assert generate_unitary_gate("I") == IdGate() for i in np.arange(-10, -1, 0.1): for j in np.arange(1, 10, 0.1): # Rx Gates assert generate_unitary_gate(f'Rx(pi*{j})') == RXGate(np.pi * j) assert generate_unitary_gate(f'Rx({i}/ {j}*pi)') == RXGate(i / j * np.pi) assert generate_unitary_gate(f'Rx( {i}*{j}/pi )') == RXGate(i * j / np.pi) assert generate_unitary_gate(f'Rx( {i} / {j}/pi)') == RXGate( i / j / np.pi) # Ry Gates assert generate_unitary_gate(f'Ry(pi*{j})') == RYGate(np.pi * j) assert generate_unitary_gate(f'Ry({i}/ {j}*pi)') == RYGate(i / j * np.pi) assert generate_unitary_gate(f'Ry( {i}*{j}/pi )') == RYGate(i * j / np.pi) assert generate_unitary_gate(f'Ry( {i} / {j}/pi)') == RYGate( i / j / np.pi) # Rz Gates assert generate_unitary_gate(f'Rz(pi*{j})') == RZGate(np.pi * j) assert generate_unitary_gate(f'Rz({i}/ {j}*pi)') == RZGate(i / j * np.pi) assert generate_unitary_gate(f'Rz( {i}*{j}/pi )') == RZGate(i * j / np.pi) assert generate_unitary_gate(f'Rz( {i} / {j}/pi)') == RZGate( i / j / np.pi)
def test_sgate_float(self, n): """Test Sgate.power(<float>) method.""" result = SGate().power(n) expected = self.results[n] self.assertEqual(result.label, "s^%s" % n) self.assertIsInstance(result, UnitaryGate) self.assertEqual(Operator(result), Operator(expected))
def _gen_lookup_table(self): op1 = RZGate(-3 * np.pi / 8) op2 = RYGate(np.pi / 2) op3 = RZGate(np.pi / 2) result = {"X": XGate(), "Y": YGate(), "S": SGate(), "Z": ZGate(), "H": HGate(), "T": TGate(), "W": self._gen_w_gate(), "Rz1": RZGate(-3 * np.pi / 8), "Rz2": RZGate(np.pi/2), "Ry1": RYGate(np.pi/2)} return result
def test_standard_sqrt(self): """Test standard Gate.power(1/2) method.""" expected = array([[1, 0], [0, 0.70710678118 + 0.70710678118j]], dtype=complex) result = SGate().power(1 / 2) self.assertEqual(result.label, "s^0.5") self.assertEqual(len(result.definition), 1) self.assertIsInstance(result, Gate) self.assertEqual(Operator(result), Operator(expected))
def test_minus_zero_two(self, exponent=-0.2): """Test Sgate^(-0.2)""" result = SGate().power(exponent) self.assertEqual(result.label, 's^' + str(exponent)) self.assertEqual(len(result.definition), 1) self.assertIsInstance(result, Gate) assert_allclose( array([[1, 0], [0, 0.95105652 - 0.30901699j]], dtype=complex), result.definition[0][0].to_matrix())
def test_minus_zero_two(self, exponent=-0.2): """Test Sgate^(-0.2)""" result = SGate().power(exponent) self.assertEqual(result.label, "s^" + str(exponent)) self.assertEqual(len(result.definition), 1) self.assertIsInstance(result, Gate) self.assertEqual( Operator(array([[1, 0], [0, 0.95105652 - 0.30901699j]], dtype=complex)), Operator(result), )
def test_standard_sqrt(self): """Test standard Gate.power(1/2) method. """ expected = array([[1, 0], [0, 0.70710678118 + 0.70710678118j]], dtype=complex) result = SGate().power(1 / 2) self.assertEqual(result.label, 's^0.5') self.assertEqual(len(result.definition), 1) self.assertIsInstance(result, Gate) assert_allclose(result.definition[0][0].to_matrix(), expected)
def test_unroller_one(self): """Test unrolling gate.repeat(1). """ qr = QuantumRegister(1, 'qr') circuit = QuantumCircuit(qr) circuit.append(SGate().repeat(1), [qr[0]]) result = PassManager(Unroller('u3')).run(circuit) expected = QuantumCircuit(qr) expected.append(U3Gate(0, 0, pi / 2), [qr[0]]) self.assertEqual(result, expected)
def test_standard_1Q_minus_one(self): """Test standard 2Q gate.repeat(-1) method. Raises, since n<1. """ with self.assertRaises(CircuitError) as context: _ = SGate().repeat(-1) self.assertIn('strictly positive integer', str(context.exception))
} """ definition = [] q = QuantumRegister(1, "q") rule = [(RZGate(-3 * np.pi / 8), [q[0]], []), (RZGate(np.pi / 2), [q[0]], []), (RYGate(np.pi / 2), [q[0]], [])] for inst in rule: definition.append(inst) self.definition = definition unitary_gates = { "X": XGate(), "Y": YGate(), "S": SGate(), "Z": ZGate(), "H": HGate(), "T": TGate(), "I": IdGate(), "W": WGate(), "Rz1": RZGate(-3 * np.pi / 8), "Rz2": RZGate(np.pi / 2), "Ry1": RYGate(np.pi / 2) } class Protocol(Enum): """ The various different quantum/classical game theory game protocols """
def test_noiseless_s_gate_standard_basis(self): basis = default_gateset_basis() basis.add_gate(SGate()) self.run_test_on_basis_and_noise(gateset_basis=basis)
def test_standard_no_int(self): """Test standard Gate.repeat(2/3) method. Raises, since n is not int. """ with self.assertRaises(CircuitError) as context: _ = SGate().repeat(2 / 3) self.assertIn('strictly positive integer', str(context.exception))