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

mapFolding/algorithms/pinning2Dn.py

@@ -0,0 +1,345 @@
+# ruff: noqa ERA001
+from collections.abc import Callable
+from gmpy2 import bit_test, is_even, is_odd
+from hunterMakesPy import raiseIfNone
+from mapFolding.algorithms.patternFinder import (
+	bitBiggest, bitSecond, distanceFromPowerOf2, getDictionaryAddends4Next, getDictionaryAddends4Prior,
+	getDictionaryLeafRanges, getDictionaryPileToLeaves, getExcludedAddendIndices, getExcludedIndexLeaves,
+	multiplicityOfPrimeFactor2, numeralOfLengthInBase)
+from mapFolding.algorithms.pinning2DnAnnex import addItUp, exclude_rBefore_k
+from mapFolding.dataBaskets import EliminationState
+from mapFolding.tests.verify import printStatisticsPermutations, verifyPinning2Dn
+from math import log2, prod
+from pprint import pprint
+
+def pinByFormula(state: EliminationState, maximumListPinnedLeaves: int = 5000) -> EliminationState:
+	if not ((state.dimensionsTotal > 2) and (state.mapShape[0] == 2)):
+		return state
+
+	def appendPinnedLeavesAtPile(pinnedLeavesWorkbench: dict[int, int], listIndexLeavesAtPile: list[int], pile: int, mapShape: tuple[int, ...]) -> None:
+		for indexLeaf in listIndexLeavesAtPile:
+			if indexLeaf < sumsProductsOfDimensions[0]:
+				continue
+
+			if indexLeaf > sumsProductsOfDimensions[-1]:
+				continue
+
+			if indexLeaf in pinnedLeavesWorkbench.values():
+				continue
+
+			if pile not in list(dictionaryLeafRanges[indexLeaf]):
+				continue
+
+			if exclude_rBefore_k(pile, indexLeaf, pinnedLeavesWorkbench, mapShape):
+				continue
+
+			pileToPin: int = pile
+			pinnedLeaves: dict[int, int] = pinnedLeavesWorkbench.copy()
+
+			if indexLeaf in [0b000011, ordinal([0,1],'0',0)]:
+				pinnedLeaves[pileToPin] = indexLeaf
+				pileToPin += 1
+				indexLeaf += dictionaryAddends4Next[indexLeaf][0]
+
+			if indexLeaf in [0b000010, ordinal([1,1],'0',0)]:
+				pinnedLeaves[pileToPin] = indexLeaf
+				pileToPin -= 1
+				indexLeaf += dictionaryAddends4Prior[indexLeaf][0]
+
+			pinnedLeaves[pileToPin] = indexLeaf
+			state.listPinnedLeaves.append(pinnedLeaves.copy())
+
+	def nextPinnedLeavesWorkbench(state: EliminationState) -> dict[int, int] | None:
+		pinnedLeavesWorkbench: dict[int, int] | None = None
+		for pile in pileProcessingOrder:
+			if pile == queueStopBefore:
+				break
+			if not all(pile in pinnedLeaves for pinnedLeaves in state.listPinnedLeaves):
+				pinnedLeavesWorkbench = next((pinnedLeaves.copy() for pinnedLeaves in state.listPinnedLeaves if pile not in pinnedLeaves))
+				state.listPinnedLeaves.remove(pinnedLeavesWorkbench)
+				break
+		return pinnedLeavesWorkbench
+
+	def whereNext(pilingsPinned: list[int]) -> int:
+		return next(pile for pile in pileProcessingOrder if pile not in pilingsPinned)
+
+	ordinal: Callable[[int | list[int], str, int | list[int]], int] = numeralOfLengthInBase(positions=state.dimensionsTotal, base=state.mapShape[0])
+	"""Prototype."""
+
+	productsOfDimensions:		list[int] = [prod(state.mapShape[0:dimension]) for dimension in range(state.dimensionsTotal + 1)]
+	sumsProductsOfDimensions:	list[int] = [sum(productsOfDimensions[0:dimension]) for dimension in range(state.dimensionsTotal + 1)]
+
+	dictionaryAddends4Next:		dict[int, list[int]]	= getDictionaryAddends4Next(state)
+	dictionaryAddends4Prior:	dict[int, list[int]]	= getDictionaryAddends4Prior(state)
+	dictionaryLeafRanges:		dict[int, range]		= getDictionaryLeafRanges(state)
+	dictionaryPileToLeaves:		dict[int, list[int]]	= getDictionaryPileToLeaves(state)
+
+	state.listPinnedLeaves = state.listPinnedLeaves or [{0b000000: 0b000000}]
+
+	pileProcessingOrder: list[int] = [0b000000, 0b000001, 0b000010, ordinal([1,1],'1',1), ordinal([1,1],'1',0), 0b000011, ordinal([1,1],'1',[0,1]), 0b000100]
+	# pileProcessingOrder.extend([5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
+
+	pileProcessingOrder.extend([ordinal([0,1],'1',1), ordinal([0,1],'0',1), ordinal([1,1],'0',1)])
+	queueStopBefore: int = ordinal([0,1],'0',1)
+
+	oneTime: int = 0
+
+	while (len(state.listPinnedLeaves) < maximumListPinnedLeaves) and (pinnedLeavesWorkbench := nextPinnedLeavesWorkbench(state)):
+		pile: int = whereNext(list(pinnedLeavesWorkbench.keys()))
+		listIndexLeavesAtPile: list[int] = []
+		listAddendIndicesExcluded: list[int] = []
+		listRemoveIndexLeaves: list[int] = []
+
+		if pile == 0b000000:
+			listIndexLeavesAtPile.append(0b000000)
+		if pile == 0b000001:
+			listIndexLeavesAtPile.append(0b000001)
+		if pile == 0b000010:
+			listIndexLeavesAtPile = addItUp(dictionaryAddends4Next, pinnedLeavesWorkbench[pile - 1], listAddendIndicesExcluded)
+		if pile == ordinal([1,1],'1',1):
+			listIndexLeavesAtPile.append(ordinal([1,0],'0',0))
+		if pile == ordinal([1,1],'1',0):
+			indexLeafAt__10: int = pinnedLeavesWorkbench[0b000010]
+			if indexLeafAt__10.bit_length() < state.dimensionsTotal:
+				listAddendIndicesExcluded.extend([*range(0b000001, indexLeafAt__10.bit_length())])
+			listIndexLeavesAtPile = addItUp(dictionaryAddends4Prior, pinnedLeavesWorkbench[pile + 1], listAddendIndicesExcluded)
+		if pile == 0b000011:
+			listAddendIndicesExcluded.append(0)
+			indexLeafAtPileLess1: int = pinnedLeavesWorkbench[pile - 1]
+			indexLeafAt11ones0: int = pinnedLeavesWorkbench[ordinal([1,1],'1',0)]
+			if is_even(indexLeafAt11ones0) and (indexLeafAtPileLess1 == ordinal([1,0],'0',1)):
+				listAddendIndicesExcluded.extend([*range(multiplicityOfPrimeFactor2(pinnedLeavesWorkbench[ordinal([1,1],'1',0)]) + 1, state.dimensionsTotal)])
+			listIndexLeavesAtPile = addItUp(dictionaryAddends4Next, indexLeafAtPileLess1, listAddendIndicesExcluded)
+		if pile == ordinal([1,1],'1',[0,1]):
+			indexLeafAtPilePlus1: int = pinnedLeavesWorkbench[pile + 1]
+			if indexLeafAtPilePlus1 < ordinal([1,1],'0',0):
+				listAddendIndicesExcluded.append(-1)
+			indexLeafAt__10 = pinnedLeavesWorkbench[0b000010]
+			if (indexLeafAtPilePlus1 == ordinal([1,0],'0',1)) and (indexLeafAt__10 != 0b000011):
+				listAddendIndicesExcluded.extend([*range(0, indexLeafAt__10.bit_length() - 2)])
+			listIndexLeavesAtPile = addItUp(dictionaryAddends4Prior, indexLeafAtPilePlus1, listAddendIndicesExcluded)
+		if pile == 0b000100:
+			indexLeafAtPileLess1 = pinnedLeavesWorkbench[pile - 1]
+			if is_odd(indexLeafAtPileLess1):
+				listAddendIndicesExcluded.extend([*range(indexLeafAtPileLess1.bit_length() - 1, 5), distanceFromPowerOf2(indexLeafAtPileLess1 - 0b000011).bit_count()])
+			indexLeafAt11ones0 = pinnedLeavesWorkbench[ordinal([1,1],'1',0)]
+			if is_even(indexLeafAtPileLess1) and is_even(indexLeafAt11ones0):
+				listAddendIndicesExcluded.extend([*range(multiplicityOfPrimeFactor2(distanceFromPowerOf2(indexLeafAt11ones0)) - 0b000010, (state.dimensionsTotal - 3))])
+			if is_odd(indexLeafAtPileLess1):
+				listAddendIndicesExcluded.append((int(log2(distanceFromPowerOf2(indexLeafAt11ones0))) + 4) % 5)
+			indexLeafAt11ones01: int = pinnedLeavesWorkbench[ordinal([1,1],'1',[0,1])]
+			if is_even(indexLeafAtPileLess1) and indexLeafAt11ones01:
+				listAddendIndicesExcluded.extend([*range((state.dimensionsTotal - 3))][(state.dimensionsTotal - 3) - ((state.dimensionsTotal - 2) - distanceFromPowerOf2(indexLeafAt11ones01 - (indexLeafAt11ones01.bit_count() - is_even(indexLeafAt11ones01))).bit_count()) % (state.dimensionsTotal - 2) - is_even(indexLeafAt11ones01): None])
+			indexLeafAt__10 = pinnedLeavesWorkbench[0b000010]
+			if (indexLeafAt__10 == ordinal([1,0],'0',1)):
+				listAddendIndicesExcluded.extend([(int(log2(distanceFromPowerOf2(indexLeafAt11ones0))) + 4) % 5, multiplicityOfPrimeFactor2(indexLeafAt11ones01) - 1])
+			if (indexLeafAt__10 == ordinal([1,0],'0',1)) and (indexLeafAt11ones01 > ordinal([1,0],'0',1)):
+				listAddendIndicesExcluded.extend([*range(int(indexLeafAt11ones01 - 2**(indexLeafAt11ones01.bit_length() - 1)).bit_length() - 1, state.dimensionsTotal - 2)])
+			if ((indexLeafAt__10 == ordinal([1,0],'0',1)) and (0 < indexLeafAtPileLess1 - indexLeafAt__10 <= 2**(state.dimensionsTotal - 4)) and (0 < (indexLeafAt11ones0 - indexLeafAtPileLess1) <= 2**(state.dimensionsTotal - 3))):
+				listAddendIndicesExcluded.extend([distanceFromPowerOf2(indexLeafAtPileLess1 - 0b11).bit_count(), state.dimensionsTotal - 3, state.dimensionsTotal - 4])
+			listIndexLeavesAtPile = addItUp(dictionaryAddends4Next, indexLeafAtPileLess1, listAddendIndicesExcluded)
+
+
+		if pile == ordinal([0,1],'1',1):
+			listRemoveIndexLeaves = []
+
+			pileExcluder: int = 0b000010
+			indexLeafAtPileExcluder: int = pinnedLeavesWorkbench[pileExcluder]
+			for d in range(state.dimensionsTotal):
+				if d < state.dimensionsTotal - 2:
+					indexLeaf: int = dictionaryPileToLeaves[pileExcluder][d]
+					if indexLeaf == indexLeafAtPileExcluder:
+						listRemoveIndexLeaves.extend([0b000010, ordinal([1,0],'0',0) + indexLeafAtPileExcluder])
+				if 0 < d < state.dimensionsTotal - 2:
+					indexLeaf = dictionaryPileToLeaves[pileExcluder][d]
+					if indexLeaf == indexLeafAtPileExcluder:
+						listRemoveIndexLeaves.extend([0b000010 + indexLeafAtPileExcluder])
+				if d == 1:
+					indexLeaf = dictionaryPileToLeaves[pileExcluder][d]
+					if indexLeaf == indexLeafAtPileExcluder:
+						listRemoveIndexLeaves.extend([ordinal([1,0],'0',0) + indexLeafAtPileExcluder + 1])
+				if d == state.dimensionsTotal - 2:
+					indexLeaf = dictionaryPileToLeaves[pileExcluder][d]
+					if indexLeaf == indexLeafAtPileExcluder:
+						listRemoveIndexLeaves.extend([ordinal([0,1],'0',0), ordinal([0,1],'0',0) + indexLeafAtPileExcluder])
+			del pileExcluder
+
+			pileExcluder = ordinal([1,1],'1',0)
+			indexLeafAtPileExcluder = pinnedLeavesWorkbench[pileExcluder]
+			for d in range(state.dimensionsTotal):
+				if d == 0:
+					indexLeaf = dictionaryPileToLeaves[pileExcluder][d]
+					if indexLeaf == indexLeafAtPileExcluder:
+						listRemoveIndexLeaves.extend([0b000010])
+				if d < state.dimensionsTotal - 2:
+					indexLeaf = dictionaryPileToLeaves[pileExcluder][d]
+					if indexLeaf == indexLeafAtPileExcluder:
+						listRemoveIndexLeaves.extend([ordinal([0,1],'0',0) + indexLeafAtPileExcluder])
+				if 0 < d < state.dimensionsTotal - 2:
+					indexLeaf = dictionaryPileToLeaves[pileExcluder][d]
+					if indexLeaf == indexLeafAtPileExcluder:
+						listRemoveIndexLeaves.extend([2**d, ordinal([0,1],'0',0) + indexLeafAtPileExcluder - (2**d - 0b000001)])
+				if 0 < d < state.dimensionsTotal - 3:
+					indexLeaf = dictionaryPileToLeaves[pileExcluder][d]
+					if indexLeaf == indexLeafAtPileExcluder:
+						listRemoveIndexLeaves.extend([0b000001 + indexLeafAtPileExcluder])
+				if 0 < d < state.dimensionsTotal - 1:
+					indexLeaf = dictionaryPileToLeaves[pileExcluder][d]
+					if indexLeaf == indexLeafAtPileExcluder:
+						listRemoveIndexLeaves.extend([ordinal([0,1],'0',0)])
+			del pileExcluder
+
+			"""indexLeafAt__11
+			(2,) * 5:
+			13      False   [2, 4, 7, 11, 13, 19, 21, 25, 28]       [13, 4, 2, 28, 25, 11, 19]
+			25      False   [8, 25, 28]     [25, 8, 25, 8]
+
+			(2,) * 6:
+			13      False   [2, 4, 7, 11, 13, 35, 37, 41, 44]       [13, 4, 2, 44, 41, 11, 35]
+			21      False   [2, 4, 8, 19, 21, 25, 28, 35, 49, 52, 56]       [21, 4, 2, 52, 49, 19, 35]
+			25      False   [2, 8, 19, 25, 41, 49, 56, 59]  [25, 8, 2, 56, 49]
+			49      False   [16, 49, 56]    [49, 16, 49, 16]
+			"""
+			pileExcluder = 0b000011
+			indexLeafAtPileExcluder = pinnedLeavesWorkbench[pileExcluder]
+
+			if is_odd(indexLeafAtPileExcluder):
+				listRemoveIndexLeaves.extend([indexLeafAtPileExcluder, productsOfDimensions[raiseIfNone(bitSecond(indexLeafAtPileExcluder))]])
+
+				if indexLeafAtPileExcluder < ordinal([1,0],'0',0):
+					comebackOffset: int = sumsProductsOfDimensions[distanceFromPowerOf2(indexLeafAtPileExcluder - 0b000011).bit_count() + 1]
+					listRemoveIndexLeaves.extend([
+						0b000010
+						, indexLeafAtPileExcluder + ordinal([0,1],'1',1)
+						, indexLeafAtPileExcluder + ordinal([0,1],'1',1) - comebackOffset
+					])
+					if distanceFromPowerOf2(indexLeafAtPileExcluder - 0b000011).bit_count() == 1:
+						listRemoveIndexLeaves.extend([
+							productsOfDimensions[bitBiggest(indexLeafAtPileExcluder)] + comebackOffset
+							, ordinal([1,0],'0',0) + comebackOffset
+						])
+
+				if ordinal([1,0],'0',0) < indexLeafAtPileExcluder:
+					listRemoveIndexLeaves.extend([ordinal([1,1],'0',1), productsOfDimensions[bitBiggest(indexLeafAtPileExcluder) - 1]])
+			del pileExcluder
+
+			"""ordinal([1,1],'1',[0,1])
+			38: [2, 4, 16, 21, 35, 37, 38, 49, 50], # NOTE missing 21
+			42: [2, 4, 14, 16, 35, 37, 38, 41, 42, 49, 50], # NOTE missing 4, 14, 37, 38, 41
+			"""
+
+			pileExcluder = ordinal([1,1],'1',[0,1])
+			indexLeafAtPileExcluder = pinnedLeavesWorkbench[pileExcluder]
+			if ordinal([1,0],'0',0) < indexLeafAtPileExcluder:
+				listRemoveIndexLeaves.extend([ordinal([1,1],'0',1), indexLeafAtPileExcluder])
+
+				if is_even(indexLeafAtPileExcluder):
+					listRemoveIndexLeaves.extend([ordinal([0,1],'0',0)])
+					bit = 1
+					if bit_test(indexLeafAtPileExcluder, bit):
+						listRemoveIndexLeaves.extend([2**bit, ordinal([1,0],'0',0) + 2**bit + 0b000001])
+						listRemoveIndexLeaves.extend([state.leavesTotal - sum(productsOfDimensions[bit: state.dimensionsTotal - 2])])
+					bit = 2
+					if bit_test(indexLeafAtPileExcluder, bit):
+						listRemoveIndexLeaves.extend([2**bit, ordinal([1,0],'0',0) + 2**bit + 0b000001])
+						if 1 < multiplicityOfPrimeFactor2(indexLeafAtPileExcluder):
+							listRemoveIndexLeaves.extend([state.leavesTotal - sum(productsOfDimensions[bit: state.dimensionsTotal - 2])])
+					bit = 3
+					if bit_test(indexLeafAtPileExcluder, bit) and (1 < multiplicityOfPrimeFactor2(indexLeafAtPileExcluder)):
+						listRemoveIndexLeaves.extend([2**bit])
+						listRemoveIndexLeaves.extend([state.leavesTotal - sum(productsOfDimensions[bit: state.dimensionsTotal - 2])])
+						if multiplicityOfPrimeFactor2(indexLeafAtPileExcluder) < state.dimensionsTotal - 3:
+							listRemoveIndexLeaves.extend([ordinal([1,0],'0',0) + 2**bit + 0b000001])
+
+				if is_odd(indexLeafAtPileExcluder):
+					listRemoveIndexLeaves.extend([0b000010])
+
+					sheepOrGoat = distanceFromPowerOf2(indexLeafAtPileExcluder - 0b000011).bit_count()
+					if 0 < sheepOrGoat < state.dimensionsTotal - 3:
+						comebackOffset = 2**bitBiggest(indexLeafAtPileExcluder) - 2
+						listRemoveIndexLeaves.extend([indexLeafAtPileExcluder - comebackOffset])
+					if 0 < sheepOrGoat < state.dimensionsTotal - 4:
+						comebackOffset = 2**raiseIfNone(bitSecond(indexLeafAtPileExcluder)) - 2
+						listRemoveIndexLeaves.extend([indexLeafAtPileExcluder - comebackOffset])
+
+			pileExcluder = 0b000100
+			indexLeafAtPileExcluder = pinnedLeavesWorkbench[pileExcluder]
+
+			if is_even(indexLeafAtPileExcluder):
+				listRemoveIndexLeaves.extend([0b000010, indexLeafAtPileExcluder + 1, ordinal([1,0],'0',0) + 0b000011])
+			if is_odd(indexLeafAtPileExcluder):
+				listRemoveIndexLeaves.extend([indexLeafAtPileExcluder - 1])
+				if ordinal([0,1],'0',0) < indexLeafAtPileExcluder < ordinal([1,0],'0',0):
+					listRemoveIndexLeaves.extend([ordinal([0,1],'0',0) + 0b000011, ordinal([1,1],'0',1)])
+				if ordinal([1,0],'0',0) < indexLeafAtPileExcluder:
+					listRemoveIndexLeaves.extend([ordinal([0,1],'0',0), ordinal([1,1],'0',1)])
+					bit = 1
+					if bit_test(indexLeafAtPileExcluder, bit):
+						listRemoveIndexLeaves.extend([2**bit, ordinal([1,0],'0',0) + 2**bit + 0b000001])
+					bit = 2
+					if bit_test(indexLeafAtPileExcluder, bit):
+						listRemoveIndexLeaves.extend([ordinal([1,0],'0',0) + 2**bit + 0b000001])
+					bit = 3
+					if bit_test(indexLeafAtPileExcluder, bit):
+						listRemoveIndexLeaves.extend([ordinal([1,0],'0',0) + 2**bit + 0b000001])
+					bit = 4
+					if bit_test(indexLeafAtPileExcluder, bit) and (indexLeafAtPileExcluder.bit_length() > 5):
+						listRemoveIndexLeaves.extend([ordinal([1,1,1],'0',0)])
+			del pileExcluder
+
+			indexLeafAt__10 = pinnedLeavesWorkbench[0b000010]
+			indexLeafAt11ones0 = pinnedLeavesWorkbench[ordinal([1,1],'1',0)]
+			indexLeafAt__11 = pinnedLeavesWorkbench[0b000011]
+			indexLeafAt11ones01 = pinnedLeavesWorkbench[ordinal([1,1],'1',[0,1])]
+
+			if (indexLeafAt__11 != ordinal([1,1],'0',1)) and (indexLeafAt11ones0 == ordinal([1,1],'0',0)):
+				listRemoveIndexLeaves.append(0b000010)
+			if (indexLeafAt11ones01 != ordinal([1,0],'0',1) + dictionaryAddends4Prior[ordinal([1,0],'0',1)][0]) and (indexLeafAt__10 == 0b000011):
+				listRemoveIndexLeaves.append(ordinal([0,1],'0',0))
+
+			tuplePilesExcluders = (0b000010, ordinal([1,1],'1',0))
+			(indexLeavesAtPilesExcluders) = (indexLeafAt__10, indexLeafAt11ones0)
+			if (indexLeafAt__10 == ordinal([0,0,1],'0',1)) and (indexLeafAt11ones0 == ordinal([1,1],'0',0)):
+				listRemoveIndexLeaves.extend([ordinal([0,0,1],'0',0), ordinal([1,1,1],'0',0)])
+			if indexLeafAt__10 == ordinal([1,0],'0',1):
+				listRemoveIndexLeaves.extend([ordinal([0,1],'0',0), indexLeafAt11ones0 + 0b000001])
+			if indexLeafAt__10.bit_length() < state.dimensionsTotal - 2:
+				listRemoveIndexLeaves.extend([0b000010, indexLeafAt11ones0 + 0b000010])
+
+			tuplePilesExcluders = (0b000010, 0b000011)
+			(indexLeavesAtPilesExcluders) = (indexLeafAt__10, indexLeafAt__11)
+
+			tuplePilesExcluders = (ordinal([1,1],'1',0), ordinal([1,1],'1',[0,1]))
+			(indexLeavesAtPilesExcluders) = (indexLeafAt11ones0, indexLeafAt11ones01)
+
+			tuplePilesExcluders = (0b000011, ordinal([1,1],'1',[0,1]))
+			(indexLeavesAtPilesExcluders) = (indexLeafAt__11, indexLeafAt11ones01)
+
+			# listRemoveIndexLeaves: list[int] = []
+
+			dictionaryExcludedIndexLeaves = getExcludedIndexLeaves(state, pile, tuplePilesExcluders)
+			if oneTime < 1:
+				oneTime += 1
+				# pprint(dictionaryExcludedIndexLeaves, width=140)
+
+			listExcludedIndexLeavesGoal = dictionaryExcludedIndexLeaves[((indexLeavesAtPilesExcluders))]
+
+			# print(indexLeavesAtPilesExcluders, sorted(set(listExcludedIndexLeavesGoal).difference(set(listRemoveIndexLeaves)))
+			# 	, listExcludedIndexLeavesGoal == sorted(set(listRemoveIndexLeaves)), sorted(set(listRemoveIndexLeaves)), listExcludedIndexLeavesGoal, sep='\t')
+
+			listIndexLeavesAtPile = sorted(set(dictionaryPileToLeaves[pile]).difference(set(listRemoveIndexLeaves)))
+
+		appendPinnedLeavesAtPile(pinnedLeavesWorkbench, listIndexLeavesAtPile, pile, state.mapShape)
+
+	return state
+
+if __name__ == '__main__':
+	state = EliminationState((2,) * 5)
+	state: EliminationState = pinByFormula(state)
+
+	# pprint(state.listPinnedLeaves)
+	print(f"{len(state.listPinnedLeaves)=}")
+
+	printStatisticsPermutations(state)
+	verifyPinning2Dn(state)
+

