def test_qubit_order_to_wavefunction_order_matches_np_kron(scheduler):
simulator = cg.XmonSimulator()
zero = [1, 0]
one = [0, 1]
result = simulate(simulator,
cirq.Circuit.from_ops(cirq.X(Q1)),
scheduler,
qubit_order=[Q1, Q2])
assert cirq.allclose_up_to_global_phase(result.final_state,
np.kron(one, zero))
result = simulate(simulator,
cirq.Circuit.from_ops(cirq.X(Q1)),
scheduler,
qubit_order=[Q2, Q1])
assert cirq.allclose_up_to_global_phase(result.final_state,
np.kron(zero, one))
result = simulate(simulator,
cirq.Circuit.from_ops(cirq.X(Q1)),
scheduler,
qubit_order=cirq.QubitOrder.sorted_by(repr))
assert cirq.allclose_up_to_global_phase(result.final_state, np.array(one))
result = simulate(simulator,
cirq.Circuit.from_ops(cirq.X(Q1), cirq.Z(Q2)),
scheduler,
qubit_order=cirq.QubitOrder.sorted_by(repr))
assert cirq.allclose_up_to_global_phase(result.final_state,
np.kron(one, zero))
def test_qubit_order_to_wavefunction_order_matches_np_kron(scheduler):
simulator = cg.XmonSimulator()
zero = [1, 0]
one = [0, 1]
result = simulate(simulator,
cirq.Circuit.from_ops(cirq.X(Q1)),
scheduler,
qubit_order=[Q1, Q2])
assert cirq.allclose_up_to_global_phase(
result.final_state, np.kron(one, zero))
result = simulate(simulator,
cirq.Circuit.from_ops(cirq.X(Q1)),
scheduler,
qubit_order=[Q2, Q1])
assert cirq.allclose_up_to_global_phase(
result.final_state, np.kron(zero, one))
result = simulate(simulator,
cirq.Circuit.from_ops(cirq.X(Q1)),
scheduler,
qubit_order=cirq.QubitOrder.sorted_by(repr))
assert cirq.allclose_up_to_global_phase(
result.final_state, np.array(one))
result = simulate(simulator,
cirq.Circuit.from_ops(cirq.X(Q1), cirq.Z(Q2)),
scheduler,
qubit_order=cirq.QubitOrder.sorted_by(repr))
assert cirq.allclose_up_to_global_phase(
result.final_state, np.kron(one, zero))
def test_bit_flip_order_to_wavefunction_order_matches_np_kron(scheduler):
simulator = cg.XmonSimulator()
result = simulate(simulator,
cirq.Circuit.from_ops(cirq.X(Q1)),
scheduler,
qubit_order=[Q1, Q2, Q3])
assert cirq.allclose_up_to_global_phase(result.final_state,
np.array([0, 0, 0, 0, 1, 0, 0, 0]))
result = simulate(simulator,
cirq.Circuit.from_ops(cirq.X(Q3)),
scheduler,
qubit_order=[Q1, Q2, Q3])
assert cirq.allclose_up_to_global_phase(result.final_state,
np.array([0, 1, 0, 0, 0, 0, 0, 0]))
result = simulate(simulator,
cirq.Circuit.from_ops(cirq.X(Q3)),
scheduler,
qubit_order=[Q3, Q2, Q1])
assert cirq.allclose_up_to_global_phase(result.final_state,
np.array([0, 0, 0, 0, 1, 0, 0, 0]))
result = simulate(simulator,
cirq.Circuit.from_ops(cirq.X(Q3)),
scheduler,
qubit_order=[Q2, Q3, Q1])
assert cirq.allclose_up_to_global_phase(result.final_state,
np.array([0, 0, 1, 0, 0, 0, 0, 0]))
def test_bit_flip_order_to_wavefunction_order_matches_np_kron(scheduler):
simulator = cg.XmonSimulator()
result = simulate(simulator,
cirq.Circuit.from_ops(cirq.X(Q1)),
scheduler,
qubit_order=[Q1, Q2, Q3])
assert cirq.allclose_up_to_global_phase(
result.final_state, np.array([0, 0, 0, 0, 1, 0, 0, 0]))
result = simulate(simulator,
cirq.Circuit.from_ops(cirq.X(Q3)),
scheduler,
qubit_order=[Q1, Q2, Q3])
assert cirq.allclose_up_to_global_phase(
result.final_state, np.array([0, 1, 0, 0, 0, 0, 0, 0]))
result = simulate(simulator,
cirq.Circuit.from_ops(cirq.X(Q3)),
scheduler,
qubit_order=[Q3, Q2, Q1])
assert cirq.allclose_up_to_global_phase(
result.final_state, np.array([0, 0, 0, 0, 1, 0, 0, 0]))
result = simulate(simulator,
cirq.Circuit.from_ops(cirq.X(Q3)),
scheduler,
qubit_order=[Q2, Q3, Q1])
assert cirq.allclose_up_to_global_phase(
result.final_state, np.array([0, 0, 1, 0, 0, 0, 0, 0]))
def test_allclose_up_to_global_phase():
assert cirq.allclose_up_to_global_phase(
np.array([1]),
np.array([1j]))
assert cirq.allclose_up_to_global_phase(
np.array([[1]]),
np.array([[1]]))
assert cirq.allclose_up_to_global_phase(
np.array([[1]]),
np.array([[-1]]))
assert cirq.allclose_up_to_global_phase(
np.array([[0]]),
np.array([[0]]))
assert cirq.allclose_up_to_global_phase(
np.array([[1, 2]]),
np.array([[1j, 2j]]))
assert cirq.allclose_up_to_global_phase(
np.array([[1, 2.0000000001]]),
np.array([[1j, 2j]]))
assert not cirq.allclose_up_to_global_phase(
np.array([[1]]),
np.array([[1, 0]]))
assert not cirq.allclose_up_to_global_phase(
np.array([[1]]),
np.array([[2]]))
assert not cirq.allclose_up_to_global_phase(
np.array([[1]]),
np.array([[2]]))
def test_convert_to_ion_gates():
q0 = cirq.GridQubit(0, 0)
q1 = cirq.GridQubit(0, 1)
op = cirq.CNOT(q0, q1)
circuit = cirq.Circuit()
with pytest.raises(TypeError):
cirq.ion.ConvertToIonGates().convert_one(circuit)
with pytest.raises(TypeError):
cirq.ion.ConvertToIonGates().convert_one(NoUnitary().on(q0))
no_unitary_op = NoUnitary().on(q0)
assert cirq.ion.ConvertToIonGates(ignore_failures=True).convert_one(
no_unitary_op) == [no_unitary_op]
rx = cirq.ion.ConvertToIonGates().convert_one(OtherX().on(q0))
rop = cirq.ion.ConvertToIonGates().convert_one(op)
assert cirq.approx_eq(
rx, [cirq.PhasedXPowGate(phase_exponent=1.0).on(cirq.GridQubit(0, 0))])
assert cirq.approx_eq(rop, [
cirq.ry(np.pi / 2).on(op.qubits[0]),
cirq.ms(np.pi / 4).on(op.qubits[0], op.qubits[1]),
cirq.rx(-1 * np.pi / 2).on(op.qubits[0]),
cirq.rx(-1 * np.pi / 2).on(op.qubits[1]),
cirq.ry(-1 * np.pi / 2).on(op.qubits[0])
])
rcnot = cirq.ion.ConvertToIonGates().convert_one(OtherCNOT().on(q0, q1))
assert cirq.approx_eq([op for op in rcnot if len(op.qubits) > 1],
[cirq.ms(-0.5 * np.pi / 2).on(q0, q1)],
atol=1e-4)
assert cirq.allclose_up_to_global_phase(
cirq.unitary(cirq.Circuit(rcnot)), cirq.unitary(OtherCNOT().on(q0, q1)))
def _unitaries_allclose(circuit1, circuit2):
unitary1 = cirq.unitary(circuit1)
unitary2 = cirq.unitary(circuit2)
if unitary2.size == 1:
# Resize the unitary of empty circuits to be 4x4 for 2q gates
unitary2 = unitary2 * np.eye(unitary1.shape[0])
return cirq.allclose_up_to_global_phase(unitary1, unitary2)
def check_distinct(unitaries):
n = len(unitaries)
for i in range(n):
for j in range(i + 1, n):
Ui, Uj = unitaries[i], unitaries[j]
assert not cirq.allclose_up_to_global_phase(Ui,
Uj), f'{i}, {j}'
def test_controlled_op_to_gates_equivalent_on_known_and_random(mat):
qc = cirq.QubitId()
qt = cirq.QubitId()
operations = decompositions.controlled_op_to_native_gates(
control=qc, target=qt, operation=mat)
actual_effect = _operations_to_matrix(operations, (qc, qt))
intended_effect = cirq.kron_with_controls(cirq.CONTROL_TAG, mat)
assert cirq.allclose_up_to_global_phase(actual_effect, intended_effect)
def test_controlled_op_to_operations_equivalent_on_known_and_random(mat):
qc = cirq.NamedQubit('c')
qt = cirq.NamedQubit('qt')
operations = cirq.controlled_op_to_operations(
control=qc, target=qt, operation=mat)
actual_effect = _operations_to_matrix(operations, (qc, qt))
intended_effect = cirq.kron_with_controls(cirq.CONTROL_TAG, mat)
assert cirq.allclose_up_to_global_phase(actual_effect, intended_effect)
def test_from_characterizations_sqrt_iswap_simulates_correctly() -> None:
parameters_ab = cirq.google.PhasedFSimCharacterization(theta=0.6,
zeta=0.5,
chi=0.4,
gamma=0.3,
phi=0.2)
parameters_bc = cirq.google.PhasedFSimCharacterization(theta=0.8,
zeta=-0.5,
chi=-0.4,
gamma=-0.3,
phi=-0.2)
parameters_cd = cirq.google.PhasedFSimCharacterization(theta=0.1,
zeta=0.2,
chi=0.3,
gamma=0.4,
phi=0.5)
a, b, c, d = cirq.LineQubit.range(4)
circuit = cirq.Circuit([
[cirq.X(a), cirq.Y(c)],
[
cirq.FSimGate(np.pi / 4, 0.0).on(a, b),
cirq.FSimGate(np.pi / 4, 0.0).on(c, d)
],
[cirq.FSimGate(np.pi / 4, 0.0).on(c, b)],
])
expected_circuit = cirq.Circuit([
[cirq.X(a), cirq.X(c)],
[
cirq.PhasedFSimGate(**parameters_ab.asdict()).on(a, b),
cirq.PhasedFSimGate(**parameters_cd.asdict()).on(c, d),
],
[cirq.PhasedFSimGate(**parameters_bc.asdict()).on(b, c)],
])
engine_simulator = PhasedFSimEngineSimulator.create_from_characterizations_sqrt_iswap(
characterizations=[
cirq.google.PhasedFSimCalibrationResult(
gate=cirq.FSimGate(np.pi / 4, 0.0),
parameters={
(a, b): parameters_ab,
(c, d): parameters_cd
},
options=ALL_ANGLES_FLOQUET_PHASED_FSIM_CHARACTERIZATION,
),
cirq.google.PhasedFSimCalibrationResult(
gate=cirq.FSimGate(np.pi / 4, 0.0),
parameters={
(c, b): parameters_bc.parameters_for_qubits_swapped()
},
options=ALL_ANGLES_FLOQUET_PHASED_FSIM_CHARACTERIZATION,
),
])
actual = engine_simulator.final_state_vector(circuit)
expected = cirq.final_state_vector(expected_circuit)
assert cirq.allclose_up_to_global_phase(actual, expected)
def test_interchangable_qubits(gate):
q0, q1 = cirq.NamedQubit('q0'), cirq.NamedQubit('q1')
op0 = gate(q0, q1)
op1 = gate(q1, q0)
mat0 = cirq.Circuit.from_ops(op0, ).to_unitary_matrix()
mat1 = cirq.Circuit.from_ops(op1, ).to_unitary_matrix()
same = op0 == op1
same_check = cirq.allclose_up_to_global_phase(mat0, mat1)
assert same == same_check
def test_controlled_op_to_gates_equivalent_on_known_and_random(mat):
qc = cirq.QubitId()
qt = cirq.QubitId()
operations = decompositions.controlled_op_to_native_gates(control=qc,
target=qt,
operation=mat)
actual_effect = _operations_to_matrix(operations, (qc, qt))
intended_effect = cirq.kron_with_controls(cirq.CONTROL_TAG, mat)
assert cirq.allclose_up_to_global_phase(actual_effect, intended_effect)
def assert_ops_implement_unitary(q0,
q1,
operations,
intended_effect,
atol=0.01):
actual_effect = _operations_to_matrix(operations, (q0, q1))
assert cirq.allclose_up_to_global_phase(actual_effect,
intended_effect,
atol=atol)
def test_interchangeable_qubits(gate):
q0, q1 = cirq.NamedQubit('q0'), cirq.NamedQubit('q1')
op0 = gate(q0, q1)
op1 = gate(q1, q0)
mat0 = cirq.Circuit(op0).unitary()
mat1 = cirq.Circuit(op1).unitary()
same = op0 == op1
same_check = cirq.allclose_up_to_global_phase(mat0, mat1)
assert same == same_check
def test_from_dictionary_sqrt_iswap_simulates_correctly() -> None:
parameters_ab = cirq.google.PhasedFSimCharacterization(theta=0.6,
zeta=0.5,
chi=0.4,
gamma=0.3,
phi=0.2)
parameters_bc = cirq.google.PhasedFSimCharacterization(theta=0.8,
zeta=-0.5,
chi=-0.4,
gamma=-0.3,
phi=-0.2)
parameters_cd_dict = {
'theta': 0.1,
'zeta': 0.2,
'chi': 0.3,
'gamma': 0.4,
'phi': 0.5
}
a, b, c, d = cirq.LineQubit.range(4)
circuit = cirq.Circuit([
[cirq.X(a), cirq.Y(c)],
[
cirq.FSimGate(np.pi / 4, 0.0).on(a, b),
cirq.FSimGate(np.pi / 4, 0.0).on(d, c)
],
[cirq.FSimGate(np.pi / 4, 0.0).on(b, c)],
[
cirq.FSimGate(np.pi / 4, 0.0).on(a, b),
cirq.FSimGate(np.pi / 4, 0.0).on(c, d)
],
])
expected_circuit = cirq.Circuit([
[cirq.X(a), cirq.X(c)],
[
cirq.PhasedFSimGate(**parameters_ab.asdict()).on(a, b),
cirq.PhasedFSimGate(**parameters_cd_dict).on(c, d),
],
[cirq.PhasedFSimGate(**parameters_bc.asdict()).on(b, c)],
[
cirq.PhasedFSimGate(**parameters_ab.asdict()).on(a, b),
cirq.PhasedFSimGate(**parameters_cd_dict).on(c, d),
],
])
engine_simulator = PhasedFSimEngineSimulator.create_from_dictionary_sqrt_iswap(
parameters={
(a, b): parameters_ab,
(b, c): parameters_bc,
(c, d): parameters_cd_dict
})
actual = engine_simulator.final_state_vector(circuit)
expected = cirq.final_state_vector(expected_circuit)
assert cirq.allclose_up_to_global_phase(actual, expected)
def test_prepare_two_qubit_state_using_cz(state):
state = cirq.to_valid_state_vector(state, num_qubits=2)
q = cirq.LineQubit.range(2)
circuit = cirq.Circuit(cirq.prepare_two_qubit_state_using_cz(*q, state))
ops_cz = [*circuit.findall_operations(lambda op: op.gate == cirq.CZ)]
ops_2q = [*circuit.findall_operations(lambda op: cirq.num_qubits(op) > 1)]
assert ops_cz == ops_2q
assert len(ops_cz) <= 1
assert cirq.allclose_up_to_global_phase(circuit.final_state_vector(),
state)
def test_make_zeta_chi_gamma_compensation_for_operations():
a, b, c, d = cirq.LineQubit.range(4)
parameters_ab = cirq_google.PhasedFSimCharacterization(zeta=0.5,
chi=0.4,
gamma=0.3)
parameters_bc = cirq_google.PhasedFSimCharacterization(zeta=-0.5,
chi=-0.4,
gamma=-0.3)
parameters_cd = cirq_google.PhasedFSimCharacterization(zeta=0.2,
chi=0.3,
gamma=0.4)
parameters_dict = {
(a, b): parameters_ab,
(b, c): parameters_bc,
(c, d): parameters_cd
}
engine_simulator = cirq_google.PhasedFSimEngineSimulator.create_from_dictionary_sqrt_iswap(
parameters={
pair: parameters.merge_with(SQRT_ISWAP_PARAMETERS)
for pair, parameters in parameters_dict.items()
})
circuit = cirq.Circuit([
[cirq.X(a), cirq.Y(c)],
[SQRT_ISWAP_GATE.on(a, b),
SQRT_ISWAP_GATE.on(c, d)],
[SQRT_ISWAP_GATE.on(b, c)],
])
options = cirq_google.FloquetPhasedFSimCalibrationOptions(
characterize_theta=False,
characterize_zeta=True,
characterize_chi=True,
characterize_gamma=True,
characterize_phi=False,
)
characterizations = [
PhasedFSimCalibrationResult(parameters={pair: parameters},
gate=SQRT_ISWAP_GATE,
options=options)
for pair, parameters in parameters_dict.items()
]
calibrated_circuit = workflow.make_zeta_chi_gamma_compensation_for_operations(
circuit,
characterizations,
)
assert cirq.allclose_up_to_global_phase(
engine_simulator.final_state_vector(calibrated_circuit),
cirq.final_state_vector(circuit),
)
def test_single_qubit_cliffords():
I = np.eye(2)
X = np.array([[0, 1], [1, 0]])
Y = np.array([[0, -1j], [1j, 0]])
Z = np.diag([1, -1])
PAULIS = (I, X, Y, Z)
def is_pauli(u):
return any(cirq.equal_up_to_global_phase(u, p) for p in PAULIS)
cliffords = ceqc._single_qubit_cliffords()
assert len(cliffords.c1_in_xy) == 24
assert len(cliffords.c1_in_xz) == 24
def unitary(gates):
U = np.eye(2)
for gate in gates:
U = cirq.unitary(gate) @ U
return U
xy_unitaries = [unitary(gates) for gates in cliffords.c1_in_xy]
xz_unitaries = [unitary(gates) for gates in cliffords.c1_in_xz]
def check_distinct(unitaries):
n = len(unitaries)
for i in range(n):
for j in range(i + 1, n):
Ui, Uj = unitaries[i], unitaries[j]
assert not cirq.allclose_up_to_global_phase(Ui,
Uj), f'{i}, {j}'
# Check that unitaries in each decomposition are distinct.
check_distinct(xy_unitaries)
check_distinct(xz_unitaries)
# Check that each decomposition gives the same set of unitaries.
for Uxy in xy_unitaries:
assert any(
cirq.allclose_up_to_global_phase(Uxy, Uxz) for Uxz in xz_unitaries)
# Check that each unitary fixes the Pauli group.
for u in xy_unitaries:
for p in PAULIS:
assert is_pauli(u @ p @ u.conj().T), str(u)
# Check that XZ decomposition has at most one X gate per clifford.
for gates in cliffords.c1_in_xz:
num_x = len(
[gate for gate in gates if isinstance(gate, cirq.XPowGate)])
num_z = len(
[gate for gate in gates if isinstance(gate, cirq.ZPowGate)])
assert num_x + num_z == len(gates)
assert num_x <= 1
def test_commutes_single_qubit_gate(gate, other):
q0 = cirq.NamedQubit('q0')
mat = cirq.Circuit(
gate(q0),
other(q0),
).unitary()
mat_swap = cirq.Circuit(
other(q0),
gate(q0),
).unitary()
commutes = cirq.commutes(gate, other)
commutes_check = cirq.allclose_up_to_global_phase(mat, mat_swap)
assert commutes == commutes_check
def test_commutes_with_single_qubit_gate(gate, other):
q0 = cirq.NamedQubit('q0')
mat = cirq.Circuit.from_ops(
gate(q0),
other(q0),
).to_unitary_matrix()
mat_swap = cirq.Circuit.from_ops(
other(q0),
gate(q0),
).to_unitary_matrix()
commutes = gate.commutes_with(other)
commutes_check = cirq.allclose_up_to_global_phase(mat, mat_swap)
assert commutes == commutes_check
def test_interchangable_qubits(gate):
q0, q1 = cirq.NamedQubit('q0'), cirq.NamedQubit('q1')
op0 = gate(q0, q1)
op1 = gate(q1, q0)
mat0 = cirq.Circuit.from_ops(
op0,
).to_unitary_matrix()
mat1 = cirq.Circuit.from_ops(
op1,
).to_unitary_matrix()
same = op0 == op1
same_check = cirq.allclose_up_to_global_phase(mat0, mat1)
assert same == same_check
def test_commutes_with_single_qubit_gate(gate, other):
q0 = cirq.NamedQubit('q0')
mat = cirq.Circuit.from_ops(
gate(q0),
other(q0),
).to_unitary_matrix()
mat_swap = cirq.Circuit.from_ops(
other(q0),
gate(q0),
).to_unitary_matrix()
commutes = gate.commutes_with(other)
commutes_check = cirq.allclose_up_to_global_phase(mat, mat_swap)
assert commutes == commutes_check
def test_commutes_single_qubit_gate(gate, other):
q0 = cirq.NamedQubit('q0')
gate_op = gate(q0)
other_op = other(q0)
mat = cirq.Circuit(gate_op, other_op).unitary()
mat_swap = cirq.Circuit(other_op, gate_op).unitary()
commutes = cirq.commutes(gate, other)
commutes_check = cirq.allclose_up_to_global_phase(mat, mat_swap)
assert commutes == commutes_check
# Test after switching order
mat_swap = cirq.Circuit(gate.equivalent_gate_before(other)(q0), gate_op).unitary()
assert_allclose_up_to_global_phase(mat, mat_swap, rtol=1e-7, atol=1e-7)
def test_commutes_pauli(gate, pauli, half_turns):
pauli_gate = pauli ** half_turns
q0 = cirq.NamedQubit('q0')
mat = cirq.Circuit(
gate(q0),
pauli_gate(q0),
).unitary()
mat_swap = cirq.Circuit(
pauli_gate(q0),
gate(q0),
).unitary()
commutes = cirq.commutes(gate, pauli)
commutes_check = cirq.allclose_up_to_global_phase(mat, mat_swap)
assert commutes == commutes_check
def test_commutes_with_pauli(gate, pauli, half_turns):
pauli_gate = pauli**half_turns
q0 = cirq.NamedQubit('q0')
mat = cirq.Circuit.from_ops(
gate(q0),
pauli_gate(q0),
).to_unitary_matrix()
mat_swap = cirq.Circuit.from_ops(
pauli_gate(q0),
gate(q0),
).to_unitary_matrix()
commutes = gate.commutes_with(pauli)
commutes_check = cirq.allclose_up_to_global_phase(mat, mat_swap)
assert commutes == commutes_check
def general_rule(slack_length: int,
gates: List[Gate],
spacing: int = -1) -> Circuit:
"""Returns a digital dynamical decoupling sequence, based on inputs.
Args:
slack_length: Length of idle window to fill.
spacing: How many identity spacing gates to apply between dynamical
decoupling gates, as a non-negative int. Negative int corresponds
to default. Defaults to maximal spacing that fits a single sequence
in the given slack window.
E.g. given slack_length = 8, gates = [X, X] the spacing defaults
to 2 and the rule returns the sequence:
──I──I──X──I──I──X──I──I──
given slack_length = 9, gates [X, Y, X, Y] the spacing defaults
to 1 and the rule returns the sequence:
──I──X──I──Y──I──X──I──Y──I──.
gates: A list of single qubit Cirq gates to build the rule. E.g. [X, X]
is the xx sequence, [X, Y, X, Y] is the xyxy sequence.
- Note: To repeat the sequence, specify a repeated gateset.
Returns:
A digital dynamical decoupling sequence, as a Cirq circuit.
"""
if len(gates) < 2:
raise ValueError("Gateset too short to make a ddd sequence.")
if slack_length < 2 or slack_length < len(gates):
return Circuit()
num_decoupling_gates = len(gates)
slack_difference = slack_length - num_decoupling_gates
if spacing < 0:
spacing = slack_difference // (num_decoupling_gates + 1)
slack_remainder = slack_length - (spacing * (num_decoupling_gates + 1) +
num_decoupling_gates)
if slack_remainder < 0:
return Circuit()
q = LineQubit(0)
slack_gates = [I(q) for _ in range(spacing)]
sequence = Circuit(
slack_gates,
[(
gate.on(q),
slack_gates,
) for (_, gate) in zip(range(num_decoupling_gates), cycle(gates))],
)
if not allclose_up_to_global_phase(np.eye(2), unitary(sequence)):
raise ValueError("Sequence is not equivalent to the identity!")
for i in range(slack_remainder):
sequence.append(I(q)) if i % 2 else sequence.insert(0, I(q))
return sequence
def test_prepare_two_qubit_state_using_sqrt_iswap(state, use_sqrt_iswap_inv):
state = cirq.to_valid_state_vector(state, num_qubits=2)
q = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
cirq.prepare_two_qubit_state_using_sqrt_iswap(
*q, state, use_sqrt_iswap_inv=use_sqrt_iswap_inv))
sqrt_iswap_gate = cirq.SQRT_ISWAP_INV if use_sqrt_iswap_inv else cirq.SQRT_ISWAP
ops_iswap = [
*circuit.findall_operations(lambda op: op.gate == sqrt_iswap_gate)
]
ops_2q = [*circuit.findall_operations(lambda op: cirq.num_qubits(op) > 1)]
assert ops_iswap == ops_2q
assert len(ops_iswap) <= 1
assert cirq.allclose_up_to_global_phase(circuit.final_state_vector(),
state)
def test_controlled_op_to_operations_concrete_case():
c = cirq.NamedQubit('c')
t = cirq.NamedQubit('t')
expected = [cirq.Y(t)**-0.5, cirq.CZ(c, t)**1.5,
cirq.Z(c)**0.25, cirq.Y(t)**0.5]
operations = cirq.controlled_op_to_operations(
control=c,
target=t,
operation=np.array([[1, 1j], [1j, 1]]) * np.sqrt(0.5),
tolerance=0.0001)
# Test closeness as opposed to equality to avoid precision errors
for actual_op, expected_op in zip(operations, expected):
assert cirq.allclose_up_to_global_phase(cirq.unitary(actual_op),
cirq.unitary(expected_op),
atol=1e-8)
def test_with_random_gaussian_sqrt_iswap_simulates_correctly() -> None:
engine_simulator = PhasedFSimEngineSimulator.create_with_random_gaussian_sqrt_iswap(
mean=SQRT_ISWAP_PARAMETERS,
sigma=PhasedFSimCharacterization(theta=0.02,
zeta=0.05,
chi=0.05,
gamma=None,
phi=0.02),
)
a, b, c, d = cirq.LineQubit.range(4)
circuit = cirq.Circuit([
[cirq.X(a), cirq.Y(c)],
[
cirq.FSimGate(np.pi / 4, 0.0).on(a, b),
cirq.FSimGate(np.pi / 4, 0.0).on(c, d)
],
[cirq.FSimGate(np.pi / 4, 0.0).on(b, c)],
[
cirq.FSimGate(np.pi / 4, 0.0).on(b, a),
cirq.FSimGate(np.pi / 4, 0.0).on(d, c)
],
])
calibrations = engine_simulator.get_calibrations([
_create_sqrt_iswap_request([(a, b), (c, d)]),
_create_sqrt_iswap_request([(b, c)])
])
parameters = collections.ChainMap(*(calibration.parameters
for calibration in calibrations))
expected_circuit = cirq.Circuit([
[cirq.X(a), cirq.X(c)],
[
cirq.PhasedFSimGate(**parameters[(a, b)].asdict()).on(a, b),
cirq.PhasedFSimGate(**parameters[(c, d)].asdict()).on(c, d),
],
[cirq.PhasedFSimGate(**parameters[(b, c)].asdict()).on(b, c)],
[
cirq.PhasedFSimGate(**parameters[(a, b)].asdict()).on(a, b),
cirq.PhasedFSimGate(**parameters[(c, d)].asdict()).on(c, d),
],
])
actual = engine_simulator.final_state_vector(circuit)
expected = cirq.final_state_vector(expected_circuit)
assert cirq.allclose_up_to_global_phase(actual, expected)
def test_ideal_sqrt_iswap_inverse_simulates_correctly() -> None:
a, b, c, d = cirq.LineQubit.range(4)
circuit = cirq.Circuit(
[
[cirq.X(a), cirq.Y(c)],
[cirq.FSimGate(-np.pi / 4, 0.0).on(a, b), cirq.FSimGate(-np.pi / 4, 0.0).on(c, d)],
[cirq.FSimGate(-np.pi / 4, 0.0).on(b, c)],
]
)
engine_simulator = PhasedFSimEngineSimulator.create_with_ideal_sqrt_iswap()
actual = engine_simulator.final_state_vector(circuit)
expected = cirq.final_state_vector(circuit)
assert cirq.allclose_up_to_global_phase(actual, expected)
def test_from_dictionary_sqrt_iswap_ideal_when_missing_simulates_correctly(
) -> None:
parameters_ab = cirq.google.PhasedFSimCharacterization(theta=0.6,
zeta=0.5,
chi=0.4,
gamma=0.3,
phi=0.2)
parameters_bc = cirq.google.PhasedFSimCharacterization(theta=0.8,
zeta=-0.5,
chi=-0.4)
a, b, c, d = cirq.LineQubit.range(4)
circuit = cirq.Circuit([
[cirq.X(a), cirq.Y(c)],
[
cirq.FSimGate(np.pi / 4, 0.0).on(a, b),
cirq.FSimGate(np.pi / 4, 0.0).on(c, d)
],
[cirq.FSimGate(np.pi / 4, 0.0).on(b, c)],
])
expected_circuit = cirq.Circuit([
[cirq.X(a), cirq.X(c)],
[
cirq.PhasedFSimGate(**parameters_ab.asdict()).on(a, b),
cirq.PhasedFSimGate(**SQRT_ISWAP_PARAMETERS.asdict()).on(c, d),
],
[
cirq.PhasedFSimGate(
**parameters_bc.merge_with(SQRT_ISWAP_PARAMETERS).asdict()).on(
b, c)
],
])
engine_simulator = PhasedFSimEngineSimulator.create_from_dictionary_sqrt_iswap(
parameters={
(a, b): parameters_ab,
(b, c): parameters_bc
},
ideal_when_missing_parameter=True,
ideal_when_missing_gate=True,
)
actual = engine_simulator.final_state_vector(circuit)
expected = cirq.final_state_vector(expected_circuit)
assert cirq.allclose_up_to_global_phase(actual, expected)
def test_prepare_slater_determinant(slater_determinant_matrix,
correct_state,
initial_state,
atol=1e-7):
n_qubits = slater_determinant_matrix.shape[1]
qubits = LineQubit.range(n_qubits)
circuit = cirq.Circuit(
prepare_slater_determinant(qubits,
slater_determinant_matrix,
initial_state=initial_state))
if isinstance(initial_state, list):
initial_state = sum(1 << (n_qubits - 1 - i) for i in initial_state)
state = circuit.final_state_vector(initial_state=initial_state)
assert cirq.allclose_up_to_global_phase(state, correct_state, atol=atol)
def test_commutes_with_pauli(gate, pauli, half_turns):
pauli_gates = {cirq.Pauli.X: cirq.X,
cirq.Pauli.Y: cirq.Y,
cirq.Pauli.Z: cirq.Z}
pauli_gate = pauli_gates[pauli] ** half_turns
q0 = cirq.NamedQubit('q0')
mat = cirq.Circuit.from_ops(
gate(q0),
pauli_gate(q0),
).to_unitary_matrix()
mat_swap = cirq.Circuit.from_ops(
pauli_gate(q0),
gate(q0),
).to_unitary_matrix()
commutes = gate.commutes_with(pauli)
commutes_check = cirq.allclose_up_to_global_phase(mat, mat_swap)
assert commutes == commutes_check
def test_example_qaoa_same_unitary():
n = 6
p = 2
qubits = cirq.LineQubit.range(n)
graph = networkx.random_regular_graph(3, n)
betas = np.random.uniform(-np.pi, np.pi, size=p)
gammas = np.random.uniform(-np.pi, np.pi, size=p)
circuits = [
examples.qaoa.qaoa_max_cut_circuit(qubits, betas, gammas, graph,
use_boolean_hamiltonian_gate)
for use_boolean_hamiltonian_gate in [True, False]
]
assert cirq.allclose_up_to_global_phase(cirq.unitary(circuits[0]),
cirq.unitary(circuits[1]))
def test_prepare_slater_determinant(slater_determinant_matrix,
correct_state,
initial_state,
atol=1e-7):
simulator = cirq.google.XmonSimulator()
n_qubits = slater_determinant_matrix.shape[1]
qubits = LineQubit.range(n_qubits)
circuit = cirq.Circuit.from_ops(
prepare_slater_determinant(qubits,
slater_determinant_matrix,
initial_state=initial_state))
if isinstance(initial_state, list):
initial_state = sum(1 << (n_qubits - 1 - i) for i in initial_state)
result = simulator.simulate(circuit, initial_state=initial_state)
state = result.final_state
assert cirq.allclose_up_to_global_phase(state, correct_state, atol=atol)
def test_single_qubit_op_to_framed_phase_form_output_on_example_case():
u, t, g = cirq.single_qubit_op_to_framed_phase_form(
(cirq.Y**0.25).matrix())
assert cirq.allclose_up_to_global_phase(u, (cirq.X**0.5).matrix())
assert abs(t - (1 + 1j) * math.sqrt(0.5)) < 0.00001
assert abs(g - 1) < 0.00001
def assert_ops_implement_unitary(q0, q1, operations, intended_effect,
atol=0.01):
actual_effect = _operations_to_matrix(operations, (q0, q1))
assert cirq.allclose_up_to_global_phase(actual_effect, intended_effect,
atol=atol)
def assert_gates_implement_unitary(gates, intended_effect):
actual_effect = _gates_to_matrix(gates)
assert cirq.allclose_up_to_global_phase(actual_effect, intended_effect)
