def test_bounded_effect():
q = cirq.NamedQubit('q')
# If the gate isn't bounded, you get a type error.
op0 = cirq.GateOperation(cirq.SingleQubitGate(), [q])
assert cirq.trace_distance_bound(op0) >= 1
op1 = cirq.GateOperation(cirq.Z**0.000001, [q])
op1_bound = cirq.trace_distance_bound(op1)
assert op1_bound == cirq.trace_distance_bound(cirq.Z**0.000001)
def test_trace_bound():
assert (
cirq.trace_distance_bound(cirq.PhasedXPowGate(phase_exponent=0.25, exponent=0.001)) < 0.01
)
assert (
cirq.trace_distance_bound(
cirq.PhasedXPowGate(phase_exponent=0.25, exponent=sympy.Symbol('a'))
)
>= 1
)
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)
mock = cirq.ControlledOperation(qubits[:1], MockGate().on(*qubits[1:]))
assert cirq.approx_eq(cirq.trace_distance_bound(mock), 1)
def test_trace_distance():
s = cirq.X**0.25
two_g = cirq.ParallelGate(s, 2)
three_g = cirq.ParallelGate(s, 3)
four_g = cirq.ParallelGate(s, 4)
assert cirq.approx_eq(cirq.trace_distance_bound(two_g), np.sin(np.pi / 4))
assert cirq.approx_eq(cirq.trace_distance_bound(three_g),
np.sin(3 * np.pi / 8))
assert cirq.approx_eq(cirq.trace_distance_bound(four_g), 1.0)
spg = cirq.ParallelGate(cirq.X**sympy.Symbol('a'), 4)
assert cirq.approx_eq(cirq.trace_distance_bound(spg), 1.0)
def test_trace_distance():
foo = sympy.Symbol('foo')
sswap = cirq.SWAP**foo
siswap = cirq.ISWAP**foo
# These values should have 1.0 or 0.0 directly returned
assert cirq.trace_distance_bound(sswap) == 1.0
assert cirq.trace_distance_bound(siswap) == 1.0
# These values are calculated, so we use approx_eq
assert cirq.approx_eq(cirq.trace_distance_bound(cirq.SWAP**0.3),
np.sin(0.3 * np.pi / 2))
assert cirq.approx_eq(cirq.trace_distance_bound(cirq.ISWAP**0), 0.0)
def test_trace_distance():
s = cirq.X ** 0.25
twoop = cirq.ParallelGateOperation(s, cirq.LineQubit.range(2))
threeop = cirq.ParallelGateOperation(s, cirq.LineQubit.range(3))
fourop = cirq.ParallelGateOperation(s, cirq.LineQubit.range(4))
assert cirq.approx_eq(cirq.trace_distance_bound(twoop), np.sin(np.pi / 4))
assert cirq.approx_eq(cirq.trace_distance_bound(threeop), np.sin(3 * np.pi / 8))
assert cirq.approx_eq(cirq.trace_distance_bound(fourop), 1.0)
foo = sympy.Symbol('foo')
spo = cirq.ParallelGateOperation(cirq.X ** foo, cirq.LineQubit.range(4))
assert cirq.approx_eq(cirq.trace_distance_bound(spo), 1.0)
def test_trace_distance():
with cirq.testing.assert_deprecated(deadline="v0.14", count=None):
s = cirq.X**0.25
twoop = cirq.ParallelGateOperation(s, cirq.LineQubit.range(2))
threeop = cirq.ParallelGateOperation(s, cirq.LineQubit.range(3))
fourop = cirq.ParallelGateOperation(s, cirq.LineQubit.range(4))
assert cirq.approx_eq(cirq.trace_distance_bound(twoop),
np.sin(np.pi / 4))
assert cirq.approx_eq(cirq.trace_distance_bound(threeop),
np.sin(3 * np.pi / 8))
assert cirq.approx_eq(cirq.trace_distance_bound(fourop), 1.0)
foo = sympy.Symbol('foo')
spo = cirq.ParallelGateOperation(cirq.X**foo, cirq.LineQubit.range(4))
assert cirq.approx_eq(cirq.trace_distance_bound(spo), 1.0)
def test_trace_distance_bound():
assert cirq.trace_distance_bound(CExpZinGate(0.001)) < 0.01
assert cirq.trace_distance_bound(CExpZinGate(sympy.Symbol('a'))) == 1
assert cirq.approx_eq(cirq.trace_distance_bound(CExpZinGate(2)), 1)
class E(cirq.EigenGate):
def _num_qubits_(self):
# coverage: ignore
return 1
def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
return [(0, np.array([[1, 0], [0, 0]])),
(12, np.array([[0, 0], [0, 1]]))]
for numerator in range(13):
assert_has_consistent_trace_distance_bound(E()**(numerator / 12))
def test_trace_distance_bound():
class NoMethod:
pass
class ReturnsNotImplemented:
def _trace_distance_bound_(self):
return NotImplemented
class ReturnsTwo:
def _trace_distance_bound_(self) -> float:
return 2.0
class ReturnsConstant:
def __init__(self, bound):
self.bound = bound
def _trace_distance_bound_(self) -> float:
return self.bound
assert cirq.trace_distance_bound(NoMethod()) == 1.0
assert cirq.trace_distance_bound(ReturnsNotImplemented()) == 1.0
assert cirq.trace_distance_bound(ReturnsTwo()) == 1.0
assert cirq.trace_distance_bound(ReturnsConstant(0.1)) == 0.1
assert cirq.trace_distance_bound(ReturnsConstant(0.5)) == 0.5
assert cirq.trace_distance_bound(ReturnsConstant(1.0)) == 1.0
assert cirq.trace_distance_bound(ReturnsConstant(2.0)) == 1.0
def test_trace_distance():
foo = sympy.Symbol('foo')
assert cirq.trace_distance_bound(cirq.XX**foo) == 1.0
assert cirq.trace_distance_bound(cirq.YY**foo) == 1.0
assert cirq.trace_distance_bound(cirq.ZZ**foo) == 1.0
assert cirq.approx_eq(cirq.trace_distance_bound(cirq.XX), 1.0)
assert cirq.approx_eq(cirq.trace_distance_bound(cirq.YY**0), 0)
assert cirq.approx_eq(cirq.trace_distance_bound(cirq.ZZ ** (1 / 3)), np.sin(np.pi / 6))
def test_protocols():
t = sympy.Symbol('t')
p = cirq.WaitGate(cirq.Duration(millis=5 * t))
c = cirq.WaitGate(cirq.Duration(millis=2))
q = cirq.LineQubit(0)
cirq.testing.assert_implements_consistent_protocols(cirq.wait(q, nanos=0))
cirq.testing.assert_implements_consistent_protocols(c.on(q))
cirq.testing.assert_implements_consistent_protocols(p.on(q))
assert cirq.has_unitary(p)
assert cirq.has_unitary(c)
assert cirq.is_parameterized(p)
assert not cirq.is_parameterized(c)
assert cirq.resolve_parameters(p, {'t': 2}) == cirq.WaitGate(cirq.Duration(millis=10))
assert cirq.resolve_parameters(c, {'t': 2}) == c
assert cirq.resolve_parameters_once(c, {'t': 2}) == c
assert cirq.trace_distance_bound(p) == 0
assert cirq.trace_distance_bound(c) == 0
assert cirq.inverse(c) == c
assert cirq.inverse(p) == p
assert cirq.decompose(c.on(q)) == []
assert cirq.decompose(p.on(q)) == []
def test_bounded_effect():
assert cirq.trace_distance_bound(CY**0.001) < 0.01
def test_tagged_operation_forwards_protocols():
"""The results of all protocols applied to an operation with a tag should
be equivalent to the result without tags.
"""
q1 = cirq.GridQubit(1, 1)
q2 = cirq.GridQubit(1, 2)
h = cirq.H(q1)
tag = 'tag1'
tagged_h = cirq.H(q1).with_tags(tag)
np.testing.assert_equal(cirq.unitary(tagged_h), cirq.unitary(h))
assert cirq.has_unitary(tagged_h)
assert cirq.decompose(tagged_h) == cirq.decompose(h)
assert cirq.pauli_expansion(tagged_h) == cirq.pauli_expansion(h)
assert cirq.equal_up_to_global_phase(h, tagged_h)
assert np.isclose(cirq.channel(h), cirq.channel(tagged_h)).all()
assert cirq.measurement_key(cirq.measure(q1, key='blah').with_tags(tag)) == 'blah'
parameterized_op = cirq.XPowGate(exponent=sympy.Symbol('t'))(q1).with_tags(tag)
assert cirq.is_parameterized(parameterized_op)
resolver = cirq.study.ParamResolver({'t': 0.25})
assert cirq.resolve_parameters(parameterized_op, resolver) == cirq.XPowGate(exponent=0.25)(
q1
).with_tags(tag)
assert cirq.resolve_parameters_once(parameterized_op, resolver) == cirq.XPowGate(exponent=0.25)(
q1
).with_tags(tag)
y = cirq.Y(q1)
tagged_y = cirq.Y(q1).with_tags(tag)
assert tagged_y ** 0.5 == cirq.YPowGate(exponent=0.5)(q1)
assert tagged_y * 2 == (y * 2)
assert 3 * tagged_y == (3 * y)
assert cirq.phase_by(y, 0.125, 0) == cirq.phase_by(tagged_y, 0.125, 0)
controlled_y = tagged_y.controlled_by(q2)
assert controlled_y.qubits == (
q2,
q1,
)
assert isinstance(controlled_y, cirq.Operation)
assert not isinstance(controlled_y, cirq.TaggedOperation)
clifford_x = cirq.SingleQubitCliffordGate.X(q1)
tagged_x = cirq.SingleQubitCliffordGate.X(q1).with_tags(tag)
assert cirq.commutes(clifford_x, clifford_x)
assert cirq.commutes(tagged_x, clifford_x)
assert cirq.commutes(clifford_x, tagged_x)
assert cirq.commutes(tagged_x, tagged_x)
assert cirq.trace_distance_bound(y ** 0.001) == cirq.trace_distance_bound(
(y ** 0.001).with_tags(tag)
)
flip = cirq.bit_flip(0.5)(q1)
tagged_flip = cirq.bit_flip(0.5)(q1).with_tags(tag)
assert cirq.has_mixture(tagged_flip)
assert cirq.has_channel(tagged_flip)
flip_mixture = cirq.mixture(flip)
tagged_mixture = cirq.mixture(tagged_flip)
assert len(tagged_mixture) == 2
assert len(tagged_mixture[0]) == 2
assert len(tagged_mixture[1]) == 2
assert tagged_mixture[0][0] == flip_mixture[0][0]
assert np.isclose(tagged_mixture[0][1], flip_mixture[0][1]).all()
assert tagged_mixture[1][0] == flip_mixture[1][0]
assert np.isclose(tagged_mixture[1][1], flip_mixture[1][1]).all()
qubit_map = {q1: 'q1'}
qasm_args = cirq.QasmArgs(qubit_id_map=qubit_map)
assert cirq.qasm(h, args=qasm_args) == cirq.qasm(tagged_h, args=qasm_args)
cirq.testing.assert_has_consistent_apply_unitary(tagged_h)
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
sswap = cirq.SWAP**foo
siswap = cirq.ISWAP**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(sswap) == 1.0
assert cirq.trace_distance_bound(siswap) == 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))
assert cirq.approx_eq(cirq.trace_distance_bound(cirq.SWAP**0.3),
np.sin(0.3 * np.pi / 2))
assert cirq.approx_eq(cirq.trace_distance_bound(cirq.ISWAP**0), 0.0)
def test_trace_bound():
assert cirq.trace_distance_bound(cg.ExpWGate(half_turns=.001)) < 0.01
assert cirq.trace_distance_bound(
cg.ExpWGate(half_turns=cirq.Symbol('a'))) >= 1
def test_single_qubit_trace_distance_bound():
x = cirq.SingleQubitMatrixGate(np.array([[0, 1], [1, 0]]))
x2 = cirq.SingleQubitMatrixGate(
np.array([[1, 1j], [1j, 1]]) * np.sqrt(0.5))
assert cirq.trace_distance_bound(x) >= 1
assert cirq.trace_distance_bound(x2) >= 0.5
def test_bounded_effect():
assert cirq.trace_distance_bound(CY**0.001) < 0.01
assert cirq.approx_eq(cirq.trace_distance_bound(CCH), 1.0)
assert cirq.approx_eq(cirq.trace_distance_bound(CRestricted), 1.0)
foo = sympy.Symbol('foo')
assert cirq.trace_distance_bound(cirq.ControlledGate(cirq.X**foo)) == 1
def test_trace_distance_bound():
class NoMethod:
pass
class ReturnsNotImplemented:
def _trace_distance_bound_(self):
return NotImplemented
class ReturnsTwo:
def _trace_distance_bound_(self) -> float:
return 2.0
class ReturnsConstant:
def __init__(self, bound):
self.bound = bound
def _trace_distance_bound_(self) -> float:
return self.bound
x = cirq.SingleQubitMatrixGate(cirq.unitary(cirq.X))
cx = cirq.TwoQubitMatrixGate(cirq.unitary(cirq.CX))
cxh = cirq.TwoQubitMatrixGate(cirq.unitary(cirq.CX**0.5))
assert np.isclose(cirq.trace_distance_bound(x),
cirq.trace_distance_bound(cirq.X))
assert np.isclose(cirq.trace_distance_bound(cx),
cirq.trace_distance_bound(cirq.CX))
assert np.isclose(cirq.trace_distance_bound(cxh),
cirq.trace_distance_bound(cirq.CX**0.5))
assert cirq.trace_distance_bound(NoMethod()) == 1.0
assert cirq.trace_distance_bound(ReturnsNotImplemented()) == 1.0
assert cirq.trace_distance_bound(ReturnsTwo()) == 1.0
assert cirq.trace_distance_bound(ReturnsConstant(0.1)) == 0.1
assert cirq.trace_distance_bound(ReturnsConstant(0.5)) == 0.5
assert cirq.trace_distance_bound(ReturnsConstant(1.0)) == 1.0
assert cirq.trace_distance_bound(ReturnsConstant(2.0)) == 1.0
def test_trace_distance_bound():
assert cirq.trace_distance_bound(CExpZinGate(0.001)) < 0.01
assert cirq.trace_distance_bound(CExpZinGate(cirq.Symbol('a'))) >= 1
def test_bounded_effect():
qubits = cirq.LineQubit.range(2)
cy = cirq.ControlledOperation(qubits[0], cirq.Y(qubits[1]))
assert cirq.trace_distance_bound(cy**0.001) < 0.01
def test_trace_bound():
assert cirq.trace_distance_bound(cg.ExpWGate(exponent=.001)) < 0.01
assert cirq.trace_distance_bound(cg.ExpWGate(
exponent=cirq.Symbol('a'))) >= 1
