def test_kraus_to_ptm_qubit(self): p_damp = 0.5 damp_kraus_mat = np.array([[[1, 0], [0, np.sqrt(1 - p_damp)]], [[0, np.sqrt(p_damp)], [0, 0]]]) gm_qubit_basis = (bases.gell_mann(2), ) gm_two_qubit_basis = gm_qubit_basis * 2 damp_op = Operation.from_kraus(damp_kraus_mat, gm_qubit_basis) damp_ptm = damp_op.ptm(gm_qubit_basis) expected_mat = np.array([[1, 0, 0, 0], [0, np.sqrt(1 - p_damp), 0, 0], [0, 0, np.sqrt(1 - p_damp), 0], [p_damp, 0, 0, 1 - p_damp]]) assert np.allclose(damp_ptm, expected_mat) with pytest.raises(ValueError, match=r'.* must be list-like, .*'): damp_op.set_bases(bases.gell_mann(2), bases.gell_mann(2)) cz_kraus_mat = np.diag([1, 1, 1, -1]) cz = Operation.from_kraus(cz_kraus_mat, gm_two_qubit_basis) cz_ptm = cz.ptm(gm_two_qubit_basis) assert cz_ptm.shape == (4, 4, 4, 4) cz_ptm = cz_ptm.reshape((16, 16)) assert np.all(cz_ptm.round(3) <= 1) assert np.all(cz_ptm.round(3) >= -1) assert np.isclose(np.sum(cz_ptm[0, :]), 1) assert np.isclose(np.sum(cz_ptm[:, 0]), 1)
def test_lindblad_singlequbit(self): ham = random_hermitian_matrix(2, seed=56) lindblad_ops = np.array([ [[0, 0.1], [0, 0]], [[0, 0], [0, 0.33]], ]) t1 = 10 t2 = 25 b1 = (bases.general(2), ) b2 = (bases.gell_mann(2), ) op1 = Operation.from_lindblad_form(t1, b1, b2, hamiltonian=ham, lindblad_ops=lindblad_ops) op2 = Operation.from_lindblad_form(t2, b2, b1, hamiltonian=ham, lindblad_ops=lindblad_ops) op = Operation.from_lindblad_form(t1 + t2, b1, hamiltonian=ham, lindblad_ops=lindblad_ops) dm = random_hermitian_matrix(2, seed=3) state1 = PauliVector.from_dm(dm, b1) state2 = PauliVector.from_dm(dm, b1) op1(state1, 0) op2(state1, 0) op(state2, 0) assert np.allclose(state1.to_pv(), state2.to_pv())
def test_kraus_to_ptm_qubit(self): p_damp = 0.5 damp_kraus_mat = np.array( [[[1, 0], [0, np.sqrt(1 - p_damp)]], [[0, np.sqrt(p_damp)], [0, 0]]]) gm_qubit_basis = (bases.gell_mann(2),) gm_two_qubit_basis = gm_qubit_basis + gm_qubit_basis damp_op = Operation.from_kraus(damp_kraus_mat, 2) damp_ptm = damp_op.set_bases(bases_in=gm_qubit_basis, bases_out=gm_qubit_basis).ptm expected_mat = np.array([[1, 0, 0, 0], [0, np.sqrt(1-p_damp), 0, 0], [0, 0, np.sqrt(1-p_damp), 0], [p_damp, 0, 0, 1-p_damp]]) assert np.allclose(damp_ptm, expected_mat) with pytest.raises(ValueError, match=r'.* should be a list, .*'): damp_op.set_bases(bases.gell_mann(2), bases.gell_mann(2)) cz_kraus_mat = np.diag([1, 1, 1, -1]) cz = Operation.from_kraus(cz_kraus_mat, 2).set_bases(gm_two_qubit_basis, gm_two_qubit_basis) assert cz.ptm.shape == (4, 4, 4, 4) cz_ptm = cz.ptm.reshape((16, 16)) assert np.all(cz_ptm.round(3) <= 1) assert np.all(cz_ptm.round(3) >= -1) assert np.isclose(np.sum(cz_ptm[0, :]), 1) assert np.isclose(np.sum(cz_ptm[:, 0]), 1)
def test_lindblad_time_inverse(self): ham = random_hermitian_matrix(2, seed=4) b = (bases.general(2), ) op_plus = Operation.from_lindblad_form(20, b, hamiltonian=ham) op_minus = Operation.from_lindblad_form(20, b, hamiltonian=-ham) dm = random_hermitian_matrix(2, seed=5) state = PauliVector.from_dm(dm, b) op_plus(state, 0) op_minus(state, 0) assert np.allclose(state.to_dm(), dm)
def test_lindblad_two_qubit(self): b = (bases.general(2), ) id = np.array([[1, 0], [0, 1]]) ham1 = random_hermitian_matrix(2, seed=6) ham2 = random_hermitian_matrix(2, seed=7) ham = np.kron(ham1, id).reshape(2, 2, 2, 2) + \ np.kron(id, ham2).reshape(2, 2, 2, 2) dm = random_hermitian_matrix(4, seed=3) op1 = Operation.from_lindblad_form(25, b, hamiltonian=ham1) op2 = Operation.from_lindblad_form(25, b, hamiltonian=ham2) op = Operation.from_lindblad_form(25, b * 2, hamiltonian=ham) state1 = PauliVector.from_dm(dm, b * 2) state2 = PauliVector.from_dm(dm, b * 2) op1(state1, 0) op2(state1, 1) op(state2, 0, 1) assert np.allclose(state1.to_pv(), state2.to_pv()) ops1 = np.array([ [[0, 0.1], [0, 0]], [[0, 0], [0, 0.33]], ]) ops2 = np.array([ [[0, 0.15], [0, 0]], [[0, 0], [0, 0.17]], ]) ops = [np.kron(op, id).reshape(2, 2, 2, 2) for op in ops1] +\ [np.kron(id, op).reshape(2, 2, 2, 2) for op in ops2] op1 = Operation.from_lindblad_form(25, b, lindblad_ops=ops1) op2 = Operation.from_lindblad_form(25, b, lindblad_ops=ops2) op = Operation.from_lindblad_form(25, b * 2, lindblad_ops=ops) state1 = PauliVector.from_dm(dm, b * 2) state2 = PauliVector.from_dm(dm, b * 2) op1(state1, 0) op2(state1, 1) op(state2, 0, 1) assert np.allclose(state1.to_pv(), state2.to_pv()) op1 = Operation.from_lindblad_form(25, b, hamiltonian=ham1, lindblad_ops=ops1) op2 = Operation.from_lindblad_form(25, b, hamiltonian=ham2, lindblad_ops=ops2) op = Operation.from_lindblad_form(25, b * 2, hamiltonian=ham, lindblad_ops=ops) state1 = PauliVector.from_dm(dm, b * 2) state2 = PauliVector.from_dm(dm, b * 2) op1(state1, 0) op2(state1, 1) op(state2, 0, 1) assert np.allclose(state1.to_pv(), state2.to_pv())
def phase_damping(total_rate=None, *, x_deph_rate=None, y_deph_rate=None, z_deph_rate=None): if total_rate is not None: kraus = np.array([[[1, 0], [0, np.sqrt(1 - total_rate)]], [[0, 0], [0, np.sqrt(total_rate)]]]) return Operation.from_kraus(kraus, 2) else: if None in (x_deph_rate, y_deph_rate, z_deph_rate): raise ValueError( "Either the total_rate or the dephasing rates along each of " "the three axis must be provided") ptm = np.diag( [1, 1 - x_deph_rate, 1 - y_deph_rate, 1 - z_deph_rate]) return Operation.from_ptm(ptm, (bases.gell_mann(2),))
def test_kraus_to_ptm_errors(self): qutrit_basis = (bases.general(3), ) cz_kraus_mat = np.diag([1, 1, 1, -1]) kraus_op = Operation.from_kraus(cz_kraus_mat, 2) wrong_dim_kraus = np.random.random((4, 4, 2, 2)) with pytest.raises(ValueError): _ = Operation.from_kraus(wrong_dim_kraus, 2) not_sqr_kraus = np.random.random((4, 2, 3)) with pytest.raises(ValueError): _ = Operation.from_kraus(not_sqr_kraus, 2) with pytest.raises(ValueError): _ = Operation.from_kraus(cz_kraus_mat, 3) with pytest.raises(ValueError): _ = kraus_op.set_bases(qutrit_basis + qutrit_basis)
def amp_damping(total_rate=None, *, exc_rate=None, damp_rate=None): if total_rate is not None: kraus = np.array([[[1, 0], [0, np.sqrt(1 - total_rate)]], [[0, np.sqrt(total_rate)], [0, 0]]]) return Operation.from_kraus(kraus, 2) else: if None in (exc_rate, damp_rate): raise ValueError( "Either the total_rate or both the exc_rate and damp_rate " "must be provided") comb_rate = exc_rate + damp_rate ptm = np.array([[1, 0, 0, 0], [0, np.sqrt((1 - comb_rate)), 0, 0], [0, 0, np.sqrt((1 - comb_rate)), 0], [2 * damp_rate - comb_rate, 0, 0, 1 - comb_rate]]) return Operation.from_ptm(ptm, (bases.gell_mann(2), ))
def test_kraus_to_ptm_errors(self): qutrit_basis = (bases.general(3),) cz_kraus_mat = np.diag([1, 1, 1, -1]) kraus_op = Operation.from_kraus(cz_kraus_mat, 2) wrong_dim_kraus = np.random.random((4, 4, 2, 2)) with pytest.raises(ValueError): _ = Operation.from_kraus(wrong_dim_kraus, 2) not_sqr_kraus = np.random.random((4, 2, 3)) with pytest.raises(ValueError): _ = Operation.from_kraus(not_sqr_kraus, 2) with pytest.raises(ValueError): _ = Operation.from_kraus(cz_kraus_mat, 3) with pytest.raises(ValueError): _ = kraus_op.set_bases(qutrit_basis + qutrit_basis)
def phase_flipping(flip_rate): # This is actually equivalent to the phase damping matrix = np.array([ np.sqrt(flip_rate) * _PAULI["I"], np.sqrt(1 - flip_rate) * _PAULI["Z"] ]) return Operation.from_kraus(matrix, 2)
def phase_damping(total_rate=None, *, x_deph_rate=None, y_deph_rate=None, z_deph_rate=None): if total_rate is not None: kraus = np.array([[[1, 0], [0, np.sqrt(1 - total_rate)]], [[0, 0], [0, np.sqrt(total_rate)]]]) return Operation.from_kraus(kraus, 2) else: if None in (x_deph_rate, y_deph_rate, z_deph_rate): raise ValueError( "Either the total_rate or the dephasing rates along each of " "the three axis must be provided") ptm = np.diag([1, 1 - x_deph_rate, 1 - y_deph_rate, 1 - z_deph_rate]) return Operation.from_ptm(ptm, (bases.gell_mann(2), ))
def test_create_timed_model(): basis = (bases.general(2), ) class SampleModel(Model): dim = 2 @Model.gate(duration=20) def rotate_y(self, qubit): return ( self.wait(qubit, 10), ParametrizedOperation(lib.rotate_y, basis), self.wait(qubit, 10), ) @Model.gate(duration='t_twoqubit') def cphase(self, qubit_static, qubit_fluxed): return ( self.wait(qubit_static, 0.5 * self.p('t_twoqubit')), self.wait(qubit_fluxed, 0.5 * self.p('t_twoqubit')), lib.cphase(pi).at(qubit_static, qubit_fluxed), self.wait(qubit_static, 0.5 * self.p('t_twoqubit')), self.wait(qubit_fluxed, 0.5 * self.p('t_twoqubit')), ) @Model.gate(duration=lambda qubit, setup: 600 if qubit == 'D0' else 400) def strange_duration_gate(self, qubit): return lib.rotate_y(pi) @staticmethod def _filter_wait_placeholders(operation): return Operation.from_sequence([ unit for unit in operation.units() if not isinstance(unit.operation, WaitPlaceholder) ]) def finalize(self, circuit, bases_in=None): return circuit.finalize([self._filter_wait_placeholders], bases_in) sample_setup = Setup(""" setup: - t_twoqubit: 40 """) m = SampleModel(sample_setup) cnot = m.rotate_y('D0', angle=0.5*pi) + m.cphase('D0', 'D1') + \ m.rotate_y('D0', angle=-0.5*pi) cnot = m.finalize(cnot) assert cnot.operation.ptm(basis * 2, basis * 2) == approx( Operation.from_sequence( lib.rotate_y(0.5 * pi).at(0), lib.cphase(pi).at(0, 1), lib.rotate_y(-0.5 * pi).at(0), ).ptm(basis * 2, basis * 2)) gate1 = m.strange_duration_gate('D0') assert gate1.duration == 600 gate2 = m.strange_duration_gate('D1') assert gate2.duration == 400
def rotate_euler(phi, theta, lamda): """A perfect single qubit rotation described by three Euler angles. Unitary operation, that corresponds to this rotation, is: .. math:: U = R_Z(\\phi) \\cdot R_X(\\theta) \\cdot R_Z(\\lambda) Parameters ---------- phi, theta, lamda: float Euler rotation angles in radians. Returns ------- Operation An operation, that corresponds to the rotation. """ exp_phi, exp_lambda = np.exp(1j * phi), np.exp(1j * lamda) sin_theta, cos_theta = np.sin(theta / 2), np.cos(theta / 2) matrix = np.array([ [cos_theta, -1j * exp_lambda * sin_theta, 0], [-1j * exp_phi * sin_theta, exp_phi * exp_lambda * cos_theta, 0], [0, 0, 1]]) return Operation.from_kraus(matrix, 3)
def amp_damping(p0_up, p1_up, p1_down, p2_down): """ A gate, that excites or relaxes a qubit with a certain probability. Parameters ---------- p0_up : float Probability to excite to state 1, being in the state 0 p1_up : float Probability to excite to state 2, being in the state 1 p1_down : float Probability to relax to state 0, being in the state 1 p2_down : float Probability to relax to state 1, being in the state 2 Returns ------- quantumsim.operation._PTMOperation """ ptm = np.identity(9, dtype=float) ptm[:3, :3] = [[1. - p0_up, p1_down, 0.], [p0_up, 1. - p1_down - p1_up, p2_down], [0., p1_up, 1 - p2_down]] basis = (bases.general(3), ) return Operation.from_ptm(ptm, basis, basis)
def rotate_euler(phi, theta, lamda): """A perfect single qubit rotation described by three Euler angles. Unitary operation, that corresponds to this rotation, is: .. math:: U = R_Z(\\phi) \\cdot R_X(\\theta) \\cdot R_Z(\\lambda) Parameters ---------- phi, theta, lamda: float Euler rotation angles in radians. Returns ------- Operation An operation, that corresponds to the rotation. """ exp_phi, exp_lambda = np.exp(1j * phi), np.exp(1j * lamda) sin_theta, cos_theta = np.sin(theta / 2), np.cos(theta / 2) matrix = np.array([ [cos_theta, -1j * exp_lambda * sin_theta], [-1j * exp_phi * sin_theta, exp_phi * exp_lambda * cos_theta]]) return Operation.from_kraus(matrix, 2)
def test_chain_compile_leaking(self): b = bases.general(3) chain0 = Operation.from_sequence( lib3.rotate_x(0.5 * np.pi).at(2), lib3.cphase(leakage_rate=0.1).at(0, 2), lib3.cphase(leakage_rate=0.1).at(1, 2), lib3.rotate_x(-0.75 * np.pi).at(2), lib3.rotate_x(0.25 * np.pi).at(2), ) b0 = b.subbasis([0]) b01 = b.subbasis([0, 1]) b0134 = b.subbasis([0, 1, 3, 4]) chain1 = chain0.compile((b0, b0, b0134), (b, b, b)) assert isinstance(chain1, _Chain) # Ancilla is not leaking here anc_basis = chain1._units[1].operation.bases_out[1] for label in anc_basis.labels: assert '2' not in label chain2 = chain0.compile((b01, b01, b0134), (b, b, b)) # Ancilla is leaking here assert isinstance(chain2, _Chain) anc_basis = chain2._units[1].operation.bases_out[1] for label in '2', 'X20', 'Y20', 'X21', 'Y21': assert label in anc_basis.labels
def test_chain_merge_prev(self, d, lib): b = bases.general(d) rng = np.random.RandomState(4242) dm = rng.randn(d*d, d*d) + 1j * rng.randn(d*d, d*d) dm += dm.conjugate().transpose() dm /= dm.trace() chain = Operation.from_sequence( (lib.cphase(angle=np.pi/7, leakage=0.25) if d == 3 else lib.cphase(3*np.pi / 7)).at(0, 1), lib.rotate_x(4 * np.pi / 7).at(0), ) bases_full = (b, b) chain_c = chain.compile(bases_full, bases_full) assert len(chain.operations) == 2 assert isinstance(chain_c, _PTMOperation) state1 = State.from_dm(dm, bases_full) state2 = State.from_dm(dm, bases_full) chain(state1, 0, 1) chain_c(state2, 0, 1) assert np.allclose(state1.meas_prob(0), state2.meas_prob(0)) assert np.allclose(state1.meas_prob(1), state2.meas_prob(1))
def test_create_untimed_model(): basis = (bases.general(2), ) class SampleModel(Model): dim = 2 @Model.gate() def rotate_y(self, qubit): return (ParametrizedOperation(lib.rotate_y, basis), ) @Model.gate() def cphase(self, qubit_static, qubit_fluxed): return (lib.cphase(pi).at(qubit_static, qubit_fluxed), ) sample_setup = Setup(""" setup: [] """) m = SampleModel(sample_setup) cnot = m.rotate_y('D0', angle=0.5*pi) + m.cphase('D0', 'D1') + \ m.rotate_y('D0', angle=-0.5*pi) assert cnot.finalize().operation.ptm(basis * 2, basis * 2) == approx( Operation.from_sequence( lib.rotate_y(0.5 * pi).at(0), lib.cphase(pi).at(0, 1), lib.rotate_y(-0.5 * pi).at(0), ).ptm(basis * 2, basis * 2))
def idle(duration, t1, t2, anharmonicity=0.): if np.isfinite(t1) and np.isfinite(t2): t_phi = 1. / (1. / t2 - 0.5 / t1) if t_phi < 0: raise ValueError('t2 must be less than 2*t1') elif np.allclose(t_phi, 0): ops_t2 = [] else: ops_t2 = [(8. / (9 * t_phi))**0.5 * np.array([[1, 0, 0], [0, 0, 0], [0, 0, -1]]), (2. / (9 * t_phi))**0.5 * np.array([[1, 0, 0], [0, -1, 0], [0, 0, 0]]), (2. / (9 * t_phi))**0.5 * np.array([[0, 0, 0], [0, 1, 0], [0, 0, -1]])] else: ops_t2 = [] op_t1 = t1**-0.5 * np.array([[0, 1, 0], [0, 0, np.sqrt(2)], [0, 0, 0]]) if not np.allclose(anharmonicity, 0.): ham = np.array([ [0., 0., 0.], [0., 0., 0.], [0., 0., anharmonicity], ]) else: ham = None return Operation.from_lindblad_form(duration, (bases.general(3), ), hamiltonian=ham, lindblad_ops=[op_t1, *ops_t2])
def test_chain_merge_prev(self, d, lib): b = bases.general(d) rng = np.random.RandomState(4242) dm = rng.randn(d * d, d * d) + 1j * rng.randn(d * d, d * d) dm += dm.conjugate().transpose() dm /= dm.trace() chain = Operation.from_sequence( (lib.cphase(angle=np.pi / 7, leakage_rate=0.25) if d == 3 else lib.cphase(3 * np.pi / 7)).at(0, 1), lib.rotate_x(4 * np.pi / 7).at(0), ) bases_full = (b, b) chain_c = chain.compile(bases_full, bases_full) assert len(chain._units) == 2 assert isinstance(chain_c, PTMOperation) pv1 = PauliVector.from_dm(dm, bases_full) pv2 = PauliVector.from_dm(dm, bases_full) chain(pv1, 0, 1) chain_c(pv2, 0, 1) assert np.allclose(pv1.meas_prob(0), pv2.meas_prob(0)) assert np.allclose(pv1.meas_prob(1), pv2.meas_prob(1))
def depolarization(rate): rate = rate / 2 sqrt = np.sqrt(rate) matrix = np.array([ np.sqrt(2 - (3 * rate)) * _PAULI["I"], sqrt * _PAULI["X"], sqrt * _PAULI["Y"], sqrt * _PAULI["Z"] ]) return Operation.from_kraus(matrix, 2)
def depolarization(rate): rate = rate / 2 sqrt = np.sqrt(rate) matrix = np.array([np.sqrt(2 - (3 * rate)) * _PAULI["I"], sqrt * _PAULI["X"], sqrt * _PAULI["Y"], sqrt * _PAULI["Z"]]) return Operation.from_kraus(matrix, 2)
def amp_damping(total_rate=None, *, exc_rate=None, damp_rate=None): if total_rate is not None: kraus = np.array([[[1, 0], [0, np.sqrt(1 - total_rate)]], [[0, np.sqrt(total_rate)], [0, 0]]]) return Operation.from_kraus(kraus, 2) else: if None in (exc_rate, damp_rate): raise ValueError( "Either the total_rate or both the exc_rate and damp_rate " "must be provided") comb_rate = exc_rate + damp_rate ptm = np.array([ [1, 0, 0, 0], [0, np.sqrt((1 - comb_rate)), 0, 0], [0, 0, np.sqrt((1 - comb_rate)), 0], [2*damp_rate - comb_rate, 0, 0, 1 - comb_rate]]) return Operation.from_ptm(ptm, (bases.gell_mann(2),))
def cnot(): dcnot = np.zeros((9, 9)) dcnot[3, 3] = 0.5 dcnot[4, 4] = 0.5 dcnot[3, 4] = -0.5 dcnot[4, 3] = -0.5 unitary = expm(-1j*np.pi*dcnot) return Operation.from_kraus(unitary, 3)
def test_circuits_params(self): dim = 2 basis = (bases.general(dim), ) * 2 orotate = lib.rotate_y ocphase = lib.cphase grotate = Gate('Q0', dim, ParametrizedOperation(orotate, basis[:1])) gcphase = Gate(('Q0', 'Q1'), dim, ParametrizedOperation(ocphase, basis)) with pytest.raises(RuntimeError, match=r".*free parameters.*\n" r".*angle.*\n" r".*allow_param_repeat.*"): _ = gcphase + grotate with allow_param_repeat(): circuit = grotate + gcphase + grotate assert circuit.free_parameters == {sympy.symbols('angle')} assert len(circuit.gates) == 3 angle = 0.736 assert c_op(circuit(angle=angle)).ptm(basis, basis) == \ approx(Operation.from_sequence( orotate(angle).at(0), ocphase(angle).at(0, 1), orotate(angle).at(0) ).ptm(basis, basis)) angle1 = 0.4 * pi angle2 = 1.01 * pi angle3 = -0.6 * pi ptm_ref = Operation.from_sequence( orotate(angle1).at(0), ocphase(angle2).at(0, 1), orotate(angle3).at(0)).ptm(basis, basis) circuit = grotate(angle=angle1) + gcphase(angle=angle2) + \ grotate(angle=angle3) assert circuit.finalize().operation.ptm(basis, basis) == \ approx(ptm_ref) circuit = grotate(angle='angle1') + gcphase(angle='angle2') + \ grotate(angle='angle3') assert c_op(circuit(angle1=angle1, angle2=angle2, angle3=angle3)).ptm(basis, basis) == approx(ptm_ref)
def controlled_unitary(unitary): dim_hilbert = unitary.shape[0] if unitary.shape != (dim_hilbert, dim_hilbert): raise ValueError("Unitary matrix must be square") control_block = np.eye(2) off_diag_block_0 = np.zeros((2, dim_hilbert)) off_diag_block_1 = np.zeros((dim_hilbert, 2)) matrix = np.array([[control_block, off_diag_block_0], [off_diag_block_1, unitary]]) return Operation.from_kraus(matrix, 2)
def hadamard(): """A perfect Hadamard operation. Returns ------- Operation.from_kraus An operation, that corresponds to the rotation. """ matrix = np.sqrt(0.5) * np.array([[1, 1], [1, -1]]) return Operation.from_kraus(matrix, 2)
def hadamard(): """A perfect Hadamard operation. Returns ------- Operation.from_kraus An operation, that corresponds to the rotation. """ matrix = np.sqrt(0.5)*np.array([[1, 1], [1, -1]]) return Operation.from_kraus(matrix, 2)
def controlled_unitary(unitary): dim_hilbert = unitary.shape[0] if unitary.shape != (dim_hilbert, dim_hilbert): raise ValueError("Unitary matrix must be square") control_block = np.eye(2) off_diag_block_0 = np.zeros((2, dim_hilbert)) off_diag_block_1 = np.zeros((dim_hilbert, 2)) matrix = np.array([[control_block, off_diag_block_0], [off_diag_block_1, unitary]]) return Operation.from_kraus(matrix, 2)
def test_chain_compile_single_qubit(self, d, lib): b = bases.general(d) dm = random_hermitian_matrix(d, seed=487) bases_full = (b, ) subbases = (b.subbasis([0, 1]), ) angle = np.pi / 5 rx_angle = lib.rotate_x(angle) rx_2angle = lib.rotate_x(2 * angle) chain0 = Operation.from_sequence(rx_angle.at(0), rx_angle.at(0)) pv0 = PauliVector.from_dm(dm, bases_full) chain0(pv0, 0) assert chain0.num_qubits == 1 assert len(chain0._units) == 2 chain0_c = chain0.compile(bases_full, bases_full) assert isinstance(chain0_c, PTMOperation) pv1 = PauliVector.from_dm(dm, bases_full) chain0_c(pv1, 0) assert chain0_c.num_qubits == 1 assert isinstance(chain0_c, PTMOperation) op_angle = chain0_c op_2angle = rx_2angle.compile(bases_full, bases_full) assert isinstance(op_2angle, PTMOperation) assert op_angle.shape == op_2angle.shape assert op_angle.bases_in == op_2angle.bases_in assert op_angle.bases_out == op_2angle.bases_out assert op_angle.ptm(op_angle.bases_in, op_angle.bases_out) == \ approx(op_2angle.ptm(op_2angle.bases_in, op_2angle.bases_out)) assert pv1.to_pv() == approx(pv0.to_pv()) rx_pi = lib.rotate_x(np.pi) chain_2pi = Operation.from_sequence(rx_pi.at(0), rx_pi.at(0)) chain_2pi_c1 = chain_2pi.compile(subbases, bases_full) assert isinstance(chain_2pi_c1, PTMOperation) assert chain_2pi_c1.bases_in == subbases assert chain_2pi_c1.bases_out == subbases chain_2pi_c2 = chain_2pi.compile(bases_full, subbases) assert isinstance(chain_2pi_c2, PTMOperation) assert chain_2pi_c2.bases_in == subbases assert chain_2pi_c2.bases_out == subbases
def hadamard(): """A perfect Hadamard operation. Returns ------- Operation An operation, that corresponds to the rotation. """ s = np.sqrt(0.5) matrix = np.array([[s, s, 0], [s, -s, 0], [0, 0, 1]]) return Operation.from_kraus(matrix, 3)
def test_ptm(self): # Some random gate sequence op_indices = [(lib2.rotate_x(np.pi / 2), (0, )), (lib2.rotate_y(0.3333), (1, )), (lib2.cphase(), (0, 2)), (lib2.cphase(), (1, 2)), (lib2.rotate_x(-np.pi / 2), (0, ))] circuit = Operation.from_sequence(*(op.at(*ix) for op, ix in op_indices)) b = (bases.general(2), ) * 3 ptm = circuit.ptm(b, b) assert isinstance(ptm, np.ndarray) op_3q = Operation.from_ptm(ptm, b) dm = random_hermitian_matrix(8, seed=93) state1 = PauliVector.from_dm(dm, b) state2 = PauliVector.from_dm(dm, b) circuit(state1, 0, 1, 2) op_3q(state2, 0, 1, 2) assert np.allclose(state1.to_pv(), state2.to_pv())
def test_convert_ptm_basis(self): p_damp = 0.5 damp_kraus_mat = np.array([[[1, 0], [0, np.sqrt(1 - p_damp)]], [[0, np.sqrt(p_damp)], [0, 0]]]) gell_mann_basis = (bases.gell_mann(2), ) general_basis = (bases.general(2), ) op1 = Operation.from_kraus(damp_kraus_mat, gell_mann_basis) op2 = op1.set_bases(general_basis, general_basis) \ .set_bases(gell_mann_basis, gell_mann_basis) assert np.allclose(op1.ptm(gell_mann_basis), op2.ptm(gell_mann_basis)) assert op1.bases_in == op2.bases_in assert op1.bases_out == op2.bases_out
def test_circuits_add(self): dim = 2 orplus = lib.rotate_y(0.5 * pi) ocphase = lib.cphase(pi) orminus = lib.rotate_y(-0.5 * pi) grplus = Gate('Q0', dim, orplus) gcphase = Gate(('Q0', 'Q1'), dim, ocphase) grminus = Gate('Q0', dim, orminus) basis = (bases.general(2), ) * 2 circuit = grplus + gcphase assert circuit.qubits == ['Q0', 'Q1'] assert len(circuit.gates) == 2 assert c_op(circuit).ptm(basis, basis) == approx( Operation.from_sequence(orplus.at(0), ocphase.at(0, 1)).ptm(basis, basis)) circuit = circuit + grminus assert circuit.qubits == ['Q0', 'Q1'] assert len(circuit.gates) == 3 assert c_op(circuit).ptm(basis, basis) == approx( Operation.from_sequence(orplus.at(0), ocphase.at(0, 1), orminus.at(0)).ptm(basis, basis)) circuit = grplus + (gcphase + grminus) assert circuit.qubits == ['Q0', 'Q1'] assert len(circuit.gates) == 3 assert c_op(circuit).ptm(basis, basis) == approx( Operation.from_sequence(orplus.at(0), ocphase.at(0, 1), orminus.at(0)).ptm(basis, basis)) grplus = Gate('Q1', dim, orplus) grminus = Gate('Q1', dim, orminus) circuit = grplus + gcphase + grminus assert circuit.qubits == ['Q1', 'Q0'] assert len(circuit.gates) == 3 assert c_op(circuit).ptm(basis, basis) == approx( Operation.from_sequence(orplus.at(0), ocphase.at(0, 1), orminus.at(0)).ptm(basis, basis)) basis = (basis[0], ) * 3 grplus = Gate('Q2', dim, orplus) grminus = Gate('Q0', dim, orminus) circuit = grplus + gcphase + grminus assert circuit.qubits == ['Q2', 'Q0', 'Q1'] assert len(circuit.gates) == 3 assert c_op(circuit).ptm(basis, basis) == approx( Operation.from_sequence(orplus.at(0), ocphase.at(1, 2), orminus.at(1)).ptm(basis, basis)) grplus = Gate('Q0', dim, orplus) grminus = Gate('Q2', dim, orminus) circuit = grplus + gcphase + grminus assert circuit.qubits == ['Q0', 'Q1', 'Q2'] assert len(circuit.gates) == 3 assert c_op(circuit).ptm(basis, basis) == approx( Operation.from_sequence(orplus.at(0), ocphase.at(0, 1), orminus.at(2)).ptm(basis, basis))
def test_chain_compile_single_qubit(self, d, lib): b = bases.general(d) dm = random_density_matrix(d, seed=487) bases_full = (b,) subbases = (b.subbasis([0, 1]),) angle = np.pi/5 rx_angle = lib.rotate_x(angle) rx_2angle = lib.rotate_x(2*angle) chain0 = Operation.from_sequence(rx_angle.at(0), rx_angle.at(0)) state0 = State.from_dm(dm, bases_full) chain0(state0, 0) assert chain0.num_qubits == 1 assert len(chain0.operations) == 2 chain0_c = chain0.compile(bases_full, bases_full) state1 = State.from_dm(dm, bases_full) chain0_c(state1, 0) assert chain0_c.num_qubits == 1 assert isinstance(chain0_c, _PTMOperation) op_angle = chain0_c op_2angle = rx_2angle.compile(bases_full, bases_full) assert op_angle.shape == op_2angle.shape assert op_angle.bases_in == op_2angle.bases_in assert op_angle.bases_out == op_2angle.bases_out assert op_angle.ptm == approx(op_2angle.ptm) assert state1.to_pv() == approx(state0.to_pv()) rx_pi = lib.rotate_x(np.pi) chain_2pi = Operation.from_sequence(rx_pi.at(0), rx_pi.at(0)) chain_2pi_c1 = chain_2pi.compile(subbases, bases_full) assert isinstance(chain_2pi_c1, _PTMOperation) assert chain_2pi_c1.bases_in == subbases assert chain_2pi_c1.bases_out == subbases chain_2pi_c2 = chain_2pi.compile(bases_full, subbases) assert isinstance(chain_2pi_c2, _PTMOperation) assert chain_2pi_c2.bases_in == subbases assert chain_2pi_c2.bases_out == subbases
def test_kraus_to_ptm_qutrits(self): cz_kraus_mat = np.diag([1, 1, 1, 1, -1, 1, -1, 1, 1]) qutrit_basis = (bases.gell_mann(3), ) system_bases = qutrit_basis * 2 cz = Operation.from_kraus(cz_kraus_mat, system_bases) cz_ptm = cz.ptm(system_bases) assert cz_ptm.shape == (9, 9, 9, 9) cz_ptm_flat = cz_ptm.reshape((81, 81)) assert np.all(cz_ptm_flat.round(3) <= 1) and np.all( cz_ptm.round(3) >= -1) assert np.isclose(np.sum(cz_ptm_flat[0, :]), 1) assert np.isclose(np.sum(cz_ptm_flat[:, 0]), 1)
def test_kraus_to_ptm_qutrits(self): cz_kraus_mat = np.diag([1, 1, 1, 1, -1, 1, -1, 1, 1]) qutrit_basis = (bases.gell_mann(3),) system_bases = qutrit_basis * 2 cz = Operation.from_kraus(cz_kraus_mat, 3).set_bases(system_bases, system_bases) assert cz.ptm.shape == (9, 9, 9, 9) cz_ptm_flat = cz.ptm.reshape((81, 81)) assert np.all(cz_ptm_flat.round(3) <= 1) and np.all( cz.ptm.round(3) >= -1) assert np.isclose(np.sum(cz_ptm_flat[0, :]), 1) assert np.isclose(np.sum(cz_ptm_flat[:, 0]), 1)
def cphase(angle=np.pi): """A perfect controlled phase rotation. Parameters ---------- angle: float, optional Rotation angle in radians. Default is :math:`\\pi`. Returns ------- Operation.from_kraus An operation, that corresponds to the rotation. """ matrix = np.diag([1, 1, 1, np.exp(1j * angle)]) return Operation.from_kraus(matrix, 2)
def test_convert_ptm_basis(self): p_damp = 0.5 damp_kraus_mat = np.array( [[[1, 0], [0, np.sqrt(1-p_damp)]], [[0, np.sqrt(p_damp)], [0, 0]]]) gell_mann_basis = (bases.gell_mann(2),) general_basis = (bases.general(2),) damp_op_kraus = Operation.from_kraus(damp_kraus_mat, 2) op1 = damp_op_kraus.set_bases(gell_mann_basis, gell_mann_basis) op2 = damp_op_kraus.set_bases(general_basis, general_basis) \ .set_bases(gell_mann_basis, gell_mann_basis) assert np.allclose(op1.ptm, op2.ptm) assert op1.bases_in == op2.bases_in assert op1.bases_out == op2.bases_out
def cphase(angle=np.pi): """A perfect controlled phase rotation. Parameters ---------- angle: float, optional Rotation angle in radians. Default is :math:`\\pi`. Returns ------- Operation.from_kraus An operation, that corresponds to the rotation. """ matrix = np.diag([1, 1, 1, np.exp(1j * angle)]) return Operation.from_kraus(matrix, 2)
def rotate_y(angle=np.pi): """A perfect single qubit rotation around :math:`Oy` axis. Parameters ---------- angle: float, optional Rotation angle in radians. Default is :math:`\\pi`. Returns ------- Operation An operation, that corresponds to the rotation. """ sin, cos = np.sin(angle / 2), np.cos(angle / 2) matrix = np.array([[cos, -sin, 0], [sin, cos, 0], [0, 0, 1]]) return Operation.from_kraus(matrix, 3)
def rotate_y(angle=np.pi): """A perfect single qubit rotation around :math:`Oy` axis. Parameters ---------- angle: float, optional Rotation angle in radians. Default is :math:`\\pi`. Returns ------- Operation.from_kraus An operation, that corresponds to the rotation. """ sin, cos = np.sin(angle / 2), np.cos(angle / 2) matrix = np.array([[cos, -sin], [sin, cos]]) return Operation.from_kraus(matrix, 2)
def rotate_z(angle=np.pi): """A perfect single qubit rotation around :math:`Oz` axis. Parameters ---------- angle: float, optional Rotation angle in radians. Default is :math:`\\pi`. Returns ------- Operation.from_kraus An operation, that corresponds to the rotation. """ exp = np.exp(-1j * angle / 2) matrix = np.diag([exp, exp.conj()]) return Operation.from_kraus(matrix, 2)
def rotate_z(angle=np.pi): """A perfect single qubit rotation around :math:`Oz` axis. Parameters ---------- angle: float, optional Rotation angle in radians. Default is :math:`\\pi`. Returns ------- Operation An operation, that corresponds to the rotation. """ exp = np.exp(-1j * angle / 2) matrix = np.diag([exp, exp.conj(), 1]) return Operation.from_kraus(matrix, 3)
def iswap(angle=np.pi/2): """A perfect controlled phase rotation. Parameters ---------- angle: float, optional Rotation angle in radians. Default is :math:`\\pi`. Returns ------- Operation.from_kraus An operation, that corresponds to the rotation. """ sin, cos = np.sin(angle), np.cos(angle) matrix = np.array([[1, 0, 0, 0], [0, cos, 1j*sin, 0], [0, 1j*sin, cos, 0], [0, 0, 0, 1]]) return Operation.from_kraus(matrix, 2)
def test_zz_parity_compilation(self): b_full = bases.general(3) b0 = b_full.subbasis([0]) b01 = b_full.subbasis([0, 1]) b012 = b_full.subbasis([0, 1, 2]) bases_in = (b01, b01, b0) bases_out = (b_full, b_full, b012) zz = Operation.from_sequence( lib3.rotate_x(-np.pi/2).at(2), lib3.cphase(leakage=0.1).at(0, 2), lib3.cphase(leakage=0.25).at(2, 1), lib3.rotate_x(np.pi/2).at(2), lib3.rotate_x(np.pi).at(0), lib3.rotate_x(np.pi).at(1) ) zzc = zz.compile(bases_in=bases_in, bases_out=bases_out) assert len(zzc.operations) == 2 op1, ix1 = zzc.operations[0] op2, ix2 = zzc.operations[1] assert ix1 == (0, 2) assert ix2 == (1, 2) assert op1.bases_in[0] == bases_in[0] assert op2.bases_in[0] == bases_in[1] assert op1.bases_in[1] == bases_in[2] # Qubit 0 did not leak assert op1.bases_out[0] == bases_out[0].subbasis([0, 1, 3, 4]) # Qubit 1 leaked assert op2.bases_out[0] == bases_out[1].subbasis([0, 1, 2, 6]) # Qubit 2 is measured assert op2.bases_out[1] == bases_out[2] dm = random_density_matrix(3**3, seed=85) state1 = State.from_dm(dm, (b01, b01, b0)) state2 = State.from_dm(dm, (b01, b01, b0)) zz(state1, 0, 1, 2) zzc(state2, 0, 1, 2) # Compiled version still needs to be projected, so we can't compare # Pauli vectors, so we can to check only DM diagonals. assert np.allclose(state1.diagonal(), state2.diagonal())
def test_chain_compile_three_qubit(self, d, lib): b = bases.general(d) b0 = b.subbasis([0]) chain0 = Operation.from_sequence( lib.rotate_x(0.5*np.pi).at(2), lib.cphase().at(0, 2), lib.cphase().at(1, 2), lib.rotate_x(-0.75*np.pi).at(2), lib.rotate_x(0.25*np.pi).at(2), ) chain1 = chain0.compile((b, b, b0), (b, b, b)) assert chain1.operations[0].indices == (0, 2) assert chain1.operations[0].operation.bases_in == (b, b0) assert chain1.operations[0].operation.bases_out[0] == b assert chain1.operations[1].indices == (1, 2) assert chain1.operations[1].operation.bases_in[0] == b assert chain1.operations[1].operation.bases_out[0] == b for label in '0', '1', 'X10', 'Y10': assert label in chain1.operations[1].operation.bases_out[1].labels
def test_chain_apply(self): b = (bases.general(2),) * 3 dm = random_density_matrix(8, seed=93) state1 = State.from_dm(dm, b) state2 = State.from_dm(dm, b) # Some random gate sequence op_indices = [(lib2.rotate_x(np.pi/2), (0,)), (lib2.rotate_y(0.3333), (1,)), (lib2.cphase(), (0, 2)), (lib2.cphase(), (1, 2)), (lib2.rotate_x(-np.pi/2), (0,))] for op, indices in op_indices: op(state1, *indices), circuit = Operation.from_sequence( *(op.at(*ix) for op, ix in op_indices)) circuit(state2, 0, 1, 2) assert np.all(state1.to_pv() == state2.to_pv())
def cphase(angle=np.pi, leakage=0.): """A perfect controlled phase rotation. First qubit is low-frequency, second qubit is high-frequency (it leaks). Parameters ---------- angle: float, optional Rotation angle in radians. Default is :math:`\\pi`. leakage: float, optional Leakage rate of a CPhase gate Returns ------- Operation An operation, that corresponds to the rotation. """ dcphase = np.zeros((9, 9)) dcphase[2, 4] = 1 dcphase[4, 2] = 1 angle_frac = 1 - np.arcsin(np.sqrt(leakage)) / np.pi unitary = expm(-1j*angle*angle_frac*dcphase) return Operation.from_kraus(unitary, 3)
def test_chain_compile_leaking(self): b = bases.general(3) chain0 = Operation.from_sequence( lib3.rotate_x(0.5*np.pi).at(2), lib3.cphase(leakage=0.1).at(0, 2), lib3.cphase(leakage=0.1).at(1, 2), lib3.rotate_x(-0.75*np.pi).at(2), lib3.rotate_x(0.25*np.pi).at(2), ) b0 = b.subbasis([0]) b01 = b.subbasis([0, 1]) b0134 = b.subbasis([0, 1, 3, 4]) chain1 = chain0.compile((b0, b0, b0134), (b, b, b)) # Ancilla is not leaking here anc_basis = chain1.operations[1].operation.bases_out[1] for label in anc_basis.labels: assert '2' not in label chain2 = chain0.compile((b01, b01, b0134), (b, b, b)) # Ancilla is leaking here anc_basis = chain2.operations[1].operation.bases_out[1] for label in '2', 'X20', 'Y20', 'X21', 'Y21': assert label in anc_basis.labels
def test_chain_merge_next(self, d, lib): b = bases.general(d) dm = random_density_matrix(d**2, seed=574) chain = Operation.from_sequence( lib.rotate_x(np.pi / 5).at(0), (lib.cphase(angle=3*np.pi/7, leakage=0.1) if d == 3 else lib.cphase(3*np.pi / 7)).at(0, 1), ) bases_full = (b, b) chain_c = chain.compile(bases_full, bases_full) assert len(chain.operations) == 2 assert isinstance(chain_c, _PTMOperation) state1 = State.from_dm(dm, bases_full) state2 = State.from_dm(dm, bases_full) chain(state1, 0, 1) chain_c(state2, 0, 1) assert state1.meas_prob(0) == approx(state2.meas_prob(0)) assert state1.meas_prob(1) == approx(state2.meas_prob(1))
def idle(duration, t1, t2, anharmonicity=0.): t_phi = 1./(1./t2 - 0.5/t1) op_t1 = t1**-0.5 * np.array([ [0, 1, 0], [0, 0, np.sqrt(2)], [0, 0, 0] ]) ops_t2 = [ (8. / (9*t_phi))**0.5 * np.array([ [1, 0, 0], [0, 0, 0], [0, 0, -1] ]), (2. / (9*t_phi))**0.5 * np.array([ [1, 0, 0], [0, -1, 0], [0, 0, 0] ]), (2. / (9*t_phi))**0.5 * np.array([ [0, 0, 0], [0, 1, 0], [0, 0, -1] ]) ] if not np.allclose(anharmonicity, 0.): ham = np.array([ [0., 0., 0.], [0., 0., 0.], [0., 0., anharmonicity], ]) else: ham = None return Operation.from_lindblad_form( duration, bases.general(3), hamiltonian=ham, lindblad_ops=[op_t1, *ops_t2])
def amp_phase_damping(damp_rate, deph_rate): amp_damp = amp_damping(damp_rate) phase_damp = phase_damping(deph_rate) return Operation.from_sequence(amp_damp.at(0), phase_damp.at(0))
def phase_shift(angle=np.pi): matrix = np.diag([1, np.exp(1j * angle)]) return Operation.from_kraus(matrix, 2)
def cnot(): matrix = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]) return Operation.from_kraus(matrix, 2)
def bit_phase_flipping(flip_rate): matrix = np.array([np.sqrt(flip_rate) * _PAULI["I"], np.sqrt(1 - flip_rate) * _PAULI["Y"]]) return Operation.from_kraus(matrix, 2)
def phase_flipping(flip_rate): # This is actually equivalent to the phase damping matrix = np.array([np.sqrt(flip_rate) * _PAULI["I"], np.sqrt(1 - flip_rate) * _PAULI["Z"]]) return Operation.from_kraus(matrix, 2)