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

mapFolding/algorithms/symmetricFolds.py

@@ -3,34 +3,33 @@
 Notes
 -----
 - About constructing `leafComparison`:
-    - This branch of the algorithm executes IFF `leafBelow[0] == 1`.
-    - Therefore, `leafComparison[0]` must be `1`.
-    - Therefore, the first iteration of the loop is hardcoded to save processing time.
-    - I _feel_ there must be a more efficient way to do this.
+	- The first iteration of the loop is hardcoded to save processing time.
+	- I _feel_ there must be a more efficient way to do this.
 - Some implementation details are based on Numba compatibility. Incompatible:
-    - `numpy.take(..., out=...)`
-    - `numpy.all(..., axis=...)`
+	- `numpy.take(..., out=...)`
+	- `numpy.all(..., axis=...)`
 """
 from mapFolding.dataBaskets import SymmetricFoldsState
-import numpy
 
 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
-
-    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()
-
-    return state
+	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
 

mapFolding/basecamp.py

@@ -174,13 +174,15 @@ def countFolds(listDimensions: Sequence[int] | None = None
 
 # ruff: noqa: E701
 	else:
-		match flow:
-			case 'daoOfMapFolding': from mapFolding.algorithms.daoOfMapFolding import doTheNeedful
-			case 'numba': from mapFolding.syntheticModules.daoOfMapFoldingNumba import doTheNeedful
-			case 'theorem2': from mapFolding.syntheticModules.theorem2 import doTheNeedful
-			case 'theorem2Numba': from mapFolding.syntheticModules.theorem2Numba import doTheNeedful
-			case 'theorem2Trimmed': from mapFolding.syntheticModules.theorem2Trimmed import doTheNeedful
-			case _: from mapFolding.algorithms.daoOfMapFolding import doTheNeedful
+		if all(dimension < 3 for dimension in mapShape):
+			from mapFolding.algorithms.daoOfMapFolding import doTheNeedful
+		else:
+			match flow:
+				case 'numba': from mapFolding.syntheticModules.daoOfMapFoldingNumba import doTheNeedful
+				case 'theorem2': from mapFolding.syntheticModules.theorem2 import doTheNeedful
+				case 'theorem2Numba': from mapFolding.syntheticModules.theorem2Numba import doTheNeedful
+				case 'theorem2Trimmed': from mapFolding.syntheticModules.theorem2Trimmed import doTheNeedful
+				case 'daoOfMapFolding' | _: from mapFolding.algorithms.daoOfMapFolding import doTheNeedful
 
 		from mapFolding.dataBaskets import MapFoldingState
 		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
@@ -203,7 +205,6 @@ def NOTcountingFolds(oeisID: str, oeis_n: int, flow: str | None = None
 	matched_oeisID: bool = True
 
 	match oeisID:
-		case 'A000136': from mapFolding.algorithms.oeisIDbyFormula import A000136 as doTheNeedful
 		case 'A000560': from mapFolding.algorithms.oeisIDbyFormula import A000560 as doTheNeedful
 		case 'A001010': from mapFolding.algorithms.oeisIDbyFormula import A001010 as doTheNeedful
 		case 'A001011': from mapFolding.algorithms.oeisIDbyFormula import A001011 as doTheNeedful
@@ -222,15 +223,30 @@ def NOTcountingFolds(oeisID: str, oeis_n: int, flow: str | None = None
 	else:
 		matched_oeisID = True
 		match oeisID:
+			case 'A000136':
+				from mapFolding import setProcessorLimit
+				concurrencyLimit: int = setProcessorLimit(CPUlimit)
+				match flow:
+					case 'elimination':
+						from mapFolding.algorithms.A000136elimination import doTheNeedful
+						countTotal = doTheNeedful(oeis_n)
+					case 'eliminationParallel':
+						from mapFolding.algorithms.A000136eliminationParallel import doTheNeedful
+						countTotal = doTheNeedful(oeis_n, concurrencyLimit)
+					case 'constraintPropagation':
+						from mapFolding.algorithms.A000136constraintPropagation import doTheNeedful
+						countTotal = doTheNeedful(oeis_n, concurrencyLimit)
+					case _:
+						from mapFolding.algorithms.oeisIDbyFormula import A000136 as doTheNeedful
+						countTotal = doTheNeedful(oeis_n)
 			case 'A000682' | 'A005316':
 				match flow:
 					case 'matrixNumPy':
-						from mapFolding.algorithms.matrixMeandersNumPy import doTheNeedful
-						from mapFolding.dataBaskets import MatrixMeandersNumPyState as State
+						from mapFolding.algorithms.matrixMeandersNumPyndas import doTheNeedful, MatrixMeandersNumPyState as State
 					case 'matrixPandas':
-						from mapFolding.algorithms.matrixMeandersPandas import doTheNeedful
-						from mapFolding.dataBaskets import MatrixMeandersNumPyState as State
-					case _:
+						from mapFolding.algorithms.matrixMeandersNumPyndas import (
+							doTheNeedfulPandas as doTheNeedful, MatrixMeandersNumPyState as State)
+					case 'matrixMeanders' | _:
 						from mapFolding.algorithms.matrixMeanders import doTheNeedful
 						from mapFolding.dataBaskets import MatrixMeandersState as State
 
@@ -291,7 +307,7 @@ def NOTcountingFolds(oeisID: str, oeis_n: int, flow: str | None = None
 						from mapFolding.syntheticModules.A007822.algorithm import doTheNeedful
 						symmetricState = doTheNeedful(symmetricState)
 
-				countTotal = symmetricState.groupsOfFolds
+				countTotal = symmetricState.symmetricFolds
 			case _:
 				matched_oeisID = False
 

mapFolding/dataBaskets.py

@@ -21,12 +21,9 @@ integrity throughout the recursive analysis while providing the structured data
 access patterns that enable efficient result persistence and retrieval.
 """
 from mapFolding import (
-	Array1DElephino, Array1DLeavesTotal, Array2DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal,
-	DatatypeLeavesTotal, getConnectionGraph, getLeavesTotal, makeDataContainer)
-from numpy.typing import NDArray
-from typing import TypeAlias
+	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
+	getConnectionGraph, getLeavesTotal, makeDataContainer)
 import dataclasses
