def _random_double_partial_cz_effect(): return linalg.dot( linalg.kron(testing.random_unitary(2), testing.random_unitary(2)), np.diag([1, 1, 1, cmath.exp(2j * random.random() * np.pi)]), linalg.kron(testing.random_unitary(2), testing.random_unitary(2)), np.diag([1, 1, 1, cmath.exp(2j * random.random() * np.pi)]), linalg.kron(testing.random_unitary(2), testing.random_unitary(2)))
def _random_double_full_cz_effect(): return linalg.dot( linalg.kron(testing.random_unitary(2), testing.random_unitary(2)), ops.CZ.matrix(), linalg.kron(testing.random_unitary(2), testing.random_unitary(2)), ops.CZ.matrix(), linalg.kron(testing.random_unitary(2), testing.random_unitary(2)))
def _merge_into_matrix_gate_op( qubit: ops.QubitId, operations: Iterable[ops.Operation]) -> ops.Operation: matrix = linalg.dot( np.eye(2, dtype=np.complex128), *(reversed([protocols.unitary(op) for op in operations]))) return ops.SingleQubitMatrixGate(matrix).on(qubit)
def _unitary_(self) -> np.ndarray: # Source: https://arxiv.org/abs/1707.03429 (equation 2) operations = [ ops.Rz(self.phi * np.pi), ops.Ry(self.theta * np.pi), ops.Rz(self.lmda * np.pi), ] return linalg.dot(*map(protocols.unitary, operations))
def _merge_rotations( self, qubit: ops.QubitId, operations: Iterable[ops.Operation]) -> List[ops.Operation]: matrix = linalg.dot( np.eye(2, dtype=np.complex128), *reversed([protocols.unitary(op) for op in operations])) out_gates = single_qubit_matrix_to_native_gates(matrix, self.tolerance) return [gate(qubit) for gate in out_gates]
def test_single_qubit_matrix_to_native_gates_fuzz_half_turns_always_one_gate( pre_turns, post_turns): intended_effect = linalg.dot( ops.RotZGate(half_turns=2 * pre_turns).matrix(), ops.X.matrix(), ops.RotZGate(half_turns=2 * post_turns).matrix()) gates = decompositions.single_qubit_matrix_to_native_gates( intended_effect, tolerance=0.0001) assert len(gates) == 1 assert_gates_implement_unitary(gates, intended_effect)
def recompose_kak(g, a, v, b) -> np.ndarray: a1, a0 = a x, y, z = v b1, b0 = b xx = linalg.kron(X, X) yy = linalg.kron(Y, Y) zz = linalg.kron(Z, Z) a = linalg.kron(a1, a0) m = linalg.map_eigenvalues(xx * x + yy * y + zz * z, lambda e: np.exp(1j * e)) b = linalg.kron(b1, b0) return linalg.dot(a, m, b) * g
def _rewrite(self, operations: List[ops.Operation]) -> Optional[ops.OP_TREE]: if not operations: return None q = operations[0].qubits[0] # Custom rewriter? if self._rewriter is not None: return self._rewriter(operations) unitary = linalg.dot(*(protocols.unitary(op) for op in operations[::-1])) # Custom synthesizer? if self._synthesizer is not None: return self._synthesizer(q, unitary) # Just use the default. return ops.MatrixGate(unitary).on(q)