def test_qubitop_to_paulisum_more_terms(self): # Given qubit_operator = ( QubitOperator("Z0 Z1 Z2", -1.5) + QubitOperator("X0", 2.5) + QubitOperator("Y1", 3.5) ) expected_qubits = (LineQubit(0), LineQubit(5), LineQubit(8)) expected_paulisum = ( PauliSum() + ( PauliString(Z.on(expected_qubits[0])) * PauliString(Z.on(expected_qubits[1])) * PauliString(Z.on(expected_qubits[2])) * -1.5 ) + (PauliString(X.on(expected_qubits[0]) * 2.5)) + (PauliString(Y.on(expected_qubits[1]) * 3.5)) ) # When paulisum = qubitop_to_paulisum(qubit_operator, qubits=expected_qubits) # Then self.assertEqual(paulisum.qubits, expected_qubits) self.assertEqual(paulisum, expected_paulisum)
def test_simple_pauli_deco_dict_CNOT(): """Tests that the _simple_pauli_deco_dict function returns a decomposition dicitonary which is consistent with a local depolarizing noise model. The channel acting on the state each qubit is assumed to be: D(rho) = = (1 - epsilon) rho + epsilon I/2 = (1 - p) rho + p/3 (X rho X + Y rho Y^dag + Z rho Z) """ # Deduce epsilon from BASE_NOISE epsilon = BASE_NOISE * 4.0 / 3.0 c_neg = -(1 / 4) * epsilon / (1 - epsilon) c_pos = 1 - 3 * c_neg qreg = LineQubit.range(2) # Get the decomposition of a CNOT gate deco = DECO_DICT[CNOT.on(*qreg)] # The first term of 'deco' corresponds to no error occurring first_coefficient, first_imp_seq = deco[0] assert np.isclose(c_pos * c_pos, first_coefficient) assert first_imp_seq == [CNOT.on(*qreg)] # The second term corresponds to a Pauli X error on one qubit second_coefficient, second_imp_seq = deco[1] assert np.isclose(c_pos * c_neg, second_coefficient) assert second_imp_seq == [CNOT.on(*qreg), X.on(qreg[0])] # The last term corresponds to two Pauli Z errors on both qubits last_coefficient, last_imp_seq = deco[-1] assert np.isclose(c_neg * c_neg, last_coefficient) assert last_imp_seq == [CNOT.on(*qreg), Z.on(qreg[0]), Z.on(qreg[1])]
def test_get_imp_sequences_no_simplify(gate: Gate): q = LineQubit(0) expected_imp_sequences = [ [gate.on(q)], [gate.on(q), X.on(q)], [gate.on(q), Y.on(q)], [gate.on(q), Z.on(q)], ] assert get_imp_sequences(gate.on(q), DECO_DICT) == expected_imp_sequences
def test_sample_circuit_with_seed(): decomp = _simple_pauli_deco_dict(0.7, simplify_paulis=True) circ = Circuit([X.on(LineQubit(0)) for _ in range(10)]) expected = sample_circuit(circ, decomp, random_state=4)[0] # Check we're not sampling the same operation every call to sample_sequence assert len(set(expected.all_operations())) > 1 for _ in range(10): sampled = sample_circuit(circ, decomp, random_state=4)[0] assert _equal(sampled, expected)
def test_simple_pauli_deco_dict_single_qubit(gate: Gate): """Tests that the _simple_pauli_deco_dict function returns a decomposition dicitonary which is consistent with a local depolarizing noise model. This is similar to test_simple_pauli_deco_dict_CNOT but applied to single-qubit gates. """ epsilon = BASE_NOISE * 4.0 / 3.0 c_neg = -(1 / 4) * epsilon / (1 - epsilon) c_pos = 1 - 3 * c_neg qreg = LineQubit.range(2) for q in qreg: deco = DECO_DICT[gate.on(q)] first_coefficient, first_imp_seq = deco[0] assert np.isclose(c_pos, first_coefficient) assert first_imp_seq == [gate.on(q)] second_coefficient, second_imp_seq = deco[1] assert np.isclose(c_neg, second_coefficient) assert second_imp_seq == [gate.on(q), X.on(q)]
def qubit_op_to_gate(operation: 'QubitOperator', qubit) -> 'SingleQubitPauliStringGateOperation': """Convert a qubit operation into a gate operations that can be digested by a Cirq simulator. Args: operation (QubitOperator) qubit (Qid) - a qubit on which the Pauli matrices will act. Returns: (gate) - a gate that can be executed on the qubit passed """ if operation == 'X': return X.on(qubit) if operation == 'Y': return Y.on(qubit) if operation == 'Z': return Z.on(qubit) raise ValueError('No gate identified in qubit_op_to_gate')
_simple_pauli_deco_dict, DecompositionDict, _operation_to_choi, _circuit_to_choi, ) from mitiq.pec.sampling import sample_sequence, sample_circuit BASE_NOISE = 0.02 DECO_DICT = _simple_pauli_deco_dict(BASE_NOISE) DECO_DICT_SIMP = _simple_pauli_deco_dict(BASE_NOISE, simplify_paulis=True) NOISELESS_DECO_DICT = _simple_pauli_deco_dict(0) # Simple 2-qubit circuit qreg = LineQubit.range(2) twoq_circ = Circuit( X.on(qreg[0]), CNOT.on(*qreg), ) @pytest.mark.parametrize("gate", [X, Y, Z, CNOT]) def test_sample_sequence_types(gate: Gate): num_qubits = gate.num_qubits() qreg = LineQubit.range(num_qubits) for _ in range(1000): imp_seq, sign, norm = sample_sequence(gate.on(*qreg), DECO_DICT) assert all([isinstance(op, Operation) for op in imp_seq]) assert sign in {1, -1} assert norm > 1
def _simple_pauli_deco_dict(base_noise: float, simplify_paulis: bool = False ) -> DecompositionDict: """Returns a simple hard-coded decomposition dictionary to be used for testing and protoptyping. The decomposition is compatible with one-qubit or two-qubit circuits involving only Pauli and CNOT gates. The keys of the output dictionary are Pauli and CNOT operations. The decomposition assumes that Pauli and CNOT operations, followed by local depolarizing noise, are implementable. Args: base_noise: The depolarizing noise level. simplify_paulis: If True, products of Paulis are simplified to a single Pauli. If False, Pauli sequences are not simplified. Returns: decomposition_dict: The decomposition dictionary. """ # Initialize two qubits qreg = LineQubit.range(2) # Single-qubit Pauli operations i0 = I.on(qreg[0]) x0 = X.on(qreg[0]) y0 = Y.on(qreg[0]) z0 = Z.on(qreg[0]) i1 = I.on(qreg[1]) x1 = X.on(qreg[1]) y1 = Y.on(qreg[1]) z1 = Z.on(qreg[1]) single_paulis = [x0, y0, z0, x1, y1, z1] # Single-qubit decomposition coefficients epsilon = base_noise * 4 / 3 c_neg = -(1 / 4) * epsilon / (1 - epsilon) c_pos = 1 - 3 * c_neg assert np.isclose(c_pos + 3 * c_neg, 1.0) # Single-qubit decomposition dictionary decomposition_dict = {} if simplify_paulis: # Hard-coded simplified gates decomposition_dict = { x0: [(c_pos, [x0]), (c_neg, [i0]), (c_neg, [z0]), (c_neg, [y0])], y0: [(c_pos, [y0]), (c_neg, [z0]), (c_neg, [i0]), (c_neg, [x0])], z0: [(c_pos, [z0]), (c_neg, [y0]), (c_neg, [x0]), (c_neg, [i0])], x1: [(c_pos, [x1]), (c_neg, [i1]), (c_neg, [z1]), (c_neg, [y1])], y1: [(c_pos, [y1]), (c_neg, [z1]), (c_neg, [i1]), (c_neg, [x1])], z1: [(c_pos, [z1]), (c_neg, [y1]), (c_neg, [x1]), (c_neg, [i1])], } else: for local_paulis in [[x0, y0, z0], [x1, y1, z1]]: for key in local_paulis: key_deco_pos = [(c_pos, [key])] key_deco_neg = [(c_neg, [key, op]) for op in local_paulis] decomposition_dict[key] = ( key_deco_pos + key_deco_neg # type: ignore ) # Two-qubit Paulis xx = [x0, x1] xy = [x0, y1] xz = [x0, z1] yx = [y0, x1] yy = [y0, y1] yz = [y0, z1] zx = [z0, x1] zy = [z0, y1] zz = [z0, z1] double_paulis = [xx, xy, xz, yx, yy, yz, zx, zy, zz] # Two-qubit decomposition coefficients (assuming local noise) c_pos_pos = c_pos * c_pos c_pos_neg = c_neg * c_pos c_neg_neg = c_neg * c_neg assert np.isclose(c_pos_pos + 6 * c_pos_neg + 9 * c_neg_neg, 1.0) cnot = CNOT.on(qreg[0], qreg[1]) cnot_decomposition = [(c_pos_pos, [cnot])] for p in single_paulis: cnot_decomposition.append((c_pos_neg, [cnot] + [p])) for pp in double_paulis: cnot_decomposition.append((c_neg_neg, [cnot] + pp)) # type: ignore decomposition_dict[cnot] = cnot_decomposition # type: ignore return decomposition_dict # type: ignore
def test_get_imp_sequences_with_simplify(): q = LineQubit(0) expected_imp_sequences = [[X.on(q)], [I.on(q)], [Z.on(q)], [Y.on(q)]] assert get_imp_sequences(X.on(q), DECO_DICT_SIMP) == expected_imp_sequences