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

easyRun/NOTcountingFolds.py

@@ -22,15 +22,26 @@ if __name__ == '__main__':
 	flow: str | None = None
 
 	oeisID = 'A007822'
+	oeisID = 'A000136'
 
 	flow = 'algorithm'
-	flow = 'asynchronous'
-	flow = 'theorem2Trimmed'
-	flow = 'theorem2Numba'
 	flow = 'theorem2'
+	flow = 'eliminationParallel'
+	flow = 'elimination_combi'
+	flow = 'constraintPropagation'
+	flow = 'elimination'
 
-	# for n in range(13,16):
-	for n in range(1,4):
+	sys.stdout.write(f"\033[{30+int(oeisID,11)%8};{40+int(oeisID,12)%8}m{oeisID} ")
+	sys.stdout.write(f"\033[{31+int(flow,35)%7};{41+int(flow,36)%7}m{flow}")
+	sys.stdout.write("\033[0m\n")
+
+	nList: list[int] = []
+	nList.extend(range(7, 11))
+	# nList.extend(range(9, 13))
+	# nList.extend(range(11, 15))
+	# nList.extend(range(13, 17))
+
+	for n in dict.fromkeys(nList):
 
 		timeStart = time.perf_counter()
 		countTotal = NOTcountingFolds(oeisID, n, flow, CPUlimit)
@@ -41,4 +52,3 @@ 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/__init__.py

@@ -0,0 +1 @@
+"""Instead of learning to make a Python UI, I made these modules."""

easyRun/countFolds.py

@@ -14,6 +14,7 @@ if __name__ == '__main__':
 			f"\033[{(not match)*91}m"
 			f"{n}\t"
 			f"{foldsTotal}\t"
+			f"{dictionaryOEISMapFolding[oeisID]['valuesKnown'][n]}\t"
 			f"{time.perf_counter() - timeStart:.2f}\t"
 			"\033[0m\n"
 		)
@@ -27,17 +28,23 @@ if __name__ == '__main__':
 	flow = 'numba'
 	flow = 'theorem2'
 	flow = 'theorem2Numba'
-	flow: str | None = 'theorem2Trimmed'
 
-
-	oeisID: str = 'A001415'
+	oeisID: str = 'A195646'
+	oeisID: str = 'A001418'
 	oeisID: str = 'A000136'
-	for n in range(1,4):
+	oeisID: str = 'A001416'
+	oeisID: str = 'A001415'
+	oeisID: str = 'A001417'
+
+	sys.stdout.write(f"\033[{30+int(oeisID,11)%8};{40+int(oeisID,12)%8}m{oeisID} ")
+	sys.stdout.write(f"\033[{31+int(flow,35)%7};{41+int(flow,36)%7}m{flow}")
+	sys.stdout.write("\033[0m\n")
+
+	for n in range(6,7):
 
 		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/eliminateFolds.py

