def test_parameterizable(resolve_fn): t = sympy.Symbol('t') x = cirq.DensePauliString('X') assert not cirq.is_parameterized(x) assert not cirq.is_parameterized(x * 2) assert cirq.is_parameterized(x * t) assert resolve_fn(x * t, {'t': 2}) == x * 2 assert resolve_fn(x * 3, {'t': 2}) == x * 3
def test_parameterizable_effect(): q = cirq.NamedQubit('q') r = cirq.ParamResolver({'a': 0.5}) op1 = cirq.ParallelGateOperation(cirq.Z**sympy.Symbol('a'), [q]) assert cirq.is_parameterized(op1) op2 = cirq.resolve_parameters(op1, r) assert not cirq.is_parameterized(op2)
def _is_parameterized_(self) -> bool: return ( cirq.is_parameterized(self.theta) or cirq.is_parameterized(self.zeta) or cirq.is_parameterized(self.chi) or cirq.is_parameterized(self.gamma) or cirq.is_parameterized(self.phi) )
def test_parameterizable_effect(resolve_fn): with cirq.testing.assert_deprecated(deadline="v0.14", count=None): q = cirq.NamedQubit('q') r = cirq.ParamResolver({'a': 0.5}) op1 = cirq.ParallelGateOperation(cirq.Z**sympy.Symbol('a'), [q]) assert cirq.is_parameterized(op1) op2 = resolve_fn(op1, r) assert not cirq.is_parameterized(op2)
def test_parameterizable(): s = sympy.Symbol('s') q0 = cirq.LineQubit(0) op = cirq.X(q0).with_classical_controls('a') opa = cirq.XPowGate(exponent=s).on(q0).with_classical_controls('a') assert cirq.is_parameterized(opa) assert not cirq.is_parameterized(op) assert cirq.resolve_parameters(opa, cirq.ParamResolver({'s': 1})) == op
def test_parameterized(resolve_fn): t = sympy.Symbol('t') assert not cirq.is_parameterized(Duration()) assert not cirq.is_parameterized(Duration(nanos=500)) assert cirq.is_parameterized(Duration(nanos=500 * t)) assert resolve_fn(Duration(), {'t': 2}) == Duration() assert resolve_fn(Duration(nanos=500), {'t': 2}) == Duration(nanos=500) assert resolve_fn(Duration(nanos=500 * t), {'t': 2}) == Duration(nanos=1000)
def test_parameterizable(resolve_fn): a = sympy.Symbol('a') qubits = cirq.LineQubit.range(3) cz = cirq.ControlledOperation(qubits[:1], cirq.Z(qubits[1])) cza = cirq.ControlledOperation(qubits[:1], cirq.ZPowGate(exponent=a)(qubits[1])) assert cirq.is_parameterized(cza) assert not cirq.is_parameterized(cz) assert resolve_fn(cza, cirq.ParamResolver({'a': 1})) == cz
def test_parameterizable_effect(resolve_fn): q = cirq.NamedQubit('q') r = cirq.ParamResolver({'a': 0.5}) op1 = cirq.GateOperation(cirq.Z**sympy.Symbol('a'), [q]) assert cirq.is_parameterized(op1) op2 = resolve_fn(op1, r) assert not cirq.is_parameterized(op2) assert op2 == cirq.S.on(q)
def test_parameterizable_effect(): q = cirq.NamedQubit('q') r = cirq.ParamResolver({'a': 0.5}) op1 = cirq.GateOperation(cirq.RotZGate(half_turns=cirq.Symbol('a')), [q]) assert cirq.is_parameterized(op1) op2 = cirq.resolve_parameters(op1, r) assert not cirq.is_parameterized(op2) assert op2 == cirq.S.on(q)
def test_parameterizable(): a = sympy.Symbol('a') cy = cirq.ControlledGate(cirq.Y) cya = cirq.ControlledGate(cirq.YPowGate(exponent=a)) scya = cirq.ControlledGate(cirq.YPowGate(exponent=a), [q]) assert cirq.is_parameterized(cya) assert cirq.is_parameterized(scya) assert not cirq.is_parameterized(cy) assert cirq.resolve_parameters(cya, cirq.ParamResolver({'a': 1})) == cy
def test_tagged_operation_resolves_parameterized_tags(): q = cirq.GridQubit(0, 0) tag = ParameterizableTag(sympy.Symbol('t')) assert cirq.is_parameterized(tag) op = cirq.Z(q).with_tags(tag) assert cirq.is_parameterized(op) resolved_op = cirq.resolve_parameters(op, {'t': 10}) assert resolved_op == cirq.Z(q).with_tags(ParameterizableTag(10)) assert not cirq.is_parameterized(resolved_op)
def _check_equal(self, g1: POSSIBLE_FSIM_GATES, g2: POSSIBLE_FSIM_GATES) -> bool: if not self.allow_symbols: return g1 == g2 and not (cirq.is_parameterized(g1) or cirq.is_parameterized(g2)) if self._get_value_equality_values_cls( g1) != self._get_value_equality_values_cls(g2): return False return self._approx_eq_or_symbol(self._get_value_equality_values(g1), self._get_value_equality_values(g2))
def test_phase_gradient_symbolic(resolve_fn): a = cirq.PhaseGradientGate(num_qubits=2, exponent=0.5) b = cirq.PhaseGradientGate(num_qubits=2, exponent=sympy.Symbol('t')) assert not cirq.is_parameterized(a) assert cirq.is_parameterized(b) assert cirq.has_unitary(a) assert not cirq.has_unitary(b) assert resolve_fn(a, {'t': 0.25}) is a assert resolve_fn(b, {'t': 0.5}) == a assert resolve_fn(b, {'t': 0.25}) == cirq.PhaseGradientGate(num_qubits=2, exponent=0.25)
def test_parameterized(resolve_fn): op = cirq.X.with_probability(sympy.Symbol('x')) assert cirq.is_parameterized(op) assert not cirq.has_kraus(op) assert not cirq.has_mixture(op) op2 = resolve_fn(op, {'x': 0.5}) assert op2 == cirq.X.with_probability(0.5) assert not cirq.is_parameterized(op2) assert cirq.has_kraus(op2) assert cirq.has_mixture(op2)
def test_fsim_resolve(): f = cirq.FSimGate(sympy.Symbol('a'), sympy.Symbol('b')) assert cirq.is_parameterized(f) f = cirq.resolve_parameters(f, {'a': 2}) assert f == cirq.FSimGate(2, sympy.Symbol('b')) assert cirq.is_parameterized(f) f = cirq.resolve_parameters(f, {'b': 1}) assert f == cirq.FSimGate(2, 1) assert not cirq.is_parameterized(f)
def test_parameterized(): op = cirq.X.with_probability(sympy.Symbol('x')) assert cirq.is_parameterized(op) assert not cirq.has_channel(op) assert not cirq.has_mixture(op) op2 = cirq.resolve_parameters(op, {'x': 0.5}) assert op2 == cirq.X.with_probability(0.5) assert not cirq.is_parameterized(op2) assert cirq.has_channel(op2) assert cirq.has_mixture(op2)
def test_tagged_operation_resolves_parameterized_tags(resolve_fn): q = cirq.GridQubit(0, 0) tag = ParameterizableTag(sympy.Symbol('t')) assert cirq.is_parameterized(tag) assert cirq.parameter_names(tag) == {'t'} op = cirq.Z(q).with_tags(tag) assert cirq.is_parameterized(op) assert cirq.parameter_names(op) == {'t'} resolved_op = resolve_fn(op, {'t': 10}) assert resolved_op == cirq.Z(q).with_tags(ParameterizableTag(10)) assert not cirq.is_parameterized(resolved_op) assert cirq.parameter_names(resolved_op) == set()
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_resolve(resolve_fn): diagonal_angles = [2, 3, 5, 7, 11, 13, 17, 19] diagonal_gate = cirq.DiagonalGate(diagonal_angles[:6] + [sympy.Symbol('a'), sympy.Symbol('b')]) assert cirq.is_parameterized(diagonal_gate) diagonal_gate = resolve_fn(diagonal_gate, {'a': 17}) assert diagonal_gate == cirq.DiagonalGate(diagonal_angles[:7] + [sympy.Symbol('b')]) assert cirq.is_parameterized(diagonal_gate) diagonal_gate = resolve_fn(diagonal_gate, {'b': 19}) assert diagonal_gate == cirq.DiagonalGate(diagonal_angles) assert not cirq.is_parameterized(diagonal_gate)
def test_resolve_parameters(resolve_fn): class NoMethod: pass class ReturnsNotImplemented: def _is_parameterized_(self): return NotImplemented def _resolve_parameters_(self, resolver, recursive): 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, recursive: bool): self.parameter = resolver.value_of(self.parameter, recursive) 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 resolve_fn(no, r) == no assert resolve_fn(no, d) == no assert resolve_fn(ni, r) == ni assert resolve_fn(SimpleParameterSwitch(0), r).parameter == 0 assert resolve_fn(SimpleParameterSwitch('a'), r).parameter == 0 assert resolve_fn(SimpleParameterSwitch('a'), d).parameter == 0 assert resolve_fn(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 resolve_fn((a, b, c), resolver) == (x, y, z) assert resolve_fn([a, b, c], resolver) == [x, y, z] assert resolve_fn((x, y, z), resolver) == (x, y, z) assert resolve_fn([x, y, z], resolver) == [x, y, z] assert resolve_fn((), resolver) == () assert resolve_fn([], resolver) == [] assert resolve_fn(1, resolver) == 1 assert resolve_fn(1.1, resolver) == 1.1 assert resolve_fn(1j, resolver) == 1j
def test_parameterizable(resolve_fn): a = sympy.Symbol('a') cy = cirq.ControlledGate(cirq.Y) cya = cirq.ControlledGate(cirq.YPowGate(exponent=a)) assert cirq.is_parameterized(cya) assert not cirq.is_parameterized(cy) assert resolve_fn(cya, cirq.ParamResolver({'a': 1})) == cy cchan = cirq.ControlledGate( cirq.RandomGateChannel(sub_gate=cirq.PhaseDampingChannel(0.1), probability=a)) with pytest.raises(ValueError, match='Cannot control channel'): resolve_fn(cchan, cirq.ParamResolver({'a': 0.1}))
def test_parameterizable(resolve_fn): t = sympy.Symbol('t') x = cirq.DensePauliString('X') xt = x * t x2 = x * 2 q = cirq.LineQubit(0) assert not cirq.is_parameterized(x) assert not cirq.is_parameterized(x * 2) assert cirq.is_parameterized(x * t) assert resolve_fn(xt, {'t': 2}) == x2 assert resolve_fn(x * 3, {'t': 2}) == x * 3 assert resolve_fn(xt(q), {'t': 2}).gate == x2 assert resolve_fn(xt(q).gate, {'t': 2}) == x2
def test_parameterize(resolve_fn, global_shift): parameterized_gate = cirq.PhasedXPowGate(exponent=sympy.Symbol('a'), phase_exponent=sympy.Symbol('b'), global_shift=global_shift) assert cirq.pow(parameterized_gate, 5) == cirq.PhasedXPowGate(exponent=sympy.Symbol('a') * 5, phase_exponent=sympy.Symbol('b'), global_shift=global_shift) assert cirq.unitary(parameterized_gate, default=None) is None assert cirq.is_parameterized(parameterized_gate) q = cirq.NamedQubit("q") parameterized_decomposed_circuit = cirq.Circuit( cirq.decompose(parameterized_gate(q))) for resolver in cirq.Linspace('a', 0, 2, 10) * cirq.Linspace( 'b', 0, 2, 10): resolved_gate = resolve_fn(parameterized_gate, resolver) assert resolved_gate == cirq.PhasedXPowGate( exponent=resolver.value_of('a'), phase_exponent=resolver.value_of('b'), global_shift=global_shift, ) np.testing.assert_allclose( cirq.unitary(resolved_gate(q)), cirq.unitary(resolve_fn(parameterized_decomposed_circuit, resolver)), atol=1e-8, ) unparameterized_gate = cirq.PhasedXPowGate(exponent=0.1, phase_exponent=0.2, global_shift=global_shift) assert not cirq.is_parameterized(unparameterized_gate) assert cirq.is_parameterized(unparameterized_gate**sympy.Symbol('a')) assert cirq.is_parameterized(unparameterized_gate**(sympy.Symbol('a') + 1)) resolver = {'a': 0.5j} with pytest.raises(ValueError, match='complex value'): resolve_fn( cirq.PhasedXPowGate(exponent=sympy.Symbol('a'), phase_exponent=0.2, global_shift=global_shift), resolver, ) with pytest.raises(ValueError, match='complex value'): resolve_fn( cirq.PhasedXPowGate(exponent=0.1, phase_exponent=sympy.Symbol('a'), global_shift=global_shift), resolver, )
def test_resolve(resolve_fn): diagonal_angles = [2, 3, 5, 7] diagonal_gate = cirq.TwoQubitDiagonalGate( diagonal_angles[:2] + [sympy.Symbol('a'), sympy.Symbol('b')] ) assert cirq.is_parameterized(diagonal_gate) diagonal_gate = resolve_fn(diagonal_gate, {'a': 5}) assert diagonal_gate == cirq.TwoQubitDiagonalGate(diagonal_angles[:3] + [sympy.Symbol('b')]) assert cirq.is_parameterized(diagonal_gate) diagonal_gate = resolve_fn(diagonal_gate, {'b': 7}) assert diagonal_gate == cirq.TwoQubitDiagonalGate(diagonal_angles) assert not cirq.is_parameterized(diagonal_gate)
def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> Optional[np.ndarray]: if cirq.is_parameterized(self): return NotImplemented am, bm, cm = (la.expm(-1j * self.exponent * np.array([[0, w], [w.conjugate(), 0]])) for w in self.weights) a1 = args.subspace_index(0b1001) b1 = args.subspace_index(0b0101) c1 = args.subspace_index(0b0011) a2 = args.subspace_index(0b0110) b2 = args.subspace_index(0b1010) c2 = args.subspace_index(0b1100) cirq.apply_matrix_to_slices(args.target_tensor, am, slices=[a1, a2], out=args.available_buffer) cirq.apply_matrix_to_slices(args.available_buffer, bm, slices=[b1, b2], out=args.target_tensor) return cirq.apply_matrix_to_slices(args.target_tensor, cm, slices=[c1, c2], out=args.available_buffer)
def _qasm_(self, args: 'cirq.QasmArgs', qubits: Tuple['cirq.Qid', ...]) -> Optional[str]: if cirq.is_parameterized(self): return None args.validate_version('2.0') e = cast(float, value.canonicalize_half_turns(self._exponent)) p = cast(float, self.phase_exponent) epsilon = 10**-args.precision if abs(e + 0.5) <= epsilon: return args.format('u2({0:half_turns}, {1:half_turns}) {2};\n', p + 0.5, -p - 0.5, qubits[0]) if abs(e - 0.5) <= epsilon: return args.format('u2({0:half_turns}, {1:half_turns}) {2};\n', p - 0.5, -p + 0.5, qubits[0]) return args.format( 'u3({0:half_turns}, {1:half_turns}, {2:half_turns}) {3};\n', -e, p + 0.5, -p - 0.5, qubits[0], )
def is_pasqal_device_op(self, op: cirq.ops.Operation) -> bool: if not isinstance(op, cirq.ops.Operation): raise ValueError('Got unknown operation:', op) valid_op = isinstance( op.gate, ( cirq.ops.IdentityGate, cirq.ops.MeasurementGate, cirq.ops.PhasedXPowGate, cirq.ops.XPowGate, cirq.ops.YPowGate, cirq.ops.ZPowGate, ), ) if not valid_op: # To prevent further checking if already passed if (isinstance( op.gate, ( cirq.ops.HPowGate, cirq.ops.CNotPowGate, cirq.ops.CZPowGate, cirq.ops.CCZPowGate, cirq.ops.CCXPowGate, ), ) and not cirq.is_parameterized(op)): expo = op.gate.exponent valid_op = np.isclose(expo, np.around(expo, decimals=0)) return valid_op
def _apply_unitary_(self, args: 'cirq.ApplyUnitaryArgs') -> Optional[np.ndarray]: if cirq.is_parameterized(self): return None oi = args.subspace_index(0b01) io = args.subspace_index(0b10) ii = args.subspace_index(0b11) if self.theta != 0 or self.zeta != 0 or self.chi != 0: rx = protocols.unitary(cirq.rx(2 * self.theta)) rz1 = protocols.unitary(cirq.rz(-self.zeta + self.chi)) rz2 = protocols.unitary(cirq.rz(-self.zeta - self.chi)) inner_matrix = rz1 @ rx @ rz2 out = cirq.apply_matrix_to_slices(args.target_tensor, inner_matrix, slices=[oi, io], out=args.available_buffer) else: out = args.target_tensor if self.phi != 0: out[ii] *= cmath.exp(-1j * self.phi) if self.gamma != 0: f = cmath.exp(-1j * self.gamma) out[oi] *= f out[io] *= f out[ii] *= f * f return out
def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs ) -> Optional[np.ndarray]: if cirq.is_parameterized(self): return None am = cirq.unitary(cirq.Rx(-np.pi * self.exponent * self.weights[0])) bm = cirq.unitary(cirq.Rx(-np.pi * self.exponent * self.weights[1])) cm = cirq.unitary(cirq.Rx(-np.pi * self.exponent * self.weights[2])) a1 = args.subspace_index(0b1001) b1 = args.subspace_index(0b0101) c1 = args.subspace_index(0b0011) a2 = args.subspace_index(0b0110) b2 = args.subspace_index(0b1010) c2 = args.subspace_index(0b1100) cirq.apply_matrix_to_slices(args.target_tensor, am, slices=[a1, a2], out=args.available_buffer) cirq.apply_matrix_to_slices(args.available_buffer, bm, slices=[b1, b2], out=args.target_tensor) return cirq.apply_matrix_to_slices(args.target_tensor, cm, slices=[c1, c2], out=args.available_buffer)
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)