-import numpy
 
 @dataclasses.dataclass(slots=True)
 class MapFoldingState:
@@ -203,7 +200,7 @@ class SymmetricFoldsState:
 	mapShape: tuple[DatatypeLeavesTotal, ...] = dataclasses.field(init=True, metadata={'elementConstructor': 'DatatypeLeavesTotal'})
 	"""Dimensions of the map being analyzed for folding patterns."""
 
-	groupsOfFolds: DatatypeFoldsTotal = dataclasses.field(default=DatatypeFoldsTotal(0), metadata={'theCountingIdentifier': True})
+	symmetricFolds: DatatypeFoldsTotal = dataclasses.field(default=DatatypeFoldsTotal(0), metadata={'theCountingIdentifier': True})
 	"""Current count of symmetric folds."""
 
 	gap1ndex: DatatypeElephino = DatatypeElephino(0)  # noqa: RUF009
@@ -237,12 +234,12 @@ class SymmetricFoldsState:
 	leafComparison: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
 	"""Array for finding symmetric folds."""
 
-	arrayGroupOfFolds: Array2DLeavesTotal = dataclasses.field(init=False, metadata={'dtype': Array2DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
 	connectionGraph: Array3DLeavesTotal = dataclasses.field(init=False, metadata={'dtype': Array3DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
 	"""Unchanging array representing connections between all leaves."""
 	dimensionsTotal: DatatypeLeavesTotal = dataclasses.field(init=False)
 	"""Unchanging total number of dimensions in the map."""
-	indicesArrayGroupOfFolds: Array2DLeavesTotal = dataclasses.field(init=False, metadata={'dtype': Array2DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
+	indices: list[list[tuple[int, int]]] = dataclasses.field(init=False)
+	"""Precomputed index pairs for symmetric fold checking."""
 	leavesTotal: DatatypeLeavesTotal = dataclasses.field(init=False)
 	"""Unchanging total number of leaves in the map."""
 
@@ -259,12 +256,9 @@ class SymmetricFoldsState:
 		self.leavesTotal = DatatypeLeavesTotal(getLeavesTotal(self.mapShape))
 
 		leavesTotalAsInt = int(self.leavesTotal)
-
 		self.connectionGraph = getConnectionGraph(self.mapShape, leavesTotalAsInt, self.__dataclass_fields__['connectionGraph'].metadata['dtype'])
 
-		self.indicesArrayGroupOfFolds = (numpy.arange(leavesTotalAsInt + 1)[:, None] + numpy.arange(leavesTotalAsInt)[None, :]) % (leavesTotalAsInt + 1)
-		self.indicesArrayGroupOfFolds[..., leavesTotalAsInt // 2:None] = self.indicesArrayGroupOfFolds[..., leavesTotalAsInt - 1: leavesTotalAsInt - leavesTotalAsInt // 2 - 1: -1]
-		self.arrayGroupOfFolds = numpy.zeros_like(self.indicesArrayGroupOfFolds)
+		self.indices = [[((index + folding) % (self.leavesTotal+1), (-2-index + folding) % (self.leavesTotal+1)) for index in range(self.leavesTotal//2)] for folding in range(self.leavesTotal + 1)]
 
 		if self.dimensionsUnconstrained is None: self.dimensionsUnconstrained = DatatypeLeavesTotal(int(self.dimensionsTotal)) # pyright: ignore[reportUnnecessaryComparison]  # noqa: E701
 		if self.gapsWhere is None: self.gapsWhere = makeDataContainer(leavesTotalAsInt * leavesTotalAsInt + 1, self.__dataclass_fields__['gapsWhere'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]  # noqa: E701
@@ -398,6 +392,7 @@ class MatrixMeandersState:
 	"""The index of the meanders problem being solved."""
 	oeisID: str
 	"""'A000682', semi-meanders, or 'A005316', meanders."""
+
 	boundary: int
 	"""The algorithm analyzes `n` boundaries starting at `boundary = n - 1`."""
 	dictionaryMeanders: dict[int, int]
@@ -408,14 +403,19 @@ class MatrixMeandersState:
 	bitWidth: int = 0
 	"""At the start of an iteration enumerated by `boundary`, the number of bits of the largest value `arcCode`. The
 	`dataclass` computes a `property` from `bitWidth`."""
-
-	@property
-	def MAXIMUMarcCode(self) -> int:
-		"""Compute the maximum value of `arcCode` for the current iteration of the transfer matrix."""
-		return 1 << (2 * self.boundary + 4)
-
-	@property
-	def locatorBits(self) -> int:
+	bitsLocator: int = 0
+	"""An odd-parity bit-mask with `bitWidth` bits."""
+	MAXIMUMarcCode: int = 0
+	"""The maximum value of `arcCode` for the current iteration of the transfer matrix."""
+
+	def reduceBoundary(self) -> None:
+		"""Prepare for the next iteration of the transfer matrix algorithm by reducing `boundary` by 1 and updating related fields."""
+		self.boundary -= 1
+		self.setBitWidth()
+		self.setBitsLocator()
+		self.setMAXIMUMarcCode()
+
+	def setBitsLocator(self) -> None:
 		"""Compute an odd-parity bit-mask with `bitWidth` bits.
 
 		Notes
@@ -429,60 +429,19 @@ class MatrixMeandersState:
 		odd numbers from even numbers, so I avoid using "odd" and "even" in the names of these bit-masks.
 
 		"""
-		return sum(1 << one for one in range(0, self.bitWidth, 2))
-
-@dataclasses.dataclass(slots=True)
-class MatrixMeandersNumPyState(MatrixMeandersState):
-	"""Hold the state of a meanders transfer matrix algorithm computation."""
+		self.bitsLocator = sum(1 << one for one in range(0, self.bitWidth, 2))
 
-	arrayArcCodes: NDArray[numpy.uint64] = dataclasses.field(default_factory=lambda: numpy.empty((0,), dtype=numpy.uint64))
-	arrayCrossings: NDArray[numpy.uint64] = dataclasses.field(default_factory=lambda: numpy.empty((0,), dtype=numpy.uint64))
+	def setBitWidth(self) -> None:
+		"""Set `bitWidth` from the current `dictionaryMeanders`."""
+		self.bitWidth = max(self.dictionaryMeanders.keys()).bit_length()
 
-	bitWidthLimitArcCode: int | None = None
-	bitWidthLimitCrossings: int | None = None
-
-	datatypeArcCode: TypeAlias = numpy.uint64  # noqa: UP040
-	"""The fixed-size integer type used to store `arcCode`."""
-	datatypeCrossings: TypeAlias = numpy.uint64  # noqa: UP040
-	"""The fixed-size integer type used to store `crossings`."""
-
-	indexTarget: int = 0
-	"""What is being indexed depends on the algorithm flavor."""
+	def setMAXIMUMarcCode(self) -> None:
+		"""Compute the maximum value of `arcCode` for the current iteration of the transfer matrix."""
+		self.MAXIMUMarcCode = 1 << (2 * self.boundary + 4)
 
 	def __post_init__(self) -> None:
 		"""Post init."""
-		if self.bitWidthLimitArcCode is None:
-			_bitWidthOfFixedSizeInteger: int = numpy.dtype(self.datatypeArcCode).itemsize * 8 # bits
-
-			_offsetNecessary: int = 3 # For example, `bitsZulu << 3`.
-			_offsetSafety: int = 1 # I don't have mathematical proof of how many extra bits I need.
-			_offset: int = _offsetNecessary + _offsetSafety
-
-			self.bitWidthLimitArcCode = _bitWidthOfFixedSizeInteger - _offset
-
-			del _bitWidthOfFixedSizeInteger, _offsetNecessary, _offsetSafety, _offset
-
-		if self.bitWidthLimitCrossings is None:
-			_bitWidthOfFixedSizeInteger: int = numpy.dtype(self.datatypeCrossings).itemsize * 8 # bits
-
-			_offsetNecessary: int = 0 # I don't know of any.
-			_offsetEstimation: int = 3 # See reference directory.
-			_offsetSafety: int = 1
-			_offset: int = _offsetNecessary + _offsetEstimation + _offsetSafety
-
-			self.bitWidthLimitCrossings = _bitWidthOfFixedSizeInteger - _offset
-
-			del _bitWidthOfFixedSizeInteger, _offsetNecessary, _offsetEstimation, _offsetSafety, _offset
-
-	def makeDictionary(self) -> None:
-		"""Convert from NumPy `ndarray` (*Num*erical *Py*thon *n-d*imensional array) to Python `dict` (*dict*ionary)."""
-		self.dictionaryMeanders = {int(key): int(value) for key, value in zip(self.arrayArcCodes, self.arrayCrossings, strict=True)}
-		self.arrayArcCodes = numpy.empty((0,), dtype=self.datatypeArcCode)
-		self.arrayCrossings = numpy.empty((0,), dtype=self.datatypeCrossings)
+		self.setBitWidth()
+		self.setBitsLocator()
+		self.setMAXIMUMarcCode()
 
-	def makeArray(self) -> None:
-		"""Convert from Python `dict` (*dict*ionary) to NumPy `ndarray` (*Num*erical *Py*thon *n-d*imensional array)."""
-		self.arrayArcCodes = numpy.array(list(self.dictionaryMeanders.keys()), dtype=self.datatypeArcCode)
-		self.arrayCrossings = numpy.array(list(self.dictionaryMeanders.values()), dtype=self.datatypeCrossings)
-		self.bitWidth = int(self.arrayArcCodes.max()).bit_length()
-		self.dictionaryMeanders = {}

mapFolding/reference/irvineJavaPort.py

@@ -1,5 +1,5 @@
-"""
-Ported from the Java version by Sean A. Irvine:
+"""Ported from the Java version by Sean A. Irvine.
+
 https://github.com/archmageirvine/joeis/blob/80e3e844b11f149704acbab520bc3a3a25ac34ff/src/irvine/oeis/a001/A001415.java
 
 This implementation is a Python version of a Java implementation of Lunnon's algorithm by Sean A. Irvine.
@@ -9,7 +9,7 @@ Key characteristics:
 - A procedural paradigm more similar to Lunnon and unlike Irvine's object-oriented implementation.
 - Only primitive Python data structures.
 
-Citation: https://github.com/hunterhogan/mapFolding/blob/134f2e6ecdf59fb6f6829c775475544a6aaaa800/citations/jOEIS.bibtex
+Citation: https://github.com/hunterhogan/mapFolding/blob/134f2e6ecdf59fb6f6829c775475544a6aaaa800/citations/jOEIS.bib
 """
 
 def foldings(p: list[int], res: int = 0, mod: int = 0) -> int:

mapFolding/reference/meandersDumpingGround/matrixMeandersNumPyV1finalForm.py

@@ -360,7 +360,7 @@ def doTheNeedful(n: int, dictionaryCurveLocations: dict[int, int]) -> int:
 	--------------
 
 	As first computed by Iwan Jensen in 2000, A000682(41) = 6664356253639465480.
-	Citation: https://github.com/hunterhogan/mapFolding/blob/main/citations/Jensen.bibtex
+	Citation: https://github.com/hunterhogan/mapFolding/blob/main/citations/Jensen.bib
 	See also https://oeis.org/A000682
 
 	I'm sure you instantly observed that A000682(41) = (6664356253639465480).bit_length() = 63 bits. And A005316(44) =

mapFolding/someAssemblyRequired/A007822/_asynchronousAnnex.py

@@ -34,7 +34,7 @@ def _threadDoesSomething() -> None:
 			break
 		state = _filterAsymmetricFolds(state)
 		with LOCKsymmetricFoldsTotal:
-			symmetricFoldsTotal += state.groupsOfFolds
+			symmetricFoldsTotal += state.symmetricFolds
 
 def _filterAsymmetricFolds(state: SymmetricFoldsState) -> SymmetricFoldsState:
 	"""Add real function during generation; the signature is here to preview its interactions with the module."""

mapFolding/someAssemblyRequired/A007822/makeA007822AsynchronousModules.py

@@ -1,10 +1,12 @@
 """addSymmetryCheckAsynchronous."""
-from astToolkit import Be, Grab, identifierDotAttribute, LedgerOfImports, Make, NodeChanger, NodeTourist, Then
+from astToolkit import Be, Grab, identifierDotAttribute, Make, NodeChanger, NodeTourist, Then
+from astToolkit.containers import LedgerOfImports
+from astToolkit.transformationTools import write_astModule
 from hunterMakesPy import raiseIfNone
 from mapFolding import packageSettings
 from mapFolding.someAssemblyRequired import defaultA007822, IfThis
 from mapFolding.someAssemblyRequired.A007822.A007822rawMaterials import ExprCallFilterAsymmetricFoldsState
-from mapFolding.someAssemblyRequired.toolkitMakeModules import getModule, getPathFilename, write_astModule
+from mapFolding.someAssemblyRequired.toolkitMakeModules import getModule, getPathFilename
 from pathlib import PurePath
 import ast
 
@@ -85,7 +87,7 @@ def addSymmetryCheckAsynchronous(astModule: ast.Module, identifierModule: str, i
 
 	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, identifierModule)
 
-	write_astModule(astModule, pathFilename, packageSettings.identifierPackage)
+	write_astModule(astModule, pathFilename, identifierPackage=packageSettings.identifierPackage)
 
 	return pathFilename
 

mapFolding/someAssemblyRequired/A007822/makeA007822Modules.py

@@ -1,6 +1,8 @@
 """addSymmetryCheck."""
 from astToolkit import (
-	Be, Grab, identifierDotAttribute, LedgerOfImports, NodeChanger, NodeTourist, parsePathFilename2astModule, Then)
+	Be, Grab, identifierDotAttribute, Make, NodeChanger, NodeTourist, parsePathFilename2astModule, Then)
+from astToolkit.containers import LedgerOfImports
+from astToolkit.transformationTools import write_astModule
 from hunterMakesPy import raiseIfNone
 from mapFolding import packageSettings
 from mapFolding.someAssemblyRequired import default, defaultA007822, IfThis
@@ -8,7 +10,7 @@ from mapFolding.someAssemblyRequired.A007822.A007822rawMaterials import (
 	A007822adjustFoldsTotal, A007822incrementCount, FunctionDef_filterAsymmetricFolds)
 from mapFolding.someAssemblyRequired.makingModules_count import makeTheorem2, numbaOnTheorem2, trimTheorem2
 from mapFolding.someAssemblyRequired.makingModules_doTheNeedful import makeInitializeState
-from mapFolding.someAssemblyRequired.toolkitMakeModules import getModule, getPathFilename, write_astModule
+from mapFolding.someAssemblyRequired.toolkitMakeModules import getModule, getPathFilename
 from pathlib import PurePath
 import ast
 
@@ -43,7 +45,21 @@ def addSymmetryCheck(astModule: ast.Module, identifierModule: str, identifierCal
 
 	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, identifierModule)
 
-	write_astModule(astModule, pathFilename, packageSettings.identifierPackage)
+	write_astModule(astModule, pathFilename, identifierPackage=packageSettings.identifierPackage)
+
+	return pathFilename
+
+def _numbaOnTheorem2(astModule: ast.Module, identifierModule: str, identifierCallable: str | None = None, logicalPathInfix: identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:
+	pathFilename: PurePath = numbaOnTheorem2(astModule, identifierModule, identifierCallable, logicalPathInfix, sourceCallableDispatcher)
+	astModule = parsePathFilename2astModule(pathFilename)
+
+	NodeChanger(Be.AnnAssign.valueIs(IfThis.isAttributeNamespaceIdentifier(defaultA007822['variable']['stateInstance'], 'indices'))
+			, lambda node: Grab.valueAttribute(Then.replaceWith(Make.Call(Make.Name('List'), [raiseIfNone(node.value)])))(node)
+		).visit(astModule)
+
+	astModule.body.insert(0, Make.ImportFrom('numba.typed', [Make.alias('List')]))
+
+	write_astModule(astModule, pathFilename, identifierPackage=packageSettings.identifierPackage)
 
 	return pathFilename
 
@@ -55,18 +71,18 @@ def makeA007822Modules() -> None:
 
 	astModule = getModule(logicalPathInfix=defaultA007822['logicalPath']['synthetic'], identifierModule=defaultA007822['module']['algorithm'])
 	makeInitializeState(astModule, defaultA007822['module']['initializeState']
-		, defaultA007822['function']['initializeState'], defaultA007822['logicalPath']['synthetic'], None)
+		, defaultA007822['function']['initializeState'], defaultA007822['logicalPath']['synthetic'], None, identifiers=defaultA007822)
 
 	astModule = getModule(logicalPathInfix=defaultA007822['logicalPath']['synthetic'], identifierModule=defaultA007822['module']['algorithm'])
 	pathFilename = makeTheorem2(astModule, 'theorem2', defaultA007822['function']['counting']
-		, defaultA007822['logicalPath']['synthetic'], defaultA007822['function']['dispatcher'])
+		, defaultA007822['logicalPath']['synthetic'], defaultA007822['function']['dispatcher'], identifiers=defaultA007822)
 
 	astModule = parsePathFilename2astModule(pathFilename)
 	pathFilename = trimTheorem2(astModule, 'theorem2Trimmed', defaultA007822['function']['counting']
 		, defaultA007822['logicalPath']['synthetic'], defaultA007822['function']['dispatcher'])
 
 	astModule = parsePathFilename2astModule(pathFilename)
-	pathFilename = numbaOnTheorem2(astModule, 'theorem2Numba', defaultA007822['function']['counting']
+	pathFilename = _numbaOnTheorem2(astModule, 'theorem2Numba', defaultA007822['function']['counting']
 		, defaultA007822['logicalPath']['synthetic'], defaultA007822['function']['dispatcher'])
 
 if __name__ == '__main__':

mapFolding/someAssemblyRequired/RecipeJob.py

@@ -1,16 +1,16 @@
 """Configuration by dataclass."""
 
-from astToolkit import identifierDotAttribute, IngredientsFunction, IngredientsModule, parseLogicalPath2astModule
+from astToolkit import identifierDotAttribute, parseLogicalPath2astModule
+from astToolkit.containers import IngredientsFunction, IngredientsModule, LedgerOfImports
 from astToolkit.transformationTools import pythonCode2ast_expr
 from hunterMakesPy import autoDecodingRLE
-# TODO 'The...' identifiers are a vestigial semiotic system. Do I still need to import `asname`? If so, would different
+# TODO 'The____' identifiers are a vestigial semiotic system. Do I still need to import `asname`? If so, would different
 # identifiers better integrate into the current semiotics?
 from mapFolding import (
 	DatatypeElephino as TheDatatypeElephino, DatatypeFoldsTotal as TheDatatypeFoldsTotal,
 	DatatypeLeavesTotal as TheDatatypeLeavesTotal, getPathFilenameFoldsTotal, getPathRootJobDEFAULT, packageSettings)
-from mapFolding.dataBaskets import MapFoldingState
-from mapFolding.someAssemblyRequired import DatatypeConfiguration, default
-from mapFolding.someAssemblyRequired._toolkitContainers import ShatteredDataclass
+from mapFolding.dataBaskets import MapFoldingState, SymmetricFoldsState
+from mapFolding.someAssemblyRequired import DatatypeConfiguration, default, ShatteredDataclass
 from mapFolding.someAssemblyRequired.transformationTools import shatter_dataclassesDOTdataclass
 from pathlib import Path, PurePosixPath
 from typing import cast
@@ -22,18 +22,8 @@ class RecipeJobTheorem2:
 	"""Configuration recipe for generating map folding computation jobs.
 
 	This dataclass serves as the central configuration hub for the code transformation
-	assembly line that converts generic map folding algorithms into highly optimized,
-	specialized computation modules. The recipe encapsulates all parameters required
-	for source code analysis, target file generation, datatype mapping, and compilation
-	optimization settings.
-
-	The transformation process operates by extracting functions from source modules,
-	embedding concrete parameter values, eliminating dead code paths, and generating
-	standalone Python modules optimized for specific map dimensions.
-
-	The recipe maintains both source configuration (where to find the generic algorithm)
-	and target configuration (where to write the optimized module), along with the
-	computational state that provides concrete values for the transformation process.
+	assembly line that converts generic map folding algorithms into optimized,
+	specialized modules.
 
 	Attributes
 	----------
@@ -87,7 +77,7 @@ class RecipeJobTheorem2:
 		Type alias for leaf count datatype.
 	"""
 
-	state: MapFoldingState
+	state: MapFoldingState | SymmetricFoldsState
 	"""The map folding computation state containing dimensions and initial values."""
 	foldsTotalEstimated: int = 0
 	"""Estimated total number of folds for progress tracking."""
@@ -129,7 +119,7 @@ class RecipeJobTheorem2:
 	"""Logical path root; probably corresponds to physical filesystem directory."""
 	moduleIdentifier: str = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
 	"""Target module identifier."""
-	countCallable: str = identifierCallableSource
+	identifierCallable: str = identifierCallableSource
 	"""Name of the counting function in generated module."""
 	identifierDataclass: str | None = sourceDataclassIdentifier
 	"""Target dataclass identifier."""
@@ -211,12 +201,12 @@ class RecipeJobTheorem2:
 		"""
 		pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(self.state.mapShape))
 
-		if self.moduleIdentifier is None: # pyright: ignore[reportUnnecessaryComparison]
-			self.moduleIdentifier = pathFilenameFoldsTotal.stem
-
 		if self.pathFilenameFoldsTotal is None: # pyright: ignore[reportUnnecessaryComparison]
 			self.pathFilenameFoldsTotal = pathFilenameFoldsTotal
 
+		if self.moduleIdentifier is None: # pyright: ignore[reportUnnecessaryComparison]
+			self.moduleIdentifier = self.pathFilenameFoldsTotal.stem
+
 		if self.shatteredDataclass is None and self.logicalPathModuleDataclass and self.identifierDataclass and self.identifierDataclassInstance: # pyright: ignore[reportUnnecessaryComparison]
 			self.shatteredDataclass = shatter_dataclassesDOTdataclass(self.logicalPathModuleDataclass, self.identifierDataclass, self.identifierDataclassInstance)
 
@@ -245,11 +235,11 @@ def moveShatteredDataclass_arg2body(identifier: str, job: RecipeJobTheorem2) ->
 	Ima___Assign, elementConstructor = job.shatteredDataclass.Z0Z_field2AnnAssign[identifier]
 	match elementConstructor:
 		case 'scalar':
-			cast('ast.Constant', cast('ast.Call', Ima___Assign.value).args[0]).value = int(eval(f"job.state.{identifier}"))  # noqa: S307
+			cast(ast.Constant, cast(ast.Call, Ima___Assign.value).args[0]).value = int(eval(f"job.state.{identifier}"))  # noqa: S307
 		case 'array':
 			dataAsStrRLE: str = autoDecodingRLE(eval(f"job.state.{identifier}"), assumeAddSpaces=True)  # noqa: S307
 			dataAs_ast_expr: ast.expr = pythonCode2ast_expr(dataAsStrRLE)
-			cast('ast.Call', Ima___Assign.value).args = [dataAs_ast_expr]
+			cast(ast.Call, Ima___Assign.value).args = [dataAs_ast_expr]
 		case _:
 			pass
 	return Ima___Assign

mapFolding/someAssemblyRequired/__init__.py

@@ -74,6 +74,7 @@ calculations through the strategic application of compiler optimization techniqu
 
 from mapFolding.someAssemblyRequired.infoBooth import (
     default as default,
+    Default as Default,
     defaultA007822 as defaultA007822,
 	dictionaryEstimatesMapFolding as dictionaryEstimatesMapFolding,
 )

mapFolding/someAssemblyRequired/_toolkitContainers.py

@@ -25,7 +25,8 @@ to low-level optimized functions while maintaining semantic equivalence and type
 the compilation process.
 """
 
-from astToolkit import Be, DOT, identifierDotAttribute, LedgerOfImports, Make, NodeTourist, Then
+from astToolkit import Be, DOT, identifierDotAttribute, Make, NodeTourist, Then
+from astToolkit.containers import LedgerOfImports
 from collections.abc import Callable
 from copy import deepcopy
 from hunterMakesPy import raiseIfNone
@@ -220,7 +221,7 @@ class DeReConstructField2ast: # slots?
 		self.ast_keyword_field__field = Make.keyword(self.name, self.astName)
 		self.ast_nameDOTname = Make.Attribute(Make.Name(dataclassesDOTdataclassInstanceIdentifier), self.name)
 
-		self.astAnnotation = cast('ast.Name', raiseIfNone(NodeTourist(
+		self.astAnnotation = cast(ast.Name, raiseIfNone(NodeTourist(
 			findThis = Be.AnnAssign.targetIs(IfThis.isNameIdentifier(self.name))
 			, doThat = Then.extractIt(DOT.annotation)
 			).captureLastMatch(dataclassClassDef)))
@@ -251,8 +252,9 @@ class DeReConstructField2ast: # slots?
 			self.astAnnAssignConstructor = Make.AnnAssign(self.astName, self.astAnnotation, Make.Call(self.astAnnotation, [Make.Constant(-1)]))
 			self.Z0Z_hack = (self.astAnnAssignConstructor, 'scalar')
 		elif isinstance(self.astAnnotation, ast.Subscript):
-			elementConstructor: str = self.metadata['elementConstructor']
-			self.ledger.addImportFrom_asStr(dataclassesDOTdataclassLogicalPathModule, elementConstructor)
+			elementConstructor: str = self.metadata.get('elementConstructor', 'generic')
+			if elementConstructor != 'generic':
+				self.ledger.addImportFrom_asStr(dataclassesDOTdataclassLogicalPathModule, elementConstructor)
 			takeTheTuple = deepcopy(self.astAnnotation.slice)
 			self.astAnnAssignConstructor = Make.AnnAssign(self.astName, self.astAnnotation, takeTheTuple)
 			self.Z0Z_hack = (self.astAnnAssignConstructor, elementConstructor)

mapFolding/someAssemblyRequired/infoBooth.py

@@ -44,6 +44,7 @@ default = Default(
 	},
 	module = {
 		'algorithm': 'daoOfMapFolding',
+		'dataBasket': 'dataBaskets',
 		'initializeState': 'initializeState',
 	},
 	variable = {
@@ -62,5 +63,5 @@ defaultA007822['logicalPath']['assembly'] = 'someAssemblyRequired.A007822'
 defaultA007822['logicalPath']['synthetic'] += '.A007822'
 defaultA007822['module']['algorithm'] = 'algorithm'
 defaultA007822['module']['asynchronous'] = 'asynchronous'
-# defaultA007822['variable']['counting'] = 'symmetricFolds'
+defaultA007822['variable']['counting'] = 'symmetricFolds'
 defaultA007822['variable']['stateDataclass'] = 'SymmetricFoldsState'