mapFolding 0.15.0__py3-none-any.whl → 0.15.1__py3-none-any.whl

mapFolding/someAssemblyRequired/makeAllModules.py

@@ -39,7 +39,10 @@ from astToolkit.transformationTools import inlineFunctionDef, removeUnusedParame
 from hunterMakesPy import importLogicalPath2Identifier, raiseIfNone
 from mapFolding import packageSettings
 from mapFolding.someAssemblyRequired import (
-	DeReConstructField2ast, IfThis, ShatteredDataclass, sourceCallableDispatcherDEFAULT)
+	dataclassInstanceIdentifierDEFAULT, DeReConstructField2ast, IfThis, ShatteredDataclass,
+	sourceCallableDispatcherDEFAULT)
+from mapFolding.someAssemblyRequired.A007822rawMaterials import (
+	FunctionDef_filterAsymmetricFolds, Z0Z_adjustFoldsTotal, Z0Z_incrementCount)
 from mapFolding.someAssemblyRequired.infoBooth import (
 	algorithmSourceModuleDEFAULT, dataPackingModuleIdentifierDEFAULT, logicalPathInfixDEFAULT,
 	sourceCallableIdentifierDEFAULT, theCountingIdentifierDEFAULT)
@@ -98,69 +101,18 @@ def _findDataclass(ingredientsFunction: IngredientsFunction) -> tuple[str, str,
 	dataclassInstanceIdentifier: identifierDotAttribute = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef))
 	return raiseIfNone(dataclassLogicalPathModule), dataclassIdentifier, dataclassInstanceIdentifier
 
-def _getLogicalPath(packageName: str | None = None, logicalPathInfix: str | None = None, moduleIdentifier: str | None = None, *modules: str) -> identifierDotAttribute:
-	"""Construct logical module path by joining package and module components.
-
-	(AI generated docstring)
-
-	Builds a dot-separated logical path string from optional package name, infix path
-	components, and module identifiers. This standardizes module path construction
-	across the code generation system and ensures consistent naming conventions.
-
-	Parameters
-	----------
-	packageName : str | None = None
-		Root package name for the logical path.
-	logicalPathInfix : str | None = None
-		Middle path component (typically 'syntheticModules').
-	moduleIdentifier : str | None = None
-		Primary module identifier.
-	*modules : str
-		Additional module path components to append.
-
-	Returns
-	-------
-	logicalPath : identifierDotAttribute
-		Dot-separated logical path string suitable for module import operations.
-
-	"""
+def _getLogicalPath(identifierPackage: str | None = None, logicalPathInfix: str | None = None, *moduleIdentifier: str | None) -> identifierDotAttribute:
 	listLogicalPathParts: list[str] = []
-	if packageName:
-		listLogicalPathParts.append(packageName)
+	if identifierPackage:
+		listLogicalPathParts.append(identifierPackage)
 	if logicalPathInfix:
 		listLogicalPathParts.append(logicalPathInfix)
 	if moduleIdentifier:
-		listLogicalPathParts.append(moduleIdentifier)
-	if modules:
-		listLogicalPathParts.extend(modules)
+		listLogicalPathParts.extend([module for module in moduleIdentifier if module is not None])
 	return '.'.join(listLogicalPathParts)
 
-def _getModule(packageName: str | None = packageSettings.identifierPackage, logicalPathInfix: str | None = logicalPathInfixDEFAULT, moduleIdentifier: str | None = algorithmSourceModuleDEFAULT) -> ast.Module:
-	"""Load source algorithm module as AST for transformation operations.
-
-	(AI generated docstring)
-
-	Retrieves the specified module and parses it into an AST representation that can
-	be manipulated by the transformation tools. This provides the foundation for all
-	code generation operations by making the source algorithms available for analysis
-	and modification.
-
-	Parameters
-	----------
-	packageName : str | None = packageSettings.identifierPackage
-		Package containing the source module.
-	logicalPathInfix : str | None = logicalPathInfixDEFAULT
-		Path component within the package structure.
-	moduleIdentifier : str | None = algorithmSourceModuleDEFAULT
-		Specific module containing the algorithms.
-
-	Returns
-	-------
-	astModule : ast.Module
-		AST module representation ready for transformation operations.
-
-	"""
-	logicalPathSourceModule: identifierDotAttribute = _getLogicalPath(packageName, logicalPathInfix, moduleIdentifier)
+def _getModule(identifierPackage: str | None = packageSettings.identifierPackage, logicalPathInfix: str | None = logicalPathInfixDEFAULT, moduleIdentifier: str | None = algorithmSourceModuleDEFAULT) -> ast.Module:
+	logicalPathSourceModule: identifierDotAttribute = _getLogicalPath(identifierPackage, logicalPathInfix, moduleIdentifier)
 	astModule: ast.Module = parseLogicalPath2astModule(logicalPathSourceModule)
 	return astModule
 