mapFolding/algorithms/pinning2DnAnnex.py

@@ -0,0 +1,43 @@
+from itertools import pairwise, repeat
+from mapFolding import exclude
+from mapFolding.algorithms.patternFinder import getDictionaryLeafRanges
+from mapFolding.dataBaskets import EliminationState
+from math import prod
+from operator import add
+
+def secondOrderLeaves(state: EliminationState) -> EliminationState:
+	if not ((state.dimensionsTotal > 2) and (state.mapShape[0] == 2)):
+		return state
+
+	for pile in getDictionaryLeafRanges(state)[state.leavesTotal//2**2]:
+		state.listPinnedLeaves.append({0: 0, 1: 1
+					, pile  :   (1) * state.leavesTotal//2**2
+					, pile + 1 : (2**2 - 1) * state.leavesTotal//2**2
+		, state.leavesTotal - 1 :     state.leavesTotal//2**1})
+
+	return state
+
+def secondOrderPilings(state: EliminationState) -> EliminationState:
+	if not ((state.dimensionsTotal > 2) and (state.mapShape[0] == 2)):
+		return state
+
+	dictionaryLeafRanges: dict[int, range] = getDictionaryLeafRanges(state)
+	pile: int = state.leavesTotal//2**1
+	for indexLeaf in range(state.leavesTotal):
+		if pile in list(dictionaryLeafRanges[indexLeaf]):
+			state.listPinnedLeaves.append({0: 0, 1: 1
+								, pile : indexLeaf
+				, state.leavesTotal - 1 : state.leavesTotal//2**1})
+
+	return state
+
+def addItUp(dictionaryAddends: dict[int, list[int]], indexLeafAddend: int, listIndicesExcluded: list[int]) -> list[int]:
+	return list(map(add, repeat(indexLeafAddend), exclude(dictionaryAddends[indexLeafAddend], listIndicesExcluded)))
+
+def exclude_rBefore_k(pile: int, indexLeaf: int, pinnedLeaves: dict[int, int], mapShape: tuple[int, ...]) -> bool:
+	productsOfDimensions:  list[int] = [prod(mapShape[0:dimension]) for dimension in range((len(mapShape)) + 1)]
+	dictionary_r_to_k: dict[int, int] = {r: k for k, r in pairwise(productsOfDimensions[0:-1])}
+
+	if (k := dictionary_r_to_k.get(indexLeaf)) and (pileOf_k := next(iter(pilePinned for pilePinned, indexLeafPinned in pinnedLeaves.items() if indexLeafPinned == k), None)):
+		return pile < pileOf_k
+	return False

mapFolding/basecamp.py

@@ -169,12 +169,12 @@ def countFolds(listDimensions: Sequence[int] | None = None
 
 		mapFoldingParallelState: ParallelMapFoldingState = ParallelMapFoldingState(mapShape, taskDivisions=taskDivisions)
 
-		# `listStatesParallel` exists so you can research the parallel computation.
+		# NOTE `listStatesParallel` exists so you can research the parallel computation.
 		foldsTotal, _listStatesParallel = doTheNeedful(mapFoldingParallelState, concurrencyLimit)
 
 # ruff: noqa: E701
 	else:
-		if all(dimension < 3 for dimension in mapShape):
+		if all(dimension < 2 for dimension in mapShape):
 			from mapFolding.algorithms.daoOfMapFolding import doTheNeedful
 		else:
 			match flow:
@@ -196,6 +196,75 @@ def countFolds(listDimensions: Sequence[int] | None = None
 
 	return foldsTotal
 
+def eliminateFolds(mapShape: tuple[int, ...]
+				, pathLikeWriteFoldsTotal: PathLike[str] | PurePath | None = None
+				# , * # TODO improve `standardizedEqualToCallableReturn` so it will work with keyword arguments
+				, CPUlimit: bool | float | int | None = None  # noqa: FBT001
+				, flow: str | None = None
+				) -> int:
+	"""
+	Compute foldsTotal by elimination.
+
+	Parameters
+	----------
+	mapShape : tuple[int, ...] | None = None
+		Tuple of integers representing the dimensions of the map to be folded. Mathematicians almost always use the term
+		"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.
+	pathLikeWriteFoldsTotal : PathLike[str] | PurePath | None = None
+		A filename, a path of only directories, or a path with directories and a filename to which `countFolds` will write the
+		value of `foldsTotal`. If `pathLikeWriteFoldsTotal` is a path of only directories, `countFolds` creates a filename based
+		on the map dimensions.
+	CPUlimit : bool | float | int | None = None
+		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.
+		- `int >= 1`: The maximum number of available processors to use.
+		- `0 < float < 1`: The maximum number of processors to use expressed as a fraction of available processors.
+		- `-1 < float < 0`: The number of processors to *not* use expressed as a fraction of available processors.
+		- `int <= -1`: The number of available processors to *not* use.
+		- If the value of `CPUlimit` is a `float` greater than 1 or less than -1, `countFolds` truncates the value to an `int`
+		with the same sign as the `float`.
+	flow : str | None = None
+		My stupid way of selecting the version of the algorithm to use in the computation.
+
+	Returns
+	-------
+	foldsTotal : int
+		Number of distinct ways to fold a map of the given dimensions.
+	"""
+	from mapFolding.beDRY import setProcessorLimit
+	concurrencyLimit: int = setProcessorLimit(CPUlimit, packageSettings.concurrencyPackage)
+
+# ------- memorialization instructions ---------------------------------------------
+
+	if pathLikeWriteFoldsTotal is not None:
+		pathFilenameFoldsTotal: Path | None = getPathFilenameFoldsTotal(mapShape, pathLikeWriteFoldsTotal)
+		saveFoldsTotalFAILearly(pathFilenameFoldsTotal)
+	else:
+		pathFilenameFoldsTotal = None
+
+# ------- Algorithm version -----------------------------------------------------
+# ruff: noqa: E701
+	match flow:
+		case 'constraintPropagation': from mapFolding.algorithms.constraintPropagation import doTheNeedful
+		case 'pinned': from mapFolding.algorithms.eliminationPinned import doTheNeedful
+		case 'elimination' | _: from mapFolding.algorithms.elimination import doTheNeedful
+
+	from mapFolding.dataBaskets import EliminationState
+	eliminationState: EliminationState = EliminationState(mapShape)
+	eliminationState = doTheNeedful(eliminationState, concurrencyLimit)
+	foldsTotal = eliminationState.foldsTotal
+
+# ------- Follow memorialization instructions ---------------------------------------------
+
+	if pathFilenameFoldsTotal is not None:
+		saveFoldsTotal(pathFilenameFoldsTotal, foldsTotal)
+
+	return foldsTotal
+
 def NOTcountingFolds(oeisID: str, oeis_n: int, flow: str | None = None
 # TODO , pathLikeWriteFoldsTotal: PathLike[str] | PurePath | None = None
 		, CPUlimit: bool | float | int | None = None  # noqa: FBT001
@@ -205,6 +274,7 @@ 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
@@ -223,22 +293,6 @@ def NOTcountingFolds(oeisID: str, oeis_n: int, flow: str | None = None
 	else:
 		matched_oeisID = True
 		match oeisID:
-			case 'A000136':
-				from mapFolding import setProcessorLimit
-				concurrencyLimit: int = setProcessorLimit(CPUlimit)
-				match flow:
-					case 'elimination':
-						from mapFolding.algorithms.A000136elimination import doTheNeedful
-						countTotal = doTheNeedful(oeis_n)
-					case 'eliminationParallel':
-						from mapFolding.algorithms.A000136eliminationParallel import doTheNeedful
-						countTotal = doTheNeedful(oeis_n, concurrencyLimit)
-					case 'constraintPropagation':
-						from mapFolding.algorithms.A000136constraintPropagation import doTheNeedful
-						countTotal = doTheNeedful(oeis_n, concurrencyLimit)
-					case _:
-						from mapFolding.algorithms.oeisIDbyFormula import A000136 as doTheNeedful
-						countTotal = doTheNeedful(oeis_n)
 			case 'A000682' | 'A005316':
 				match flow:
 					case 'matrixNumPy':

mapFolding/beDRY.py

@@ -1,13 +1,26 @@
 """Oft-needed computations or actions, especially for multi-dimensional map folding."""
 
-from collections.abc import Sequence
+from collections.abc import Iterable, Iterator, Sequence
+from functools import cache
 from hunterMakesPy import defineConcurrencyLimit, intInnit, oopsieKwargsie
 from mapFolding import NumPyIntegerType
+from more_itertools import extract
 from numpy import dtype as numpy_dtype, int64 as numpy_int64, ndarray
 from sys import maxsize as sysMaxsize
 from typing import Any
 import numpy
 
+def exclude[个](iterable: Sequence[个], indices: Iterable[int]) -> Iterator[个]:
+	"""Yield items from `iterable` whose positions are not in `indices`."""
+	lengthIterable: int = len(iterable)
+	def normalizeIndex(index: int) -> int:
+		if index < 0:
+			index = (index + lengthIterable) % lengthIterable
+		return index
+	indicesInclude: list[int] = sorted(set(range(lengthIterable)).difference(map(normalizeIndex, indices)))
+	return extract(iterable, indicesInclude)
+
+@cache
 def getLeavesTotal(mapShape: tuple[int, ...]) -> int:
 	"""Calculate the total number of leaves in a map with the given dimensions.
 

mapFolding/dataBaskets.py

@@ -25,6 +25,62 @@ from mapFolding import (
 	getConnectionGraph, getLeavesTotal, makeDataContainer)
 import dataclasses
 
+@dataclasses.dataclass(slots=True)
+class EliminationState:
+	"""Computational state for algorithms to compute foldsTotal by elimination.
+
+	Attributes
+	----------
+	mapShape : tuple[DatatypeLeavesTotal, ...]
+		Dimensions of the map being analyzed for folding patterns.
+	groupsOfFolds : DatatypeFoldsTotal = DatatypeFoldsTotal(0)
+		Current count of distinct folding pattern groups: each group has `leavesTotal`-many foldings.
+	dimensionsTotal : DatatypeLeavesTotal
+		Unchanging total number of dimensions in the map.
+	leavesTotal : DatatypeLeavesTotal
+		Unchanging total number of leaves in the map.
+	"""
+
+	mapShape: tuple[DatatypeLeavesTotal, ...] = dataclasses.field(init=True, metadata={'elementConstructor': 'DatatypeLeavesTotal'})
+	"""Dimensions of the map being analyzed for folding patterns."""
+
+	groupsOfFolds: DatatypeFoldsTotal = dataclasses.field(default=DatatypeFoldsTotal(0), metadata={'theCountingIdentifier': True})
+	"""Current count of distinct folding pattern groups: each group has `leavesTotal`-many foldings."""
+
+	listPinnedLeaves: list[dict[int, int]] = dataclasses.field(default_factory=list[dict[int, int]], init=True)
+	"""column: leaf or pile: indexLeaf"""
+	pile: DatatypeLeavesTotal = DatatypeLeavesTotal(-1)  # noqa: RUF009
+	pinnedLeaves: dict[int, int] = dataclasses.field(default_factory=dict[int, int], init=True, metadata={'elementConstructor': 'DatatypeLeavesTotal'})
+	"""column: leaf or pile: indexLeaf"""
+
+	subsetsTheorem2: DatatypeLeavesTotal = DatatypeLeavesTotal(1)  # noqa: RUF009
+	subsetsTheorem3: DatatypeLeavesTotal = DatatypeLeavesTotal(1)  # noqa: RUF009
+	subsetsTheorem4: DatatypeLeavesTotal = DatatypeLeavesTotal(1)  # noqa: RUF009
+
+	columnLast: DatatypeLeavesTotal = dataclasses.field(init=False)
+	dimensionsTotal: DatatypeLeavesTotal = dataclasses.field(init=False)
+	"""Unchanging total number of dimensions in the map."""
+	leavesTotal: DatatypeLeavesTotal = dataclasses.field(init=False)
+	"""Unchanging total number of leaves in the map."""
+
+	@property
+	def foldsTotal(self) -> DatatypeFoldsTotal:
+		"""The total number of possible folding patterns for this map.
+
+		Returns
+		-------
+		foldsTotal : DatatypeFoldsTotal
+			The complete count of distinct folding patterns achievable with the current map configuration.
+
+		"""
+		return DatatypeFoldsTotal(self.leavesTotal) * self.groupsOfFolds * self.subsetsTheorem2 * self.subsetsTheorem3 * self.subsetsTheorem4
+
+	def __post_init__(self) -> None:
+		"""Ensure all fields have a value."""
+		self.dimensionsTotal = DatatypeLeavesTotal(len(self.mapShape))
+		self.leavesTotal = DatatypeLeavesTotal(getLeavesTotal(self.mapShape))
+		self.columnLast = self.leavesTotal - DatatypeLeavesTotal(1)
+
 @dataclasses.dataclass(slots=True)
 class MapFoldingState:
 	"""Core computational state for map folding algorithms.

mapFolding/someAssemblyRequired/transformationTools.py

@@ -26,7 +26,7 @@ low-level optimized implementations, maintaining code clarity while achieving pe
 through specialized compilation paths essential for computationally intensive map folding research.
 """
 from astToolkit import Be, extractClassDef, identifierDotAttribute, Make, NodeChanger, parseLogicalPath2astModule, Then
-from astToolkit.containers import IngredientsFunction, LedgerOfImports
+from astToolkit.containers import IngredientsFunction
 from astToolkit.transformationTools import unparseFindReplace
 from hunterMakesPy import importLogicalPath2Identifier
 from mapFolding.someAssemblyRequired import DeReConstructField2ast, IfThis, ShatteredDataclass

mapFolding/tests/conftest.py

@@ -242,7 +242,7 @@ def mapShapeTestCountFolds(oeisIDmapFolding: str) -> tuple[int, ...]:
 		n = random.choice(dictionaryOEISMapFolding[oeisIDmapFolding]['valuesTestValidation'])
 		if n < 2:
 			continue
-		listDimensionsCandidate = list(dictionaryOEISMapFolding[oeisIDmapFolding]['getMapShape'](n))
+		listDimensionsCandidate: list[int] = list(dictionaryOEISMapFolding[oeisIDmapFolding]['getMapShape'](n))
 
 		try:
 			return validateListDimensions(listDimensionsCandidate)