make submodules in rotation_synthesis/ private to improve doc view (#1776)

For now this is just a minimial change that renames of the files while
exporting essential methods/variables at __init__.py files with minimal
changes to the the import statements. overtime import statments such as
`import xx._yy` should be
 `import xx` unless it is happening within the `xx` directory

Author: NoureldinYosri

qualtran/rotation_synthesis/README.md

@@ -11,20 +11,18 @@ The examples assume the following lines have been executed.
 ```py3
 >>> import mpmath
 >>> import qualtran.rotation_synthesis as rs
->>> from qualtran.rotation_synthesis import math_config as mc
->>> from qualtran.rotation_synthesis.protocols import clifford_t_synthesis as cts
 >>> # 300 digits of precision is enough for eps as low as 10^-30.
 >>> # for big enough eps (>= 10^-10) prefer dps ~100 to reduce the runtime
 >>> # A high dps increases the runtime but a low dps risks missing solutions.
->>> config = mc.with_dps(300)
+>>> config = rs.with_dps(300)
 >>> theta = 0.1  # theta = 0.1 rad
 >>> eps = mpmath.mpf(1e-8)  # epsilon = 1e-8
 ```
 
 ### Diagonal Protocol
 
 ```py3
->>> diagonal = cts.diagonal_unitary_approx(theta=theta, eps=eps, max_n=400, config=config)
+>>> diagonal = rs.diagonal_unitary_approx(theta=theta, eps=eps, max_n=400, config=config)
 >>> diagonal
 Unitary(p=ZW(coords=(1509861905169903736208, 1174754259083368969221, 151491500481353346337, -960512924518388809952)), q=ZW(coords=(-4263827284335, -6564144819191, -5019275344346, -534182446068)), n=80, twirl=False)
 
@@ -55,7 +53,7 @@ https://algassert.com/quirk#circuit={"cols":[["Z^½"],["X^¼"],["Z^-¼"],["X^¼"
 ### Fallback (a.k.a Repeat-Until-Success (RUS)) Protocol
 
 ```py3
->>> fallback = cts.fallback_protocol(theta, eps, success_probability=0.99, max_n=200, config=config)
+>>> fallback = rs.fallback_protocol(theta, eps, success_probability=0.99, max_n=200, config=config)
 >>> fallback
 ProjectiveChannel(rotation=Unitary(p=ZW(coords=(239242444, 186143567, 24004313, -152196342)), q=ZW(coords=(11711997, 17295059, 12746910, 731794)), n=32, twirl=False), correction=Unitary(p=ZW(coords=(113393374677276065, 8759190556798315, -101006008596441546, -151603257795059376)), q=ZW(coords=(-13979001969, 2234592382, 17139192822, 22003886555)), n=65, twirl=False))
 
@@ -90,7 +88,7 @@ m: ═════════════════════════
 ### Mixed Diagonal Protocol
 
 ```py3
->>> mixed_diagonal = cts.mixed_diagonal_protocol(theta, eps, max_n=300, config=config)
+>>> mixed_diagonal = rs.mixed_diagonal_protocol(theta, eps, max_n=300, config=config)
 >>> mixed_diagonal
 ProbabilisticChannel(c1=Unitary(p=ZW(coords=(111279824866, 86577736003, 11159583589, -70795701541)), q=ZW(coords=(2905774, -827421, -4075924, -4936806)), n=42, twirl=True), c2=Unitary(p=ZW(coords=(32592863748, 25359568315, 3270981699, -20733701634)), q=ZW(coords=(-261947, -1668702, -2097954, -1298253)), n=40, twirl=True), probability=mpf('0.322751359448635267114326370859256829689458745026081702686971426030895682599474514910816660886778364762073662905955339813205441513151138367919667045726178096784779764992341606213189667302147688085007915854895131323239141860542004025041462985374870176351764143883625569021092174011359447964257700140487645'))
 
@@ -106,7 +104,7 @@ expected number of T gates is 40.646
 
 
 ```py3
->>> mixed_fallback = cts.mixed_fallback_protocol(theta, eps, success_probability=0.99, max_n=300, config=config)
+>>> mixed_fallback = rs.mixed_fallback_protocol(theta, eps, success_probability=0.99, max_n=300, config=config)
 >>> mixed_fallback
 ProbabilisticChannel(c1=ProjectiveChannel(rotation=Unitary(p=ZW(coords=(81907, 63728, 8218, -52106)), q=ZW(coords=(-1154, 985, 2547, 2617)), n=19, twirl=False), correction=ProbabilisticChannel(c1=Unitary(p=ZW(coords=(-263391098, -737624638, -779767669, -365133375)), q=ZW(coords=(-33461, 136222, 226108, 183543)), n=34, twirl=True), c2=Unitary(p=ZW(coords=(-77065381, -216007734, -228415686, -107020827)), q=ZW(coords=(-69300, -100383, -72663, -2378)), n=32, twirl=True), probability=mpf('0.045325686665484547940062502757622971144169613023747430900082177527088724087189898382813946924494697326621166855704833076057576200695347588135413318392991377437019817846667142336189311546588693427566709307270541970137781795585088761789630584519324449933375058208979540812676838676732065743027397323424595'))), c2=ProjectiveChannel(rotation=Unitary(p=ZW(coords=(23978, 18657, 2407, -15253)), q=ZW(coords=(-956, -1084, -577, 268)), n=17, twirl=False), correction=ProbabilisticChannel(c1=Unitary(p=ZW(coords=(-1373879826, -510348019, 652138736, 1432611464)), q=ZW(coords=(-189284, 278185, 582697, 545873)), n=35, twirl=True), c2=Unitary(p=ZW(coords=(-402460569, -149610333, 190879607, 419554862)), q=ZW(coords=(-69300, -31083, 25342, 66922)), n=33, twirl=True), probability=mpf('0.525040802635724724816097410427482676809933478764171151369355514657076375140052487037506999832799609679457396659076441254494844846449599140703045579066152308112059014940560931326583883941250186082725677082913867579961221230890451563733787938393583123811396292716244823945079739397111073899481930671270029'))), probability=mpf('0.972077582319464271880109129184631244429176680508313282994368258672700642062726782223015417086951750128434612291521852730028085519115453255242801194500490513953599832009476998145136699780645059022125864590137472901641917927185402638252104301881958927225784570356720997394377273869421589887668348541958305'))
 

qualtran/rotation_synthesis/__init__.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from qualtran.rotation_synthesis.math_config import NumpyConfig, with_dps
+from qualtran.rotation_synthesis._math_config import NumpyConfig, with_dps
 from qualtran.rotation_synthesis.matrix import to_cirq, to_quirk, to_sequence
 from qualtran.rotation_synthesis.protocols import (
     diagonal_unitary_approx,

…altran/rotation_synthesis/math_config.py …ltran/rotation_synthesis/_math_config.pyqualtran/rotation_synthesis/math_config.py renamed to qualtran/rotation_synthesis/_math_config.py qualtran/rotation_synthesis/math_config.py renamed to qualtran/rotation_synthesis/_math_config.py

@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from qualtran.rotation_synthesis.channels.channel import (
+from qualtran.rotation_synthesis.channels._channel import (
     Channel,
     ProbabilisticChannel,
     ProjectiveChannel,

qualtran/rotation_synthesis/channels/__init__.py

@@ -21,12 +21,12 @@
 import cirq
 import numpy as np
 
+import qualtran.rotation_synthesis._math_config as mc
 import qualtran.rotation_synthesis._typing as rst
-import qualtran.rotation_synthesis.math_config as mc
-import qualtran.rotation_synthesis.matrix.clifford_t_repr as ctr
+import qualtran.rotation_synthesis.matrix._clifford_t_repr as ctr
 import qualtran.rotation_synthesis.rings as rings
-from qualtran.rotation_synthesis.matrix import su2_ct
-from qualtran.rotation_synthesis.rings import zsqrt2
+from qualtran.rotation_synthesis.matrix import _su2_ct
+from qualtran.rotation_synthesis.rings import _zsqrt2
 
 
 class Channel(abc.ABC):
@@ -74,8 +74,8 @@ class UnitaryChannel(Channel):
     n: int = attrs.field(validator=attrs.validators.instance_of(int))
     twirl: bool = False
 
-    def to_matrix(self) -> su2_ct.SU2CliffordT:
-        return su2_ct.SU2CliffordT.from_pair(self.p, self.q, pick_phase=True)
+    def to_matrix(self) -> _su2_ct.SU2CliffordT:
+        return _su2_ct.SU2CliffordT.from_pair(self.p, self.q, pick_phase=True)
 
     def expected_num_ts(self, config: Optional[mc.MathConfig] = None) -> rst.Real:
         return self.n
@@ -90,7 +90,7 @@ def failure_angle(self, config: mc.MathConfig) -> rst.Real:
 
     def diamond_norm_distance_to_rz(self, theta: rst.Real, config: mc.MathConfig) -> rst.Real:
         u = self.p.value(config.sqrt2)
-        u = u / zsqrt2.radius_at_n(zsqrt2.LAMBDA_KLIUCHNIKOV, self.n, config)
+        u = u / _zsqrt2.radius_at_n(_zsqrt2.LAMBDA_KLIUCHNIKOV, self.n, config)
         neg_rot = config.cos(theta) - config.sin(theta) * 1j
         real_squared = (u * neg_rot).real ** 2
         if self.twirl:
@@ -109,7 +109,7 @@ def from_sequence(cls, seq: Sequence[str], twirl: bool = False) -> UnitaryChanne
         Returns:
             A UnitaryChannel.
         """
-        u = su2_ct.SU2CliffordT.from_sequence(seq)
+        u = _su2_ct.SU2CliffordT.from_sequence(seq)
         n = sum(g.startswith("T") for g in seq)
         return UnitaryChannel(u.matrix[0, 0], u.matrix[1, 0], n, twirl)
 
@@ -181,12 +181,12 @@ def diamond_norm_distance_to_unitary(
 
     @classmethod
     def from_unitaries(
-        cls, *unitaries: Union[UnitaryChannel, su2_ct.SU2CliffordT]
+        cls, *unitaries: Union[UnitaryChannel, _su2_ct.SU2CliffordT]
     ) -> UnitaryChannel:
         if not unitaries:
             raise ValueError('at least one unitary should be provided')
 
-        unitary = su2_ct.ISqrt2
+        unitary = _su2_ct.ISqrt2
         for u in unitaries:
             if isinstance(u, UnitaryChannel):
                 unitary = unitary @ u.to_matrix()
@@ -219,8 +219,8 @@ class ProjectiveChannel(Channel):
 
     def success_probability(self, config: mc.MathConfig) -> rst.Real:
         """Constructs a probablity of a zero measurement."""
-        v = self.rotation.q.polar(config)[0] / zsqrt2.radius_at_n(
-            zsqrt2.LAMBDA_KLIUCHNIKOV, self.rotation.n, config
+        v = self.rotation.q.polar(config)[0] / _zsqrt2.radius_at_n(
+            _zsqrt2.LAMBDA_KLIUCHNIKOV, self.rotation.n, config
         )
         return 1 - v * v
 
@@ -234,8 +234,8 @@ def failure_angle(self, config: mc.MathConfig) -> rst.Real:
 
     def expected_num_ts(self, config: mc.MathConfig) -> rst.Real:
         v = self.rotation.q.value(config.sqrt2)
-        fail_prob = (v * v.conjugate()).real / zsqrt2.radius2_at_n(
-            zsqrt2.LAMBDA_KLIUCHNIKOV, self.rotation.n, config
+        fail_prob = (v * v.conjugate()).real / _zsqrt2.radius2_at_n(
+            _zsqrt2.LAMBDA_KLIUCHNIKOV, self.rotation.n, config
         )
         return self.rotation.expected_num_ts(config) + fail_prob * self.correction.expected_num_ts(
             config
@@ -387,8 +387,8 @@ def from_unitary_channels(
         r2, phi2 = u2.p.polar(config)
         delta1 = phi1 - target_theta
         delta2 = phi2 - target_theta
-        r1 /= zsqrt2.radius_at_n(zsqrt2.LAMBDA_KLIUCHNIKOV, u1.n, config)
-        r2 /= zsqrt2.radius_at_n(zsqrt2.LAMBDA_KLIUCHNIKOV, u2.n, config)
+        r1 /= _zsqrt2.radius_at_n(_zsqrt2.LAMBDA_KLIUCHNIKOV, u1.n, config)
+        r2 /= _zsqrt2.radius_at_n(_zsqrt2.LAMBDA_KLIUCHNIKOV, u2.n, config)
         prob = (
             r2**2
             * config.sin(2 * delta2)

…n/rotation_synthesis/channels/channel.py …/rotation_synthesis/channels/_channel.pyqualtran/rotation_synthesis/channels/channel.py renamed to qualtran/rotation_synthesis/channels/_channel.py qualtran/rotation_synthesis/channels/channel.py renamed to qualtran/rotation_synthesis/channels/_channel.py

@@ -16,14 +16,14 @@
 import numpy as np
 import pytest
 
+import qualtran.rotation_synthesis._math_config as mc
 import qualtran.rotation_synthesis.channels as ch
-import qualtran.rotation_synthesis.math_config as mc
-import qualtran.rotation_synthesis.matrix.clifford_t_repr as ctr
-import qualtran.rotation_synthesis.matrix.su2_ct as su2_ct
+import qualtran.rotation_synthesis.matrix._clifford_t_repr as ctr
+import qualtran.rotation_synthesis.matrix._su2_ct as _su2_ct
 
 
 def _make_gates(n_seqs: int, n_gates: int, seed: int):
-    gates = tuple(su2_ct.GATE_MAP.keys())
+    gates = tuple(_su2_ct.GATE_MAP.keys())
     rng = np.random.default_rng(seed)
     for _ in range(n_seqs):
         yield [gates[i] for i in rng.choice(len(gates), n_gates)]
@@ -32,7 +32,7 @@ def _make_gates(n_seqs: int, n_gates: int, seed: int):
 @pytest.mark.parametrize("gates", _make_gates(10, 4, 0))
 def test_unitary_from_sequence(gates):
     u = ch.UnitaryChannel.from_sequence(gates)
-    assert u.to_matrix() == su2_ct.SU2CliffordT.from_sequence(gates)
+    assert u.to_matrix() == _su2_ct.SU2CliffordT.from_sequence(gates)
 
 
 @pytest.mark.parametrize(

qualtran/rotation_synthesis/channels/channel_test.py

@@ -14,12 +14,12 @@
 
 """A package that provides methods for integer point enumeration."""
 
-from qualtran.rotation_synthesis.lattice.geometry import Ellipse, Range, Rectangle
-from qualtran.rotation_synthesis.lattice.grid_operators import GridOperator
-from qualtran.rotation_synthesis.lattice.ipe import (
+from qualtran.rotation_synthesis.lattice._geometry import Ellipse, Range, Rectangle
+from qualtran.rotation_synthesis.lattice._grid_operators import GridOperator
+from qualtran.rotation_synthesis.lattice._ipe import (
     enumerate_1d,
     enumerate_upright,
     get_overall_action,
     get_points_from_state,
 )
-from qualtran.rotation_synthesis.lattice.state import GridOperatorAction, SelingerState
+from qualtran.rotation_synthesis.lattice._state import GridOperatorAction, SelingerState

qualtran/rotation_synthesis/lattice/__init__.py

@@ -25,8 +25,8 @@
 import mpmath
 import numpy as np
 
+import qualtran.rotation_synthesis._math_config as mc
 import qualtran.rotation_synthesis._typing as rst
-import qualtran.rotation_synthesis.math_config as mc
 
 
 @attrs.frozen

…n/rotation_synthesis/lattice/geometry.py …/rotation_synthesis/lattice/_geometry.pyqualtran/rotation_synthesis/lattice/geometry.py renamed to qualtran/rotation_synthesis/lattice/_geometry.py qualtran/rotation_synthesis/lattice/geometry.py renamed to qualtran/rotation_synthesis/lattice/_geometry.py

@@ -18,8 +18,8 @@
 import numpy as np
 
 import qualtran.rotation_synthesis._typing as rst
-import qualtran.rotation_synthesis.rings.zsqrt2 as zsqrt2
-import qualtran.rotation_synthesis.rings.zw as zw
+import qualtran.rotation_synthesis.rings._zsqrt2 as _zsqrt2
+import qualtran.rotation_synthesis.rings._zw as _zw
 
 
 @attrs.frozen
@@ -48,7 +48,7 @@ def __attrs_post_init__(self):
         m = self.matrix
         assert isinstance(m.dtype, object)
         assert m.shape == (2, 2)
-        assert all(isinstance(x, zsqrt2.ZSqrt2) for x in m.reshape(-1))
+        assert all(isinstance(x, _zsqrt2.ZSqrt2) for x in m.reshape(-1))
         assert sum(x.a for x in self.matrix.reshape(-1)) % 2 == 0
         assert sum(x.b for x in self.matrix.reshape(-1)) % 2 == 0
 
@@ -75,18 +75,19 @@ def shift(self, k: rst.Integral) -> "GridOperator":
         """
         k = int(k)
         if k >= 0:
-            lambda_value = zsqrt2.LAMBDA
-            l_inv = zsqrt2.LAMBDA_INV
+            lambda_value = _zsqrt2.LAMBDA
+            l_inv = _zsqrt2.LAMBDA_INV
         else:
-            l_inv = zsqrt2.LAMBDA
-            lambda_value = zsqrt2.LAMBDA_INV
+            l_inv = _zsqrt2.LAMBDA
+            lambda_value = _zsqrt2.LAMBDA_INV
 
         k = abs(k)
         left = GridOperator(
-            np.array([[zsqrt2.One, zsqrt2.Zero], [zsqrt2.Zero, l_inv**k]]) * zsqrt2.SQRT_2
+            np.array([[_zsqrt2.One, _zsqrt2.Zero], [_zsqrt2.Zero, l_inv**k]]) * _zsqrt2.SQRT_2
         )
         right = GridOperator(
-            np.array([[lambda_value**k, zsqrt2.Zero], [zsqrt2.Zero, zsqrt2.One]]) * zsqrt2.SQRT_2
+            np.array([[lambda_value**k, _zsqrt2.Zero], [_zsqrt2.Zero, _zsqrt2.One]])
+            * _zsqrt2.SQRT_2
         )
         return left @ self @ right
 
@@ -135,12 +136,12 @@ def actual_value(self, sqrt2: rst.Real) -> np.ndarray:
     def scaled_inverse(self) -> "GridOperator":
         """Returns the inverse of the operator multiplied by sqrt(2)."""
         a, b, c, d = self.matrix.reshape(-1)
-        det: zsqrt2.ZSqrt2 = a * d - b * c
+        det: _zsqrt2.ZSqrt2 = a * d - b * c
         assert det.b == 0 and det.a in (-2, 2)
         sgn = -1 if det.a == -2 else 1
         return GridOperator(np.array([[d, -b], [-c, a]]) * sgn)
 
-    def apply(self, z: zw.ZW) -> zw.ZW:
+    def apply(self, z: _zw.ZW) -> _zw.ZW:
         r"""Applies the operator on the given point in $\mathbb{\omega}$."""
 
         # The operator is a 2x2 matrix that acts on the real and imaginary parts of a point.
@@ -150,56 +151,58 @@ def apply(self, z: zw.ZW) -> zw.ZW:
         a, b, c, d = self.matrix.reshape(-1)
 
         if include_w:
-            x = x * zsqrt2.SQRT_2 + zsqrt2.One
-            y = y * zsqrt2.SQRT_2 + zsqrt2.One
+            x = x * _zsqrt2.SQRT_2 + _zsqrt2.One
+            y = y * _zsqrt2.SQRT_2 + _zsqrt2.One
             xp = a * x + b * y
             yp = c * x + d * y
             assert xp.a % 2 == yp.a % 2 == 0
             assert xp.b % 2 == yp.b % 2
             if xp.b % 2 == 0:
-                xp = zsqrt2.ZSqrt2(xp.a // 2, xp.b // 2)
-                yp = zsqrt2.ZSqrt2(yp.a // 2, yp.b // 2)
-                return zw.ZW.from_pair(xp, yp, False)
+                xp = _zsqrt2.ZSqrt2(xp.a // 2, xp.b // 2)
+                yp = _zsqrt2.ZSqrt2(yp.a // 2, yp.b // 2)
+                return _zw.ZW.from_pair(xp, yp, False)
             else:
-                xp = zsqrt2.ZSqrt2(xp.a // 2, (xp.b - 1) // 2)
-                yp = zsqrt2.ZSqrt2(yp.a // 2, (yp.b - 1) // 2)
-                return zw.ZW.from_pair(xp, yp, True)
+                xp = _zsqrt2.ZSqrt2(xp.a // 2, (xp.b - 1) // 2)
+                yp = _zsqrt2.ZSqrt2(yp.a // 2, (yp.b - 1) // 2)
+                return _zw.ZW.from_pair(xp, yp, True)
         else:
             xp = a * x + b * y
             yp = c * x + d * y
             assert (xp.a + yp.a) % 2 == 0
             if xp.a % 2 == 0:
-                return zw.ZW.from_pair(xp.divide_by_sqrt2(), yp.divide_by_sqrt2(), False)
+                return _zw.ZW.from_pair(xp.divide_by_sqrt2(), yp.divide_by_sqrt2(), False)
             else:
-                xp = xp - zsqrt2.One
-                yp = yp - zsqrt2.One
-                return zw.ZW.from_pair(xp.divide_by_sqrt2(), yp.divide_by_sqrt2(), True)
+                xp = xp - _zsqrt2.One
+                yp = yp - _zsqrt2.One
+                return _zw.ZW.from_pair(xp.divide_by_sqrt2(), yp.divide_by_sqrt2(), True)
 
 
 ####### The operators {R, K, K^\bullet, A, B, X, Z, I, Sigma} * sqrt(2) ############
 
 
-RSqrt2 = GridOperator([[zsqrt2.One, -zsqrt2.One], [zsqrt2.One, zsqrt2.One]])
+RSqrt2 = GridOperator([[_zsqrt2.One, -_zsqrt2.One], [_zsqrt2.One, _zsqrt2.One]])
 
-KSqrt2 = GridOperator([[-zsqrt2.LAMBDA_INV, -zsqrt2.One], [zsqrt2.LAMBDA, zsqrt2.One]])
+KSqrt2 = GridOperator([[-_zsqrt2.LAMBDA_INV, -_zsqrt2.One], [_zsqrt2.LAMBDA, _zsqrt2.One]])
 
 KConjSqrt2 = GridOperator(
-    [[-zsqrt2.LAMBDA_INV.conj(), -zsqrt2.One], [zsqrt2.LAMBDA.conj(), zsqrt2.One]]
+    [[-_zsqrt2.LAMBDA_INV.conj(), -_zsqrt2.One], [_zsqrt2.LAMBDA.conj(), _zsqrt2.One]]
 )
 
-ASqrt2 = GridOperator(np.array([[zsqrt2.SQRT_2, -2 * zsqrt2.SQRT_2], [zsqrt2.Zero, zsqrt2.SQRT_2]]))
+ASqrt2 = GridOperator(
+    np.array([[_zsqrt2.SQRT_2, -2 * _zsqrt2.SQRT_2], [_zsqrt2.Zero, _zsqrt2.SQRT_2]])
+)
 
-BSqrt2 = GridOperator(np.array([[zsqrt2.SQRT_2, 2 * zsqrt2.One], [zsqrt2.Zero, zsqrt2.SQRT_2]]))
+BSqrt2 = GridOperator(np.array([[_zsqrt2.SQRT_2, 2 * _zsqrt2.One], [_zsqrt2.Zero, _zsqrt2.SQRT_2]]))
 
-XSqrt2 = GridOperator(np.array([[zsqrt2.Zero, zsqrt2.SQRT_2], [zsqrt2.SQRT_2, zsqrt2.Zero]]))
-ZSqrt2 = GridOperator(np.array([[zsqrt2.SQRT_2, zsqrt2.Zero], [zsqrt2.Zero, -zsqrt2.SQRT_2]]))
+XSqrt2 = GridOperator(np.array([[_zsqrt2.Zero, _zsqrt2.SQRT_2], [_zsqrt2.SQRT_2, _zsqrt2.Zero]]))
+ZSqrt2 = GridOperator(np.array([[_zsqrt2.SQRT_2, _zsqrt2.Zero], [_zsqrt2.Zero, -_zsqrt2.SQRT_2]]))
 
-ISqrt2 = GridOperator(np.array([[zsqrt2.SQRT_2, zsqrt2.Zero], [zsqrt2.Zero, zsqrt2.SQRT_2]]))
+ISqrt2 = GridOperator(np.array([[_zsqrt2.SQRT_2, _zsqrt2.Zero], [_zsqrt2.Zero, _zsqrt2.SQRT_2]]))
 
 HALF_SIGMA_Sqrt2 = GridOperator(
-    zsqrt2.SQRT_2 * np.array([[zsqrt2.LAMBDA, zsqrt2.Zero], [zsqrt2.Zero, zsqrt2.One]])
+    _zsqrt2.SQRT_2 * np.array([[_zsqrt2.LAMBDA, _zsqrt2.Zero], [_zsqrt2.Zero, _zsqrt2.One]])
 )
 
 HALF_SIGMA_INV_Sqrt2 = GridOperator(
-    zsqrt2.SQRT_2 * np.array([[zsqrt2.LAMBDA_INV, zsqrt2.Zero], [zsqrt2.Zero, zsqrt2.One]])
+    _zsqrt2.SQRT_2 * np.array([[_zsqrt2.LAMBDA_INV, _zsqrt2.Zero], [_zsqrt2.Zero, _zsqrt2.One]])
 )