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

mapFolding/_e/basecamp.py

@@ -0,0 +1,89 @@
+# ruff: noqa: E701
+from mapFolding import (
+	defineProcessorLimit, getPathFilenameFoldsTotal, packageSettings, saveFoldsTotal, saveFoldsTotalFAILearly)
+from mapFolding._e import mapShapeIs2上nDimensions
+from mapFolding._e.dataBaskets import EliminationState
+from os import PathLike
+from pathlib import Path, PurePath
+
+def eliminateFolds(mapShape: tuple[int, ...] | None = None
+				, state: EliminationState | None = None
+				, 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.
+	"""
+#-------- state ---------------------------------------------------------------------
+	if not state:
+		if not mapShape:
+			message: str = (f"""I received these values:
+	`{mapShape = }` and `{state = }`,
+	but I was unable to select a map of which to count the folds."""
+			)
+			raise ValueError(message)
+		state = EliminationState(mapShape)
+
+#-------- concurrency limit -----------------------------------------------------
+
+	concurrencyLimit: int = defineProcessorLimit(CPUlimit, packageSettings.concurrencyPackage)
+
+#-------- memorialization instructions ---------------------------------------------
+
+	if pathLikeWriteFoldsTotal is not None:
+		pathFilenameFoldsTotal: Path | None = getPathFilenameFoldsTotal(state.mapShape, pathLikeWriteFoldsTotal)
+		saveFoldsTotalFAILearly(pathFilenameFoldsTotal)
+	else:
+		pathFilenameFoldsTotal = None
+
+#-------- Algorithm version -----------------------------------------------------
+	match flow:
+		case 'constraintPropagation': from mapFolding._e.algorithms.constraintPropagation import doTheNeedful  # noqa: PLC0415
+		case 'crease':
+			if mapShapeIs2上nDimensions(state.mapShape, youMustBeDimensionsTallToPinThis=4):
+				from mapFolding._e.algorithms.eliminationCrease import doTheNeedful  # noqa: PLC0415
+			else:
+				message: str = "As of 25 December 2025, this algorithm only works on mapShape = (2,) * n, n >= 4. Did I forget to update this barrier?"
+				raise NotImplementedError(message)
+		case 'elimination' | _: from mapFolding._e.algorithms.elimination import doTheNeedful  # noqa: PLC0415
+
+	state = doTheNeedful(state, concurrencyLimit)
+
+#-------- Follow memorialization instructions ---------------------------------------------
+
+	if pathFilenameFoldsTotal is not None:
+		saveFoldsTotal(pathFilenameFoldsTotal, state.foldsTotal)
+
+	return state.foldsTotal

mapFolding/_e/dataBaskets.py

@@ -0,0 +1,123 @@
+"""Use data baskets to easily move data, including values that affect computations: don't limit yourself to one data basket per algorithm."""
+from mapFolding import getLeavesTotal
+from mapFolding._e import (
+	Folding, getProductsOfDimensions, getSumsOfProductsOfDimensions, getSumsOfProductsOfDimensionsNearest首, Leaf,
+	LeafOrPileRangeOfLeaves, PermutationSpace, Pile)
+from math import prod
+import dataclasses
+
+@dataclasses.dataclass(slots=True)
+class EliminationState:
+	"""Computational state for algorithms that compute `foldsTotal` by elimination.
+
+	This data basket stores both mutable workbench fields (which change during the search) and
+	precomputed constants derived from `mapShape` (which do not change after `__post_init__`).
+
+	Attributes
+	----------
+	mapShape : tuple[int, ...]
+		Dimension lengths of the map being analyzed.
+	groupsOfFolds : int = 0
+		Count of distinct `Folding` pattern groups found so far.
+	listFolding : list[`Folding`]
+		List of `Folding` patterns found.
+	listPermutationSpace : list[`PermutationSpace`]
+		List of exclusive `PermutationSpace` dictionaries.
+	pile : `Pile` = -1
+		The current `pile` on the workbench.
+	permutationSpace : `PermutationSpace`
+		The current `PermutationSpace` dictionary on the workbench.
+	Theorem2Multiplier : int = 1
+		Multiplier applied by Theorem 2 optimizations.
+	Theorem3Multiplier : int = 1
+		Multiplier applied by Theorem 3 optimizations.
+	Theorem4Multiplier : int = 1
+		Multiplier applied by Theorem 4 optimizations.
+	dimensionsTotal : int
+		Unchanging total number of axes in `mapShape`.
+	foldingCheckSum : int
+		Unchanging triangular-number check-sum for a valid `Folding`.
+	leafLast : `Leaf`
+		Unchanging 0-indexed largest `leaf` value.
+	leavesTotal : int
+		Unchanging total number of leaves in the map.
+	pileLast : `Pile`
+		Unchanging 0-indexed largest `pile` value.
+	pilesTotal : int
+		Unchanging total number of piles in the map.
+	productsOfDimensions : tuple[int, ...]
+		Unchanging products of dimension lengths, from the empty product through all dimensions.
+	sumsOfProductsOfDimensions : tuple[int, ...]
+		Unchanging sums of `productsOfDimensions` from the head.
+	sumsOfProductsOfDimensionsNearest首 : tuple[int, ...]
+		Unchanging sums of `productsOfDimensions` from the head `首`.
+	首 : int
+		Unchanging single-base positional-numeral value of the first out-of-bounds Cartesian coordinate.
+
+	Notes
+	-----
+	The computed `foldsTotal` is `groupsOfFolds * leavesTotal * Theorem2Multiplier * Theorem3Multiplier * Theorem4Multiplier`.
+
+	"""
+
+	mapShape: tuple[int, ...] = dataclasses.field(init=True)
+	"""Dimensions of the map being analyzed for folding patterns."""
+
+	groupsOfFolds: int = 0
+	"""`foldsTotal` is divisible by `leavesTotal`; the algorithm counts each `Folding` that represents a group of `leavesTotal`-many foldings."""
+
+	listFolding: list[Folding] = dataclasses.field(default_factory=list[Folding], init=True)
+	"""A list of `Folding` patterns found."""
+	listPermutationSpace: list[PermutationSpace] = dataclasses.field(default_factory=list[PermutationSpace], init=True)
+	"""A list of dictionaries (`{pile: leaf or possible leaves}`) that each define an exclusive permutation space: no overlap between dictionaries."""
+
+	pile: Pile = -1
+	"""The `pile` on the workbench."""
+	permutationSpace: PermutationSpace = dataclasses.field(default_factory=dict[Pile, LeafOrPileRangeOfLeaves], init=True)
+	"""The `permutationSpace` dictionary (`{pile: leaf or possible leaves}`) on the workbench."""
+
+	Theorem2aMultiplier: int = 1
+	Theorem2Multiplier: int = 1
+	Theorem3Multiplier: int = 1
+	Theorem4Multiplier: int = 1
+
+	dimensionsTotal: int = dataclasses.field(init=False)
+	"""Unchanging total number of dimensions in the map."""
+	foldingCheckSum: int = dataclasses.field(init=False)
+	"""Unchanging triangular number check-sum for a valid `Folding`."""
+	leafLast: Leaf = dataclasses.field(init=False)
+	"""Unchanging 0-indexed largest `leaf` in a `Folding`."""
+	leavesTotal: int = dataclasses.field(init=False)
+	"""Unchanging total number of leaves in the map."""
+	pileLast: Pile = dataclasses.field(init=False)
+	"""Unchanging 0-indexed final `pile` in a `Folding`."""
+	pilesTotal: int = dataclasses.field(init=False)
+	"""Unchanging total number of piles in the map."""
+	productsOfDimensions: tuple[int, ...] = dataclasses.field(init=False)
+	"""Unchanging list of products of map dimensions from the product of no dimensions, `[0]`, to the product of all dimensions, `[dimensionsTotal + inclusive]`."""
+	sumsOfProductsOfDimensions: tuple[int, ...] = dataclasses.field(init=False)
+	"""Unchanging list of sums of products of map dimensions from the sum of no products, `[0]`, to the sum of all products, `[len(productsOfDimensions) + inclusive]`."""
+	sumsOfProductsOfDimensionsNearest首: tuple[int, ...] = dataclasses.field(init=False)
+	"""Unchanging list of sums of products of map dimensions starting from the head `首`, from the sum of no products, `[0]`, to the sum of all products, `[len(productsOfDimensions) + inclusive]`."""
+	首: int = dataclasses.field(init=False)
+	"""Unchanging single-base positional-numeral value of the Cartesian coordinates that are the first to be _out-of-bounds_ for the `mapShape`."""
+
+	@property
+	def foldsTotal(self) -> int:
+		"""The computed number of distinct `Folding` patterns for this `mapShape`."""
+		return prod((self.groupsOfFolds, self.Theorem2aMultiplier, self.Theorem2Multiplier, self.Theorem3Multiplier, self.Theorem4Multiplier))
+
+	def __post_init__(self) -> None:
+		"""One-time computation of unchanging values."""
+		self.dimensionsTotal = len(self.mapShape)
+		self.leavesTotal = getLeavesTotal(self.mapShape)
+		if 0 < self.leavesTotal:
+			self.Theorem2aMultiplier = self.leavesTotal
+		self.leafLast = self.leavesTotal - 1
+		self.foldingCheckSum = self.leafLast * self.leavesTotal // 2 # https://en.wikipedia.org/wiki/Triangular_number
+		self.pilesTotal = self.leavesTotal
+		self.pileLast = self.pilesTotal - 1
+		self.首 = self.leavesTotal
+		self.productsOfDimensions = getProductsOfDimensions(self.mapShape)
+		self.sumsOfProductsOfDimensions = getSumsOfProductsOfDimensions(self.mapShape)
+		self.sumsOfProductsOfDimensionsNearest首 = getSumsOfProductsOfDimensionsNearest首(self.productsOfDimensions, self.dimensionsTotal, self.dimensionsTotal)

mapFolding/_e/easyRun/eliminateFolds.py

@@ -0,0 +1,72 @@
+# ruff: noqa
+# pyright: basic
+from functools import partial
+from itertools import filterfalse
+from mapFolding import ansiColorReset, ansiColors, dictionaryOEISMapFolding, packageSettings
+from mapFolding._e import PermutationSpace
+from mapFolding._e.basecamp import eliminateFolds
+from mapFolding._e.dataBaskets import EliminationState
+from mapFolding._e.filters import between, extractPinnedLeaves
+from mapFolding._e.pin2上nDimensions import (
+	pinLeavesDimensions0零一, pinLeavesDimension一, pinLeavesDimension二, pinLeavesDimension首二, pinPilesAtEnds, pinPile零Ante首零)
+from os import PathLike
+from pathlib import Path, PurePath
+from tqdm import tqdm
+import csv
+import sys
+import time
+
+if __name__ == "__main__":
+
+	def _write() -> None:
+		sys.stdout.write(
+			f"{(match := foldsTotal == dictionaryOEISMapFolding[oeisID]['valuesKnown'][n])}\t"
+			f"{(ansiColors.YellowOnRed, ansiColors.GreenOnBlack)[match]}"
+			f"{n}\t"
+			# f"{mapShape}\t"
+			f"{foldsTotal}\t"
+			f"{dictionaryOEISMapFolding[oeisID]['valuesKnown'][n]}\t"
+			f"{time.perf_counter() - timeStart:.2f}\t"
+			f"{ansiColorReset}\n"
+		)
+
+	pathLikeWriteFoldsTotal: PathLike[str] | PurePath | None = None
+	oeisID: str = ""
+	flow: str = ""
+	CPUlimit: bool | float | int | None = -2
+	state: EliminationState | None = None
+
+	flow = "constraintPropagation"
+	flow = "elimination"
+	flow = "crease"
+
+	oeisID: str = "A195646"
+	oeisID: str = "A000136"
+	oeisID: str = "A001416"
+	oeisID: str = "A001418"
+	oeisID: str = "A001415"
+	oeisID: str = "A001417"
+
+	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(6,7):
+		mapShape: tuple[int, ...] = dictionaryOEISMapFolding[oeisID]["getMapShape"](n)
+		if oeisID == "A001417" and n > 3:
+			state = EliminationState(mapShape)
+			# state = pinPilesAtEnds(state, 4)
+			state = pinPile零Ante首零(state)
+			state = pinLeavesDimensions0零一(state)
+			# state = pinLeavesDimension二(state)
+			# state = pinLeavesDimension首二(state)
+
+		timeStart = time.perf_counter()
+		foldsTotal: int = eliminateFolds(mapShape=mapShape, state=state, pathLikeWriteFoldsTotal=pathLikeWriteFoldsTotal, CPUlimit=CPUlimit, flow=flow)
+
+		_write()
+
+r"""
+title running && start "working" /B /HIGH /wait py -X faulthandler=0 -X tracemalloc=0 -X frozen_modules=on mapFolding\_e\easyRun\eliminateFolds.py & title I'm done
+"""
+

mapFolding/_e/easyRun/pinning.py

@@ -0,0 +1,62 @@
+# ruff: noqa: T201, T203, D103, TC003, ERA001  # noqa: RUF100
+# pyright: reportUnusedImport=false
+from collections.abc import Callable, Iterable
+from cytoolz.curried import map as toolz_map
+from cytoolz.functoolz import compose
+from gmpy2 import fac
+from mapFolding._e import (
+	DOTvalues, getDictionaryConditionalLeafPredecessors, getDictionaryLeafDomains, getDictionaryPileRanges, getLeafDomain,
+	getLeavesCreaseAnte, getLeavesCreasePost, getPileRange, PermutationSpace, PileRangeOfLeaves)
+from mapFolding._e.dataBaskets import EliminationState
+from mapFolding._e.filters import extractPilesWithPileRangeOfLeaves
+from mapFolding._e.pin2上nDimensions import (
+	pinLeavesDimensions0零一, pinLeavesDimension二, pinLeavesDimension首二, pinPilesAtEnds, pinPile零Ante首零)
+from mapFolding._e.Z0Z_analysisPython.toolkit import verifyPinning2Dn
+from math import prod
+from pprint import pprint
+import time
+
+def printStatisticsPermutations(state: EliminationState) -> None:
+	def prodOfDOTvalues(listPileRangeOfLeaves: Iterable[PileRangeOfLeaves]) -> int:
+		return prod([pileRangeOfLeaves.bit_count() - 1 for pileRangeOfLeaves in listPileRangeOfLeaves])
+	permutationsPermutationSpaceTotal: Callable[[list[PermutationSpace]], int] = compose(sum, toolz_map(compose(prodOfDOTvalues, DOTvalues, extractPilesWithPileRangeOfLeaves)))
+	print(len(str(mm:=fac(state.leavesTotal))), mm, "Maximum permutations of leaves")
+	print(len(str(rr:=prod(toolz_map(len, filter(None, DOTvalues(getDictionaryPileRanges(state))))))), rr, "dictionaryPileRanges")
+	print(len(str(pp:=permutationsPermutationSpaceTotal(state.listPermutationSpace))), pp, "Pinning these leaves")
+
+if __name__ == '__main__':
+	state = EliminationState((2,) * 6)
+
+	printThis = True
+
+	"""
+	4th order piles and leaves dimensions 0, 零, 一. 2d6.
+	11.42   seconds
+	2688492703286605023848766675550409414155249702868353306025321493319522402099200 permutations
+	len(state.listPermutationSpace)=3205
+	2537 surplus dictionaries: 79%
+	"""
+
+	if printThis:
+		timeStart: float = time.perf_counter()
+		state: EliminationState = pinPile零Ante首零(state)
+		state: EliminationState = pinLeavesDimensions0零一(state)
+		print(f"{time.perf_counter() - timeStart:.2f}\tpinning")
+		verifyPinning2Dn(state)
+		print(f"{time.perf_counter() - timeStart:.2f}\tverifyPinning2Dn")
+		printStatisticsPermutations(state)
+		print(f"{len(state.listPermutationSpace)=}")
+
+	elif printThis:
+		state: EliminationState = pinLeavesDimension首二(state)
+		state: EliminationState = pinPilesAtEnds(state, 4)
+		print(state.sumsOfProductsOfDimensionsNearest首)
+		pprint(dictionaryPileRanges := getDictionaryPileRanges(state), width=200)
+		pprint(dictionaryLeafDomains := getDictionaryLeafDomains(state))
+		pprint(getDictionaryConditionalLeafPredecessors(state), width=260)
+		state: EliminationState = pinLeavesDimension二(state)
+		print(*getLeavesCreasePost(state, 22))
+		print(*getLeavesCreaseAnte(state, 53))
+		print(*(format(x, '06b') for x in getPileRange(state, 60)))
+		print(list(getLeafDomain(state, 37)))
+		pprint(state.listPermutationSpace)