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

mapFolding/_e/Z0Z_analysisPython/toolkit.py

@@ -0,0 +1,166 @@
+from collections.abc import Callable, Sequence
+from cytoolz.dicttoolz import valfilter as leafFilter
+from cytoolz.functoolz import curry as syntacticCurry
+from dataclasses import dataclass
+from mapFolding import ansiColorReset, ansiColors, packageSettings
+from mapFolding._e import DOTvalues, PermutationSpace, 一, 零, 首一, 首零一
+from mapFolding._e._dataDynamic import getDataFrameFoldings
+from mapFolding._e.dataBaskets import EliminationState
+from mapFolding._e.filters import thisIsALeaf
+from pathlib import Path
+from pprint import pformat
+import csv
+import numpy
+import sys
+
+@syntacticCurry
+def beansWithoutCornbread(state: EliminationState, permutationSpace: PermutationSpace) -> bool:
+	return any((beans in DOTvalues(permutationSpace)) ^ (cornbread in DOTvalues(permutationSpace)) for beans, cornbread in ((一+零, 一), (首一(state.dimensionsTotal), 首零一(state.dimensionsTotal))))
+
+@dataclass
+class PermutationSpaceStatus:
+	listSurplusDictionaries: list[PermutationSpace]
+	maskUnion: numpy.ndarray
+	indicesOverlappingRows: numpy.ndarray
+	indicesOverlappingPermutationSpace: set[int]
+	rowsRequired: int
+	rowsTotal: int
+
+def detectPermutationSpaceErrors(arrayFoldings: numpy.ndarray, listPermutationSpace: Sequence[PermutationSpace]) -> PermutationSpaceStatus:
+	rowsTotal: int = int(arrayFoldings.shape[0])
+	listMasks: list[numpy.ndarray] = []
+	listSurplusDictionaries: list[PermutationSpace] = []
+	for permutationSpace in listPermutationSpace:
+		maskMatches: numpy.ndarray = numpy.ones(rowsTotal, dtype=bool)
+		for pile, leaf in leafFilter(thisIsALeaf, permutationSpace).items():
+			maskMatches = maskMatches & (arrayFoldings[:, pile] == leaf)
+		if not bool(maskMatches.any()):
+			listSurplusDictionaries.append(permutationSpace)
+		listMasks.append(maskMatches)
+
+	if listMasks:
+		masksStacked: numpy.ndarray = numpy.column_stack(listMasks)
+	else:
+		masksStacked = numpy.zeros((rowsTotal, 0), dtype=bool)
+
+	coverageCountPerRow: numpy.ndarray = masksStacked.sum(axis=1)
+	maskUnion: numpy.ndarray = coverageCountPerRow > 0
+	rowsRequired: int = int(maskUnion.sum())
+	indicesOverlappingRows: numpy.ndarray = numpy.flatnonzero(coverageCountPerRow >= 2)
+	indicesOverlappingPermutationSpace: set[int] = set()
+	if indicesOverlappingRows.size > 0:
+		for indexMask, mask in enumerate(listMasks):
+			if bool(mask[indicesOverlappingRows].any()):
+				indicesOverlappingPermutationSpace.add(indexMask)
+
+	return PermutationSpaceStatus(listSurplusDictionaries, maskUnion, indicesOverlappingRows, indicesOverlappingPermutationSpace, rowsRequired, rowsTotal)
+
+def verifyPinning2Dn(state: EliminationState) -> None:
+	def getPermutationSpaceWithLeafValuesOnly(permutationSpace: PermutationSpace) -> PermutationSpace:
+		return leafFilter(thisIsALeaf, permutationSpace)
+	arrayFoldings = getDataFrameFoldings(state)
+	if arrayFoldings is not None:
+		arrayFoldings = arrayFoldings.to_numpy(dtype=numpy.uint8, copy=False)
+		pinningCoverage: PermutationSpaceStatus = detectPermutationSpaceErrors(arrayFoldings, state.listPermutationSpace)
+
+		listSurplusDictionariesOriginal: list[PermutationSpace] = pinningCoverage.listSurplusDictionaries
+		listDictionaryPinned: list[PermutationSpace] = [
+			getPermutationSpaceWithLeafValuesOnly(permutationSpace)
+			for permutationSpace in listSurplusDictionariesOriginal
+		]
+		if listDictionaryPinned:
+			sys.stdout.write(ansiColors.YellowOnBlack)
+			sys.stdout.write(pformat(listDictionaryPinned[0:5], width=140) + '\n')
+		else:
+			sys.stdout.write(ansiColors.GreenOnBlack)
+		sys.stdout.write(f"{len(listDictionaryPinned)} surplus dictionaries.\n")
+		sys.stdout.write(ansiColorReset)
+
+		pathFilename = Path(f"{packageSettings.pathPackage}/_e/analysisExcel/p2d{state.dimensionsTotal}SurplusDictionaries.csv")
+
+		if listDictionaryPinned:
+			with pathFilename.open('w', newline='') as writeStream:
+				writerCSV = csv.writer(writeStream)
+				listPiles: list[int] = list(range(state.leavesTotal))
+				writerCSV.writerow(listPiles)
+				for permutationSpace in listDictionaryPinned:
+					writerCSV.writerow([permutationSpace.get(pile, '') for pile in listPiles])
+
+		if pinningCoverage.indicesOverlappingPermutationSpace:
+			sys.stdout.write(f"{ansiColors.RedOnWhite}{len(pinningCoverage.indicesOverlappingPermutationSpace)} overlapping dictionaries{ansiColorReset}\n")
+			for indexDictionary in sorted(pinningCoverage.indicesOverlappingPermutationSpace)[0:2]:
+				sys.stdout.write(pformat(leafFilter(thisIsALeaf, state.listPermutationSpace[indexDictionary]), width=140) + '\n')
+
+		beansOrCornbread: Callable[[PermutationSpace], bool] = beansWithoutCornbread(state)
+		listBeans: list[PermutationSpace] = list(filter(beansOrCornbread, state.listPermutationSpace))
+		if listBeans:
+			sys.stdout.write(f"{ansiColors.MagentaOnBlack}{len(listBeans)} dictionaries with beans but no cornbread.{ansiColorReset}\n")
+			sys.stdout.write(pformat(getPermutationSpaceWithLeafValuesOnly(listBeans[0]), width=140) + '\n')
+
+		maskUnion: numpy.ndarray = pinningCoverage.maskUnion
+		rowsRequired: int = pinningCoverage.rowsRequired
+		rowsTotal: int = pinningCoverage.rowsTotal
+		color = ansiColorReset
+		if rowsRequired < rowsTotal:
+			color = ansiColors.RedOnWhite
+			indicesMissingRows: numpy.ndarray = numpy.flatnonzero(~maskUnion)
+			for indexRow in indicesMissingRows[0:2]:
+				sys.stdout.write(f"{color}{arrayFoldings[indexRow, :]}\n")
+		sys.stdout.write(f"{color}Required rows: {rowsRequired}/{rowsTotal}{ansiColorReset}\n")
+
+def verifyDomainAgainstKnown(domainComputed: Sequence[tuple[int, ...]], domainKnown: Sequence[tuple[int, ...]], *, printResults: bool = True) -> dict[str, list[tuple[int, ...]]]:
+	"""Compare a computed domain against known verification data.
+
+	Parameters
+	----------
+	domainComputed : Sequence[tuple[int, ...]]
+		The domain generated by the function under development.
+	domainKnown : Sequence[tuple[int, ...]]
+		The empirically extracted domain from verification data (e.g., from `makeVerificationDataLeavesDomain`).
+	printResults : bool = True
+		Whether to print the comparison results using pprint.
+
+	Returns
+	-------
+	comparisonResults : dict[str, list[tuple[int, ...]]]
+		Dictionary with keys:
+		- 'missing': tuples in domainKnown but not in domainComputed (the function fails to generate these)
+		- 'surplus': tuples in domainComputed but not in domainKnown (the function generates extra invalid tuples)
+		- 'matched': tuples present in both domains
+
+	"""
+	setComputed: set[tuple[int, ...]] = set(domainComputed)
+	setKnown: set[tuple[int, ...]] = set(domainKnown)
+
+	listMissing: list[tuple[int, ...]] = sorted(setKnown - setComputed)
+	listSurplus: list[tuple[int, ...]] = sorted(setComputed - setKnown)
+	listMatched: list[tuple[int, ...]] = sorted(setComputed & setKnown)
+
+	comparisonResults: dict[str, list[tuple[int, ...]]] = {
+		'missing': listMissing,
+		'surplus': listSurplus,
+		'matched': listMatched,
+	}
+
+	if printResults:
+		countComputed: int = len(setComputed)
+		countKnown: int = len(setKnown)
+		countMissing: int = len(listMissing)
+		countSurplus: int = len(listSurplus)
+		countMatched: int = len(listMatched)
+
+		sys.stdout.write(f"Domain comparison: {countComputed} computed vs {countKnown} known\n")
+		sys.stdout.write(f"  Matched: {countMatched} ({100 * countMatched / countKnown:.1f}% of known)\n")
+
+		if listMissing:
+			sys.stdout.write(f"  Missing ({countMissing} tuples in known but not in computed):\n")
+			sys.stdout.write(pformat(listMissing, width=140, compact=True) + '\n')
+
+		if listSurplus:
+			sys.stdout.write(f"  Surplus ({countSurplus} tuples in computed but not in known):\n")
+			sys.stdout.write(pformat(listSurplus, width=140, compact=True) + '\n')
+
+		if not listMissing and not listSurplus:
+			sys.stdout.write("  Perfect match!\n")
+
+	return comparisonResults

