cirq-core 1.2.0.dev20230717225858__py3-none-any.whl → 1.3.0__py3-none-any.whl

cirq/experiments/xeb_fitting.py

@@ -108,12 +108,11 @@ def benchmark_2q_xeb_fidelities(
         def _try_keep(k):
             """If all the values for a key `k` are the same in this group, we can keep it."""
             if k not in df.columns:
-                return  # coverage: ignore
+                return  # pragma: no cover
             vals = df[k].unique()
             if len(vals) == 1:
                 ret[k] = vals[0]
-            else:
-                # coverage: ignore
+            else:  # pragma: no cover
                 raise AssertionError(
                     f"When computing per-cycle-depth fidelity, multiple "
                     f"values for {k} were grouped together: {vals}"
@@ -574,8 +573,7 @@ def _fit_exponential_decay(
             p0=(a_0, layer_fid_0),
             bounds=((0, 0), (1, 1)),
         )
-    except ValueError:  # coverage: ignore
-        # coverage: ignore
+    except ValueError:  # pragma: no cover
         return 0, 0, np.inf, np.inf
 
     a_std, layer_fid_std = np.sqrt(np.diag(pcov))

cirq/experiments/xeb_fitting_test.py

@@ -129,8 +129,8 @@ def test_benchmark_2q_xeb_fidelities_parallel():
 
 def test_benchmark_2q_xeb_fidelities_vectorized():
     rs = np.random.RandomState(52)
-    dummy_records = [{'pure_probs': rs.rand(4), 'sampled_probs': rs.rand(4)} for _ in range(100)]
-    df = pd.DataFrame(dummy_records)
+    mock_records = [{'pure_probs': rs.rand(4), 'sampled_probs': rs.rand(4)} for _ in range(100)]
+    df = pd.DataFrame(mock_records)
 
     # Using `df.apply` is wayyyy slower than the new implementation!
     # but they should give the same results

cirq/experiments/xeb_sampling.py

@@ -130,7 +130,7 @@ def _verify_two_line_qubits_from_circuits(circuits: Sequence['cirq.Circuit']):
 
 
 class _NoProgress:
-    """Dummy (lack of) tqdm-style progress bar."""
+    """Lack of tqdm-style progress bar."""
 
     def __init__(self, total: int):
         pass

cirq/interop/quirk/url_to_circuit.py

@@ -77,39 +77,40 @@ def quirk_url_to_circuit(
             a billion laughs attack in the form of nested custom gates.
 
     Examples:
-        >>> print(cirq.quirk_url_to_circuit(
-        ...     'http://algassert.com/quirk#circuit={"cols":[["H"],["•","X"]]}'
-        ... ))
-        0: ───H───@───
-                  │
-        1: ───────X───
-
-        >>> print(cirq.quirk_url_to_circuit(
-        ...     'http://algassert.com/quirk#circuit={"cols":[["H"],["•","X"]]}',
-        ...     qubits=[cirq.NamedQubit('Alice'), cirq.NamedQubit('Bob')]
-        ... ))
-        Alice: ───H───@───
-                      │
-        Bob: ─────────X───
-
-        >>> print(cirq.quirk_url_to_circuit(
-        ...     'http://algassert.com/quirk#circuit={"cols":[["iswap"]]}',
-        ...     extra_cell_makers={'iswap': cirq.ISWAP}))
-        0: ───iSwap───
-              │
-        1: ───iSwap───
-
-        >>> print(cirq.quirk_url_to_circuit(
-        ...     'http://algassert.com/quirk#circuit={"cols":[["iswap"]]}',
-        ...     extra_cell_makers=[
-        ...         cirq.interop.quirk.cells.CellMaker(
-        ...             identifier='iswap',
-        ...             size=2,
-        ...             maker=lambda args: cirq.ISWAP(*args.qubits))
-        ...     ]))
-        0: ───iSwap───
+
+    >>> print(cirq.quirk_url_to_circuit(
+    ...     'http://algassert.com/quirk#circuit={"cols":[["H"],["•","X"]]}'
+    ... ))
+    0: ───H───@───
               │
-        1: ───iSwap───
+    1: ───────X───
+
+    >>> print(cirq.quirk_url_to_circuit(
+    ...     'http://algassert.com/quirk#circuit={"cols":[["H"],["•","X"]]}',
+    ...     qubits=[cirq.NamedQubit('Alice'), cirq.NamedQubit('Bob')]
+    ... ))
+    Alice: ───H───@───
+                  │
+    Bob: ─────────X───
+
+    >>> print(cirq.quirk_url_to_circuit(
+    ...     'http://algassert.com/quirk#circuit={"cols":[["iswap"]]}',
+    ...     extra_cell_makers={'iswap': cirq.ISWAP}))
+    0: ───iSwap───
+          │
+    1: ───iSwap───
+
+    >>> print(cirq.quirk_url_to_circuit(
+    ...     'http://algassert.com/quirk#circuit={"cols":[["iswap"]]}',
+    ...     extra_cell_makers=[
+    ...         cirq.interop.quirk.cells.CellMaker(
+    ...             identifier='iswap',
+    ...             size=2,
+    ...             maker=lambda args: cirq.ISWAP(*args.qubits))
+    ...     ]))
+    0: ───iSwap───
+          │
+    1: ───iSwap───
 
     Returns:
         The parsed circuit.
@@ -172,12 +173,13 @@ def quirk_json_to_circuit(
             a billion laughs attack in the form of nested custom gates.
 
     Examples:
-        >>> print(cirq.quirk_json_to_circuit(
-        ...     {"cols":[["H"], ["•", "X"]]}
-        ... ))
-        0: ───H───@───
-                  │
-        1: ───────X───
+
+    >>> print(cirq.quirk_json_to_circuit(
+    ...     {"cols":[["H"], ["•", "X"]]}
+    ... ))
+    0: ───H───@───
+              │
+    1: ───────X───
 
     Returns:
         The parsed circuit.

cirq/json_resolver_cache.py

@@ -47,6 +47,7 @@ def _class_resolver_dictionary() -> Dict[str, ObjectFactory]:
     import pandas as pd
     import numpy as np
     from cirq.devices.noise_model import _NoNoiseModel
+    from cirq.devices import InsertionNoiseModel
     from cirq.experiments import GridInteractionLayer
     from cirq.experiments.grid_parallel_two_qubit_xeb import GridParallelXEBMetadata
 
@@ -147,6 +148,7 @@ def _class_resolver_dictionary() -> Dict[str, ObjectFactory]:
         'ISwapPowGate': cirq.ISwapPowGate,
         'IdentityGate': cirq.IdentityGate,
         'InitObsSetting': cirq.work.InitObsSetting,
+        'InsertionNoiseModel': InsertionNoiseModel,
         'KeyCondition': cirq.KeyCondition,
         'KrausChannel': cirq.KrausChannel,
         'LinearDict': cirq.LinearDict,

cirq/linalg/decompositions.py

@@ -20,6 +20,7 @@ import math
 from typing import (
     Any,
     Callable,
+    cast,
     Iterable,
     List,
     Optional,
@@ -33,7 +34,7 @@ from typing import (
 import matplotlib.pyplot as plt
 
 # this is for older systems with matplotlib <3.2 otherwise 3d projections fail
-from mpl_toolkits import mplot3d  # pylint: disable=unused-import
+from mpl_toolkits import mplot3d
 import numpy as np
 
 from cirq import value, protocols
@@ -554,7 +555,7 @@ def scatter_plot_normalized_kak_interaction_coefficients(
     interactions: Iterable[Union[np.ndarray, 'cirq.SupportsUnitary', 'KakDecomposition']],
     *,
     include_frame: bool = True,
-    ax: Optional[plt.Axes] = None,
+    ax: Optional[mplot3d.axes3d.Axes3D] = None,
     **kwargs,
 ):
     r"""Plots the interaction coefficients of many two-qubit operations.
@@ -633,13 +634,13 @@ def scatter_plot_normalized_kak_interaction_coefficients(
     show_plot = not ax
     if not ax:
         fig = plt.figure()
-        ax = fig.add_subplot(1, 1, 1, projection='3d')
+        ax = cast(mplot3d.axes3d.Axes3D, fig.add_subplot(1, 1, 1, projection='3d'))
 
     def coord_transform(
         pts: Union[List[Tuple[int, int, int]], np.ndarray]
-    ) -> Tuple[Iterable[float], Iterable[float], Iterable[float]]:
+    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
         if len(pts) == 0:
-            return [], [], []
+            return np.array([]), np.array([]), np.array([])
         xs, ys, zs = np.transpose(pts)
         return xs, zs, ys
 

cirq/ops/__init__.py

@@ -122,6 +122,8 @@ from cirq.ops.controlled_operation import ControlledOperation
 
 from cirq.ops.qubit_manager import BorrowableQubit, CleanQubit, QubitManager, SimpleQubitManager
 
+from cirq.ops.greedy_qubit_manager import GreedyQubitManager
+
 from cirq.ops.qubit_order import QubitOrder
 
 from cirq.ops.qubit_order_or_list import QubitOrderOrList

cirq/ops/classically_controlled_operation.py

@@ -155,7 +155,7 @@ class ClassicallyControlledOperation(raw_types.Operation):
         )
         sub_info = protocols.circuit_diagram_info(self._sub_operation, sub_args, None)
         if sub_info is None:
-            return NotImplemented  # coverage: ignore
+            return NotImplemented  # pragma: no cover
         control_label_count = 0
         if args.label_map is not None:
             control_label_count = len({k for c in self._conditions for k in c.keys})

cirq/ops/clifford_gate.py

@@ -448,7 +448,7 @@ class CliffordGate(raw_types.Gate, CommonCliffordGates):
             sim_state._state = sim_state.tableau.then(padded_tableau)
             return True
 
-        if isinstance(sim_state, sim.clifford.StabilizerChFormSimulationState):  # coverage: ignore
+        if isinstance(sim_state, sim.clifford.StabilizerChFormSimulationState):  # pragma: no cover
             # Do we know how to apply CliffordTableau on StabilizerChFormSimulationState?
             # It should be unlike because CliffordTableau ignores the global phase but CHForm
             # is aimed to fix that.
@@ -683,25 +683,26 @@ class SingleQubitCliffordGate(CliffordGate):
         flip_index = int(z_to_flip) * 2 + x_to_flip
         a, x, z = 0.0, 0.0, 0.0
 
-        if np.array_equal(self.clifford_tableau.matrix(), [[1, 0], [0, 1]]):
+        matrix = self.clifford_tableau.matrix()
+        if np.array_equal(matrix, [[1, 0], [0, 1]]):
             # I, Z, X, Y cases
             to_phased_xz = [(0.0, 0.0, 0.0), (0.0, 0.0, 1.0), (0.0, 1.0, 0.0), (0.5, 1.0, 0.0)]
             a, x, z = to_phased_xz[flip_index]
-        elif np.array_equal(self.clifford_tableau.matrix(), [[1, 0], [1, 1]]):
+        elif np.array_equal(matrix, [[1, 0], [1, 1]]):
             # +/- X_sqrt, 2 Hadamard-like gates acting on the YZ plane
             a = 0.0
             x = 0.5 if x_to_flip ^ z_to_flip else -0.5
             z = 1.0 if x_to_flip else 0.0
-        elif np.array_equal(self.clifford_tableau.matrix(), [[0, 1], [1, 0]]):
+        elif np.array_equal(matrix, [[0, 1], [1, 0]]):
             # +/- Y_sqrt, 2 Hadamard-like gates acting on the XZ plane
             a = 0.5
             x = 0.5 if x_to_flip else -0.5
             z = 0.0 if x_to_flip ^ z_to_flip else 1.0
-        elif np.array_equal(self.clifford_tableau.matrix(), [[1, 1], [0, 1]]):
+        elif np.array_equal(matrix, [[1, 1], [0, 1]]):
             # +/- Z_sqrt, 2 Hadamard-like gates acting on the XY plane
             to_phased_xz = [(0.0, 0.0, 0.5), (0.0, 0.0, -0.5), (0.25, 1.0, 0.0), (-0.25, 1.0, 0.0)]
             a, x, z = to_phased_xz[flip_index]
-        elif np.array_equal(self.clifford_tableau.matrix(), [[0, 1], [1, 1]]):
+        elif np.array_equal(matrix, [[0, 1], [1, 1]]):
             # axis swapping rotation -- (312) permutation
             a = 0.5
             x = 0.5 if x_to_flip else -0.5
@@ -709,7 +710,7 @@ class SingleQubitCliffordGate(CliffordGate):
         else:
             # axis swapping rotation -- (231) permutation.
             # This should be the only cases left.
-            assert np.array_equal(self.clifford_tableau.matrix(), [[1, 1], [1, 0]])
+            assert np.array_equal(matrix, [[1, 1], [1, 0]])
             a = 0.0
             x = -0.5 if x_to_flip ^ z_to_flip else 0.5
             z = -0.5 if x_to_flip else 0.5
@@ -846,8 +847,7 @@ class SingleQubitCliffordGate(CliffordGate):
                 ]
 
             return [(pauli_gates.Z, 1 if y_rot[1] else -1), (pauli_gates.X, 1 if z_rot[1] else -1)]
-        # coverage: ignore
-        assert (
+        assert (  # pragma: no cover
             False
         ), 'Impossible condition where this gate only rotates one Pauli to a different Pauli.'
 

cirq/ops/clifford_gate_test.py

@@ -20,7 +20,7 @@ import numpy as np
 import pytest
 
 import cirq
-from cirq.protocols.act_on_protocol_test import DummySimulationState
+from cirq.protocols.act_on_protocol_test import ExampleSimulationState
 from cirq.testing import EqualsTester, assert_allclose_up_to_global_phase
 
 _bools = (False, True)
@@ -47,7 +47,7 @@ def _assert_no_collision(gate) -> None:
 
 
 def _all_rotations():
-    for (pauli, flip) in itertools.product(_paulis, _bools):
+    for pauli, flip in itertools.product(_paulis, _bools):
         yield (pauli, flip)
 
 
@@ -490,7 +490,6 @@ def test_commutes_pauli(gate, pauli, half_turns):
 
 
 def test_to_clifford_tableau_util_function():
-
     tableau = cirq.ops.clifford_gate._to_clifford_tableau(
         x_to=(cirq.X, False), z_to=(cirq.Z, False)
     )
@@ -879,7 +878,7 @@ def test_clifford_gate_act_on_ch_form():
 
 def test_clifford_gate_act_on_fail():
     with pytest.raises(TypeError, match="Failed to act"):
-        cirq.act_on(cirq.CliffordGate.X, DummySimulationState(), qubits=())
+        cirq.act_on(cirq.CliffordGate.X, ExampleSimulationState(), qubits=())
 
 
 def test_all_single_qubit_clifford_unitaries():

cirq/ops/common_channels.py

@@ -400,13 +400,10 @@ class GeneralizedAmplitudeDampingChannel(raw_types.Gate):
     This channel evolves a density matrix via
 
     $$
-    \rho \rightarrow M_0 \rho M_0^\dagger
-                       + M_1 \rho M_1^\dagger
-                       + M_2 \rho M_2^\dagger
-                       + M_3 \rho M_3^\dagger
+    \rho \rightarrow \sum_{i=0}^3 M_i \rho M_i^\dagger
     $$
 
-    With
+    with
 
     $$
     \begin{aligned}

cirq/ops/common_channels_test.py

@@ -18,7 +18,7 @@ import numpy as np
 import pytest
 
 import cirq
-from cirq.protocols.act_on_protocol_test import DummySimulationState
+from cirq.protocols.act_on_protocol_test import ExampleSimulationState
 
 X = np.array([[0, 1], [1, 0]])
 Y = np.array([[0, -1j], [1j, 0]])
@@ -87,7 +87,6 @@ def test_asymmetric_depolarizing_channel_str():
 
 
 def test_asymmetric_depolarizing_channel_eq():
-
     a = cirq.asymmetric_depolarize(0.0099999, 0.01)
     b = cirq.asymmetric_depolarize(0.01, 0.0099999)
     c = cirq.asymmetric_depolarize(0.0, 0.0, 0.0)
@@ -492,7 +491,7 @@ def test_reset_channel_text_diagram():
 
 def test_reset_act_on():
     with pytest.raises(TypeError, match="Failed to act"):
-        cirq.act_on(cirq.ResetChannel(), DummySimulationState(), qubits=())
+        cirq.act_on(cirq.ResetChannel(), ExampleSimulationState(), qubits=())
 
     args = cirq.StateVectorSimulationState(
         available_buffer=np.empty(shape=(2, 2, 2, 2, 2), dtype=np.complex64),
@@ -697,7 +696,6 @@ def test_bit_flip_channel_str():
 
 
 def test_bit_flip_channel_eq():
-
     a = cirq.bit_flip(0.0099999)
     b = cirq.bit_flip(0.01)
     c = cirq.bit_flip(0.0)
@@ -735,7 +733,7 @@ def test_bit_flip_channel_text_diagram():
 def test_stabilizer_supports_depolarize():
     with pytest.raises(TypeError, match="act_on"):
         for _ in range(100):
-            cirq.act_on(cirq.depolarize(3 / 4), DummySimulationState(), qubits=())
+            cirq.act_on(cirq.depolarize(3 / 4), ExampleSimulationState(), qubits=())
 
     q = cirq.LineQubit(0)
     c = cirq.Circuit(cirq.depolarize(3 / 4).on(q), cirq.measure(q, key='m'))

cirq/ops/common_gates_test.py

@@ -17,7 +17,7 @@ import pytest
 import sympy
 
 import cirq
-from cirq.protocols.act_on_protocol_test import DummySimulationState
+from cirq.protocols.act_on_protocol_test import ExampleSimulationState
 
 H = np.array([[1, 1], [1, -1]]) * np.sqrt(0.5)
 HH = cirq.kron(H, H)
@@ -310,7 +310,7 @@ def test_h_str():
 
 def test_x_act_on_tableau():
     with pytest.raises(TypeError, match="Failed to act"):
-        cirq.act_on(cirq.X, DummySimulationState(), qubits=())
+        cirq.act_on(cirq.X, ExampleSimulationState(), qubits=())
     original_tableau = cirq.CliffordTableau(num_qubits=5, initial_state=31)
     flipped_tableau = cirq.CliffordTableau(num_qubits=5, initial_state=23)
 
@@ -359,7 +359,7 @@ class MinusOnePhaseGate(cirq.testing.SingleQubitGate):
 
 def test_y_act_on_tableau():
     with pytest.raises(TypeError, match="Failed to act"):
-        cirq.act_on(cirq.Y, DummySimulationState(), qubits=())
+        cirq.act_on(cirq.Y, ExampleSimulationState(), qubits=())
     original_tableau = cirq.CliffordTableau(num_qubits=5, initial_state=31)
     flipped_tableau = cirq.CliffordTableau(num_qubits=5, initial_state=23)
 
@@ -397,9 +397,9 @@ def test_y_act_on_tableau():
 
 def test_z_h_act_on_tableau():
     with pytest.raises(TypeError, match="Failed to act"):
-        cirq.act_on(cirq.Z, DummySimulationState(), qubits=())
+        cirq.act_on(cirq.Z, ExampleSimulationState(), qubits=())
     with pytest.raises(TypeError, match="Failed to act"):
-        cirq.act_on(cirq.H, DummySimulationState(), qubits=())
+        cirq.act_on(cirq.H, ExampleSimulationState(), qubits=())
     original_tableau = cirq.CliffordTableau(num_qubits=5, initial_state=31)
     flipped_tableau = cirq.CliffordTableau(num_qubits=5, initial_state=23)
 
@@ -450,7 +450,7 @@ def test_z_h_act_on_tableau():
 
 def test_cx_act_on_tableau():
     with pytest.raises(TypeError, match="Failed to act"):
-        cirq.act_on(cirq.CX, DummySimulationState(), qubits=())
+        cirq.act_on(cirq.CX, ExampleSimulationState(), qubits=())
     original_tableau = cirq.CliffordTableau(num_qubits=5, initial_state=31)
 
     state = cirq.CliffordTableauSimulationState(
@@ -494,7 +494,7 @@ def test_cx_act_on_tableau():
 
 def test_cz_act_on_tableau():
     with pytest.raises(TypeError, match="Failed to act"):
-        cirq.act_on(cirq.CZ, DummySimulationState(), qubits=())
+        cirq.act_on(cirq.CZ, ExampleSimulationState(), qubits=())
     original_tableau = cirq.CliffordTableau(num_qubits=5, initial_state=31)
 
     state = cirq.CliffordTableauSimulationState(

cirq/ops/controlled_operation_test.py

@@ -446,10 +446,10 @@ def test_controlled_operation_gate():
     class Gateless(cirq.Operation):
         @property
         def qubits(self):
-            return ()  # coverage: ignore
+            return ()  # pragma: no cover
 
         def with_qubits(self, *new_qubits):
-            return self  # coverage: ignore
+            return self  # pragma: no cover
 
         def _has_mixture_(self):
             return True

cirq/ops/dense_pauli_string.py

@@ -570,6 +570,9 @@ class MutableDensePauliString(BaseDensePauliString):
     def __str__(self) -> str:
         return super().__str__() + ' (mutable)'
 
+    def _value_equality_values_(self):
+        return self.coefficient, tuple(PAULI_CHARS[p] for p in self.pauli_mask)
+
     @classmethod
     def inline_gaussian_elimination(cls, rows: 'List[MutableDensePauliString]') -> None:
         if not rows:

cirq/ops/eigen_gate_test.py

@@ -201,8 +201,7 @@ def test_trace_distance_bound():
     assert cirq.approx_eq(cirq.trace_distance_bound(CExpZinGate(2)), 1)
 
     class E(cirq.EigenGate):
-        def _num_qubits_(self):
-            # coverage: ignore
+        def _num_qubits_(self):  # pragma: no cover
             return 1
 
         def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
@@ -227,7 +226,6 @@ def test_extrapolate():
 
 
 def test_matrix():
-
     for n in [1, 2, 3, 4, 0.0001, 3.9999]:
         assert cirq.has_unitary(CExpZinGate(n))
 

cirq/ops/fourier_transform.py

@@ -146,8 +146,7 @@ class PhaseGradientGate(raw_types.Gate):
 
     def __pow__(self, power):
         new_exponent = cirq.mul(self.exponent, power, NotImplemented)
-        if new_exponent is NotImplemented:
-            # coverage: ignore
+        if new_exponent is NotImplemented:  # pragma: no cover
             return NotImplemented
         return PhaseGradientGate(num_qubits=self._num_qubits, exponent=new_exponent)
 

cirq/ops/fsim_gate.py

@@ -81,7 +81,7 @@ class FSimGate(gate_features.InterchangeableQubitsGate, raw_types.Gate):
     $$
 
     $$
-    c = e^{i \phi}
+    c = e^{-i \phi}
     $$
 
     Note the difference in sign conventions between FSimGate and the

cirq/ops/gate_features_test.py

@@ -53,7 +53,7 @@ def test_qasm_output_args_format():
 
 
 def test_multi_qubit_gate_validate():
-    class Dummy(cirq.Gate):
+    class Example(cirq.Gate):
         def _num_qubits_(self) -> int:
             return self._num_qubits
 
@@ -62,7 +62,7 @@ def test_multi_qubit_gate_validate():
 
     a, b, c, d = cirq.LineQubit.range(4)
 
-    g = Dummy(3)
+    g = Example(3)
 
     assert g.num_qubits() == 3
     g.validate_args([a, b, c])

cirq/ops/gate_operation_test.py

@@ -523,8 +523,7 @@ def test_gate_to_operation_to_gate_round_trips():
             if gate_cls in skip_classes:
                 skipped.add(gate_cls)
                 continue
-            # coverage:ignore
-            raise AssertionError(
+            raise AssertionError(  # pragma: no cover
                 f"{gate_cls} has no json file, please add a json file or add to the list of "
                 "classes to be skipped if there is a reason this gate should not round trip "
                 "to a gate via creating an operation."

cirq/ops/greedy_qubit_manager.py

@@ -0,0 +1,86 @@
+# Copyright 2023 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.
+
+from typing import Iterable, List, Set, TYPE_CHECKING
+
+from cirq.ops import named_qubit, qid_util, qubit_manager
+
+if TYPE_CHECKING:
+    import cirq
+
+
+class GreedyQubitManager(qubit_manager.QubitManager):
+    """Greedy allocator that maximizes/minimizes qubit reuse based on a configurable parameter.
+
+    GreedyQubitManager can be configured, using `maximize_reuse` flag, to work in one of two modes:
+    - Minimize qubit reuse (maximize_reuse=False): For a fixed width, this mode uses a FIFO (First
+             in First out) strategy s.t. next allocated qubit is one which was freed the earliest.
+    - Maximize qubit reuse (maximize_reuse=True): For a fixed width, this mode uses a LIFO (Last in
+            First out) strategy s.t. the next allocated qubit is one which was freed the latest.
+
+    If the requested qubits are more than the set of free qubits, the qubit manager automatically
+    resizes the size of the managed qubit pool and adds new free qubits, that have their last
+    freed time to be -infinity.
+
+    For borrowing qubits, the qubit manager simply delegates borrow requests to `self.qalloc`, thus
+    always allocating new clean qubits.
+    """
+
+    def __init__(self, prefix: str, *, size: int = 0, maximize_reuse: bool = False):
+        """Initializes `GreedyQubitManager`
+
+        Args:
+            prefix: The prefix to use for naming new clean ancillas allocated by the qubit manager.
+                    The i'th allocated qubit is of the type `cirq.NamedQubit(f'{prefix}_{i}')`.
+            size: The initial size of the pool of ancilla qubits managed by the qubit manager. The
+                    qubit manager can automatically resize itself when the allocation request
+                    exceeds the number of available qubits.
+            maximize_reuse: Flag to control a FIFO vs LIFO strategy, defaults to False (FIFO).
+        """
+        self._prefix = prefix
+        self._used_qubits: Set['cirq.Qid'] = set()
+        self._free_qubits: List['cirq.Qid'] = []
+        self._size = 0
+        self.maximize_reuse = maximize_reuse
+        self.resize(size)
+
+    def _allocate_qid(self, name: str, dim: int) -> 'cirq.Qid':
+        return qid_util.q(name) if dim == 2 else named_qubit.NamedQid(name, dimension=dim)
+
+    def resize(self, new_size: int, dim: int = 2) -> None:
+        if new_size <= self._size:
+            return
+        new_qubits: List['cirq.Qid'] = [
+            self._allocate_qid(f'{self._prefix}_{s}', dim) for s in range(self._size, new_size)
+        ]
+        self._free_qubits = new_qubits + self._free_qubits
+        self._size = new_size
+
+    def qalloc(self, n: int, dim: int = 2) -> List['cirq.Qid']:
+        if not n:
+            return []
+        self.resize(self._size + n - len(self._free_qubits), dim=dim)
+        ret_qubits = self._free_qubits[-n:] if self.maximize_reuse else self._free_qubits[:n]
+        self._free_qubits = self._free_qubits[:-n] if self.maximize_reuse else self._free_qubits[n:]
+        self._used_qubits.update(ret_qubits)
+        return ret_qubits
+
+    def qfree(self, qubits: Iterable['cirq.Qid']) -> None:
+        qs = list(dict(zip(qubits, qubits)).keys())
+        assert self._used_qubits.issuperset(qs), "Only managed qubits currently in-use can be freed"
+        self._used_qubits = self._used_qubits.difference(qs)
+        self._free_qubits.extend(qs)
+
+    def qborrow(self, n: int, dim: int = 2) -> List['cirq.Qid']:
+        return self.qalloc(n, dim)