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

easyRun/NOTcountingFolds.py

@@ -1,6 +1,6 @@
 # ruff: noqa
 from collections import ChainMap
-from mapFolding import dictionaryOEIS, dictionaryOEISMapFolding
+from mapFolding import ansiColorReset, ansiColors, dictionaryOEIS, dictionaryOEISMapFolding
 from mapFolding.basecamp import NOTcountingFolds
 import sys
 import time
@@ -11,26 +11,33 @@ if __name__ == '__main__':
 	def _write() -> None:
 		sys.stdout.write(
 			f"{(match:=countTotal == dictionaryONE[oeisID]['valuesKnown'][n])}\t"
-			f"\033[{(not match)*91}m"
+			f"{(ansiColors.YellowOnRed, ansiColors.GreenOnBlack)[match]}"
 			f"{n}\t"
 			f"{countTotal}\t"
 			f"{time.perf_counter() - timeStart:.2f}\t"
-			"\033[0m\n"
+			f"{ansiColorReset}\n"
 		)
 
 	CPUlimit: bool | float | int | None = -2
 	flow: str | None = None
 
 	oeisID = 'A007822'
+	oeisID = 'A000136'
 
 	flow = 'algorithm'
-	flow = 'asynchronous'
-	flow = 'theorem2Trimmed'
-	flow = 'theorem2Numba'
 	flow = 'theorem2'
 
-	# for n in range(13,16):
-	for n in range(1,4):
+	sys.stdout.write(f"{ansiColors[int(oeisID,36)%len(ansiColors)]}{oeisID} ")
+	sys.stdout.write(f"{ansiColors[int(flow,36)%len(ansiColors)]}{flow}")
+	sys.stdout.write(ansiColorReset + '\n')
+
+	nList: list[int] = []
+	nList.extend(range(7, 11))
+	# nList.extend(range(9, 13))
+	# nList.extend(range(11, 15))
+	# nList.extend(range(13, 17))
+
+	for n in dict.fromkeys(nList):
 
 		timeStart = time.perf_counter()
 		countTotal = NOTcountingFolds(oeisID, n, flow, CPUlimit)
@@ -38,7 +45,6 @@ if __name__ == '__main__':
 		_write()
 
 r"""
-deactivate && C:\apps\mapFolding\.vtail\Scripts\activate.bat && title good && cls
+
 title running && start "working" /B /HIGH /wait py -X faulthandler=0 -X tracemalloc=0 -X frozen_modules=on easyRun\NOTcountingFolds.py & title I'm done
 """
-

easyRun/__init__.py

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

easyRun/countFolds.py

@@ -1,7 +1,8 @@
 # ruff: noqa
 # pyright: basic
 from collections.abc import Sequence
-from mapFolding import countFolds, dictionaryOEISMapFolding
+from mapFolding import ansiColorReset, ansiColors, dictionaryOEISMapFolding
+from mapFolding.basecamp import countFolds
 from os import PathLike
 from pathlib import PurePath
 import sys
@@ -11,11 +12,12 @@ if __name__ == '__main__':
 	def _write() -> None:
 		sys.stdout.write(
 			f"{(match:=foldsTotal == dictionaryOEISMapFolding[oeisID]['valuesKnown'][n])}\t"
-			f"\033[{(not match)*91}m"
+			f"{(ansiColors.YellowOnRed, ansiColors.GreenOnBlack)[match]}"
 			f"{n}\t"
 			f"{foldsTotal}\t"
+			f"{dictionaryOEISMapFolding[oeisID]['valuesKnown'][n]}\t"
 			f"{time.perf_counter() - timeStart:.2f}\t"
-			"\033[0m\n"
+			f"{ansiColorReset}\n"
 		)
 
 	listDimensions: Sequence[int] | None = None
@@ -23,21 +25,27 @@ if __name__ == '__main__':
 	computationDivisions: int | str | None = None
 	CPUlimit: bool | float | int | None = None
 	# mapShape: tuple[int, ...] | None = None
-	flow = 'daoOfMapFolding'
 	flow = 'numba'
 	flow = 'theorem2'
 	flow = 'theorem2Numba'
-	flow: str | None = 'theorem2Trimmed'
-
+	flow = 'daoOfMapFolding'
 
