def assert_consistent_resolve_parameters(val: Any):
names = cirq.parameter_names(val)
symbols = cirq.parameter_symbols(val)
assert {symbol.name for symbol in symbols} == names
if not cirq.is_parameterized(val):
assert not names
assert not symbols
else:
# Try to resolve all parameters with numbers. This may fail if some of
# the parameters want different types. But if resolution succeeds, the
# object should report that it has no more parameters to resolve.
try:
resolved = cirq.resolve_parameters(val, {name: 0 for name in names})
except Exception:
pass
else:
assert not cirq.parameter_names(resolved)
assert not cirq.parameter_symbols(resolved)
# Try single-step resolution of parameters to names that map to zero.
# All names should be preserved.
param_dict: cirq.ParamDictType = {
name: sympy.Symbol(name + '_CONSISTENCY_TEST') for name in names
}
param_dict.update({sympy.Symbol(name + '_CONSISTENCY_TEST'): 0 for name in names})
resolver = cirq.ParamResolver(param_dict) # type:ignore
resolved = cirq.resolve_parameters_once(val, resolver)
assert cirq.parameter_names(resolved) == set(name + '_CONSISTENCY_TEST' for name in names)
def _ref_simulate_2q_xeb_circuit(task: Dict[str, Any]):
"""Helper function for simulating a given (circuit, cycle_depth)."""
circuit_i = task['circuit_i']
cycle_depth = task['cycle_depth']
circuit = task['circuit']
param_resolver = task['param_resolver']
circuit_depth = cycle_depth * 2 + 1
assert circuit_depth <= len(circuit)
tcircuit = circuit[:circuit_depth]
tcircuit = cirq.resolve_parameters_once(tcircuit, param_resolver=param_resolver)
pure_sim = cirq.Simulator()
psi = pure_sim.simulate(tcircuit)
psi = psi.final_state_vector
pure_probs = cirq.state_vector_to_probabilities(psi)
return {'circuit_i': circuit_i, 'cycle_depth': cycle_depth, 'pure_probs': pure_probs}
def test_recursive_resolve():
a, b, c = [sympy.Symbol(l) for l in 'abc']
resolver = cirq.ParamResolver({a: b + 3, b: c + 2, c: 1})
assert cirq.resolve_parameters_once(a, resolver) == b + 3
assert cirq.resolve_parameters(a, resolver) == 6
assert cirq.resolve_parameters_once(b, resolver) == c + 2
assert cirq.resolve_parameters(b, resolver) == 3
assert cirq.resolve_parameters_once(c, resolver) == 1
assert cirq.resolve_parameters(c, resolver) == 1
assert cirq.resolve_parameters_once([a, b], {a: b, b: c}) == [b, c]
assert cirq.resolve_parameters_once(a, {}) == a
resolver = cirq.ParamResolver({a: b, b: a})
assert cirq.resolve_parameters_once(a, resolver) == b
with pytest.raises(RecursionError):
_ = cirq.resolve_parameters(a, resolver)
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_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)
