Update path.

recirq/third_party/quaff/__init__.py

@@ -1,4 +1,10 @@
-from recirq.qcqmc.quaff import indexing, json_serialization, linalg, random, testing
+from recirq.third_party.quaff import (
+    indexing,
+    json_serialization,
+    linalg,
+    random,
+    testing,
+)
 
 from .basis_change import BasisChangeGate, get_clearing_network, get_reversal_network
 from .comb import binom, get_inversion_number, get_num_perms_with_inversion_number
@@ -66,8 +72,8 @@
 
 
 def _register_resolver() -> None:
-    from recirq.qcqmc.quaff.json_resolver import json_resolver
-    from recirq.qcqmc.quaff.json_serialization import _internal_register_resolver
+    from recirq.third_party.quaff.json_resolver import json_resolver
+    from recirq.third_party.quaff.json_serialization import _internal_register_resolver
 
     _internal_register_resolver(json_resolver)
 

recirq/third_party/quaff/basis_change.py

@@ -3,7 +3,7 @@
 import cirq
 import numpy as np
 
-from recirq.qcqmc.quaff import indexing, linalg, random
+from recirq.third_party.quaff import indexing, linalg, random
 
 
 class BasisChangeGate(cirq.Gate):

recirq/third_party/quaff/basis_change_test.py

@@ -2,7 +2,7 @@
 import numpy as np
 import pytest
 
