cirq-core 1.3.0.dev20231201141002__py3-none-any.whl → 1.4.0__py3-none-any.whl

cirq/__init__.py

@@ -240,6 +240,7 @@ from cirq.ops import (
     MatrixGate,
     MixedUnitaryChannel,
     M,
+    MSGate,
     measure,
     measure_each,
     measure_paulistring_terms,
@@ -331,10 +332,12 @@ from cirq.ops import (
     ZPowGate,
     ZZ,
     ZZPowGate,
+    UniformSuperpositionGate,
 )
 
 from cirq.transformers import (
     AbstractInitialMapper,
+    add_dynamical_decoupling,
     align_left,
     align_right,
     CompilationTargetGateset,
@@ -508,6 +511,7 @@ from cirq.study import (
     to_sweeps,
     Result,
     UnitSweep,
+    UNIT_SWEEP,
     Zip,
     ZipLongest,
 )

cirq/_compat.py

@@ -61,23 +61,19 @@ def with_debug(value: bool) -> Iterator[None]:
         __cirq_debug__.reset(token)
 
 
-try:
-    from functools import cached_property  # pylint: disable=unused-import
-except ImportError:
-    from backports.cached_property import cached_property  # type: ignore[no-redef]
+# Sentinel used by wrapped_no_args below when method has not yet been cached.
+_NOT_FOUND = object()
 
 
 TFunc = TypeVar('TFunc', bound=Callable)
 
 
 @overload
-def cached_method(__func: TFunc) -> TFunc:
-    ...
+def cached_method(__func: TFunc) -> TFunc: ...
 
 
 @overload
-def cached_method(*, maxsize: int = 128) -> Callable[[TFunc], TFunc]:
-    ...
+def cached_method(*, maxsize: int = 128) -> Callable[[TFunc], TFunc]: ...
 
 
 def cached_method(method: Optional[TFunc] = None, *, maxsize: int = 128) -> Any:
@@ -103,9 +99,11 @@ def cached_method(method: Optional[TFunc] = None, *, maxsize: int = 128) -> Any:
 
             @functools.wraps(func)
             def wrapped_no_args(self):
-                if not hasattr(self, cache_name):
-                    object.__setattr__(self, cache_name, func(self))
-                return getattr(self, cache_name)
+                result = getattr(self, cache_name, _NOT_FOUND)
+                if result is _NOT_FOUND:
+                    result = func(self)
+                    object.__setattr__(self, cache_name, result)
+                return result
 
             return wrapped_no_args
 

cirq/_compat_test.py

@@ -38,7 +38,6 @@ import cirq.testing
 from cirq._compat import (
     block_overlapping_deprecation,
     cached_method,
-    cached_property,
     proper_repr,
     dataclass_repr,
     deprecated,
@@ -346,7 +345,7 @@ def test_wrap_module():
 
 
 def test_deprecate_attributes_assert_attributes_in_sys_modules():
-    subprocess_context(_test_deprecate_attributes_assert_attributes_in_sys_modules)()
+    run_in_subprocess(_test_deprecate_attributes_assert_attributes_in_sys_modules)
 
 
 def _test_deprecate_attributes_assert_attributes_in_sys_modules():
@@ -635,42 +634,49 @@ _repeated_child_deprecation_msg = [
 ] + _deprecation_origin
 
 
-def _trace_unhandled_exceptions(*args, queue: 'multiprocessing.Queue', func: Callable, **kwargs):
+def _trace_unhandled_exceptions(*args, queue: 'multiprocessing.Queue', func: Callable):
     try:
-        func(*args, **kwargs)
+        func(*args)
         queue.put(None)
     except BaseException as ex:
         msg = str(ex)
         queue.put((type(ex).__name__, msg, traceback.format_exc()))
 
 
-def subprocess_context(test_func):
-    """Ensures that sys.modules changes in subprocesses won't impact the parent process."""
+def run_in_subprocess(test_func, *args):
+    """Run a function in a subprocess.
+
+    This ensures that sys.modules changes in subprocesses won't impact the parent process.
+
+    Args:
+        test_func: The function to be run in a subprocess.
+        *args: Positional args to pass to the function.
+    """
+
     assert callable(test_func), (
-        "subprocess_context expects a function. Did you call the function instead of passing "
+        "run_in_subprocess expects a function. Did you call the function instead of passing "
         "it to this method?"
     )
 
-    ctx = multiprocessing.get_context('spawn' if os.name == 'nt' else 'fork')
-
-    exception = ctx.Queue()
+    # Use spawn to ensure subprocesses are isolated.
+    # See https://github.com/quantumlib/Cirq/issues/6373
+    ctx = multiprocessing.get_context('spawn')
 
-    def isolated_func(*args, **kwargs):
-        kwargs['queue'] = exception
-        kwargs['func'] = test_func
-        p = ctx.Process(target=_trace_unhandled_exceptions, args=args, kwargs=kwargs)
-        p.start()
-        p.join()
-        result = exception.get()
-        if result:  # pragma: no cover
-            ex_type, msg, ex_trace = result
-            if ex_type == "Skipped":
-                warnings.warn(f"Skipping: {ex_type}: {msg}\n{ex_trace}")
-                pytest.skip(f'{ex_type}: {msg}\n{ex_trace}')
-            else:
-                pytest.fail(f'{ex_type}: {msg}\n{ex_trace}')
+    queue = ctx.Queue()
 
-    return isolated_func
+    p = ctx.Process(
+        target=_trace_unhandled_exceptions, args=args, kwargs={'queue': queue, 'func': test_func}
+    )
+    p.start()
+    p.join()
+    result = queue.get()
+    if result:  # pragma: no cover
+        ex_type, msg, ex_trace = result
+        if ex_type == "Skipped":
+            warnings.warn(f"Skipping: {ex_type}: {msg}\n{ex_trace}")
+            pytest.skip(f'{ex_type}: {msg}\n{ex_trace}')
+        else:
+            pytest.fail(f'{ex_type}: {msg}\n{ex_trace}')
 
 
 @mock.patch.dict(os.environ, {"CIRQ_FORCE_DEDUPE_MODULE_DEPRECATION": "1"})
@@ -698,7 +704,7 @@ def subprocess_context(test_func):
     ],
 )
 def test_deprecated_module(outdated_method, deprecation_messages):
-    subprocess_context(_test_deprecated_module_inner)(outdated_method, deprecation_messages)
+    run_in_subprocess(_test_deprecated_module_inner, outdated_method, deprecation_messages)
 
 
 def _test_deprecated_module_inner(outdated_method, deprecation_messages):
@@ -736,7 +742,7 @@ def test_same_name_submodule_earlier_in_subtree():
     cirq.ops.engine.calibration packages. The wrong resolution resulted in false circular
     imports!
     """
-    subprocess_context(_test_same_name_submodule_earlier_in_subtree_inner)()
+    run_in_subprocess(_test_same_name_submodule_earlier_in_subtree_inner)
 
 
 def _test_same_name_submodule_earlier_in_subtree_inner():
@@ -748,7 +754,7 @@ def _test_same_name_submodule_earlier_in_subtree_inner():
 def test_metadata_search_path():
     # to cater for metadata path finders
     # https://docs.python.org/3/library/importlib.metadata.html#extending-the-search-algorithm
-    subprocess_context(_test_metadata_search_path_inner)()
+    run_in_subprocess(_test_metadata_search_path_inner)
 
 
 def _test_metadata_search_path_inner():  # pragma: no cover
@@ -760,7 +766,7 @@ def _test_metadata_search_path_inner():  # pragma: no cover
 
 
 def test_metadata_distributions_after_deprecated_submodule():
-    subprocess_context(_test_metadata_distributions_after_deprecated_submodule)()
+    run_in_subprocess(_test_metadata_distributions_after_deprecated_submodule)
 
 
 def _test_metadata_distributions_after_deprecated_submodule():
@@ -779,7 +785,7 @@ def _test_metadata_distributions_after_deprecated_submodule():
 
 
 def test_parent_spec_after_deprecated_submodule():
-    subprocess_context(_test_parent_spec_after_deprecated_submodule)()
+    run_in_subprocess(_test_parent_spec_after_deprecated_submodule)
 
 
 def _test_parent_spec_after_deprecated_submodule():
@@ -791,7 +797,7 @@ def _test_parent_spec_after_deprecated_submodule():
 def test_type_repr_in_new_module():
     # to cater for metadata path finders
     # https://docs.python.org/3/library/importlib.metadata.html#extending-the-search-algorithm
-    subprocess_context(_test_type_repr_in_new_module_inner)()
+    run_in_subprocess(_test_type_repr_in_new_module_inner)
 
 
 def _test_type_repr_in_new_module_inner():
@@ -849,19 +855,19 @@ def _test_broken_module_3_inner():
 
 
 def test_deprecated_module_error_handling_1():
-    subprocess_context(_test_broken_module_1_inner)()
+    run_in_subprocess(_test_broken_module_1_inner)
 
 
 def test_deprecated_module_error_handling_2():
-    subprocess_context(_test_broken_module_2_inner)()
+    run_in_subprocess(_test_broken_module_2_inner)
 
 
 def test_deprecated_module_error_handling_3():
-    subprocess_context(_test_broken_module_3_inner)()
+    run_in_subprocess(_test_broken_module_3_inner)
 
 
 def test_new_module_is_top_level():
-    subprocess_context(_test_new_module_is_top_level_inner)()
+    run_in_subprocess(_test_new_module_is_top_level_inner)
 
 
 def _test_new_module_is_top_level_inner():
@@ -877,7 +883,7 @@ def _test_new_module_is_top_level_inner():
 
 
 def test_import_deprecated_with_no_attribute():
-    subprocess_context(_test_import_deprecated_with_no_attribute_inner)()
+    run_in_subprocess(_test_import_deprecated_with_no_attribute_inner)
 
 
 def _test_import_deprecated_with_no_attribute_inner():
@@ -970,7 +976,7 @@ def test_deprecated_module_loader_repr():
 
 def test_subprocess_test_failure():
     with pytest.raises(Failed, match='ValueError.*this fails'):
-        subprocess_context(_test_subprocess_test_failure_inner)()
+        run_in_subprocess(_test_subprocess_test_failure_inner)
 
 
 def _test_subprocess_test_failure_inner():
@@ -978,7 +984,7 @@ def _test_subprocess_test_failure_inner():
 
 
 def test_dir_is_still_valid():
-    subprocess_context(_dir_is_still_valid_inner)()
+    run_in_subprocess(_dir_is_still_valid_inner)
 
 
 def _dir_is_still_valid_inner():
@@ -986,7 +992,7 @@ def _dir_is_still_valid_inner():
 
     import cirq.testing._compat_test_data as mod
 
-    for m in ['fake_a', 'info', 'module_a', 'sys']:
+    for m in ['fake_a', 'logging', 'module_a']:
         assert m in dir(mod)
 
 
@@ -1004,23 +1010,6 @@ def test_block_overlapping_deprecation():
         f(5)
 
 
-def test_cached_property():
-    class Foo:
-        def __init__(self):
-            self.bar_calls = 0
-
-        @cached_property
-        def bar(self):
-            self.bar_calls += 1
-            return []
-
-    foo = Foo()
-    bar = foo.bar
-    bar2 = foo.bar
-    assert bar2 is bar
-    assert foo.bar_calls == 1
-
-
 class Bar:
     def __init__(self) -> None:
         self.foo_calls: Dict[int, int] = collections.Counter()

cirq/_version.py

@@ -1 +1,31 @@
-__version__ = "1.3.0.dev20231201141002"
+# Copyright 2018 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Define version number here, read it from setup.py automatically,
+and warn users that the latest version of cirq uses python 3.10+"""
+
+import sys
+
+if sys.version_info < (3, 10, 0):  # pragma: no cover
+    raise SystemError(
+        "You installed the latest version of cirq but aren't on python 3.10+.\n"
+        'To fix this error, you need to either:\n'
+        '\n'
+        'A) Update to python 3.10 or later.\n'
+        '- OR -\n'
+        'B) Explicitly install an older deprecated-but-compatible version '
+        'of cirq (e.g. "python -m pip install cirq==1.1.*")'
+    )
+
+__version__ = "1.4.0"

cirq/_version_test.py

@@ -3,4 +3,4 @@ import cirq
 
 
 def test_version():
-    assert cirq.__version__ == "1.3.0.dev"
+    assert cirq.__version__ == "1.4.0"

cirq/circuits/circuit.py

@@ -29,14 +29,14 @@ from typing import (
     AbstractSet,
     Any,
     Callable,
-    Mapping,
-    MutableSequence,
     cast,
     Dict,
     FrozenSet,
     Iterable,
     Iterator,
     List,
+    Mapping,
+    MutableSequence,
     Optional,
     overload,
     Sequence,
@@ -58,9 +58,9 @@ from cirq._doc import document
 from cirq.circuits._bucket_priority_queue import BucketPriorityQueue
 from cirq.circuits.circuit_operation import CircuitOperation
 from cirq.circuits.insert_strategy import InsertStrategy
+from cirq.circuits.moment import Moment
 from cirq.circuits.qasm_output import QasmOutput
 from cirq.circuits.text_diagram_drawer import TextDiagramDrawer
-from cirq.circuits.moment import Moment
 from cirq.protocols import circuit_diagram_info_protocol
 from cirq.type_workarounds import NotImplementedType
 
@@ -203,19 +203,24 @@ class AbstractCircuit(abc.ABC):
             copy: If True and 'self' is a Circuit, returns a copy that circuit.
         """
 
-    def __bool__(self):
+    def __bool__(self) -> bool:
         return bool(self.moments)
 
-    def __eq__(self, other):
+    def __eq__(self, other) -> bool:
         if not isinstance(other, AbstractCircuit):
             return NotImplemented
-        return tuple(self.moments) == tuple(other.moments)
+        return other is self or (
+            len(self.moments) == len(other.moments)
+            and all(m0 == m1 for m0, m1 in zip(self.moments, other.moments))
+        )
 
     def _approx_eq_(self, other: Any, atol: Union[int, float]) -> bool:
         """See `cirq.protocols.SupportsApproximateEquality`."""
         if not isinstance(other, AbstractCircuit):
             return NotImplemented
-        return cirq.protocols.approx_eq(tuple(self.moments), tuple(other.moments), atol=atol)
+        return other is self or cirq.protocols.approx_eq(
+            tuple(self.moments), tuple(other.moments), atol=atol
+        )
 
     def __ne__(self, other) -> bool:
         return not self == other
@@ -2625,7 +2630,7 @@ def _draw_moment_in_diagram(
         if desc:
             y = max(label_map.values(), default=0) + 1
             if tags and include_tags:
-                desc = desc + str(tags)
+                desc = desc + f"[{', '.join(map(str, tags))}]"
             out_diagram.write(x0, y, desc)
 
     if not non_global_ops:

cirq/circuits/circuit_operation.py

@@ -19,6 +19,7 @@ applied as part of a larger circuit, a CircuitOperation will execute all
 component operations in order, including any nested CircuitOperations.
 """
 import math
+from functools import cached_property
 from typing import (
     Callable,
     cast,
@@ -38,7 +39,7 @@ import numpy as np
 import sympy
 
 from cirq import circuits, ops, protocols, value, study
-from cirq._compat import cached_property, proper_repr
+from cirq._compat import proper_repr
 
 if TYPE_CHECKING:
     import cirq

cirq/circuits/circuit_test.py

@@ -2305,9 +2305,9 @@ global phase:   0.5π   0.5π
     cirq.testing.assert_has_diagram(
         c,
         """\
-2: ───X──────────
+2: ───X────────
 
-      π['tag']""",
+      π[tag]""",
     )
 
 

cirq/circuits/frozen_circuit.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """An immutable version of the Circuit data structure."""
+from functools import cached_property
 from typing import (
     AbstractSet,
     FrozenSet,
@@ -90,7 +91,7 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
         """Returns a tuple of the Circuit's tags."""
         return self._tags
 
-    @_compat.cached_property
+    @cached_property
     def untagged(self) -> 'cirq.FrozenCircuit':
         """Returns the underlying FrozenCircuit without any tags."""
         return self._from_moments(self._moments) if self.tags else self
@@ -148,7 +149,7 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
     def all_qubits(self) -> FrozenSet['cirq.Qid']:
         return super().all_qubits()
 
-    @_compat.cached_property
+    @cached_property
     def _all_operations(self) -> Tuple['cirq.Operation', ...]:
         return tuple(super().all_operations())
 

cirq/circuits/moment.py

@@ -283,9 +283,11 @@ class Moment:
 
     def _with_measurement_key_mapping_(self, key_map: Mapping[str, str]):
         return Moment(
-            protocols.with_measurement_key_mapping(op, key_map)
-            if protocols.measurement_keys_touched(op)
-            else op
+            (
+                protocols.with_measurement_key_mapping(op, key_map)
+                if protocols.measurement_keys_touched(op)
+                else op
+            )
             for op in self.operations
         )
 
@@ -320,9 +322,11 @@ class Moment:
 
     def _with_key_path_prefix_(self, prefix: Tuple[str, ...]):
         return Moment(
-            protocols.with_key_path_prefix(op, prefix)
-            if protocols.measurement_keys_touched(op)
-            else op
+            (
+                protocols.with_key_path_prefix(op, prefix)
+                if protocols.measurement_keys_touched(op)
+                else op
+            )
             for op in self.operations
         )
 
@@ -343,14 +347,14 @@ class Moment:
         if not isinstance(other, type(self)):
             return NotImplemented
 
-        return self._sorted_operations_() == other._sorted_operations_()
+        return self is other or self._sorted_operations_() == other._sorted_operations_()
 
     def _approx_eq_(self, other: Any, atol: Union[int, float]) -> bool:
         """See `cirq.protocols.SupportsApproximateEquality`."""
         if not isinstance(other, type(self)):
             return NotImplemented
 
-        return protocols.approx_eq(
+        return self is other or protocols.approx_eq(
             self._sorted_operations_(), other._sorted_operations_(), atol=atol
         )
 
@@ -510,13 +514,11 @@ class Moment:
         return cls.from_ops(*operations)
 
     def __add__(self, other: 'cirq.OP_TREE') -> 'cirq.Moment':
-
         if isinstance(other, circuits.AbstractCircuit):
             return NotImplemented  # Delegate to Circuit.__radd__.
         return self.with_operations(other)
 
     def __sub__(self, other: 'cirq.OP_TREE') -> 'cirq.Moment':
-
         must_remove = set(op_tree.flatten_to_ops(other))
         new_ops = []
         for op in self.operations:

cirq/circuits/qasm_output.py

@@ -293,7 +293,11 @@ class QasmOutput:
                 output(f'creg {meas_id}[{len(meas.qubits)}];\n')
             else:
                 output(f'creg {meas_id}[{len(meas.qubits)}];  // Measurement: {comment}\n')
-        output_line_gap(2)
+        # In OpenQASM 2.0, the transformation of global phase gates is ignored.
+        # Therefore, no newline is created when the operations contained in
+        # a circuit consist only of global phase gates.
+        if any(not isinstance(op.gate, ops.GlobalPhaseGate) for op in self.operations):
+            output_line_gap(2)
 
         # Operations
         self._write_operations(self.operations, output, output_line_gap)

cirq/circuits/qasm_output_test.py

@@ -191,6 +191,19 @@ ry(pi*-0.25) q[0];
     )
 
 
+def test_qasm_global_pahse():
+    output = cirq.QasmOutput((cirq.global_phase_operation(np.exp(1j * 5))), ())
+    assert (
+        str(output)
+        == """OPENQASM 2.0;
+include "qelib1.inc";
+
+
+// Qubits: []
+"""
+    )
+
+
 def test_precision():
     (q0,) = _make_qubits(1)
     output = cirq.QasmOutput((cirq.X(q0) ** 0.1234567,), (q0,), precision=3)
@@ -318,16 +331,18 @@ def _all_operations(q0, q1, q2, q3, q4, include_measurements=True):
         cirq.PhasedXPowGate(phase_exponent=0.333, exponent=0.5).on(q1),
         cirq.PhasedXPowGate(phase_exponent=0.777, exponent=-0.5).on(q1),
         (
-            cirq.measure(q0, key='xX'),
-            cirq.measure(q2, key='x_a'),
-            cirq.measure(q1, key='x?'),
-            cirq.measure(q3, key='X'),
-            cirq.measure(q4, key='_x'),
-            cirq.measure(q2, key='x_a'),
-            cirq.measure(q1, q2, q3, key='multi', invert_mask=(False, True)),
-        )
-        if include_measurements
-        else (),
+            (
+                cirq.measure(q0, key='xX'),
+                cirq.measure(q2, key='x_a'),
+                cirq.measure(q1, key='x?'),
+                cirq.measure(q3, key='X'),
+                cirq.measure(q4, key='_x'),
+                cirq.measure(q2, key='x_a'),
+                cirq.measure(q1, q2, q3, key='multi', invert_mask=(False, True)),
+            )
+            if include_measurements
+            else ()
+        ),
         ExampleOperation(),
         ExampleCompositeOperation(),
     )

cirq/contrib/qcircuit/qcircuit_diagram_info.py

@@ -51,13 +51,15 @@ def hardcoded_qcircuit_diagram_info(op: ops.Operation) -> Optional[protocols.Cir
     symbols = (
         (r'\targ',)
         if op.gate == ops.X
-        else (r'\control', r'\control')
-        if op.gate == ops.CZ
-        else (r'\control', r'\targ')
-        if op.gate == ops.CNOT
-        else (r'\meter',)
-        if isinstance(op.gate, ops.MeasurementGate)
-        else ()
+        else (
+            (r'\control', r'\control')
+            if op.gate == ops.CZ
+            else (
+                (r'\control', r'\targ')
+                if op.gate == ops.CNOT
+                else (r'\meter',) if isinstance(op.gate, ops.MeasurementGate) else ()
+            )
+        )
     )
     return protocols.CircuitDiagramInfo(symbols) if symbols else None
 

cirq/contrib/quimb/mps_simulator_test.py

@@ -335,7 +335,7 @@ def test_random_circuits_equal_more_rows():
     assert_same_output_as_dense(circuit, qubits)
 
 
-def test_supremacy_equal_more_cols():
+def test_random_circuits_equal_more_cols():
     circuit = cirq.testing.random_circuit(
         qubits=cirq.GridQubit.rect(2, 3), n_moments=6, op_density=1.0
     )

cirq/contrib/quimb/state_vector.py

@@ -170,8 +170,15 @@ def tensor_expectation_value(
         )
     else:
         tn.rank_simplify(inplace=True)
-    path_info = tn.contract(get='path-info')
-    ram_gb = path_info.largest_intermediate * 128 / 8 / 1024 / 1024 / 1024
+    # TODO(#6586): revert when our minimum quimb version has bugfix for quimb#231
+    # Skip path-info evaluation when TensorNetwork consists of scalar Tensors.
+    # Avoid bug in quimb-1.8.0.
+    # Ref: https://github.com/jcmgray/quimb/issues/231
+    if tn.ind_map:
+        path_info = tn.contract(get='path-info')
+        ram_gb = path_info.largest_intermediate * 128 / 8 / 1024 / 1024 / 1024
+    else:
+        ram_gb = 0
     if ram_gb > max_ram_gb:
         raise MemoryError(f"We estimate that this contraction will take too much RAM! {ram_gb} GB")
     e_val = tn.contract(inplace=True)

cirq/contrib/svg/svg.py

@@ -9,7 +9,7 @@ if TYPE_CHECKING:
     import cirq
 
 QBLUE = '#1967d2'
-FONT = matplotlib.font_manager.FontProperties(family="Arial")
+FONT = matplotlib.font_manager.FontProperties()
 EMPTY_MOMENT_COLWIDTH = float(21)  # assumed default column width
 
 
@@ -21,6 +21,7 @@ def fixup_text(text: str):
     # https://github.com/quantumlib/Cirq/issues/2905
     text = text.replace('[<virtual>]', '')
     text = text.replace('[cirq.VirtualTag()]', '')
+    text = text.replace('&', '&amp;')
     text = text.replace('<', '&lt;').replace('>', '&gt;')
     return text
 

cirq/contrib/svg/svg_test.py

@@ -65,6 +65,7 @@ def test_empty_moments():
     'symbol,svg_symbol',
     [
         ('<a', '&lt;a'),
+        ('<a&', '&lt;a&amp;'),
         ('<=b', '&lt;=b'),
         ('>c', '&gt;c'),
         ('>=d', '&gt;=d'),