lds

python/len_spec/__init__.py

@@ -48,37 +48,77 @@ def mcomplex_for_len_spec(
     c.normalize_cusps(areas)
 
     _scale_vertices(mcomplex)
+
+    # tet.R13_vertices    
 
     return mcomplex
 
-    # mcomplex.GeneratorMatrices # psl2c
-    # mcomplex.num_generators
-    # tet.R13_vertices
-
-    # mcomplex.R13_baseTetInCenter
-
-def compute_domain_tiles(mcomplex):
+def compute_domain_tiles(mcomplex,  verified):
 
     RF = mcomplex.baseTetInRadius.parent()
-
-    pending_lifted_domains : Sequence[_pending_lifted_domains] = []
-
-    heapq.heappush(
-        pending_lifted_domains,
-        _PendingLiftedDomain(
-            matrix.identity(RF, 4), [], RF(-2)))
-
+    if verified:
+        minus_infinity = RF(-sage.all.Infinity)
+    else:
+        minus_infinity = RF(-1e20)
+
+    initial_domain = _PendingLiftedDomain(
+        matrix.identity(4, RF),
+        [],
+        minus_infinity)
+    visited_lifted_domains[initial_domain] = [ True ]
+
+    pending_lifted_domains : Sequence[_PendingLiftedDomains] = []
     for i in range(mcomplex.num_generators):
         for g in [ (i + 1), -(i + 1) ]:
             heapq.heappush(
                 pending_lifted_domains,
                 _PendingLiftedDomain(
-                    m, word + [ g ], RF(0)))
-
-    min_inner_product = -(mcomplex.baseTetInRadius/2).cosh()
-    visited_lifted_domains = get_hyperboloid_dict(
-        min_inner_product, verified=verified)
+                    mcomplex.GeneratorMatrices[g], # Need o13 matrices
+                    [ g ],
+                    minus_infinity))
+
+    while True:
+        pending_lifted_domain : _PendingLiftedDomain = (
+            heapq.heappop(pending_lifted_domains))
+
+        if not visited_lifted_domains.add(pending_lifted_domain)
+            continue
+
+        yield pending_lifted_domain
+
+        for i in range(mcomplex.num_generators):
+            for g in [ (i + 1), -(i + 1) ]:
+                if g == -pending_lifted_domain.word[0]:
+                    continue
+
+                m = pending_lifted_domain.o13_matrices * mcomplex.GeneratorMatrices[g]
+                heapq.heappush(
+                    pending_lifted_domains,
+                    _PendingLiftedDomain(
+                        m,
+                        pending_lifted_domain + [ g ],
+                        compute_lower_bound_covered_radius(
+                            mcomplex, m)))
+
+class LiftedDomainSet:
+    """
+    Abstracting
 
+    
+    """
+    def __init__(self, mcomplex, verified):
+        min_inner_product = -(mcomplex.baseTetInRadius/2).cosh()
+        self.hyperboloid_dict = get_hyperboloid_dict(
+            min_inner_product, verified=verified)
+        self.base_point = mcomplex.R13_baseTetInCenter
+
+    def add(self, lifted_domain):
+        p = lifted_domain.o13_matrix * self.base_point
+        visited = self.hyperboloid_dict.setdefault(p)
+        if visited[0]:
+            return False
+        visited[0] = True
+        return True
 
 class _PendingLiftedDomain:
     def __init__(self,
@@ -93,3 +133,7 @@ def __init__(self,
 
     def __lt__(self, other):
         return self._key < other._key
+
+def compute_lower_bound_covered_radius(mcomplex, o13_matrix):
+
+    return 0