def test_resolve_parameters(): class NoMethod: pass class ReturnsNotImplemented: def _is_parameterized_(self): return NotImplemented def _resolve_parameters_(self, resolver): return NotImplemented class SimpleParameterSwitch: def __init__(self, var): self.parameter = var def _is_parameterized_(self) -> bool: return self.parameter == 0 def _resolve_parameters_(self, resolver: ParamResolver): self.parameter = resolver.value_of(self.parameter) return self assert not cirq.is_parameterized(NoMethod()) assert not cirq.is_parameterized(ReturnsNotImplemented()) assert not cirq.is_parameterized(SimpleParameterSwitch('a')) assert cirq.is_parameterized(SimpleParameterSwitch(0)) ni = ReturnsNotImplemented() d = {'a': 0} r = cirq.ParamResolver(d) no = NoMethod() assert cirq.resolve_parameters(no, r) == no assert cirq.resolve_parameters(no, d) == no assert cirq.resolve_parameters(ni, r) == ni assert cirq.resolve_parameters(SimpleParameterSwitch(0), r).parameter == 0 assert cirq.resolve_parameters(SimpleParameterSwitch('a'), r).parameter == 0 assert cirq.resolve_parameters(SimpleParameterSwitch('a'), d).parameter == 0 assert cirq.resolve_parameters(sympy.Symbol('a'), r) == 0 a, b, c = tuple(sympy.Symbol(l) for l in 'abc') x, y, z = 0, 4, 7 resolver = {a: x, b: y, c: z} assert cirq.resolve_parameters((a, b, c), resolver) == (x, y, z) assert cirq.resolve_parameters([a, b, c], resolver) == [x, y, z] assert cirq.resolve_parameters((x, y, z), resolver) == (x, y, z) assert cirq.resolve_parameters([x, y, z], resolver) == [x, y, z] assert cirq.resolve_parameters((), resolver) == () assert cirq.resolve_parameters([], resolver) == [] assert cirq.resolve_parameters(1, resolver) == 1 assert cirq.resolve_parameters(1.1, resolver) == 1.1 assert cirq.resolve_parameters(1j, resolver) == 1j assert not cirq.is_parameterized((x, y)) assert not cirq.is_parameterized([x, y]) assert cirq.is_parameterized([a, b]) assert cirq.is_parameterized([a, x]) assert cirq.is_parameterized((a, b)) assert cirq.is_parameterized((a, x)) assert not cirq.is_parameterized(()) assert not cirq.is_parameterized([]) assert not cirq.is_parameterized(1) assert not cirq.is_parameterized(1.1) assert not cirq.is_parameterized(1j) assert cirq.parameter_names((a, b, c)) == {'a', 'b', 'c'} assert cirq.parameter_names([a, b, c]) == {'a', 'b', 'c'} assert cirq.parameter_names((x, y, z)) == set() assert cirq.parameter_names([x, y, z]) == set() assert cirq.parameter_names(()) == set() assert cirq.parameter_names([]) == set() assert cirq.parameter_names(1) == set() assert cirq.parameter_names(1.1) == set() assert cirq.parameter_names(1j) == set()
def _parameter_names_(self) -> AbstractSet[str]: return cirq.parameter_names(self.exponent) | cirq.parameter_names( self.phase_exponent)
def _parameter_names_(self) -> AbstractSet[str]: return cirq.parameter_names(self.theta) | cirq.parameter_names( self.phi)
def test_parameterized_repeat_side_effects(): q = cirq.LineQubit(0) op = cirq.CircuitOperation( cirq.FrozenCircuit( cirq.X(q).with_classical_controls('c'), cirq.measure(q, key='m')), repetitions=sympy.Symbol('a'), ) # Control keys can be calculated because they only "lift" if there's a matching # measurement, in which case they're not returned here. assert cirq.control_keys(op) == {cirq.MeasurementKey('c')} # "local" params do not bind to the repetition param. assert cirq.parameter_names(op.with_params({'a': 1})) == {'a'} # Check errors that require unrolling the circuit. with pytest.raises( ValueError, match='Cannot unroll circuit due to nondeterministic repetitions'): cirq.measurement_key_objs(op) with pytest.raises( ValueError, match='Cannot unroll circuit due to nondeterministic repetitions'): cirq.measurement_key_names(op) with pytest.raises( ValueError, match='Cannot unroll circuit due to nondeterministic repetitions'): op.mapped_circuit() with pytest.raises( ValueError, match='Cannot unroll circuit due to nondeterministic repetitions'): cirq.decompose(op) # Not compatible with repetition ids with pytest.raises(ValueError, match='repetition ids with parameterized repetitions'): op.with_repetition_ids(['x', 'y']) with pytest.raises(ValueError, match='repetition ids with parameterized repetitions'): op.repeat(repetition_ids=['x', 'y']) # TODO(daxfohl): This should work, but likely requires a new protocol that returns *just* the # name of the measurement keys. (measurement_key_names returns the full serialized string). with pytest.raises( ValueError, match='Cannot unroll circuit due to nondeterministic repetitions'): cirq.with_measurement_key_mapping(op, {'m': 'm2'}) # Everything should work once resolved op = cirq.resolve_parameters(op, {'a': 2}) assert set(map(str, cirq.measurement_key_objs(op))) == {'0:m', '1:m'} assert op.mapped_circuit() == cirq.Circuit( cirq.X(q).with_classical_controls('c'), cirq.measure(q, key=cirq.MeasurementKey.parse_serialized('0:m')), cirq.X(q).with_classical_controls('c'), cirq.measure(q, key=cirq.MeasurementKey.parse_serialized('1:m')), ) assert cirq.decompose(op) == cirq.decompose( cirq.Circuit( cirq.X(q).with_classical_controls('c'), cirq.measure(q, key=cirq.MeasurementKey.parse_serialized('0:m')), cirq.X(q).with_classical_controls('c'), cirq.measure(q, key=cirq.MeasurementKey.parse_serialized('1:m')), ))
def test_parameterized_repeat(): q = cirq.LineQubit(0) op = cirq.CircuitOperation(cirq.FrozenCircuit( cirq.X(q)))**sympy.Symbol('a') assert cirq.parameter_names(op) == {'a'} assert not cirq.has_unitary(op) result = cirq.Simulator().simulate(cirq.Circuit(op), param_resolver={'a': 0}) assert np.allclose(result.state_vector(), [1, 0]) result = cirq.Simulator().simulate(cirq.Circuit(op), param_resolver={'a': 1}) assert np.allclose(result.state_vector(), [0, 1]) result = cirq.Simulator().simulate(cirq.Circuit(op), param_resolver={'a': 2}) assert np.allclose(result.state_vector(), [1, 0]) result = cirq.Simulator().simulate(cirq.Circuit(op), param_resolver={'a': -1}) assert np.allclose(result.state_vector(), [0, 1]) with pytest.raises(TypeError, match='Only integer or sympy repetitions are allowed'): cirq.Simulator().simulate(cirq.Circuit(op), param_resolver={'a': 1.5}) with pytest.raises( ValueError, match='Circuit contains ops whose symbols were not specified'): cirq.Simulator().simulate(cirq.Circuit(op)) op = op**-1 assert cirq.parameter_names(op) == {'a'} assert not cirq.has_unitary(op) result = cirq.Simulator().simulate(cirq.Circuit(op), param_resolver={'a': 0}) assert np.allclose(result.state_vector(), [1, 0]) result = cirq.Simulator().simulate(cirq.Circuit(op), param_resolver={'a': 1}) assert np.allclose(result.state_vector(), [0, 1]) result = cirq.Simulator().simulate(cirq.Circuit(op), param_resolver={'a': 2}) assert np.allclose(result.state_vector(), [1, 0]) result = cirq.Simulator().simulate(cirq.Circuit(op), param_resolver={'a': -1}) assert np.allclose(result.state_vector(), [0, 1]) with pytest.raises(TypeError, match='Only integer or sympy repetitions are allowed'): cirq.Simulator().simulate(cirq.Circuit(op), param_resolver={'a': 1.5}) with pytest.raises( ValueError, match='Circuit contains ops whose symbols were not specified'): cirq.Simulator().simulate(cirq.Circuit(op)) op = op**sympy.Symbol('b') assert cirq.parameter_names(op) == {'a', 'b'} assert not cirq.has_unitary(op) result = cirq.Simulator().simulate(cirq.Circuit(op), param_resolver={ 'a': 1, 'b': 1 }) assert np.allclose(result.state_vector(), [0, 1]) result = cirq.Simulator().simulate(cirq.Circuit(op), param_resolver={ 'a': 2, 'b': 1 }) assert np.allclose(result.state_vector(), [1, 0]) result = cirq.Simulator().simulate(cirq.Circuit(op), param_resolver={ 'a': 1, 'b': 2 }) assert np.allclose(result.state_vector(), [1, 0]) with pytest.raises(TypeError, match='Only integer or sympy repetitions are allowed'): cirq.Simulator().simulate(cirq.Circuit(op), param_resolver={ 'a': 1.5, 'b': 1 }) with pytest.raises( ValueError, match='Circuit contains ops whose symbols were not specified'): cirq.Simulator().simulate(cirq.Circuit(op)) op = op**2.0 assert cirq.parameter_names(op) == {'a', 'b'} assert not cirq.has_unitary(op) result = cirq.Simulator().simulate(cirq.Circuit(op), param_resolver={ 'a': 1, 'b': 1 }) assert np.allclose(result.state_vector(), [1, 0]) result = cirq.Simulator().simulate(cirq.Circuit(op), param_resolver={ 'a': 1.5, 'b': 1 }) assert np.allclose(result.state_vector(), [0, 1]) result = cirq.Simulator().simulate(cirq.Circuit(op), param_resolver={ 'a': 1, 'b': 1.5 }) assert np.allclose(result.state_vector(), [0, 1]) with pytest.raises(TypeError, match='Only integer or sympy repetitions are allowed'): cirq.Simulator().simulate(cirq.Circuit(op), param_resolver={ 'a': 1.5, 'b': 1.5 }) with pytest.raises( ValueError, match='Circuit contains ops whose symbols were not specified'): cirq.Simulator().simulate(cirq.Circuit(op))
def _parameter_names_(self) -> AbstractSet[str]: return cirq.parameter_names(self.value)
def test_periodic_value_is_parameterized(value, is_parameterized, parameter_names): assert cirq.is_parameterized(value) == is_parameterized assert cirq.parameter_names(value) == parameter_names resolved = cirq.resolve_parameters(value, {p: 1 for p in parameter_names}) assert not cirq.is_parameterized(resolved)