def test_bounded_effect():
qubits = cirq.LineQubit.range(3)
cy = cirq.ControlledOperation(qubits[:1], cirq.Y(qubits[1]))
assert cirq.trace_distance_bound(cy**0.001) < 0.01
foo = sympy.Symbol('foo')
scy = cirq.ControlledOperation(qubits[:1], cirq.Y(qubits[1]) ** foo)
assert cirq.trace_distance_bound(scy) == 1.0
assert cirq.approx_eq(cirq.trace_distance_bound(cy), 1.0)
def test_gate_operation_approx_eq():
a = [cirq.NamedQubit('r1')]
b = [cirq.NamedQubit('r2')]
assert cirq.approx_eq(cirq.GateOperation(cirq.XPowGate(), a),
cirq.GateOperation(cirq.XPowGate(), a))
assert not cirq.approx_eq(cirq.GateOperation(cirq.XPowGate(), a),
cirq.GateOperation(cirq.XPowGate(), b))
assert cirq.approx_eq(cirq.GateOperation(cirq.XPowGate(exponent=0), a),
cirq.GateOperation(cirq.XPowGate(exponent=1e-9), a))
assert not cirq.approx_eq(
cirq.GateOperation(cirq.XPowGate(exponent=0), a),
cirq.GateOperation(cirq.XPowGate(exponent=1e-7), a))
assert cirq.approx_eq(cirq.GateOperation(cirq.XPowGate(exponent=0), a),
cirq.GateOperation(cirq.XPowGate(exponent=1e-7), a),
atol=1e-6)
def test_decompose_two_qubit_interaction_into_two_b_gates(obj: Any):
circuit = cirq.Circuit(
_decompose_two_qubit_interaction_into_two_b_gates(
obj, qubits=cirq.LineQubit.range(2)))
desired_unitary = obj if isinstance(obj, np.ndarray) else cirq.unitary(obj)
for operation in circuit.all_operations():
assert len(operation.qubits) < 2 or operation.gate == _B
assert cirq.approx_eq(cirq.unitary(circuit), desired_unitary, atol=1e-6)
def test_eq():
eq = cirq.testing.EqualsTester()
q = cirq.LineQubit(0)
eq.add_equality_group(
cirq.RandomGateChannel(sub_gate=cirq.X, probability=0.5),
cirq.X.with_probability(0.5))
# Each field matters for equality.
eq.add_equality_group(cirq.Y.with_probability(0.5))
eq.add_equality_group(cirq.X.with_probability(0.25))
# `with_probability(1)` doesn't wrap
eq.add_equality_group(cirq.X, cirq.X.with_probability(1))
eq.add_equality_group(
cirq.X.with_probability(1).on(q),
cirq.X.on(q).with_probability(1),
cirq.X(q),
)
# `with_probability` with `on`.
eq.add_equality_group(
cirq.X.with_probability(0.5).on(q),
cirq.X.on(q).with_probability(0.5),
)
# Flattening.
eq.add_equality_group(
cirq.RandomGateChannel(sub_gate=cirq.Z, probability=0.25),
cirq.RandomGateChannel(sub_gate=cirq.RandomGateChannel(sub_gate=cirq.Z,
probability=0.5),
probability=0.5),
cirq.Z.with_probability(0.5).with_probability(0.5),
cirq.Z.with_probability(0.25))
# Supports approximate equality.
assert cirq.approx_eq(
cirq.X.with_probability(0.5),
cirq.X.with_probability(0.50001),
atol=1e-2,
)
assert not cirq.approx_eq(
cirq.X.with_probability(0.5),
cirq.X.with_probability(0.50001),
atol=1e-8,
)
def test_approx_eq_symbol():
q = cirq.GridQubit(0, 0)
s = sympy.Symbol("s")
t = sympy.Symbol("t")
assert not cirq.approx_eq(t + 1.51 + s, t + 1.50 + s, atol=0.005)
assert cirq.approx_eq(t + 1.51 + s, t + 1.50 + s, atol=0.020)
with pytest.raises(
AttributeError,
match="Insufficient information to decide whether expressions are "
"approximately equal .* vs .*",
):
cirq.approx_eq(t, 0.0, atol=0.005)
symbol_1 = cirq.Circuit(cirq.rz(1.515 + s)(q))
symbol_2 = cirq.Circuit(cirq.rz(1.510 + s)(q))
assert cirq.approx_eq(symbol_1, symbol_2, atol=0.2)
symbol_3 = cirq.Circuit(cirq.rz(1.510 + t)(q))
with pytest.raises(
AttributeError,
match="Insufficient information to decide whether expressions are "
"approximately equal .* vs .*",
):
cirq.approx_eq(symbol_1, symbol_3, atol=0.2)
def test_phased_fsim_phase_angle_symmetry(rz_angles_before, rz_angles_after):
f = cirq.PhasedFSimGate.from_fsim_rz(np.pi / 3, np.pi / 5, rz_angles_before, rz_angles_after)
for d in (-10, -7, -2 * np.pi, -0.2, 0, 0.1, 0.2, np.pi, 8, 20):
rz_angles_before2 = (rz_angles_before[0] + d, rz_angles_before[1] + d)
rz_angles_after2 = (rz_angles_after[0] - d, rz_angles_after[1] - d)
f2 = cirq.PhasedFSimGate.from_fsim_rz(
np.pi / 3, np.pi / 5, rz_angles_before2, rz_angles_after2
)
assert cirq.approx_eq(f, f2)
def test_periodic_value_approx_eq_boundary():
assert cirq.approx_eq(cirq.PeriodicValue(0.0, 2.0), cirq.PeriodicValue(1.9, 2.0), atol=0.2)
assert cirq.approx_eq(cirq.PeriodicValue(0.1, 2.0), cirq.PeriodicValue(1.9, 2.0), atol=0.3)
assert cirq.approx_eq(cirq.PeriodicValue(1.9, 2.0), cirq.PeriodicValue(0.1, 2.0), atol=0.3)
assert not cirq.approx_eq(cirq.PeriodicValue(0.1, 2.0), cirq.PeriodicValue(1.9, 2.0), atol=0.1)
assert cirq.approx_eq(cirq.PeriodicValue(0, 1.0), cirq.PeriodicValue(0.5, 1.0), atol=0.6)
assert not cirq.approx_eq(cirq.PeriodicValue(0, 1.0), cirq.PeriodicValue(0.5, 1.0), atol=0.1)
assert cirq.approx_eq(cirq.PeriodicValue(0.4, 1.0), cirq.PeriodicValue(0.6, 1.0), atol=0.3)
def test_periodic_value_approx_eq_basic():
assert cirq.approx_eq(cirq.PeriodicValue(1.0, 2.0), cirq.PeriodicValue(1.0, 2.0), atol=0.1)
assert cirq.approx_eq(cirq.PeriodicValue(1.0, 2.0), cirq.PeriodicValue(1.2, 2.0), atol=0.3)
assert not cirq.approx_eq(cirq.PeriodicValue(1.0, 2.0), cirq.PeriodicValue(1.2, 2.0), atol=0.1)
assert not cirq.approx_eq(cirq.PeriodicValue(1.0, 2.0), cirq.PeriodicValue(1.0, 2.2), atol=0.3)
assert not cirq.approx_eq(cirq.PeriodicValue(1.0, 2.0), cirq.PeriodicValue(1.0, 2.2), atol=0.1)
assert not cirq.approx_eq(cirq.PeriodicValue(1.0, 2.0), cirq.PeriodicValue(1.2, 2.2), atol=0.3)
assert not cirq.approx_eq(cirq.PeriodicValue(1.0, 2.0), cirq.PeriodicValue(1.2, 2.2), atol=0.1)
def test_approx_eq_primitives():
assert not cirq.approx_eq(1, 2, atol=1e-01)
assert cirq.approx_eq(1.0, 1.0 + 1e-10, atol=1e-09)
assert not cirq.approx_eq(1.0, 1.0 + 1e-10, atol=1e-11)
assert cirq.approx_eq(0.0, 1e-10, atol=1e-09)
assert not cirq.approx_eq(0.0, 1e-10, atol=1e-11)
assert cirq.approx_eq(complex(1, 1), complex(1.1, 1.2), atol=0.3)
assert not cirq.approx_eq(complex(1, 1), complex(1.1, 1.2), atol=0.1)
def test_approx_eq_list():
assert cirq.approx_eq([], [], atol=0.0)
assert not cirq.approx_eq([], [[]], atol=0.0)
assert cirq.approx_eq([1, 1], [1, 1], atol=0.0)
assert not cirq.approx_eq([1, 1], [1, 1, 1], atol=0.0)
assert not cirq.approx_eq([1, 1], [1], atol=0.0)
assert cirq.approx_eq([1.1, 1.2, 1.3], [1, 1, 1], atol=0.4)
assert not cirq.approx_eq([1.1, 1.2, 1.3], [1, 1, 1], atol=0.2)
def test_create_circuits_initial_trapping(layout_type: type) -> None:
layout = layout_type(size=4)
parameters = _create_test_parameters(
layout,
initial_state=IndependentChainsInitialState(
up=UniformTrappingPotential(particles=2),
down=GaussianTrappingPotential(particles=2,
center=0.2,
sigma=0.3,
scale=0.4)))
initial, _, _ = create_circuits(parameters, trotter_steps=0)
up1, up2, up3, up4 = layout.up_qubits
down1, down2, down3, down4 = layout.down_qubits
expected = cirq.Circuit([
cirq.Moment(cirq.X(up1), cirq.X(up2), cirq.X(down1), cirq.X(down2)),
cirq.Moment(
cirq.PhasedISwapPowGate(phase_exponent=0.25,
exponent=-0.7322795271987699).on(up2, up3),
cirq.PhasedISwapPowGate(phase_exponent=0.25,
exponent=-0.7502896835888355).on(
down2, down3),
),
cirq.Moment((cirq.Z**0.0).on(up3), (cirq.Z**0.0).on(down3)),
cirq.Moment(
cirq.PhasedISwapPowGate(phase_exponent=0.25,
exponent=-0.564094216848975).on(up1, up2),
cirq.PhasedISwapPowGate(phase_exponent=0.25,
exponent=-0.5768514417132005).on(
down1, down2),
cirq.PhasedISwapPowGate(phase_exponent=0.25,
exponent=-0.5640942168489748).on(up3, up4),
cirq.PhasedISwapPowGate(phase_exponent=0.25,
exponent=-0.5973464819433905).on(
down3, down4),
),
cirq.Moment(
(cirq.Z**0.0).on(up2),
(cirq.Z**0.0).on(down2),
(cirq.Z**0.0).on(up4),
(cirq.Z**0.0).on(down4),
),
cirq.Moment(
cirq.PhasedISwapPowGate(phase_exponent=0.25,
exponent=-0.26772047280123007).on(
up2, up3),
cirq.PhasedISwapPowGate(phase_exponent=0.25,
exponent=-0.2994619470606122).on(
down2, down3),
),
cirq.Moment((cirq.Z**0.0).on(up3), (cirq.Z**0.0).on(down3)),
])
assert cirq.approx_eq(initial, expected)
def test_diagonal_exponent():
diagonal_angles = [2, 3, 5, 7]
diagonal_gate = cirq.TwoQubitDiagonalGate(diagonal_angles)
sqrt_diagonal_gate = diagonal_gate ** 0.5
expected_angles = [prime / 2 for prime in diagonal_angles]
assert cirq.approx_eq(sqrt_diagonal_gate, cirq.TwoQubitDiagonalGate(expected_angles))
assert cirq.pow(cirq.TwoQubitDiagonalGate(diagonal_angles), "test", None) is None
def test_decompose_two_qubit_interaction_into_four_fsim_gates_equivalence(
obj: Any, fsim_gate: cirq.FSimGate
):
qubits = obj.qubits if isinstance(obj, cirq.Operation) else cirq.LineQubit.range(2)
circuit = cirq.decompose_two_qubit_interaction_into_four_fsim_gates(obj, fsim_gate=fsim_gate)
desired_unitary = obj if isinstance(obj, np.ndarray) else cirq.unitary(obj)
for operation in circuit.all_operations():
assert len(operation.qubits) < 2 or operation.gate == fsim_gate
assert len(circuit) <= 4 * 3 + 5
assert cirq.approx_eq(circuit.unitary(qubit_order=qubits), desired_unitary, atol=1e-6)
def test_binding_and_exporting_parametrized_circuit_results_in_equivalent_circuit(
self, zquantum_circuit, cirq_circuit):
bound = zquantum_circuit.bind(EXAMPLE_PARAM_VALUES)
bound_converted = export_to_cirq(bound)
ref_bound = cirq.resolve_parameters(
cirq_circuit, {
**EXAMPLE_PARAM_VALUES, sympy.pi: 3.14
})
assert cirq.approx_eq(bound_converted, ref_bound), (
f"Converted circuit:\n{bound_converted}\n isn't equal to\n{ref_bound}"
)
def _approx_eq_or_symbol(self, lhs: Any, rhs: Any) -> bool:
lhs = lhs if isinstance(lhs, tuple) else (lhs, )
rhs = rhs if isinstance(rhs, tuple) else (rhs, )
assert len(lhs) == len(rhs)
for l, r in zip(lhs, rhs):
is_parameterized = cirq.is_parameterized(
l) or cirq.is_parameterized(r)
if (is_parameterized and not self.allow_symbols) or (
not is_parameterized
and not cirq.approx_eq(l, r, atol=self.atol)):
return False
return True
def test_simulate_expectation_values(dtype):
# Compare with test_expectation_from_state_vector_two_qubit_states
# in file: cirq/ops/linear_combinations_test.py
q0, q1 = cirq.LineQubit.range(2)
psum1 = cirq.Z(q0) + 3.2 * cirq.Z(q1)
psum2 = -1 * cirq.X(q0) + 2 * cirq.X(q1)
c1 = cirq.Circuit(cirq.I(q0), cirq.X(q1))
simulator = cirq.Simulator(dtype=dtype)
result = simulator.simulate_expectation_values(c1, [psum1, psum2])
assert cirq.approx_eq(result[0], -2.2, atol=1e-6)
assert cirq.approx_eq(result[1], 0, atol=1e-6)
c2 = cirq.Circuit(cirq.H(q0), cirq.H(q1))
result = simulator.simulate_expectation_values(c2, [psum1, psum2])
assert cirq.approx_eq(result[0], 0, atol=1e-6)
assert cirq.approx_eq(result[1], 1, atol=1e-6)
psum3 = cirq.Z(q0) + cirq.X(q1)
c3 = cirq.Circuit(cirq.I(q0), cirq.H(q1))
result = simulator.simulate_expectation_values(c3, psum3)
assert cirq.approx_eq(result[0], 2, atol=1e-6)
def test_approx_eq_uses__eq__():
assert cirq.approx_eq(C(0), C(0), atol=0.0)
assert not cirq.approx_eq(C(1), C(2), atol=0.0)
assert cirq.approx_eq([C(0)], [C(0)], atol=0.0)
assert not cirq.approx_eq([C(1)], [C(2)], atol=0.0)
assert cirq.approx_eq(complex(0, 0), 0, atol=0.0)
assert cirq.approx_eq(0, complex(0, 0), atol=0.0)
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 test_approx_eq_mixed_primitives():
assert cirq.approx_eq(complex(1, 1e-10), 1, atol=1e-09)
assert not cirq.approx_eq(complex(1, 1e-4), 1, atol=1e-09)
assert cirq.approx_eq(complex(1, 1e-10), 1.0, atol=1e-09)
assert not cirq.approx_eq(complex(1, 1e-8), 1.0, atol=1e-09)
assert cirq.approx_eq(1, 1.0 + 1e-10, atol=1e-9)
assert not cirq.approx_eq(1, 1.0 + 1e-10, atol=1e-11)
def test_single_qubit_matrix_to_native_gates_known():
actual = cirq.single_qubit_matrix_to_phased_x_z(np.array([[0, 1], [1, 0]]),
atol=0.01)
assert cirq.approx_eq(actual, [cirq.PhasedXPowGate(phase_exponent=1.0)],
atol=1e-9)
actual = cirq.single_qubit_matrix_to_phased_x_z(np.array([[0, -1j],
[1j, 0]]),
atol=0.01)
assert cirq.approx_eq(actual, [cirq.Y], atol=1e-9)
actual = cirq.single_qubit_matrix_to_phased_x_z(np.array([[1, 0], [0,
-1]]),
atol=0.01)
assert cirq.approx_eq(actual, [cirq.Z], atol=1e-9)
actual = cirq.single_qubit_matrix_to_phased_x_z(np.array([[1, 0], [0,
1j]]),
atol=0.01)
assert cirq.approx_eq(actual, [cirq.Z**0.5], atol=1e-9)
actual = cirq.single_qubit_matrix_to_phased_x_z(np.array([[1, 0], [0,
-1j]]),
atol=0.01)
assert cirq.approx_eq(actual, [cirq.Z**-0.5], atol=1e-9)
actual = cirq.single_qubit_matrix_to_phased_x_z(
np.array([[1, 1], [1, -1]]) * np.sqrt(0.5), atol=0.001)
assert cirq.approx_eq(
actual,
[cirq.PhasedXPowGate(phase_exponent=-0.5, exponent=0.5), cirq.Z**-1],
atol=1e-9)
def test_approx_eq_special_numerics():
assert not cirq.approx_eq(float('nan'), 0, atol=0.0)
assert not cirq.approx_eq(float('nan'), float('nan'), atol=0.0)
assert not cirq.approx_eq(float('inf'), float('-inf'), atol=0.0)
assert not cirq.approx_eq(float('inf'), 5, atol=0.0)
assert not cirq.approx_eq(float('inf'), 0, atol=0.0)
assert cirq.approx_eq(float('inf'), float('inf'), atol=0.0)
def test_approx_eq():
assert cirq.approx_eq(cirq.Z**0.1, cirq.Z**0.2, atol=0.3)
assert not cirq.approx_eq(cirq.Z**0.1, cirq.Z**0.2, atol=0.05)
assert cirq.approx_eq(cirq.Y**0.1, cirq.Y**0.2, atol=0.3)
assert not cirq.approx_eq(cirq.Y**0.1, cirq.Y**0.2, atol=0.05)
assert cirq.approx_eq(cirq.X**0.1, cirq.X**0.2, atol=0.3)
assert not cirq.approx_eq(cirq.X**0.1, cirq.X**0.2, atol=0.05)
def test_trace_distance():
foo = sympy.Symbol('foo')
sx = cirq.X**foo
sy = cirq.Y**foo
sz = cirq.Z**foo
sh = cirq.H**foo
scx = cirq.CX**foo
scz = cirq.CZ**foo
# These values should have 1.0 or 0.0 directly returned
assert cirq.trace_distance_bound(sx) == 1.0
assert cirq.trace_distance_bound(sy) == 1.0
assert cirq.trace_distance_bound(sz) == 1.0
assert cirq.trace_distance_bound(scx) == 1.0
assert cirq.trace_distance_bound(scz) == 1.0
assert cirq.trace_distance_bound(sh) == 1.0
assert cirq.trace_distance_bound(cirq.I) == 0.0
# These values are calculated, so we use approx_eq
assert cirq.approx_eq(cirq.trace_distance_bound(cirq.X), 1.0)
assert cirq.approx_eq(cirq.trace_distance_bound(cirq.Y**-1), 1.0)
assert cirq.approx_eq(cirq.trace_distance_bound(cirq.Z**0.5),
np.sin(np.pi / 4))
assert cirq.approx_eq(cirq.trace_distance_bound(cirq.H**0.25),
np.sin(np.pi / 8))
assert cirq.approx_eq(cirq.trace_distance_bound(cirq.CX**2), 0.0)
assert cirq.approx_eq(cirq.trace_distance_bound(cirq.CZ**(1 / 9)),
np.sin(np.pi / 18))
def test_depolarizing_channel_eq():
a = cirq.depolarize(p=0.0099999)
b = cirq.depolarize(p=0.01)
c = cirq.depolarize(0.0)
assert cirq.approx_eq(a, b, atol=1e-2)
et = cirq.testing.EqualsTester()
et.make_equality_group(lambda: c)
et.add_equality_group(cirq.depolarize(0.1))
et.add_equality_group(cirq.depolarize(0.9))
et.add_equality_group(cirq.depolarize(1.0))
def test_generalized_amplitude_damping_channel_eq():
a = cirq.generalized_amplitude_damp(0.0099999, 0.01)
b = cirq.generalized_amplitude_damp(0.01, 0.0099999)
assert cirq.approx_eq(a, b, atol=1e-2)
et = cirq.testing.EqualsTester()
c = cirq.generalized_amplitude_damp(0.0, 0.0)
et.make_equality_group(lambda: c)
et.add_equality_group(cirq.generalized_amplitude_damp(0.1, 0.0))
et.add_equality_group(cirq.generalized_amplitude_damp(0.0, 0.1))
et.add_equality_group(cirq.generalized_amplitude_damp(0.6, 0.4))
et.add_equality_group(cirq.generalized_amplitude_damp(0.8, 0.2))
def test_approx_eq():
assert cirq.approx_eq(
cirq.PhasedXPowGate(phase_exponent=0.1, exponent=0.2,
global_shift=0.3),
cirq.PhasedXPowGate(phase_exponent=0.1, exponent=0.2,
global_shift=0.3),
atol=1e-4,
)
assert not cirq.approx_eq(
cirq.PhasedXPowGate(phase_exponent=0.1, exponent=0.2,
global_shift=0.4),
cirq.PhasedXPowGate(phase_exponent=0.1, exponent=0.2,
global_shift=0.3),
atol=1e-4,
)
assert cirq.approx_eq(
cirq.PhasedXPowGate(phase_exponent=0.1, exponent=0.2,
global_shift=0.4),
cirq.PhasedXPowGate(phase_exponent=0.1, exponent=0.2,
global_shift=0.3),
atol=0.2,
)
def test_phase_flip_channel_eq():
a = cirq.phase_flip(0.0099999)
b = cirq.phase_flip(0.01)
c = cirq.phase_flip(0.0)
assert cirq.approx_eq(a, b, atol=1e-2)
et = cirq.testing.EqualsTester()
et.make_equality_group(lambda: c)
et.add_equality_group(cirq.phase_flip(0.1))
et.add_equality_group(cirq.phase_flip(0.4))
et.add_equality_group(cirq.phase_flip(0.6))
et.add_equality_group(cirq.phase_flip(0.8))
def test_pauli_sum_pow():
identity = cirq.PauliSum.from_pauli_strings(
[cirq.PauliString(coefficient=1)])
psum1 = cirq.X(q0) + cirq.Y(q0)
assert psum1**2 == psum1 * psum1
assert psum1**2 == 2 * identity
psum2 = cirq.X(q0) + cirq.Y(q1)
assert psum2**2 == cirq.PauliString(
cirq.I(q0)) + 2 * cirq.X(q0) * cirq.Y(q1) + cirq.PauliString(cirq.I(q1))
psum3 = cirq.X(q0) * cirq.Z(q1) + 1.3 * cirq.Z(q0)
sqd = cirq.PauliSum.from_pauli_strings(
[2.69 * cirq.PauliString(cirq.I(q0))])
assert cirq.approx_eq(psum3**2, sqd, atol=1e-8)
psum4 = cirq.X(q0) * cirq.Z(q1) + 1.3 * cirq.Z(q1)
sqd2 = cirq.PauliSum.from_pauli_strings(
[2.69 * cirq.PauliString(cirq.I(q0)), 2.6 * cirq.X(q0)])
assert cirq.approx_eq(psum4**2, sqd2, atol=1e-8)
for psum in [psum1, psum2, psum3, psum4]:
assert cirq.approx_eq(psum**0, identity)
def test_create_circuits_initial_single_particle(layout_type: type) -> None:
layout = layout_type(size=4)
parameters = _create_test_parameters(
layout,
initial_state=IndependentChainsInitialState(
up=UniformSingleParticle(),
down=PhasedGaussianSingleParticle(k=0.2, sigma=0.4, position=0.6)))
initial, _, _ = create_circuits(parameters, trotter_steps=0)
up1, up2, up3, up4 = layout.up_qubits
down1, down2, down3, down4 = layout.down_qubits
expected = cirq.Circuit([
cirq.Moment(
cirq.X(up2),
cirq.X(down2),
),
cirq.Moment(
cirq.PhasedISwapPowGate(phase_exponent=0.25,
exponent=-0.5).on(up2, up3),
cirq.PhasedISwapPowGate(phase_exponent=0.25,
exponent=-0.5550026943884815).on(
down2, down3),
),
cirq.Moment(
cirq.PhasedISwapPowGate(phase_exponent=0.25,
exponent=-0.5).on(up3, up4),
cirq.PhasedISwapPowGate(phase_exponent=0.25,
exponent=0.5).on(up1, up2),
cirq.PhasedISwapPowGate(phase_exponent=0.25,
exponent=-0.42338370832577876).on(
down3, down4),
cirq.PhasedISwapPowGate(phase_exponent=0.25,
exponent=0.3609629722553269).on(
down1, down2),
),
cirq.Moment(
(cirq.Z**0.0).on(up3),
(cirq.Z**0.0).on(up4),
(cirq.Z**0.0).on(up1),
(cirq.Z**0.0).on(up2),
(cirq.Z**0.004244131815783875).on(down3),
(cirq.Z**0.02546479089470326).on(down4),
(cirq.Z**-0.03819718634205488).on(down1),
(cirq.Z**-0.016976527263135508).on(down2),
),
])
assert cirq.approx_eq(initial, expected)
def test_approx_eq_periodic():
assert cirq.approx_eq(CExpZinGate(1.5), CExpZinGate(5.5), atol=1e-9)
assert cirq.approx_eq(CExpZinGate(1.5), CExpZinGate(9.5), atol=1e-9)
assert cirq.approx_eq(CExpZinGate(-2.5), CExpZinGate(1.5), atol=1e-9)
assert not cirq.approx_eq(CExpZinGate(0), CExpZinGate(1.5), atol=1e-9)
# The tests below do not work with usual canonical exponent comparison.
assert cirq.approx_eq(CExpZinGate(0 - 1e-10), CExpZinGate(0), atol=1e-9)
assert cirq.approx_eq(CExpZinGate(0), CExpZinGate(4 - 1e-10), atol=1e-9)
