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 "