@@ -0,0 +1,60 @@
+# ruff: noqa
+# pyright: basic
+from mapFolding import dictionaryOEISMapFolding, eliminateFolds
+from os import PathLike
+from pathlib import PurePath
+import sys
+import time
+
+if __name__ == '__main__':
+	def _write() -> None:
+		sys.stdout.write(
+			f"{(match:=foldsTotal == dictionaryOEISMapFolding[oeisID]['valuesKnown'][n])}\t"
+			f"\033[{(not match)*91}m"
+			f"{n}\t"
+			# f"{mapShape}\t"
+			f"{foldsTotal}\t"
+			f"{dictionaryOEISMapFolding[oeisID]['valuesKnown'][n]}\t"
+			f"{time.perf_counter() - timeStart:.2f}\t"
+			"\033[0m\n"
+		)
+
+	pathLikeWriteFoldsTotal: PathLike[str] | PurePath | None = None
+	oeisID: str = ''
+	flow: str = ''
+	CPUlimit: bool | float | int | None = -2
+
+	flow = 'elimination'
+	flow = 'constraintPropagation'
+
+	oeisID: str = 'A000136'
+	oeisID: str = 'A001416'
+	oeisID: str = 'A195646'
+	oeisID: str = 'A001415'
+	oeisID: str = 'A001418'
+	oeisID: str = 'A001417'
+
+	sys.stdout.write(f"\033[{30+int(oeisID,11)%8};{40+int(oeisID,12)%8}m{oeisID} ")
+	sys.stdout.write(f"\033[{31+int(flow,35)%7};{41+int(flow,36)%7}m{flow}")
+	sys.stdout.write("\033[0m\n")
+
+	for n in range(7,8):
+
+		mapShape: tuple[int, ...] = dictionaryOEISMapFolding[oeisID]['getMapShape'](n)
+
+		timeStart = time.perf_counter()
+		foldsTotal: int = eliminateFolds(
+						mapShape=mapShape
+						, pathLikeWriteFoldsTotal=pathLikeWriteFoldsTotal
+						, CPUlimit=CPUlimit
+						, flow=flow)
+
+		_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\eliminateFolds.py & title I'm done
+"""
+
+# maps of 3 x 3 ... x 3, divisible by leavesTotal * 2^dimensionsTotal * factorial(dimensionsTotal)

mapFolding/__init__.py

@@ -24,6 +24,7 @@ from mapFolding._theTypes import (
 from mapFolding._theSSOT import packageSettings as packageSettings
 
 from mapFolding.beDRY import (
+    exclude as exclude,
 	getConnectionGraph as getConnectionGraph,
 	getLeavesTotal as getLeavesTotal,
 	getTaskDivisions as getTaskDivisions,
@@ -38,7 +39,7 @@ from mapFolding.filesystemToolkit import (
 	saveFoldsTotal as saveFoldsTotal,
 	saveFoldsTotalFAILearly as saveFoldsTotalFAILearly)
 
-from mapFolding.basecamp import countFolds as countFolds
+from mapFolding.basecamp import countFolds as countFolds, eliminateFolds as eliminateFolds
 
 from mapFolding.oeis import (
 	dictionaryOEIS as dictionaryOEIS,

mapFolding/_theTypes.py

@@ -131,4 +131,3 @@ class ShapeSlicer(NamedTuple):
 
 	length: EllipsisType | slice
 	indices: int
-

mapFolding/algorithms/A086345.py

@@ -1,4 +1,9 @@
-"""Directly based on code Chai Wah Wu, https://oeis.org/wiki/User:Chai_Wah_Wu, posted on OEIS."""
+"""Directly based on code by Chai Wah Wu, https://oeis.org/wiki/User:Chai_Wah_Wu, posted on OEIS.
+
+See Also
+--------
+mapFolding/reference/A086345Wu.py
+"""
 from fractions import Fraction
 from functools import cache
 from itertools import combinations
@@ -32,7 +37,7 @@ def _blender(n: int) -> int:
 			nummaNumma += _goRight(integer, copies)
 			denominator *= _deFactorial(integer, copies)
 		numerator: int = 3 ** (numbinations + nummaNumma)
-		sumReBletionary += Fraction(numerator, denominator)
+		sumReBletionary += Fraction(numerator, denominator) # pyright: ignore[reportAssignmentType]
 	return sumReBletionary
 
 @cache
@@ -70,6 +75,6 @@ def A086345(n: int) -> int:
 	else:
 		aOFn: int = 0
 		for aDivisor in divisors(n, generator=True):