-	oeisID: str = 'A001415'
+	oeisID: str = 'A195646'
+	oeisID: str = 'A001416'
+	oeisID: str = 'A001418'
+	oeisID: str = 'A001417'
 	oeisID: str = 'A000136'
-	for n in range(1,4):
+	oeisID: str = 'A001415'
+
+	sys.stdout.write(f"{ansiColors[int(oeisID,36)%len(ansiColors)]}{oeisID} ")
+	sys.stdout.write(f"{ansiColors[int(flow,36)%len(ansiColors)]}{flow}")
+	sys.stdout.write(ansiColorReset + '\n')
+
+	for n in range(2):
 
 		mapShape: tuple[int, ...] = dictionaryOEISMapFolding[oeisID]['getMapShape'](n)
 
 		timeStart = time.perf_counter()
-		# foldsTotal: int = countFolds(listDimensions=None, pathLikeWriteFoldsTotal=None, computationDivisions=None, CPUlimit=None, mapShape=(2, 3), flow='theorem2Trimmed')
 		foldsTotal: int = countFolds(listDimensions=listDimensions
 						, pathLikeWriteFoldsTotal=pathLikeWriteFoldsTotal
 						, computationDivisions=computationDivisions

easyRun/meanders.py

@@ -1,26 +1,24 @@
 # ruff: noqa
 # pyright: basic
-from mapFolding import dictionaryOEIS
+from mapFolding import ansiColorReset, ansiColors, dictionaryOEIS
 from mapFolding.basecamp import NOTcountingFolds
 import gc
-import multiprocessing
 import sys
 import time
 import warnings
 
 def write() -> None:
 	sys.stdout.write(
-		f"{(booleanColor:=(countTotal == dictionaryOEIS[oeisID]['valuesKnown'][n]))}\t"
-		f"\033[{(not booleanColor)*91}m"
+		f"{(match:=(countTotal == dictionaryOEIS[oeisID]['valuesKnown'][n]))}\t"
+		f"{(ansiColors.YellowOnRed, ansiColors.GreenOnBlack)[match]}"
 		f"{n}\t"
 		# f"{countTotal}\t"
 		# f"{dictionaryOEISMeanders[oeisID]['valuesKnown'][n]}\t"
 		f"{time.perf_counter() - timeStart:.2f}\t"
-		"\033[0m\n"
+		f"{ansiColorReset}\n"
 	)
 
 if __name__ == '__main__':
-	multiprocessing.set_start_method('spawn')
 	if sys.version_info >= (3, 14):
 		warnings.filterwarnings("ignore", category=FutureWarning)
 
@@ -34,7 +32,7 @@ if __name__ == '__main__':
 				]:
 		sys.stdout.write(f"\n{oeisID}\n")
 
-		"""TODO Identifiers. improve
+		"""# TODO Identifiers. improve
 		"generate up to four targets."
 		1. Adding a new loop.
 		2. Dragging up a loop end.
@@ -63,7 +61,7 @@ if __name__ == '__main__':
 				sys.stdout.write(f"{n} {countTotal} {time.perf_counter() - timeStart:.2f}\n")
 
 r"""
-deactivate && C:\apps\mapFolding\.vtail\Scripts\activate.bat && title good && cls
+
 title running && start "meanders" /B /HIGH /wait py -X faulthandler=0 -X tracemalloc=0 -X frozen_modules=on easyRun\meanders.py && title I'm done || title Error
 
 """

mapFolding/__init__.py

@@ -1,49 +1,38 @@
 """Map folding, meanders, stamp folding, semi-meanders. Experiment with algorithm transformations, and analyze computational states."""
 