@@ -197,55 +149,43 @@ def _getPathFilename(pathRoot: PathLike[str] | PurePath | None = packageSettings
 		pathFilename = PurePath(pathRoot, pathFilename)
 	return pathFilename
 
-def makeInitializeGroupsOfFolds(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: PathLike[str] | PurePath | str | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
-	"""Generate initialization module for counting variable setup.
+# TODO Where is the generalized form of these functions?!
 
-	(AI generated docstring)
+def addSymmetryCheck(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: PathLike[str] | PurePath | str | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
+	"""Add logic to check for symmetric folds."""
+	imports=LedgerOfImports(astModule)
 
-	Creates a specialized module containing initialization logic for the counting variables
-	used in map folding computations. The generated function transforms the original
-	algorithm's loop conditions to use equality comparisons instead of greater-than
-	comparisons, optimizing the initialization phase.
+	astFunctionDef_count: ast.FunctionDef = raiseIfNone(NodeTourist(
+		findThis = Be.FunctionDef.nameIs(IfThis.isIdentifier(sourceCallableIdentifierDEFAULT))
+		, doThat = Then.extractIt
+		).captureLastMatch(astModule))
 
-	This transformation is particularly important for ensuring that counting variables
-	are properly initialized before the main computational loops begin executing.
+# NOTE 2025 August 7. I am SHOCKED to discover that `astFunctionDef_count: ast.FunctionDef` returned by `NodeTourist` (subclass of
+# `ast.NodeVisitor`) is a so-called mutable `object`!!!!!!
+# !!!!!! Using the mutability of `ast.AST` subclasses, makes `astToolkit` SIGNIFICANTLY more powerful and solves "obstacles" I
+# have been trying to overcome.
+# (Side note: fuck you, Python, for your idiotic paradigms around mutability, its documentation, its identifiers, and its types.)
 
-	Parameters
-	----------
-	astModule : ast.Module
-		Source module containing the base algorithm.
-	moduleIdentifier : str
-		Name for the generated initialization module.
-	callableIdentifier : str | None = None
-		Name for the initialization function.
-	logicalPathInfix : PathLike[str] | PurePath | str | None = None
-		Directory path for organizing the generated module.
-	sourceCallableDispatcher : str | None = None
-		Optional dispatcher function identifier.
+	NodeChanger(Be.Return, Then.insertThisAbove([Z0Z_adjustFoldsTotal])).visit(astFunctionDef_count)
 
-	Returns
-	-------
-	pathFilename : PurePath
-		Filesystem path where the initialization module was written.
+	NodeChanger(
+		findThis=Be.AugAssign.targetIs(IfThis.isAttributeNamespaceIdentifier(dataclassInstanceIdentifierDEFAULT, theCountingIdentifierDEFAULT))
+		, doThat=Then.replaceWith(Z0Z_incrementCount)
+		).visit(astFunctionDef_count)
 
-	"""
-	sourceCallableIdentifier: identifierDotAttribute = sourceCallableIdentifierDEFAULT
-	ingredientsFunction = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule), LedgerOfImports(astModule))
-	ingredientsFunction.astFunctionDef.name = callableIdentifier or sourceCallableIdentifier
+	ingredientsFunction=IngredientsFunction(FunctionDef_filterAsymmetricFolds)
 
-	dataclassInstanceIdentifier: identifierDotAttribute = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef))
-	theCountingIdentifier: identifierDotAttribute = theCountingIdentifierDEFAULT
+	NodeChanger(Be.ImportFrom, Then.removeIt).visit(astModule)
 