-			aOFn += mobius(aDivisor) * _recurser(n//aDivisor)
+			aOFn += mobius(aDivisor) * _recurser(n//aDivisor) # pyright: ignore[reportAssignmentType]
 		aOFn //= n
 	return aOFn

mapFolding/algorithms/__init__.py

@@ -1 +1 @@
-"""Hand-made algorithms."""
+"""Hand-made algorithms and formulas."""

mapFolding/algorithms/constraintPropagation.py

@@ -0,0 +1,184 @@
+# ruff: noqa: ERA001
+from concurrent.futures import as_completed, Future, ProcessPoolExecutor
+from copy import deepcopy
+from itertools import pairwise, product as CartesianProduct
+from mapFolding.algorithms.patternFinder import getDictionaryIndexLeafRanges
+from mapFolding.algorithms.pinning2Dn import pinByFormula, secondOrderLeaves, secondOrderPilings
+from mapFolding.dataBaskets import EliminationState
+from math import factorial, prod
+from more_itertools import iter_index, unique
+from ortools.sat.python import cp_model
+from tqdm import tqdm
+from typing import Final
+
+def findValidFoldings(state: EliminationState) -> int:
+	model = cp_model.CpModel()
+
+	listIndicesLeafInPilingsOrder: list[cp_model.IntVar] = [model.NewIntVar(0, state.leavesTotal - 1, f"indexLeafInPile[{pile}]") for pile in range(state.leavesTotal)]
+	listPilingsInIndexLeafOrder: list[cp_model.IntVar] = [model.NewIntVar(0, state.leavesTotal - 1, f"pileOfIndexLeaf[{indexLeaf}]") for indexLeaf in range(state.leavesTotal)]
+	model.AddInverse(listIndicesLeafInPilingsOrder, listPilingsInIndexLeafOrder)
+
+# ------- Leaf domain restrictions from dictionaryLeafRanges -----------------------------
+	if (state.dimensionsTotal > 2) and (state.mapShape[0] == 2):
+		dictionaryLeafRanges: Final[dict[int, range]] = getDictionaryIndexLeafRanges(state)
+		for indexLeaf, rangePilings in dictionaryLeafRanges.items():
+			if indexLeaf < 2:
+				continue
+			model.AddAllowedAssignments([listPilingsInIndexLeafOrder[indexLeaf]], [(pile,) for pile in rangePilings])
+
+		if state.leavesTotal in [64, 128]:
+			from mapFolding.algorithms.patternFinder import getDictionaryAddends4Next  # noqa: PLC0415
+			dictionaryAddends4Next: Final[dict[int, list[int]]] = getDictionaryAddends4Next(state)
+			dictionaryNextLeaf: dict[int, list[int]] = {}
+			for indexLeaf, listDifferences in dictionaryAddends4Next.items():
+				listAllowedNextLeaves: list[int] = []
+				for difference in listDifferences:
+					listAllowedNextLeaves.append(indexLeaf + difference)  # noqa: PERF401
+				dictionaryNextLeaf[indexLeaf] = listAllowedNextLeaves
+
+	# ------- Constraints from dictionaryNextLeaf -----------------------------
+			for indexLeaf, listAllowedNextLeaves in dictionaryNextLeaf.items():
+				if not listAllowedNextLeaves:
+					continue
+				for pile in range(state.leavesTotal - 1):
+					currentLeafAtThisPile: cp_model.IntVar = listIndicesLeafInPilingsOrder[pile]
+					nextLeafAtNextPile: cp_model.IntVar = listIndicesLeafInPilingsOrder[pile + 1]
+
+					isCurrentLeafEqualToIndexLeaf: cp_model.IntVar = model.NewBoolVar(f"pile{pile}_leaf{indexLeaf}")
+					model.Add(currentLeafAtThisPile == indexLeaf).OnlyEnforceIf(isCurrentLeafEqualToIndexLeaf)
+					model.Add(currentLeafAtThisPile != indexLeaf).OnlyEnforceIf(isCurrentLeafEqualToIndexLeaf.Not())
+
+					model.AddAllowedAssignments([nextLeafAtNextPile], [(leaf,) for leaf in listAllowedNextLeaves]).OnlyEnforceIf(isCurrentLeafEqualToIndexLeaf)
+
+# ------- Manual concurrency -----------------------------
+	for pile, indexLeaf in state.pinnedLeaves.items():
+		model.Add(listIndicesLeafInPilingsOrder[pile] == indexLeaf)
+
+# ------- Lunnon Theorem 2(a): foldsTotal is divisible by leavesTotal; fix in pile at 0, indexLeaf at 0 -----------------------------
+	model.Add(listIndicesLeafInPilingsOrder[0] == 0)
+
+# ------- Lunnon Theorem 4: "G(p^d) is divisible by d!p^d." ---------------
+	for listIndicesSameMagnitude in [list(iter_index(state.mapShape, magnitude)) for magnitude in unique(state.mapShape)]:
+		if len(listIndicesSameMagnitude) > 1:
+			state.subsetsTheorem4 *= factorial(len(listIndicesSameMagnitude))
+			for dimensionAlpha, dimensionBeta in pairwise(listIndicesSameMagnitude):
+				k, r = (prod(state.mapShape[0:dimension]) for dimension in (dimensionAlpha, dimensionBeta))
+				model.Add(listPilingsInIndexLeafOrder[k] < listPilingsInIndexLeafOrder[r])
+
+# ------- Lunnon Theorem 2(b): "If some [magnitude in state.mapShape] > 2, [foldsTotal] is divisible by 2 * [leavesTotal]." -----------------------------
+	if state.subsetsTheorem4 == 1:
+		for aDimension in range(state.dimensionsTotal - 1, -1, -1):
+			if state.mapShape[aDimension] > 2:
+				state.subsetsTheorem2 = 2
+				indexLeafOrigin下_aDimension: int = prod(state.mapShape[0:aDimension])
+				model.Add(listPilingsInIndexLeafOrder[indexLeafOrigin下_aDimension] < listPilingsInIndexLeafOrder[2 * indexLeafOrigin下_aDimension])
+				break
+
+# ------- Forbidden inequalities -----------------------------
+	def addLessThan(comparatorLeft: int, comparatorRight: int) -> cp_model.IntVar:
+		ruleΩ: cp_model.IntVar = model.NewBoolVar(f"this_{comparatorLeft}_lessThan_{comparatorRight}")
+		model.Add(listPilingsInIndexLeafOrder[comparatorLeft] < listPilingsInIndexLeafOrder[comparatorRight]).OnlyEnforceIf(ruleΩ)
+		model.Add(listPilingsInIndexLeafOrder[comparatorLeft] >= listPilingsInIndexLeafOrder[comparatorRight]).OnlyEnforceIf(ruleΩ.Not())
+		return ruleΩ
+
+	def addForbiddenInequalityCycle(k: int, r: int, k1: int, r1: int) -> None:
+		k__小于_r: cp_model.IntVar = addLessThan(k, r) # 小, xiǎo: small, less; as in 李小龍, Lǐ Xiǎolóng, Lǐ little dragon, aka Bruce Lee
+		r1_小于_k: cp_model.IntVar = addLessThan(r1, k)
+		k1_小于_r1: cp_model.IntVar = addLessThan(k1, r1)
+		model.AddBoolOr([k1_小于_r1.Not(), r1_小于_k.Not(), k__小于_r.Not()])	# [k+1 < r+1 < k < r]
+
+		r__小于_k1: cp_model.IntVar = addLessThan(r, k1)
+		model.AddBoolOr([r1_小于_k.Not(), k__小于_r.Not(), r__小于_k1.Not()])	# [r+1 < k < r < k+1]
+
+		model.AddBoolOr([k__小于_r.Not(), r__小于_k1.Not(), k1_小于_r1.Not()])	# [k < r < k+1 < r+1]
+
+		k__小于_r1: cp_model.IntVar = addLessThan(k, r1)
+		r1_小于_k1: cp_model.IntVar = addLessThan(r1, k1)
+		k1_小于_r: cp_model.IntVar = addLessThan(k1, r)
+		model.AddBoolOr([k__小于_r1.Not(), r1_小于_k1.Not(), k1_小于_r.Not()])	# [k < r+1 < k+1 < r]
+
+	def indexLeaf2IndicesCartesian(indexLeaf: int) -> tuple[int, ...]:
+		return tuple((indexLeaf // prod(state.mapShape[0:dimension])) % state.mapShape[dimension] for dimension in range(state.dimensionsTotal))
+
+	def indexLeafNextCrease(indexLeaf: int, dimension: int) -> int | None:
+		indexLeafNext: int | None = None
+		if indexLeaf2IndicesCartesian(indexLeaf)[dimension] + 1 < state.mapShape[dimension]:
+			indexLeafNext = indexLeaf + prod(state.mapShape[0:dimension])
+		return indexLeafNext
+
+	for k, r in CartesianProduct(range(state.leavesTotal-1), range(1, state.leavesTotal-1)):
+		if k == r:
+			continue
+
+		k下_indicesCartesian: tuple[int, ...] = indexLeaf2IndicesCartesian(k) # 下, xià: below, subscript
+		r下_indicesCartesian: tuple[int, ...] = indexLeaf2IndicesCartesian(r)
+
+		for aDimension in range(state.dimensionsTotal):
+			k1下_aDimension: int | None = indexLeafNextCrease(k, aDimension)
+			r1下_aDimension: int | None = indexLeafNextCrease(r, aDimension)
+
+			if k1下_aDimension and r1下_aDimension and ((k下_indicesCartesian[aDimension] - r下_indicesCartesian[aDimension]) % 2 == 0):
+				addForbiddenInequalityCycle(k, r, k1下_aDimension, r1下_aDimension)
+
+# ------- Solver -----------------------------
+	solver = cp_model.CpSolver()
+	solver.parameters.enumerate_all_solutions = True
+
+	solver.parameters.log_search_progress = False
+
+	class FoldingCollector(cp_model.CpSolverSolutionCallback):
+		def __init__(self, _listOfIndicesLeafInPilingsOrder: list[cp_model.IntVar]) -> None:
+			super().__init__()
+			self._listOfIndicesLeafInPilingsOrder: list[cp_model.IntVar] = _listOfIndicesLeafInPilingsOrder
+			self.listFoldings: list[list[int]] = []
+
+		def OnSolutionCallback(self) -> None:
+			self.listFoldings.append([self.Value(indexLeaf) for indexLeaf in self._listOfIndicesLeafInPilingsOrder]) # pyright: ignore[reportUnknownMemberType]
+
+	foldingCollector = FoldingCollector(listIndicesLeafInPilingsOrder)
+	solver.Solve(model, foldingCollector)
+
+	# if not foldingCollector.listFoldings:
+	# 	print("\n",state.pinnedLeaves)
+	# if foldingCollector.listFoldings:
+	# 	print(*foldingCollector.listFoldings, sep="\n")
+
+	return len(foldingCollector.listFoldings) * state.subsetsTheorem2 * state.subsetsTheorem4
+
+def doTheNeedful(state: EliminationState, workersMaximum: int) -> EliminationState:
+	"""Find the quantity of valid foldings for a given map."""
+	# state = pinByFormula(state)
+	# state = secondOrderLeaves(state)
+	# state = secondOrderPilings(state)
+
+	if state.listPinnedLeaves:
+
+		with ProcessPoolExecutor(workersMaximum) as concurrencyManager:
+			listClaimTickets: list[Future[int]] = []
+
+			listPinnedLeavesCopy: list[dict[int, int]] = deepcopy(state.listPinnedLeaves)
+			state.listPinnedLeaves = []
+			for pinnedLeaves in listPinnedLeavesCopy:
+				stateCopy: EliminationState = deepcopy(state)
+				stateCopy.pinnedLeaves = pinnedLeaves
+				listClaimTickets.append(concurrencyManager.submit(findValidFoldings, stateCopy))
+
+			for claimTicket in tqdm(as_completed(listClaimTickets), total=len(listClaimTickets), disable=False):
+				state.groupsOfFolds += claimTicket.result()
+
+	elif workersMaximum > 1:
+		pile = 2
+		with ProcessPoolExecutor(workersMaximum) as concurrencyManager:
+			listClaimTickets: list[Future[int]] = []
+			for indicesLeaf in range(1, state.leavesTotal):
+				stateCopy: EliminationState = deepcopy(state)
+				stateCopy.pinnedLeaves = {pile: indicesLeaf}
+				listClaimTickets.append(concurrencyManager.submit(findValidFoldings, stateCopy))
+
+			for claimTicket in listClaimTickets:
+				state.groupsOfFolds += claimTicket.result()
+
+	else:
+		state.groupsOfFolds = findValidFoldings(deepcopy(state))
+
+	return state

mapFolding/algorithms/elimination.py

@@ -0,0 +1,131 @@
+from cytoolz.functoolz import curry as syntacticCurry
+from cytoolz.itertoolz import groupby as toolz_groupby
+from itertools import pairwise, repeat
+from mapFolding.algorithms.eliminationCount import count, permutands
+from mapFolding.algorithms.iff import productOfDimensions
+from mapFolding.algorithms.pinning2Dn import pinByFormula
+from mapFolding.dataBaskets import EliminationState
+from math import factorial
+from more_itertools import flatten, iter_index, unique
+from typing import Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+	from collections.abc import Callable
+
+@syntacticCurry
+def _excludeLeafAtColumn(sequencePinnedLeaves: list[dict[int, int]], leaf: int, column: int, leavesTotal: int) -> list[dict[int, int]]:
+	listPinnedLeaves: list[dict[int, int]] = []
+	for pinnedLeaves in sequencePinnedLeaves:
+		leafAtColumn: int | None = pinnedLeaves.get(column)
+		if leaf == leafAtColumn:
+			continue																						# Exclude `leaf` previously fixed at `column`.
+		if (leafAtColumn is not None) or (leaf in pinnedLeaves.values()):									# `column` is occupied, which excludes `leaf`.
+			listPinnedLeaves.append(pinnedLeaves)															# Or `leaf` is pinned, but not at `column`.
+			continue
+		deconstructedPinnedLeaves: dict[int, dict[int, int]] = deconstructPinnedLeaves(pinnedLeaves, column, leavesTotal)
+		deconstructedPinnedLeaves.pop(leaf)																	# Exclude dictionary with `leaf` fixed at `column`.
+		listPinnedLeaves.extend(deconstructedPinnedLeaves.values())
+	return listPinnedLeaves
+
+def pinLeafAtColumn(sequencePinnedLeaves: list[dict[int, int]], leaf: int, column: int, leavesTotal: int) -> list[dict[int, int]]:
+	listPinnedLeaves: list[dict[int, int]] = []
+	for pinnedLeaves in sequencePinnedLeaves:
+		leafAtColumn: int | None = pinnedLeaves.get(column)
+		if leaf == leafAtColumn:
+			listPinnedLeaves.append(pinnedLeaves)															# That was easy.
+			continue
+		if leafAtColumn is not None:																		# `column` is occupied, but not by `leaf`, so exclude it.
+			continue
+		listPinnedLeaves.append(deconstructPinnedLeaves(pinnedLeaves, column, leavesTotal).pop(leaf))		# Keep the dictionary with `leaf` fixed at `column`.
+	return listPinnedLeaves
+
+@syntacticCurry
+def _isPinnedAtColumn(pinnedLeaves: dict[int, int], leaf: int, column: int) -> bool:
+	return leaf == pinnedLeaves.get(column)
+
+def _segregatePinnedAtColumn(listPinnedLeaves: list[dict[int, int]], leaf: int, column: int) -> tuple[list[dict[int, int]], list[dict[int, int]]]:
+	isPinned: Callable[[dict[int, int]], bool] = _isPinnedAtColumn(leaf=leaf, column=column)
+	grouped: dict[bool, list[dict[int, int]]] = toolz_groupby(isPinned, listPinnedLeaves)
+	return (grouped.get(False, []), grouped.get(True, []))
+
+@syntacticCurry
+def atColumnPinLeaf(pinnedLeaves: dict[int, int], column: int, leaf: int) -> dict[int, int]:
+	dictionaryPinnedLeaves: dict[int, int] = dict(pinnedLeaves)
+	dictionaryPinnedLeaves[column] = leaf
+	return dictionaryPinnedLeaves
+
+def deconstructPinnedLeaves(pinnedLeaves: dict[int, int], column: int, leavesTotal: int) -> dict[int, dict[int, int]]:
+	"""Replace `pinnedLeaves`, which doesn't pin a leaf at `column`, with the equivalent group of dictionaries, which each pin a distinct leaf at `column`.
+
+	Parameters
+	----------
+	pinnedLeaves : dict[int, int]
+		Dictionary to divide and replace.
+	column : int
+		Column in which to pin a leaf.
+
+	Returns
+	-------
+	deconstructedPinnedLeaves : dict[int, dict[int, int]]
+		Dictionary mapping from `leaf` pinned at `column` to the dictionary with the `leaf` pinned at `column`.
+	"""
+	leafAtColumn: int | None = pinnedLeaves.get(column)
+	if leafAtColumn is not None:
+		deconstructedPinnedLeaves: dict[int, dict[int, int]] = {leafAtColumn: pinnedLeaves}
+	else:
+		pin: Callable[[int], dict[int, int]] = atColumnPinLeaf(pinnedLeaves, column)
+		deconstructedPinnedLeaves = {leaf: pin(leaf) for leaf in permutands(pinnedLeaves, leavesTotal)}
+	return deconstructedPinnedLeaves
+
+def DOTvalues[个](dictionary: dict[Any, 个]) -> list[个]:
+	return list(dictionary.values())
+
+def deconstructListPinnedLeaves(listPinnedLeaves: list[dict[int, int]], column: int, leavesTotal: int) -> list[dict[int, int]]:
+	return list(flatten(map(DOTvalues, map(deconstructPinnedLeaves, listPinnedLeaves, repeat(column), repeat(leavesTotal)))))
+
+def _excludeLeafRBeforeLeafK(state: EliminationState, k: int, r: int, columnK: int, listPinnedLeaves: list[dict[int, int]]) -> list[dict[int, int]]:
+	listPinnedLeaves = deconstructListPinnedLeaves(listPinnedLeaves, columnK, state.leavesTotal)
+	listPinned: list[dict[int, int]] = []
+	for column in range(columnK, state.columnLast + 1):
+		(listPinnedLeaves, listPinnedAtColumn) = _segregatePinnedAtColumn(listPinnedLeaves, k, column)
+		listPinned.extend(listPinnedAtColumn)
+	listPinnedLeaves.extend(_excludeLeafAtColumn(listPinned, r, columnK - 1, state.leavesTotal))
+	return listPinnedLeaves
+
+def excludeLeafRBeforeLeafK(state: EliminationState, k: int, r: int) -> EliminationState:
+	for columnK in range(state.columnLast, 0, -1):
+		state.listPinnedLeaves = _excludeLeafRBeforeLeafK(state, k, r, columnK, state.listPinnedLeaves)
+	return state
+
+def theorem4(state: EliminationState) -> EliminationState:
+# ------- Lunnon Theorem 4: "G(p^d) is divisible by d!p^d." ---------------
+	for listIndicesSameMagnitude in [list(iter_index(state.mapShape, magnitude)) for magnitude in unique(state.mapShape)]:
+		if len(listIndicesSameMagnitude) > 1:
+			state.subsetsTheorem4 = factorial(len(listIndicesSameMagnitude))
+			for dimensionAlpha, dimensionBeta in pairwise(listIndicesSameMagnitude):
+				k, r = (productOfDimensions(state.mapShape, dimension) + 1 for dimension in (dimensionAlpha, dimensionBeta))
+				state = excludeLeafRBeforeLeafK(state, k, r)
+	return state
+
+def theorem2b(state: EliminationState) -> EliminationState:
+# ------- Lunnon Theorem 2(b): "If some pᵢ > 2, G is divisible by 2n." -----------------------------
+	if state.subsetsTheorem4 == 1 and max(state.mapShape) > 2:
+		state.subsetsTheorem2 = 2
+		dimension: int = state.mapShape.index(max(state.mapShape))
+		k: int = productOfDimensions(state.mapShape, dimension) + 1
+		r: int = 2 * k
+		state = excludeLeafRBeforeLeafK(state, k, r)
+
+	return state
+
+def doTheNeedful(state: EliminationState, workersMaximum: int) -> EliminationState:  # noqa: ARG001
+	"""Count the number of valid foldings for a given number of leaves."""
+# ------- Lunnon Theorem 2(a): foldsTotal is divisible by leavesTotal; Pin leaf1 in column0 and exclude leaf2--leafN at column0 ----------------------------
+	state.listPinnedLeaves = [{0: 1}]
+
+	state = theorem4(state)
+	state = theorem2b(state)
+	state = pinByFormula(state)
+	state = count(state)
+
+	return state

mapFolding/algorithms/eliminationCount.py

@@ -0,0 +1,26 @@
+from collections.abc import Iterator
+from cytoolz.functoolz import memoize
+from itertools import permutations, repeat
+from mapFolding.algorithms.iff import thisLeafFoldingIsValid
+from mapFolding.dataBaskets import EliminationState
+
+def _makeFolding(pinnedLeaves: dict[int, int], permutandsPermutation: tuple[int, ...], leavesTotal: int) -> tuple[int, ...]:
+	permutand: Iterator[int] = iter(permutandsPermutation)
+	return tuple([pinnedLeaves.get(column) or next(permutand) for column in range(leavesTotal)])
+
+@memoize
+def setOfLeaves(leavesTotal: int) -> set[int]:
+	return set(range(1, leavesTotal + 1))
+
+def permutands(pinnedLeaves: dict[int, int], leavesTotal: int) -> tuple[int, ...]:
+	return tuple(setOfLeaves(leavesTotal).difference(pinnedLeaves.values()))
+
+def permutePermutands(pinnedLeaves: dict[int, int], leavesTotal: int) -> Iterator[tuple[int, ...]]:
+	return permutations(permutands(pinnedLeaves, leavesTotal))
+
+def countPinnedLeaves(pinnedLeaves: dict[int, int], mapShape: tuple[int, ...], leavesTotal: int) -> int:
+	return sum(map(thisLeafFoldingIsValid, map(_makeFolding, repeat(pinnedLeaves), permutePermutands(pinnedLeaves, leavesTotal), repeat(leavesTotal)), repeat(mapShape)))
+
+def count(state: EliminationState) -> EliminationState:
+	state.groupsOfFolds += sum(map(countPinnedLeaves, state.listPinnedLeaves, repeat(state.mapShape), repeat(state.leavesTotal)))
+	return state

mapFolding/algorithms/eliminationPinned.py

@@ -0,0 +1,35 @@
+from concurrent.futures import as_completed, Future, ProcessPoolExecutor
+from copy import deepcopy
+from mapFolding.algorithms.eliminationCount import count
+from mapFolding.algorithms.pinning2Dn import pinByFormula
+from mapFolding.dataBaskets import EliminationState
+from math import e, factorial
+from more_itertools import chunked_even
+from tqdm import tqdm
+
+def doTheNeedful(state: EliminationState, workersMaximum: int) -> EliminationState:
+	"""Find the quantity of valid foldings for a given map."""
+	state = pinByFormula(state)
+
+	groupsOfFolds:int = 0
+
+	with ProcessPoolExecutor(workersMaximum) as concurrencyManager:
+		listClaimTickets: list[Future[EliminationState]] = []
+
+		listPinnedLeavesCopy: list[dict[int, int]] = deepcopy(state.listPinnedLeaves)
+		state.listPinnedLeaves = []
+
+		# lengthChunk:int = max(1, int(len(listPinnedLeavesCopy) / (e * workersMaximum)))
+		lengthChunk:int = 5
+
+		for listPinnedLeaves in chunked_even(listPinnedLeavesCopy, lengthChunk):
+			stateCopy: EliminationState = deepcopy(state)
+			stateCopy.listPinnedLeaves = listPinnedLeaves
+			listClaimTickets.append(concurrencyManager.submit(count, stateCopy))
+
+		for claimTicket in tqdm(as_completed(listClaimTickets), total=len(listClaimTickets), disable=False):
+			groupsOfFolds += claimTicket.result().groupsOfFolds
+
+	state.subsetsTheorem4 = factorial(state.dimensionsTotal)
+
+	return state