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

easyRun/A000682.py

@@ -10,7 +10,7 @@ if sys.version_info >= (3, 14):
 def main():
 	oeisID = 'A000682'
 	n=45
-	print(NOTcountingFolds(oeisID, n, 'matrixNumPy'))
+	print(NOTcountingFolds(oeisID, n, 'matrixMeanders'))
 
 	from mapFolding import dictionaryOEIS
 	if n < dictionaryOEIS[oeisID]['valueUnknown']:
@@ -21,5 +21,5 @@ if __name__ == "__main__":
 
 r"""
 deactivate && C:\apps\mapFolding\.vtail\Scripts\activate.bat && title good && cls
-title running && start "running" /B /HIGH /wait py -X faulthandler=0 -X tracemalloc=0 -X frozen_modules=on easyRun\A000682.py && title I'm done || title Error
+title running && start "running" /B /HIGH /wait py -X faulthandler=0 -X tracemalloc=0 -X frozen_modules=on easyRun\A000682.py & title I'm done
 """

easyRun/NOTcountingFolds.py

@@ -1,13 +1,16 @@
 # ruff: noqa
-from mapFolding import dictionaryOEIS
+from collections import ChainMap
+from mapFolding import dictionaryOEIS, dictionaryOEISMapFolding
 from mapFolding.basecamp import NOTcountingFolds
 import sys
 import time
 
+dictionaryONE = ChainMap(dictionaryOEISMapFolding, dictionaryOEIS) # pyright: ignore[reportArgumentType]
+
 if __name__ == '__main__':
 	def _write() -> None:
 		sys.stdout.write(
-			f"{(match:=countTotal == dictionaryOEIS[oeisID]['valuesKnown'][n])}\t"
+			f"{(match:=countTotal == dictionaryONE[oeisID]['valuesKnown'][n])}\t"
 			f"\033[{(not match)*91}m"
 			f"{n}\t"
 			f"{countTotal}\t"
@@ -16,21 +19,26 @@ if __name__ == '__main__':
 		)
 
 	CPUlimit: bool | float | int | None = -2
-	# oeisID: str | None = None
-	oeis_n: int | None = None
 	flow: str | None = None
 
 	oeisID = 'A007822'
 
-	flow = 'asynchronous'
 	flow = 'algorithm'
-	flow = 'asynchronousNumba'
+	flow = 'asynchronous'
+	flow = 'theorem2Trimmed'
 	flow = 'theorem2Numba'
-	flow = 'asynchronousTrimmed'
+	flow = 'theorem2'
 
-	for n in range(3,9):
+	# for n in range(13,16):
+	for n in range(1,4):
 
 		timeStart = time.perf_counter()
 		countTotal = NOTcountingFolds(oeisID, n, flow, CPUlimit)
 
 		_write()
+
+r"""
+deactivate && C:\apps\mapFolding\.vtail\Scripts\activate.bat && title good && cls
+title running && start "working" /B /HIGH /wait py -X faulthandler=0 -X tracemalloc=0 -X frozen_modules=on easyRun\NOTcountingFolds.py & title I'm done
+"""
+

easyRun/countFolds.py

@@ -23,14 +23,21 @@ if __name__ == '__main__':
 	computationDivisions: int | str | None = None
 	CPUlimit: bool | float | int | None = None
 	# mapShape: tuple[int, ...] | None = None
-	flow: str | None = 'theorem2Numba'
+	flow = 'daoOfMapFolding'
+	flow = 'numba'
+	flow = 'theorem2'
+	flow = 'theorem2Numba'
+	flow: str | None = 'theorem2Trimmed'
+
 
 	oeisID: str = 'A001415'
-	for n in range(3,8):
+	oeisID: str = 'A000136'
+	for n in range(1,4):
 
 		mapShape: tuple[int, ...] = dictionaryOEISMapFolding[oeisID]['getMapShape'](n)
 
 		timeStart = time.perf_counter()
