def test_add_cast_include_subtypes():
e = extension.Extensions()
e.add_cast(desired_type=Cousin,
actual_type=Child,
conversion=lambda _: 'boo',
also_add_inherited_conversions=True)
e2 = extension.Extensions()
e2.add_cast(desired_type=Cousin,
actual_type=Child,
conversion=lambda _: 'boo',
also_add_inherited_conversions=False)
c = Child()
assert e.try_cast(Child, c) is c
assert e.try_cast(Parent, c) is c
assert e.try_cast(Grandparent, c) is c
assert e.try_cast(object, c) is c
assert e.try_cast(Aunt, c) == 'boo'
assert e.try_cast(Cousin, c) == 'boo'
assert e2.try_cast(Child, c) is c
assert e2.try_cast(Parent, c) is c
assert e2.try_cast(Grandparent, c) is c
assert e2.try_cast(object, c) is c
assert e2.try_cast(Aunt, c) is None
assert e2.try_cast(Cousin, c) == 'boo'
def test_add_cast_redundant_including_subtypes():
o1 = Cousin()
o2 = Cousin()
o3 = Cousin()
e = extension.Extensions()
e.add_cast(desired_type=Aunt,
actual_type=Child,
conversion=lambda _: o1,
also_add_inherited_conversions=True,
overwrite_existing=False)
with pytest.raises(ValueError):
e.add_cast(desired_type=Cousin,
actual_type=Child,
conversion=lambda _: o2,
also_add_inherited_conversions=True,
overwrite_existing=False)
assert e.try_cast(Aunt, Child()) is o1
assert e.try_cast(Cousin, Child()) is None
e.add_cast(desired_type=Cousin,
actual_type=Child,
conversion=lambda _: o3,
also_add_inherited_conversions=True,
overwrite_existing=True)
assert e.try_cast(Aunt, Child()) is o3
assert e.try_cast(Cousin, Child()) is o3
def test_wrap():
e = extension.Extensions({DesiredType: {OtherType: WrapType}})
o = OtherType()
w = e.cast(DesiredType, o)
assert w.make() == 'wrap'
assert isinstance(w, WrapType)
assert w.other is o
def circuit_to_latex_using_qcircuit(
circuit: circuits.Circuit,
ext: extension.Extensions = None,
qubit_order: ops.QubitOrderOrList = ops.QubitOrder.DEFAULT) -> str:
"""Returns a QCircuit-based latex diagram of the given circuit.
Args:
circuit: The circuit to represent in latex.
ext: Extensions used when attempting to cast gates into
QCircuitDiagrammableGate instances (before falling back to the
default wrapping methods).
qubit_order: Determines the order of qubit wires in the diagram.
Returns:
Latex code for the diagram.
"""
if ext is None:
ext = extension.Extensions()
qcircuit = _wrap_circuit(circuit, ext)
# Note: can't be a lambda because we need the type hint.
def get_sub(q: _QCircuitQubit) -> ops.QubitId:
return q.sub
diagram = qcircuit.to_text_diagram_drawer(
ext,
qubit_name_suffix='',
qubit_order=ops.QubitOrder.as_qubit_order(qubit_order).map(
internalize=get_sub, externalize=_QCircuitQubit))
return _render(diagram)
def test_add_cast():
e = extension.Extensions()
d = DesiredType()
assert e.try_cast(DesiredType, UnrelatedType()) is None
e.add_cast(desired_type=DesiredType,
actual_type=UnrelatedType,
conversion=lambda _: d)
assert e.try_cast(DesiredType, UnrelatedType()) is d
def test_override_order():
e = extension.Extensions({
DesiredType: {
object: lambda _, _2: 'obj',
UnrelatedType: lambda _, _2: 'unrelated',
}
})
assert e.cast(DesiredType, '') == 'obj'
assert e.cast(DesiredType, None) == 'obj'
assert e.cast(DesiredType, UnrelatedType()) == 'unrelated'
assert e.cast(DesiredType, ChildType()) == 'obj'
def test_override_order():
e = extension.Extensions({
DesiredType: {
object: lambda _: 'obj',
UnrelatedType: lambda _: 'unrelated',
}
})
assert e.cast('', DesiredType) == 'obj'
assert e.cast(None, DesiredType) == 'obj'
assert e.cast(UnrelatedType(), DesiredType) == 'unrelated'
assert e.cast(ChildType(), DesiredType) == 'obj'
def test_add_potential_cast():
a = Aunt()
c1 = Child()
c2 = Child()
e = extension.Extensions()
e.add_cast(desired_type=Aunt,
actual_type=Child,
conversion=lambda e: a if e is c1 else None)
assert e.try_cast(Aunt, c1) is a
assert e.try_cast(Aunt, c2) is None
def test_add_recursive_cast():
cousin = Cousin()
child = Child()
e = extension.Extensions()
e.add_cast(desired_type=Cousin,
actual_type=Child,
conversion=lambda _: cousin)
e.add_recursive_cast(desired_type=Cousin,
actual_type=Grandparent,
conversion=lambda ext, _: ext.try_cast(Cousin, child))
assert e.try_cast(Cousin, Grandparent()) is cousin
def __init__(self,
tolerance: float = 0.0,
ext: extension.Extensions=None) -> None:
"""
Args:
tolerance: Maximum absolute error tolerance. The optimization is
permitted to simply drop negligible combinations of Z gates,
with a threshold determined by this tolerance.
ext: Extensions object used for determining if gates are phaseable
(i.e. if Z gates can pass through them).
"""
self.tolerance = tolerance
self.ext = ext or extension.Extensions()
def __init__(self,
composite_gate_extension: extension.Extensions = None,
no_decomp: Callable[[ops.Operation], bool]=(lambda _: False)
) -> None:
"""Construct the optimization pass.
Args:
composite_gate_extension: An extension that that can be used
to supply or override a CompositeOperation decomposition.
no_decomp: A predicate that determines whether an operation should
be decomposed or not. Defaults to decomposing everything.
"""
self.extension = composite_gate_extension or extension.Extensions()
self.no_decomp = no_decomp
def __init__(self,
extensions: extension.Extensions = None,
ignore_failures: bool = False,
allow_partial_czs: bool = False) -> None:
"""
Args:
extensions: The extensions instance to use when trying to
cast gates to known types.
ignore_failures: If set, gates that fail to convert are forwarded
unchanged. If not set, conversion failures raise a TypeError.
"""
self.extensions = extensions or extension.Extensions()
self.ignore_failures = ignore_failures
self.allow_partial_czs = allow_partial_czs
def test_try_cast_hit_vs_miss():
e = extension.Extensions({DesiredType: {OtherType: WrapType}})
o = OtherType()
c = ChildType()
u = UnrelatedType()
assert e.try_cast(DesiredType, None) is None
assert e.try_cast(DesiredType, u) is None
assert e.try_cast(DesiredType, c) is c
assert e.try_cast(DesiredType, o) is not o
assert e.try_cast(UnrelatedType, None) is None
assert e.try_cast(UnrelatedType, u) is u
assert e.try_cast(UnrelatedType, c) is None
assert e.try_cast(UnrelatedType, o) is None
def test_try_cast_hit_vs_miss():
e = extension.Extensions({DesiredType: {OtherType: WrapType}})
o = OtherType()
c = ChildType()
u = UnrelatedType()
assert e.try_cast(None, DesiredType) is None
assert e.try_cast(u, DesiredType) is None
assert e.try_cast(c, DesiredType) is c
assert e.try_cast(o, DesiredType) is not o
assert e.try_cast(None, UnrelatedType) is None
assert e.try_cast(u, UnrelatedType) is u
assert e.try_cast(c, UnrelatedType) is None
assert e.try_cast(o, UnrelatedType) is None
def test_try_cast_potential_implementation():
class PotentialOther(PotentialImplementation):
def __init__(self, is_other):
self.is_other = is_other
def try_cast_to(self, desired_type, extensions):
if desired_type is OtherType and self.is_other:
return OtherType()
return None
e = extension.Extensions()
o = PotentialOther(is_other=False)
u = PotentialOther(is_other=False)
assert e.try_cast(OtherType, o) is None
assert e.try_cast(OtherType, u) is None
def test_empty():
e = extension.Extensions()
o = OtherType()
c = ChildType()
u = UnrelatedType()
with pytest.raises(TypeError):
_ = e.cast(u, DesiredType)
assert e.cast(c, DesiredType) is c
with pytest.raises(TypeError):
_ = e.cast(o, DesiredType)
assert e.cast(u, UnrelatedType) is u
with pytest.raises(TypeError):
_ = e.cast(c, UnrelatedType)
with pytest.raises(TypeError):
_ = e.cast(o, UnrelatedType)
def test_empty():
e = extension.Extensions()
o = OtherType()
c = ChildType()
u = UnrelatedType()
with pytest.raises(TypeError):
_ = e.cast(DesiredType, u)
assert e.cast(DesiredType, c) is c
with pytest.raises(TypeError):
_ = e.cast(DesiredType, o)
assert e.cast(UnrelatedType, u) is u
with pytest.raises(TypeError):
_ = e.cast(UnrelatedType, c)
with pytest.raises(TypeError):
_ = e.cast(UnrelatedType, o)
def __init__(self,
ignore_failures: bool = False,
tolerance: float = 0,
extensions: extension.Extensions = None) -> None:
"""
Args:
ignore_failures: If set, gates that fail to convert are forwarded
unchanged. If not set, conversion failures raise a TypeError.
tolerance: Maximum absolute error tolerance. The optimization is
permitted to round angles with a threshold determined by this
tolerance.
extensions: The extensions instance to use when trying to
cast gates to known types.
"""
self.extensions = extensions or extension.Extensions()
self.ignore_failures = ignore_failures
self.tolerance = tolerance
def test_cast_hit_vs_miss():
e = extension.Extensions({DesiredType: {OtherType: WrapType}})
o = OtherType()
c = ChildType()
u = UnrelatedType()
with pytest.raises(TypeError):
_ = e.cast(None, DesiredType)
with pytest.raises(TypeError):
_ = e.cast(u, DesiredType)
assert e.cast(c, DesiredType) is c
assert e.cast(o, DesiredType) is not o
with pytest.raises(TypeError):
_ = e.cast(None, UnrelatedType)
assert e.cast(u, UnrelatedType) is u
with pytest.raises(TypeError):
_ = e.cast(c, UnrelatedType)
with pytest.raises(TypeError):
_ = e.cast(o, UnrelatedType)
def test_cast_hit_vs_miss():
e = extension.Extensions({DesiredType: {OtherType: WrapType}})
o = OtherType()
c = ChildType()
u = UnrelatedType()
with pytest.raises(TypeError):
_ = e.cast(DesiredType, None)
with pytest.raises(TypeError):
_ = e.cast(DesiredType, u)
assert e.cast(DesiredType, c) is c
assert e.cast(DesiredType, o) is not o
with pytest.raises(TypeError):
_ = e.cast(UnrelatedType, None)
assert e.cast(UnrelatedType, u) is u
with pytest.raises(TypeError):
_ = e.cast(UnrelatedType, c)
with pytest.raises(TypeError):
_ = e.cast(UnrelatedType, o)
def __init__(self,
ignore_failures: bool = False,
keep_clifford: bool = False,
tolerance: float = 0,
extensions: extension.Extensions = None) -> None:
"""
Args:
ignore_failures: If set, gates that fail to convert are forwarded
unchanged. If not set, conversion failures raise a TypeError.
keep_clifford: If set, single qubit rotations in the Clifford group
are converted to CliffordGates.
tolerance: Maximum absolute error tolerance. The optimization is
permitted to round angles with a threshold determined by this
tolerance.
extensions: The extensions instance to use when trying to
cast gates to known types.
"""
super().__init__()
self.extensions = extensions or extension.Extensions()
self.ignore_failures = ignore_failures
self.keep_clifford = keep_clifford
self.tolerance = tolerance
self._tol = linalg.Tolerance(atol=tolerance)
def test_add_cast_redundant():
o1 = Cousin()
o2 = Cousin()
o3 = Cousin()
e = extension.Extensions()
e.add_cast(desired_type=Cousin,
actual_type=Child,
conversion=lambda _: o1,
also_add_inherited_conversions=False,
overwrite_existing=False)
with pytest.raises(ValueError):
e.add_cast(desired_type=Cousin,
actual_type=Child,
conversion=lambda _: o2,
also_add_inherited_conversions=False,
overwrite_existing=False)
assert e.try_cast(Child(), Cousin) is o1
e.add_cast(desired_type=Cousin,
actual_type=Child,
conversion=lambda _: o3,
also_add_inherited_conversions=False,
overwrite_existing=True)
assert e.try_cast(Child(), Cousin) is o3
def __init__(self,
operations: ops.OP_TREE,
qubits: Tuple[ops.QubitId, ...],
header: str = '',
precision: int = 10,
version: str = '2.0',
ext: extension.Extensions = None) -> None:
self.operations = tuple(ops.flatten_op_tree(operations))
self.qubits = qubits
self.header = header
if ext is None:
ext = extension.Extensions()
self.ext = ext
self.measurements = tuple(
cast(ops.GateOperation, op) for op in self.operations
if ops.MeasurementGate.is_measurement(op))
meas_key_id_map, meas_comments = self._generate_measurement_ids()
self.meas_comments = meas_comments
qubit_id_map = self._generate_qubit_ids()
self.args = ops.QasmOutputArgs(precision=precision,
version=version,
qubit_id_map=qubit_id_map,
meas_key_id_map=meas_key_id_map)
def test_can_cast():
e = extension.Extensions({DesiredType: {OtherType: WrapType}})
c = ChildType()
u = UnrelatedType()
assert not e.can_cast(DesiredType, u)
assert e.can_cast(DesiredType, c)
def __init__(self):
circuits.PointOptimizer.__init__(self)
self.extension = extension.Extensions()
self.no_decomp = lambda op: (not get_acquaintance_size(op) or (
isinstance(op, ops.GateOperation) and isinstance(
op.gate, AcquaintanceOpportunityGate)))
def __init__(self, extensions: extension.Extensions = None) -> None:
super().__init__()
self.extensions = extensions or extension.Extensions()
def _cast_sub_gate(self, desired_type: Type[T_DESIRED]) -> T_DESIRED:
ext = self.default_extensions or extension.Extensions()
cast_sub_gate = ext.try_cast(desired_type, self.sub_gate)
if cast_sub_gate is None:
raise TypeError('sub_gate is not a {}', desired_type)
return cast_sub_gate
def __init__(self,
tolerance: float = 1e-8,
extensions: extension.Extensions = None) -> None:
self.tolerance = tolerance
self.extensions = extensions or extension.Extensions()
