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)
