def test_clifford_decompose_one_qubit(): """Two random instance for one qubit decomposition.""" qubits = cirq.LineQubit.range(1) args = cirq.CliffordTableauSimulationState( tableau=cirq.CliffordTableau(num_qubits=1), qubits=qubits, prng=np.random.RandomState() ) cirq.act_on(cirq.X, args, qubits=[qubits[0]], allow_decompose=False) cirq.act_on(cirq.H, args, qubits=[qubits[0]], allow_decompose=False) cirq.act_on(cirq.S, args, qubits=[qubits[0]], allow_decompose=False) expect_circ = cirq.Circuit(cirq.X(qubits[0]), cirq.H(qubits[0]), cirq.S(qubits[0])) ops = cirq.decompose_clifford_tableau_to_operations(qubits, args.tableau) circ = cirq.Circuit(ops) assert_allclose_up_to_global_phase(cirq.unitary(expect_circ), cirq.unitary(circ), atol=1e-7) qubits = cirq.LineQubit.range(1) args = cirq.CliffordTableauSimulationState( tableau=cirq.CliffordTableau(num_qubits=1), qubits=qubits, prng=np.random.RandomState() ) cirq.act_on(cirq.Z, args, qubits=[qubits[0]], allow_decompose=False) cirq.act_on(cirq.H, args, qubits=[qubits[0]], allow_decompose=False) cirq.act_on(cirq.S, args, qubits=[qubits[0]], allow_decompose=False) cirq.act_on(cirq.H, args, qubits=[qubits[0]], allow_decompose=False) cirq.act_on(cirq.X, args, qubits=[qubits[0]], allow_decompose=False) expect_circ = cirq.Circuit( cirq.Z(qubits[0]), cirq.H(qubits[0]), cirq.S(qubits[0]), cirq.H(qubits[0]), cirq.X(qubits[0]), ) ops = cirq.decompose_clifford_tableau_to_operations(qubits, args.tableau) circ = cirq.Circuit(ops) assert_allclose_up_to_global_phase(cirq.unitary(expect_circ), cirq.unitary(circ), atol=1e-7)
def test_absorbs_z(): q = cirq.NamedQubit('q') # Full Z. assert_optimizes(before=quick_circuit( [cirq.PhasedXPowGate(phase_exponent=0.125).on(q)], [cirq.Z(q)], ), expected=quick_circuit( [cirq.PhasedXPowGate(phase_exponent=0.625).on(q)], [], )) # Partial Z. assert_optimizes(before=quick_circuit( [cirq.PhasedXPowGate(phase_exponent=0.125).on(q)], [cirq.S(q)], ), expected=quick_circuit( [cirq.PhasedXPowGate(phase_exponent=0.375).on(q)], [], )) # Multiple Zs. assert_optimizes(before=quick_circuit( [cirq.PhasedXPowGate(phase_exponent=0.125).on(q)], [cirq.S(q)], [cirq.T(q)**-1], ), expected=quick_circuit( [cirq.PhasedXPowGate(phase_exponent=0.25).on(q)], [], [], ))
def test_explicit_operations_cell(): a, b = cirq.LineQubit.range(2) v = ExplicitOperationsCell([cirq.X(a)], [cirq.S(a)]) assert v.operations() == (cirq.X(a), ) assert v.basis_change() == (cirq.S(a), ) assert v.controlled_by(b) == ExplicitOperationsCell( [cirq.X(a).controlled_by(b)], [cirq.S(a)])
def test_json_roundtrip(): (q0, q1, q2) = (cirq.LineQubit(0), cirq.LineQubit(1), cirq.LineQubit(2)) state = cirq.CliffordState(qubit_map={q0: 0, q1: 1, q2: 2}) # Apply some transformations. state.apply_unitary(cirq.X(q0)) state.apply_unitary(cirq.H(q1)) # Roundtrip serialize, then deserialize. state_roundtrip = cirq.CliffordState._from_json_dict_( **state._json_dict_()) # Apply the same transformation on both the original object and the one that # went through the roundtrip. state.apply_unitary(cirq.S(q1)) state_roundtrip.apply_unitary(cirq.S(q1)) # The (de)stabilizers should be the same. assert state.stabilizers() == state_roundtrip.stabilizers() assert state.destabilizers() == state_roundtrip.destabilizers() # Also check that the tableaux are also unchanged. assert state.tableau._str_full_() == state_roundtrip.tableau._str_full_() # And the CH form isn't changed either. assert np.allclose(state.ch_form.state_vector(), state_roundtrip.ch_form.state_vector())
def test_absorbs_z(): q = cirq.NamedQubit('q') # Full Z. assert_optimizes(before=quick_circuit( [cg.ExpWGate(axis_half_turns=0.125).on(q)], [cirq.Z(q)], ), expected=quick_circuit( [cg.ExpWGate(axis_half_turns=0.625).on(q)], [], )) # Partial Z. assert_optimizes(before=quick_circuit( [cg.ExpWGate(axis_half_turns=0.125).on(q)], [cirq.S(q)], ), expected=quick_circuit( [cg.ExpWGate(axis_half_turns=0.375).on(q)], [], )) # Multiple Zs. assert_optimizes(before=quick_circuit( [cg.ExpWGate(axis_half_turns=0.125).on(q)], [cirq.S(q)], [cirq.T(q)**-1], ), expected=quick_circuit( [cg.ExpWGate(axis_half_turns=0.25).on(q)], [], [], ))
def test_sensitive_to_measurement_but_not_measured_phase(): q = cirq.NamedQubit('q') with pytest.raises(AssertionError): cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent( cirq.Circuit([cirq.Moment([cirq.measure(q)])]), cirq.Circuit(), atol=1e-8) cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent( cirq.Circuit([cirq.Moment([cirq.measure(q)])]), cirq.Circuit([ cirq.Moment([cirq.Z(q)]), cirq.Moment([cirq.measure(q)]), ]), atol=1e-8) a, b = cirq.LineQubit.range(2) cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent( cirq.Circuit([cirq.Moment([cirq.measure(a, b)])]), cirq.Circuit([ cirq.Moment([cirq.Z(a)]), cirq.Moment([cirq.measure(a, b)]), ]), atol=1e-8) cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent( cirq.Circuit([cirq.Moment([cirq.measure(a)])]), cirq.Circuit([ cirq.Moment([cirq.Z(a)]), cirq.Moment([cirq.measure(a)]), ]), atol=1e-8) cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent( cirq.Circuit([cirq.Moment([cirq.measure(a, b)])]), cirq.Circuit([ cirq.Moment([cirq.T(a), cirq.S(b)]), cirq.Moment([cirq.measure(a, b)]), ]), atol=1e-8) with pytest.raises(AssertionError): cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent( cirq.Circuit([cirq.Moment([cirq.measure(a)])]), cirq.Circuit([ cirq.Moment([cirq.T(a), cirq.S(b)]), cirq.Moment([cirq.measure(a)]), ]), atol=1e-8) cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent( cirq.Circuit([cirq.Moment([cirq.measure(a, b)])]), cirq.Circuit([ cirq.Moment([cirq.CZ(a, b)]), cirq.Moment([cirq.measure(a, b)]), ]), atol=1e-8)
def test_gate_types(): a = cirq.NamedQubit("a") assert (ctu.is_t_or_s_gate(cirq.T(a)) == True) assert (ctu.is_t_or_s_gate(cirq.S(a)) == True) assert (ctu.is_t_or_s_gate(cirq.T(a)**-1) == True) assert (ctu.is_t_or_s_gate(cirq.S(a)**-1) == True) assert (ctu.is_t_or_s_gate(cirq.X(a)) == False)
def test_inverse(): a, b, c = cirq.LineQubit.range(3) m = cirq.Moment([cirq.S(a), cirq.CNOT(b, c)]) assert m**1 is m assert m**-1 == cirq.Moment([cirq.S(a)**-1, cirq.CNOT(b, c)]) assert m**0.5 == cirq.Moment([cirq.T(a), cirq.CNOT(b, c)**0.5]) assert cirq.inverse(m) == m**-1 assert cirq.inverse(cirq.inverse(m)) == m assert cirq.inverse(cirq.Moment([cirq.measure(a)]), default=None) is None
def correct(self, qubits: List[cirq.Qid], ancillas: List[cirq.Qid]) -> cirq.Circuit: """Corrects the code word. Creates a correction circuit by computing the syndrome on the ancillas, and then using this syndrome to correct the qubits. Args: qubits: a vector of self.n qubits that contains (potentially corrupted) code words ancillas: a vector of self.n - self.k qubits that are set to zero and will contain the syndrome once the circuit is applied. Returns: The circuit that both computes the syndrome and uses this syndrome to correct errors. """ circuit = cirq.Circuit() gate_dict = {'X': cirq.X, 'Y': cirq.Y, 'Z': cirq.Z} # We set the ancillas so that measuring them directly would be the same # as measuring the qubits with Pauli strings. In other words, we store # the syndrome inside the ancillas. for r in range(self.n - self.k): for n in range(self.n): if self.M[r][n] == 'Z': circuit.append(cirq.ControlledOperation([qubits[n]], cirq.X(ancillas[r]))) elif self.M[r][n] == 'X': circuit.append(cirq.H(qubits[n])) circuit.append(cirq.ControlledOperation([qubits[n]], cirq.X(ancillas[r]))) circuit.append(cirq.H(qubits[n])) elif self.M[r][n] == 'Y': circuit.append(cirq.S(qubits[n]) ** -1) circuit.append(cirq.H(qubits[n])) circuit.append(cirq.ControlledOperation([qubits[n]], cirq.X(ancillas[r]))) circuit.append(cirq.H(qubits[n])) circuit.append(cirq.S(qubits[n])) # At this stage, the ancillas are equal to the syndrome. Now, we apply # the errors back to correct the code. for syndrome, correction in self.syndromes_to_corrections.items(): op = gate_dict[correction[0]] n = correction[1] # We do a Boolean operation on the ancillas (i.e. syndrome). for r in range(self.n - self.k): if syndrome[r] == 1: circuit.append(cirq.X(ancillas[r])) circuit.append(cirq.ControlledOperation(ancillas, op(qubits[n]))) for r in range(self.n - self.k): if syndrome[r] == 1: circuit.append(cirq.X(ancillas[r])) return circuit
def test_noise_composition(): # Verify that noise models can be composed without regard to ordering, as # long as the noise operators commute with one another. a, b, c = cirq.LineQubit.range(3) noise_z = cirq.ConstantQubitNoiseModel(cirq.Z) noise_inv_s = cirq.ConstantQubitNoiseModel(cirq.S**-1) base_moments = [ cirq.Moment([cirq.X(a)]), cirq.Moment([cirq.Y(b)]), cirq.Moment([cirq.H(c)]) ] circuit_z = cirq.Circuit(noise_z.noisy_moments(base_moments, [a, b, c])) circuit_s = cirq.Circuit(noise_inv_s.noisy_moments(base_moments, [a, b, c])) actual_zs = cirq.Circuit( noise_inv_s.noisy_moments(circuit_z.moments, [a, b, c])) actual_sz = cirq.Circuit( noise_z.noisy_moments(circuit_s.moments, [a, b, c])) expected_circuit = cirq.Circuit( cirq.Moment([cirq.X(a)]), cirq.Moment([cirq.S(a), cirq.S(b), cirq.S(c)]), cirq.Moment([cirq.Y(b)]), cirq.Moment([cirq.S(a), cirq.S(b), cirq.S(c)]), cirq.Moment([cirq.H(c)]), cirq.Moment([cirq.S(a), cirq.S(b), cirq.S(c)]), ) # All of the gates will be the same, just out of order. Merging fixes this. actual_zs = cirq.merge_single_qubit_gates_to_phased_x_and_z(actual_zs) actual_sz = cirq.merge_single_qubit_gates_to_phased_x_and_z(actual_sz) expected_circuit = cirq.merge_single_qubit_gates_to_phased_x_and_z( expected_circuit) assert_equivalent_op_tree(actual_zs, actual_sz) assert_equivalent_op_tree(actual_zs, expected_circuit)
def test_clifford_circuit_SHSYSHS(): q0 = cirq.LineQubit(0) circuit = cirq.Circuit(cirq.S(q0), cirq.H(q0), cirq.S(q0), cirq.Y(q0), cirq.S(q0), cirq.H(q0), cirq.S(q0), cirq.measure(q0)) clifford_simulator = cirq.CliffordSimulator() state_vector_simulator = cirq.Simulator() np.testing.assert_almost_equal( clifford_simulator.simulate(circuit).final_state.state_vector(), state_vector_simulator.simulate(circuit).final_state_vector)
def test_clifforf_circuit_SHSYSHS(): q0 = cirq.LineQubit(0) circuit = cirq.Circuit(cirq.S(q0), cirq.H(q0), cirq.S(q0), cirq.Y(q0), cirq.S(q0), cirq.H(q0), cirq.S(q0), cirq.measure(q0)) clifford_simulator = cirq.CliffordSimulator() wave_function_simulator = cirq.Simulator() np.testing.assert_almost_equal( clifford_simulator.simulate(circuit).final_state.wave_function(), wave_function_simulator.simulate(circuit).final_state)
def simulate_qd_scheme(spin_gates_list, print_circuit=False): """OldQDfunctions that calculates the state vectors of the QD spin (0-th qubit) and of the photonic qubits after the pulse sequence. spin_gates_list. Returns the state vector. If print_circuit is True, the simulated circuit is printed. :param list spin_gates_list: gates to be done on the QD after each round of photon generation. """ for this_rot in spin_gates_list: if this_rot not in Allowed_Gates: raise ValueError("All rotation gates need to be in allowed list.") num_phot = len(spin_gates_list) qubits = cirq.LineQubit.range(num_phot + 1) # start preparing spin in |+> all_gates = [cirq.H(qubits[0])] for phot_ix, this_rot in enumerate(spin_gates_list): # perform CNOT (photon generation) all_gates.append(cirq.CNOT(qubits[0], qubits[phot_ix + 1])) # spin ends up in opposite spin after the pi gate all_gates.append(cirq.X(qubits[0])) # do rotation on spin if this_rot == 'H': all_gates.append(cirq.H(qubits[0])) if this_rot == 'X': all_gates.append(cirq.X(qubits[0])) if this_rot == 'Y': all_gates.append(cirq.Y(qubits[0])) if this_rot == 'Z': all_gates.append(cirq.Z(qubits[0])) if this_rot == 'SX': all_gates.append(cirq.H(qubits[0])) all_gates.append(cirq.S(qubits[0])) all_gates.append(cirq.H(qubits[0])) if this_rot == 'SZ': all_gates.append(cirq.S(qubits[0])) if this_rot == 'T': all_gates.append(cirq.T(qubits[0])) circuit = cirq.Circuit(all_gates) if print_circuit: print(circuit) simulator = cirq.Simulator() result = simulator.simulate(circuit) return result.final_state_vector
def build_circuit(qubits, params): """ Constructs a circuit representing a single timestep of quantum stuff. params is a list of 6 lists, each containing nqubits floats in [0, 1). These parameterize the circuit, such that each operation is performed only if its relevant parameter is >= 0.5. In order, we check the parameters, and if they are big enough we: -Set each qubit to zero. -Apply a CNOT gate between this qubit and its right neighbour. -Apply H, then S, then T gates. -Measure in the Z basis. Returns the constructed circuit. """ circuit = cirq.Circuit() circuit.append( cirq.reset(q) for q, p in zip(qubits, params[0]) if p >= 0.5) for qi, q in enumerate(qubits[:-1]): if params[1][qi] >= 0.5: circuit.append(cirq.CNOT(q, qubits[qi + 1])) circuit.append(cirq.H(q) for q, p in zip(qubits, params[2]) if p >= 0.5) circuit.append(cirq.S(q) for q, p in zip(qubits, params[3]) if p >= 0.5) circuit.append(cirq.T(q) for q, p in zip(qubits, params[4]) if p >= 0.5) circuit.append( cirq.measure(q) for q, p in zip(qubits, params[5]) if p >= 0.5) return circuit
def test_superoperator(): cnot = cirq.unitary(cirq.CNOT) a, b = cirq.LineQubit.range(2) m = cirq.Moment() assert m._has_superoperator_() s = m._superoperator_() assert np.allclose(s, np.array([[1.0]])) m = cirq.Moment(cirq.I(a)) assert m._has_superoperator_() s = m._superoperator_() assert np.allclose(s, np.eye(4)) m = cirq.Moment(cirq.IdentityGate(2).on(a, b)) assert m._has_superoperator_() s = m._superoperator_() assert np.allclose(s, np.eye(16)) m = cirq.Moment(cirq.S(a)) assert m._has_superoperator_() s = m._superoperator_() assert np.allclose(s, np.diag([1, -1j, 1j, 1])) m = cirq.Moment(cirq.CNOT(a, b)) assert m._has_superoperator_() s = m._superoperator_() assert np.allclose(s, np.kron(cnot, cnot)) m = cirq.Moment(cirq.depolarize(0.75).on(a)) assert m._has_superoperator_() s = m._superoperator_() assert np.allclose(s, np.array([[1, 0, 0, 1], [0, 0, 0, 0], [0, 0, 0, 0], [1, 0, 0, 1]]) / 2)
def test_valid_powers(self): gcirq = cirq.Circuit() qreg = [cirq.LineQubit(i) for i in range(5)] gcirq.append(cirq.X(qreg[0])**-3.67) gcirq.append(cirq.Y(qreg[0])**7.9) gcirq.append(cirq.Z(qreg[0])**sqrt(5)) gcirq.append(cirq.S(qreg[0])**-pi) gcirq.append(cirq.T(qreg[0])**(sqrt(7) - pi)) gcirq.append(cirq.SWAP(qreg[0], qreg[1])**-0.5) gcirq.append(cirq.ISWAP(qreg[0], qreg[1])**16.0) result = cirq_to_qlm(gcirq) for i, op in enumerate(result.ops): name, params = extract_syntax(result.gateDic[op.gate], result.gateDic) if i == 0: self.assertEqual(params[0], -3.67 * pi) elif i == 1: self.assertEqual(params[0], 7.9 * pi) elif i == 2: self.assertEqual(params[0], sqrt(5) * pi) elif i == 3: self.assertEqual(params[0], -pi * pi / 2) elif i == 4: self.assertEqual(params[0], (sqrt(7) - pi) * pi / 4) else: continue
def buildCirqCircuit(self, qubits, circuit): cirqCircuit = cirq.Circuit() ## Instantiate a CNot Gate cNotGate = cirq.CNotGate() ## Instantiate a Swap Gate swapGate = cirq.SwapGate() control = 0 controlFirst = False for j in range(len(circuit[0])): for i in range(len(circuit)): if circuit[i][j] == "Pauli-X-Gate": cirqCircuit.append(cirq.X(qubits[i])) elif circuit[i][j] == "Pauli-Y-Gate": cirqCircuit.append(cirq.Y(qubits[i])) elif circuit[i][j] == "Pauli-Z-Gate": cirqCircuit.append(cirq.Z(qubits[i])) elif circuit[i][j] == "Hadamard Gate": cirqCircuit.append(cirq.H(qubits[i])) elif circuit[i][j] == "S Gate": cirqCircuit.append(cirq.S(qubits[i])) elif circuit[i][j] == "T Gate": cirqCircuit.append(cirq.T(qubits[i])) elif circuit[i][j] == "Identity": pass elif circuit[i][j] == "CNot Gate": if controlFirst: cirqCircuit.append(cNotGate(control, qubits[i])) else: cirqCircuit.append(cNotGate(qubits[i + 1], qubits[i])) elif circuit[i][j] == "Swap Gate": cirqCircuit.append(cirq.swapGate(control, qubits[i])) elif circuit[i][j] == "Deutsch OracleC": pass elif circuit[i][j] == "Deutsch Oracle": if randint(0, 1) == 1: cirqCircuit.append(cNotGate(qubits[i - 1], qubits[i])) else: pass elif circuit[i][j] == "Fredkin Gate": cirqCircuit.append( cirq.CSWAP(qubits[i], qubits[i + 1], qubits[i + 2])) elif circuit[i][j] == "Toffoli Gate": cirqCircuit.append( cirq.TOFFOLI(qubits[i - 2], qubits[i - 1], qubits[i])) elif "Control" in circuit[i][j]: if not controlFirst: control = qubits[i] controlFirst = True elif "Measurement" in circuit[i][j]: cirqCircuit.append( cirq.measure(qubits[i], key=str(i) + " " + str(j))) if DEBUG: print( "Class: cirqSim Function: buildCirqCircuit Line: 42 Output: cirqCircuit after being completely build" ) print(cirqCircuit) return cirqCircuit
def expected_values(params): sol = [] for i in range(2): qs = cirq.LineQubit.range(n + 2) circuit = cirq.Circuit() circuit.append(cirq.X(qs[n])) cg = cirq.ControlledGate(ParametrizedGate()) circuit.append(cirq.H(qs[n + 1])) circuit.append(cirq.S(qs[n + 1]) ** i) circuit.append(cg(qs[n + 1], *[qs[i] for i in range(n + 1)])) circuit.append(cirq.H(qs[n + 1])) circuit.append(cirq.measure(qs[n + 1])) circuit = ansatz(params) + circuit s = cirq.Simulator() rep = 1000 sol.append(s.run(circuit, repetitions = rep)) real = 2 * int(str(sol[0]).count('0')) / rep - 1 img = - 2 * int(str(sol[1]).count('0')) / rep + 1 if np.sin(L * gamma * np.pi) - img < 0: return 3 else: return np.abs(np.cos(L * gamma * np.pi) - real)
def single_qubits(string, qubit): assert len(string) == 1 if string == 'X': yield cirq.H(qubit) elif string == 'Y': yield cirq.inverse(cirq.S(qubit)) yield cirq.H(qubit)
def random_circuit(self, nr_qubits, nr_gates): c = cirq.Circuit() qubits = [] for i in range(nr_qubits): qubits.append(cirq.NamedQubit("q" + str(i))) # S 0, T 1, H 2, CNOT 3 for i in range(nr_gates): r_gate_type = random.randint(0, 3) r_qub = random.randint(0, len(qubits) - 1) if r_gate_type == 0: c.append(cirq.S(qubits[r_qub])) elif r_gate_type == 1: c.append(cirq.T(qubits[r_qub])) elif r_gate_type == 2: c.append(cirq.H(qubits[r_qub])) elif r_gate_type == 3: r_qub2 = random.randint(0, len(qubits) - 1) while r_qub2 == r_qub: r_qub2 = random.randint(0, len(qubits) - 1) c.append( cirq.CNOT(control=qubits[r_qub], target=qubits[r_qub2])) # print(c.to_qasm()) return c.to_qasm()
def sampled_bloch_vector_of(qubit, circuit, reps=1000000): """sampled_bloch_vector_of: get bloch vector of a specified qubit by sampling. :param qubit: qubit to sample bloch vector of :param circuit: circuit to evaluate before sampling :param reps: number of measurements on each qubit """ sim = cirq.Simulator() C = circuit.copy() C.append([cirq.measure(qubit, key='z')]) meas = sim.run(C, repetitions=reps).measurements['z'] z = array(list(map(int, meas))).mean() C = circuit.copy() C.append([ cirq.inverse(cirq.S(qubit)), cirq.H(qubit), cirq.measure(qubit, key='y') ]) meas = sim.run(C, repetitions=reps).measurements['y'] y = array(list(map(int, meas))).mean() C = circuit.copy() C.append([cirq.H(qubit), cirq.measure(qubit, key='x')]) meas = sim.run(C, repetitions=reps).measurements['x'] x = array(list(map(int, meas))).mean() return -2 * array([x, y, z]) + 1
def type_circuit(n): type_x = [[cirq.X(LineQubit(i)), 1, matrix_type(i, n, NOT)] for i in range(n)] type_h = [[cirq.H(LineQubit(i)), 1, matrix_type(i, n, H)] for i in range(n)] type_z = [[cirq.Z(LineQubit(i)), 1, matrix_type(i, n, Z)] for i in range(n)] type_s = [[cirq.S(LineQubit(i)), 1, matrix_type(i, n, S)] for i in range(n)] type_sdg = [[(cirq.S**-1)(LineQubit(i)), 1, matrix_type(i, n, Sdg)] for i in range(n)] type_t = [[cirq.T(LineQubit(i)), 1, matrix_type(i, n, T)] for i in range(n)] type_tdg = [[(cirq.T**-1)(LineQubit(i)), 1, matrix_type(i, n, Tdg)] for i in range(1, n)] type_cx = [[ cirq.CNOT(LineQubit(i), LineQubit(j)), 3, matrix_type1(i, j, n, NOT) ] for i in range(n) for j in range(n) if i != j] type_cz = [[ cirq.CZ(LineQubit(i), LineQubit(j)), 3, matrix_type1(i, j, n, Z) ] for i in range(n) for j in range(n) if i != j] type_swap = [[ cirq.SWAP(LineQubit(i), LineQubit(j)), 9, matrix_type2(i, j, n, NOT) ] for i in range(n) for j in range(i + 1, n)] type_all = type_x + type_h + type_z + type_s + type_t + type_sdg + type_tdg + type_cx + type_cz + type_swap # type_all = type_cx print(type_all) show_circuit(type_all) print('一共{}种情况\n'.format(len(type_all))) return type_all
def get_match_circuit() -> cirq.Circuit: qubits = [cirq.LineQubit(i) for i in range(9)] g = cirq.CZPowGate(exponent=0.1) zz = cirq.ZZPowGate(exponent=0.3) px = cirq.PhasedXPowGate(phase_exponent=0.6, exponent=0.2) circ = cirq.Circuit( [ cirq.H(qubits[0]), cirq.X(qubits[1]), cirq.Y(qubits[2]), cirq.Z(qubits[3]), cirq.S(qubits[4]), cirq.CNOT(qubits[1], qubits[4]), cirq.T(qubits[3]), cirq.CNOT(qubits[6], qubits[8]), cirq.I(qubits[5]), cirq.XPowGate(exponent=0.1)(qubits[5]), cirq.YPowGate(exponent=0.1)(qubits[6]), cirq.ZPowGate(exponent=0.1)(qubits[7]), g(qubits[2], qubits[3]), zz(qubits[3], qubits[4]), px(qubits[6]), cirq.CZ(qubits[2], qubits[3]), cirq.ISWAP(qubits[4], qubits[5]), cirq.FSimGate(1.4, 0.7)(qubits[6], qubits[7]), cirq.google.SYC(qubits[3], qubits[0]), cirq.PhasedISwapPowGate(phase_exponent=0.7, exponent=0.8)( qubits[3], qubits[4]), cirq.GlobalPhaseOperation(1j), cirq.measure_each(*qubits[3:-2]), ], strategy=InsertStrategy.EARLIEST, ) return circ
def test_clifford_circuit_2(qubits, split): circuit = cirq.Circuit() np.random.seed(2) for _ in range(50): x = np.random.randint(7) if x == 0: circuit.append(cirq.X(np.random.choice(qubits))) # coverage: ignore elif x == 1: circuit.append(cirq.Z(np.random.choice(qubits))) # coverage: ignore elif x == 2: circuit.append(cirq.Y(np.random.choice(qubits))) # coverage: ignore elif x == 3: circuit.append(cirq.S(np.random.choice(qubits))) # coverage: ignore elif x == 4: circuit.append(cirq.H(np.random.choice(qubits))) # coverage: ignore elif x == 5: circuit.append(cirq.CNOT(qubits[0], qubits[1])) # coverage: ignore elif x == 6: circuit.append(cirq.CZ(qubits[0], qubits[1])) # coverage: ignore circuit.append(cirq.measure(qubits[0])) result = cirq.CliffordSimulator(split_untangled_states=split).run(circuit, repetitions=100) assert sum(result.measurements['q(0)'])[0] < 80 assert sum(result.measurements['q(0)'])[0] > 20
def QNPU2B(l_old,l_new,n): ctrl,q0,q1 = [cirq.GridQubit(0, 0), cirq.GridQubit(0, 1), cirq.GridQubit(0, 2)] U1=cirq.ControlledGate(U(l_old)) U2=cirq.ControlledGate(cirq.inverse(U(l_new))) circuit = cirq.Circuit(cirq.H(ctrl), cirq.S(ctrl),U1.on(ctrl,q0,q1), cirq.CNOT(ctrl,q1), cirq.TOFFOLI(ctrl,q1,q0), U2.on(ctrl,q0,q1), cirq.H(ctrl), cirq.measure(ctrl,key='c'), strategy=cirq.InsertStrategy.EARLIEST) simulator = cirq.Simulator() result=simulator.run(circuit, repetitions=n) m=result.histogram(key='c') for i,j in m.items(): if i==0: term=2*(j/n)-1 elif i==1: term=1-2*(j/n) return term
def test_clifford_circuit(split): (q0, q1) = (cirq.LineQubit(0), cirq.LineQubit(1)) circuit = cirq.Circuit() np.random.seed(0) for _ in range(100): x = np.random.randint(7) if x == 0: circuit.append(cirq.X(np.random.choice((q0, q1)))) elif x == 1: circuit.append(cirq.Z(np.random.choice((q0, q1)))) elif x == 2: circuit.append(cirq.Y(np.random.choice((q0, q1)))) elif x == 3: circuit.append(cirq.S(np.random.choice((q0, q1)))) elif x == 4: circuit.append(cirq.H(np.random.choice((q0, q1)))) elif x == 5: circuit.append(cirq.CNOT(q0, q1)) elif x == 6: circuit.append(cirq.CZ(q0, q1)) clifford_simulator = cirq.CliffordSimulator(split_untangled_states=split) state_vector_simulator = cirq.Simulator() np.testing.assert_almost_equal( clifford_simulator.simulate(circuit).final_state.state_vector(), state_vector_simulator.simulate(circuit).final_state_vector, )
def test_default_validation_and_inverse(): class TestGate(cirq.Gate): def _num_qubits_(self): return 2 def _decompose_(self, qubits): a, b = qubits yield cirq.Z(a) yield cirq.S(b) yield cirq.X(a) def __eq__(self, other): return isinstance(other, TestGate) def __repr__(self): return 'TestGate()' a, b = cirq.LineQubit.range(2) with pytest.raises(ValueError, match='number of qubits'): TestGate().on(a) t = TestGate().on(a, b) i = t ** -1 assert i ** -1 == t assert t ** -1 == i assert cirq.decompose(i) == [cirq.X(a), cirq.S(b) ** -1, cirq.Z(a)] cirq.testing.assert_allclose_up_to_global_phase( cirq.unitary(i), cirq.unitary(t).conj().T, atol=1e-8 ) cirq.testing.assert_implements_consistent_protocols(i, local_vals={'TestGate': TestGate})
def test_clifford_state_stabilizers(): (q0, q1, q2) = (cirq.LineQubit(0), cirq.LineQubit(1), cirq.LineQubit(2)) state = cirq.CliffordState(qubit_map={q0: 0, q1: 1, q2: 2}) state.apply_unitary(cirq.H(q0)) state.apply_unitary(cirq.H(q1)) state.apply_unitary(cirq.S(q1)) assert (state.stabilizers() == ['X0', 'Y1', 'Z2'])
def test_cannot_multiply_by_non_paulis(): q = cirq.NamedQubit('q') with pytest.raises(TypeError): _ = cirq.X(q) * cirq.Z(q)**0.5 with pytest.raises(TypeError): _ = cirq.Z(q)**0.5 * cirq.X(q) with pytest.raises(TypeError): _ = cirq.Y(q) * cirq.S(q)
def test_clifford_tableau_str(): (q0, q1, q2) = (cirq.LineQubit(0), cirq.LineQubit(1), cirq.LineQubit(2)) state = cirq.CliffordState(qubit_map={q0: 0, q1: 1, q2: 2}) state.apply_unitary(cirq.H(q0)) state.apply_unitary(cirq.H(q1)) state.apply_unitary(cirq.S(q1)) assert str(state.tableau) == "+ X I I \n+ I Y I \n+ I I Z "