mapFolding 0.16.0__py3-none-any.whl → 0.16.2__py3-none-any.whl

mapFolding/basecamp.py

@@ -1,17 +1,19 @@
 """Unified interface for map folding computation."""
 
 from collections.abc import Sequence
-from functools import cache
 from mapFolding import (
-	getPathFilenameFoldsTotal, MatrixMeandersState, packageSettings, saveFoldsTotal, saveFoldsTotalFAILearly,
-	setProcessorLimit, validateListDimensions)
-from mapFolding.algorithms.matrixMeanders import doTheNeedful
+	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
@@ -21,6 +23,7 @@ algorithms directory
 	an enhanced version of `oeisIDfor_n` will be a stable interface for calling by ID and n
 
 General flow structure
+	basecamp should call `doTheNeedful` instead of `count` and `doTheNeedful` should handle things like `initializeState`.
 	doTheNeedful
 		specific to that version of that algorithm
 		abstracts the API for that algorithm, so that algorithm (such as multidimensional map folding) has a stable interface
@@ -76,8 +79,6 @@ def countFolds(listDimensions: Sequence[int] | 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:
 	"""
@@ -102,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.
@@ -118,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:
@@ -153,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)
@@ -174,10 +162,10 @@ 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)
+		taskDivisions: int = getTaskDivisions(computationDivisions, concurrencyLimit, leavesTotal)
 		del leavesTotal
 	else:
 		concurrencyLimit = 1
@@ -193,169 +181,46 @@ 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 'asynchronous':
-				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
-				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
-
-				from mapFolding.syntheticModules.A007822.asynchronous import doTheNeedful  # noqa: PLC0415
-				mapFoldingState = doTheNeedful(mapFoldingState)
-
-			case 'asynchronousTheorem2':
-				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
-				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
-
-				from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds  # noqa: PLC0415
-				mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
-
-				from mapFolding.syntheticModules.A007822.asynchronousAnnex import initializeConcurrencyManager  # noqa: PLC0415
-				initializeConcurrencyManager(groupsOfFolds=mapFoldingState.groupsOfFolds)
-				mapFoldingState.groupsOfFolds = 0
-
-				from mapFolding.syntheticModules.A007822.asynchronousTheorem2 import count  # noqa: PLC0415
-				mapFoldingState = count(mapFoldingState)
-
-			case 'asynchronousTrimmed':
-				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
-				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
-
-				from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds  # noqa: PLC0415
-				mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
-
-				from mapFolding.syntheticModules.A007822.asynchronousAnnex import initializeConcurrencyManager  # noqa: PLC0415
-				initializeConcurrencyManager(groupsOfFolds=mapFoldingState.groupsOfFolds)
-				mapFoldingState.groupsOfFolds = 0
-
-				from mapFolding.syntheticModules.A007822.asynchronousTrimmed import count  # noqa: PLC0415
-				mapFoldingState = count(mapFoldingState)
-
-			case 'numba':
-				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
-				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
-
-				from mapFolding.syntheticModules.A007822.algorithmNumba import doTheNeedful  # noqa: PLC0415
-				mapFoldingState = doTheNeedful(mapFoldingState)
-
-			case 'theorem2':
-				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
-				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
-
-				from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds  # noqa: PLC0415
-				mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
-
-				from mapFolding.syntheticModules.A007822.theorem2 import count  # noqa: PLC0415
-				mapFoldingState = count(mapFoldingState)
-
-			case 'theorem2Numba':
-				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
-				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
-
-				from mapFolding.syntheticModules.A007822.initializeState 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.A007822.initializeState import transitionOnGroupsOfFolds  # noqa: PLC0415
-				mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
-
-				from mapFolding.syntheticModules.A007822.theorem2Trimmed import count  # noqa: PLC0415
-				mapFoldingState = count(mapFoldingState)
-
-			case _:
-				from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
-				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
-
-				from mapFolding.syntheticModules.A007822.algorithm import doTheNeedful  # noqa: PLC0415
-				mapFoldingState = doTheNeedful(mapFoldingState)
-
-		foldsTotal = mapFoldingState.groupsOfFolds
-
-	elif flow == 'daoOfMapFolding':
-		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
-		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
-
-		from mapFolding.algorithms.daoOfMapFolding import doTheNeedful  # noqa: PLC0415
-		mapFoldingState = doTheNeedful(mapFoldingState)
-		foldsTotal = mapFoldingState.foldsTotal
-
-	elif flow == 'numba':
-		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
-		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
-
-		from mapFolding.syntheticModules.daoOfMapFoldingNumba import doTheNeedful  # noqa: PLC0415
-		mapFoldingState = doTheNeedful(mapFoldingState)
-		foldsTotal = mapFoldingState.foldsTotal
-
-	elif flow == 'theorem2' and any(dimension > 2 for dimension in mapShape):
-		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
-		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
-
-		from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds  # noqa: PLC0415
-		mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
-
-		from mapFolding.syntheticModules.theorem2 import count  # noqa: PLC0415
-		mapFoldingState = count(mapFoldingState)
-
-		foldsTotal = mapFoldingState.foldsTotal
-
-	elif flow == 'theorem2Trimmed' and any(dimension > 2 for dimension in mapShape):
-		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
-		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+	if taskDivisions > 1:
+		from mapFolding.dataBaskets import ParallelMapFoldingState
+		mapFoldingParallelState: ParallelMapFoldingState = ParallelMapFoldingState(mapShape, taskDivisions=taskDivisions)
 
-		from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds  # noqa: PLC0415
-		mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
+		from mapFolding.syntheticModules.countParallelNumba import doTheNeedful
 
-		from mapFolding.syntheticModules.theorem2Trimmed import count  # noqa: PLC0415
-		mapFoldingState = count(mapFoldingState)
-
-		foldsTotal = mapFoldingState.foldsTotal
+		# `listStatesParallel` exists so you can research the parallel computation.
+		foldsTotal, listStatesParallel = doTheNeedful(mapFoldingParallelState, concurrencyLimit) # pyright: ignore[reportUnusedVariable]  # noqa: RUF059
 
-	elif (flow == 'theorem2Numba' or taskDivisions == 0) and any(dimension > 2 for dimension in mapShape):
-		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
+	else:
+		from mapFolding.dataBaskets import MapFoldingState
 		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 
-		from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds  # noqa: PLC0415
-		mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
+		if flow == 'daoOfMapFolding':
+			from mapFolding.algorithms.daoOfMapFolding import doTheNeedful
+			mapFoldingState = doTheNeedful(mapFoldingState)
 
-		from mapFolding.syntheticModules.dataPacking import sequential  # noqa: PLC0415
-		mapFoldingState = sequential(mapFoldingState)
+		elif flow == 'numba':
+			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.syntheticModules.theorem2 import doTheNeedful
+			mapFoldingState = doTheNeedful(mapFoldingState)
 
-	elif taskDivisions > 1:
-		from mapFolding.dataBaskets import ParallelMapFoldingState  # noqa: PLC0415
-		parallelMapFoldingState: ParallelMapFoldingState = ParallelMapFoldingState(mapShape, taskDivisions=taskDivisions)
+		elif (flow == 'theorem2Numba' or taskDivisions == 0) and any(dimension > 2 for dimension in mapShape):
+			from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds
+			mapFoldingState = transitionOnGroupsOfFolds(mapFoldingState)
 
-		from mapFolding.syntheticModules.countParallelNumba import doTheNeedful  # noqa: PLC0415
+			from mapFolding.syntheticModules.dataPacking import sequential
+			mapFoldingState = sequential(mapFoldingState)
 
-		# `listStatesParallel` exists so you can research the parallel computation.
-		foldsTotal, listStatesParallel = doTheNeedful(parallelMapFoldingState, concurrencyLimit) # pyright: ignore[reportUnusedVariable]  # noqa: RUF059
+		elif flow == 'theorem2Trimmed' and any(dimension > 2 for dimension in mapShape):
+			from mapFolding.syntheticModules.theorem2Trimmed import doTheNeedful
+			mapFoldingState = doTheNeedful(mapFoldingState)
 
-	else:
-		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
-		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+		else:
+			from mapFolding.algorithms.daoOfMapFolding import doTheNeedful
+			mapFoldingState = doTheNeedful(mapFoldingState)
 
-		from mapFolding.syntheticModules.daoOfMapFoldingNumba import doTheNeedful  # noqa: PLC0415
-		mapFoldingState = doTheNeedful(mapFoldingState)
 		foldsTotal = mapFoldingState.foldsTotal
 
 	# Follow memorialization instructions ---------------------------------------------
@@ -365,42 +230,138 @@ def countFolds(listDimensions: Sequence[int] | None = None
 
 	return foldsTotal
 
-@cache
-def A000682(n: int) -> int:
-	"""Compute A000682(n)."""
-	oeisID = 'A000682'
+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 = -31212012 # ERROR
+	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
+		case 'A005315':
+			from mapFolding.algorithms.oeisIDbyFormula import A005315 as doTheNeedful
+		case 'A060206':
+			from mapFolding.algorithms.oeisIDbyFormula import A060206 as doTheNeedful
+		case 'A077460':
+			from mapFolding.algorithms.oeisIDbyFormula import A077460 as doTheNeedful
+		case 'A078591':
+			from mapFolding.algorithms.oeisIDbyFormula import A078591 as doTheNeedful
+		case 'A178961':
+			from mapFolding.algorithms.oeisIDbyFormula import A178961 as doTheNeedful
+		case 'A223094':
+			from mapFolding.algorithms.oeisIDbyFormula import A223094 as doTheNeedful
+		case 'A259702':
+			from mapFolding.algorithms.oeisIDbyFormula import A259702 as doTheNeedful
+		case 'A301620':
+			from mapFolding.algorithms.oeisIDbyFormula import A301620 as doTheNeedful
+		case _:
+			matched_oeisID = False
+	if matched_oeisID:
+		countTotal = doTheNeedful(oeis_n) # pyright: ignore[reportPossiblyUnboundVariable]
+	else:
+		matched_oeisID = True
+		match oeisID:
+			case 'A000682' | 'A005316':
+				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
+
+				boundary: int = oeis_n - 1
+
+				if oeisID == 'A000682':
+					if oeis_n == 1:
+						return 1
+					elif oeis_n & 0b1:
+						arcCode: int = 0b101
+					else:
+						arcCode = 0b1
+					listArcCodes: list[int] = [(arcCode << 1) | arcCode]
+													#  0b1010 | 0b0101 is 0b1111, or 0xf
+													#    0b10 |   0b01 is   0b11, or 0x3
+
+					MAXIMUMarcCode: int = 1 << (2 * boundary + 4)
+					while listArcCodes[-1] < MAXIMUMarcCode:
+						arcCode = (arcCode << 4) | 0b0101 # e.g., 0b 10000 | 0b 0101 = 0b 10101
+						listArcCodes.append((arcCode << 1) | arcCode) # e.g., 0b 101010 | 0b 1010101 = 0b 111111 = 0x3f
+						# Thereafter, append 0b1111 or 0xf, so, e.g., 0x3f, 0x3ff, 0x3fff, 0x3ffff, ...
+						# See "mapFolding/reference/A000682facts.py"
+					dictionaryMeanders=dict.fromkeys(listArcCodes, 1)
+
+				elif oeisID == 'A005316':
+					if oeis_n & 0b1:
+						dictionaryMeanders: dict[int, int] = {0b1111: 1} # 0xf
+					else:
+						dictionaryMeanders = {0b10110: 1}
+				else:
+					message = f"Programming error: I should never have received `{oeisID = }`."
+					raise ValueError(message)
+
+				state = State(oeis_n, oeisID, boundary, dictionaryMeanders)
+				countTotal = doTheNeedful(state) # pyright: ignore[reportArgumentType]
+			case 'A007822':
+				mapShape: tuple[Literal[1], int] = (1, 2 * oeis_n)
+				from mapFolding import setProcessorLimit
+				concurrencyLimit: int = setProcessorLimit(CPUlimit)
+
+				from mapFolding.dataBaskets import MapFoldingState
+				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+				match flow:
+					case 'asynchronous':
+						from mapFolding.syntheticModules.A007822.asynchronous import doTheNeedful
+						mapFoldingState = doTheNeedful(mapFoldingState, concurrencyLimit)
 
-	kOfMatrix: int = n - 1
+					case 'asynchronousNumba':
+						from mapFolding.syntheticModules.A007822.asynchronousNumba import doTheNeedful
+						mapFoldingState = doTheNeedful(mapFoldingState, concurrencyLimit)
 
-	if n & 0b1:
-		curveLocations: int = 5
-	else:
-		curveLocations = 1
-	listCurveLocations: list[int] = [(curveLocations << 1) | curveLocations]
+					case 'asynchronousTheorem2':
+						from mapFolding.syntheticModules.A007822.asynchronousTheorem2 import doTheNeedful
+						mapFoldingState = doTheNeedful(mapFoldingState, concurrencyLimit)
 
-	MAXIMUMcurveLocations: int = 1 << (2 * kOfMatrix + 4)
-	while listCurveLocations[-1] < MAXIMUMcurveLocations:
-		curveLocations = (curveLocations << 4) | 0b101 # == curveLocations * 2**4 + 5
-		listCurveLocations.append((curveLocations << 1) | curveLocations)
+					case 'asynchronousTrimmed':
+						from mapFolding.syntheticModules.A007822.asynchronousTrimmed import doTheNeedful
+						mapFoldingState = doTheNeedful(mapFoldingState, concurrencyLimit)
 
-	dictionaryCurveLocations=dict.fromkeys(listCurveLocations, 1)
+					case 'numba':
+						from mapFolding.syntheticModules.A007822.algorithmNumba import doTheNeedful
+						mapFoldingState = doTheNeedful(mapFoldingState)
 
-	state = MatrixMeandersState(n, oeisID, kOfMatrix, dictionaryCurveLocations)
+					case 'theorem2':
+						from mapFolding.syntheticModules.A007822.theorem2 import doTheNeedful
+						mapFoldingState = doTheNeedful(mapFoldingState)
 
-	return doTheNeedful(state)
+					case 'theorem2Numba':
+						from mapFolding.syntheticModules.A007822.theorem2Numba import doTheNeedful
+						mapFoldingState = doTheNeedful(mapFoldingState)
 
-@cache
-def A005316(n: int) -> int:
-	"""Compute A005316(n)."""
-	oeisID = 'A005316'
+					case 'theorem2Trimmed':
+						from mapFolding.syntheticModules.A007822.theorem2Trimmed import doTheNeedful
+						mapFoldingState = doTheNeedful(mapFoldingState)
 
-	kOfMatrix: int = n - 1
+					case _:
+						from mapFolding.syntheticModules.A007822.algorithm import doTheNeedful
+						mapFoldingState = doTheNeedful(mapFoldingState)
 
-	if n & 0b1:
-		dictionaryCurveLocations: dict[int, int] = {15: 1}
-	else:
-		dictionaryCurveLocations = {22: 1}
+				countTotal = mapFoldingState.groupsOfFolds
+			case _:
+				matched_oeisID = False
 
-	state = MatrixMeandersState(n, oeisID, kOfMatrix, dictionaryCurveLocations)
+	return countTotal
 
-	return doTheNeedful(state)

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.