mapFolding 0.15.4__py3-none-any.whl → 0.16.1__py3-none-any.whl

mapFolding/basecamp.py

@@ -1,22 +1,27 @@
 """Unified interface for map folding computation."""
 
 from collections.abc import Sequence
+from functools import cache
 from mapFolding import (
-	getPathFilenameFoldsTotal, packageSettings, saveFoldsTotal, saveFoldsTotalFAILearly, setProcessorLimit,
-	validateListDimensions)
+	getPathFilenameFoldsTotal, packageSettings, saveFoldsTotal, saveFoldsTotalFAILearly, validateListDimensions)
 from os import PathLike
 from pathlib import PurePath
-import contextlib
+from typing import Literal
 
+# ruff: noqa: PLC0415
 """TODO new flow paradigm, incomplete
 
+I don't want to FORCE people to use the meaningless OEIS ids without providing the definition of the ID at the same time.
+
+On the other hand, I don't have any evidence that anyone is using this package except me.
+
 algorithms directory
 	manually coded algorithms or formulas
-	countFolds will be a stable interface for multidimensional map folding, including synthetic modules
+	`countFolds` will be a stable interface for multidimensional map folding, including synthetic modules
 		This has special treatment because people may want to call mapShape not defined in OEIS
-	countMeanders will be a stable interface for meanders
+	`countMeanders` will be a stable interface for meanders
 		This has special treatment because people may want to call meanders not defined in OEIS
-	an enhanced version of oeisIDfor_n will be a stable interface for calling by ID and n
+	an enhanced version of `oeisIDfor_n` will be a stable interface for calling by ID and n
 
 General flow structure
 	doTheNeedful
@@ -60,14 +65,20 @@ General flow structure
 
 """
 
+# Parameters
+	# What you want to compute
+	# Memorialization
+	# Concurrency
+	# How you want to compute it
+# Interpretation of parameters
+	# Input data
+
 def countFolds(listDimensions: Sequence[int] | None = None
 				, pathLikeWriteFoldsTotal: PathLike[str] | PurePath | None = None
 				, computationDivisions: int | str | None = None
 				# , * # TODO improve `standardizedEqualToCallableReturn` so it will work with keyword arguments
 				, CPUlimit: bool | float | int | None = None  # noqa: FBT001
 				, mapShape: tuple[int, ...] | None = None
-				, oeisID: str | None = None
-				, oeis_n: int | None = None
 				, flow: str | None = None
 				) -> int:
 	"""
@@ -92,8 +103,7 @@ def countFolds(listDimensions: Sequence[int] | None = None
 		- 'maximum': divides the computation into `leavesTotal`-many tasks.
 		- 'cpu': divides the computation into the number of available CPUs.
 	CPUlimit : bool | float | int | None = None
-		If relevant, whether and how to limit the number of processors `countFolds` will use. `CPUlimit` is an irrelevant setting
-		unless the computation is divided into more than one task with the `computationDivisions` parameter.
+		If relevant, whether and how to limit the number of processors `countFolds` will use.
 		- `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.
@@ -108,10 +118,6 @@ def countFolds(listDimensions: Sequence[int] | None = None
 		"dimensions", such as in the seminal paper, "Multi-dimensional map-folding". Nevertheless, in contemporary Python
 		programming, in the context of these algorithms, the term "shape" makes it much easier to align the mathematics with the
 		syntax of the programming language.
-	oeisID : str | None = None
-		The On-Line Encyclopedia of Integer Sequences (OEIS) ID for which to compute a(n) for value of 'n' set in `oeis_n`.
-	oeis_n : int | None = None
-		The 'n' value for the `oeisID`.
 	flow : str | None = None
 		My stupid way of selecting the version of the algorithm to use in the computation. There are certainly better ways to do
 		this, but I have not yet solved this issue. As of 2025 Aug 14, these values will work:
@@ -143,20 +149,12 @@ def countFolds(listDimensions: Sequence[int] | None = None
 
 	if mapShape:
 		pass
-	else:
-		if oeisID and oeis_n:
-			from mapFolding.oeis import dictionaryOEISMapFolding  # noqa: PLC0415
-			with contextlib.suppress(KeyError):
-				mapShape = dictionaryOEISMapFolding[oeisID]['getMapShape'](oeis_n)
-		if not mapShape and listDimensions:
-			mapShape = validateListDimensions(listDimensions)
+	elif listDimensions:
+		mapShape = validateListDimensions(listDimensions)
 
 	if mapShape is None:
-		message = (
-			f"""I received these values:
-	`{listDimensions = }`,
-	`{mapShape = }`,
-	`{oeisID = }` and `{oeis_n = }`,
+		message = (f"""I received these values:
+	`{listDimensions = }` and `{mapShape = }`,
 	but I was unable to select a map for which to count the folds."""
 		)
 		raise ValueError(message)
