def test_google_v2_supremacy_bristlecone():
pytest.importorskip("cirq_google")
# Check instance consistency
with cirq.testing.assert_deprecated('_beyond_classical_',
deadline='v0.16',
count=2):
c = supremacy_v2.generate_boixo_2018_supremacy_circuits_v2_bristlecone(
n_rows=11, cz_depth=8, seed=0)
assert len(c) == 10
assert len(c.all_qubits()) == 70
assert len(list(c.findall_operations_with_gate_type(ops.CZPowGate))) == 119
assert len(list(c.findall_operations_with_gate_type(ops.XPowGate))) == 43
assert len(list(c.findall_operations_with_gate_type(ops.YPowGate))) == 69
assert isinstance(c.operation_at(GridQubit(2, 5), 2).gate, ops.YPowGate)
assert isinstance(c.operation_at(GridQubit(3, 2), 2).gate, ops.XPowGate)
assert isinstance(c.operation_at(GridQubit(1, 6), 3).gate, ops.XPowGate)
# test smaller subgraph
with cirq.testing.assert_deprecated('_beyond_classical_',
deadline='v0.16',
count=2):
c = supremacy_v2.generate_boixo_2018_supremacy_circuits_v2_bristlecone(
n_rows=9, cz_depth=8, seed=0)
qubits = list(c.all_qubits())
qubits.sort()
assert len(qubits) == 48
assert isinstance(c.operation_at(qubits[5], 2).gate, ops.YPowGate)
assert isinstance(c.operation_at(qubits[7], 3).gate, ops.YPowGate)
assert len(list(c.findall_operations_with_gate_type(ops.CZPowGate))) == 79
assert len(list(c.findall_operations_with_gate_type(ops.XPowGate))) == 32
def test_two_qubit_state_tomography():
# Check that the density matrices of the four Bell states closely match
# the ideal cases.
simulator = sim.Simulator()
q_0 = GridQubit(0, 0)
q_1 = GridQubit(0, 1)
circuit_00 = circuits.Circuit.from_ops(ops.H(q_0), ops.CNOT(q_0, q_1))
circuit_01 = circuits.Circuit.from_ops(ops.X(q_1), ops.H(q_0),
ops.CNOT(q_0, q_1))
circuit_10 = circuits.Circuit.from_ops(ops.X(q_0), ops.H(q_0),
ops.CNOT(q_0, q_1))
circuit_11 = circuits.Circuit.from_ops(ops.X(q_0), ops.X(q_1), ops.H(q_0),
ops.CNOT(q_0, q_1))
act_rho_00 = two_qubit_state_tomography(simulator, q_0, q_1, circuit_00,
100000).data
act_rho_01 = two_qubit_state_tomography(simulator, q_0, q_1, circuit_01,
100000).data
act_rho_10 = two_qubit_state_tomography(simulator, q_0, q_1, circuit_10,
100000).data
act_rho_11 = two_qubit_state_tomography(simulator, q_0, q_1, circuit_11,
100000).data
tar_rho_00 = np.outer([1.0, 0, 0, 1.0], [1.0, 0, 0, 1.0]) / 2.0
tar_rho_01 = np.outer([0, 1.0, 1.0, 0], [0, 1.0, 1.0, 0]) / 2.0
tar_rho_10 = np.outer([1.0, 0, 0, -1.0], [1.0, 0, 0, -1.0]) / 2.0
tar_rho_11 = np.outer([0, 1.0, -1.0, 0], [0, 1.0, -1.0, 0]) / 2.0
np.testing.assert_almost_equal(act_rho_00, tar_rho_00, decimal=1)
np.testing.assert_almost_equal(act_rho_01, tar_rho_01, decimal=1)
np.testing.assert_almost_equal(act_rho_10, tar_rho_10, decimal=1)
np.testing.assert_almost_equal(act_rho_11, tar_rho_11, decimal=1)
def test_google_v2_supremacy_bristlecone():
# Check instance consistency
circuit = supremacy_v2.google_v2_supremacy_circuit_bristlecone(n_rows=11,
cz_depth=8,
seed=0)
assert len(circuit) == 10
assert len(circuit.all_qubits()) == 70
assert len(list(circuit.findall_operations_with_gate_type(
ops.CZPowGate))) == 119
assert len(list(circuit.findall_operations_with_gate_type(
ops.XPowGate))) == 43
assert len(list(circuit.findall_operations_with_gate_type(
ops.YPowGate))) == 69
assert isinstance(
circuit.operation_at(GridQubit(2, 5), 2).gate, ops.YPowGate)
assert isinstance(
circuit.operation_at(GridQubit(3, 2), 2).gate, ops.XPowGate)
assert isinstance(
circuit.operation_at(GridQubit(1, 6), 3).gate, ops.XPowGate)
#test smaller subgraph
circuit = supremacy_v2.google_v2_supremacy_circuit_bristlecone(n_rows=9,
cz_depth=8,
seed=0)
qubits = list(circuit.all_qubits())
qubits.sort()
assert len(qubits) == 48
assert isinstance(circuit.operation_at(qubits[5], 2).gate, ops.YPowGate)
assert isinstance(circuit.operation_at(qubits[7], 3).gate, ops.YPowGate)
assert len(list(circuit.findall_operations_with_gate_type(
ops.CZPowGate))) == 79
assert len(list(circuit.findall_operations_with_gate_type(
ops.XPowGate))) == 32
def test_two_qubit_randomized_benchmarking():
# Check that the ground state population at the end of the Clifford
# sequences is always unity.
simulator = sim.Simulator()
q_0 = GridQubit(0, 0)
q_1 = GridQubit(0, 1)
num_cfds = range(5, 20, 5)
results = two_qubit_randomized_benchmarking(simulator, q_0, q_1,
num_clifford_range=num_cfds)
g_pops = np.asarray(results.data)[:, 1]
assert np.isclose(np.mean(g_pops), 1.0)
def test_two_qubit_state_tomography():
# Check that the density matrices of the four Bell states closely match
# the ideal cases. In addition, check that the output states of
# single-qubit rotations (H, H), (X/2, Y/2), (Y/2, X/2) have the correct
# density matrices.
simulator = sim.Simulator()
q_0 = GridQubit(0, 0)
q_1 = GridQubit(0, 1)
circuit_00 = circuits.Circuit.from_ops(ops.H(q_0), ops.CNOT(q_0, q_1))
circuit_01 = circuits.Circuit.from_ops(ops.X(q_1), ops.H(q_0),
ops.CNOT(q_0, q_1))
circuit_10 = circuits.Circuit.from_ops(ops.X(q_0), ops.H(q_0),
ops.CNOT(q_0, q_1))
circuit_11 = circuits.Circuit.from_ops(ops.X(q_0), ops.X(q_1), ops.H(q_0),
ops.CNOT(q_0, q_1))
circuit_hh = circuits.Circuit.from_ops(ops.H(q_0), ops.H(q_1))
circuit_xy = circuits.Circuit.from_ops(ops.X(q_0)**0.5, ops.Y(q_1)**0.5)
circuit_yx = circuits.Circuit.from_ops(ops.Y(q_0)**0.5, ops.X(q_1)**0.5)
act_rho_00 = two_qubit_state_tomography(simulator, q_0, q_1, circuit_00,
1000).data
act_rho_01 = two_qubit_state_tomography(simulator, q_0, q_1, circuit_01,
1000).data
act_rho_10 = two_qubit_state_tomography(simulator, q_0, q_1, circuit_10,
1000).data
act_rho_11 = two_qubit_state_tomography(simulator, q_0, q_1, circuit_11,
1000).data
act_rho_hh = two_qubit_state_tomography(simulator, q_0, q_1, circuit_hh,
1000).data
act_rho_xy = two_qubit_state_tomography(simulator, q_0, q_1, circuit_xy,
1000).data
act_rho_yx = two_qubit_state_tomography(simulator, q_0, q_1, circuit_yx,
1000).data
tar_rho_00 = np.outer([1.0, 0, 0, 1.0], [1.0, 0, 0, 1.0]) * 0.5
tar_rho_01 = np.outer([0, 1.0, 1.0, 0], [0, 1.0, 1.0, 0]) * 0.5
tar_rho_10 = np.outer([1.0, 0, 0, -1.0], [1.0, 0, 0, -1.0]) * 0.5
tar_rho_11 = np.outer([0, 1.0, -1.0, 0], [0, 1.0, -1.0, 0]) * 0.5
tar_rho_hh = np.outer([0.5, 0.5, 0.5, 0.5], [0.5, 0.5, 0.5, 0.5])
tar_rho_xy = np.outer([0.5, 0.5, -0.5j, -0.5j], [0.5, 0.5, 0.5j, 0.5j])
tar_rho_yx = np.outer([0.5, -0.5j, 0.5, -0.5j], [0.5, 0.5j, 0.5, 0.5j])
np.testing.assert_almost_equal(act_rho_00, tar_rho_00, decimal=1)
np.testing.assert_almost_equal(act_rho_01, tar_rho_01, decimal=1)
np.testing.assert_almost_equal(act_rho_10, tar_rho_10, decimal=1)
np.testing.assert_almost_equal(act_rho_11, tar_rho_11, decimal=1)
np.testing.assert_almost_equal(act_rho_hh, tar_rho_hh, decimal=1)
np.testing.assert_almost_equal(act_rho_xy, tar_rho_xy, decimal=1)
np.testing.assert_almost_equal(act_rho_yx, tar_rho_yx, decimal=1)
def test_qubitop_to_paulisum_z0z1_operator(self):
# Given
qubit_operator = QubitOperator("Z0 Z1", -1.5)
expected_qubits = (GridQubit(0, 0), GridQubit(1, 0))
expected_paulisum = (PauliSum() +
PauliString(Z.on(expected_qubits[0])) *
PauliString(Z.on(expected_qubits[1])) * -1.5)
# When
paulisum = qubitop_to_paulisum(qubit_operator)
# Then
self.assertEqual(paulisum.qubits, expected_qubits)
self.assertEqual(paulisum, expected_paulisum)
def test_simulate(self):
compressed_status = [True, False]
rad = 0.75
pauli_word = PauliWord("XZYX")
for initial_state in range(2**len(pauli_word)):
results = []
for is_compressed in compressed_status:
simulator = Simulator()
circuit = Circuit()
qubits = [GridQubit(i, j) for i in range(3) for j in range(3)]
gate = PauliWordExpGate(rad, pauli_word)
operation = gate.on(*qubits[0:len(gate.pauli_word)])
if is_compressed:
circuit.append(operation)
else:
circuit.append(cirq.decompose(operation))
result = simulator.simulate(
circuit, initial_state=initial_state
) # type: cirq.SimulationTrialResult
# print(circuit)
print(result.final_state)
# print(cirq.unitary(circuit_compressed))
results.append(result)
self.assertTrue(
np.allclose(results[0].final_state,
results[1].final_state,
rtol=1e-4,
atol=1e-5))
def test_google_v2_supremacy_circuit():
circuit = supremacy_v2.google_v2_supremacy_circuit_grid(n_rows=4,
n_cols=5,
cz_depth=9,
seed=0)
# We check that is exactly circuit inst_4x5_10_0
# in github.com/sboixo/GRCS cz_v2
assert len(circuit) == 11
assert len(list(circuit.findall_operations_with_gate_type(
ops.CZPowGate))) == 35
assert len(list(circuit.findall_operations_with_gate_type(
ops.XPowGate))) == 15
assert len(list(circuit.findall_operations_with_gate_type(
ops.YPowGate))) == 23
assert len(list(circuit.findall_operations_with_gate_type(
ops.ZPowGate))) == 32
assert len(list(circuit.findall_operations_with_gate_type(
ops.HPowGate))) == 40
qubits = [GridQubit(i, j) for i in range(4) for j in range(5)]
assert isinstance(circuit.operation_at(qubits[0], 2).gate, ops.YPowGate)
assert isinstance(circuit.operation_at(qubits[1], 2).gate, ops.YPowGate)
assert isinstance(circuit.operation_at(qubits[8], 2).gate, ops.XPowGate)
assert circuit.operation_at(qubits[0], 1).gate == ops.CZ
assert circuit.operation_at(qubits[5], 2).gate == ops.CZ
assert circuit.operation_at(qubits[8], 3).gate == ops.CZ
assert circuit.operation_at(qubits[13], 4).gate == ops.CZ
assert circuit.operation_at(qubits[12], 5).gate == ops.CZ
assert circuit.operation_at(qubits[13], 6).gate == ops.CZ
assert circuit.operation_at(qubits[14], 7).gate == ops.CZ
def exponentiation_circuit(param):
circuit = Circuit()
if is_constant(pauli_string):
PHASE = ZPowGate(exponent=(-param * coeff)/np.pi)
circuit.append([X(GridQubit(0, 0))],
strategy=InsertStrategy.EARLIEST)
circuit.append([PHASE(GridQubit(0, 0))],
strategy=InsertStrategy.EARLIEST)
circuit.append([X(GridQubit(0, 0))],
strategy=InsertStrategy.EARLIEST)
circuit.append([PHASE(GridQubit(0, 0))],
strategy=InsertStrategy.EARLIEST)
elif is_zero(pauli_string):
pass
else:
circuit += exponentiate_general_case(pauli_string, param)
return circuit
def setUp(self) -> None:
self.circuit_decomposed = Circuit()
self.circuit_compressed = Circuit()
self.qubits = [GridQubit(i, j) for i in range(3) for j in range(3)]
self.gate = PauliWordExpGate(0.25, PauliWord("IXXZ"))
self.operation = self.gate.on(*self.qubits[0:4])
self.circuit_decomposed.append(cirq.decompose(self.operation))
self.circuit_compressed.append(self.operation)
def test_symbolic_circuit(self):
circuit = Circuit()
qubits = [GridQubit(i, j) for i in range(3) for j in range(3)]
gate = PauliWordExpGate(sympy.Symbol("t"), PauliWord("XXZX"))
operation = gate.on(qubits[0], qubits[1], qubits[3], qubits[2])
circuit.append(cirq.decompose(operation))
circuit.append(operation)
print(circuit)
def test_tomography_plot_raises_for_incorrect_number_of_axes():
simulator = sim.Simulator()
qubit = GridQubit(0, 0)
circuit = circuits.Circuit(ops.X(qubit)**0.5)
result = single_qubit_state_tomography(simulator, qubit, circuit, 1000)
with pytest.raises(TypeError): # ax is not a List[plt.Axes]
ax = plt.subplot()
result.plot(ax)
with pytest.raises(ValueError):
_, axes = plt.subplots(1, 3)
result.plot(axes)
def test_simplest_case(self):
circuit = Circuit()
qubits = [GridQubit(i, j) for i in range(3) for j in range(3)]
gate = PauliWordExpGate(0.1, PauliWord("II"))
circuit.append(gate.on(qubits[2], qubits[0]))
# If use the following line instead, `print(circuit)` will show nothing:
# circuit.append(cirq.decompose(gate.on(qubits[2], qubits[0])))
print(circuit)
self.assertTrue(np.allclose(cirq.unitary(gate), np.identity(4)))
def test_symbolic_gate(self):
sym_circuit = Circuit()
qubits = [GridQubit(i, j) for i in range(3) for j in range(3)]
gate = TwoPauliExpGate(Pauli("X"), Pauli("Z"), sympy.Symbol("rad"))
sym_circuit.append(gate.on(qubits[0], qubits[2]))
self.assertEqual(
str(sym_circuit), "(0, 0): ───^X────────\n"
" │\n"
"(0, 2): ───^Z{rad}───")
def test_rabi_oscillations():
# Check that the excited state population matches the ideal case within a
# small statistical error.
simulator = sim.Simulator()
qubit = GridQubit(0, 0)
results = rabi_oscillations(simulator, qubit, np.pi, repetitions=1000)
data = np.asarray(results.data)
angles = data[:, 0]
actual_pops = data[:, 1]
target_pops = 0.5 - 0.5 * np.cos(angles)
rms_err = np.sqrt(np.mean((target_pops - actual_pops)**2))
assert rms_err < 0.1
def define_grid_qubits(size=2):
"""
Defines qubits on a square grid of given size
Parameters
----------
size : (int) size of the grid. Default=2 ,i.e, a grid containing four qubits
(0,0), (0,1), (1,0) and (1,1)
Returns
-------
a list of GridQubits defined on a grid of given size
"""
return [GridQubit(i, j) for i in range(size) for j in range(size)]
def define_graph(qubits=[(GridQubit(0, 0), GridQubit(0, 1))],
number_of_vertices=2):
"""
Creates a cycle graph as a list of GridQubit pairs for the given number of vertices
Parameters
----------
qubits : (list of GridQubits). Default is
one pair of qubits (0,0) and (0,1) representing a
two vertex graph
number_of_vertices : (int) number of vertices the cycle graph must contain.
Default=2
Returns
-------
a list of GridQubit pairs representing a cycle graph containing the given number of vertices
"""
if len(qubits) == 1:
return qubits
return [(qubits[i % number_of_vertices],
qubits[(i + 1) % number_of_vertices])
for i in range(number_of_vertices)]
def test_symbolic_gate(self):
sym_circuit = Circuit()
qubits = [GridQubit(i, j) for i in range(3) for j in range(3)]
gate = GlobalPhaseGate(sympy.Symbol("rad"))
sym_circuit.append(gate.on(qubits[0]))
print(sym_circuit)
rad_list = np.random.rand(10) * 5
for rad in rad_list:
simulator = Simulator()
circuit = cirq.resolve_parameters(sym_circuit, {"rad": rad})
result = simulator.simulate(circuit)
self.assertTrue(
np.allclose(result.final_state,
np.exp(1.0j * rad * np.pi) * np.array([1, 0])))
def test_single_qubit_state_tomography():
# Check that the density matrices of the output states of X/2, Y/2 and
# H + Y gates closely match the ideal cases.
simulator = sim.Simulator()
qubit = GridQubit(0, 0)
circuit_1 = circuits.Circuit(ops.X(qubit)**0.5)
circuit_2 = circuits.Circuit(ops.Y(qubit)**0.5)
circuit_3 = circuits.Circuit(ops.H(qubit), ops.Y(qubit))
act_rho_1 = single_qubit_state_tomography(simulator, qubit, circuit_1,
1000).data
act_rho_2 = single_qubit_state_tomography(simulator, qubit, circuit_2,
1000).data
act_rho_3 = single_qubit_state_tomography(simulator, qubit, circuit_3,
1000).data
tar_rho_1 = np.array([[0.5, 0.5j], [-0.5j, 0.5]])
tar_rho_2 = np.array([[0.5, 0.5], [0.5, 0.5]])
tar_rho_3 = np.array([[0.5, -0.5], [-0.5, 0.5]])
np.testing.assert_almost_equal(act_rho_1, tar_rho_1, decimal=1)
np.testing.assert_almost_equal(act_rho_2, tar_rho_2, decimal=1)
np.testing.assert_almost_equal(act_rho_3, tar_rho_3, decimal=1)
}
g_1, g_2, g_12 = 2, 1, 0
gp = math.sqrt(abs((g_1 - g_2)**2 + 4 * g_12**2))
if g_1 > g_2:
gp = -gp
g_a, g_b = (g_1 + g_2 - gp) / 2, (g_1 + g_2 + gp) / 2
u = math.sqrt(abs((gp + g_1 - g_2) / (2 * gp)))
eps = .001
circuit = cirq.Circuit()
simulator = Simulator()
circuit.append([[X((qubit)) for qubit in pReg[i]] for i in range(N + n_i)])
circuit.append([[X((qubit)) for qubit in hReg[i]] for i in range(N)])
w_hReg.extend([GridQubit(N + n_i, j) for j in range(L - 1)])
eReg.extend([GridQubit(N + n_i, L - 1)])
wReg.extend([GridQubit(N + n_i, j) for j in range(L, L + 5)])
n_phiReg.extend([GridQubit(N + n_i + 1, j) for j in range(L)])
w_phiReg.extend([GridQubit(N + n_i + 1, j) for j in range(L, 2 * L - 1)])
n_aReg.extend([GridQubit(N + n_i + 2, j) for j in range(L)])
w_aReg.extend([GridQubit(N + n_i + 2, j) for j in range(L, 2 * L - 1)])
n_bReg.extend([GridQubit(N + n_i + 3, j) for j in range(L)])
w_bReg.extend([GridQubit(N + n_i + 3, j) for j in range(L, 2 * L - 1)])
timeStepList, P_aList, P_bList, P_phiList, Delta_aList, Delta_bList, Delta_phiList = [], [], [], [], [], [], []
cc.populateParameterLists(N, timeStepList, P_aList, P_bList, P_phiList,
Delta_aList, Delta_bList, Delta_phiList, g_a, g_b,
eps)
cc.U_h(circuit, l, n_i, m, n_phiReg, w_phiReg, n_aReg, w_aReg, n_bReg, w_bReg,
def allocateQubs(N, n_i, L, pReg, hReg, w_hReg, eReg, wReg, n_aReg, w_aReg,
n_bReg, w_bReg, n_phiReg, w_phiReg):
"""method 1: Pro: keeps qubits geometrically close (in rectangle), Con: Ordering is weird so hard to debug"""
pReg.extend([[GridQubit(i, j) for j in range(3)] for i in range(N + n_i)])
hReg.extend([[GridQubit(i, j) for j in range(4, 4 + L)] for i in range(N)])
w_hReg.extend([GridQubit(N + n_i, j) for j in range(L - 1)])
eReg.extend([GridQubit(N + n_i, L - 1)])
wReg.extend([GridQubit(N + n_i, j) for j in range(L, L + 5)])
n_phiReg.extend([GridQubit(N + n_i + 1, j) for j in range(L)])
w_phiReg.extend([GridQubit(N + n_i + 1, j) for j in range(L, 2 * L - 1)])
n_aReg.extend([GridQubit(N + n_i + 2, j) for j in range(L)])
w_aReg.extend([GridQubit(N + n_i + 2, j) for j in range(L, 2 * L - 1)])
n_bReg.extend([GridQubit(N + n_i + 3, j) for j in range(L)])
w_bReg.extend([GridQubit(N + n_i + 3, j) for j in range(L, 2 * L - 1)])
def setUp(self) -> None:
self.circuit = Circuit()
self.qubits = [GridQubit(i, j) for i in range(3) for j in range(3)]
self.gate = TwoPauliExpGate(Pauli("X"), Pauli("Z"), 0.5)
self.circuit.append(self.gate.on(self.qubits[0], self.qubits[2]))