-	findThis = IfThis.isWhileAttributeNamespaceIdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
-	doThat = Grab.testAttribute(Grab.andDoAllOf([Grab.opsAttribute(Then.replaceWith([ast.Eq()])), Grab.leftAttribute(Grab.attrAttribute(Then.replaceWith(theCountingIdentifier)))]))
-	NodeChanger(findThis, doThat).visit(ingredientsFunction.astFunctionDef.body[0])
+	ingredientsModule = IngredientsModule(ingredientsFunction=ingredientsFunction, epilogue=astModule, imports=imports)
 
 	pathFilename: PurePath = _getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier)
-	write_astModule(IngredientsModule(ingredientsFunction), pathFilename, packageSettings.identifierPackage)
+
+	write_astModule(ingredientsModule, pathFilename, packageSettings.identifierPackage)
 
 	return pathFilename
 
-def makeDaoOfMapFolding(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: PathLike[str] | PurePath | str | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:
+def makeDaoOfMapFoldingNumba(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: PathLike[str] | PurePath | str | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:
 	"""Generate Numba-optimized sequential implementation of map folding algorithm.
 
 	(AI generated docstring)
@@ -318,19 +258,9 @@ def makeDaoOfMapFolding(astModule: ast.Module, moduleIdentifier: str, callableId
 
 	return pathFilename
 
-def makeDaoOfMapFoldingParallel(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: PathLike[str] | PurePath | str | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001, PLR0915
+def makeDaoOfMapFoldingParallelNumba(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: PathLike[str] | PurePath | str | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
 	"""Generate parallel implementation with concurrent execution and task division.
 
-	This version of the algorithm: Creates a parallel processing version of the map folding algorithm that distributes
-	computational work across multiple processes using `ProcessPoolExecutor`. The implementation includes dataclass decomposition
-	for both base and parallel state fields, task division logic that partitions work based on leaf indices, concurrent execution
-	management with future objects, result aggregation from multiple parallel computations, and Numba optimization for the core
-	computational kernels.
-
-	The generated module contains multiple functions including core counting function with parallel-aware task filtering,
-	dataclass unpacking/repacking function for process communication, and main dispatcher function that manages the parallel
-	execution assembly line.
-
 	Parameters
 	----------
 	astModule : ast.Module
@@ -496,22 +426,56 @@ def makeDaoOfMapFoldingParallel(astModule: ast.Module, moduleIdentifier: str, ca
 
 	return pathFilename
 
-def makeTheorem2(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: PathLike[str] | PurePath | str | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:
-	"""Generate optimized implementation applying Theorem 2 mathematical optimizations.
+def makeInitializeState(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: PathLike[str] | PurePath | str | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
+	"""Generate initialization module for counting variable setup.
 
 	(AI generated docstring)
 
-	Creates a specialized version of the map folding algorithm that applies Theorem 2
-	optimizations for improved computational efficiency. The transformation includes
-	modifying loop termination conditions from general cases to Theorem 2 specifics,
-	restructuring conditional logic to eliminate unnecessary branch evaluations,
-	adding count doubling operations to leverage mathematical properties, and
-	removing redundant computations that are not needed under Theorem 2 constraints.
+	Creates a specialized module containing initialization logic for the counting variables
+	used in map folding computations. The generated function transforms the original
+	algorithm's loop conditions to use equality comparisons instead of greater-than
+	comparisons, optimizing the initialization phase.
+
+	This transformation is particularly important for ensuring that counting variables
+	are properly initialized before the main computational loops begin executing.
+
+	Parameters
+	----------
+	astModule : ast.Module
+		Source module containing the base algorithm.
+	moduleIdentifier : str
+		Name for the generated initialization module.
+	callableIdentifier : str | None = None
+		Name for the initialization function.
+	logicalPathInfix : PathLike[str] | PurePath | str | None = None
+		Directory path for organizing the generated module.
+	sourceCallableDispatcher : str | None = None
+		Optional dispatcher function identifier.
+
+	Returns
+	-------
+	pathFilename : PurePath
+		Filesystem path where the initialization module was written.
+
+	"""
+	sourceCallableIdentifier: identifierDotAttribute = sourceCallableIdentifierDEFAULT
+	ingredientsFunction = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule), LedgerOfImports(astModule))
+	ingredientsFunction.astFunctionDef.name = callableIdentifier or sourceCallableIdentifier
+
+	dataclassInstanceIdentifier: identifierDotAttribute = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef))
+	theCountingIdentifier: identifierDotAttribute = theCountingIdentifierDEFAULT
+
+	findThis = IfThis.isWhileAttributeNamespaceIdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+	doThat = Grab.testAttribute(Grab.andDoAllOf([Grab.opsAttribute(Then.replaceWith([ast.Eq()])), Grab.leftAttribute(Grab.attrAttribute(Then.replaceWith(theCountingIdentifier)))]))
+	NodeChanger(findThis, doThat).visit(ingredientsFunction.astFunctionDef.body[0])
+
+	pathFilename: PurePath = _getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier)
+	write_astModule(IngredientsModule(ingredientsFunction), pathFilename, packageSettings.identifierPackage)
 
-	Theorem 2 provides mathematical guarantees that allow certain computational
-	shortcuts and optimizations that would not be valid in the general case. This
-	implementation capitalizes on those properties to achieve significant performance
-	improvements for maps that satisfy Theorem 2 conditions.
+	return pathFilename
+
+def makeTheorem2(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: PathLike[str] | PurePath | str | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:
+	"""Generate module by applying optimization predicted by Theorem 2.
 
 	Parameters
 	----------
@@ -543,6 +507,14 @@ def makeTheorem2(astModule: ast.Module, moduleIdentifier: str, callableIdentifie
 
 	dataclassInstanceIdentifier: identifierDotAttribute = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef))
 
+	theCountingIdentifier: identifierDotAttribute = theCountingIdentifierDEFAULT
+	doubleTheCount: ast.AugAssign = Make.AugAssign(Make.Attribute(Make.Name(dataclassInstanceIdentifier), theCountingIdentifier), Make.Mult(), Make.Constant(2))
+
+	NodeChanger(
+		findThis = IfThis.isWhileAttributeNamespaceIdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+		, doThat = Grab.orelseAttribute(Then.replaceWith([doubleTheCount]))
+	).visit(ingredientsFunction.astFunctionDef)
+
 	NodeChanger(
 		findThis = IfThis.isWhileAttributeNamespaceIdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
 		, doThat = Grab.testAttribute(Grab.comparatorsAttribute(Then.replaceWith([Make.Constant(4)])))
@@ -567,13 +539,6 @@ def makeTheorem2(astModule: ast.Module, moduleIdentifier: str, callableIdentifie
 		, doThat = Then.removeIt
 	).visit(ingredientsFunction.astFunctionDef)
 
-	theCountingIdentifier: identifierDotAttribute = theCountingIdentifierDEFAULT
-	doubleTheCount: ast.AugAssign = Make.AugAssign(Make.Attribute(ast.Name(dataclassInstanceIdentifier), theCountingIdentifier), ast.Mult(), Make.Constant(2))
-	NodeChanger(
-		findThis = Be.Return
-		, doThat = Then.insertThisAbove([doubleTheCount])
-	).visit(ingredientsFunction.astFunctionDef)
-
 	ingredientsModule = IngredientsModule(ingredientsFunction)
 
 	if sourceCallableDispatcher is not None:
@@ -586,47 +551,61 @@ def makeTheorem2(astModule: ast.Module, moduleIdentifier: str, callableIdentifie
 
 	return pathFilename
 
-def trimTheorem2(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: PathLike[str] | PurePath | str | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
-	"""Generate constrained Theorem 2 implementation by removing unnecessary logic.
+def makeUnRePackDataclass(astImportFrom: ast.ImportFrom) -> None:
+	"""Generate interface module for dataclass unpacking and repacking operations.
 
 	(AI generated docstring)
 
-	Creates a trimmed version of the Theorem 2 implementation by eliminating conditional logic that is not needed under specific
-	constraint assumptions. This transformation removes checks for unconstrained dimensions, simplifying the algorithm for cases
-	where dimensional constraints are guaranteed to be satisfied by external conditions.
+	Creates a specialized module that serves as an interface between dataclass-based
+	calling code and optimized implementations that operate on decomposed primitive
+	values. The generated module includes a function that unpacks dataclass instances
+	into individual primitive values, calls to the specified optimized target function
+	with decomposed parameters, repacking of results back into appropriate dataclass
+	instances, and import management for all required dependencies.
 
-	The trimming operation is particularly valuable for generating lean implementations where the calling context ensures that
-	certain conditions will always be met, allowing the removal of defensive programming constructs that add computational
-	overhead without providing benefits in the constrained environment.
+	This bridge module enables seamless integration between high-level dataclass-based
+	APIs and low-level optimized implementations, maintaining type safety and usability
+	while leveraging performance optimizations that require primitive value operations.
 
 	Parameters
 	----------
-	astModule : ast.Module
-		Source module containing the Theorem 2 implementation.
-	moduleIdentifier : str
-		Name for the generated trimmed module.
-	callableIdentifier : str | None = None
-		Name for the trimmed computational function.
-	logicalPathInfix : PathLike[str] | PurePath | str | None = None
-		Directory path for organizing the generated module.
-	sourceCallableDispatcher : str | None = None
-		Optional dispatcher function identifier (unused).
+	astImportFrom : ast.ImportFrom
+		Import statement specifying the target optimized function to call.
 
 	Returns
 	-------
-	pathFilename : PurePath
-		Filesystem path where the trimmed module was written.
+	None
+		The generated module is written directly to the filesystem.
 
 	"""
-	sourceCallableIdentifier = sourceCallableIdentifierDEFAULT
-	ingredientsFunction = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule), LedgerOfImports(astModule))
-	ingredientsFunction.astFunctionDef.name = callableIdentifier or sourceCallableIdentifier
+	callableIdentifierHARDCODED: str = 'sequential'
 
-	dataclassInstanceIdentifier: identifierDotAttribute = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef))
+	algorithmSourceModule: identifierDotAttribute = algorithmSourceModuleDEFAULT
+	sourceCallableIdentifier: identifierDotAttribute = sourceCallableDispatcherDEFAULT
+	logicalPathSourceModule: identifierDotAttribute = '.'.join([packageSettings.identifierPackage, algorithmSourceModule])  # noqa: FLY002
 
-	findThis = IfThis.isIfUnaryNotAttributeNamespaceIdentifier(dataclassInstanceIdentifier, 'dimensionsUnconstrained')
-	doThat = Then.removeIt
-	NodeChanger(findThis, doThat).visit(ingredientsFunction.astFunctionDef)
+	logicalPathInfix: identifierDotAttribute = logicalPathInfixDEFAULT
+	moduleIdentifier: identifierDotAttribute = dataPackingModuleIdentifierDEFAULT
+	callableIdentifier: identifierDotAttribute = callableIdentifierHARDCODED
+
+	ingredientsFunction: IngredientsFunction = astModuleToIngredientsFunction(parseLogicalPath2astModule(logicalPathSourceModule), sourceCallableIdentifier)
+	ingredientsFunction.astFunctionDef.name = callableIdentifier
+
+	shatteredDataclass: ShatteredDataclass = shatter_dataclassesDOTdataclass(*_findDataclass(ingredientsFunction))
+
+	ingredientsFunction.imports.update(shatteredDataclass.imports)
+	ingredientsFunction.imports.addAst(astImportFrom)
+	targetCallableIdentifier = astImportFrom.names[0].name
+	ingredientsFunction = raiseIfNone(unpackDataclassCallFunctionRepackDataclass(ingredientsFunction, targetCallableIdentifier, shatteredDataclass))
+	targetFunctionDef: ast.FunctionDef = raiseIfNone(extractFunctionDef(parseLogicalPath2astModule(raiseIfNone(astImportFrom.module)), targetCallableIdentifier))
+	astTuple: ast.Tuple = cast('ast.Tuple', raiseIfNone(NodeTourist(Be.Return.valueIs(Be.Tuple)
+			, doThat=Then.extractIt(DOT.value)).captureLastMatch(targetFunctionDef)))
+	astTuple.ctx = ast.Store()
+
+	changeAssignCallToTarget = NodeChanger(
+		findThis = Be.Assign.valueIs(IfThis.isCallIdentifier(targetCallableIdentifier))
+		, doThat = Then.replaceWith(Make.Assign([astTuple], value=Make.Call(Make.Name(targetCallableIdentifier), astTuple.elts))))
+	changeAssignCallToTarget.visit(ingredientsFunction.astFunctionDef)
 
 	ingredientsModule = IngredientsModule(ingredientsFunction)
 	ingredientsModule.removeImportFromModule('numpy')
@@ -635,8 +614,6 @@ def trimTheorem2(astModule: ast.Module, moduleIdentifier: str, callableIdentifie
 
 	write_astModule(ingredientsModule, pathFilename, packageSettings.identifierPackage)
 
-	return pathFilename
-
 def numbaOnTheorem2(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: PathLike[str] | PurePath | str | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
 	"""Generate Numba-accelerated Theorem 2 implementation with dataclass decomposition.
 
@@ -696,61 +673,47 @@ def numbaOnTheorem2(astModule: ast.Module, moduleIdentifier: str, callableIdenti
 
 	return pathFilename
 
-def makeUnRePackDataclass(astImportFrom: ast.ImportFrom) -> None:
-	"""Generate interface module for dataclass unpacking and repacking operations.
+def trimTheorem2(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: PathLike[str] | PurePath | str | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
+	"""Generate constrained Theorem 2 implementation by removing unnecessary logic.
 
 	(AI generated docstring)
 
-	Creates a specialized module that serves as an interface between dataclass-based
-	calling code and optimized implementations that operate on decomposed primitive
-	values. The generated module includes a function that unpacks dataclass instances
-	into individual primitive values, calls to the specified optimized target function
-	with decomposed parameters, repacking of results back into appropriate dataclass
-	instances, and import management for all required dependencies.
+	Creates a trimmed version of the Theorem 2 implementation by eliminating conditional logic that is not needed under specific
+	constraint assumptions. This transformation removes checks for unconstrained dimensions, simplifying the algorithm for cases
+	where dimensional constraints are guaranteed to be satisfied by external conditions.
 
-	This bridge module enables seamless integration between high-level dataclass-based
-	APIs and low-level optimized implementations, maintaining type safety and usability
-	while leveraging performance optimizations that require primitive value operations.
+	The trimming operation is particularly valuable for generating lean implementations where the calling context ensures that
+	certain conditions will always be met, allowing the removal of defensive programming constructs that add computational
+	overhead without providing benefits in the constrained environment.
 
 	Parameters
 	----------
-	astImportFrom : ast.ImportFrom
-		Import statement specifying the target optimized function to call.
+	astModule : ast.Module
+		Source module containing the Theorem 2 implementation.
+	moduleIdentifier : str
+		Name for the generated trimmed module.
+	callableIdentifier : str | None = None
+		Name for the trimmed computational function.
+	logicalPathInfix : PathLike[str] | PurePath | str | None = None
+		Directory path for organizing the generated module.
+	sourceCallableDispatcher : str | None = None
+		Optional dispatcher function identifier (unused).
 
 	Returns
 	-------
-	None
-		The generated module is written directly to the filesystem.
+	pathFilename : PurePath
+		Filesystem path where the trimmed module was written.
 
 	"""
-	callableIdentifierHARDCODED: str = 'sequential'
-
-	algorithmSourceModule: identifierDotAttribute = algorithmSourceModuleDEFAULT
-	sourceCallableIdentifier: identifierDotAttribute = sourceCallableDispatcherDEFAULT
-	logicalPathSourceModule: identifierDotAttribute = '.'.join([packageSettings.identifierPackage, algorithmSourceModule])  # noqa: FLY002
-
-	logicalPathInfix: identifierDotAttribute = logicalPathInfixDEFAULT
-	moduleIdentifier: identifierDotAttribute = dataPackingModuleIdentifierDEFAULT
-	callableIdentifier: identifierDotAttribute = callableIdentifierHARDCODED
-
-	ingredientsFunction: IngredientsFunction = astModuleToIngredientsFunction(parseLogicalPath2astModule(logicalPathSourceModule), sourceCallableIdentifier)
-	ingredientsFunction.astFunctionDef.name = callableIdentifier
-
-	shatteredDataclass: ShatteredDataclass = shatter_dataclassesDOTdataclass(*_findDataclass(ingredientsFunction))
+	sourceCallableIdentifier = sourceCallableIdentifierDEFAULT
+	ingredientsFunction = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule), LedgerOfImports(astModule))
+	ingredientsFunction.astFunctionDef.name = callableIdentifier or sourceCallableIdentifier
 
-	ingredientsFunction.imports.update(shatteredDataclass.imports)
-	ingredientsFunction.imports.addAst(astImportFrom)
-	targetCallableIdentifier = astImportFrom.names[0].name
-	ingredientsFunction = raiseIfNone(unpackDataclassCallFunctionRepackDataclass(ingredientsFunction, targetCallableIdentifier, shatteredDataclass))
-	targetFunctionDef: ast.FunctionDef = raiseIfNone(extractFunctionDef(parseLogicalPath2astModule(raiseIfNone(astImportFrom.module)), targetCallableIdentifier))
-	astTuple: ast.Tuple = cast('ast.Tuple', raiseIfNone(NodeTourist(Be.Return.valueIs(Be.Tuple)
-			, doThat=Then.extractIt(DOT.value)).captureLastMatch(targetFunctionDef)))
-	astTuple.ctx = ast.Store()
+	dataclassInstanceIdentifier: identifierDotAttribute = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef))
 
-	changeAssignCallToTarget = NodeChanger(
-		findThis = Be.Assign.valueIs(IfThis.isCallIdentifier(targetCallableIdentifier))
-		, doThat = Then.replaceWith(Make.Assign([astTuple], value=Make.Call(Make.Name(targetCallableIdentifier), astTuple.elts))))
-	changeAssignCallToTarget.visit(ingredientsFunction.astFunctionDef)
+	findThis = IfThis.isIfUnaryNotAttributeNamespaceIdentifier(dataclassInstanceIdentifier, 'dimensionsUnconstrained')
+	doThat = Then.removeIt
+	NodeChanger(findThis, doThat).visit(ingredientsFunction.astFunctionDef)
 
 	ingredientsModule = IngredientsModule(ingredientsFunction)
 	ingredientsModule.removeImportFromModule('numpy')
@@ -759,15 +722,17 @@ def makeUnRePackDataclass(astImportFrom: ast.ImportFrom) -> None:
 
 	write_astModule(ingredientsModule, pathFilename, packageSettings.identifierPackage)
 
-if __name__ == '__main__':
-	astModule: ast.Module = _getModule(logicalPathInfix=None)
-	makeInitializeGroupsOfFolds(astModule, 'initializeCount', 'initializeGroupsOfFolds', logicalPathInfixDEFAULT)
+	return pathFilename
 
+if __name__ == '__main__':
 	astModule = _getModule(logicalPathInfix=None)
-	pathFilename: PurePath = makeDaoOfMapFolding(astModule, 'daoOfMapFolding', None, logicalPathInfixDEFAULT, sourceCallableDispatcherDEFAULT)
+	pathFilename: PurePath = makeDaoOfMapFoldingNumba(astModule, 'daoOfMapFoldingNumba', None, logicalPathInfixDEFAULT, sourceCallableDispatcherDEFAULT)
 
 	astModule = _getModule(logicalPathInfix=None)
-	pathFilename = makeDaoOfMapFoldingParallel(astModule, 'countParallel', None, logicalPathInfixDEFAULT, sourceCallableDispatcherDEFAULT)
+	pathFilename = makeDaoOfMapFoldingParallelNumba(astModule, 'countParallelNumba', None, logicalPathInfixDEFAULT, sourceCallableDispatcherDEFAULT)
+
+	astModule: ast.Module = _getModule(logicalPathInfix=None)
+	makeInitializeState(astModule, 'initializeState', 'transitionOnGroupsOfFolds', logicalPathInfixDEFAULT)
 
 	astModule = _getModule(logicalPathInfix=None)
 	pathFilename = makeTheorem2(astModule, 'theorem2', None, logicalPathInfixDEFAULT, None)
@@ -780,3 +745,31 @@ if __name__ == '__main__':
 
 	astImportFrom: ast.ImportFrom = Make.ImportFrom(_getLogicalPath(packageSettings.identifierPackage, logicalPathInfixDEFAULT, 'theorem2Numba'), list_alias=[Make.alias(sourceCallableIdentifierDEFAULT)])
 	makeUnRePackDataclass(astImportFrom)
+
+# A007822 -----------------------------------------------------------
+	astModule = _getModule(logicalPathInfix=None)
+	pathFilename = addSymmetryCheck(astModule, 'algorithmA007822', None, logicalPathInfixDEFAULT, None)
+
+	astModule = _getModule(moduleIdentifier='algorithmA007822')
+	pathFilename: PurePath = makeDaoOfMapFoldingNumba(astModule, 'algorithmA007822Numba', None, logicalPathInfixDEFAULT, sourceCallableDispatcherDEFAULT)
+
+	# I can't handle parallel right now.
+
+# TODO Implement logic that lets me amend modules instead of only overwriting them. "initializeState" could/should include state
+# initialization for multiple algorithms.
+	astModule = _getModule(moduleIdentifier='algorithmA007822')
+# NOTE `initializeState.transitionOnGroupsOfFolds` will collide with `initializeStateA007822.transitionOnGroupsOfFolds` if the
+# modules are merged. This problem is a side effect of the problem with `MapFoldingState.groupsOfFolds` and
+# `MapFoldingState.foldsTotal`. If I fix that issue, then the identifier `initializeStateA007822.transitionOnGroupsOfFolds` will
+# naturally change to something more appropriate (and remove the collision).
+	makeInitializeState(astModule, 'initializeStateA007822', 'transitionOnGroupsOfFolds', logicalPathInfixDEFAULT)
+
+	astModule = _getModule(moduleIdentifier='algorithmA007822')
+	pathFilename = makeTheorem2(astModule, 'theorem2A007822', None, logicalPathInfixDEFAULT, None)
+
+	astModule = parsePathFilename2astModule(pathFilename)
+	pathFilename = trimTheorem2(astModule, 'theorem2A007822Trimmed', None, logicalPathInfixDEFAULT, None)
+
+	astModule = parsePathFilename2astModule(pathFilename)
+	pathFilename = numbaOnTheorem2(astModule, 'theorem2A007822Numba', None, logicalPathInfixDEFAULT, None)
+

mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py

@@ -37,7 +37,7 @@ from mapFolding import getPathFilenameFoldsTotal, MapFoldingState, packageSettin
 from mapFolding.someAssemblyRequired import IfThis
 from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2
 from mapFolding.someAssemblyRequired.toolkitNumba import decorateCallableWithNumba, parametersNumbaLight, SpicesJobNumba
-from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
+from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds
 from pathlib import PurePosixPath
 from typing import cast, NamedTuple, TYPE_CHECKING
 from typing_extensions import TypeIs
@@ -326,7 +326,7 @@ if __name__ == '__main__':
 	"""
 
 if __name__ == '__main__':
-	state = initializeGroupsOfFolds(MapFoldingState((2,4)))
+	state = transitionOnGroupsOfFolds(MapFoldingState((2,4)))
 	pathModule = PurePosixPath(packageSettings.pathPackage, 'jobs')
 	pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(state.mapShape, pathModule))
 	aJob = RecipeJobTheorem2(state, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)

mapFolding/someAssemblyRequired/makeJobTheorem2codon.py

@@ -11,7 +11,7 @@ from hunterMakesPy import autoDecodingRLE, raiseIfNone
 from mapFolding import DatatypeLeavesTotal, getPathFilenameFoldsTotal, MapFoldingState
 from mapFolding.someAssemblyRequired import IfThis
 from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2
-from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
+from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds
 from pathlib import Path, PurePosixPath
 from typing import cast, NamedTuple, TYPE_CHECKING
 import ast
@@ -212,7 +212,7 @@ def fromMapShape(mapShape: tuple[DatatypeLeavesTotal, ...]) -> None:
 		along one axis.
 
 	"""
-	state = initializeGroupsOfFolds(MapFoldingState(mapShape))
+	state = transitionOnGroupsOfFolds(MapFoldingState(mapShape))
 	pathModule = PurePosixPath(Path.home(), 'mapFolding', 'jobs')
 	pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(state.mapShape, pathModule))
 	aJob = RecipeJobTheorem2(state, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)