+# isort: split
+from mapFolding._semiotics import (
+	ansiColorReset as ansiColorReset, ansiColors as ansiColors, decreasing as decreasing, inclusive as inclusive,
+	zeroIndexed as zeroIndexed)
+
+# isort: split
 from mapFolding._theTypes import (
-	Array1DElephino as Array1DElephino,
-	Array1DFoldsTotal as Array1DFoldsTotal,
-	Array1DLeavesTotal as Array1DLeavesTotal,
-    Array2DLeavesTotal as Array2DLeavesTotal,
-	Array3DLeavesTotal as Array3DLeavesTotal,
-    axisOfLength as axisOfLength,
-	DatatypeElephino as DatatypeElephino,
-	DatatypeFoldsTotal as DatatypeFoldsTotal,
-	DatatypeLeavesTotal as DatatypeLeavesTotal,
-	MetadataOEISid as MetadataOEISid,
-	MetadataOEISidManuallySet as MetadataOEISidManuallySet,
-	MetadataOEISidMapFolding as MetadataOEISidMapFolding,
-	MetadataOEISidMapFoldingManuallySet as MetadataOEISidMapFoldingManuallySet,
-	NumPyElephino as NumPyElephino,
-	NumPyFoldsTotal as NumPyFoldsTotal,
-	NumPyIntegerType as NumPyIntegerType,
-	NumPyLeavesTotal as NumPyLeavesTotal,
-	ShapeArray as ShapeArray,
-	ShapeSlicer as ShapeSlicer)
+	Array1DElephino as Array1DElephino, Array1DFoldsTotal as Array1DFoldsTotal, Array1DLeavesTotal as Array1DLeavesTotal,
+	Array2DLeavesTotal as Array2DLeavesTotal, Array3DLeavesTotal as Array3DLeavesTotal, axisOfLength as axisOfLength,
+	DatatypeElephino as DatatypeElephino, DatatypeFoldsTotal as DatatypeFoldsTotal,
+	DatatypeLeavesTotal as DatatypeLeavesTotal, MetadataOEISid as MetadataOEISid,
+	MetadataOEISidManuallySet as MetadataOEISidManuallySet, MetadataOEISidMapFolding as MetadataOEISidMapFolding,
+	MetadataOEISidMapFoldingManuallySet as MetadataOEISidMapFoldingManuallySet, NumPyElephino as NumPyElephino,
+	NumPyFoldsTotal as NumPyFoldsTotal, NumPyIntegerType as NumPyIntegerType, NumPyLeavesTotal as NumPyLeavesTotal,
+	ShapeArray as ShapeArray, ShapeSlicer as ShapeSlicer)
 
+# isort: split
 from mapFolding._theSSOT import packageSettings as packageSettings
 
+# isort: split
 from mapFolding.beDRY import (
-	getConnectionGraph as getConnectionGraph,
-	getLeavesTotal as getLeavesTotal,
-	getTaskDivisions as getTaskDivisions,
-	makeDataContainer as makeDataContainer,
-	setProcessorLimit as setProcessorLimit,
+	defineProcessorLimit as defineProcessorLimit, getConnectionGraph as getConnectionGraph,
+	getLeavesTotal as getLeavesTotal, getTaskDivisions as getTaskDivisions, makeDataContainer as makeDataContainer,
 	validateListDimensions as validateListDimensions)
 
+# isort: split
 from mapFolding.filesystemToolkit import (
-	getFilenameFoldsTotal as getFilenameFoldsTotal,
-	getPathFilenameFoldsTotal as getPathFilenameFoldsTotal,
-	getPathRootJobDEFAULT as getPathRootJobDEFAULT,
-	saveFoldsTotal as saveFoldsTotal,
+	getFilenameFoldsTotal as getFilenameFoldsTotal, getPathFilenameFoldsTotal as getPathFilenameFoldsTotal,
+	getPathRootJobDEFAULT as getPathRootJobDEFAULT, saveFoldsTotal as saveFoldsTotal,
 	saveFoldsTotalFAILearly as saveFoldsTotalFAILearly)
 
-from mapFolding.basecamp import countFolds as countFolds
-
+# isort: split
 from mapFolding.oeis import (
-	dictionaryOEIS as dictionaryOEIS,
-	dictionaryOEISMapFolding as dictionaryOEISMapFolding,
-	getFoldsTotalKnown as getFoldsTotalKnown,
-	getOEISids as getOEISids,
-	OEIS_for_n as OEIS_for_n,
+	dictionaryOEIS as dictionaryOEIS, dictionaryOEISMapFolding as dictionaryOEISMapFolding,
+	getFoldsTotalKnown as getFoldsTotalKnown, getOEISids as getOEISids, OEIS_for_n as OEIS_for_n,
 	oeisIDfor_n as oeisIDfor_n)

mapFolding/_e/Z0Z_analysisPython/SORTZ0Z_hypothesis.py

