mapFolding 0.9.4__py3-none-any.whl → 0.9.5__py3-none-any.whl

mapFolding/__init__.py

@@ -44,7 +44,41 @@ allowing users to compute map folding totals for larger dimensions than previous
 foundation for exploring advanced code transformation techniques.
 """
 
-from mapFolding.datatypes import (
+from typing import Any, TypeAlias
+import sys
+
+stuPyd: TypeAlias = Any
+
+if sys.version_info >= (3, 12):
+	from ast import (
+		ParamSpec as astDOTParamSpec,
+		type_param as astDOTtype_param,
+		TypeAlias as astDOTTypeAlias,
+		TypeVar as astDOTTypeVar,
+		TypeVarTuple as astDOTTypeVarTuple,
+	)
+else:
+	astDOTParamSpec: TypeAlias = stuPyd
+	astDOTtype_param: TypeAlias = stuPyd
+	astDOTTypeAlias: TypeAlias = stuPyd
+	astDOTTypeVar: TypeAlias = stuPyd
+	astDOTTypeVarTuple: TypeAlias = stuPyd
+
+if sys.version_info >= (3, 11):
+	from ast import TryStar as astDOTTryStar
+	from typing import TypedDict as TypedDict
+	from typing import NotRequired as NotRequired
+else:
+	astDOTTryStar: TypeAlias = stuPyd
+	try:
+		from typing_extensions import TypedDict as TypedDict
+		from typing_extensions import NotRequired as NotRequired
+	except Exception:
+		TypedDict = dict[stuPyd, stuPyd]
+		from collections.abc import Iterable
+		NotRequired: TypeAlias = Iterable
+
+from mapFolding.datatypes import (  # noqa: E402
 	Array1DElephino as Array1DElephino,
 	Array1DFoldsTotal as Array1DFoldsTotal,
 	Array1DLeavesTotal as Array1DLeavesTotal,
@@ -58,18 +92,18 @@ from mapFolding.datatypes import (
 	NumPyLeavesTotal as NumPyLeavesTotal,
 )
 
-from mapFolding.theSSOT import (
+from mapFolding.theSSOT import (  # noqa: E402
 	ComputationState as ComputationState,
 	raiseIfNoneGitHubIssueNumber3 as raiseIfNoneGitHubIssueNumber3,
 	The as The,
 )
 
-from mapFolding.theDao import (
+from mapFolding.theDao import (  # noqa: E402
 	countInitialize as countInitialize,
 	doTheNeedful as doTheNeedful,
 )
 
-from mapFolding.beDRY import (
+from mapFolding.beDRY import (  # noqa: E402
 	getLeavesTotal as getLeavesTotal,
 	getTaskDivisions as getTaskDivisions,
 	outfitCountFolds as outfitCountFolds,
@@ -77,7 +111,7 @@ from mapFolding.beDRY import (
 	validateListDimensions as validateListDimensions,
 )
 
-from mapFolding.toolboxFilesystem import (
+from mapFolding.toolboxFilesystem import (  # noqa: E402
 	getPathFilenameFoldsTotal as getPathFilenameFoldsTotal,
 	getPathRootJobDEFAULT as getPathRootJobDEFAULT,
 	saveFoldsTotal as saveFoldsTotal,
@@ -85,9 +119,9 @@ from mapFolding.toolboxFilesystem import (
 	writeStringToHere as writeStringToHere,
 )
 
-from mapFolding.Z0Z_flowControl import countFolds
+from mapFolding.basecamp import countFolds as countFolds  # noqa: E402
 
-from mapFolding.oeis import (
+from mapFolding.oeis import (  # noqa: E402
 	clearOEIScache as clearOEIScache,
 	getFoldsTotalKnown as getFoldsTotalKnown,
 	getOEISids as getOEISids,

mapFolding/basecamp.py

@@ -23,10 +23,15 @@ from mapFolding import (
 from os import PathLike
 from pathlib import PurePath
 
-def countFolds(listDimensions: Sequence[int]
+def countFolds(listDimensions: Sequence[int] | None = None
 				, pathLikeWriteFoldsTotal: PathLike[str] | PurePath | None = None
 				, computationDivisions: int | str | None = None
 				, CPUlimit: int | float | bool | None = None
+				# , * I need to improve `standardizedEqualToCallableReturn` so it will work with keyword arguments
+				, mapShape: tuple[int, ...] | None = None
+				, oeisID: str | None = None
+				, oeis_n: int | None = None
+				, flow: str | None = None
 				) -> int:
 	"""
 	Count the total number of possible foldings for a given map dimensions.
