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

mapFolding/algorithms/patternFinder.py

@@ -1,280 +0,0 @@
-# ruff: noqa: ERA001 T201 T203
-from collections.abc import Callable
-from cytoolz.functoolz import curry as syntacticCurry
-from hunterMakesPy import raiseIfNone
-from itertools import repeat
-from mapFolding.dataBaskets import EliminationState
-from math import prod
-from pathlib import Path
-from pprint import pprint
-import gmpy2
-import pandas
-
-def ptount(integerAbove3:int, /) -> int:
-	"""After subtracting 0b000011 from `zz`, measure the distance from a ***p***ower of ***t***wo's bit c***ount***.
-
-	Notes
-	-----
-	- Pronounced "tount" because the "p" is silent.
-	- Just like the "p", the reason why this is useful is also silent.
-	- I suspect there is a more direct route to measure this but I am unaware of it.
-	"""
-	return distanceFromPowerOf2(integerAbove3 - 0b000011).bit_count()
-
-def bitBiggest(integerAbove0: int, /) -> int:
-	"""Find the 0-indexed position of the biggest set bit in `integerAbove0`."""
-	return integerAbove0.bit_length() - 1
-
-def bitSecond(integerAbove0: int, /) -> int | None:
-	"""Find the 0-indexed position of the second biggest set bit, if any, in `integerAbove0`."""
-	second = bitBiggest(int(gmpy2.bit_flip(integerAbove0, bitBiggest(integerAbove0))))
-	return second if second >= 0 else None
-
-def distanceFromPowerOf2(integerAbove0: int, /) -> int:
-	return int(gmpy2.f_mod_2exp(integerAbove0, integerAbove0.bit_length() - 1))
-
-def multiplicityOfPrimeFactor2(integerAbove0: int, /) -> int:
-	"""Compute the number of times `integerAbove0` is divisible by 2; aka 'CTZ', Count Trailing Zeros in the binary form."""
-	return raiseIfNone(gmpy2.bit_scan1(integerAbove0))
-
-@syntacticCurry
-def numeralOfLengthInBase(mostSignificantDigits: int | list[int], fillerDigits: str = '0', leastSignificantDigits: int | list[int] = 0, positions: int = 8, base: int = 2) -> int:
-	"""Prototype."""
-	digitsPrefix: tuple[int, ...] = (mostSignificantDigits,) if isinstance(mostSignificantDigits, int) else tuple(mostSignificantDigits)
-	quantityPrefix: int = len(digitsPrefix)
-
-	digitsSuffix: tuple[int, ...] = (leastSignificantDigits,) if isinstance(leastSignificantDigits, int) else tuple(leastSignificantDigits)
-	quantitySuffix: int = len(digitsSuffix)
-
-	quantityFiller: int = positions - quantityPrefix - quantitySuffix
-	digitsFiller: tuple[int, ...] = tuple(int(digit) for digit in list(repeat(fillerDigits, quantityFiller))[0:quantityFiller])
-
-	tupleDigitsMSBtoLSB: tuple[int, ...] = (*digitsPrefix, *digitsFiller, *digitsSuffix)
-	digitsAsString: str = ''.join(str(digit) for digit in tupleDigitsMSBtoLSB)
-
-	numeralAs_int: int = int(digitsAsString, base)
-
-	return numeralAs_int
-
-@syntacticCurry
-def makeFillerDigitsNotation(numeral: int, positions: int = 8, base: int = 2) -> tuple[list[int], str, int | list[int]]:
-	"""Represent `numeral` as prefix, filler digit, and suffix for reuse with `numeralOfLengthInBase`.
-
-	(AI generated docstring)
-
-	This prototype only supports base 2 and expects a non-negative numeral whose binary expansion
-	fits inside the specified number of positions. The returned structure abstracts the repeated
-	interior digits so that different position counts share the same notation.
-	"""
-	if positions <= 0:
-		message: str = f'positions must be positive; received {positions}.'
-		raise ValueError(message)
-	if base != 2:
-		message: str = f'makeFillerDigitsNotation currently supports base 2 only; received base {base}.'
-		raise ValueError(message)
-	if numeral < 0:
-		message: str = f'numeral must be non-negative; received {numeral}.'
-		raise ValueError(message)
-
-	digitsAsString: str = f'{numeral:b}'
-	if len(digitsAsString) > positions:
-		message: str = f'numeral {numeral} requires {len(digitsAsString)} positions; received {positions}.'
-		raise ValueError(message)
-	digitsAsString = digitsAsString.zfill(positions)
-
-	lengthPrefix: int | None = None
-	lengthSuffix: int | None = None
-	lengthFiller: int = -1
-	fillerDigit: str = '0'
-
-	for prefixLength in range(1, positions):
-		for suffixLength in range(1, positions - prefixLength + 1):
-			fillerLength: int = positions - prefixLength - suffixLength
-			if fillerLength < 0:
-				continue
-
-			if fillerLength == 0:
-				candidateFillerDigit: str = digitsAsString[prefixLength - 1]
-			else:
-				candidateFillerDigit = digitsAsString[prefixLength]
-				segmentFiller: str = digitsAsString[prefixLength:prefixLength + fillerLength]
-				if segmentFiller != candidateFillerDigit * fillerLength:
-					continue
-
-			if ((lengthPrefix is None)
-				or (fillerLength > lengthFiller)
-				or ((fillerLength == lengthFiller) and (
-												(prefixLength < lengthPrefix)
-												or ((prefixLength == lengthPrefix) and (suffixLength < lengthSuffix if lengthSuffix is not None else True))))):
-				lengthPrefix = prefixLength
-				lengthSuffix = suffixLength
-				lengthFiller = fillerLength
-				fillerDigit = candidateFillerDigit
-
-	if lengthPrefix is None or lengthSuffix is None:
-		lengthPrefix = positions if positions > 0 else 1
-		lengthSuffix = max(0, positions - lengthPrefix)
-		lengthFiller = 0
-		fillerDigit = digitsAsString[lengthPrefix - 1] if positions > 0 else '0'
-
-	mostSignificantDigits: list[int] = [int(digit) for digit in digitsAsString[0:lengthPrefix]]
-	leastSignificantDigitsSequence: list[int] = [int(digit) for digit in digitsAsString[positions - lengthSuffix:]] if lengthSuffix > 0 else []
-	leastSignificantDigits: int | list[int]
-	if lengthSuffix == 1:
-		leastSignificantDigits = leastSignificantDigitsSequence[0]
-	else:
-		leastSignificantDigits = leastSignificantDigitsSequence
-
-	notation: tuple[list[int], str, int | list[int]] = (mostSignificantDigits, fillerDigit, leastSignificantDigits)
-	return notation
-
-def getDictionaryAddends4Next(state: EliminationState) -> dict[int, list[int]]:
-	dictionaryAddends: dict[int, list[int]] = {}
-
-	indexLeaf: int = 0
-	listOfDifferences: list[int] = [1]
-	dictionaryAddends[indexLeaf] = listOfDifferences
-
-	productsOfDimensions: list[int] = [prod(state.mapShape[0:dimension], start=1) for dimension in range(state.dimensionsTotal)]
-
-	for indexLeaf in range(1, state.leavesTotal):
-		products下_indexLeaf: list[int] = productsOfDimensions.copy()
-
-		theMaskOfDirectionality = gmpy2.bit_mask(state.leavesTotal - 1) & indexLeaf
-		for index in range(state.dimensionsTotal):
-			if gmpy2.bit_test(theMaskOfDirectionality, index):
-				products下_indexLeaf[index] *= -1
-
-		slicingIndexStart: int = (indexLeaf.bit_count() - 1) & 1 ^ 1
-		slicingIndexEnd = (indexLeaf.bit_length() - 1) * (slicingIndexStart ^ 1) or None
-
-		if (slicingIndexStart == 1) and (gmpy2.is_even(indexLeaf)):
-			slicingIndexStart += multiplicityOfPrimeFactor2(indexLeaf)
-
-		products下_indexLeaf = products下_indexLeaf[slicingIndexStart:None]
-		products下_indexLeaf = products下_indexLeaf[0:slicingIndexEnd]
-		dictionaryAddends[indexLeaf] = products下_indexLeaf
-
-	return dictionaryAddends
-
-def getDictionaryAddends4Prior(state: EliminationState) -> dict[int, list[int]]:
-	dictionaryAddends: dict[int, list[int]] = {}
-
-	indexLeaf: int = 0
-	listOfDifferences: list[int] = []
-	dictionaryAddends[indexLeaf] = listOfDifferences
-
-	indexLeaf = 1
-	listOfDifferences = [-1]
-	dictionaryAddends[indexLeaf] = listOfDifferences
-
-	productsOfDimensions: list[int] = [prod(state.mapShape[0:dimension], start=1) for dimension in range(state.dimensionsTotal)]
-
-	for indexLeaf in range(state.leavesTotal - 1, 1, -1):
-		products下_indexLeaf: list[int] = productsOfDimensions.copy()
-
-		theMaskOfDirectionality = gmpy2.bit_mask(state.leavesTotal - 1) & indexLeaf
-		for index in range(state.dimensionsTotal):
-			if gmpy2.bit_test(theMaskOfDirectionality, index):
-				products下_indexLeaf[index] *= -1
-
-		slicingIndexStart: int = (indexLeaf.bit_count() - 1) & 1
-		slicingIndexEnd = (indexLeaf.bit_length() - 1) * (slicingIndexStart ^ 1) or None
-
-		if (slicingIndexStart == 1) and (gmpy2.is_even(indexLeaf)):
-			slicingIndexStart += multiplicityOfPrimeFactor2(indexLeaf)
-
-		products下_indexLeaf = products下_indexLeaf[slicingIndexStart:None]
-		products下_indexLeaf = products下_indexLeaf[0:slicingIndexEnd]
-		dictionaryAddends[indexLeaf] = products下_indexLeaf
-
-	return dictionaryAddends
-
-def getIndexLeafRange(state: EliminationState, indexLeaf: int) -> range:
-	return range(indexLeaf.bit_count() + (2**(multiplicityOfPrimeFactor2(indexLeaf) + 1) - 2)
-				, state.leavesTotal - (2**(state.dimensionsTotal - indexLeaf.bit_length() + 1) - 2) - (indexLeaf.bit_count() - 1)
-				, 2)
-
-def getDictionaryIndexLeafRanges(state: EliminationState) -> dict[int, range]:
-	"""For each `indexLeaf` (not `leaf`), the associated `range` defines
-	1. every `pile` at which `indexLeaf` may be found in a `folding` and
-	2. in the set of all valid foldings, every `pile` at which `indexLeaf` must be found.
-	"""  # noqa: D205
-	dictionaryIndexLeafRanges: dict[int, range] = {indexLeaf: getIndexLeafRange(state, indexLeaf) for indexLeaf in range(1, state.leavesTotal)}
-
-	indexLeaf: int = 0
-	dictionaryIndexLeafRanges[indexLeaf] = range(0, 1, 2)
-
-	indexLeaf = state.leavesTotal // 2 + 1
-	step = 4
-	rangeIndexLeaf: range = dictionaryIndexLeafRanges[indexLeaf]
-	dictionaryIndexLeafRanges[indexLeaf] = range(rangeIndexLeaf.start, rangeIndexLeaf.stop, step)
-
-	return dictionaryIndexLeafRanges
-
-# TODO
-def getDictionaryPileToLeavesByFormula(state: EliminationState) -> dict[int, list[int]]:
-	dictionaryPileToLeaves: dict[int, list[int]] = {pile: [] for pile in range(state.leavesTotal)}
-
-	return dictionaryPileToLeaves
-
-def getDictionaryPileToLeaves(state: EliminationState) -> dict[int, list[int]]:
-	dictionaryPileToLeaves: dict[int, list[int]] = {pile: [] for pile in range(state.leavesTotal)}
-
-	dictionaryLeafRanges: dict[int, range] = getDictionaryIndexLeafRanges(state)
-
-	for indexLeaf, rangePilings in dictionaryLeafRanges.items():
-		for pile in rangePilings:
-			dictionaryPileToLeaves[pile].append(indexLeaf)
-
-	return dictionaryPileToLeaves
-
-def _getGroupedBy(state: EliminationState, pileTarget: int, groupByIndexLeavesAtPiles: tuple[int, ...]) -> dict[int | tuple[int, ...], list[int]]:
-	pathFilename = Path(f'/apps/mapFolding/Z0Z_notes/arrayFoldingsP2d{state.dimensionsTotal}.pkl')
-	arrayFoldings = pandas.read_pickle(pathFilename)  # noqa: S301
-	dataframeFoldings = pandas.DataFrame(arrayFoldings)
-
-	groupedBy: dict[int | tuple[int, ...], list[int]] = dataframeFoldings.groupby(list(groupByIndexLeavesAtPiles))[pileTarget].apply(list).to_dict()
-	return {indexLeaves: sorted(set(listLeaves)) for indexLeaves, listLeaves in groupedBy.items()}
-
-def getExcludedAddendIndices(state: EliminationState, indexLeafAddend: int, pileTarget: int, groupByIndexLeavesAtPiles: tuple[int, ...]) -> dict[int | tuple[int, ...], list[int]]:
-	groupedBy: dict[int | tuple[int, ...], list[int]] = _getGroupedBy(state, pileTarget, groupByIndexLeavesAtPiles)
-
-	dictionaryExclusion: dict[int | tuple[int, ...], list[int]] = {}
-	listAddends: list[int] = getDictionaryAddends4Next(state)[indexLeafAddend]
-
-	for groupByIndexLeaves, listIndexLeavesIncludedAtPile in groupedBy.items():
-		listAddendIndicesIncluded: list[int] = [addendIndex for addendIndex, addend in enumerate(listAddends) if indexLeafAddend + addend in listIndexLeavesIncludedAtPile]
-		listAddendIndicesExcluded: list[int] = sorted(set(range(len(listAddends))).difference(set(listAddendIndicesIncluded)))
-		dictionaryExclusion[groupByIndexLeaves] = listAddendIndicesExcluded
-
-	return dictionaryExclusion
-
-def getExcludedIndexLeaves(state: EliminationState, pileTarget: int, groupByIndexLeavesAtPiles: tuple[int, ...]) -> dict[int | tuple[int, ...], list[int]]:
-	return {indexLeaves: sorted(set(getDictionaryPileToLeaves(state)[pileTarget]).difference(set(listLeaves))) for indexLeaves, listLeaves in _getGroupedBy(state, pileTarget, groupByIndexLeavesAtPiles).items()}
-
-if __name__ == '__main__':
-	from mapFolding.tests.verify import (
-		verifyDictionaryAddends4Next, verifyDictionaryAddends4Prior, verifyDictionaryLeafRanges)
-
-	state = EliminationState((2,) * 6)
-	dictionaryLeafRanges = getDictionaryIndexLeafRanges(state)
-	# verifyDictionaryLeafRanges(state, dictionaryLeafRanges)
-	dictionaryAddends4Next = getDictionaryAddends4Next(state)
-	# verifyDictionaryAddends4Next(state, dictionaryAddends4Next)
-	dictionaryAddends4Prior = getDictionaryAddends4Prior(state)
-	verifyDictionaryAddends4Prior(state, dictionaryAddends4Prior)
-
-	# dictionaryPileToLeaves = getDictionaryPileToLeaves(state)
-	colorReset = '\33[0m'
-	color = '\33[91m'
-
-	# print(dictionaryPileToLeaves[31])
-
-	# for indexLeaf in [*dictionaryPileToLeaves[31]]:
-	# 	print(f"{indexLeaf:2}: {distanceFromPowerOf2(indexLeaf - 0b000011).bit_count()} ", end='')
-	# 	for d in range(state.dimensionsTotal - 1, -1, -1):
-	# 		bit = gmpy2.bit_test(indexLeaf, d)
-	# 		print(f'\33[{3+(d&0)}{int(bit+3)}m', "█▊", colorReset, sep='', end='')
-	# 	print()
-

mapFolding/algorithms/pinning2Dn.py

@@ -1,345 +0,0 @@
-# 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

@@ -1,43 +0,0 @@
-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