mapFolding 0.16.2__py3-none-any.whl → 0.17.0__py3-none-any.whl

mapFolding/syntheticModules/A007822/asynchronous.py

@@ -1,58 +1,114 @@
-from mapFolding.dataBaskets import MapFoldingState
-from mapFolding.syntheticModules.A007822.asynchronousAnnex import (
-    filterAsymmetricFolds, getSymmetricFoldsTotal,
-    initializeConcurrencyManager)
-
-
-def activeLeafGreaterThan0(state: MapFoldingState) -> bool:
+from copy import deepcopy
+from mapFolding import DatatypeFoldsTotal
+from mapFolding.dataBaskets import SymmetricFoldsState
+from queue import Queue
+from threading import Lock, Thread
+
+listThreads: list[Thread] = []
+queueFutures: Queue[SymmetricFoldsState] = Queue()
+symmetricFoldsTotal: int = 0
+LOCKsymmetricFoldsTotal = Lock()
+STOPsignal = object()
+
+def initializeConcurrencyManager(maxWorkers: int, symmetricFolds: int=0) -> None:
+    global listThreads, symmetricFoldsTotal, queueFutures
+    listThreads = []
+    queueFutures = Queue()
+    symmetricFoldsTotal = symmetricFolds
+    indexThread = 0
+    while indexThread < maxWorkers:
+        thread = Thread(target=_threadDoesSomething, name=f'thread{indexThread}', daemon=True)
+        thread.start()
+        listThreads.append(thread)
+        indexThread += 1
+
+def _threadDoesSomething() -> None:
+    global symmetricFoldsTotal
+    while True:
+        state = queueFutures.get()
+        if state is STOPsignal:
+            break
+        state = _filterAsymmetricFolds(state)
+        with LOCKsymmetricFoldsTotal:
+            symmetricFoldsTotal += state.symmetricFolds
+
+def filterAsymmetricFolds(state: SymmetricFoldsState) -> None:
+    queueFutures.put_nowait(deepcopy(state))
+
+def getSymmetricFoldsTotal() -> DatatypeFoldsTotal:
+    for _thread in listThreads:
+        queueFutures.put(STOPsignal)
+    for thread in listThreads:
+        thread.join()
+    return symmetricFoldsTotal
+
+def _filterAsymmetricFolds(state: SymmetricFoldsState) -> SymmetricFoldsState:
+    state.indexLeaf = 1
+    state.leafComparison[0] = 1
+    state.leafConnectee = 1
+    while state.leafConnectee < state.leavesTotal + 1:
+        state.indexMiniGap = state.leafBelow[state.indexLeaf]
+        state.leafComparison[state.leafConnectee] = (state.indexMiniGap - state.indexLeaf + state.leavesTotal) % state.leavesTotal
+        state.indexLeaf = state.indexMiniGap
+        state.leafConnectee += 1
+    for listTuples in state.indices:
+        state.leafConnectee = 1
+        for indexLeft, indexRight in listTuples:
+            if state.leafComparison[indexLeft] != state.leafComparison[indexRight]:
+                state.leafConnectee = 0
+                break
+        state.symmetricFolds += state.leafConnectee
+    return state
+
+def activeLeafGreaterThan0(state: SymmetricFoldsState) -> bool:
     return state.leaf1ndex > 0
 
-def activeLeafGreaterThanLeavesTotal(state: MapFoldingState) -> bool:
+def activeLeafGreaterThanLeavesTotal(state: SymmetricFoldsState) -> bool:
     return state.leaf1ndex > state.leavesTotal
 
-def activeLeafIsTheFirstLeaf(state: MapFoldingState) -> bool:
+def activeLeafIsTheFirstLeaf(state: SymmetricFoldsState) -> bool:
     return state.leaf1ndex <= 1
 
-def activeLeafIsUnconstrainedInAllDimensions(state: MapFoldingState) -> bool:
+def activeLeafIsUnconstrainedInAllDimensions(state: SymmetricFoldsState) -> bool:
     return not state.dimensionsUnconstrained
 