+		# foldsTotal: int = countFolds(listDimensions=None, pathLikeWriteFoldsTotal=None, computationDivisions=None, CPUlimit=None, mapShape=(2, 3), flow='theorem2Trimmed')
 		foldsTotal: int = countFolds(listDimensions=listDimensions
 						, pathLikeWriteFoldsTotal=pathLikeWriteFoldsTotal
 						, computationDivisions=computationDivisions

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

@@ -24,12 +24,12 @@ if __name__ == '__main__':
 	if sys.version_info >= (3, 14):
 		warnings.filterwarnings("ignore", category=FutureWarning)
 
-	flow = 'matrixMeanders'
 	flow = 'matrixPandas'
+	flow = 'matrixMeanders'
 	flow = 'matrixNumPy'
 
 	for oeisID in [
-			# 'A005316',
+			'A005316',
 			'A000682',
 				]:
 		sys.stdout.write(f"\n{oeisID}\n")
@@ -46,8 +46,8 @@ if __name__ == '__main__':
 
 		nList: list[int] = []
 		nList.extend(range(2, 10))
-		# nList.extend(range(2, 28))
-		nList.extend(range(28,33))
+		# nList.extend(range(10, 28))
+		# nList.extend(range(28,33))
 		# nList.extend(range(33,38))
 		# nList.extend(range(38,43))
 		# nList.extend(range(43,45))

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/A000136constraintPropagation.py

@@ -0,0 +1,95 @@
+from ortools.sat.python import cp_model
+
+def findValidFoldings(leavesTotal: int, workersMaximum: int) -> list[list[int]]:  # noqa: ARG001
+	model = cp_model.CpModel()
+	listIndexAsIntVar: list[cp_model.IntVar] = [model.NewIntVar(0, leavesTotal - 1, f"leafIndexAtPosition[{positionIndex}]") for positionIndex in range(leavesTotal)]
+	indexOfLeafInIndexOfPosition: list[cp_model.IntVar] = [model.NewIntVar(0, leavesTotal - 1, f"positionOfLeafIndex[{leafNumber}]") for leafNumber in range(1, leavesTotal + 1)]
+	model.AddInverse(listIndexAsIntVar, indexOfLeafInIndexOfPosition)
+	model.Add(listIndexAsIntVar[0] == 0) # Fix leaf 1 at position 0
+
+	if leavesTotal > 2:
+		leavesTotalIsOdd: bool = leavesTotal % 2 == 1
+		if leavesTotalIsOdd:
+			leafTwoOccupiesPositionTwo: cp_model.IntVar = model.NewBoolVar("leafTwoOccupiesPositionTwo")
+			model.Add(indexOfLeafInIndexOfPosition[1] == 2).OnlyEnforceIf(leafTwoOccupiesPositionTwo)
+			model.Add(indexOfLeafInIndexOfPosition[1] != 2).OnlyEnforceIf(leafTwoOccupiesPositionTwo.Not())
+			model.Add(listIndexAsIntVar[1] == leavesTotal - 1).OnlyEnforceIf(leafTwoOccupiesPositionTwo)
+		else:
+			model.Add(indexOfLeafInIndexOfPosition[1] != 2)
+
+	if leavesTotal > 3:
+		leafTwoOccupiesFinalPosition: cp_model.IntVar = model.NewBoolVar("leafTwoOccupiesFinalPosition")
+		model.Add(indexOfLeafInIndexOfPosition[1] == leavesTotal - 1).OnlyEnforceIf(leafTwoOccupiesFinalPosition)
+		model.Add(indexOfLeafInIndexOfPosition[1] != leavesTotal - 1).OnlyEnforceIf(leafTwoOccupiesFinalPosition.Not())
+		leavesTotalIsEven: bool = leavesTotal % 2 == 0
+		if leavesTotalIsEven:
+			leafThreeOccupiesIndexTwoFromEnd: cp_model.IntVar = model.NewBoolVar("leafThreeOccupiesIndexTwoFromEnd")
+			model.Add(indexOfLeafInIndexOfPosition[2] == leavesTotal - 3).OnlyEnforceIf(leafThreeOccupiesIndexTwoFromEnd)
+			model.Add(indexOfLeafInIndexOfPosition[2] != leavesTotal - 3).OnlyEnforceIf(leafThreeOccupiesIndexTwoFromEnd.Not())
+			lastLeafOccupiesPenultimatePosition: cp_model.IntVar = model.NewBoolVar("lastLeafOccupiesPenultimatePosition")
+			model.Add(listIndexAsIntVar[leavesTotal - 2] == leavesTotal - 1).OnlyEnforceIf(lastLeafOccupiesPenultimatePosition)
+			model.Add(listIndexAsIntVar[leavesTotal - 2] != leavesTotal - 1).OnlyEnforceIf(lastLeafOccupiesPenultimatePosition.Not())
+			model.AddBoolOr([
+				leafTwoOccupiesFinalPosition.Not(),
+				leafThreeOccupiesIndexTwoFromEnd.Not(),
+				lastLeafOccupiesPenultimatePosition,
+			])
+		else:
+			model.Add(indexOfLeafInIndexOfPosition[2] != leavesTotal - 3).OnlyEnforceIf(leafTwoOccupiesFinalPosition)
+
+	listForbiddenInequalitiesDeconstructed: list[tuple[tuple[int, int], tuple[int, int], tuple[int, int]]] = []
+	for k in range(1, leavesTotal):
+		for r in range(2, leavesTotal):
+			if r == k or (k - r) % 2 != 0:
+				continue
+			k1: int = k + 1
+			r1: int = r + 1
+
+			"""All 8 forbidden forms, index of:
+				[k < r < k+1 < r+1] [r < k+1 < r+1 < k] [k+1 < r+1 < k < r] [r+1 < k < r < k+1]
+				[r < k < r+1 < k+1] [k < r+1 < k+1 < r] [r+1 < k+1 < r < k] [k+1 < r < k < r+1]
+			"""
+			listForbiddenInequalitiesDeconstructed.extend([
+				((k-1, r-1), (r-1, k1-1), (k1-1, r1-1)),
+				((k1-1, r1-1), (r1-1, k-1), (k-1, r-1)),
+				((r1-1, k-1), (k-1, r-1), (r-1, k1-1)),
+				((k-1, r1-1), (r1-1, k1-1), (k1-1, r-1)),
+				# ((r-1, k1-1), (k1-1, r1-1), (r1-1, k-1)), ((r-1, k-1), (k-1, r1-1), (r1-1, k1-1)), ((r1-1, k1-1), (k1-1, r-1), (r-1, k-1)), ((k1-1, r-1), (r-1, k-1), (k-1, r1-1)),  # noqa: ERA001
+			])
+	for tupleIndices in listForbiddenInequalitiesDeconstructed:
+		listOfInequalities: list[cp_model.IntVar] = []
+		for indexLeft, indexRight in tupleIndices:
+			inequalityOf2Indices: cp_model.IntVar = model.NewBoolVar(f"order_{indexLeft}_{indexRight}")
+			model.Add(indexOfLeafInIndexOfPosition[indexLeft] < indexOfLeafInIndexOfPosition[indexRight]).OnlyEnforceIf(inequalityOf2Indices)
+			model.Add(indexOfLeafInIndexOfPosition[indexLeft] >= indexOfLeafInIndexOfPosition[indexRight]).OnlyEnforceIf(inequalityOf2Indices.Not())
+			listOfInequalities.append(inequalityOf2Indices)
+		# At least one inequality must be false to avoid forbidden pattern
+		model.AddBoolOr([inequality.Not() for inequality in listOfInequalities])
+
+	solver = cp_model.CpSolver()
+	solver.parameters.enumerate_all_solutions = True
+
+	solver.parameters.cp_model_presolve = True
+	solver.parameters.use_combined_no_overlap = True
+	solver.parameters.use_disjunctive_constraint_in_cumulative = True
+	solver.parameters.use_objective_shaving_search = True
+	solver.parameters.use_precedences_in_disjunctive_constraint = True
+	# solver.parameters.num_workers = 2  # noqa: ERA001
+	solver.parameters.num_workers = 1
+
+	class FoldingCollector(cp_model.CpSolverSolutionCallback):
+		def __init__(self, leafIndexAtPositionInput: list[cp_model.IntVar]) -> None:
+			super().__init__()
+			self.leafIndexAtPositionInput = leafIndexAtPositionInput
+			self.listFoldings: list[list[int]] = []
+
+		def OnSolutionCallback(self) -> None:
+			self.listFoldings.append([self.Value(positionVariable) + 1 for positionVariable in self.leafIndexAtPositionInput]) # pyright: ignore[reportUnknownMemberType]
+
+	foldingCollector = FoldingCollector(listIndexAsIntVar)
+	solver.Solve(model, foldingCollector)
+	return foldingCollector.listFoldings
+
+def doTheNeedful(leavesTotal: int, workersMaximum: int = 1) -> int:
+	"""Count the number of valid foldings for a given number of leaves."""
+	return len(findValidFoldings(leavesTotal, workersMaximum)) * leavesTotal

mapFolding/algorithms/A000136elimination.py

@@ -0,0 +1,163 @@
+from itertools import permutations, starmap
+from typing import Final
+
+def isThisValid(folding: tuple[int, ...]) -> bool:
+	"""Verify that a folding sequence is possible.
+
+	Parameters
+	----------
+	folding : list[int]
+		List of integers representing the folding sequence.
+
+	Returns
+	-------
+	valid : bool
+		True if the folding sequence is valid, False otherwise.
+
+	Notes
+	-----
+	All 8 forbidden forms
+		[k, r, k+1, r+1] [r, k+1, r+1, k] [k+1, r+1, k, r] [r+1, k, r, k+1]
+		[r, k, r+1, k+1] [k, r+1, k+1, r] [r+1, k+1, r, k] [k+1, r, k, r+1]
+
+	I selected the four forms in which k precedes r. Because of the flow, I _think_ that is why these four are sufficient.
+
+	Citation
+	--------
+	John E. Koehler, Folding a strip of stamps, Journal of Combinatorial Theory, Volume 5, Issue 2, 1968, Pages 135-152, ISSN
+	0021-9800, https://doi.org/10.1016/S0021-9800(68)80048-1.
+	(https://www.sciencedirect.com/science/article/pii/S0021980068800481)
+
+	See Also
+	--------
+	- "[Annotated, corrected, scanned copy]" at https://oeis.org/A001011.
+	- Citation in BibTeX format "citations/KOEHLER1968135.bib".
+	"""
+	leavesTotal: int = len(folding)
+	for index, leaf in enumerate(folding[0:-1]):												# `[0:-1]` No room to interpose
+		if leaf == leavesTotal:
+			continue
+		indexLeafRightSide: int = folding.index(leaf+1)
+		leafIsOdd: int = leaf & 1
+
+		for indexInterposer, interposer in enumerate(folding[index + 1:None], start=index + 1):	# [k != r]
+			if leafIsOdd != (interposer & 1):													# [k%2 == r%2]
+				continue
+			if interposer == leavesTotal:
+				continue
+
+			indexInterposerRightSide: int = folding.index(interposer + 1)
+
+			if (index < indexInterposer < indexLeafRightSide < indexInterposerRightSide			# [k, r, k+1, r+1]
+			or  index < indexInterposerRightSide < indexLeafRightSide < indexInterposer			# [k, r+1, k+1, r]
+			or  indexLeafRightSide < indexInterposerRightSide < index < indexInterposer			# [k+1, r+1, k, r]
+			or  indexInterposerRightSide < index < indexInterposer < indexLeafRightSide			# [r+1, k, r, k+1]
+				):
+				return False
+	return True
+
+def count(prefix: list[int], permutands: list[int], postfix: list[int]) -> int:
+	"""Count the number of valid foldings for a given fixed start and remaining leaves.
+
+	Parameters
+	----------
+	prefix : list[int]
+		List of integers representing the fixed start of the folding sequence.
+	permutands : list[int]
+		List of elements to permute into permutations.
+	postfix : list[int]
+		List of integers representing the fixed end of the folding sequence.
+
+	Returns
+	-------
+	groupsOfFolds : int
+		Number of valid foldings, which each represent a group of folds, for the given configuration.
+	"""
+	groupsOfFolds: int = 0
+	for aPermutation in permutations(permutands):
+		groupsOfFolds += isThisValid((*prefix, *aPermutation, *postfix))
+	return groupsOfFolds
+
+def staging(prefix: list[int], permutands: list[int]) -> int:
+	"""Segregate sequences with a final `2`: necessary as part of excluding leading `1,2`.
+
+	Parameters
+	----------
+	prefix : list[int]
+		List of integers representing the fixed start of the folding sequence.
+	permutands : list[int]
+		List of elements to permute into permutations.
+
+	Notes
+	-----
+	Transformation indices:
+
+	1,3,4,5,6,2,
+	1,2,6,5,4,3,
+
+	All valid sequences that end with '2' are in the first half.
+	All valid sequences that start with '1,2' are in the second half.
+	The remaining valid sequences are evenly split between the two halves.
+	Therefore:
+		1. Filter out all '1,2' before checking validity.
+		2. If a valid sequence ends in '2', add 2 to the total count.
+		3. If a valid sequence does not end in '2', add 1 to the total count.
+
+	`leaf = leavesTotal` is evenly distributed in each half like this: (ex. from A007822(7))
+	^1,14, ,14,$ 612
+	,14,$ ^1,14, 1486
+	"""
+	groupsOfFolds: int = 0
+	postfix: list[int] = []
+	if 2 in permutands:
+		postfix.append(2)
+		postfixComplement: list[int] = permutands.copy()
+		postfixComplement.remove(2)
+		groupsOfFolds += count(prefix, postfixComplement, postfix) * 2
+		for leafPostfix in postfixComplement:
+			groupsOfFolds += count(prefix, [leaf for leaf in permutands if leaf != leafPostfix], [leafPostfix])
+	else:
+		groupsOfFolds += count(prefix, permutands, postfix)
+	return groupsOfFolds
+
+def doTheNeedful(n: int) -> int:
+	"""Count the number of valid foldings for a given number of leaves."""
+	leavesTotal: Final[int] = n
+	listToPermute: list[tuple[list[int], list[int]]] = []
+
+	prefix: list[int] = [1]
+	listLeaves: Final[list[int]] = list(range(leavesTotal, 1, -1))
+
+	permutands: list[int] = listLeaves.copy()
+
+# ------- Exclude leading 2 -------------------------------
+# NOTE 1,{3..n},{2..n}...
+	excludeLeading2: list[int] = permutands.copy()
+	excludeLeading2.remove(2)
+	listToPermute.extend([([*prefix, leafPrefix], [leaf for leaf in permutands if leaf != leafPrefix]) for leafPrefix in excludeLeading2])
+	del excludeLeading2
+
+# ------- Exclude interposed 2 ----------------------------
+# NOTE 1,{3..n},{3..n},{2..n}...
+# NOTE 1,{n,if n&1},{2..n-1}...
+	for aTuple in listToPermute.copy():
+		if len(aTuple[0]) != 2 or leavesTotal < 4:
+			continue
+		interposer: int = aTuple[0][1]
+		excludeInterposed2: list[int] = permutands.copy()
+		excludeInterposed2.remove(2)
+		excludeInterposed2.remove(interposer)
+		if interposer == leavesTotal and interposer & 1:
+			listToPermute.append(([*aTuple[0], 2], excludeInterposed2))
+		listToPermute.extend([([*aTuple[0], leafPrefix], [leaf for leaf in permutands if leaf not in (leafPrefix, interposer)]) for leafPrefix in excludeInterposed2])
+		listToPermute.remove(aTuple)
+		del aTuple, excludeInterposed2, interposer
+
+	return sum(starmap(staging, listToPermute)) * leavesTotal
+
+# ------- Exclude interposed 3 ----------------------------
+# NOTE 1,{3..n},{3..n},{2..n}...,{3..n}
+# NOTE 1,{3..n},{3..n},{3..n}...,{4..n},{3..n},{2}
+# NOTE 1,{3..n-1},...,{n,if ~n&1},{2}
+# NOTE 1,{n,if n&1},{2..n-1}...
+

mapFolding/algorithms/A000136eliminationParallel.py

@@ -0,0 +1,77 @@
+from concurrent.futures import Future, ProcessPoolExecutor
+from itertools import permutations
+
+def isThisValid(folding: list[int]) -> bool:
+	"""Verify that a folding sequence is possible.
+
+	Parameters
+	----------
+	folding : list[int]
+		List of integers representing the folding sequence.
+
+	Returns
+	-------
+	valid : bool
+		True if the folding sequence is valid, False otherwise.
+	"""
+	leavesTotal: int = len(folding)
+	for index, leaf in enumerate(folding[0:-1]):	# Last leaf cannot interpose
+		if leaf == leavesTotal:
+			continue
+		indexLeafRightSide: int = folding.index(leaf+1)
+		leafIsOdd: int = leaf & 1
+
+		for indexInterposer, interposer in enumerate(folding[index + 1:None], start=index + 1):	# [k != r]
+			if leafIsOdd != (interposer & 1):											# [k%2 == r%2]
+				continue
+			if interposer == leavesTotal:
+				continue
+
+			indexInterposerRightSide: int = folding.index(interposer + 1)
+
+			if (index < indexInterposer < indexLeafRightSide < indexInterposerRightSide	# [k, r, k+1, r+1]
+			or  index < indexInterposerRightSide < indexLeafRightSide < indexInterposer	# [k, r+1, k+1, r]
+			or  indexLeafRightSide < indexInterposerRightSide < index < indexInterposer	# [k+1, r+1, k, r]
+			or  indexInterposerRightSide < index < indexInterposer < indexLeafRightSide	# [r+1, k, r, k+1]
+				):
+				return False
+	return True
+
+def count(fixed: list[int], permutands: list[int]) -> int:
+	"""Count the number of valid foldings for a given fixed start and remaining leaves.
+
+	Parameters
+	----------
+	fixed : list[int]
+		List of integers representing the fixed start of the folding sequence.
+	permutands : list[int]
+		List of elements to permute into permutations.
+	"""
+	validTotal: int = 0
+	for aPermutation in permutations(permutands):
+		validTotal += isThisValid([*fixed, *aPermutation])
+	return validTotal
+
+def doTheNeedful(n: int, processesMaximum: int) -> int:
+	"""Count the number of valid foldings for a given number of leaves."""
+	validTotal: int = 0
+	listLeavesTruncated: list[int] = list(range(2, n + 1))
+# NOTE Design goals:
+# Minimize creation/destruction of processes.
+# Use all processes until the end.
+# A valid sequence takes many times more cycles to process than a sequence that is proved invalid in the first few elements.
+# So, dividing purely on the number of sequences is not optimal.
+# Prefer generators of lists over lists of lists.
+
+# In the current system, each `Future` leads to a returned value, which is then summed. But, I don't care about any specific
+# `Future`. I would rather have the processes "consume" work from a common well and return their results when the work is done.
+	workers: int = min(processesMaximum, n - 1)
+	with ProcessPoolExecutor(max_workers=workers) as processPool:
+		listFutures: list[Future[int]] = []
+		for index in range(len(listLeavesTruncated)):
+			permutands: list[int] = listLeavesTruncated.copy()
+			fixedLeaves: list[int] = [1, permutands.pop(index)]
+			listFutures.append(processPool.submit(count, fixedLeaves, permutands))
+		for futureCount in listFutures:
+			validTotal += futureCount.result()
+	return validTotal * n

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