def get_eqn_matrix(expressions, varList):
""" Return A and B matrices for expression with x as varList """
exprs = []
for expr in expressions.split('&&'):
if '==' in expr:
eq = expr.split('==')
exprs.append(sympy.sympify(eq[0] + '<=' + eq[1]))
exprs.append(sympy.sympify(eq[0] + '>=' + eq[1]))
else:
sym_expr = sympy.sympify(expr)
if sym_expr.func == sympy.StrictLessThan:
sym_expr = sympy.LessThan(sym_expr.lhs, sym_expr.rhs)
elif sym_expr.func == sympy.StrictGreaterThan:
sym_expr = sympy.GreaterThan(sym_expr.lhs, sym_expr.rhs)
exprs.append(sym_expr)
aMatrix = [[0 for v in varList] for expr in exprs]
bMatrix = [0 for expr in exprs]
eqMatrix = []
for i, expr in enumerate(exprs):
eqMatrix.append([expr.rel_op])
expr = expr.lhs - expr.rhs
expr *= SymEq.get_factor(expr)
for v in expr.free_symbols:
aMatrix[i][varList.index(
str(v))] = expr.as_coefficients_dict()[v]
bMatrix[i] = [
-expr.as_coefficients_dict()[sympy.numbers.One()]
]
return [aMatrix, bMatrix, eqMatrix]
def construct_invariant(guard):
inv_eqn = []
for eqn in guard.expr:
print('Eqn is: ' + str(eqn))
if eqn.func == sympy.LessThan:
inv = sympy.GreaterThan(*eqn.args)
elif eqn.func == sympy.GreaterThan:
inv = sympy.LessThan(*eqn.args)
elif eqn.func == sympy.StrictLessThan:
inv = sympy.StrictGreaterThan(*eqn.args)
elif eqn.func == sympy.StrictGreaterThan:
inv = sympy.StrictLessThan(*eqn.args)
inv_eqn.append(inv)
inv_eqn = [str(inv) for inv in inv_eqn]
return Invariant('||'.join(inv_eqn))
def convert_relation(rel):
if rel.expr():
return convert_expr(rel.expr())
lh = convert_relation(rel.relation(0))
rh = convert_relation(rel.relation(1))
if rel.LT():
return sympy.StrictLessThan(lh, rh)
elif rel.LTE():
return sympy.LessThan(lh, rh)
elif rel.GT():
return sympy.StrictGreaterThan(lh, rh)
elif rel.GTE():
return sympy.GreaterThan(lh, rh)
elif rel.EQUAL():
return sympy.Eq(lh, rh)
def __convert_relation(rel: PSParser.RelationContext):
if rel.expr():
return Math.__convert_expr(rel.expr())
lh = Math.__convert_relation(rel.relation(0))
rh = Math.__convert_relation(rel.relation(1))
if rel.LT():
return sympy.StrictLessThan(lh, rh)
elif rel.LTE():
return sympy.LessThan(lh, rh)
elif rel.GT():
return sympy.StrictGreaterThan(lh, rh)
elif rel.GTE():
return sympy.GreaterThan(lh, rh)
elif rel.EQUAL():
return sympy.Eq(lh, rh)
else:
raise NotImplementedError("Function implemented")
def convert_relation(rel):
if rel.expr():
return convert_expr(rel.expr())
lh = convert_relation(rel.relation(0))
rh = convert_relation(rel.relation(1))
if rel.LT():
return sympy.StrictLessThan(lh, rh, evaluate=False)
elif rel.LTE():
return sympy.LessThan(lh, rh, evaluate=False)
elif rel.GT():
return sympy.StrictGreaterThan(lh, rh, evaluate=False)
elif rel.GTE():
return sympy.GreaterThan(lh, rh, evaluate=False)
elif rel.EQUAL():
return sympy.Eq(lh, rh, evaluate=False)
elif rel.ASSIGNMENT():
# !Use Global variances
variances[lh] = rh
var[str(lh)] = rh
return rh
elif rel.UNEQUAL():
return sympy.Ne(lh, rh, evaluate=False)
def calculate_cache_access(self):
# FIXME handle multiple datatypes
element_size = self.kernel.datatypes_size[self.kernel.datatype]
results = {'dimensions': {}}
def sympy_compare(a, b):
c = 0
for i in range(min(len(a), len(b))):
s = a[i] - b[i]
if sympy.simplify(s > 0):
c = -1
elif sympy.simplify(s == 0):
c = 0
else:
c = 1
if c != 0: break
return c
accesses = defaultdict(list)
sympy_accesses = defaultdict(list)
for var_name in self.kernel.variables:
for r in self.kernel._sources.get(var_name, []):
if r is None: continue
accesses[var_name].append(r)
sympy_accesses[var_name].append(
self.kernel.access_to_sympy(var_name, r))
for w in self.kernel._destinations.get(var_name, []):
if w is None: continue
accesses[var_name].append(w)
sympy_accesses[var_name].append(
self.kernel.access_to_sympy(var_name, w))
# order accesses by increasing order
accesses[var_name].sort(
key=cmp_to_key(sympy_compare)) #cmp=sympy_compare)
results['accesses'] = accesses
results['sympy_accesses'] = sympy_accesses
# For each dimension (1D, 2D, 3D ... nD)
for dimension in range(1, len(list(self.kernel.get_loop_stack())) + 1):
results['dimensions'][dimension] = {}
slices = defaultdict(list)
slices_accesses = defaultdict(list)
for var_name in accesses:
for a in accesses[var_name]:
# slices are identified by the tuple of indices of higher dimensions
slice_id = tuple([var_name, tuple(a[:-dimension])])
slices[slice_id].append(a)
slices_accesses[slice_id].append(
self.kernel.access_to_sympy(var_name, a))
results['dimensions'][dimension]['slices'] = slices
results['dimensions'][dimension][
'slices_accesses'] = slices_accesses
slices_distances = defaultdict(list)
for k, v in slices_accesses.items():
for i in range(1, len(v)):
slices_distances[k].append((v[i - 1] - v[i]).simplify())
results['dimensions'][dimension][
'slices_distances'] = slices_distances
# Check that distances contain only free_symbols based on constants
for dist in chain(*slices_distances.values()):
if any([
s not in self.kernel.constants.keys()
for s in dist.free_symbols
]):
raise ValueError(
"Some distances are not based on non-constants: " +
str(dist))
# Sum of lengths between relative distances
slices_sum = sum(
[sum(dists) for dists in slices_distances.values()])
results['dimensions'][dimension]['slices_sum'] = slices_sum
# Max of lengths between relative distances
# Work-around, the arguments with the most symbols get to stay
# FIXME, may not be correct in all cases. e.g., N+M vs. N*M
def FuckedUpMax(*args):
if len(args) == 1:
return args[0]
# expand all expressions:
args = [a.expand() for a in args]
# Filter expressions with less than the maximum number of symbols
max_symbols = max([len(a.free_symbols) for a in args])
args = list(
filter(lambda a: len(a.free_symbols) == max_symbols, args))
if max_symbols == 0:
return sympy.Max(*args)
# Filter symbols with lower exponent
max_coeffs = 0
for a in args:
for s in a.free_symbols:
max_coeffs = max(max_coeffs,
len(sympy.Poly(a, s).all_coeffs()))
def coeff_filter(a):
return max(
0, 0, *[
len(sympy.Poly(a, s).all_coeffs())
for s in a.free_symbols
]) == max_coeffs
args = list(filter(coeff_filter, args))
m = sympy.Max(*args)
#if m.is_Function:
# raise ValueError("Could not resolve {} to maximum.".format(m))
return m
slices_max = FuckedUpMax(
*[FuckedUpMax(*dists) for dists in slices_distances.values()])
results['dimensions'][dimension]['slices_sum'] = slices_sum
# Nmber of slices
slices_count = len(slices_accesses)
results['dimensions'][dimension]['slices_count'] = slices_count
# Cache requirement expression
cache_requirement_bytes = (
slices_sum + slices_max * slices_count) * element_size
results['dimensions'][dimension][
'cache_requirement_bytes'] = cache_requirement_bytes
# Apply to all cache sizes
csim = self.machine.get_cachesim()
results['dimensions'][dimension]['caches'] = {}
for cl in csim.levels(with_mem=False):
cache_equation = sympy.Eq(cache_requirement_bytes, cl.size())
if len(self.kernel.constants.keys()) <= 1:
inequality = sympy.solve(
sympy.LessThan(cache_requirement_bytes, cl.size()),
*self.kernel.constants.keys())
else:
# Sympy does not solve for multiple constants
inequality = sympy.LessThan(cache_requirement_bytes,
cl.size())
results['dimensions'][dimension]['caches'][cl.name] = {
'cache_size':
cl.size(),
'equation':
cache_equation,
'lt':
inequality,
'eq':
sympy.solve(cache_equation,
*self.kernel.constants.keys(),
dict=True)
}
return results
def _class_resolver_dictionary() -> Dict[str, ObjectFactory]:
import cirq
from cirq.ops import raw_types
import pandas as pd
import numpy as np
from cirq.devices.noise_model import _NoNoiseModel
from cirq.experiments import CrossEntropyResult, CrossEntropyResultDict, GridInteractionLayer
from cirq.experiments.grid_parallel_two_qubit_xeb import GridParallelXEBMetadata
def _boolean_hamiltonian_gate_op(qubit_map, boolean_strs, theta):
return cirq.BooleanHamiltonianGate(parameter_names=list(
qubit_map.keys()),
boolean_strs=boolean_strs,
theta=theta).on(*qubit_map.values())
def _identity_operation_from_dict(qubits, **kwargs):
return cirq.identity_each(*qubits)
def single_qubit_matrix_gate(matrix):
if not isinstance(matrix, np.ndarray):
matrix = np.array(matrix, dtype=np.complex128)
return cirq.MatrixGate(matrix, qid_shape=(matrix.shape[0], ))
def two_qubit_matrix_gate(matrix):
if not isinstance(matrix, np.ndarray):
matrix = np.array(matrix, dtype=np.complex128)
return cirq.MatrixGate(matrix, qid_shape=(2, 2))
def _parallel_gate_op(gate, qubits):
return cirq.parallel_gate_op(gate, *qubits)
def _datetime(timestamp: float) -> datetime.datetime:
# As part of our serialization logic, we make sure we only serialize "aware"
# datetimes with the UTC timezone, so we implicitly add back in the UTC timezone here.
#
# Please note: even if the assumption is somehow violated, the fact that we use
# unix timestamps should mean that the deserialized datetime should refer to the
# same point in time but may not satisfy o = read_json(to_json(o)) because the actual
# timezones, and hour fields will not be identical.
return datetime.datetime.fromtimestamp(timestamp,
tz=datetime.timezone.utc)
def _symmetricalqidpair(qids):
return frozenset(qids)
import sympy
return {
'AmplitudeDampingChannel': cirq.AmplitudeDampingChannel,
'AnyIntegerPowerGateFamily': cirq.AnyIntegerPowerGateFamily,
'AnyUnitaryGateFamily': cirq.AnyUnitaryGateFamily,
'AsymmetricDepolarizingChannel': cirq.AsymmetricDepolarizingChannel,
'BitFlipChannel': cirq.BitFlipChannel,
'BitstringAccumulator': cirq.work.BitstringAccumulator,
'BooleanHamiltonianGate': cirq.BooleanHamiltonianGate,
'CCNotPowGate': cirq.CCNotPowGate,
'CCXPowGate': cirq.CCXPowGate,
'CCZPowGate': cirq.CCZPowGate,
'Circuit': cirq.Circuit,
'CircuitOperation': cirq.CircuitOperation,
'ClassicallyControlledOperation': cirq.ClassicallyControlledOperation,
'ClassicalDataDictionaryStore': cirq.ClassicalDataDictionaryStore,
'CliffordGate': cirq.CliffordGate,
'CliffordState': cirq.CliffordState,
'CliffordTableau': cirq.CliffordTableau,
'CNotPowGate': cirq.CNotPowGate,
'ConstantQubitNoiseModel': cirq.ConstantQubitNoiseModel,
'ControlledGate': cirq.ControlledGate,
'ControlledOperation': cirq.ControlledOperation,
'CrossEntropyResult': CrossEntropyResult,
'CrossEntropyResultDict': CrossEntropyResultDict,
'CSwapGate': cirq.CSwapGate,
'CXPowGate': cirq.CXPowGate,
'CZPowGate': cirq.CZPowGate,
'CZTargetGateset': cirq.CZTargetGateset,
'DiagonalGate': cirq.DiagonalGate,
'DensePauliString': cirq.DensePauliString,
'DepolarizingChannel': cirq.DepolarizingChannel,
'DeviceMetadata': cirq.DeviceMetadata,
'Duration': cirq.Duration,
'FrozenCircuit': cirq.FrozenCircuit,
'FSimGate': cirq.FSimGate,
'GateFamily': cirq.GateFamily,
'GateOperation': cirq.GateOperation,
'Gateset': cirq.Gateset,
'GeneralizedAmplitudeDampingChannel':
cirq.GeneralizedAmplitudeDampingChannel,
'GlobalPhaseGate': cirq.GlobalPhaseGate,
'GlobalPhaseOperation': cirq.GlobalPhaseOperation,
'GridDeviceMetadata': cirq.GridDeviceMetadata,
'GridInteractionLayer': GridInteractionLayer,
'GridParallelXEBMetadata': GridParallelXEBMetadata,
'GridQid': cirq.GridQid,
'GridQubit': cirq.GridQubit,
'HPowGate': cirq.HPowGate,
'ISwapPowGate': cirq.ISwapPowGate,
'IdentityGate': cirq.IdentityGate,
'InitObsSetting': cirq.work.InitObsSetting,
'KeyCondition': cirq.KeyCondition,
'KrausChannel': cirq.KrausChannel,
'LinearDict': cirq.LinearDict,
'LineQubit': cirq.LineQubit,
'LineQid': cirq.LineQid,
'LineTopology': cirq.LineTopology,
'MatrixGate': cirq.MatrixGate,
'MixedUnitaryChannel': cirq.MixedUnitaryChannel,
'MeasurementKey': cirq.MeasurementKey,
'MeasurementGate': cirq.MeasurementGate,
'MeasurementType': cirq.MeasurementType,
'_MeasurementSpec': cirq.work._MeasurementSpec,
'Moment': cirq.Moment,
'MutableDensePauliString': cirq.MutableDensePauliString,
'MutablePauliString': cirq.MutablePauliString,
'_NoNoiseModel': _NoNoiseModel,
'NamedQubit': cirq.NamedQubit,
'NamedQid': cirq.NamedQid,
'NoIdentifierQubit': cirq.testing.NoIdentifierQubit,
'ObservableMeasuredResult': cirq.work.ObservableMeasuredResult,
'OpIdentifier': cirq.OpIdentifier,
'ParamResolver': cirq.ParamResolver,
'ParallelGate': cirq.ParallelGate,
'ParallelGateFamily': cirq.ParallelGateFamily,
'PauliInteractionGate': cirq.PauliInteractionGate,
'PauliMeasurementGate': cirq.PauliMeasurementGate,
'PauliString': cirq.PauliString,
'PauliStringPhasor': cirq.PauliStringPhasor,
'PauliStringPhasorGate': cirq.PauliStringPhasorGate,
'PauliSum': cirq.PauliSum,
'_PauliX': cirq.ops.pauli_gates._PauliX,
'_PauliY': cirq.ops.pauli_gates._PauliY,
'_PauliZ': cirq.ops.pauli_gates._PauliZ,
'PhaseDampingChannel': cirq.PhaseDampingChannel,
'PhaseFlipChannel': cirq.PhaseFlipChannel,
'PhaseGradientGate': cirq.PhaseGradientGate,
'PhasedFSimGate': cirq.PhasedFSimGate,
'PhasedISwapPowGate': cirq.PhasedISwapPowGate,
'PhasedXPowGate': cirq.PhasedXPowGate,
'PhasedXZGate': cirq.PhasedXZGate,
'ProductState': cirq.ProductState,
'ProjectorString': cirq.ProjectorString,
'ProjectorSum': cirq.ProjectorSum,
'QasmUGate': cirq.circuits.qasm_output.QasmUGate,
'_QubitAsQid': raw_types._QubitAsQid,
'QuantumFourierTransformGate': cirq.QuantumFourierTransformGate,
'QubitPermutationGate': cirq.QubitPermutationGate,
'RandomGateChannel': cirq.RandomGateChannel,
'RepetitionsStoppingCriteria': cirq.work.RepetitionsStoppingCriteria,
'ResetChannel': cirq.ResetChannel,
'Result': cirq.ResultDict, # Keep support for Cirq < 0.14.
'ResultDict': cirq.ResultDict,
'Rx': cirq.Rx,
'Ry': cirq.Ry,
'Rz': cirq.Rz,
'SingleQubitCliffordGate': cirq.SingleQubitCliffordGate,
'SingleQubitPauliStringGateOperation':
cirq.SingleQubitPauliStringGateOperation,
'SingleQubitReadoutCalibrationResult':
cirq.experiments.SingleQubitReadoutCalibrationResult,
'SqrtIswapTargetGateset': cirq.SqrtIswapTargetGateset,
'StabilizerStateChForm': cirq.StabilizerStateChForm,
'StatePreparationChannel': cirq.StatePreparationChannel,
'SwapPowGate': cirq.SwapPowGate,
'SympyCondition': cirq.SympyCondition,
'TaggedOperation': cirq.TaggedOperation,
'TensoredConfusionMatrices': cirq.TensoredConfusionMatrices,
'TiltedSquareLattice': cirq.TiltedSquareLattice,
'ThreeQubitDiagonalGate': cirq.ThreeQubitDiagonalGate,
'TrialResult': cirq.ResultDict, # keep support for Cirq < 0.11.
'TwoQubitDiagonalGate': cirq.TwoQubitDiagonalGate,
'TwoQubitGateTabulation': cirq.TwoQubitGateTabulation,
'_UnconstrainedDevice':
cirq.devices.unconstrained_device._UnconstrainedDevice,
'VarianceStoppingCriteria': cirq.work.VarianceStoppingCriteria,
'VirtualTag': cirq.VirtualTag,
'WaitGate': cirq.WaitGate,
# The formatter keeps putting this back
# pylint: disable=line-too-long
'XEBPhasedFSimCharacterizationOptions':
cirq.experiments.XEBPhasedFSimCharacterizationOptions,
# pylint: enable=line-too-long
'_XEigenState': cirq.value.product_state._XEigenState, # type: ignore
'XPowGate': cirq.XPowGate,
'XXPowGate': cirq.XXPowGate,
'_YEigenState': cirq.value.product_state._YEigenState, # type: ignore
'YPowGate': cirq.YPowGate,
'YYPowGate': cirq.YYPowGate,
'_ZEigenState': cirq.value.product_state._ZEigenState, # type: ignore
'ZPowGate': cirq.ZPowGate,
'ZZPowGate': cirq.ZZPowGate,
# Old types, only supported for backwards-compatibility
'BooleanHamiltonian': _boolean_hamiltonian_gate_op, # Removed in v0.15
'IdentityOperation': _identity_operation_from_dict,
'ParallelGateOperation': _parallel_gate_op, # Removed in v0.14
'SingleQubitMatrixGate': single_qubit_matrix_gate,
'SymmetricalQidPair': _symmetricalqidpair, # Removed in v0.15
'TwoQubitMatrixGate': two_qubit_matrix_gate,
# not a cirq class, but treated as one:
'pandas.DataFrame': pd.DataFrame,
'pandas.Index': pd.Index,
'pandas.MultiIndex': pd.MultiIndex.from_tuples,
'sympy.Symbol': sympy.Symbol,
'sympy.Add': lambda args: sympy.Add(*args),
'sympy.Mul': lambda args: sympy.Mul(*args),
'sympy.Pow': lambda args: sympy.Pow(*args),
'sympy.GreaterThan': lambda args: sympy.GreaterThan(*args),
'sympy.StrictGreaterThan': lambda args: sympy.StrictGreaterThan(*args),
'sympy.LessThan': lambda args: sympy.LessThan(*args),
'sympy.StrictLessThan': lambda args: sympy.StrictLessThan(*args),
'sympy.Equality': lambda args: sympy.Equality(*args),
'sympy.Unequality': lambda args: sympy.Unequality(*args),
'sympy.Float': lambda approx: sympy.Float(approx),
'sympy.Integer': sympy.Integer,
'sympy.Rational': sympy.Rational,
'sympy.pi': lambda: sympy.pi,
'sympy.E': lambda: sympy.E,
'sympy.EulerGamma': lambda: sympy.EulerGamma,
'complex': complex,
'datetime.datetime': _datetime,
}
def approx_eq(val: Any, other: Any, *, atol: Union[int, float] = 1e-8) -> bool:
"""Approximately compares two objects.
If `val` implements SupportsApproxEquality protocol then it is invoked and
takes precedence over all other checks:
- For primitive numeric types `int` and `float` approximate equality is
delegated to math.isclose().
- For complex primitive type the real and imaginary parts are treated
independently and compared using math.isclose().
- For `val` and `other` both iterable of the same length, consecutive
elements are compared recursively. Types of `val` and `other` does not
necessarily needs to match each other. They just need to be iterable and
have the same structure.
Args:
val: Source object for approximate comparison.
other: Target object for approximate comparison.
atol: The minimum absolute tolerance. See np.isclose() documentation for
details. Defaults to 1e-8 which matches np.isclose() default
absolute tolerance.
Returns:
True if objects are approximately equal, False otherwise.
"""
# Check if val defines approximate equality via _approx_eq_. This takes
# precedence over all other overloads.
approx_eq_getter = getattr(val, '_approx_eq_', None)
if approx_eq_getter is not None:
result = approx_eq_getter(other, atol)
if result is not NotImplemented:
return result
# The same for other to make approx_eq symmetric.
other_approx_eq_getter = getattr(other, '_approx_eq_', None)
if other_approx_eq_getter is not None:
result = other_approx_eq_getter(val, atol)
if result is not NotImplemented:
return result
# Compare primitive types directly.
if isinstance(val, numbers.Number):
if not isinstance(other, numbers.Number):
return False
result = _isclose(val, other, atol=atol)
if result is not NotImplemented:
return result
if isinstance(val, str):
return val == other
if isinstance(val, sympy.Basic) or isinstance(other, sympy.Basic):
delta = sympy.Abs(other - val).simplify()
if not delta.is_number:
raise AttributeError('Insufficient information to decide whether '
'expressions are approximately equal '
f'[{val}] vs [{other}]')
return sympy.LessThan(delta, atol) == sympy.true
# If the values are iterable, try comparing recursively on items.
if isinstance(val, Iterable) and isinstance(other, Iterable):
return _approx_eq_iterables(val, other, atol=atol)
# Last resort: exact equality.
return val == other
print('## str, repr')
display(str(expr))
display(repr(expr))
# In[10]:
display((expr.lhs, expr.rhs)) # left-hand side, # right-hand side
display((expr.lts, expr.gts)) # less-than side, # greater-than side
# Sympy rewrites inequalities so that the left-hand side is the less-than-side:
assert expr.lhs == expr.lts
assert expr.rhs == expr.gts
# In[11]:
expr = sympy.solve(x <= 10)
expr2 = sympy.LessThan(x, 10)
expr3 = (x <= 10)
expr4 = (10 >= x)
display(expr, expr2, expr3, expr4)
assert expr == expr2 == expr3 == expr4
# Sympy rewrites inequalities so that the left-hand side is the less-than-side:
assert (expr.lhs, expr.rhs) == (expr.lts, expr.gts)
assert (expr4.lhs, expr4.rhs) == (expr4.lts, expr4.gts)
display((expr2.lts, expr2.gts))
display((expr3.lts, expr3.gts))
display((expr4.lts, expr4.gts))
# In[12]:
expr.rel_op
("x_0", sympy.Symbol('x_{0}')), ("x_{1}", sympy.Symbol('x_{1}')),
("x_a", sympy.Symbol('x_{a}')), ("x_{b}", sympy.Symbol('x_{b}')),
("h_\\theta", sympy.Symbol('h_{theta}')),
("h_{\\theta}", sympy.Symbol('h_{theta}')),
("h_{\\theta}(x_0, x_1)",
sympy.Symbol('h_{theta}')(sympy.Symbol('x_{0}'), sympy.Symbol('x_{1}'))),
("x!", _factorial(x)), ("100!", _factorial(100)),
("\\theta!", _factorial(theta)), ("(x + 1)!", _factorial(_Add(x, 1))),
("(x!)!", _factorial(_factorial(x))),
("x!!!", _factorial(_factorial(_factorial(x)))),
("5!7!", _Mul(_factorial(5), _factorial(7))), ("\\sqrt{x}", sympy.sqrt(x)),
("\\sqrt{x + b}", sympy.sqrt(_Add(x, b))),
("\\sqrt[3]{\\sin x}", sympy.root(sympy.sin(x), 3)),
("\\sqrt[y]{\\sin x}", sympy.root(sympy.sin(x), y)),
("\\sqrt[\\theta]{\\sin x}", sympy.root(sympy.sin(x), theta)),
("x < y", sympy.StrictLessThan(x, y)), ("x \\leq y", sympy.LessThan(x, y)),
("x > y", sympy.StrictGreaterThan(x, y)),
("x \\geq y", sympy.GreaterThan(x, y)), ("\\mathit{x}", sympy.Symbol('x')),
("\\mathit{test}", sympy.Symbol('test')),
("\\mathit{TEST}", sympy.Symbol('TEST')),
("\\mathit{HELLO world}", sympy.Symbol('HELLO world')),
("\\sum_{k = 1}^{3} c", sympy.Sum(c, (k, 1, 3))),
("\\sum_{k = 1}^3 c", sympy.Sum(c, (k, 1, 3))),
("\\sum^{3}_{k = 1} c", sympy.Sum(c, (k, 1, 3))),
("\\sum^3_{k = 1} c", sympy.Sum(c, (k, 1, 3))),
("\\sum_{k = 1}^{10} k^2", sympy.Sum(k**2, (k, 1, 10))),
("\\sum_{n = 0}^{\\infty} \\frac{1}{n!}",
sympy.Sum(_Pow(_factorial(n), -1), (n, 0, sympy.oo))),
("\\prod_{a = b}^{c} x", sympy.Product(x, (a, b, c))),
("\\prod_{a = b}^c x", sympy.Product(x, (a, b, c))),
("\\prod^{c}_{a = b} x", sympy.Product(x, (a, b, c))),
def _class_resolver_dictionary() -> Dict[str, ObjectFactory]:
import cirq
from cirq.ops import raw_types
import pandas as pd
import numpy as np
from cirq.devices.noise_model import _NoNoiseModel
from cirq.experiments import CrossEntropyResult, CrossEntropyResultDict, GridInteractionLayer
from cirq.experiments.grid_parallel_two_qubit_xeb import GridParallelXEBMetadata
def _identity_operation_from_dict(qubits, **kwargs):
return cirq.identity_each(*qubits)
def single_qubit_matrix_gate(matrix):
if not isinstance(matrix, np.ndarray):
matrix = np.array(matrix, dtype=np.complex128)
return cirq.MatrixGate(matrix, qid_shape=(matrix.shape[0], ))
def two_qubit_matrix_gate(matrix):
if not isinstance(matrix, np.ndarray):
matrix = np.array(matrix, dtype=np.complex128)
return cirq.MatrixGate(matrix, qid_shape=(2, 2))
def _parallel_gate_op(gate, qubits):
return cirq.parallel_gate_op(gate, *qubits)
import sympy
return {
'AmplitudeDampingChannel': cirq.AmplitudeDampingChannel,
'AnyIntegerPowerGateFamily': cirq.AnyIntegerPowerGateFamily,
'AnyUnitaryGateFamily': cirq.AnyUnitaryGateFamily,
'AsymmetricDepolarizingChannel': cirq.AsymmetricDepolarizingChannel,
'BitFlipChannel': cirq.BitFlipChannel,
'BitstringAccumulator': cirq.work.BitstringAccumulator,
'BooleanHamiltonian': cirq.BooleanHamiltonian,
'CCNotPowGate': cirq.CCNotPowGate,
'CCXPowGate': cirq.CCXPowGate,
'CCZPowGate': cirq.CCZPowGate,
'Circuit': cirq.Circuit,
'CircuitOperation': cirq.CircuitOperation,
'ClassicallyControlledOperation': cirq.ClassicallyControlledOperation,
'CliffordState': cirq.CliffordState,
'CliffordTableau': cirq.CliffordTableau,
'CNotPowGate': cirq.CNotPowGate,
'ConstantQubitNoiseModel': cirq.ConstantQubitNoiseModel,
'ControlledGate': cirq.ControlledGate,
'ControlledOperation': cirq.ControlledOperation,
'CrossEntropyResult': CrossEntropyResult,
'CrossEntropyResultDict': CrossEntropyResultDict,
'CSwapGate': cirq.CSwapGate,
'CXPowGate': cirq.CXPowGate,
'CZPowGate': cirq.CZPowGate,
'DensePauliString': cirq.DensePauliString,
'DepolarizingChannel': cirq.DepolarizingChannel,
'DeviceMetadata': cirq.DeviceMetadata,
'Duration': cirq.Duration,
'FrozenCircuit': cirq.FrozenCircuit,
'FSimGate': cirq.FSimGate,
'GateFamily': cirq.GateFamily,
'GateOperation': cirq.GateOperation,
'Gateset': cirq.Gateset,
'GeneralizedAmplitudeDampingChannel':
cirq.GeneralizedAmplitudeDampingChannel,
'GlobalPhaseGate': cirq.GlobalPhaseGate,
'GlobalPhaseOperation': cirq.GlobalPhaseOperation,
'GridDeviceMetadata': cirq.GridDeviceMetadata,
'GridInteractionLayer': GridInteractionLayer,
'GridParallelXEBMetadata': GridParallelXEBMetadata,
'GridQid': cirq.GridQid,
'GridQubit': cirq.GridQubit,
'HPowGate': cirq.HPowGate,
'ISwapPowGate': cirq.ISwapPowGate,
'IdentityGate': cirq.IdentityGate,
'InitObsSetting': cirq.work.InitObsSetting,
'KeyCondition': cirq.KeyCondition,
'KrausChannel': cirq.KrausChannel,
'LinearDict': cirq.LinearDict,
'LineQubit': cirq.LineQubit,
'LineQid': cirq.LineQid,
'LineTopology': cirq.LineTopology,
'MatrixGate': cirq.MatrixGate,
'MixedUnitaryChannel': cirq.MixedUnitaryChannel,
'MeasurementKey': cirq.MeasurementKey,
'MeasurementGate': cirq.MeasurementGate,
'_MeasurementSpec': cirq.work._MeasurementSpec,
'Moment': cirq.Moment,
'MutableDensePauliString': cirq.MutableDensePauliString,
'MutablePauliString': cirq.MutablePauliString,
'_NoNoiseModel': _NoNoiseModel,
'NamedQubit': cirq.NamedQubit,
'NamedQid': cirq.NamedQid,
'NoIdentifierQubit': cirq.testing.NoIdentifierQubit,
'ObservableMeasuredResult': cirq.work.ObservableMeasuredResult,
'OpIdentifier': cirq.OpIdentifier,
'ParamResolver': cirq.ParamResolver,
'ParallelGate': cirq.ParallelGate,
'ParallelGateFamily': cirq.ParallelGateFamily,
'PauliMeasurementGate': cirq.PauliMeasurementGate,
'PauliString': cirq.PauliString,
'PauliStringPhasor': cirq.PauliStringPhasor,
'PauliStringPhasorGate': cirq.PauliStringPhasorGate,
'_PauliX': cirq.ops.pauli_gates._PauliX,
'_PauliY': cirq.ops.pauli_gates._PauliY,
'_PauliZ': cirq.ops.pauli_gates._PauliZ,
'PhaseDampingChannel': cirq.PhaseDampingChannel,
'PhaseFlipChannel': cirq.PhaseFlipChannel,
'PhaseGradientGate': cirq.PhaseGradientGate,
'PhasedFSimGate': cirq.PhasedFSimGate,
'PhasedISwapPowGate': cirq.PhasedISwapPowGate,
'PhasedXPowGate': cirq.PhasedXPowGate,
'PhasedXZGate': cirq.PhasedXZGate,
'ProductState': cirq.ProductState,
'ProjectorString': cirq.ProjectorString,
'ProjectorSum': cirq.ProjectorSum,
'QasmUGate': cirq.circuits.qasm_output.QasmUGate,
'_QubitAsQid': raw_types._QubitAsQid,
'QuantumFourierTransformGate': cirq.QuantumFourierTransformGate,
'RandomGateChannel': cirq.RandomGateChannel,
'RepetitionsStoppingCriteria': cirq.work.RepetitionsStoppingCriteria,
'ResetChannel': cirq.ResetChannel,
'Result': cirq.Result,
'Rx': cirq.Rx,
'Ry': cirq.Ry,
'Rz': cirq.Rz,
'SingleQubitCliffordGate': cirq.SingleQubitCliffordGate,
'SingleQubitPauliStringGateOperation':
cirq.SingleQubitPauliStringGateOperation,
'SingleQubitReadoutCalibrationResult':
cirq.experiments.SingleQubitReadoutCalibrationResult,
'StabilizerStateChForm': cirq.StabilizerStateChForm,
'StatePreparationChannel': cirq.StatePreparationChannel,
'SwapPowGate': cirq.SwapPowGate,
'SymmetricalQidPair': cirq.SymmetricalQidPair,
'SympyCondition': cirq.SympyCondition,
'TaggedOperation': cirq.TaggedOperation,
'TiltedSquareLattice': cirq.TiltedSquareLattice,
'TrialResult': cirq.Result, # keep support for Cirq < 0.11.
'TwoQubitGateTabulation': cirq.TwoQubitGateTabulation,
'_UnconstrainedDevice':
cirq.devices.unconstrained_device._UnconstrainedDevice,
'VarianceStoppingCriteria': cirq.work.VarianceStoppingCriteria,
'VirtualTag': cirq.VirtualTag,
'WaitGate': cirq.WaitGate,
# The formatter keeps putting this back
# pylint: disable=line-too-long
'XEBPhasedFSimCharacterizationOptions':
cirq.experiments.XEBPhasedFSimCharacterizationOptions,
# pylint: enable=line-too-long
'_XEigenState': cirq.value.product_state._XEigenState, # type: ignore
'XPowGate': cirq.XPowGate,
'XXPowGate': cirq.XXPowGate,
'_YEigenState': cirq.value.product_state._YEigenState, # type: ignore
'YPowGate': cirq.YPowGate,
'YYPowGate': cirq.YYPowGate,
'_ZEigenState': cirq.value.product_state._ZEigenState, # type: ignore
'ZPowGate': cirq.ZPowGate,
'ZZPowGate': cirq.ZZPowGate,
# Old types, only supported for backwards-compatibility
'IdentityOperation': _identity_operation_from_dict,
'ParallelGateOperation': _parallel_gate_op, # Removed in v0.14
'SingleQubitMatrixGate': single_qubit_matrix_gate,
'TwoQubitMatrixGate': two_qubit_matrix_gate,
# not a cirq class, but treated as one:
'pandas.DataFrame': pd.DataFrame,
'pandas.Index': pd.Index,
'pandas.MultiIndex': pd.MultiIndex.from_tuples,
'sympy.Symbol': sympy.Symbol,
'sympy.Add': lambda args: sympy.Add(*args),
'sympy.Mul': lambda args: sympy.Mul(*args),
'sympy.Pow': lambda args: sympy.Pow(*args),
'sympy.GreaterThan': lambda args: sympy.GreaterThan(*args),
'sympy.StrictGreaterThan': lambda args: sympy.StrictGreaterThan(*args),
'sympy.LessThan': lambda args: sympy.LessThan(*args),
'sympy.StrictLessThan': lambda args: sympy.StrictLessThan(*args),
'sympy.Equality': lambda args: sympy.Equality(*args),
'sympy.Unequality': lambda args: sympy.Unequality(*args),
'sympy.Float': lambda approx: sympy.Float(approx),
'sympy.Integer': sympy.Integer,
'sympy.Rational': sympy.Rational,
'sympy.pi': lambda: sympy.pi,
'sympy.E': lambda: sympy.E,
'sympy.EulerGamma': lambda: sympy.EulerGamma,
'complex': complex,
}