@@ -0,0 +1,189 @@
+# ruff: noqa
+from cytoolz.dicttoolz import valfilter
+from functools import cache
+from gmpy2 import bit_flip, bit_mask, bit_test, is_even
+from hunterMakesPy import raiseIfNone
+from mapFolding import decreasing
+from mapFolding._e import dimensionNearestTail, dimensionNearest首, howManyDimensionsHaveOddParity, leafOrigin, 零
+from mapFolding._e.algorithms.iff import getCreasePost, ImaOddLeaf
+from mapFolding._e.dataBaskets import EliminationState
+from math import log2, prod
+from pprint import pprint
+
+def getDictionaryAddends4Next(state: EliminationState) -> dict[int, list[int]]:
+	@cache
+	def workhorse(mapShape: tuple[int, ...], dimensionsTotal: int, leavesTotal: int) -> dict[int, list[int]]:
+		dictionaryAddends: dict[int, list[int]] = {leafOrigin: [1]}
+
+		productsOfDimensions: list[int] = [prod(mapShape[0:dimension], start=1) for dimension in range(dimensionsTotal)]
+
+		for leaf in range(零, leavesTotal):
+			products下_leaf: list[int] = productsOfDimensions.copy()
+
+			theMaskOfDirectionality = bit_mask(leavesTotal - 零) & leaf
+			for index in range(dimensionsTotal):
+				if bit_test(theMaskOfDirectionality, index):
+					products下_leaf[index] *= -1
+
+			slicingIndexStart: int = howManyDimensionsHaveOddParity(leaf) & 1 ^ 1
+			slicingIndexEnd = dimensionNearest首(leaf) * (slicingIndexStart ^ 1) or None
+
+			if (slicingIndexStart == 1) and is_even(leaf):
+				slicingIndexStart += dimensionNearestTail(leaf)
+
+			products下_leaf = products下_leaf[slicingIndexStart:None]
+			products下_leaf = products下_leaf[0:slicingIndexEnd]
+			dictionaryAddends[leaf] = products下_leaf
+
+		return dictionaryAddends
+	return workhorse(state.mapShape, state.dimensionsTotal, state.leavesTotal)
+
+def getDictionaryAddends4Prior(state: EliminationState) -> dict[int, list[int]]:
+	@cache
+	def workhorse(mapShape: tuple[int, ...], dimensionsTotal: int, leavesTotal: int) -> dict[int, list[int]]:
+		dictionaryAddends: dict[int, list[int]] = {leafOrigin: [], 零: [-1]}
+
+		productsOfDimensions: list[int] = [prod(mapShape[0:dimension], start=1) for dimension in range(dimensionsTotal)]
+
+		for leaf in range(leavesTotal + decreasing, 1, decreasing):
+			products下_leaf: list[int] = productsOfDimensions.copy()
+
+			theMaskOfDirectionality = bit_mask(leavesTotal - 零) & leaf
+			for index in range(dimensionsTotal):
+				if bit_test(theMaskOfDirectionality, index):
+					products下_leaf[index] *= -1
+
+			slicingIndexStart: int = howManyDimensionsHaveOddParity(leaf) & 1
+			slicingIndexEnd = dimensionNearest首(leaf) * (slicingIndexStart ^ 1) or None
+
+			if (slicingIndexStart == 1) and is_even(leaf):
+				slicingIndexStart += dimensionNearestTail(leaf)
+
+			products下_leaf = products下_leaf[slicingIndexStart:None]
+			products下_leaf = products下_leaf[0:slicingIndexEnd]
+			dictionaryAddends[leaf] = products下_leaf
+
+		return dictionaryAddends
+	return workhorse(state.mapShape, state.dimensionsTotal, state.leavesTotal)
+
+if __name__ == '__main__':
+	state = EliminationState((2,) * 5)
+
+	dictionaryAddends4Next: dict[int, list[int]] = getDictionaryAddends4Next(state)
+	dictionaryAddends4Prior: dict[int, list[int]] = getDictionaryAddends4Prior(state)
+
+	printThis = False
+
+	for leaf in range(state.leavesTotal):
+		dictionaryNextCreaseLeafV0: dict[int, int | None] = {dimension: getCreasePost(state.mapShape, leaf, dimension) for dimension in range(state.dimensionsTotal)}
+		listAddendLeaves = sorted([leaf + addend for addend in dictionaryAddends4Next[leaf]])
+		if printThis:
+			print(leaf, end='\t')
+			print(leaf)
+		for indexAddend, leafW in enumerate(listAddendLeaves):
+			if leafW > leaf:
+				# NOTE parity of leaf is ALWAYS even on this branch
+				# continue
+				dimension = next(dim for dim, creaseLeaf in dictionaryNextCreaseLeafV0.items() if creaseLeaf == leafW)
+				if printThis:
+					print(ImaOddLeaf(state.mapShape, leaf, dimension), end='\t')
+					print(leafW in dictionaryNextCreaseLeafV0.values(), end='\t')
+					print('\t', indexAddend, leafW, dictionaryNextCreaseLeafV0, len(listAddendLeaves), listAddendLeaves, leafW==dictionaryNextCreaseLeafV0[indexAddend+1 + (state.dimensionsTotal - 1 - len(listAddendLeaves))])
+			else:
+				# NOTE parity of leaf is ALWAYS odd on this branch
+				# holy fuck, I've had all of this data for weeks but didn't realize it was huge.
+				# continue
+				dictionaryNextCreaseLeafW: dict[int, int | None] = {dimension: getCreasePost(state.mapShape, leafW, dimension) for dimension in range(state.dimensionsTotal)}
+				dimension = next(dim for dim, creaseLeaf in dictionaryNextCreaseLeafW.items() if creaseLeaf == leaf)
+				if printThis:
+					print(ImaOddLeaf(state.mapShape, leaf, dimension), end='\t')
+					print(leaf in dictionaryNextCreaseLeafW.values(), end='\t')
+
+		if printThis:
+			print()
+
+	printThis = False
+
+	dictionaryListNextCreaseLeaf: dict[int, list[int | None]] = {leaf: [] for leaf in range(state.leavesTotal)}
+	dictionaryNextCreaseLeaf: dict[int, dict[int, int | None]] = {leaf: {} for leaf in range(state.leavesTotal)}
+	for leaf in range(state.leavesTotal):
+		dictionaryListNextCreaseLeaf[leaf] = list(dictionaryNextCreaseLeaf[leaf].values())
+		dictionaryNextCreaseLeaf[leaf] = {dimension: getCreasePost(state.mapShape, leaf, dimension) for dimension in range(state.dimensionsTotal)}
+		dictionaryNextCreaseLeaf[leaf] = valfilter(bool, dictionaryNextCreaseLeaf[leaf])
+		listLeavesNextAndPriorInSequence = valfilter(lambda flipped: flipped > leaf, {dimension: bit_flip(leaf, dimension) for dimension in range(state.dimensionsTotal)})
+		if printThis:
+			print(leaf, len(dictionaryNextCreaseLeaf[leaf]), dictionaryNextCreaseLeaf[leaf], dictionaryNextCreaseLeaf[leaf] == listLeavesNextAndPriorInSequence, sep='\t')
+
+	printThis = False
+
+	for leaf in range(state.leavesTotal):
+		listAddendLeaves = [leaf + addend for addend in dictionaryAddends4Next[leaf]]
+		listAddendPriorLeaves = [leaf + addend for addend in dictionaryAddends4Prior[leaf]]
+		list1 = list(dict.fromkeys([*listAddendLeaves, *listAddendPriorLeaves]))
+		if len(list1) < state.dimensionsTotal and 0 < leaf:
+			index = int(log2(leaf))
+			list1.insert(index, 0)
+
+		listLeavesNextAndPriorInSequence = [int(bit_flip(leaf, dimension)) for dimension in range(state.dimensionsTotal)]
+
+		if leaf == leafOrigin:
+			listLeavesNext = [1]
+			listLeavesPrior = []
+		else:
+			slicingIndexStart: int = howManyDimensionsHaveOddParity(leaf) & 1 ^ 1
+			slicingIndexEnd = dimensionNearest首(leaf) * (slicingIndexStart ^ 1) or None
+
+			if (slicingIndexStart == 1) and is_even(leaf):
+				slicingIndexStart += dimensionNearestTail(leaf)
+			listLeavesNext = listLeavesNextAndPriorInSequence[slicingIndexStart: slicingIndexEnd]
+
+			slicingIndexStart = howManyDimensionsHaveOddParity(leaf) & 1
+			slicingIndexEnd = dimensionNearest首(leaf) * (slicingIndexStart ^ 1) or None
+
+			if (slicingIndexStart == 1) and is_even(leaf):
+				slicingIndexStart += dimensionNearestTail(leaf)
+			listLeavesPrior = listLeavesNextAndPriorInSequence[slicingIndexStart: slicingIndexEnd]
+
+			if leaf == 1:
+				listLeavesPrior = [0]
+
+		if printThis:
+				print(leaf, listAddendLeaves==listLeavesNext, listAddendPriorLeaves==listLeavesPrior, listLeavesNextAndPriorInSequence, sep='\t', end='\n')
+		else:
+			if printThis:
+				print(leaf, leaf.bit_count() - 1 & 1, dimensionNearestTail(leaf), sep='\t', end='\n')
+				print(leaf, listAddendLeaves, listAddendPriorLeaves, listLeavesNextAndPriorInSequence, sep='\n', end='\n\n')
+				print(leaf, listLeavesNextAndPriorInSequence, sorted(list1) == sorted(listLeavesNextAndPriorInSequence), sep='\t', end='\n')
+				print(leaf, list1, listLeavesNextAndPriorInSequence, sorted(list1), sorted(listLeavesNextAndPriorInSequence), sep='\n', end='\n\n')
+
+	printThis = False
+
+	creasesByDimension: dict[int, list[tuple[int, int]]] = {dimension: [] for dimension in range(state.dimensionsTotal)}
+	for dimension in range(state.dimensionsTotal):
+		for leaf in range(state.leavesTotal):
+			leafW = dictionaryNextCreaseLeaf[leaf].get(dimension)
+			if leafW is not None:
+				creasesByDimension[dimension].append((leaf, leafW))
+	if printThis:
+		pprint(creasesByDimension, width=140, compact=True)
+
+	printThis = False
+
+	for qq, ww in dictionaryListNextCreaseLeaf.items():
+		if printThis:
+			print(qq, *ww, sep='\t')
+
+	printThis = True
+
+	for leaf, dd in dictionaryNextCreaseLeaf.items():
+		tt = True
+		if printThis:
+			print(leaf, len(dd), sep='\t', end='\t')
+		for nn in dd.values():
+			qq = dictionaryNextCreaseLeaf[raiseIfNone(nn)]
+			tt &= len(dd) == 1+ len(qq)
+			if printThis:
+				print(len(qq), end='\t')
+		if printThis:
+			print(bool(tt))
+