@@ -164,8 +162,8 @@ def countFolds(listDimensions: Sequence[int] | None = None
 	# task division instructions -----------------------------------------------------
 
 	if computationDivisions:
+		from mapFolding.beDRY import getLeavesTotal, getTaskDivisions, setProcessorLimit
 		concurrencyLimit: int = setProcessorLimit(CPUlimit, packageSettings.concurrencyPackage)
-		from mapFolding.beDRY import getLeavesTotal, getTaskDivisions  # noqa: PLC0415
 		leavesTotal: int = getLeavesTotal(mapShape)
 		taskDivisions = getTaskDivisions(computationDivisions, concurrencyLimit, leavesTotal)
 		del leavesTotal
@@ -183,133 +181,72 @@ def countFolds(listDimensions: Sequence[int] | None = None
 
 	# Flow control until I can figure out a good way ---------------------------------
 
-	# A007822 flow control until I can figure out a good way ---------------------------------
-	if oeisID == 'A007822':
-		"""To use A007822, oeisID is mandatory.
-
-		`if oeisID == 'A007822'` precedes the `elif flow ==` cascade because A007822 is fundamentally incompatible with those flow
-		paths and it will cause `Exception` or incorrect computations.
-
-		Parallel version:
-			idk. The computation division logic will try to execute. As of 2025 Aug 13 at 11 PM, I haven't tried or thought about
-			a parallel version. And I don't really care. Potential parallelism is certainly present in `filterAsymmetricFolds`.
-			But, if I want to implement that, I should almost certainly replace `filterAsymmetricFolds` with a non-blocking
-			function to which `count` can pass the necessary values to. TODO Watch out for errors.
-
-		"""
-		match flow:
-			case 'numba':
-				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
-				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
-
-				from mapFolding.syntheticModules.algorithmA007822Numba import doTheNeedful  # noqa: PLC0415
-				mapFoldingState = doTheNeedful(mapFoldingState)
-
-			case 'theorem2':
-				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
-				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
-
-				from mapFolding.syntheticModules.initializeStateA007822 import transitionOnGroupsOfFolds  # noqa: PLC0415
-				mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
-
-				from mapFolding.syntheticModules.theorem2A007822 import count  # noqa: PLC0415
-				mapFoldingState = count(mapFoldingState)
-
-			case 'theorem2Numba':
-				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
-				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
-
-				from mapFolding.syntheticModules.initializeStateA007822 import transitionOnGroupsOfFolds  # noqa: PLC0415
-				mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
-
-				from mapFolding.syntheticModules.dataPackingA007822 import sequential  # noqa: PLC0415
-				mapFoldingState = sequential(mapFoldingState)
-
-			case 'theorem2Trimmed':
-				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
-				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
-
-				from mapFolding.syntheticModules.initializeStateA007822 import transitionOnGroupsOfFolds  # noqa: PLC0415
-				mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
-
-				from mapFolding.syntheticModules.theorem2A007822Trimmed import count  # noqa: PLC0415
-				mapFoldingState = count(mapFoldingState)
-
-			case _:
-				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
-				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
-
-				from mapFolding.syntheticModules.algorithmA007822 import doTheNeedful  # noqa: PLC0415
-				mapFoldingState = doTheNeedful(mapFoldingState)
-
-		foldsTotal = mapFoldingState.groupsOfFolds
-
-	elif flow == 'daoOfMapFolding':
-		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
+	if flow == 'daoOfMapFolding':
+		from mapFolding.dataBaskets import MapFoldingState
 		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 
-		from mapFolding.algorithms.daoOfMapFolding import doTheNeedful  # noqa: PLC0415
+		from mapFolding.algorithms.daoOfMapFolding import doTheNeedful
 		mapFoldingState = doTheNeedful(mapFoldingState)
 		foldsTotal = mapFoldingState.foldsTotal
 
 	elif flow == 'numba':
-		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
+		from mapFolding.dataBaskets import MapFoldingState
 		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 
-		from mapFolding.syntheticModules.daoOfMapFoldingNumba import doTheNeedful  # noqa: PLC0415
+		from mapFolding.syntheticModules.daoOfMapFoldingNumba import doTheNeedful
 		mapFoldingState = doTheNeedful(mapFoldingState)
 		foldsTotal = mapFoldingState.foldsTotal
 
 	elif flow == 'theorem2' and any(dimension > 2 for dimension in mapShape):
-		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
+		from mapFolding.dataBaskets import MapFoldingState
 		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 
-		from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds  # noqa: PLC0415
+		from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds
 		mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
 
-		from mapFolding.syntheticModules.theorem2 import count  # noqa: PLC0415
+		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  # noqa: PLC0415
+	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.initializeState import transitionOnGroupsOfFolds  # noqa: PLC0415
+		from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds
 		mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
 
-		from mapFolding.syntheticModules.theorem2Trimmed import count  # noqa: PLC0415
-		mapFoldingState = count(mapFoldingState)
+		from mapFolding.syntheticModules.dataPacking import sequential
+		mapFoldingState = sequential(mapFoldingState)
 
 		foldsTotal = mapFoldingState.foldsTotal
 
-	elif (flow == 'theorem2Numba' or taskDivisions == 0) and any(dimension > 2 for dimension in mapShape):
-		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
+	elif flow == 'theorem2Trimmed' and any(dimension > 2 for dimension in mapShape):
+		from mapFolding.dataBaskets import MapFoldingState
 		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 
-		from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds  # noqa: PLC0415
+		from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds
 		mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
 
-		from mapFolding.syntheticModules.dataPacking import sequential  # noqa: PLC0415
-		mapFoldingState = sequential(mapFoldingState)
+		from mapFolding.syntheticModules.theorem2Trimmed import count
+		mapFoldingState = count(mapFoldingState)
 
 		foldsTotal = mapFoldingState.foldsTotal
 
 	elif taskDivisions > 1:
-		from mapFolding.dataBaskets import ParallelMapFoldingState  # noqa: PLC0415
-		parallelMapFoldingState: ParallelMapFoldingState = ParallelMapFoldingState(mapShape, taskDivisions=taskDivisions)
+		from mapFolding.dataBaskets import ParallelMapFoldingState
+		mapFoldingParallelState: ParallelMapFoldingState = ParallelMapFoldingState(mapShape, taskDivisions=taskDivisions)
 
-		from mapFolding.syntheticModules.countParallelNumba import doTheNeedful  # noqa: PLC0415
+		from mapFolding.syntheticModules.countParallelNumba import doTheNeedful
 
-		# `listStatesParallel` exists in case you want to research the parallel computation.
-		foldsTotal, listStatesParallel = doTheNeedful(parallelMapFoldingState, concurrencyLimit) # pyright: ignore[reportUnusedVariable]
+		# `listStatesParallel` exists so you can research the parallel computation.
+		foldsTotal, listStatesParallel = doTheNeedful(mapFoldingParallelState, concurrencyLimit) # pyright: ignore[reportUnusedVariable]  # noqa: RUF059
 
 	else:
-		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
+		from mapFolding.dataBaskets import MapFoldingState
 		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 
-		from mapFolding.syntheticModules.daoOfMapFoldingNumba import doTheNeedful  # noqa: PLC0415
+		from mapFolding.algorithms.daoOfMapFolding import doTheNeedful
 		mapFoldingState = doTheNeedful(mapFoldingState)
 		foldsTotal = mapFoldingState.foldsTotal
 
@@ -319,3 +256,214 @@ def countFolds(listDimensions: Sequence[int] | None = None
 		saveFoldsTotal(pathFilenameFoldsTotal, foldsTotal)
 
 	return foldsTotal
+
+@cache
+def A000682(n: int, flow: str | None = None) -> int:
+	"""Compute A000682(n)."""
+	match flow:
+		case 'matrixNumPy':
+			from mapFolding.algorithms.matrixMeandersNumPy import doTheNeedful
+			from mapFolding.dataBaskets import MatrixMeandersNumPyState as State
+		case 'matrixPandas':
+			from mapFolding.algorithms.matrixMeandersPandas import doTheNeedful
+			from mapFolding.dataBaskets import MatrixMeandersNumPyState as State
+		case _:
+			from mapFolding.algorithms.matrixMeanders import doTheNeedful
+			from mapFolding.dataBaskets import MatrixMeandersState as State
+
+	oeisID = 'A000682'
+
+	kOfMatrix: int = n - 1
+
+	if n == 1:
+		return 1
+	elif n & 0b1:
+		arcCode: int = 5
+	else:
+		arcCode = 1
+	listCurveLocations: list[int] = [(arcCode << 1) | arcCode]
+
+	MAXIMUMarcCode: int = 1 << (2 * kOfMatrix + 4)
+	while listCurveLocations[-1] < MAXIMUMarcCode:
+		arcCode = (arcCode << 4) | 0b101 # == arcCode * 2**4 + 5
+		listCurveLocations.append((arcCode << 1) | arcCode)
+
+	dictionaryMeanders=dict.fromkeys(listCurveLocations, 1)
+
+	state = State(n, oeisID, kOfMatrix, dictionaryMeanders)
+
+	return doTheNeedful(state) # pyright: ignore[reportArgumentType]
+
+@cache
+def A005316(n: int, flow: str | None = None) -> int:
+	"""Compute A005316(n)."""
+	match flow:
+		case 'matrixNumPy':
+			from mapFolding.algorithms.matrixMeandersNumPy import doTheNeedful
+			from mapFolding.dataBaskets import MatrixMeandersNumPyState as State
+		case 'matrixPandas':
+			from mapFolding.algorithms.matrixMeandersPandas import doTheNeedful
+			from mapFolding.dataBaskets import MatrixMeandersNumPyState as State
+		case _:
+			from mapFolding.algorithms.matrixMeanders import doTheNeedful
+			from mapFolding.dataBaskets import MatrixMeandersState as State
+
+	oeisID = 'A005316'
+
+	kOfMatrix: int = n - 1
+
+	if n & 0b1:
+		dictionaryMeanders: dict[int, int] = {15: 1}
+	else:
+		dictionaryMeanders = {22: 1}
+
+	state = State(n, oeisID, kOfMatrix, dictionaryMeanders)
+
+	return doTheNeedful(state) # pyright: ignore[reportArgumentType]
+
+def NOTcountingFolds(oeisID: str, oeis_n: int, flow: str | None = None
+		# , pathLikeWriteFoldsTotal: PathLike[str] | PurePath | None = None  # noqa: ERA001
+		, CPUlimit: bool | float | int | None = None  # noqa: FBT001
+		) -> int:
+	"""Do stuff."""
+	countTotal: int = -1
+
+	match oeisID:
+		case 'A000136':
+			from mapFolding.algorithms.oeisIDbyFormula import A000136
+			countTotal = A000136(oeis_n)
+		case 'A000560':
+			from mapFolding.algorithms.oeisIDbyFormula import A000560
+			countTotal = A000560(oeis_n)
+		case 'A000682':
+			countTotal = A000682(oeis_n, flow)
+		case 'A001010':
+			from mapFolding.algorithms.oeisIDbyFormula import A001010
+			countTotal = A001010(oeis_n)
+		case 'A001011':
+			from mapFolding.algorithms.oeisIDbyFormula import A001011
+			countTotal = A001011(oeis_n)
+		case 'A005315':
+			from mapFolding.algorithms.oeisIDbyFormula import A005315
+			countTotal = A005315(oeis_n)
+		case 'A005316':
+			countTotal = A005316(oeis_n, flow)
+		case 'A007822':
+			mapShape: tuple[Literal[1], int] = (1, 2 * oeis_n)
+			match flow:
+				case 'asynchronous':
+					from mapFolding.dataBaskets import MapFoldingState
+					mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+					from mapFolding import setProcessorLimit
+					concurrencyLimit = setProcessorLimit(CPUlimit)
+
+					from mapFolding.syntheticModules.A007822.asynchronous import doTheNeedful
+					mapFoldingState = doTheNeedful(mapFoldingState)
+
+				case 'asynchronousNumba':
+					from mapFolding.dataBaskets import MapFoldingState
+					mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+					from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds
+					mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
+
+					from mapFolding import setProcessorLimit
+					concurrencyLimit = setProcessorLimit(CPUlimit)
+
+					from mapFolding.syntheticModules.A007822.asynchronousAnnex import initializeConcurrencyManager
+					initializeConcurrencyManager(maxWorkers=concurrencyLimit, groupsOfFolds=mapFoldingState.groupsOfFolds)
+					mapFoldingState.groupsOfFolds = 0
+
+					from mapFolding.syntheticModules.A007822.asynchronousNumba import count
+					mapFoldingState = count(mapFoldingState)
+
+				case 'asynchronousTrimmed':
+					from mapFolding.dataBaskets import MapFoldingState
+					mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+					from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds
+					mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
+
+					from mapFolding import setProcessorLimit
+					concurrencyLimit = setProcessorLimit(CPUlimit)
+
+					from mapFolding.syntheticModules.A007822.asynchronousAnnex import initializeConcurrencyManager
+					initializeConcurrencyManager(maxWorkers=concurrencyLimit, groupsOfFolds=mapFoldingState.groupsOfFolds)
+					mapFoldingState.groupsOfFolds = 0
+
+					from mapFolding.syntheticModules.A007822.asynchronousTrimmed import count
+					mapFoldingState = count(mapFoldingState)
+
+				case 'numba':
+					from mapFolding.dataBaskets import MapFoldingState
+					mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+					from mapFolding.syntheticModules.A007822.algorithmNumba import doTheNeedful
+					mapFoldingState = doTheNeedful(mapFoldingState)
+
+				case 'theorem2':
+					from mapFolding.dataBaskets import MapFoldingState
+					mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+					from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds
+					mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
+
+					from mapFolding.syntheticModules.A007822.theorem2 import count
+					mapFoldingState = count(mapFoldingState)
+
+				case 'theorem2Numba':
+					from mapFolding.dataBaskets import MapFoldingState
+					mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+					from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds
+					mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
+
+					from mapFolding.syntheticModules.A007822.theorem2Numba import count
+					mapFoldingState = count(mapFoldingState)
+
+				case 'theorem2Trimmed':
+					from mapFolding.dataBaskets import MapFoldingState
+					mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+					from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds
+					mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
+
+					from mapFolding.syntheticModules.A007822.theorem2Trimmed import count
+					mapFoldingState = count(mapFoldingState)
+
+				case _:
+					from mapFolding.dataBaskets import MapFoldingState
+					mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+					from mapFolding.syntheticModules.A007822.algorithm import doTheNeedful
+					mapFoldingState = doTheNeedful(mapFoldingState)
+
+			countTotal = mapFoldingState.groupsOfFolds
+		case 'A060206':
+			from mapFolding.algorithms.oeisIDbyFormula import A060206
+			countTotal = A060206(oeis_n)
+		case 'A077460':
+			from mapFolding.algorithms.oeisIDbyFormula import A077460
+			countTotal = A077460(oeis_n)
+		case 'A078591':
+			from mapFolding.algorithms.oeisIDbyFormula import A078591
+			countTotal = A078591(oeis_n)
+		case 'A178961':
+			from mapFolding.algorithms.oeisIDbyFormula import A178961
+			countTotal = A178961(oeis_n)
+		case 'A223094':
+			from mapFolding.algorithms.oeisIDbyFormula import A223094
+			countTotal = A223094(oeis_n)
+		case 'A259702':
+			from mapFolding.algorithms.oeisIDbyFormula import A259702
+			countTotal = A259702(oeis_n)
+		case 'A301620':
+			from mapFolding.algorithms.oeisIDbyFormula import A301620
+			countTotal = A301620(oeis_n)
+
+		case _:
+			pass
+
+	return countTotal
+

mapFolding/beDRY.py

@@ -1,26 +1,4 @@
-"""
-Core computational utilities implementing Lunnon's map folding algorithm.
-
-(AI generated docstring)
-
-With the configuration foundation established and the type system defined, this
-module provides the essential building blocks that transform mathematical theory
-into executable computation. These utilities implement the fundamental operations
-required by Lunnon's 1971 algorithm, handling dimension validation, connection
-graph generation, and computational resource management.
-
-The connection graph generation represents the mathematical heart of the algorithm,
-calculating how leaves connect across dimensions using coordinate systems, parity
-rules, and boundary conditions. This graph becomes the foundation upon which the
-recursive folding analysis operates. Validation functions ensure computational
-of large-scale problems. Validation functions ensure computational
-integrity, while task division management enables experimental task division strategies.
-
-These utilities follow DRY and SSOT principles, providing reusable functions that
-serve as the computational assembly-line components. They prepare the essential
-data structures and computational parameters that the state management system
-requires to orchestrate the complex recursive algorithms.
-"""
+"""Oft-needed computations or actions, especially for multi-dimensional map folding."""
 
 from collections.abc import Sequence
 from hunterMakesPy import defineConcurrencyLimit, intInnit, oopsieKwargsie
@@ -33,8 +11,6 @@ import numpy
 def getLeavesTotal(mapShape: tuple[int, ...]) -> int:
 	"""Calculate the total number of leaves in a map with the given dimensions.
 
-	(AI generated docstring)
-
 	The total number of leaves is the product of all dimensions in the map shape.
 
 	Parameters
@@ -66,8 +42,6 @@ def getLeavesTotal(mapShape: tuple[int, ...]) -> int:
 def getTaskDivisions(computationDivisions: int | str | None, concurrencyLimit: int, leavesTotal: int) -> int:
 	"""Determine whether to divide the computation into tasks and how many divisions.
 
-	(AI generated docstring)
-
 	Parameters
 	----------
 	computationDivisions : int | str | None
@@ -214,12 +188,10 @@ def makeDataContainer(shape: int | tuple[int, ...], datatype: type[NumPyIntegerT
 def setProcessorLimit(CPUlimit: Any | None, concurrencyPackage: str | None = None) -> int:
 	"""Set the CPU usage limit for concurrent operations.
 
-	(AI generated docstring)
-
 	Parameters
 	----------
 	CPUlimit : Any | None
-		Please see the documentation for in `countFolds` for details. I know it is annoying, but I want to be sure you
+		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.
 	concurrencyPackage : str | None = None
 		Specifies which concurrency package to use.