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

easyRun/NOTcountingFolds.py

@@ -15,20 +15,21 @@ if __name__ == '__main__':
 			"\033[0m\n"
 		)
 
-	CPUlimit: bool | float | int | None = -2
+	CPUlimit: bool | float | int | None = 3
 	# oeisID: str | None = None
 	oeis_n: int | None = None
 	flow: str | None = None
 
+	oeisID = 'A001010'
 	oeisID = 'A007822'
 
-	flow = 'asynchronous'
 	flow = 'algorithm'
-	flow = 'asynchronousNumba'
+	flow = 'asynchronous'
 	flow = 'theorem2Numba'
-	flow = 'asynchronousTrimmed'
+	flow = 'theorem2Trimmed'
 
-	for n in range(3,9):
+	# for n in range(7,10):
+	for n in range(3,8):
 
 		timeStart = time.perf_counter()
 		countTotal = NOTcountingFolds(oeisID, n, flow, CPUlimit)

easyRun/countFolds.py

@@ -25,7 +25,7 @@ if __name__ == '__main__':
 	# mapShape: tuple[int, ...] | None = None
 	flow: str | None = 'theorem2Numba'
 
-	oeisID: str = 'A001415'
+	oeisID: str = 'A001416'
 	for n in range(3,8):
 
 		mapShape: tuple[int, ...] = dictionaryOEISMapFolding[oeisID]['getMapShape'](n)

easyRun/generateAllModules.py

@@ -0,0 +1,14 @@
+"""Generate all modules that require some assembly."""
+from mapFolding.someAssemblyRequired.A007822.makeA007822AsynchronousModules import makeA007822AsynchronousModules
+from mapFolding.someAssemblyRequired.A007822.makeA007822Modules import makeA007822Modules
+from mapFolding.someAssemblyRequired.mapFoldingModules.makeMapFoldingModules import makeMapFoldingModules
+from mapFolding.someAssemblyRequired.meanders.makeMeandersModules import makeMeandersModules
+
+# TODO from mapFolding.zCuzDocStoopid import makeDocstrings
+
+makeMapFoldingModules()
+
+makeA007822Modules()
+makeA007822AsynchronousModules()
+
+makeMeandersModules()

easyRun/meanders.py

@@ -29,7 +29,7 @@ if __name__ == '__main__':
 	flow = 'matrixNumPy'
 
 	for oeisID in [
-			# 'A005316',
+			'A005316',
 			'A000682',
 				]:
 		sys.stdout.write(f"\n{oeisID}\n")

mapFolding/__init__.py

