mapFolding 0.16.4__py3-none-any.whl → 0.17.1__py3-none-any.whl

mapFolding/someAssemblyRequired/toolkitMakeModules.py

@@ -31,18 +31,14 @@ improvements through just-in-time compilation, parallel execution, and optimized
 tailored for specific computational requirements essential to large-scale map folding research.
 """
 
-from astToolkit import (
-	Be, DOT, identifierDotAttribute, IngredientsFunction, NodeTourist, parseLogicalPath2astModule, Then)
-from autoflake import fix_code as autoflake_fix_code
-from hunterMakesPy import raiseIfNone, writeStringToHere
+from astToolkit import Be, DOT, identifierDotAttribute, NodeTourist, parseLogicalPath2astModule, Then
+from astToolkit.containers import IngredientsFunction
+from hunterMakesPy import raiseIfNone
 from mapFolding import packageSettings
 from mapFolding.someAssemblyRequired import default
 from os import PathLike
 from pathlib import PurePath
-from typing import Any
 import ast
-import io
-import isort
 
 def findDataclass(ingredientsFunction: IngredientsFunction) -> tuple[identifierDotAttribute, str, str]:
 	"""Dynamically extract information about a `dataclass`: the instance identifier, the identifier, and the logical path module.
@@ -128,25 +124,3 @@ def getPathFilename(pathRoot: PathLike[str] | PurePath | None = packageSettings.
 	if pathRoot:
 		pathFilename = PurePath(pathRoot, pathFilename)
 	return pathFilename
-
-def write_astModule(astModule: ast.Module, pathFilename: PathLike[Any] | PurePath | io.TextIOBase, packageName: str | None = None) -> None:
-	"""Prototype that will likely be moved to astToolkit.
-
-	Parameters
-	----------
-	astModule : ast.Module
-		The AST module to be written to a file.
-	pathFilename : PathLike[Any] | PurePath
-		The file path where the module should be written.
-	packageName : str | None = None
-		Optional package name to preserve in import optimization.
-	"""
-	ast.fix_missing_locations(astModule)
-	pythonSource: str = ast.unparse(astModule)
-	autoflake_additional_imports: list[str] = []
-	if packageName:
-		autoflake_additional_imports.append(packageName)
-	pythonSource = autoflake_fix_code(pythonSource, autoflake_additional_imports, expand_star_imports=False, remove_all_unused_imports=True, remove_duplicate_keys = False, remove_unused_variables = False)
-	pythonSource = isort.code(pythonSource)
-	writeStringToHere(pythonSource + '\n', pathFilename)
-

mapFolding/someAssemblyRequired/toolkitNumba.py

@@ -25,7 +25,8 @@ computational modules. The compilation layer integrates seamlessly with the broa
 system to produce standalone modules optimized for specific map dimensions and computational contexts.
 """
 
-from astToolkit import identifierDotAttribute, IngredientsFunction, Make
+from astToolkit import identifierDotAttribute, Make
+from astToolkit.containers import IngredientsFunction
 from collections.abc import Callable
 from numba.core.compiler import CompilerBase as numbaCompilerBase
 from typing import Any, Final, NotRequired, TYPE_CHECKING, TypedDict

mapFolding/someAssemblyRequired/transformationTools.py

@@ -25,9 +25,8 @@ This approach enables seamless integration between high-level dataclass-based in
 low-level optimized implementations, maintaining code clarity while achieving performance gains
 through specialized compilation paths essential for computationally intensive map folding research.
 """
-
-from astToolkit import (
-	Be, extractClassDef, identifierDotAttribute, IngredientsFunction, Make, NodeChanger, parseLogicalPath2astModule, Then)
+from astToolkit import Be, extractClassDef, identifierDotAttribute, Make, NodeChanger, parseLogicalPath2astModule, Then
+from astToolkit.containers import IngredientsFunction
 from astToolkit.transformationTools import unparseFindReplace
 from hunterMakesPy import importLogicalPath2Identifier
 from mapFolding.someAssemblyRequired import DeReConstructField2ast, IfThis, ShatteredDataclass

mapFolding/syntheticModules/A007822/algorithm.py

@@ -1,8 +1,5 @@
-import numpy
-
 from mapFolding.dataBaskets import SymmetricFoldsState
 
-
 def filterAsymmetricFolds(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.indexLeaf = 1
     state.leafComparison[0] = 1
@@ -12,10 +9,13 @@ def filterAsymmetricFolds(state: SymmetricFoldsState) -> SymmetricFoldsState:
         state.leafComparison[state.leafConnectee] = (state.indexMiniGap - state.indexLeaf + state.leavesTotal) % state.leavesTotal
         state.indexLeaf = state.indexMiniGap
         state.leafConnectee += 1
-    state.arrayGroupOfFolds = numpy.take(state.leafComparison, state.indicesArrayGroupOfFolds)
-    compared = state.arrayGroupOfFolds[..., 0:state.leavesTotal // 2] == state.arrayGroupOfFolds[..., state.leavesTotal // 2:None]
-    for indexRow in range(len(compared)):
-        state.groupsOfFolds += compared[indexRow].all()
+    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:
@@ -153,7 +153,7 @@ def count(state: SymmetricFoldsState) -> SymmetricFoldsState:
             state = undoLastLeafPlacement(state)
         if gapAvailable(state):
             state = insertActiveLeafAtGap(state)
-    state.groupsOfFolds = (state.groupsOfFolds + 1) // 2
+    state.symmetricFolds = (state.symmetricFolds + 1) // 2
     return state
 
 def doTheNeedful(state: SymmetricFoldsState) -> SymmetricFoldsState:

mapFolding/syntheticModules/A007822/asynchronous.py

@@ -1,11 +1,8 @@
 from copy import deepcopy
-from queue import Queue
-from threading import Lock, Thread
-
-import numpy
-
 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()
@@ -33,7 +30,7 @@ def _threadDoesSomething() -> None:
             break
         state = _filterAsymmetricFolds(state)
         with LOCKsymmetricFoldsTotal:
-            symmetricFoldsTotal += state.groupsOfFolds
+            symmetricFoldsTotal += state.symmetricFolds
 
 def filterAsymmetricFolds(state: SymmetricFoldsState) -> None:
     queueFutures.put_nowait(deepcopy(state))
@@ -54,11 +51,13 @@ def _filterAsymmetricFolds(state: SymmetricFoldsState) -> SymmetricFoldsState:
         state.leafComparison[state.leafConnectee] = (state.indexMiniGap - state.indexLeaf + state.leavesTotal) % state.leavesTotal
         state.indexLeaf = state.indexMiniGap
         state.leafConnectee += 1
-    state.arrayGroupOfFolds = numpy.take(state.leafComparison, state.indicesArrayGroupOfFolds)
-    state.indexMiniGap = 0
-    while state.indexMiniGap < len(state.arrayGroupOfFolds):
-        state.groupsOfFolds += int(numpy.all(numpy.equal(state.arrayGroupOfFolds[state.indexMiniGap, slice(0, state.leavesTotal // 2)], state.arrayGroupOfFolds[state.indexMiniGap, slice(state.leavesTotal // 2, None)])))
-        state.indexMiniGap += 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:
@@ -197,8 +196,8 @@ def count(state: SymmetricFoldsState) -> SymmetricFoldsState:
         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: SymmetricFoldsState, maxWorkers: int) -> SymmetricFoldsState:

mapFolding/syntheticModules/A007822/initializeState.py

@@ -1,8 +1,7 @@
 from mapFolding.dataBaskets import SymmetricFoldsState
-import numpy
 
 def transitionOnGroupsOfFolds(state: SymmetricFoldsState) -> SymmetricFoldsState:
-    while state.groupsOfFolds == 0:
+    while state.symmetricFolds == 0:
         if state.leaf1ndex <= 1 or state.leafBelow[0] == 1:
             if state.leaf1ndex > state.leavesTotal:
                 state.indexLeaf = 1
@@ -13,10 +12,13 @@ def transitionOnGroupsOfFolds(state: SymmetricFoldsState) -> SymmetricFoldsState
                     state.leafComparison[state.leafConnectee] = (state.indexMiniGap - state.indexLeaf + state.leavesTotal) % state.leavesTotal
                     state.indexLeaf = state.indexMiniGap
                     state.leafConnectee += 1
-                state.arrayGroupOfFolds = numpy.take(state.leafComparison, state.indicesArrayGroupOfFolds)
-                compared = state.arrayGroupOfFolds[..., 0:state.leavesTotal // 2] == state.arrayGroupOfFolds[..., state.leavesTotal // 2:None]
-                for indexRow in range(len(compared)):
-                    state.groupsOfFolds += compared[indexRow].all()
+                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
             else:
                 state.dimensionsUnconstrained = state.dimensionsTotal
                 state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
@@ -58,5 +60,5 @@ def transitionOnGroupsOfFolds(state: SymmetricFoldsState) -> SymmetricFoldsState
             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,6 +1,5 @@
 from mapFolding.dataBaskets import SymmetricFoldsState
 from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds
-import numpy
 
 def count(state: SymmetricFoldsState) -> SymmetricFoldsState:
     while state.leaf1ndex > 4:
@@ -14,10 +13,13 @@ def count(state: SymmetricFoldsState) -> SymmetricFoldsState:
                     state.leafComparison[state.leafConnectee] = (state.indexMiniGap - state.indexLeaf + state.leavesTotal) % state.leavesTotal
                     state.indexLeaf = state.indexMiniGap
                     state.leafConnectee += 1
-                state.arrayGroupOfFolds = numpy.take(state.leafComparison, state.indicesArrayGroupOfFolds)
-                compared = state.arrayGroupOfFolds[..., 0:state.leavesTotal // 2] == state.arrayGroupOfFolds[..., state.leavesTotal // 2:None]
-                for indexRow in range(len(compared)):
-                    state.groupsOfFolds += compared[indexRow].all()
+                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
             else:
                 state.dimensionsUnconstrained = state.dimensionsTotal
                 state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
@@ -59,11 +61,11 @@ def count(state: SymmetricFoldsState) -> SymmetricFoldsState:
         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: SymmetricFoldsState) -> SymmetricFoldsState:
     state = transitionOnGroupsOfFolds(state)
     state = count(state)
-    return state
+    return state

mapFolding/syntheticModules/A007822/theorem2Numba.py

@@ -1,10 +1,12 @@
-from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array2DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, SymmetricFoldsState
+from mapFolding.dataBaskets import (
+	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
+	SymmetricFoldsState)
 from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds
 from numba import jit
-import numpy
+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, arrayGroupOfFolds: Array2DLeavesTotal, connectionGraph: Array3DLeavesTotal, dimensionsTotal: DatatypeLeavesTotal, indicesArrayGroupOfFolds: Array2DLeavesTotal, leavesTotal: DatatypeLeavesTotal) -> tuple[DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, Array1DLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array2DLeavesTotal, Array3DLeavesTotal, DatatypeLeavesTotal, Array2DLeavesTotal, 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:
@@ -16,10 +18,13 @@ def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1nde
                     leafComparison[leafConnectee] = (indexMiniGap - indexLeaf + leavesTotal) % leavesTotal
                     indexLeaf = indexMiniGap
                     leafConnectee += 1
-                arrayGroupOfFolds = numpy.take(leafComparison, indicesArrayGroupOfFolds)
-                compared = arrayGroupOfFolds[..., 0:leavesTotal // 2] == arrayGroupOfFolds[..., leavesTotal // 2:None]
-                for indexRow in range(len(compared)):
-                    groupsOfFolds += compared[indexRow].all()
+                for listTuples in indices:
+                    leafConnectee = 1
+                    for indexLeft, indexRight in listTuples:
+                        if leafComparison[indexLeft] != leafComparison[indexRight]:
+                            leafConnectee = 0
+                            break
+                    symmetricFolds += leafConnectee
             else:
                 dimensionsUnconstrained = dimensionsTotal
                 gap1ndexCeiling = gapRangeStart[leaf1ndex - 1]
@@ -55,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, arrayGroupOfFolds, connectionGraph, dimensionsTotal, indicesArrayGroupOfFolds, 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: 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
@@ -77,11 +82,10 @@ def doTheNeedful(state: SymmetricFoldsState) -> SymmetricFoldsState:
     leafAbove: Array1DLeavesTotal = state.leafAbove
     leafBelow: Array1DLeavesTotal = state.leafBelow
     leafComparison: Array1DLeavesTotal = state.leafComparison
-    arrayGroupOfFolds: Array2DLeavesTotal = state.arrayGroupOfFolds
     connectionGraph: Array3DLeavesTotal = state.connectionGraph
     dimensionsTotal: DatatypeLeavesTotal = state.dimensionsTotal
-    indicesArrayGroupOfFolds: Array2DLeavesTotal = state.indicesArrayGroupOfFolds
+    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, arrayGroupOfFolds, connectionGraph, dimensionsTotal, indicesArrayGroupOfFolds, leavesTotal = count(groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, arrayGroupOfFolds, connectionGraph, dimensionsTotal, indicesArrayGroupOfFolds, leavesTotal)
-    state = SymmetricFoldsState(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
+    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,6 +1,5 @@
 from mapFolding.dataBaskets import SymmetricFoldsState
 from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds
-import numpy
 
 def count(state: SymmetricFoldsState) -> SymmetricFoldsState:
     while state.leaf1ndex > 4:
@@ -14,10 +13,13 @@ def count(state: SymmetricFoldsState) -> SymmetricFoldsState:
                     state.leafComparison[state.leafConnectee] = (state.indexMiniGap - state.indexLeaf + state.leavesTotal) % state.leavesTotal
                     state.indexLeaf = state.indexMiniGap
                     state.leafConnectee += 1
-                state.arrayGroupOfFolds = numpy.take(state.leafComparison, state.indicesArrayGroupOfFolds)
-                compared = state.arrayGroupOfFolds[..., 0:state.leavesTotal // 2] == state.arrayGroupOfFolds[..., state.leavesTotal // 2:None]
-                for indexRow in range(len(compared)):
-                    state.groupsOfFolds += compared[indexRow].all()
+                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
             else:
                 state.dimensionsUnconstrained = state.dimensionsTotal
                 state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
@@ -53,11 +55,11 @@ def count(state: SymmetricFoldsState) -> SymmetricFoldsState:
         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: SymmetricFoldsState) -> SymmetricFoldsState:
     state = transitionOnGroupsOfFolds(state)
     state = count(state)
-    return state
+    return state

mapFolding/syntheticModules/countParallelNumba.py

@@ -1,8 +1,11 @@
 from concurrent.futures import Future as ConcurrentFuture, ProcessPoolExecutor
 from copy import deepcopy
-from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, ParallelMapFoldingState
+from mapFolding.dataBaskets import (
+	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
+	ParallelMapFoldingState)
 from multiprocessing import set_start_method as multiprocessing_set_start_method
 from numba import jit
+
 if __name__ == '__main__':
     multiprocessing_set_start_method('spawn')
 
@@ -95,4 +98,4 @@ def doTheNeedful(state: ParallelMapFoldingState, concurrencyLimit: int) -> tuple
             listStatesParallel[indexSherpa] = dictionaryConcurrency[indexSherpa].result()
             groupsOfFoldsTotal += listStatesParallel[indexSherpa].groupsOfFolds
     foldsTotal: int = groupsOfFoldsTotal * stateParallel.leavesTotal
-    return (foldsTotal, listStatesParallel)
+    return (foldsTotal, listStatesParallel)

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)
@@ -71,4 +73,4 @@ def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
     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)
-    return state
+    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

mapFolding/syntheticModules/meanders/bigInt.py

@@ -1,7 +1,43 @@
-from mapFolding.algorithms.matrixMeandersBeDry import (areIntegersWide,
-                                                       walkDyckPath)
-from mapFolding.dataBaskets import MatrixMeandersNumPyState
+from functools import cache
+from mapFolding.algorithms.matrixMeandersNumPyndas import areIntegersWide, MatrixMeandersNumPyState
 
+@cache
+def walkDyckPath(intWithExtra_0b1: int) -> int:
+    """Find the bit position for flipping paired curve endpoints in meander transfer matrices.
+
+    Parameters
+    ----------
+    intWithExtra_0b1 : int
+        Binary representation of curve locations with an extra bit encoding parity information.
+
+    Returns
+    -------
+    flipExtra_0b1_Here : int
+        Bit mask indicating the position where the balance condition fails, formatted as 2^(2k).
+
+    3L33T H@X0R
+    ------------
+    Binary search for first negative balance in shifted bit pairs. Returns 2^(2k) mask for
+    bit position k where cumulative balance counter transitions from non-negative to negative.
+
+    Mathematics
+    -----------
+    Implements the Dyck path balance verification algorithm from Jensen's transfer matrix
+    enumeration. Computes the position where ∑(i=0 to k) (-1)^b_i < 0 for the first time,
+    where b_i are the bits of the input at positions 2i.
+
+    """
+    findTheExtra_0b1: int = 0
+    flipExtra_0b1_Here: int = 1
+    while True:
+        flipExtra_0b1_Here <<= 2
+        if intWithExtra_0b1 & flipExtra_0b1_Here == 0:
+            findTheExtra_0b1 += 1
+        else:
+            findTheExtra_0b1 -= 1
+        if findTheExtra_0b1 < 0:
+            break
+    return flipExtra_0b1_Here
 
 def countBigInt(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
     """Count meanders with matrix transfer algorithm using Python `int` (*int*eger) contained in a Python `dict` (*dict*ionary).
@@ -13,31 +49,31 @@ def countBigInt(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
 
     Notes
     -----
-    The matrix transfer algorithm is sophisticated, but this implementation is straightforward: compute each index one at a time,
-    compute each `arcCode` one at a time, and compute each type of analysis one at a time.
+    The matrix transfer algorithm is sophisticated, but this implementation is straightforward: compute each `boundary` one at a
+    time, compute each `arcCode` one at a time, and compute each type of analysis one at a time.
     """
     dictionaryArcCodeToCrossings: dict[int, int] = {}
     while state.boundary > 0 and areIntegersWide(state):
-        state.boundary -= 1
-        state.bitWidth = max(state.dictionaryMeanders.keys()).bit_length()
+        state.reduceBoundary()
         dictionaryArcCodeToCrossings = state.dictionaryMeanders.copy()
         state.dictionaryMeanders = {}
-        for arcCode, crossings in dictionaryArcCodeToCrossings.items():
-            bitsAlpha: int = arcCode & state.locatorBits
-            bitsZulu: int = arcCode >> 1 & state.locatorBits
+
+        def analyzeArcCode(arcCode: int, crossings: int) -> None:
+            bitsAlpha: int = arcCode & state.bitsLocator
             bitsAlphaHasArcs: bool = bitsAlpha > 1
-            bitsZuluHasArcs: bool = bitsZulu > 1
             bitsAlphaIsEven: int = bitsAlpha & 1 ^ 1
+            bitsZulu: int = arcCode >> 1 & state.bitsLocator
+            bitsZuluHasArcs: bool = bitsZulu > 1
             bitsZuluIsEven: int = bitsZulu & 1 ^ 1
-            arcCodeAnalysis = (bitsAlpha | bitsZulu << 1) << 2 | 3
+            arcCodeAnalysis: int = (bitsZulu << 1 | bitsAlpha) << 2 | 3
             if arcCodeAnalysis < state.MAXIMUMarcCode:
                 state.dictionaryMeanders[arcCodeAnalysis] = state.dictionaryMeanders.get(arcCodeAnalysis, 0) + crossings
             if bitsAlphaHasArcs:
-                arcCodeAnalysis = bitsAlpha >> 2 | bitsZulu << 3 | bitsAlphaIsEven << 1
+                arcCodeAnalysis = bitsAlphaIsEven << 1 | bitsAlpha >> 2 | bitsZulu << 3
                 if arcCodeAnalysis < state.MAXIMUMarcCode:
                     state.dictionaryMeanders[arcCodeAnalysis] = state.dictionaryMeanders.get(arcCodeAnalysis, 0) + crossings
             if bitsZuluHasArcs:
-                arcCodeAnalysis = bitsZulu >> 1 | bitsAlpha << 2 | bitsZuluIsEven
+                arcCodeAnalysis = bitsZuluIsEven | bitsAlpha << 2 | bitsZulu >> 1
                 if arcCodeAnalysis < state.MAXIMUMarcCode:
                     state.dictionaryMeanders[arcCodeAnalysis] = state.dictionaryMeanders.get(arcCodeAnalysis, 0) + crossings
             if bitsAlphaHasArcs and bitsZuluHasArcs and (bitsAlphaIsEven or bitsZuluIsEven):
@@ -45,8 +81,9 @@ def countBigInt(state: MatrixMeandersNumPyState) -> MatrixMeandersNumPyState:
                     bitsAlpha ^= walkDyckPath(bitsAlpha)
                 elif bitsZuluIsEven and (not bitsAlphaIsEven):
                     bitsZulu ^= walkDyckPath(bitsZulu)
-                arcCodeAnalysis: int = bitsZulu >> 2 << 1 | bitsAlpha >> 2
+                arcCodeAnalysis = (bitsZulu >> 2 << 3 | bitsAlpha) >> 2
                 if arcCodeAnalysis < state.MAXIMUMarcCode:
                     state.dictionaryMeanders[arcCodeAnalysis] = state.dictionaryMeanders.get(arcCodeAnalysis, 0) + crossings
+        set(map(analyzeArcCode, dictionaryArcCodeToCrossings.keys(), dictionaryArcCodeToCrossings.values()))
         dictionaryArcCodeToCrossings = {}
     return state

mapFolding/syntheticModules/theorem2.py

@@ -53,4 +53,4 @@ def count(state: MapFoldingState) -> MapFoldingState:
 def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
     state = transitionOnGroupsOfFolds(state)
     state = count(state)
-    return state
+    return state

mapFolding/syntheticModules/theorem2Numba.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 mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds
 from numba import jit
 
@@ -68,4 +70,4 @@ def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
     leavesTotal: DatatypeLeavesTotal = state.leavesTotal
     groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal = count(groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, 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)
-    return state
+    return state

mapFolding/syntheticModules/theorem2Trimmed.py

@@ -47,4 +47,4 @@ def count(state: MapFoldingState) -> MapFoldingState:
 def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
     state = transitionOnGroupsOfFolds(state)
     state = count(state)
-    return state
+    return state

mapFolding/tests/conftest.py

@@ -242,7 +242,7 @@ def mapShapeTestCountFolds(oeisIDmapFolding: str) -> tuple[int, ...]:
 		n = random.choice(dictionaryOEISMapFolding[oeisIDmapFolding]['valuesTestValidation'])
 		if n < 2:
 			continue
-		listDimensionsCandidate = list(dictionaryOEISMapFolding[oeisIDmapFolding]['getMapShape'](n))
+		listDimensionsCandidate: list[int] = list(dictionaryOEISMapFolding[oeisIDmapFolding]['getMapShape'](n))
 
 		try:
 			return validateListDimensions(listDimensionsCandidate)

mapFolding/tests/test_computations.py

@@ -25,17 +25,19 @@ The `test_writeJobNumba` function shows how to test dynamically generated code,
 which is useful if you're working with the code synthesis features of the package.
 """
 
-from mapFolding import countFolds, dictionaryOEIS, dictionaryOEISMapFolding, getFoldsTotalKnown, oeisIDfor_n
+from mapFolding import countFolds, dictionaryOEIS, dictionaryOEISMapFolding, eliminateFolds, getFoldsTotalKnown, oeisIDfor_n
 from mapFolding.basecamp import NOTcountingFolds
 from mapFolding.dataBaskets import MapFoldingState
 from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2
 from mapFolding.someAssemblyRequired.toolkitNumba import parametersNumbaLight
 from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds
-from mapFolding.tests.conftest import registrarRecordsTemporaryFilesystemObject, standardizedEqualToCallableReturn
+from mapFolding.tests.conftest import mapShapeTestCountFolds, registrarRecordsTemporaryFilesystemObject, standardizedEqualToCallableReturn
+from numba.core.errors import NumbaPendingDeprecationWarning
 from pathlib import Path, PurePosixPath
 import importlib.util
 import multiprocessing
 import pytest
+import warnings
 
 if __name__ == '__main__':
 	multiprocessing.set_start_method('spawn')
@@ -52,7 +54,7 @@ def test_A007822(flow: str) -> None:
 	"""
 	oeisID = 'A007822'
 	CPUlimit = .5
-
+	warnings.filterwarnings('ignore', category=NumbaPendingDeprecationWarning)
 	oeis_n = 2
 	for oeis_n in dictionaryOEIS[oeisID]['valuesTestValidation']:
 		if oeis_n < 2:
@@ -88,7 +90,22 @@ def test_countFolds(mapShapeTestCountFolds: tuple[int, ...], flow: str) -> None:
 	"""
 	standardizedEqualToCallableReturn(getFoldsTotalKnown(mapShapeTestCountFolds), countFolds, None, None, None, None, mapShapeTestCountFolds, flow)
 
-@pytest.mark.parametrize('flow', ['matrixNumPy', 'matrixPandas'])
+# @pytest.mark.parametrize('flow', ['constraintPropagation', 'elimination'])
+# def test_eliminateFolds(mapShapeTestParallelization: tuple[int, ...], flow: str) -> None:
+# 	"""Validate `eliminateFolds` and different flows produce valid results.
+
+# 	Parameters
+# 	----------
+# 	mapShapeTestCountFolds : tuple[int, ...]
+# 		The map shape dimensions to test fold counting for.
+# 	flow : str
+# 		The computational flow algorithm to validate.
+# 	"""
+# 	pathLikeWriteFoldsTotal: None = None
+# 	CPUlimit: bool | float | int | None = .25
+# 	standardizedEqualToCallableReturn(getFoldsTotalKnown(mapShapeTestParallelization), eliminateFolds, mapShapeTestParallelization, pathLikeWriteFoldsTotal, CPUlimit, flow)
+
+@pytest.mark.parametrize('flow', ['matrixMeanders', 'matrixNumPy', 'matrixPandas'])
 def test_meanders(oeisIDmeanders: str, flow: str) -> None:
 	"""Verify Meanders OEIS sequence value calculations against known reference values.