mapFolding/_e/Z0Z_analysisPython/toolkitCSVsequences.py

@@ -0,0 +1,188 @@
+from mapFolding import packageSettings
+from mapFolding._e import getLeavesCreasePost
+from mapFolding._e.dataBaskets import EliminationState
+from pathlib import Path, PurePath
+from typing import TextIO
+
+def subdivideP2d7s0_1_3_2CSVFile(state: EliminationState, pathDataRaw: Path) -> None:
+	pathSorted: Path = pathDataRaw / "sorted"
+	pathSorted.mkdir(exist_ok=True)
+
+	pathFilenameSource: Path = pathDataRaw / "p2d7s0_1_3_2.csv"
+	if pathFilenameSource.exists():
+		setLeavesAllowedAfterTwo: set[int] = set(getLeavesCreasePost(state, 2))
+
+		dictionaryAppendStreams: dict[int, TextIO] = {}
+		try:
+			with pathFilenameSource.open('r', newline='') as readStream:
+				for lineRaw in readStream:
+					line: str = lineRaw.rstrip('\n').rstrip('\r')
+					if len(line) != 401:
+						continue
+					if line.count(',') != 127:
+						continue
+					if not line.startswith("0,1,3,2,"):
+						continue
+					if line[0] == ',' or line[-1] == ',' or ',,' in line:
+						continue
+
+					listPrefixParts: list[str] = line.split(',', 5)
+					if len(listPrefixParts) < 6:
+						continue
+					if not listPrefixParts[4].isdigit():
+						continue
+					leafFifth: int = int(listPrefixParts[4])
+					if leafFifth not in setLeavesAllowedAfterTwo:
+						continue
+
+					appendStream: TextIO | None = dictionaryAppendStreams.get(leafFifth)
+					if appendStream is None:
+						pathFilenameOutput: Path = pathDataRaw / f"p2d7s0_1_3_2_{leafFifth}.csv"
+						appendStream = pathFilenameOutput.open('a', newline='')
+						dictionaryAppendStreams[leafFifth] = appendStream
+
+					appendStream.write(line)
+					appendStream.write('\n')
+
+			pathFilenameDestination: Path = pathSorted / pathFilenameSource.name
+			pathFilenameSource.replace(pathFilenameDestination)
+		finally:
+			for appendStream in dictionaryAppendStreams.values():
+				appendStream.close()
+
+def cleanAndSortSequencesCSVFile(state: EliminationState, pathFilename: PurePath) -> None:
+	pathFilenameTarget: Path = Path(pathFilename)
+	pathSorted: Path = pathFilenameTarget.parent / "sorted"
+	pathSorted.mkdir(exist_ok=True)
+
+	lineHeader: str | None = None
+	tupleHeaderExpected: tuple[int, ...] = tuple(range(state.leavesTotal))
+
+	setSequences: set[tuple[int, ...]] = set()
+	listSequencesUnique: list[tuple[int, ...]] = []
+
+	duplicatesDetected: bool = False
+	invalidLinesDetected: bool = False
+	sortedAlready: bool = True
+	sequencePrior: tuple[int, ...] | None = None
+
+	with pathFilenameTarget.open('r', newline='') as readStream:
+		for indexLine, lineRaw in enumerate(readStream):
+			line: str = lineRaw.rstrip('\n').rstrip('\r')
+			if indexLine == 0 and line.startswith("0,1,2,"):
+				listHeaderParts: list[str] = line.split(',')
+				if len(listHeaderParts) == state.leavesTotal:
+					try:
+						tupleHeaderFound: tuple[int, ...] = tuple(int(part) for part in listHeaderParts)
+					except ValueError:
+						tupleHeaderFound = ()
+					if tupleHeaderFound == tupleHeaderExpected:
+						lineHeader = line
+						continue
+
+			if not line:
+				continue
+			if line[0] == ',' or line[-1] == ',' or ',,' in line:
+				invalidLinesDetected = True
+				continue
+			if line.count(',') != state.leavesTotal - 1:
+				invalidLinesDetected = True
+				continue
+			try:
+				tupleSequence: tuple[int, ...] = tuple(int(part) for part in line.split(','))
+			except ValueError:
+				invalidLinesDetected = True
+				continue
+			if len(tupleSequence) != state.leavesTotal:
+				invalidLinesDetected = True
+				continue
+
+			if sequencePrior is not None and tupleSequence < sequencePrior:
+				sortedAlready = False
+			sequencePrior = tupleSequence
+
+			if tupleSequence in setSequences:
+				duplicatesDetected = True
+				continue
+			setSequences.add(tupleSequence)
+			listSequencesUnique.append(tupleSequence)
+
+	if not (duplicatesDetected or invalidLinesDetected or not sortedAlready):
+		return
+
+	listSequencesSorted: list[tuple[int, ...]] = sorted(listSequencesUnique)
+	pathFilenameBackup: Path = pathSorted / pathFilenameTarget.name
+	pathFilenameTarget.replace(pathFilenameBackup)
+	with pathFilenameTarget.open('w', newline='') as writeStream:
+		if lineHeader is not None:
+			writeStream.write(lineHeader)
+			writeStream.write('\n')
+		for tupleSequence in listSequencesSorted:
+			writeStream.write(','.join(str(value) for value in tupleSequence))
+			writeStream.write('\n')
+
+def sortP2d7GeneratedCSVFiles(state: EliminationState, pathDataRaw: Path) -> None:
+	pathSorted: Path = pathDataRaw / "sorted"
+	pathSorted.mkdir(exist_ok=True)
+
+	setLeavesAllowedAfterOne: set[int] = set(getLeavesCreasePost(state, 1))
+	dictionaryAllowedAfterThird: dict[int, set[int]] = {
+		leafThird: set(getLeavesCreasePost(state, leafThird))
+		for leafThird in setLeavesAllowedAfterOne
+	}
+
+	dictionaryAppendStreams: dict[tuple[int, int], TextIO] = {}
+	try:
+		for pathFilenameSource in sorted(pathDataRaw.glob("p2d7_*.csv")):
+			with pathFilenameSource.open('r', newline='') as readStream:
+				for lineRaw in readStream:
+					line: str = lineRaw.rstrip('\n').rstrip('\r')
+					if len(line) != 401:
+						continue
+					if line.count(',') != 127:
+						continue
+					if not line.startswith("0,1,"):
+						continue
+					if line[0] == ',' or line[-1] == ',' or ',,' in line:
+						continue
+
+					listPrefixParts: list[str] = line.split(',', 4)
+					if len(listPrefixParts) < 5:
+						continue
+					if not listPrefixParts[2].isdigit() or not listPrefixParts[3].isdigit():
+						continue
+					leafThird: int = int(listPrefixParts[2])
+					leafFourth: int = int(listPrefixParts[3])
+					if leafThird not in setLeavesAllowedAfterOne:
+						continue
+					if leafFourth not in dictionaryAllowedAfterThird[leafThird]:
+						continue
+
+					key: tuple[int, int] = (leafThird, leafFourth)
+					appendStream: TextIO | None = dictionaryAppendStreams.get(key)
+					if appendStream is None:
+						pathFilenameOutput: Path = pathDataRaw / f"p2d7s0_1_{leafThird}_{leafFourth}.csv"
+						appendStream = pathFilenameOutput.open('a', newline='')
+						dictionaryAppendStreams[key] = appendStream
+
+					appendStream.write(line)
+					appendStream.write('\n')
+
+			pathFilenameDestination: Path = pathSorted / pathFilenameSource.name
+			pathFilenameSource.replace(pathFilenameDestination)
+	finally:
+		for appendStream in dictionaryAppendStreams.values():
+			appendStream.close()
+
+if __name__ == '__main__':
+	sortEm = True
+	if sortEm:
+		state = EliminationState((2,) * 7)
+		pathDataRaw: Path = packageSettings.pathPackage / "_e" / "dataRaw"
+		sortP2d7GeneratedCSVFiles(state, pathDataRaw)
+		subdivideP2d7s0_1_3_2CSVFile(state, pathDataRaw)
+		for pathFilename in pathDataRaw.glob("p2d7s*.csv"):
+			cleanAndSortSequencesCSVFile(state, pathFilename)
+
+	# type \apps\mapFolding\mapFolding\_e\dataRaw\p2d7s*.csv | find /c /v ""
+	# 521292 of 562368 😢