@@ -75,21 +80,107 @@ def countFolds(listDimensions: Sequence[int]
 	computation time. If logicalCores >= `leavesTotal`, it will probably be faster. If logicalCores <= 2 * `leavesTotal`, it
 	will almost certainly be slower for all map dimensions.
 	"""
-	mapShape: tuple[int, ...] = validateListDimensions(listDimensions)
-	concurrencyLimit: int = setProcessorLimit(CPUlimit, The.concurrencyPackage)
-	computationStateInitialized: ComputationState = outfitCountFolds(mapShape, computationDivisions, concurrencyLimit)
+	# mapShape =====================================================================
+
+	if mapShape:
+		pass
+	else:
+		if oeisID and oeis_n:
+			from mapFolding.oeis import settingsOEIS
+			try:
+				mapShape = settingsOEIS[oeisID]['getMapShape'](oeis_n)
+			except KeyError:
+				pass
+		if not mapShape and listDimensions:
+			mapShape = validateListDimensions(listDimensions)
+
+	if mapShape is None:
+		raise ValueError(f"""I received these values:
+	`{listDimensions = }`,
+	`{mapShape = }`,
+	`{oeisID = }` and `{oeis_n = }`,
+	but I was unable to select a map for which to count the folds.""")
+
+	# task division instructions ===============================================
+
+	if computationDivisions:
+		# NOTE `The.concurrencyPackage`
+		concurrencyLimit: int = setProcessorLimit(CPUlimit, The.concurrencyPackage)
+		from mapFolding.beDRY import getLeavesTotal, getTaskDivisions
+		leavesTotal: int = getLeavesTotal(mapShape)
+		taskDivisions = getTaskDivisions(computationDivisions, concurrencyLimit, leavesTotal)
+		del leavesTotal
+	else:
+		concurrencyLimit = 1
+		taskDivisions = 0
+
+	# memorialization instructions ===========================================
 
 	if pathLikeWriteFoldsTotal is not None:
-		pathFilenameFoldsTotal = getPathFilenameFoldsTotal(computationStateInitialized.mapShape, pathLikeWriteFoldsTotal)
+		pathFilenameFoldsTotal = getPathFilenameFoldsTotal(mapShape, pathLikeWriteFoldsTotal)
 		saveFoldsTotalFAILearly(pathFilenameFoldsTotal)
 	else:
 		pathFilenameFoldsTotal = None
 
-	computationStateComplete: ComputationState = The.dispatcher(computationStateInitialized)
+	# Flow control until I can figure out a good way ===============================
+
+	if flow == 'daoOfMapFolding':
+		from mapFolding.dataBaskets import MapFoldingState
+		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+		from mapFolding.daoOfMapFolding import doTheNeedful
+		mapFoldingState = doTheNeedful(mapFoldingState)
+		foldsTotal = mapFoldingState.foldsTotal
+
+	elif flow == 'theorem2' and any((dimension > 2 for dimension in mapShape)):
+		from mapFolding.dataBaskets import MapFoldingState
+		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+		from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
+		mapFoldingState = initializeGroupsOfFolds(mapFoldingState)
+
+		from mapFolding.syntheticModules.theorem2 import count
+		mapFoldingState = count(mapFoldingState)
+
+		foldsTotal = mapFoldingState.foldsTotal
+
+	elif flow == 'theorem2Trimmed' and any((dimension > 2 for dimension in mapShape)):
+		from mapFolding.dataBaskets import MapFoldingState
+		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+		from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
+		mapFoldingState = initializeGroupsOfFolds(mapFoldingState)
+
+		from mapFolding.syntheticModules.theorem2Trimmed import count
+		mapFoldingState = count(mapFoldingState)
+
+		foldsTotal = mapFoldingState.foldsTotal
+
+	elif (flow == 'theorem2Numba' or taskDivisions == 0) and any((dimension > 2 for dimension in mapShape)):
+		from mapFolding.dataBaskets import MapFoldingState
+		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+		from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
+		mapFoldingState = initializeGroupsOfFolds(mapFoldingState)
+
+		from mapFolding.syntheticModules.dataPacking import doTheNeedful
+		mapFoldingState = doTheNeedful(mapFoldingState)
+
+		foldsTotal = mapFoldingState.foldsTotal
+
+	# NOTE treat this as a default?
+	# flow based on `The` and `ComputationState` ====================================
+
+	else:
+		computationStateInitialized: ComputationState = outfitCountFolds(mapShape, computationDivisions, concurrencyLimit)
+		computationStateComplete: ComputationState = The.dispatcher(computationStateInitialized)
+
+		computationStateComplete.getFoldsTotal()
+		foldsTotal = computationStateComplete.foldsTotal
 
-	computationStateComplete.getFoldsTotal()
+	# Follow memorialization instructions ===========================================
 
 	if pathFilenameFoldsTotal is not None:
-		saveFoldsTotal(pathFilenameFoldsTotal, computationStateComplete.foldsTotal)
+		saveFoldsTotal(pathFilenameFoldsTotal, foldsTotal)
 
-	return computationStateComplete.foldsTotal
+	return foldsTotal

mapFolding/beDRY.py

@@ -59,14 +59,12 @@ def getTaskDivisions(computationDivisions: int | str | None, concurrencyLimit: i
 	"""
 	Determines whether to divide the computation into tasks and how many divisions.
 
+
 	Parameters
 	----------
 	computationDivisions: None
-		Specifies how to divide computations:
-		- `None`: no division of the computation into tasks; sets task divisions to 0.
-		- int: directly set the number of task divisions; cannot exceed the map's total leaves.
-		- `'maximum'`: divides into `leavesTotal`-many `taskDivisions`.
-		- `'cpu'`: limits the divisions to the number of available CPUs: i.e., `concurrencyLimit`.
+		Specifies how to divide computations: Please see the documentation in `countFolds` for details. I know it is
+		annoying, but I want to be sure you have the most accurate information.
 	concurrencyLimit
 		Maximum number of concurrent tasks allowed.
 
@@ -224,7 +222,7 @@ def outfitCountFolds(mapShape: tuple[int, ...], computationDivisions: int | str
 		A tuple of integers representing the dimensions of the map.
 	computationDivisions: None
 		Controls how to divide the computation into parallel tasks. I know it is annoying, but please see
-		`getTaskDivisions` for details, so that you and I both know you have the most accurate information.
+		`countFolds` for details, so that you and I both know you have the most accurate information.
 	concurrencyLimit: 1
 		Maximum number of concurrent processes to use during computation.
 
@@ -245,19 +243,13 @@ def outfitCountFolds(mapShape: tuple[int, ...], computationDivisions: int | str
 
 def setProcessorLimit(CPUlimit: Any | None, concurrencyPackage: str | None = None) -> int:
 	"""
-	Sets processor limit for concurrent operations.
+	Whether and how to limit the CPU usage.
 
 	Parameters
 	----------
 	CPUlimit: None
-		Controls processor usage limits:
-		- `False`, `None`, or `0`: No limits on processor usage; uses all available processors. All other values will
-		potentially limit processor usage.
-		- `True`: Yes, limit the processor usage; limits to 1 processor.
-		- Integer `>= 1`: Limits usage to the specified number of processors.
-		- Decimal value (`float`) between 0 and 1: Fraction of total processors to use.
-		- Decimal value (`float`) between -1 and 0: Fraction of processors to _not_ use.
-		- Integer `<= -1`: Subtract the absolute value from total processors.
+		Please see the documentation for in `countFolds` for details. I know it is annoying, but I want to be sure you
+		have the most accurate information.
 	concurrencyPackage: None
 		Specifies which concurrency package to use:
 		- `None` or `'multiprocessing'`: Uses standard `multiprocessing`.

mapFolding/dataBaskets.py

@@ -47,3 +47,15 @@ class MapFoldingState:
 		if self.gapRangeStart is None: self.gapRangeStart = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['gapRangeStart'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
 		if self.leafAbove is None: self.leafAbove = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafAbove'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
 		if self.leafBelow is None: self.leafBelow = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafBelow'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
+
+@dataclasses.dataclass
+class LeafSequenceState(MapFoldingState):
+	leafSequence: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+
+	def __post_init__(self) -> None:
+		super().__post_init__()
+		from mapFolding.oeis import getFoldsTotalKnown
+		groupsOfFoldsKnown = getFoldsTotalKnown(self.mapShape) // self.leavesTotal
+		if self.leafSequence is None: # pyright: ignore[reportUnnecessaryComparison]
+			self.leafSequence = makeDataContainer(groupsOfFoldsKnown, self.__dataclass_fields__['leafSequence'].metadata['dtype'])
+			self.leafSequence[self.groupsOfFolds] = self.leaf1ndex

mapFolding/datatypes.py

@@ -1,4 +1,4 @@
-from numpy import dtype, int64 as numpy_int64, integer, ndarray
+from numpy import dtype, uint8 as numpy_uint8, uint16 as numpy_uint16, uint64 as numpy_uint64, integer, ndarray
 from typing import Any, TypeAlias, TypeVar
 
 # =============================================================================
@@ -7,13 +7,13 @@ from typing import Any, TypeAlias, TypeVar
 NumPyIntegerType = TypeVar('NumPyIntegerType', bound=integer[Any], covariant=True)
 
 DatatypeLeavesTotal: TypeAlias = int
-NumPyLeavesTotal: TypeAlias = numpy_int64
+NumPyLeavesTotal: TypeAlias = numpy_uint8
 
 DatatypeElephino: TypeAlias = int
-NumPyElephino: TypeAlias = numpy_int64
+NumPyElephino: TypeAlias = numpy_uint16
 
 DatatypeFoldsTotal: TypeAlias = int
-NumPyFoldsTotal: TypeAlias = numpy_int64
+NumPyFoldsTotal: TypeAlias = numpy_uint64
 
 Array3D: TypeAlias = ndarray[tuple[int, int, int], dtype[NumPyLeavesTotal]]
 Array1DLeavesTotal: TypeAlias = ndarray[tuple[int], dtype[NumPyLeavesTotal]]

mapFolding/oeis.py

@@ -20,9 +20,9 @@ mathematical definition in OEIS and the computational implementation in the pack
 from collections.abc import Callable
 from datetime import datetime, timedelta
 from functools import cache
-from mapFolding import countFolds, The, writeStringToHere
+from mapFolding import countFolds, The, TypedDict, writeStringToHere
 from pathlib import Path
-from typing import Any, Final, TYPE_CHECKING
+from typing import Any, Final
 import argparse
 import random
 import sys
@@ -31,11 +31,6 @@ import urllib.request
 import urllib.response
 import warnings
 
-if TYPE_CHECKING:
-	from typing import TypedDict
-else:
-	TypedDict = dict[Any, Any]
-
 cacheDays = 30
 
 pathCache: Path = The.pathPackage / ".cache"

mapFolding/someAssemblyRequired/RecipeJob.py

@@ -1,12 +1,12 @@
-from mapFolding.someAssemblyRequired import ShatteredDataclass, ast_Identifier, parsePathFilename2astModule, str_nameDOTname
+from mapFolding.someAssemblyRequired import ShatteredDataclass, ast_Identifier, parseLogicalPath2astModule, parsePathFilename2astModule, str_nameDOTname
 from mapFolding.someAssemblyRequired.toolboxNumba import theNumbaFlow
 from mapFolding.someAssemblyRequired.transformationTools import shatter_dataclassesDOTdataclass
 from mapFolding.theSSOT import ComputationState, DatatypeElephino as TheDatatypeElephino, DatatypeFoldsTotal as TheDatatypeFoldsTotal, DatatypeLeavesTotal as TheDatatypeLeavesTotal
 from mapFolding.toolboxFilesystem import getPathFilenameFoldsTotal, getPathRootJobDEFAULT
-
-import dataclasses
+from mapFolding.dataBaskets import MapFoldingState
 from pathlib import Path, PurePosixPath
 from typing import TypeAlias
+import dataclasses
 
 @dataclasses.dataclass
 class RecipeJob:
@@ -101,3 +101,97 @@ class RecipeJob:
 	dataclassInstanceTaskDistribution: ast_Identifier = sourceDataclassInstanceTaskDistribution
 	concurrencyManagerNamespace: ast_Identifier = sourceConcurrencyManagerNamespace
 	concurrencyManagerIdentifier: ast_Identifier = sourceConcurrencyManagerIdentifier
+
+@dataclasses.dataclass
+class RecipeJobTheorem2Numba:
+	state: MapFoldingState
+	# TODO create function to calculate `foldsTotalEstimated`
+	foldsTotalEstimated: int = 0
+	shatteredDataclass: ShatteredDataclass = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
+
+	# ========================================
+	# Source
+	source_astModule = parseLogicalPath2astModule('mapFolding.syntheticModules.theorem2Numba')
+	sourceCountCallable: ast_Identifier = 'count'
+
+	sourceLogicalPathModuleDataclass: str_nameDOTname = 'mapFolding.dataBaskets'
+	sourceDataclassIdentifier: ast_Identifier = 'MapFoldingState'
+	sourceDataclassInstance: ast_Identifier = theNumbaFlow.dataclassInstance
+
+	sourcePathPackage: PurePosixPath | None = theNumbaFlow.pathPackage
+	sourcePackageIdentifier: ast_Identifier | None = theNumbaFlow.packageIdentifier
+
+	# ========================================
+	# Filesystem (names of physical objects)
+	pathPackage: PurePosixPath | None = None
+	pathModule: PurePosixPath | None = PurePosixPath(getPathRootJobDEFAULT())
+	""" `pathModule` will override `pathPackage` and `logicalPathRoot`."""
+	fileExtension: str = theNumbaFlow.fileExtension
+	pathFilenameFoldsTotal: PurePosixPath = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
+
+	# ========================================
+	# Logical identifiers (as opposed to physical identifiers)
+	packageIdentifier: ast_Identifier | None = None
+	logicalPathRoot: str_nameDOTname | None = None
+	""" `logicalPathRoot` likely corresponds to a physical filesystem directory."""
+	moduleIdentifier: ast_Identifier = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
+	countCallable: ast_Identifier = sourceCountCallable
+	dataclassIdentifier: ast_Identifier | None = sourceDataclassIdentifier
+	dataclassInstance: ast_Identifier | None = sourceDataclassInstance
+	logicalPathModuleDataclass: str_nameDOTname | None = sourceLogicalPathModuleDataclass
+
+	# ========================================
+	# Datatypes
+	DatatypeFoldsTotal: TypeAlias = TheDatatypeFoldsTotal
+	DatatypeElephino: TypeAlias = TheDatatypeElephino
+	DatatypeLeavesTotal: TypeAlias = TheDatatypeLeavesTotal
+
+	def _makePathFilename(self,
+			pathRoot: PurePosixPath | None = None,
+			logicalPathINFIX: str_nameDOTname | None = None,
+			filenameStem: str | None = None,
+			fileExtension: str | None = None,
+			) -> PurePosixPath:
+		if pathRoot is None:
+			pathRoot = self.pathPackage or PurePosixPath(Path.cwd())
+		if logicalPathINFIX:
+			whyIsThisStillAThing: list[str] = logicalPathINFIX.split('.')
+			pathRoot = pathRoot.joinpath(*whyIsThisStillAThing)
+		if filenameStem is None:
+			filenameStem = self.moduleIdentifier
+		if fileExtension is None:
+			fileExtension = self.fileExtension
+		filename: str = filenameStem + fileExtension
+		return pathRoot.joinpath(filename)
+
+	@property
+	def pathFilenameModule(self) -> PurePosixPath:
+		if self.pathModule is None:
+			return self._makePathFilename()
+		else:
+			return self._makePathFilename(pathRoot=self.pathModule, logicalPathINFIX=None)
+
+	def __post_init__(self):
+		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.shatteredDataclass is None and self.logicalPathModuleDataclass and self.dataclassIdentifier and self.dataclassInstance: # pyright: ignore[reportUnnecessaryComparison]
+			self.shatteredDataclass = shatter_dataclassesDOTdataclass(self.logicalPathModuleDataclass, self.dataclassIdentifier, self.dataclassInstance)
+
+	# ========================================
+	# Fields you probably don't need =================================
+	# Dispatcher =================================
+	sourceDispatcherCallable: ast_Identifier = theNumbaFlow.callableDispatcher
+	dispatcherCallable: ast_Identifier = sourceDispatcherCallable
+	# Parallel counting =================================
+	sourceDataclassInstanceTaskDistribution: ast_Identifier = theNumbaFlow.dataclassInstanceTaskDistribution
+	sourceConcurrencyManagerNamespace: ast_Identifier = theNumbaFlow.concurrencyManagerNamespace
+	sourceConcurrencyManagerIdentifier: ast_Identifier = theNumbaFlow.concurrencyManagerIdentifier
+	dataclassInstanceTaskDistribution: ast_Identifier = sourceDataclassInstanceTaskDistribution
+	concurrencyManagerNamespace: ast_Identifier = sourceConcurrencyManagerNamespace
+	concurrencyManagerIdentifier: ast_Identifier = sourceConcurrencyManagerIdentifier

mapFolding/someAssemblyRequired/Z0Z_makeSomeModules.py

@@ -64,11 +64,79 @@ def makeInitializeGroupsOfFolds():
 	]))
 	NodeChanger(findThis, doThat).visit(countInitializeIngredients.astFunctionDef.body[0])
 
-	initializationModule = IngredientsModule(countInitializeIngredients)
+	ingredientsModule = IngredientsModule(countInitializeIngredients)
 
 	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
 
-	write_astModule(initializationModule, pathFilename, The.packageName)
+	write_astModule(ingredientsModule, pathFilename, The.packageName)
+
+def makeDaoOfMapFolding():
+	moduleIdentifierHARDCODED: ast_Identifier = 'daoOfMapFolding'
+
+	algorithmSourceModule = algorithmSourceModuleHARDCODED
+	sourceCallableIdentifier = sourceCallableIdentifierHARDCODED
+	logicalPathSourceModule = '.'.join([The.packageName, algorithmSourceModule])
+
+	logicalPathInfix = logicalPathInfixHARDCODED
+	moduleIdentifier = moduleIdentifierHARDCODED
+
+	astModule = parseLogicalPath2astModule(logicalPathSourceModule)
+	daoOfMapFolding = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule)
+		, LedgerOfImports(astModule))
+
+	dataclassName: ast.expr | None = NodeTourist(be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(daoOfMapFolding.astFunctionDef)
+	if dataclassName is None: raise raiseIfNoneGitHubIssueNumber3
+	dataclass_Identifier: ast_Identifier | None = NodeTourist(be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName)
+	if dataclass_Identifier is None: raise raiseIfNoneGitHubIssueNumber3
+
+	dataclassLogicalPathModule = None
+	for moduleWithLogicalPath, listNameTuples in daoOfMapFolding.imports.dictionaryImportFrom.items():
+		for nameTuple in listNameTuples:
+			if nameTuple[0] == dataclass_Identifier:
+				dataclassLogicalPathModule = moduleWithLogicalPath
+				break
+		if dataclassLogicalPathModule:
+			break
+	if dataclassLogicalPathModule is None: raise raiseIfNoneGitHubIssueNumber3
+	dataclassInstanceIdentifier = NodeTourist(be.arg, Then.extractIt(DOT.arg)).captureLastMatch(daoOfMapFolding.astFunctionDef)
+	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
+	shatteredDataclass = shatter_dataclassesDOTdataclass(dataclassLogicalPathModule, dataclass_Identifier, dataclassInstanceIdentifier)
+
+	# theCountingIdentifier = theCountingIdentifierHARDCODED
+	# doubleTheCount = Make.AugAssign(Make.Attribute(ast.Name(dataclassInstanceIdentifier), theCountingIdentifier), ast.Mult(), Make.Constant(2))
+	# findThis = be.Return
+	# doThat = Then.insertThisAbove([doubleTheCount])
+	# NodeChanger(findThis, doThat).visit(daoOfMapFolding.astFunctionDef)
+
+	daoOfMapFolding.imports.update(shatteredDataclass.imports)
+	daoOfMapFolding = removeDataclassFromFunction(daoOfMapFolding, shatteredDataclass)
+
+	daoOfMapFolding = removeUnusedParameters(daoOfMapFolding)
+
+	daoOfMapFolding = decorateCallableWithNumba(daoOfMapFolding, parametersNumbaLight)
+
+	sourceCallableIdentifier = The.sourceCallableDispatcher
+
+	doTheNeedful: IngredientsFunction = astModuleToIngredientsFunction(astModule, sourceCallableIdentifier)
+	doTheNeedful.imports.update(shatteredDataclass.imports)
+	targetCallableIdentifier = daoOfMapFolding.astFunctionDef.name
+	doTheNeedful = unpackDataclassCallFunctionRepackDataclass(doTheNeedful, targetCallableIdentifier, shatteredDataclass)
+	astTuple: ast.Tuple | None = NodeTourist(be.Return, Then.extractIt(DOT.value)).captureLastMatch(daoOfMapFolding.astFunctionDef)
+	if astTuple is None: raise raiseIfNoneGitHubIssueNumber3
+	astTuple.ctx = ast.Store()
+
+	findThis = ifThis.isAssignAndValueIs(ifThis.isCall_Identifier(targetCallableIdentifier))
+	doThat = Then.replaceWith(Make.Assign(listTargets=[astTuple], value=Make.Call(Make.Name(targetCallableIdentifier), astTuple.elts)))
+	NodeChanger(findThis, doThat).visit(doTheNeedful.astFunctionDef)
+
+	ingredientsModule = IngredientsModule([daoOfMapFolding, doTheNeedful])
+	ingredientsModule.removeImportFromModule('numpy')
+
+	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
+
+	write_astModule(ingredientsModule, pathFilename, The.packageName)
+
+	return pathFilename
 
 def makeTheorem2():
 	moduleIdentifierHARDCODED: ast_Identifier = 'theorem2'
@@ -112,11 +180,42 @@ def makeTheorem2():
 	doThat = Then.insertThisAbove([doubleTheCount])
 	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
 
-	moduleTheorem2 = IngredientsModule(countTheorem2)
+	ingredientsModule = IngredientsModule(countTheorem2)
 
 	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
 
-	write_astModule(moduleTheorem2, pathFilename, The.packageName)
+	write_astModule(ingredientsModule, pathFilename, The.packageName)
+
+	return pathFilename
+
+def trimTheorem2(pathFilenameSource: PurePath):
+	logicalPathInfix = logicalPathInfixHARDCODED
+	sourceCallableIdentifier = sourceCallableIdentifierHARDCODED
+	ingredientsFunction = astModuleToIngredientsFunction(parsePathFilename2astModule(pathFilenameSource), sourceCallableIdentifier)
+
+	dataclassInstanceIdentifier = NodeTourist(be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef)
+	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
+
+	findThis = ifThis.isIfUnaryNotAttributeNamespace_Identifier(dataclassInstanceIdentifier, 'dimensionsUnconstrained')
+	doThat = Then.removeIt
+	NodeChanger(findThis, doThat).visit(ingredientsFunction.astFunctionDef)
+
+	ingredientsModule = IngredientsModule(ingredientsFunction)
+	ingredientsModule.removeImportFromModule('numpy')
+
+	pathFilename = pathFilenameSource.with_stem(pathFilenameSource.stem + 'Trimmed')
+
+	write_astModule(ingredientsModule, pathFilename, The.packageName)
+
+	logicalPath: list[str] = []
+	if The.packageName:
+		logicalPath.append(The.packageName)
+	if logicalPathInfix:
+		logicalPath.append(logicalPathInfix)
+	logicalPath.append(pathFilename.stem)
+	moduleWithLogicalPath: str_nameDOTname = '.'.join(logicalPath)
+
+	astImportFrom: ast.ImportFrom = Make.ImportFrom(moduleWithLogicalPath, list_astAlias=[Make.alias(ingredientsFunction.astFunctionDef.name)])
 
 	return pathFilename
 
@@ -149,12 +248,12 @@ def numbaOnTheorem2(pathFilenameSource: PurePath):
 
 	countNumbaTheorem2 = decorateCallableWithNumba(countNumbaTheorem2, parametersNumbaLight)
 
-	moduleNumbaTheorem2 = IngredientsModule(countNumbaTheorem2)
-	moduleNumbaTheorem2.removeImportFromModule('numpy')
+	ingredientsModule = IngredientsModule(countNumbaTheorem2)
+	ingredientsModule.removeImportFromModule('numpy')
 
-	pathFilename = pathFilenameSource.with_stem(pathFilenameSource.stem + 'Numba')
+	pathFilename = pathFilenameSource.with_stem(pathFilenameSource.stem.replace('Trimmed', '') + 'Numba')
 
-	write_astModule(moduleNumbaTheorem2, pathFilename, The.packageName)
+	write_astModule(ingredientsModule, pathFilename, The.packageName)
 
 	logicalPath: list[str] = []
 	if The.packageName:
@@ -175,7 +274,6 @@ def makeUnRePackDataclass(astImportFrom: ast.ImportFrom):
 	sourceCallableIdentifier = The.sourceCallableDispatcher
 	logicalPathSourceModule = '.'.join([The.packageName, algorithmSourceModule])
 
-	callableIdentifier = sourceCallableIdentifier
 	logicalPathInfix = logicalPathInfixHARDCODED
 	moduleIdentifier = moduleIdentifierHARDCODED
 
@@ -212,15 +310,17 @@ def makeUnRePackDataclass(astImportFrom: ast.ImportFrom):
 	doThat = Then.replaceWith(Make.Assign(listTargets=[astTuple], value=Make.Call(Make.Name(targetCallableIdentifier), astTuple.elts)))
 	NodeChanger(findThis, doThat).visit(doTheNeedful.astFunctionDef)
 
-	moduleDoTheNeedful = IngredientsModule(doTheNeedful)
-	moduleDoTheNeedful.removeImportFromModule('numpy')
+	ingredientsModule = IngredientsModule(doTheNeedful)
+	ingredientsModule.removeImportFromModule('numpy')
 
 	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
 
-	write_astModule(moduleDoTheNeedful, pathFilename, The.packageName)
+	write_astModule(ingredientsModule, pathFilename, The.packageName)
 
 if __name__ == '__main__':
 	makeInitializeGroupsOfFolds()
 	pathFilename = makeTheorem2()
+	pathFilename = trimTheorem2(pathFilename)
 	astImportFrom = numbaOnTheorem2(pathFilename)
 	makeUnRePackDataclass(astImportFrom)
+	makeDaoOfMapFolding()