mapFolding/_e/Z0Z_analysisPython/SORTZ0Z_p2d6.py

@@ -0,0 +1,143 @@
+# pyright: basic
+# ruff: noqa
+from functools import partial
+from itertools import pairwise, permutations, product as CartesianProduct
+from pathlib import Path
+from pprint import pprint
+from toolz import compose
+import numpy
+import pickle
+
+fileStem = "p2d4"
+pathFilename: Path = Path(f"/apps/mapFolding/Z0Z_notes/{fileStem}.csv")
+
+headerLength = 182
+headerLength = 86
+headerLength = 38
+data2Dn: str = pathFilename.read_text(encoding="utf-8")[headerLength:None]
+
+def parseLineToIntegers(textLine: str) -> list[int]:
+	return [int(numberText) for numberText in textLine.strip().split(",")]
+
+listFoldings2Dn: list[list[int]] = []
+
+for textLine in data2Dn.splitlines():
+	sequenceIntegers = parseLineToIntegers(textLine)
+	listFoldings2Dn.append(sequenceIntegers)
+
+arrayFoldings2Dn = numpy.array(listFoldings2Dn, dtype=numpy.uint8)
+
+pathFilename.with_name(f'listFoldings{fileStem}.pkl').write_bytes(pickle.dumps(listFoldings2Dn))
+pathFilename.with_name(f'arrayFoldings{fileStem}.pkl').write_bytes(pickle.dumps(arrayFoldings2Dn))
+
+dictionaryDifferencesReverse: dict[int, list[int]] = {}
+
+for rowIndex in range(arrayFoldings2Dn.shape[0]):
+	for columnIndex in range(1, arrayFoldings2Dn.shape[1]):
+		valueOriginal = int(arrayFoldings2Dn[rowIndex, columnIndex])
+		valueLeft = int(arrayFoldings2Dn[rowIndex, columnIndex - 1])
+		differenceToLeft = valueLeft - valueOriginal
+
+		if valueOriginal not in dictionaryDifferencesReverse:
+			dictionaryDifferencesReverse[valueOriginal] = []
+
+		if differenceToLeft not in dictionaryDifferencesReverse[valueOriginal]:
+			dictionaryDifferencesReverse[valueOriginal].append(differenceToLeft)
+
+for valueOriginal in dictionaryDifferencesReverse:
+	dictionaryDifferencesReverse[valueOriginal].sort(key=abs)
+
+
+pprint(dictionaryDifferencesReverse)
+
+l5 = listLeft = [8] + [8, 16] + [2]
+r4 = listRight = [8] + [8, 16]
+
+l6 = listLeft = [8] + [8, 16]	# 2,6 is on the list of 3,2.
+# However, to concatenate leafLeft,3,2,6 with 2,6,7,leafRight, leafLeft+4 == leafRight ,1,3,2,6,7,5, ,11,3,2,6,7,15, ,19,3,2,6,7,23, ,35,3,2,6,7,39,
+r7 = listRight = [8] + [8, 16] + [-2]
+#  7: [-2, -4, 8, 16, 32],
+l=6; r=7
+
+l8 = listLeft = [1] + [1, 2]
+r40 = listRight = [1] + [1, 2] + [16]
+
+l16 = listLeft = [1] + [1, 2, 4]
+r48 = listRight = [1] + [1, 2, 4] + [-16] # 48 > 16
+
+l56 = listLeft = [1] + [1, 2] + [-16]
+r24 = listRight = [1] + [1, 2]	#24,16 is on the list of 8,40.
+
+l9 = listLeft = [16] + [16] + [2]
+r8 = listRight = [16] + [16]
+l=9; r=8
+
+l52 = listLeft = [1] + [1] + [-16]
+r20 = listRight = [1] + [1]
+# NOTE appends, below.
+l=52; r=20
+# 16, 21, 22, 28
+# 36, 53, 54, 60
+
+l4 = listLeft = [1] + [1]
+r36 = listRight = [1] + [1] + [16]
+l=4; r=36
+# 37, 38, 32, 44, 52
+# +1, +2, -4, +8, +16
+
+l10 = listLeft = [16] + [16]
+r11 = listRight = [16] + [16] + [-2]
+# NOTE appends, below.
+l=10; r=11
+# 9,  15,  3,  27,  43
+# -2, +4, -8, +16, +32
+
+l3 = listLeft = [4] + [4, 8, 16] + [-2] # 3 > 2
+r2 = listRight = [4] + [4, 8, 16]
+l=3; r=2
+
+ll = []
+for index in range(1, len(listLeft)):
+	ll.append(l + sum(listLeft[0:index]))
+rr = []
+for index in range(1, len(listRight)):
+	rr.append(r + sum(listRight[0:index]))
+
+if l > r:
+	ll.append(l + listLeft[-1])
+	rr.append(r + sum(listRight[0:None]))
+else:
+	ll.append(l + sum(listLeft[0:None]))
+	rr.append(r + listRight[-1])
+
+if (l == 4) and (r == 36):	# NOTE idk.
+	rr.append(44)
+
+if (l == 6) and (r == 7):	# 2,6 is on the list of 3,2.
+	ll.append(2)
+
+if (l == 9) and (r == 8):	# NOTE I can't explain 13. 9+4=13.
+	ll.append(13)
+
+if (l == 10) and (r == 11):	# NOTE similar to 9,8.
+	rr.append(15)			# An additional, stand-alone +4. 11+4=15.
+	ll.append(14)			# An additional, stand-alone +4. 10+4=14.
+	ll.append(2)			# 2,10 is on the list of 3,2.
+
+if (l == 52) and (r == 20):	# 20,16 is on the list of 16,48.
+	rr.append(16)
+	rr.append(28)
+	ll.append(60)
+
+if (l == 56) and (r == 24):	# 24,16 is on the list of 16,48.
+	rr.append(16)
+
+# infix: str = f",{l},{r}"
+# total = 0
+# for left, right in CartesianProduct(ll, rr):
+# 	this: str = f",{left}{infix},{right},"
+# 	count = data2Dn.count(this)
+# 	total += count
+# 	print(f"{count}\t{this}")
+
+# print(total)

mapFolding/_e/Z0Z_analysisPython/__init__.py

@@ -0,0 +1,4 @@
+"""Analysis tools written in Python to help develop the "elimination" algorithms.
+
+These are not intended for long-term use. If a function evolves into something I want to keep, I should find a better home for it.
+"""