mapFolding/_e/Z0Z_analysisPython/workBenchPatternFinder.py

@@ -0,0 +1,284 @@
+# ruff: noqa: ERA001 T201 T203  # noqa: RUF100
+from bisect import bisect_left
+from collections.abc import Iterable
+from cytoolz.functoolz import curry as syntacticCurry
+from cytoolz.itertoolz import unique
+from functools import partial
+from gmpy2 import is_even, is_odd
+from hunterMakesPy import raiseIfNone
+from mapFolding import decreasing
+from mapFolding._e import (
+	dimensionNearest首, getDictionaryLeafDomains, getDictionaryPileRanges, getLeavesCreaseAnte, getLeavesCreasePost,
+	getPileRange, getSumsOfProductsOfDimensionsNearest首, Leaf, leafInSubHyperplane, Pile, ptount, 零, 首一, 首二, 首零, 首零一)
+from mapFolding._e._dataDynamic import getDataFrameFoldings
+from mapFolding._e._measure import invertLeafIn2上nDimensions
+from mapFolding._e.dataBaskets import EliminationState
+from math import prod
+from more_itertools import flatten, iter_index
+from operator import add, iadd, isub, mul
+from pprint import pprint
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+	import pandas
+
+def _getGroupedBy(state: EliminationState, pileTarget: Pile, groupByLeavesAtPiles: tuple[Pile, ...]) -> dict[Leaf | tuple[Leaf, ...], list[Leaf]]:
+	dataframeFoldings: pandas.DataFrame = raiseIfNone(getDataFrameFoldings(state))
+	groupedBy: dict[Leaf | tuple[Leaf, ...], list[Leaf]] = dataframeFoldings.groupby(list(groupByLeavesAtPiles))[pileTarget].apply(list).to_dict() # pyright: ignore[reportAssignmentType]
+	return {leaves: sorted(set(listLeaves)) for leaves, listLeaves in groupedBy.items()}
+
+def getExcludedLeaves(state: EliminationState, pileTarget: Pile, groupByLeavesAtPiles: tuple[Pile, ...]) -> dict[Leaf | tuple[Leaf, ...], list[Leaf]]:
+	return {leaves: sorted(set(getDictionaryPileRanges(state)[pileTarget]).difference(set(listLeaves))) for leaves, listLeaves in _getGroupedBy(state, pileTarget, groupByLeavesAtPiles).items()}
+
+if __name__ == '__main__':
+
+	state = EliminationState((2,) * 6)
+	"""
+000011	3
+		5	(5, 6, 10, 18, 34)
+		9	(9, 10, 12, 20, 36)
+001111	15
+		17	17	(17, 18, 20, 24, 40)
+010111	(23, 24, 40)
+011011	(27, 29, 45)
+		33	33	(33, 34, 36, 40)
+
+100111	39		(39, 40)
+101011		43
+			45	(45, 46, 54)
+110011	51
+		53	53	(53, 54, 58)
+		57		(57, 58, 60)
+
+111111	63
+
+even bit count
+0	0	00	11	its creases: crease+1
+0	0	11	11	its creases: crease+1
+0	1	01	11	crease+1
+0	1	10	11	its creases: crease+1
+
+odd bit count
+1	0	01	11	crease+1
+1	0	10	11	its creases: crease+1
+1	1	00	11	its creases: crease+1
+1	1	11	11	n/a
+
+tt = (3, 5, 6, 9, 10, 12, 15, 17, 18, 20, 23, 24, 27, 29, 30, 33, 34, 36, 39, 40, 43, 45, 46, 51, 53, 54, 57, 58, 60, 63)
+pp = (1, 2, 4, 8, 16, 32)
+
+pp63 = (63,)
+pp60 = (60,)
+pp58 = (58, 60)
+pp57 = (57, 58, 60)
+pp54 = (54, 58)
+pp53 = (53, 54, 58)
+pp51 = (51, 53, 57)
+pp46 = (46, 54)
+pp45 = (45, 46, 54)
+pp43 = (43, 45, 53)
+pp40 = (40,)
+pp39 = (39, 40)
+pp36 = (36, 40)
+pp34 = (34, 36, 40)
+pp33 = (33, 34, 36, 40)
+pp30 = (30, 34)
+pp29 = (29, 30, 34)
+pp27 = (27, 29, 45)
+pp24 = (24, 40)
+pp23 = (23, 24, 40)
+pp20 = (20, 24, 40)
+pp18 = (18, 20, 24, 40)
+pp17 = (17, 18, 20, 24, 40)
+pp15 = (15, 17, 33)
+pp12 = (12, 20, 36)
+pp10 = (10, 12, 20, 36)
+pp9  = (9, 10, 12, 20, 36)
+pp6  = (6, 10, 18, 34)
+pp5  = (5, 6, 10, 18, 34)
+pp3  = (3, 5, 9, 17, 33)
+
+	"""
+
+	pile: Pile = 4
+	pileDimension = bisect_left(state.sumsOfProductsOfDimensionsNearest首, pile>>1<<1)
+	leafMinimum = is_even(pile) + state.productsOfDimensions[pileDimension]
+	pileRange: list[Leaf] = []
+
+	# pileRange.append(leafMinimum)
+
+	if is_even(pile):
+		dd = pileDimension
+
+		ss = state.sumsOfProductsOfDimensions[dd]
+		# pileRange.extend(map(partial(iadd, leafMinimum - ss), state.sumsOfProductsOfDimensions[1:dd]))
+		# pileRange.extend(map(partial(iadd, leafMinimum - ss), state.sumsOfProductsOfDimensions[dd + 1: state.dimensionsTotal]))
+
+		if dd < dimensionNearest首(pile):
+			dd += 1
+
+			ss = state.productsOfDimensions[dd]
+			pileRange.extend(map(partial(isub, leafMinimum + ss), state.sumsOfProductsOfDimensions[1:dd]))
+			pileRange.extend(map(partial(iadd, leafMinimum + ss), state.sumsOfProductsOfDimensions[dd + 1: state.dimensionsTotal]))
+
+	if is_odd(pile):
+		dd = pileDimension
+
+		ss = state.sumsOfProductsOfDimensions[dd]
+		pileRange.extend(map(partial(iadd, leafMinimum + ss), state.productsOfDimensions[1:dd]))
+		pileRange.extend(map(partial(iadd, leafMinimum + ss), state.productsOfDimensions[dd + 1: state.dimensionsTotal]))
+
+		dd += 1
+
+		ss = state.sumsOfProductsOfDimensions[dd]
+		pileRange.extend(map(partial(iadd, leafMinimum + ss), state.productsOfDimensions[1:dd]))
+		pileRange.extend(map(partial(iadd, leafMinimum + ss), state.productsOfDimensions[dd + 1: state.dimensionsTotal]))
+
+		dd += 1
+
+		ss = state.sumsOfProductsOfDimensions[dd]
+		pileRange.extend(map(partial(iadd, leafMinimum + ss), state.productsOfDimensions[1:dd]))
+		pileRange.extend(map(partial(iadd, leafMinimum + ss), state.productsOfDimensions[dd + 1: state.dimensionsTotal]))
+
+		dd += 1
+
+		ss = state.sumsOfProductsOfDimensions[dd]
+		pileRange.extend(map(partial(iadd, leafMinimum + ss), state.productsOfDimensions[1:dd]))
+		pileRange.extend(map(partial(iadd, leafMinimum + ss), state.productsOfDimensions[dd + 1: state.dimensionsTotal]))
+
+	print(pile, pileDimension)
+	print(sorted(set(pileRange)))
+	rr = tuple(getPileRange(state, pile))
+	print(rr)
+	rrLess1 = tuple(getPileRange(state, pile - 1))
+	print(rrLess1)
+
+	"""Notes
+	33 has step = 4
+	"""
+
+	leafExcluderStuff = False
+	if leafExcluderStuff:
+		pileExcluder = 60
+		pileTarget=31
+		dictionaryExcluded = getExcludedLeaves(state, pileTarget, groupByLeavesAtPiles=(pileExcluder,))
+		domains = getDictionaryLeafDomains(state)
+		pileRange31 = frozenset(getPileRange(state, 31))
+
+		for pile in range(state.leavesTotal):
+			continue
+			print(pile, set(getPileRange(state, pile)).difference(getExcludedLeaves(state, pileTarget, groupByLeavesAtPiles=(pile,)).keys()))
+
+		for excluder, listExcluded in dictionaryExcluded.items():
+			continue
+
+			invert = int(excluder^63) # pyright: ignore[reportUnknownArgumentType, reportOperatorIssue]
+			creasePostSS = tuple(getLeavesCreasePost(state, invert)) # pyright: ignore[reportArgumentType]
+			allCreasePostSSInRange = set(creasePostSS).intersection(pileRange31)
+			creaseAnte = tuple(getLeavesCreaseAnte(state, excluder)) # pyright: ignore[reportArgumentType]
+			creasePost = tuple(getLeavesCreasePost(state, excluder)) # pyright: ignore[reportArgumentType]
+			allCreaseAnteInRange = set(creaseAnte).intersection(pileRange31)
+			allCreasePostInRange = set(creasePost).intersection(pileRange31)
+			notExcluded = allCreasePostInRange.difference(listExcluded)
+			# print(excluder, invert, allCreasePostSSInRange.intersection(listExcluded), notExcluded, allCreasePostSSInRange.difference(listExcluded), set(creasePostSS).symmetric_difference(creasePost), creasePostSS, allCreasePostSSInRange)
+			# print(excluder.__format__('06b'), excluder, f"{notExcluded}\t", f"{creasePost}", sep='\t')
+			print(excluder, f"{allCreaseAnteInRange=}", f"{allCreasePostInRange=}", sep='\t')
+			print(excluder, f"{allCreaseAnteInRange.difference(listExcluded)}", f"{allCreasePostInRange.difference(listExcluded)}", sep='\t')
+
+	pileRangeByFormula: bool = False
+	if pileRangeByFormula:
+		state = EliminationState((2,) * 6)
+
+		# NOTE works for 9 <= odd piles <= 47
+		# I _think_ I need to be able to pass start/stop to intraDimensionalLeaves
+		# Yes, sort of. `Z0Z_alphaBeta` and `intraDimensionalLeaves` need to be the same function: and I need to be able to tweak all of the parameters.
+
+		@syntacticCurry
+		def intraDimensionalLeaves(state: EliminationState, dimensionOrigin: int) -> list[int]:
+			return list(map(partial(add, dimensionOrigin+2), state.sumsOfProductsOfDimensions[1: dimensionNearest首(dimensionOrigin)]))
+
+		@syntacticCurry
+		def Z0Z_alphaBeta(state: EliminationState, alphaStart: int = 0, betaStop: int = 0, charlieStep: int = 1) -> list[int]:
+			return list(flatten(map(intraDimensionalLeaves(state), state.productsOfDimensions[2 + alphaStart: (state.dimensionsTotal - 1) + betaStop: charlieStep])))
+
+		def Z0Z_getPileRange(state: EliminationState, pile: Pile) -> Iterable[Leaf]:
+			pileRange: list[Leaf] = []
+
+			# odd leaves < 32.
+			# ? 12 < even leaves < 32.
+			# ? 24 < even leaves < 32.
+			# piles 49, 51, 53, 55 need a higher start on yy=0.
+			for yy in range(3):
+				pileRange.extend(map(partial(mul, state.productsOfDimensions[yy]), Z0Z_alphaBeta(state, betaStop=-(yy))))
+
+			# 32 < even leaves
+			for yy in range(1):
+				pileRange.extend(map(partial(invertLeafIn2上nDimensions, state.dimensionsTotal), map(partial(mul, state.productsOfDimensions[yy])
+					, Z0Z_alphaBeta(state
+						, alphaStart=yy+(state.dimensionsTotal - 2 - dimensionNearest首(pile))
+						, betaStop=-(yy)
+					))))
+			# ? 32 < odd leaves < 52
+			# ? 32 < odd leaves < 36
+			for yy in range(1,3):
+				pileRange.extend(map(partial(invertLeafIn2上nDimensions, state.dimensionsTotal), map(partial(mul, state.productsOfDimensions[yy]), Z0Z_alphaBeta(state, betaStop=-(yy)))))
+
+			# dimension origins
+			# piles 51, 53, 55 need a higher start.
+			pileRange.extend(state.productsOfDimensions[1 + ((零)+首零(state.dimensionsTotal) < pile):dimensionNearest首(pile+1)])
+			# inverse dimension origins: 62, 61, 59, 55, 47, 31
+			# pile5 needs a higher start.
+			pileRange.extend(map(partial(invertLeafIn2上nDimensions, state.dimensionsTotal), state.productsOfDimensions[0:state.dimensionsTotal]))
+
+			return tuple(sorted(pileRange))
+
+		def Z0Z_getPileRangeEven(state: EliminationState, pile: Pile) -> Iterable[Leaf]:
+			pileRange: list[Leaf] = []
+
+			for yy in range(3):
+				pileRange.extend(map(
+					partial(add, 1)
+					, (map(
+						partial(mul, state.productsOfDimensions[yy])
+						, Z0Z_alphaBeta(state, alphaStart = 0, betaStop=-(yy))
+				)
+			)
+		)
+	)
+
+			# for yy in range(1):
+			# 	pileRange.extend(map(partial(Z0Z_invert, state.dimensionsTotal), map(partial(mul, state.productsOfDimensions[yy])
+			# 		, Z0Z_alphaBeta(state
+			# 			, alphaStart=yy+(state.dimensionsTotal - 2 - dimensionNearest首(pile))
+			# 			, betaStop=-(yy)
+			# 		))))
+			# for yy in range(1,3):
+			# 	pileRange.extend(map(partial(Z0Z_invert, state.dimensionsTotal), map(partial(mul, state.productsOfDimensions[yy]), Z0Z_alphaBeta(state, betaStop=-(yy)))))
+
+			# dimension origins
+			pileRange.extend(map(partial(add, 1), state.productsOfDimensions[1 + ((零)+首零(state.dimensionsTotal) < pile):dimensionNearest首(pile+1)]))
+			# inverse dimension origins: 62, 61, 59, 55, 47, 31
+			pileRange.extend(map(partial(invertLeafIn2上nDimensions, state.dimensionsTotal), map(partial(add, 1), state.productsOfDimensions[1:state.dimensionsTotal])))
+
+			return tuple(sorted(pileRange))
+
+		for pile in range(首一(state.dimensionsTotal), 首零一(state.dimensionsTotal), 2):
+			print(pile, (real:=tuple(getPileRange(state, pile))) == (computed:=Z0Z_getPileRangeEven(state, pile)), end=': ')
+			# print(f"{ansiColors.Green}surplus: {set(computed).difference(real)}", f"{ansiColors.Magenta}missing: {set(real).difference(computed)}{ansiColorReset}", sep='\n')
+			pprint(f"{computed=}", width=180)
+
+		for pile in range((零)+首二(state.dimensionsTotal), 首零一(state.dimensionsTotal), 2):
+			print(pile, (real:=tuple(getPileRange(state, pile))) == (computed:=Z0Z_getPileRange(state, pile)), end=': ')
+			# print(f"surplus: {set(computed).difference(real)}", f"missing: {set(real).difference(computed)}", sep='\n')
+			pprint(f"{computed=}", width=180)
+
+			# > 32: matches most tail0s != 1
+			# if pile > 32:
+			# 	pile-=1
+			# else:
+			# 	pile+=1
+			# zz = tuple(map(partial(xor, 1), zz))
+			# print(pile, (ll:=getPileRange(state, pile)) == (zz), end=': ')
+			# # print(set(zz).difference(ll), set(ll).difference(zz), sep='\t')
+			# pprint(zz, width=180)
+