@@ -4,6 +4,7 @@ from mapFolding._theTypes import (
 	Array1DElephino as Array1DElephino,
 	Array1DFoldsTotal as Array1DFoldsTotal,
 	Array1DLeavesTotal as Array1DLeavesTotal,
+    Array2DLeavesTotal as Array2DLeavesTotal,
 	Array3DLeavesTotal as Array3DLeavesTotal,
     axisOfLength as axisOfLength,
 	DatatypeElephino as DatatypeElephino,

mapFolding/_theSSOT.py

@@ -43,7 +43,7 @@ class mapFoldingPackageSettings(PackageSettings):
 	concurrencyPackage: str = 'multiprocessing'
 	"""Package identifier for concurrent execution operations."""
 # ruff: noqa: S311
-# TODO I made a `TypedDict` before I knew how to make dataclasses and classes. Think about other data structures.
+# TODO I made this a `TypedDict` before I knew how to make dataclasses and classes. Think about other data structures.
 OEISidMapFoldingManuallySet: dict[str, MetadataOEISidMapFoldingManuallySet] = {
 	'A000136': {
 		'getMapShape': lambda n: (1, n),
@@ -89,7 +89,6 @@ identifierPackageFALLBACK = "mapFolding"
 packageSettings = mapFoldingPackageSettings(identifierPackageFALLBACK=identifierPackageFALLBACK, OEISidMapFoldingManuallySet=OEISidMapFoldingManuallySet)
 """Global package settings."""
 
-"""Local directory path for storing cached OEIS sequence data and metadata."""
 OEISidManuallySet: dict[str, MetadataOEISidManuallySet] = {
 	'A000560': {'valuesTestValidation': [random.randint(3, 12)]},
 	'A000682': {'valuesTestValidation': [random.randint(3, 12), 32]},
@@ -101,6 +100,7 @@ OEISidManuallySet: dict[str, MetadataOEISidManuallySet] = {
 	'A060206': {'valuesTestValidation': [random.randint(3, 9)]},
 	'A077460': {'valuesTestValidation': [3, 4, random.randint(5, 8)]},
 	'A078591': {'valuesTestValidation': [random.randint(3, 10)]},
+	'A086345': {'valuesTestValidation': [random.randint(3, 10), random.randint(11, 20), random.randint(21, 30), random.randint(31, 40)]},
 	'A178961': {'valuesTestValidation': [random.randint(3, 11)]},
 	'A223094': {'valuesTestValidation': [random.randint(3, 11)]},
 	'A259702': {'valuesTestValidation': [random.randint(3, 13)]},
@@ -117,3 +117,4 @@ packageSettings = mapFoldingPackageSettings(
 
 # TODO integrate into packageSettings
 pathCache: Path = packageSettings.pathPackage / ".cache"
+"""Local directory path for storing cached OEIS sequence data and metadata."""

mapFolding/_theTypes.py

@@ -44,6 +44,9 @@ different data structure."""
 Array3DLeavesTotal: TypeAlias = ndarray[tuple[int, int, int], dtype[NumPyLeavesTotal]]  # noqa: UP040 The TypeAlias may be used to construct ("cast") a value to the type. And the identifier may be changed to a different type.
 """A `numpy.ndarray` with three axes and elements of type `NumPyLeavesTotal`."""
 
+Array2DLeavesTotal: TypeAlias = ndarray[tuple[int, int], dtype[NumPyLeavesTotal]]  # noqa: UP040 The TypeAlias may be used to construct ("cast") a value to the type. And the identifier may be changed to a different type.
+"""A `numpy.ndarray` with two axes and elements of type `NumPyLeavesTotal`."""
+
 Array1DLeavesTotal: TypeAlias = ndarray[tuple[int], dtype[NumPyLeavesTotal]]  # noqa: UP040 The TypeAlias may be used to construct ("cast") a value to the type. And the identifier may be changed to a different type.
 """A `numpy.ndarray` with one axis and elements of type `NumPyLeavesTotal`."""
 

mapFolding/algorithms/A086345.py

@@ -0,0 +1,75 @@
+"""Directly based on code Chai Wah Wu, https://oeis.org/wiki/User:Chai_Wah_Wu, posted on OEIS."""
+from fractions import Fraction
+from functools import cache
+from itertools import combinations
+from math import factorial, gcd
+from sympy import divisors
+from sympy.functions.combinatorial.numbers import mobius
+from sympy.utilities.iterables import partitions
+
+@cache
+def _GoCountryDancing(romeo: int, copiesRomeo: int, sierra: int, copiesSierra: int) -> int:
+	return copiesRomeo * copiesSierra * gcd(romeo, sierra)
+
+@cache
+def _goRight(integer: int, copies: int) -> int:
+	return ((integer - 1) >> 1) * copies + (integer * copies * (copies - 1) >> 1)
+
+@cache
+def _deFactorial(integer: int, copies: int) -> int:
+	return integer ** copies * factorial(copies)
+
+@cache
+def _blender(n: int) -> int:
+	sumReBletionary: int = 0
+	for partitionary in partitions(n):
+		numbinations: int = 0
+		nummaNumma: int = 0
+		denominator: int = 1
+		for (romeo, copiesRomeo), (sierra, copiesSierra) in combinations(partitionary.items(), 2):
+			numbinations += _GoCountryDancing(romeo, copiesRomeo, sierra, copiesSierra)
+		for integer, copies in partitionary.items():
+			nummaNumma += _goRight(integer, copies)
+			denominator *= _deFactorial(integer, copies)
+		numerator: int = 3 ** (numbinations + nummaNumma)
+		sumReBletionary += Fraction(numerator, denominator)
+	return sumReBletionary
+
+@cache
+def _recurser(n: int) -> int:
+	sumReBlender: int = 0
+	for k in range(1, n):
+		sumReBlender += _recurser(k) * _blender(n - k)
+	return n * _blender(n) - sumReBlender
+
+def A086345(n: int) -> int:
+	"""Compute 'Number of connected oriented graphs (i.e., connected directed graphs with no bidirected edges) on n nodes'.
+
+	Parameters
+	----------
+	n : int
+		Index (n-dex) for a(n) in the sequence of values. "n" (lower case) and "a(n)" are conventions in mathematics.
+
+	Returns
+	-------
+	a(n) : int
+		Number of connected oriented graphs (i.e., connected directed graphs with no bidirected edges) on n nodes.
+
+	Notes
+	-----
+	- The largest performance gains are from caching the recursion and `sympy.utilities.iterables.partitions` functions.
+	- Interestingly, there is a small but noticeable penalty for choosing comprehension instead of `for`.
+
+	Would You Like to Know More?
+	----------------------------
+	OEIS : webpage
+		https://oeis.org/A086345
+	"""
+	if n == 0:
+		aOFn: int = 1
+	else:
+		aOFn: int = 0
+		for aDivisor in divisors(n, generator=True):
+			aOFn += mobius(aDivisor) * _recurser(n//aDivisor)
+		aOFn //= n
+	return aOFn

mapFolding/algorithms/oeisIDbyFormula.py

@@ -41,7 +41,7 @@ def A000560(n: int) -> int:
     """
     Compute A000560(n) as a function of A000682.
 
-    *The On-Line Encyclopedia of Integer Sequences* (OEIS) description of A000560 is: "Number of ways of folding a strip of n labeled stamps."
+    *The On-Line Encyclopedia of Integer Sequences* (OEIS) description of A000560 is: "Number of symmetric ways of folding a strip of n labeled stamps."
 
     The domain of A000560 starts at 2, therefore for values of `n` < 2, a(n) is undefined. The smallest value of n for which a(n)
     has not yet been computed is 45.
@@ -54,7 +54,7 @@ def A000560(n: int) -> int:
     Returns
     -------
     a(n) : int
-        Number of ways of folding a strip of n labeled stamps.
+        Number of symmetric ways of folding a strip of n labeled stamps.
 
     Would You Like to Know More?
     ----------------------------

mapFolding/algorithms/symmetricFolds.py

@@ -0,0 +1,36 @@
+"""Count the number of symmetric folds in the group of folds defined by `leafBelow`.
+
+Notes
+-----
+- About constructing `leafComparison`:
+    - This branch of the algorithm executes IFF `leafBelow[0] == 1`.
+    - Therefore, `leafComparison[0]` must be `1`.
+    - Therefore, the first iteration of the loop is hardcoded to save processing time.
+    - I _feel_ there must be a more efficient way to do this.
+- Some implementation details are based on Numba compatibility. Incompatible:
+    - `numpy.take(..., out=...)`
+    - `numpy.all(..., axis=...)`
+"""
+from mapFolding.dataBaskets import SymmetricFoldsState
+import numpy
+
+def filterAsymmetricFolds(state: SymmetricFoldsState) -> SymmetricFoldsState:
+    state.indexLeaf = 1
+    state.leafComparison[0] = 1
+    state.leafConnectee = 1
+
+    while state.leafConnectee < state.leavesTotal + 1:
+        state.indexMiniGap = state.leafBelow[state.indexLeaf]
+        state.leafComparison[state.leafConnectee] = (state.indexMiniGap - state.indexLeaf + state.leavesTotal) % state.leavesTotal
+        state.indexLeaf = state.indexMiniGap
+
+        state.leafConnectee += 1
+
+    state.arrayGroupOfFolds = numpy.take(state.leafComparison, state.indicesArrayGroupOfFolds)
+    compared = state.arrayGroupOfFolds[..., 0:state.leavesTotal // 2] == state.arrayGroupOfFolds[..., state.leavesTotal // 2:None]
+
+    for indexRow in range(len(compared)):
+        state.groupsOfFolds += compared[indexRow].all()
+
+    return state
+

mapFolding/basecamp.py

@@ -4,37 +4,39 @@ from collections.abc import Sequence
 from mapFolding import (
 	getPathFilenameFoldsTotal, packageSettings, saveFoldsTotal, saveFoldsTotalFAILearly, validateListDimensions)
 from os import PathLike
-from pathlib import PurePath
+from pathlib import Path, PurePath
 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
-		This has special treatment because people may want to call mapShape not defined in OEIS
-	`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
-
-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
-		The last place to do defensive programming
-
-- Incomplete: how to count
-	- currently in parameters computationDivisions, CPUlimit, and flow
-
-- Flow in count______
-	- DEFENSIVE PROGRAMMING
-	- FAIL EARLY
+- 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.
+- 'basecamp' should be able to call any algorithm version.
+- Quickly call the algorithm or the algorithm's dispatcher, i.e., `doTheNeedful`.
+- `countFolds` will be a stable interface for multidimensional map folding, including synthetic modules.
+- `NOTcountingFolds` is sufficient for now. I'll make an analogue to `countFolds` for some algorithms if it would be useful.
+
+- state vs ? environment?
+	In multidimensional map folding, computationDivisions is part of the state because it is used in the algorithm during a module
+	operation. In contrast, CPUlimit is not used in the algorithm, so I feel like it is not part of the state. Storing the state
+	in a databasket (i.e., a dataclass) makes things much easier.
+
+	Environment settings that I sometimes need:
+		Concurrency
+			CPUlimit.
+			Package for concurrency operations.
+			Settings for that package, if it were a GPU, for example.
+		Memorialization
+			Path
+			Filename standardization
+			Record only a(n), the entire state, or something else?
+		Status updates, such as tqdm.
+
+- Flow in basecamp
+	- Interpret parameters
+	- DEFENSIVE PROGRAMMING; FAIL EARLY
 	- Implement "common foundational logic".
 		- IDK what the correct technical term is, but I'm sure other people have researched excellent ways to do this.
 		- Example: in `countFolds`, every possible flow path needs `mapShape`. Therefore, `mapShape` is foundational logic that
@@ -42,37 +44,17 @@ General flow structure
 		- Example: in `countFolds`, some flow paths have more than one "task division" (i.e., the computation is divided into
 			multiple tasks), while other flow paths only have one task division. One reasonable perspective is that computing task
 			divisions is NOT "common foundational logic". My perspective for this example: to compute whether or not there are
-			task divisions and if so, how many task divisions is identical for all flow paths. Therefore, I handle computing task
-			divisions as "common foundational logic".
-		- Incomplete
-	- Initialize memorialization instructions, if asked
-	- MORE DEFENSIVE PROGRAMMING
-	- FAIL EARLIER THAN EARLY
-	- Incomplete
-	- DEFENSIVE PROGRAMMING ON BEHALF of downstream modules and functions
-	- FAIL SO EARLY IT IS BEFORE THE USER INSTALLS THE APP
-	- Incomplete
-	- REPEAT MANY OR ALL OF THE DEFENSIVE PROGRAMMING YOU HAVE ALREADY DONE
-
-	- Incomplete
+			task divisions is identical for all flow paths. Therefore, it is "common foundational logic".
+	- Initialize memorialization instructions, if asked.
 	- Pass control to the correct `doTheNeedful`
-	- I don't know how to "elegantly" pass control without putting `doTheNeedful` over `count______` in the stack, therefore,
+	- I don't know how to "elegantly" pass control without putting `doTheNeedful` on `count______` in the stack, therefore,
 		control will come back here.
-	- DO NOT, for the love of puppies and cookies, DO NOT use defensive programming here. Defensive programming AFTER a
-		four-week-long computation is a tacit admission of incompetent programming.
-	- Follow memorialization instructions: which means pass control to a function will tenaciously follow the instructions.
-	- return "a(n)" (as OEIS calls it), such as foldsTotal
-
+	- DO NOT, for the love of puppies and cookies, DO NOT use defensive programming when control returns here. Defensive
+		programming AFTER a four-week-long computation is a tacit admission of incompetent programming.
+	- Follow memorialization instructions: which means pass control to a function that will tenaciously follow the instructions.
+	- return "a(n)" (as OEIS calls it), such as foldsTotal.
 """
 
-# 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
@@ -82,7 +64,7 @@ def countFolds(listDimensions: Sequence[int] | None = None
 				, flow: str | None = None
 				) -> int:
 	"""
-	Count the total number of distinct ways to fold a map.
+	Count the number of distinct ways to fold a map.
 
 	Mathematicians also describe this as folding a strip of stamps, and they usually call the total "number of distinct ways to
 	fold" a map the map's "foldings."
@@ -129,7 +111,8 @@ def countFolds(listDimensions: Sequence[int] | None = None
 
 	Returns
 	-------
-	foldsTotal: Total number of distinct ways to fold a map of the given dimensions.
+	foldsTotal : int
+		Number of distinct ways to fold a map of the given dimensions.
 
 	Note well
 	---------
@@ -145,7 +128,7 @@ def countFolds(listDimensions: Sequence[int] | None = None
 	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 ---------------------------------------------------------------------
+# ------- mapShape ---------------------------------------------------------------------
 
 	if mapShape:
 		pass
@@ -159,7 +142,7 @@ def countFolds(listDimensions: Sequence[int] | None = None
 		)
 		raise ValueError(message)
 
-	# task division instructions -----------------------------------------------------
+# ------- task division instructions -----------------------------------------------------
 
 	if computationDivisions:
 		from mapFolding.beDRY import getLeavesTotal, getTaskDivisions, setProcessorLimit
@@ -171,59 +154,40 @@ def countFolds(listDimensions: Sequence[int] | None = None
 		concurrencyLimit = 1
 		taskDivisions = 0
 
-	# memorialization instructions ---------------------------------------------
+# ------- memorialization instructions ---------------------------------------------
 
 	if pathLikeWriteFoldsTotal is not None:
-		pathFilenameFoldsTotal = getPathFilenameFoldsTotal(mapShape, pathLikeWriteFoldsTotal)
+		pathFilenameFoldsTotal: Path | None = getPathFilenameFoldsTotal(mapShape, pathLikeWriteFoldsTotal)
 		saveFoldsTotalFAILearly(pathFilenameFoldsTotal)
 	else:
 		pathFilenameFoldsTotal = None
 
-	# Flow control until I can figure out a good way ---------------------------------
-
+# ------- Algorithm version -----------------------------------------------------
 	if taskDivisions > 1:
 		from mapFolding.dataBaskets import ParallelMapFoldingState
-		mapFoldingParallelState: ParallelMapFoldingState = ParallelMapFoldingState(mapShape, taskDivisions=taskDivisions)
-
 		from mapFolding.syntheticModules.countParallelNumba import doTheNeedful
 
+		mapFoldingParallelState: ParallelMapFoldingState = ParallelMapFoldingState(mapShape, taskDivisions=taskDivisions)
+
 		# `listStatesParallel` exists so you can research the parallel computation.
-		foldsTotal, listStatesParallel = doTheNeedful(mapFoldingParallelState, concurrencyLimit) # pyright: ignore[reportUnusedVariable]  # noqa: RUF059
+		foldsTotal, _listStatesParallel = doTheNeedful(mapFoldingParallelState, concurrencyLimit)
 
+# ruff: noqa: E701
 	else:
+		match flow:
+			case 'daoOfMapFolding': from mapFolding.algorithms.daoOfMapFolding import doTheNeedful
+			case 'numba': from mapFolding.syntheticModules.daoOfMapFoldingNumba import doTheNeedful
+			case 'theorem2': from mapFolding.syntheticModules.theorem2 import doTheNeedful
+			case 'theorem2Numba': from mapFolding.syntheticModules.theorem2Numba import doTheNeedful
+			case 'theorem2Trimmed': from mapFolding.syntheticModules.theorem2Trimmed import doTheNeedful
+			case _: from mapFolding.algorithms.daoOfMapFolding import doTheNeedful
+
 		from mapFolding.dataBaskets import MapFoldingState
 		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
-
-		if flow == 'daoOfMapFolding':
-			from mapFolding.algorithms.daoOfMapFolding import doTheNeedful
-			mapFoldingState = doTheNeedful(mapFoldingState)
-
-		elif flow == 'numba':
-			from mapFolding.syntheticModules.daoOfMapFoldingNumba import doTheNeedful
-			mapFoldingState = doTheNeedful(mapFoldingState)
-
-		elif flow == 'theorem2' and any(dimension > 2 for dimension in mapShape):
-			from mapFolding.syntheticModules.theorem2 import doTheNeedful
-			mapFoldingState = doTheNeedful(mapFoldingState)
-
-		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.dataPacking import sequential
-			mapFoldingState = sequential(mapFoldingState)
-
-		elif flow == 'theorem2Trimmed' and any(dimension > 2 for dimension in mapShape):
-			from mapFolding.syntheticModules.theorem2Trimmed import doTheNeedful
-			mapFoldingState = doTheNeedful(mapFoldingState)
-
-		else:
-			from mapFolding.algorithms.daoOfMapFolding import doTheNeedful
-			mapFoldingState = doTheNeedful(mapFoldingState)
-
+		mapFoldingState = doTheNeedful(mapFoldingState)
 		foldsTotal = mapFoldingState.foldsTotal
 
-	# Follow memorialization instructions ---------------------------------------------
+# ------- Follow memorialization instructions ---------------------------------------------
 
 	if pathFilenameFoldsTotal is not None:
 		saveFoldsTotal(pathFilenameFoldsTotal, foldsTotal)
@@ -231,7 +195,7 @@ def countFolds(listDimensions: Sequence[int] | None = None
 	return foldsTotal
 
 def NOTcountingFolds(oeisID: str, oeis_n: int, flow: str | None = None
-		# , pathLikeWriteFoldsTotal: PathLike[str] | PurePath | None = None  # noqa: ERA001
+# TODO , pathLikeWriteFoldsTotal: PathLike[str] | PurePath | None = None
 		, CPUlimit: bool | float | int | None = None  # noqa: FBT001
 		) -> int:
 	"""Do stuff."""
@@ -239,32 +203,20 @@ def NOTcountingFolds(oeisID: str, oeis_n: int, flow: str | None = None
 	matched_oeisID: bool = True
 
 	match oeisID:
-		case 'A000136':
-			from mapFolding.algorithms.oeisIDbyFormula import A000136 as doTheNeedful
-		case 'A000560':
-			from mapFolding.algorithms.oeisIDbyFormula import A000560 as doTheNeedful
-		case 'A001010':
-			from mapFolding.algorithms.oeisIDbyFormula import A001010 as doTheNeedful
-		case 'A001011':
-			from mapFolding.algorithms.oeisIDbyFormula import A001011 as doTheNeedful
-		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
+		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 'A086345': from mapFolding.algorithms.A086345 import A086345 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:
@@ -319,49 +271,28 @@ def NOTcountingFolds(oeisID: str, oeis_n: int, flow: str | None = None
 				from mapFolding import setProcessorLimit
 				concurrencyLimit: int = setProcessorLimit(CPUlimit)
 
-				from mapFolding.dataBaskets import MapFoldingState
-				mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+				from mapFolding.dataBaskets import SymmetricFoldsState
+				symmetricState: SymmetricFoldsState = SymmetricFoldsState(mapShape)
 
 				match flow:
 					case 'asynchronous':
 						from mapFolding.syntheticModules.A007822.asynchronous import doTheNeedful
-						mapFoldingState = doTheNeedful(mapFoldingState, concurrencyLimit)
-
-					case 'asynchronousNumba':
-						from mapFolding.syntheticModules.A007822.asynchronousNumba import doTheNeedful
-						mapFoldingState = doTheNeedful(mapFoldingState, concurrencyLimit)
-
-					case 'asynchronousTheorem2':
-						from mapFolding.syntheticModules.A007822.asynchronousTheorem2 import doTheNeedful
-						mapFoldingState = doTheNeedful(mapFoldingState, concurrencyLimit)
-
-					case 'asynchronousTrimmed':
-						from mapFolding.syntheticModules.A007822.asynchronousTrimmed import doTheNeedful
-						mapFoldingState = doTheNeedful(mapFoldingState, concurrencyLimit)
-
-					case 'numba':
-						from mapFolding.syntheticModules.A007822.algorithmNumba import doTheNeedful
-						mapFoldingState = doTheNeedful(mapFoldingState)
-
+						symmetricState = doTheNeedful(symmetricState, concurrencyLimit)
 					case 'theorem2':
 						from mapFolding.syntheticModules.A007822.theorem2 import doTheNeedful
-						mapFoldingState = doTheNeedful(mapFoldingState)
-
+						symmetricState = doTheNeedful(symmetricState)
 					case 'theorem2Numba':
 						from mapFolding.syntheticModules.A007822.theorem2Numba import doTheNeedful
-						mapFoldingState = doTheNeedful(mapFoldingState)
-
+						symmetricState = doTheNeedful(symmetricState)
 					case 'theorem2Trimmed':
 						from mapFolding.syntheticModules.A007822.theorem2Trimmed import doTheNeedful
-						mapFoldingState = doTheNeedful(mapFoldingState)
-
+						symmetricState = doTheNeedful(symmetricState)
 					case _:
 						from mapFolding.syntheticModules.A007822.algorithm import doTheNeedful
-						mapFoldingState = doTheNeedful(mapFoldingState)
+						symmetricState = doTheNeedful(symmetricState)
 
-				countTotal = mapFoldingState.groupsOfFolds
+				countTotal = symmetricState.groupsOfFolds
 			case _:
 				matched_oeisID = False
 
 	return countTotal
-