-def activeLeafUnconstrainedInThisDimension(state: MapFoldingState) -> MapFoldingState:
+def activeLeafUnconstrainedInThisDimension(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.dimensionsUnconstrained -= 1
     return state
 
-def filterCommonGaps(state: MapFoldingState) -> MapFoldingState:
+def filterCommonGaps(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.gapsWhere[state.gap1ndex] = state.gapsWhere[state.indexMiniGap]
     if state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] == state.dimensionsUnconstrained:
         state = incrementActiveGap(state)
     state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] = 0
     return state
 
-def gapAvailable(state: MapFoldingState) -> bool:
+def gapAvailable(state: SymmetricFoldsState) -> bool:
     return state.leaf1ndex > 0
 
-def incrementActiveGap(state: MapFoldingState) -> MapFoldingState:
+def incrementActiveGap(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.gap1ndex += 1
     return state
 
-def incrementGap1ndexCeiling(state: MapFoldingState) -> MapFoldingState:
+def incrementGap1ndexCeiling(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.gap1ndexCeiling += 1
     return state
 
-def incrementIndexMiniGap(state: MapFoldingState) -> MapFoldingState:
+def incrementIndexMiniGap(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.indexMiniGap += 1
     return state
 
-def initializeIndexMiniGap(state: MapFoldingState) -> MapFoldingState:
+def initializeIndexMiniGap(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.indexMiniGap = state.gap1ndex
     return state
 
-def initializeVariablesToFindGaps(state: MapFoldingState) -> MapFoldingState:
+def initializeVariablesToFindGaps(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.dimensionsUnconstrained = state.dimensionsTotal
     state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
     state.indexDimension = 0
     return state
 
-def insertActiveLeaf(state: MapFoldingState) -> MapFoldingState:
+def insertActiveLeaf(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.indexLeaf = 0
     while state.indexLeaf < state.leaf1ndex:
         state.gapsWhere[state.gap1ndexCeiling] = state.indexLeaf
@@ -60,7 +116,7 @@ def insertActiveLeaf(state: MapFoldingState) -> MapFoldingState:
         state.indexLeaf += 1
     return state
 
-def insertActiveLeafAtGap(state: MapFoldingState) -> MapFoldingState:
+def insertActiveLeafAtGap(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.gap1ndex -= 1
     state.leafAbove[state.leaf1ndex] = state.gapsWhere[state.gap1ndex]
     state.leafBelow[state.leaf1ndex] = state.leafBelow[state.leafAbove[state.leaf1ndex]]
@@ -70,54 +126,54 @@ def insertActiveLeafAtGap(state: MapFoldingState) -> MapFoldingState:
     state.leaf1ndex += 1
     return state
 
-def leafBelowSentinelIs1(state: MapFoldingState) -> bool:
+def leafBelowSentinelIs1(state: SymmetricFoldsState) -> bool:
     return state.leafBelow[0] == 1
 
-def leafConnecteeIsActiveLeaf(state: MapFoldingState) -> bool:
+def leafConnecteeIsActiveLeaf(state: SymmetricFoldsState) -> bool:
     return state.leafConnectee == state.leaf1ndex
 
-def lookForGaps(state: MapFoldingState) -> MapFoldingState:
+def lookForGaps(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.gapsWhere[state.gap1ndexCeiling] = state.leafConnectee
     if state.countDimensionsGapped[state.leafConnectee] == 0:
         state = incrementGap1ndexCeiling(state)
     state.countDimensionsGapped[state.leafConnectee] += 1
     return state
 
-def lookupLeafConnecteeInConnectionGraph(state: MapFoldingState) -> MapFoldingState:
+def lookupLeafConnecteeInConnectionGraph(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex]
     return state
 
-def loopingLeavesConnectedToActiveLeaf(state: MapFoldingState) -> bool:
+def loopingLeavesConnectedToActiveLeaf(state: SymmetricFoldsState) -> bool:
     return state.leafConnectee != state.leaf1ndex
 
-def loopingThroughTheDimensions(state: MapFoldingState) -> bool:
+def loopingThroughTheDimensions(state: SymmetricFoldsState) -> bool:
     return state.indexDimension < state.dimensionsTotal
 
-def loopingToActiveGapCeiling(state: MapFoldingState) -> bool:
+def loopingToActiveGapCeiling(state: SymmetricFoldsState) -> bool:
     return state.indexMiniGap < state.gap1ndexCeiling
 
-def noGapsHere(state: MapFoldingState) -> bool:
+def noGapsHere(state: SymmetricFoldsState) -> bool:
     return state.leaf1ndex > 0 and state.gap1ndex == state.gapRangeStart[state.leaf1ndex - 1]
 
-def tryAnotherLeafConnectee(state: MapFoldingState) -> MapFoldingState:
+def tryAnotherLeafConnectee(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leafBelow[state.leafConnectee]]
     return state
 
-def tryNextDimension(state: MapFoldingState) -> MapFoldingState:
+def tryNextDimension(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.indexDimension += 1
     return state
 
-def undoLastLeafPlacement(state: MapFoldingState) -> MapFoldingState:
+def undoLastLeafPlacement(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.leaf1ndex -= 1
     state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leafBelow[state.leaf1ndex]
     state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leafAbove[state.leaf1ndex]
     return state
 
-def count(state: MapFoldingState) -> MapFoldingState:
+def count(state: SymmetricFoldsState) -> SymmetricFoldsState:
     while activeLeafGreaterThan0(state):
         if activeLeafIsTheFirstLeaf(state) or leafBelowSentinelIs1(state):
             if activeLeafGreaterThanLeavesTotal(state):
-                filterAsymmetricFolds(state.leafBelow)
+                filterAsymmetricFolds(state)
             else:
                 state = initializeVariablesToFindGaps(state)
                 while loopingThroughTheDimensions(state):
@@ -140,11 +196,11 @@ def count(state: MapFoldingState) -> MapFoldingState:
         if gapAvailable(state):
             state = insertActiveLeafAtGap(state)
     else:
-        state.groupsOfFolds = getSymmetricFoldsTotal()
-    state.groupsOfFolds = (state.groupsOfFolds + 1) // 2
+        state.symmetricFolds = getSymmetricFoldsTotal()
+    state.symmetricFolds = (state.symmetricFolds + 1) // 2
     return state
 
-def doTheNeedful(state: MapFoldingState, maxWorkers: int | None=None) -> MapFoldingState:
+def doTheNeedful(state: SymmetricFoldsState, maxWorkers: int) -> SymmetricFoldsState:
     initializeConcurrencyManager(maxWorkers)
     state = count(state)
     return state

mapFolding/syntheticModules/A007822/initializeState.py

@@ -1,28 +1,24 @@
-from mapFolding.dataBaskets import MapFoldingState
+from mapFolding.dataBaskets import SymmetricFoldsState
 
-def transitionOnGroupsOfFolds(state: MapFoldingState) -> MapFoldingState:
-    while state.groupsOfFolds == 0:
+def transitionOnGroupsOfFolds(state: SymmetricFoldsState) -> SymmetricFoldsState:
+    while state.symmetricFolds == 0:
         if state.leaf1ndex <= 1 or state.leafBelow[0] == 1:
             if state.leaf1ndex > state.leavesTotal:
-                state.indexLeaf = 0
-                leafConnectee = 0
-                while leafConnectee < state.leavesTotal + 1:
-                    leafNumber = int(state.leafBelow[state.indexLeaf])
-                    state.leafComparison[leafConnectee] = (leafNumber - state.indexLeaf + state.leavesTotal) % state.leavesTotal
-                    state.indexLeaf = leafNumber
-                    leafConnectee += 1
-                indexInMiddle = state.leavesTotal // 2
-                state.indexMiniGap = 0
-                while state.indexMiniGap < state.leavesTotal + 1:
-                    ImaSymmetricFold = True
-                    leafConnectee = 0
-                    while leafConnectee < indexInMiddle:
-                        if state.leafComparison[(state.indexMiniGap + leafConnectee) % (state.leavesTotal + 1)] != state.leafComparison[(state.indexMiniGap + state.leavesTotal - 1 - leafConnectee) % (state.leavesTotal + 1)]:
-                            ImaSymmetricFold = False
+                state.indexLeaf = 1
+                state.leafComparison[0] = 1
+                state.leafConnectee = 1
+                while state.leafConnectee < state.leavesTotal + 1:
+                    state.indexMiniGap = state.leafBelow[state.indexLeaf]
+                    state.leafComparison[state.leafConnectee] = (state.indexMiniGap - state.indexLeaf + state.leavesTotal) % state.leavesTotal
+                    state.indexLeaf = state.indexMiniGap
+                    state.leafConnectee += 1
+                for listTuples in state.indices:
+                    state.leafConnectee = 1
+                    for indexLeft, indexRight in listTuples:
+                        if state.leafComparison[indexLeft] != state.leafComparison[indexRight]:
+                            state.leafConnectee = 0
                             break
-                        leafConnectee += 1
-                    state.groupsOfFolds += ImaSymmetricFold
-                    state.indexMiniGap += 1
+                    state.symmetricFolds += state.leafConnectee
             else:
                 state.dimensionsUnconstrained = state.dimensionsTotal
                 state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
@@ -64,5 +60,5 @@ def transitionOnGroupsOfFolds(state: MapFoldingState) -> MapFoldingState:
             state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leaf1ndex
             state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
             state.leaf1ndex += 1
-    state.groupsOfFolds = (state.groupsOfFolds + 1) // 2
-    return state
+    state.symmetricFolds = (state.symmetricFolds + 1) // 2
+    return state

mapFolding/syntheticModules/A007822/theorem2.py

@@ -1,29 +1,25 @@
-from mapFolding.dataBaskets import MapFoldingState
+from mapFolding.dataBaskets import SymmetricFoldsState
 from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds
 
-def count(state: MapFoldingState) -> MapFoldingState:
+def count(state: SymmetricFoldsState) -> SymmetricFoldsState:
     while state.leaf1ndex > 4:
         if state.leafBelow[0] == 1:
             if state.leaf1ndex > state.leavesTotal:
-                state.indexLeaf = 0
-                leafConnectee = 0
-                while leafConnectee < state.leavesTotal + 1:
-                    leafNumber = int(state.leafBelow[state.indexLeaf])
-                    state.leafComparison[leafConnectee] = (leafNumber - state.indexLeaf + state.leavesTotal) % state.leavesTotal
-                    state.indexLeaf = leafNumber
-                    leafConnectee += 1
-                indexInMiddle = state.leavesTotal // 2
-                state.indexMiniGap = 0
-                while state.indexMiniGap < state.leavesTotal + 1:
-                    ImaSymmetricFold = True
-                    leafConnectee = 0
-                    while leafConnectee < indexInMiddle:
-                        if state.leafComparison[(state.indexMiniGap + leafConnectee) % (state.leavesTotal + 1)] != state.leafComparison[(state.indexMiniGap + state.leavesTotal - 1 - leafConnectee) % (state.leavesTotal + 1)]:
-                            ImaSymmetricFold = False
+                state.indexLeaf = 1
+                state.leafComparison[0] = 1
+                state.leafConnectee = 1
+                while state.leafConnectee < state.leavesTotal + 1:
+                    state.indexMiniGap = state.leafBelow[state.indexLeaf]
+                    state.leafComparison[state.leafConnectee] = (state.indexMiniGap - state.indexLeaf + state.leavesTotal) % state.leavesTotal
+                    state.indexLeaf = state.indexMiniGap
+                    state.leafConnectee += 1
+                for listTuples in state.indices:
+                    state.leafConnectee = 1
+                    for indexLeft, indexRight in listTuples:
+                        if state.leafComparison[indexLeft] != state.leafComparison[indexRight]:
+                            state.leafConnectee = 0
                             break
-                        leafConnectee += 1
-                    state.groupsOfFolds += ImaSymmetricFold
-                    state.indexMiniGap += 1
+                    state.symmetricFolds += state.leafConnectee
             else:
                 state.dimensionsUnconstrained = state.dimensionsTotal
                 state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
@@ -65,11 +61,11 @@ def count(state: MapFoldingState) -> MapFoldingState:
         state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
         state.leaf1ndex += 1
     else:
-        state.groupsOfFolds *= 2
-    state.groupsOfFolds = (state.groupsOfFolds + 1) // 2
+        state.symmetricFolds *= 2
+    state.symmetricFolds = (state.symmetricFolds + 1) // 2
     return state
 
-def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
+def doTheNeedful(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state = transitionOnGroupsOfFolds(state)
     state = count(state)
-    return state
+    return state

mapFolding/syntheticModules/A007822/theorem2Numba.py

@@ -1,33 +1,30 @@
 from mapFolding.dataBaskets import (
 	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
-	MapFoldingState)
+	SymmetricFoldsState)
 from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds
 from numba import jit
+from numba.typed import List
 
 @jit(cache=True, error_model='numpy', fastmath=True, forceinline=True)
-def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1ndexCeiling: DatatypeElephino, indexDimension: DatatypeLeavesTotal, indexLeaf: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeLeavesTotal, leafConnectee: DatatypeLeavesTotal, dimensionsUnconstrained: DatatypeLeavesTotal, countDimensionsGapped: Array1DLeavesTotal, gapRangeStart: Array1DElephino, gapsWhere: Array1DLeavesTotal, leafAbove: Array1DLeavesTotal, leafBelow: Array1DLeavesTotal, leafComparison: Array1DLeavesTotal, connectionGraph: Array3DLeavesTotal, dimensionsTotal: DatatypeLeavesTotal, leavesTotal: DatatypeLeavesTotal) -> tuple[DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, Array1DLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal]:
+def count(symmetricFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1ndexCeiling: DatatypeElephino, indexDimension: DatatypeLeavesTotal, indexLeaf: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeLeavesTotal, leafConnectee: DatatypeLeavesTotal, dimensionsUnconstrained: DatatypeLeavesTotal, countDimensionsGapped: Array1DLeavesTotal, gapRangeStart: Array1DElephino, gapsWhere: Array1DLeavesTotal, leafAbove: Array1DLeavesTotal, leafBelow: Array1DLeavesTotal, leafComparison: Array1DLeavesTotal, connectionGraph: Array3DLeavesTotal, dimensionsTotal: DatatypeLeavesTotal, indices: list[list[tuple[int, int]]], leavesTotal: DatatypeLeavesTotal) -> tuple[DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, Array1DLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeLeavesTotal, list[list[tuple[int, int]]], DatatypeLeavesTotal]:
     while leaf1ndex > 4:
         if leafBelow[0] == 1:
             if leaf1ndex > leavesTotal:
-                indexLeaf = 0
-                leafConnectee = 0
+                indexLeaf = 1
+                leafComparison[0] = 1
+                leafConnectee = 1
                 while leafConnectee < leavesTotal + 1:
-                    leafNumber = int(leafBelow[indexLeaf])
-                    leafComparison[leafConnectee] = (leafNumber - indexLeaf + leavesTotal) % leavesTotal
-                    indexLeaf = leafNumber
+                    indexMiniGap = leafBelow[indexLeaf]
+                    leafComparison[leafConnectee] = (indexMiniGap - indexLeaf + leavesTotal) % leavesTotal
+                    indexLeaf = indexMiniGap
                     leafConnectee += 1
-                indexInMiddle = leavesTotal // 2
-                indexMiniGap = 0
-                while indexMiniGap < leavesTotal + 1:
-                    ImaSymmetricFold = True
-                    leafConnectee = 0
-                    while leafConnectee < indexInMiddle:
-                        if leafComparison[(indexMiniGap + leafConnectee) % (leavesTotal + 1)] != leafComparison[(indexMiniGap + leavesTotal - 1 - leafConnectee) % (leavesTotal + 1)]:
-                            ImaSymmetricFold = False
+                for listTuples in indices:
+                    leafConnectee = 1
+                    for indexLeft, indexRight in listTuples:
+                        if leafComparison[indexLeft] != leafComparison[indexRight]:
+                            leafConnectee = 0
                             break
-                        leafConnectee += 1
-                    groupsOfFolds += ImaSymmetricFold
-                    indexMiniGap += 1
+                    symmetricFolds += leafConnectee
             else:
                 dimensionsUnconstrained = dimensionsTotal
                 gap1ndexCeiling = gapRangeStart[leaf1ndex - 1]
@@ -63,14 +60,14 @@ def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1nde
         gapRangeStart[leaf1ndex] = gap1ndex
         leaf1ndex += 1
     else:
-        groupsOfFolds *= 2
-    groupsOfFolds = (groupsOfFolds + 1) // 2
-    return (groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, connectionGraph, dimensionsTotal, leavesTotal)
+        symmetricFolds *= 2
+    symmetricFolds = (symmetricFolds + 1) // 2
+    return (symmetricFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, connectionGraph, dimensionsTotal, indices, leavesTotal)
 
-def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
+def doTheNeedful(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state = transitionOnGroupsOfFolds(state)
     mapShape: tuple[DatatypeLeavesTotal, ...] = state.mapShape
-    groupsOfFolds: DatatypeFoldsTotal = state.groupsOfFolds
+    symmetricFolds: DatatypeFoldsTotal = state.symmetricFolds
     gap1ndex: DatatypeElephino = state.gap1ndex
     gap1ndexCeiling: DatatypeElephino = state.gap1ndexCeiling
     indexDimension: DatatypeLeavesTotal = state.indexDimension
@@ -87,7 +84,8 @@ def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
     leafComparison: Array1DLeavesTotal = state.leafComparison
     connectionGraph: Array3DLeavesTotal = state.connectionGraph
     dimensionsTotal: DatatypeLeavesTotal = state.dimensionsTotal
+    indices: list[list[tuple[int, int]]] = List(state.indices)
     leavesTotal: DatatypeLeavesTotal = state.leavesTotal
-    groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, connectionGraph, dimensionsTotal, leavesTotal = count(groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, connectionGraph, dimensionsTotal, leavesTotal)
-    state = MapFoldingState(mapShape=mapShape, groupsOfFolds=groupsOfFolds, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, dimensionsUnconstrained=dimensionsUnconstrained, countDimensionsGapped=countDimensionsGapped, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow, leafComparison=leafComparison)
+    symmetricFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, connectionGraph, dimensionsTotal, indices, leavesTotal = count(symmetricFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, connectionGraph, dimensionsTotal, indices, leavesTotal)
+    state = SymmetricFoldsState(mapShape=mapShape, symmetricFolds=symmetricFolds, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, dimensionsUnconstrained=dimensionsUnconstrained, countDimensionsGapped=countDimensionsGapped, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow, leafComparison=leafComparison)
     return state

mapFolding/syntheticModules/A007822/theorem2Trimmed.py

@@ -1,29 +1,25 @@
-from mapFolding.dataBaskets import MapFoldingState
+from mapFolding.dataBaskets import SymmetricFoldsState
 from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds
 
-def count(state: MapFoldingState) -> MapFoldingState:
+def count(state: SymmetricFoldsState) -> SymmetricFoldsState:
     while state.leaf1ndex > 4:
         if state.leafBelow[0] == 1:
             if state.leaf1ndex > state.leavesTotal:
-                state.indexLeaf = 0
-                leafConnectee = 0
-                while leafConnectee < state.leavesTotal + 1:
-                    leafNumber = int(state.leafBelow[state.indexLeaf])
-                    state.leafComparison[leafConnectee] = (leafNumber - state.indexLeaf + state.leavesTotal) % state.leavesTotal
-                    state.indexLeaf = leafNumber
-                    leafConnectee += 1
-                indexInMiddle = state.leavesTotal // 2
-                state.indexMiniGap = 0
-                while state.indexMiniGap < state.leavesTotal + 1:
-                    ImaSymmetricFold = True
-                    leafConnectee = 0
-                    while leafConnectee < indexInMiddle:
-                        if state.leafComparison[(state.indexMiniGap + leafConnectee) % (state.leavesTotal + 1)] != state.leafComparison[(state.indexMiniGap + state.leavesTotal - 1 - leafConnectee) % (state.leavesTotal + 1)]:
-                            ImaSymmetricFold = False
+                state.indexLeaf = 1
+                state.leafComparison[0] = 1
+                state.leafConnectee = 1
+                while state.leafConnectee < state.leavesTotal + 1:
+                    state.indexMiniGap = state.leafBelow[state.indexLeaf]
+                    state.leafComparison[state.leafConnectee] = (state.indexMiniGap - state.indexLeaf + state.leavesTotal) % state.leavesTotal
+                    state.indexLeaf = state.indexMiniGap
+                    state.leafConnectee += 1
+                for listTuples in state.indices:
+                    state.leafConnectee = 1
+                    for indexLeft, indexRight in listTuples:
+                        if state.leafComparison[indexLeft] != state.leafComparison[indexRight]:
+                            state.leafConnectee = 0
                             break
-                        leafConnectee += 1
-                    state.groupsOfFolds += ImaSymmetricFold
-                    state.indexMiniGap += 1
+                    state.symmetricFolds += state.leafConnectee
             else:
                 state.dimensionsUnconstrained = state.dimensionsTotal
                 state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
@@ -59,11 +55,11 @@ def count(state: MapFoldingState) -> MapFoldingState:
         state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
         state.leaf1ndex += 1
     else:
-        state.groupsOfFolds *= 2
-    state.groupsOfFolds = (state.groupsOfFolds + 1) // 2
+        state.symmetricFolds *= 2
+    state.symmetricFolds = (state.symmetricFolds + 1) // 2
     return state
 
-def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
+def doTheNeedful(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state = transitionOnGroupsOfFolds(state)
     state = count(state)
     return state

mapFolding/syntheticModules/countParallelNumba.py

@@ -75,14 +75,13 @@ def unRepackParallelMapFoldingState(state: ParallelMapFoldingState) -> ParallelM
     gapsWhere: Array1DLeavesTotal = state.gapsWhere
     leafAbove: Array1DLeavesTotal = state.leafAbove
     leafBelow: Array1DLeavesTotal = state.leafBelow
-    leafComparison: Array1DLeavesTotal = state.leafComparison
     connectionGraph: Array3DLeavesTotal = state.connectionGraph
     dimensionsTotal: DatatypeLeavesTotal = state.dimensionsTotal
     leavesTotal: DatatypeLeavesTotal = state.leavesTotal
     taskDivisions: DatatypeLeavesTotal = state.taskDivisions
     taskIndex: DatatypeLeavesTotal = state.taskIndex
     groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal, taskDivisions, taskIndex = count(groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal, taskDivisions, taskIndex)
-    state = ParallelMapFoldingState(mapShape=mapShape, groupsOfFolds=groupsOfFolds, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, dimensionsUnconstrained=dimensionsUnconstrained, countDimensionsGapped=countDimensionsGapped, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow, leafComparison=leafComparison, taskDivisions=taskDivisions, taskIndex=taskIndex)
+    state = ParallelMapFoldingState(mapShape=mapShape, groupsOfFolds=groupsOfFolds, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, dimensionsUnconstrained=dimensionsUnconstrained, countDimensionsGapped=countDimensionsGapped, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow, taskDivisions=taskDivisions, taskIndex=taskIndex)
     return state
 
 def doTheNeedful(state: ParallelMapFoldingState, concurrencyLimit: int) -> tuple[int, list[ParallelMapFoldingState]]:

mapFolding/syntheticModules/daoOfMapFoldingNumba.py

@@ -1,4 +1,6 @@
-from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, MapFoldingState
+from mapFolding.dataBaskets import (
+	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
+	MapFoldingState)
 from numba import jit
 
 @jit(cache=True, error_model='numpy', fastmath=True, forceinline=True)
@@ -66,10 +68,9 @@ def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
     gapsWhere: Array1DLeavesTotal = state.gapsWhere
     leafAbove: Array1DLeavesTotal = state.leafAbove
     leafBelow: Array1DLeavesTotal = state.leafBelow
-    leafComparison: Array1DLeavesTotal = state.leafComparison
     connectionGraph: Array3DLeavesTotal = state.connectionGraph
     dimensionsTotal: DatatypeLeavesTotal = state.dimensionsTotal
     leavesTotal: DatatypeLeavesTotal = state.leavesTotal
     groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal = count(groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal)
-    state = MapFoldingState(mapShape=mapShape, groupsOfFolds=groupsOfFolds, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, dimensionsUnconstrained=dimensionsUnconstrained, countDimensionsGapped=countDimensionsGapped, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow, leafComparison=leafComparison)
-    return state
+    state = MapFoldingState(mapShape=mapShape, groupsOfFolds=groupsOfFolds, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, dimensionsUnconstrained=dimensionsUnconstrained, countDimensionsGapped=countDimensionsGapped, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow)
+    return state

mapFolding/syntheticModules/initializeState.py

@@ -46,4 +46,4 @@ def transitionOnGroupsOfFolds(state: MapFoldingState) -> MapFoldingState:
             state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leaf1ndex
             state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
             state.leaf1ndex += 1
-    return state
+    return state