-from recirq.qcqmc import quaff
+from recirq.third_party import quaff
 
 
 @pytest.mark.parametrize(

recirq/third_party/quaff/comb_test.py

@@ -5,7 +5,7 @@
 import numpy as np
 import pytest
 
-from recirq.qcqmc import quaff
+from recirq.third_party import quaff
 
 
 def test_get_num_perms_with_inversion_number():

recirq/third_party/quaff/cz_layer.py

@@ -5,7 +5,7 @@
 import cirq
 import numpy as np
 
-from recirq.qcqmc.quaff import basis_change, gates, indexing, linalg
+from recirq.third_party.quaff import basis_change, gates, indexing, linalg
 
 
 def get_index_range(num_qubits: int, num_steps: int, i: int):

recirq/third_party/quaff/cz_layer_test.py

@@ -4,7 +4,7 @@
 import numpy as np
 import pytest
 
-from recirq.qcqmc import quaff
+from recirq.third_party import quaff
 
 
 @pytest.mark.parametrize(

recirq/third_party/quaff/gates/__init__.py

@@ -1,10 +1,10 @@
-from recirq.qcqmc.quaff.gates.fhf import FHFGate
-from recirq.qcqmc.quaff.gates.hadamard_free import HadamardFreeGate
-from recirq.qcqmc.quaff.gates.parameterized import (
+from recirq.third_party.quaff.gates.fhf import FHFGate
+from recirq.third_party.quaff.gates.hadamard_free import HadamardFreeGate
+from recirq.third_party.quaff.gates.parameterized import (
     get_parameterized_truncated_clifford_ops,
     get_parameterized_truncated_cliffords_ops,
     get_truncated_clifford_resolver,
     get_truncated_cliffords_resolver,
 )
-from recirq.qcqmc.quaff.gates.single_qubit_layer import SingleQubitLayerGate
-from recirq.qcqmc.quaff.gates.truncated_clifford import TruncatedCliffordGate
+from recirq.third_party.quaff.gates.single_qubit_layer import SingleQubitLayerGate
+from recirq.third_party.quaff.gates.truncated_clifford import TruncatedCliffordGate

recirq/third_party/quaff/gates/fhf.py

@@ -6,9 +6,9 @@
 import cirq
 import numpy as np
 
-from recirq.qcqmc.quaff import linalg, sampling, testing
-from recirq.qcqmc.quaff.gates.hadamard_free import HadamardFreeGate
-from recirq.qcqmc.quaff.gates.single_qubit_layer import SingleQubitLayerGate
+from recirq.third_party.quaff import linalg, sampling, testing
+from recirq.third_party.quaff.gates.hadamard_free import HadamardFreeGate
+from recirq.third_party.quaff.gates.single_qubit_layer import SingleQubitLayerGate
 
 
 def _recover_permutation(matrix: np.ndarray) -> Optional[np.ndarray]:
@@ -67,7 +67,7 @@ def _json_dict_(self):
 
     @classmethod
     def _json_namespace_(cls):
-        return "recirq.qcqmc.quaff"
+        return "recirq.third_party.quaff"
 
     def _num_qubits_(self):
         return self._num_qubits

recirq/third_party/quaff/gates/fhf_test.py

@@ -4,7 +4,7 @@
 import numpy as np
 import pytest
 
-from recirq.qcqmc import quaff
+from recirq.third_party import quaff
 
 
 @pytest.mark.parametrize("n, seed", ((n, quaff.random_seed()) for n in range(1, 7)))

recirq/third_party/quaff/gates/hadamard_free.py

@@ -5,7 +5,7 @@
 import cirq
 import numpy as np
 
-from recirq.qcqmc.quaff import indexing, linalg, random, testing
+from recirq.third_party.quaff import indexing, linalg, random, testing
 
 
 @dataclass
@@ -47,7 +47,7 @@ def _json_dict_(self):
 
     @classmethod
     def _json_namespace_(cls):
-        return "recirq.qcqmc.quaff"
+        return "recirq.third_party.quaff"
 
     def _num_qubits_(self):
         return self._num_qubits

recirq/third_party/quaff/gates/hadamard_free_test.py

@@ -4,7 +4,7 @@
 import numpy as np
 import pytest
 
-from recirq.qcqmc import quaff
+from recirq.third_party import quaff
 
 
 def assert_hadamard_free_gate_unitary_is_good(n, gate):

recirq/third_party/quaff/gates/parameterized.py

@@ -3,8 +3,8 @@
 import cirq
 import sympy
 
-from recirq.qcqmc.quaff import cz_layer
-from recirq.qcqmc.quaff.gates.truncated_clifford import TruncatedCliffordGate
+from recirq.third_party.quaff import cz_layer
+from recirq.third_party.quaff.gates.truncated_clifford import TruncatedCliffordGate
 
 
 def get_truncated_clifford_resolver(

recirq/third_party/quaff/gates/parameterized_test.py

@@ -4,7 +4,7 @@
 import numpy as np
 import pytest
 
-from recirq.qcqmc import quaff
+from recirq.third_party import quaff
 
 
 @pytest.mark.parametrize("n, seed", ((n, quaff.random_seed()) for n in range(1, 6)))

recirq/third_party/quaff/gates/single_qubit_layer_test.py

@@ -2,7 +2,7 @@
 import numpy as np
 import pytest
 
-from recirq.qcqmc import quaff
+from recirq.third_party import quaff
 
 
 def test_single_qubit_layer_gate_bad():

recirq/third_party/quaff/gates/truncated_clifford.py

@@ -5,11 +5,11 @@
 import cirq
 import numpy as np
 
-from recirq.qcqmc.quaff import comb, cz_layer, indexing, linalg, sampling, testing
-from recirq.qcqmc.quaff.gates.fhf import FHFGate
-from recirq.qcqmc.quaff.gates.hadamard_free import HadamardFreeGate
-from recirq.qcqmc.quaff.gates.single_qubit_layer import SingleQubitLayerGate
-from recirq.qcqmc.quaff.linalg import BooleanMatrix, BooleanVector
+from recirq.third_party.quaff import comb, cz_layer, indexing, linalg, sampling, testing
+from recirq.third_party.quaff.gates.fhf import FHFGate
+from recirq.third_party.quaff.gates.hadamard_free import HadamardFreeGate
+from recirq.third_party.quaff.gates.single_qubit_layer import SingleQubitLayerGate
+from recirq.third_party.quaff.linalg import BooleanMatrix, BooleanVector
 
 
 @dataclass(eq=True, order=True)
@@ -54,7 +54,7 @@ def _json_dict_(self):
 
     @classmethod
     def _json_namespace_(cls):
-        return "recirq.qcqmc.quaff"
+        return "recirq.third_party.quaff"
 
     def __str__(self):
         args = [f"n={self._num_qubits}"]

recirq/third_party/quaff/gates/truncated_clifford_test.py

@@ -2,7 +2,7 @@
 import numpy as np
 import pytest
 
-from recirq.qcqmc.quaff import (
+from recirq.third_party.quaff import (
     DEFAULT_RESOLVERS,
     HadamardFreeGate,
     random_seed,

recirq/third_party/quaff/indexing_test.py

@@ -3,7 +3,7 @@
 import numpy as np
 import pytest
 
-from recirq.qcqmc import quaff
+from recirq.third_party import quaff
 
 
 @pytest.mark.parametrize("n, big_endian", itertools.product(range(5), (0, 1)))

recirq/third_party/quaff/json_resolver.py

@@ -1,12 +1,16 @@
-from typing import cast, Optional
+from typing import Optional, cast
 
 from cirq.protocols.json_serialization import ObjectFactory
 
 
 def json_resolver(quaff_type: str) -> Optional[ObjectFactory]:
-    if quaff_type.startswith("recirq.qcqmc.quaff."):
+    if quaff_type.startswith("recirq.third_party.quaff."):
         return cast(
             ObjectFactory,
-            eval(f"__import__('recirq.qcqmc').{quaff_type.split('.', 1)[1]}", {}, {}),
+            eval(
+                f"__import__('recirq.third_party').{quaff_type.split('.', 1)[1]}",
+                {},
+                {},
+            ),
         )
     return None

recirq/third_party/quaff/linalg.py

@@ -2,7 +2,7 @@
 
 import numpy as np
 
-from recirq.qcqmc.quaff import indexing
+from recirq.third_party.quaff import indexing
 
 DTYPE = np.uint8
 

recirq/third_party/quaff/linalg_test.py

@@ -4,7 +4,7 @@
 import numpy as np
 import pytest
 
-from recirq.qcqmc import quaff
+from recirq.third_party import quaff
 
 
 @pytest.mark.parametrize(

recirq/third_party/quaff/random.py

@@ -3,7 +3,7 @@
 
 import numpy as np
 
-from recirq.qcqmc.quaff import indexing, linalg, sampling
+from recirq.third_party.quaff import indexing, linalg, sampling
 
 SEED = 2349230498
 RNG = np.random.default_rng(SEED)

recirq/third_party/quaff/random_test.py

@@ -1,7 +1,7 @@
 import numpy as np
 import pytest
 
-from recirq.qcqmc import quaff
+from recirq.third_party import quaff
 
 
 @pytest.mark.parametrize(

recirq/third_party/quaff/sampling/__init__.py

@@ -1,4 +1,4 @@
-from recirq.qcqmc.quaff import testing
+from recirq.third_party.quaff import testing
 
 from .boolean_sampler import BooleanSampler
 from .clifford_sampler import (

recirq/third_party/quaff/sampling/boolean_sampler.py

@@ -3,8 +3,8 @@
 
 import numpy as np
 
-from recirq.qcqmc.quaff import linalg, testing
-from recirq.qcqmc.quaff.sampling.sampler import Randomness, Sample, Sampler
+from recirq.third_party.quaff import linalg, testing
+from recirq.third_party.quaff.sampling.sampler import Randomness, Sample, Sampler
 
 
 class BooleanSampler(Sampler):

recirq/third_party/quaff/sampling/clifford_sampler.py

@@ -6,8 +6,8 @@
 import cirq
 import numpy as np
 
-from recirq.qcqmc.quaff import comb, indexing, linalg, testing
-from recirq.qcqmc.quaff.sampling.sampler import SingleParameterSampler
+from recirq.third_party.quaff import comb, indexing, linalg, testing
+from recirq.third_party.quaff.sampling.sampler import SingleParameterSampler
 
 QuantumMallowsSample = Tuple[Tuple[bool, ...], Tuple[int, ...]]
 QuantumMallowsRandomness = Tuple[int, ...]
@@ -120,7 +120,7 @@ def _json_dict_(self):
 
     @classmethod
     def _json_namespace_(cls):
-        return "recirq.qcqmc.quaff"
+        return "recirq.third_party.quaff"
 
     def num_qubits(self):
         return len(self.parity_shift)
@@ -189,12 +189,16 @@ def _get_Δ_and_Γ_indices(
                 else:
                     Δ_indices.append((i, j))
         return (
-            tuple(np.array(Δ_indices).T)
-            if Δ_indices
-            else (np.zeros(0, dtype=int),) * 2,
-            tuple(np.array(Γ_indices).T)
-            if Γ_indices
-            else (np.zeros(0, dtype=int),) * 2,
+            (
+                tuple(np.array(Δ_indices).T)
+                if Δ_indices
+                else (np.zeros(0, dtype=int),) * 2
+            ),
+            (
+                tuple(np.array(Γ_indices).T)
+                if Γ_indices
+                else (np.zeros(0, dtype=int),) * 2
+            ),
         )
 
     def randomness_to_sample(self, randomness: CliffordRandomness) -> CliffordSample:

recirq/third_party/quaff/sampling/invertible_matrix_sampler.py

@@ -4,8 +4,8 @@
 
 import numpy as np
 
-from recirq.qcqmc.quaff import comb, indexing, linalg
-from recirq.qcqmc.quaff.sampling.sampler import SingleParameterSampler
+from recirq.third_party.quaff import comb, indexing, linalg
+from recirq.third_party.quaff.sampling.sampler import SingleParameterSampler
 
 MallowsSample = Tuple[int, ...]
 MallowsRandomness = Tuple[int, ...]

recirq/third_party/quaff/sampling/sampler.py

@@ -65,7 +65,7 @@ def __str__(self):
         return f"{self.name()}({arg_str})"
 
     def __repr__(self):
-        return f"recirq.qcqmc.quaff.{self}"
+        return f"recirq.third_party.quaff.{self}"
 
     def __eq__(self, other):
         if not isinstance(other, type(self)):

recirq/third_party/quaff/sampling/testing.py

@@ -3,8 +3,8 @@
 import numpy as np
 import scipy.stats
 
-from recirq.qcqmc.quaff import json_serialization, random
-from recirq.qcqmc.quaff.testing import assert_equivalent_repr
+from recirq.third_party.quaff import json_serialization, random
+from recirq.third_party.quaff.testing import assert_equivalent_repr
 
 
 def assert_sampler_consistent(sampler_cls, *args, test_json=False, **kwargs):

recirq/third_party/quaff/testing.py

@@ -3,7 +3,7 @@
 import cirq
 import numpy as np
 
-from recirq.qcqmc.quaff import linalg
+from recirq.third_party.quaff import linalg
 
 
 def assert_consistent_unitary_round_trip(num_qubits, gate_type, seed):