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

mapFolding/_e/_semiotics.py

@@ -0,0 +1,363 @@
+from functools import cache
+from hunterMakesPy.parseParameters import intInnit
+from mapFolding._e import DimensionIndex
+from math import log
+from operator import getitem
+
+#======== Using a single-base positional-numeral system as a proxy for Cartesian coordinates =======
+# https://en.wikipedia.org/wiki/Positional_notation
+
+# Ideogram pronunciation references:
+# https://en.wikipedia.org/wiki/Chinese_numerals
+# https://en.wikipedia.org/wiki/Japanese_numerals
+# https://en.wikipedia.org/wiki/Korean_numerals
+# https://en.wikipedia.org/wiki/Vietnamese_numerals
+
+"""NOTE Do you hate my system of ideographs for powers of 2?
+
+With relatively little effort you could use `astToolkit` (pip install astToolkit) to replace all of the ideographs with
+`state.productsOfDimensions[dimensionIndex]`. With `astToolkit`, you create a transformation that you can apply after any update.
+"""
+
+_dimensionLength: int	= 2 # Hypothetically, change to 3 for 3^d-dimensional maps.
+_dimensionIndex: DimensionIndex = 0						# == 0
+
+零: int = _dimensionLength ** _dimensionIndex
+"""dimensionIndex = 0: assign `1` to `dimensionIndex = 0`, and assign `0` to each other `DimensionIndex`. Read as (any of):
+- index zero
+- líng
+- ling4
+- rei
+- yeong
+- linh
+"""
+
+# 一
+_base: int				= _dimensionLength
+_dimensionIndex			+= 1					# == 1
+_power: int				= _dimensionIndex
+一: int = _base ** _power						# == _dimensionLength ** _dimensionIndex
+"""dimensionIndex = 1: assign `1` to `dimensionIndex = 1`, and assign `0` to each other `DimensionIndex`. Read as (any of):
+- index one
+- yī
+- jat1
+- ichi
+- il
+- nhất
+"""
+
+# 二
+_radix: int				= _dimensionLength
+_dimensionIndex			+= 1					# == 2
+_place_ValueIndex: int	= _dimensionIndex
+二: int = _radix ** _place_ValueIndex			# == _dimensionLength ** _dimensionIndex
+"""dimensionIndex = 2: assign `1` to `dimensionIndex = 2`, and assign `0` to each other `DimensionIndex`. Read as (any of):
+- index two
+- èr
+- ji6
+- ni
+- i
+- nhị
+"""
+
+# etc.
+三: int = _dimensionLength ** 3
+"""dimensionIndex = 3: assign `1` to `dimensionIndex = 3`, and assign `0` to each other `DimensionIndex`. Read as (any of):
+- index three
+- sān
+- saam1
+- san
+- sam
+- tam
+"""
+四: int = _dimensionLength ** 4
+"""dimensionIndex = 4: assign `1` to `dimensionIndex = 4`, and assign `0` to each other `DimensionIndex`. Read as (any of):
+- index four
+- sì
+- sei3
+- shi
+- sa
+- tứ
+"""
+五: int = _dimensionLength ** 5
+"""dimensionIndex = 5: assign `1` to `dimensionIndex = 5`, and assign `0` to each other `DimensionIndex`. Read as (any of):
+- index five
+- wǔ
+- ng5
+- go
+- o
+- ngũ
+"""
+六: int = _dimensionLength ** 6
+"""dimensionIndex = 6: assign `1` to `dimensionIndex = 6`, and assign `0` to each other `DimensionIndex`. Read as (any of):
+- index six
+- liù
+- luk6
+- roku
+- yuk
+- lục
+"""
+七: int = _dimensionLength ** 7
+"""dimensionIndex = 7: assign `1` to `dimensionIndex = 7`, and assign `0` to each other `DimensionIndex`. Read as (any of):
+- index seven
+- qī
+- cat1
+- shichi
+- chil
+- thất
+"""
+八: int = _dimensionLength ** 8
+"""dimensionIndex = 8: assign `1` to `dimensionIndex = 8`, and assign `0` to each other `DimensionIndex`. Read as (any of):
+- index eight
+- bā
+- baat3
+- hachi
+- pal
+- bát
+"""
+九: int = _dimensionLength ** 9
+"""dimensionIndex = 9: assign `1` to `dimensionIndex = 9`, and assign `0` to each other `DimensionIndex`. Read as (any of):
+- index nine
+- jiǔ
+- gau2
+- kyū
+- gu
+- cửu
+"""
+
+@cache
+def dimensionIndex(dimensionAsNonnegativeInteger: int, /, *, dimensionLength: int = _dimensionLength) -> int:
+	"""Convert the integer value of a single dimension into its corresponding `DimensionIndex`."""
+	dimension: int = getitem(intInnit([dimensionAsNonnegativeInteger], 'dimensionNonnegative', int), 0)
+	if dimension < 0:
+		message: str = f"I received `{dimensionAsNonnegativeInteger = }`, but I need a value greater than or equal to 0."
+		raise ValueError(message)
+	base: int = getitem(intInnit([dimensionLength], 'dimensionLength', int), 0)
+	if base < 1:
+		message: str = f"I received `{dimensionLength = }`, but I need an integer value greater than 1."
+		raise ValueError(message)
+	place_ValueIndex: float = log(dimension, base)
+	if not place_ValueIndex.is_integer():
+		message: str = f"I received `{dimensionAsNonnegativeInteger = }`, but I need a value that is an integer power of `{dimensionLength = }`."
+		raise ValueError(message)
+	return int(place_ValueIndex)
+
+#-------- Access the dimension coordinates encoded in a number relative to the number's most significant digit -------
+
+@cache
+def 首零(dimensionsTotal: int, /) -> int:
+	"""Enumerate each `DimensionIndex` starting from the head `首`, assign `1` to `零` (`dimensionIndex = 0`), and assign `0` to each other `DimensionIndex` in `dimensionsTotal`.
+
+	Read as (any of):
+	- from the head, index zero
+	- shǒu líng
+	- sau2 ling4
+	- shu rei
+	- su yeong
+	- thủ linh
+	"""
+	return int('1' + '0' * (dimensionsTotal - 1), _dimensionLength)
+
+@cache
+def 首零一(dimensionsTotal: int, /) -> int:
+	"""Enumerate each `DimensionIndex` starting from the head `首`, assign `1` to `零` and `一` (`dimensionIndex = 0` and `dimensionIndex = 1`), and assign `0` to each other `DimensionIndex` in `dimensionsTotal`.
+
+	Read as (any of):
+	- from the head, indices zero-one
+	- shǒu líng yī
+	- sau2 ling4 jat1
+	- shu rei ichi
+	- su yeong il
+	- thủ linh nhất
+	"""
+	return int('11' + '0' * (dimensionsTotal - 2), _dimensionLength)
+
+@cache
+def 首零一二(dimensionsTotal: int, /) -> int:
+	"""Enumerate each `DimensionIndex` starting from the head `首`, assign `1` to `零`, `一`, and `二` (`dimensionIndex = 0`, `dimensionIndex = 1`, and `dimensionIndex = 2`), and assign `0` to each other `DimensionIndex` in `dimensionsTotal`.
+
+	Read as (any of):
+	- from the head, indices zero-one-two
+	- shǒu líng yī èr
+	- sau2 ling4 jat1 ji6
+	- shu rei ichi ni
+	- su yeong il i
+	- thủ linh nhất nhị
+	"""
+	return int('111' + '0' * (dimensionsTotal - 3), _dimensionLength)
+
+@cache
+def 首零二(dimensionsTotal: int, /) -> int:
+	"""Enumerate each `DimensionIndex` starting from the head `首`, assign `1` to `零` and `二` (`dimensionIndex = 0` and `dimensionIndex = 2`), and assign `0` to each other `DimensionIndex` in `dimensionsTotal`.
+
+	Read as (any of):
+	- from the head, indices zero-two
+	- shǒu líng èr
+	- sau2 ling4 ji6
+	- shu rei ni
+	- su yeong i
+	- thủ linh nhị
+	"""
+	return int('101' + '0' * (dimensionsTotal - 3), _dimensionLength)
+
+@cache
+def 首一(dimensionsTotal: int, /) -> int:
+	"""Enumerate each `DimensionIndex` starting from the head `首`, assign `1` to `一` (`dimensionIndex = 1`), and assign `0` to each other `DimensionIndex` in `dimensionsTotal`.
+
+	Read as (any of):
+	- from the head, index one
+	- shǒu yī
+	- sau2 jat1
+	- shu ichi
+	- su il
+	- thủ nhất
+	"""
+	return int('01' + '0' * (dimensionsTotal - 2), _dimensionLength)
+
+@cache
+def 首一二(dimensionsTotal: int, /) -> int:
+	"""Enumerate each `DimensionIndex` starting from the head `首`, assign `1` to `一` and `二` (`dimensionIndex = 1` and `dimensionIndex = 2`), and assign `0` to each other `DimensionIndex` in `dimensionsTotal`.
+
+	Read as (any of):
+	- from the head, indices one-two
+	- shǒu yī èr
+	- sau2 jat1 ji6
+	- shu ichi ni
+	- su il i
+	- thủ nhất nhị
+	"""
+	return int('011' + '0' * (dimensionsTotal - 3), _dimensionLength)
+
+@cache
+def 首二(dimensionsTotal: int, /) -> int:
+	"""Enumerate each `DimensionIndex` starting from the head `首`, assign `1` to `二` (`dimensionIndex = 2`), and assign `0` to each other `DimensionIndex` in `dimensionsTotal`.
+
+	Read as (any of):
+	- from the head, index two
+	- shǒu èr
+	- sau2 ji6
+	- shu ni
+	- su i
+	- thủ nhị
+	"""
+	return int('001' + '0' * (dimensionsTotal - 3), _dimensionLength)
+
+@cache
+def 首三(dimensionsTotal: int, /) -> int:
+	"""Enumerate each `DimensionIndex` starting from the head `首`, assign `1` to `三` (`dimensionIndex = 3`), and assign `0` to each other `DimensionIndex` in `dimensionsTotal`.
+
+	Read as (any of):
+	- from the head, index three
+	- shǒu sān
+	- sau2 saam1
+	- shu san
+	- su sam
+	- thủ tam
+	"""
+	return int('0001' + '0' * (dimensionsTotal - 4), _dimensionLength)
+
+@cache
+def 首零一二三(dimensionsTotal: int, /) -> int:
+	"""Enumerate each `DimensionIndex` starting from the head `首`, assign `1` to `零`, `一`, `二`, and `三` (`dimensionIndex = 0`, `dimensionIndex = 1`, `dimensionIndex = 2`, and `dimensionIndex = 3`), and assign `0` to each other `DimensionIndex` in `dimensionsTotal`.
+
+	Read as (any of):
+	- from the head, indices zero-one-two-three
+	- shǒu líng yī èr sān
+	- sau2 ling4 jat1 ji6 saam1
+	- shu rei ichi ni san
+	- su yeong il i sam
+	- thủ linh nhất nhị tam
+	"""
+	return int('1111' + '0' * (dimensionsTotal - 4), _dimensionLength)
+
+@cache
+def 首零一三(dimensionsTotal: int, /) -> int:
+	"""Enumerate each `DimensionIndex` starting from the head `首`, assign `1` to `零`, `一`, and `三` (`dimensionIndex = 0`, `dimensionIndex = 1`, and `dimensionIndex = 3`), and assign `0` to each other `DimensionIndex` in `dimensionsTotal`.
+
+	Read as (any of):
+	- from the head, indices zero-one-three
+	- shǒu líng yī sān
+	- sau2 ling4 jat1 saam1
+	- shu rei ichi san
+	- su yeong il sam
+	- thủ linh nhất tam
+	"""
+	return int('1101' + '0' * (dimensionsTotal - 4), _dimensionLength)
+
+@cache
+def 首零二三(dimensionsTotal: int, /) -> int:
+	"""Enumerate each `DimensionIndex` starting from the head `首`, assign `1` to `零`, `二`, and `三` (`dimensionIndex = 0`, `dimensionIndex = 2`, and `dimensionIndex = 3`), and assign `0` to each other `DimensionIndex` in `dimensionsTotal`.
+
+	Read as (any of):
+	- from the head, indices zero-two-three
+	- shǒu líng èr sān
+	- sau2 ling4 ji6 saam1
+	- shu rei ni san
+	- su yeong i sam
+	- thủ linh nhị tam
+	"""
+	return int('1011' + '0' * (dimensionsTotal - 4), _dimensionLength)
+
+@cache
+def 首零三(dimensionsTotal: int, /) -> int:
+	"""Enumerate each `DimensionIndex` starting from the head `首`, assign `1` to `零` and `三` (`dimensionIndex = 0` and `dimensionIndex = 3`), and assign `0` to each other `DimensionIndex` in `dimensionsTotal`.
+
+	Read as (any of):
+	- from the head, indices zero-three
+	- shǒu líng sān
+	- sau2 ling4 saam1
+	- shu rei san
+	- su yeong sam
+	- thủ linh tam
+	"""
+	return int('1001' + '0' * (dimensionsTotal - 4), _dimensionLength)
+
+@cache
+def 首一二三(dimensionsTotal: int, /) -> int:
+	"""Enumerate each `DimensionIndex` starting from the head `首`, assign `1` to `一`, `二`, and `三` (`dimensionIndex = 1`, `dimensionIndex = 2`, and `dimensionIndex = 3`), and assign `0` to each other `DimensionIndex` in `dimensionsTotal`.
+
+	Read as (any of):
+	- from the head, indices one-two-three
+	- shǒu yī èr sān
+	- sau2 jat1 ji6 saam1
+	- shu ichi ni san
+	- su il i sam
+	- thủ nhất nhị tam
+	"""
+	return int('0111' + '0' * (dimensionsTotal - 4), _dimensionLength)
+
+@cache
+def 首一三(dimensionsTotal: int, /) -> int:
+	"""Enumerate each `DimensionIndex` starting from the head `首`, assign `1` to `一` and `三` (`dimensionIndex = 1` and `dimensionIndex = 3`), and assign `0` to each other `DimensionIndex` in `dimensionsTotal`.
+
+	Read as (any of):
+	- from the head, indices one-three
+	- shǒu yī sān
+	- sau2 jat1 saam1
+	- shu ichi san
+	- su il sam
+	- thủ nhất tam
+	"""
+	return int('0101' + '0' * (dimensionsTotal - 4), _dimensionLength)
+
+@cache
+def 首二三(dimensionsTotal: int, /) -> int:
+	"""Enumerate each `DimensionIndex` starting from the head `首`, assign `1` to `二` and `三` (`dimensionIndex = 2` and `dimensionIndex = 3`), and assign `0` to each other `DimensionIndex` in `dimensionsTotal`.
+
+	Read as (any of):
+	- from the head, indices two-three
+	- shǒu èr sān
+	- sau2 ji6 saam1
+	- shu ni san
+	- su i sam
+	- thủ nhị tam
+	"""
+	return int('0011' + '0' * (dimensionsTotal - 4), _dimensionLength)
+
+#======== Semantic replacements for ambiguous values =======
+
+leafOrigin: int = (0 * 九) + (0 * 八) + (0 * 七) + (0 * 六) + (0 * 五) + (0 * 四) + (0 * 三) + (0 * 二) + (0 * 一) + (0 * 零)
+"""The `leaf` at the origin of all dimensions, with `0` in every `DimensionIndex`."""
+pileOrigin: int = (0 * 九) + (0 * 八) + (0 * 七) + (0 * 六) + (0 * 五) + (0 * 四) + (0 * 三) + (0 * 二) + (0 * 一) + (0 * 零)
+"""The `pile` at the origin of all dimensions, with `0` in every `DimensionIndex`."""
+

mapFolding/_e/_theTypes.py

@@ -0,0 +1,31 @@
+from gmpy2 import mpz
+
+# NOTE HEY!!! Are you -> RENAMING <- a type alias? Pylance will NOT do a global update unless you delete `type `. You can add it back afterwards.
+
+#======== Scalars ================================
+
+type DimensionIndex = int
+"""Zero-based index of a dimension."""
+type Leaf = int
+type Pile = int
+
+type PileRangeOfLeaves = mpz
+"""But I am le tired."""
+
+type LeafOrPileRangeOfLeaves = Leaf | PileRangeOfLeaves
+"""Zen take a nap, and then fire the missiles!"""
+
+#======== Containers ============================
+
+type Folding = tuple[Leaf, ...]
+"""`leaf` indexed to `pile`; length must be `leavesTotal`."""
+
+type PermutationSpace = dict[Pile, LeafOrPileRangeOfLeaves]
+"""`pile: leaf` or `pile: pileRangeOfLeaves`; length must be `leavesTotal`."""
+
+type PilesWithPileRangeOfLeaves = dict[Pile, PileRangeOfLeaves]
+"""`pile: pileRangeOfLeaves`; length less than or equal to `leavesTotal`."""
+
+type PinnedLeaves = dict[Pile, Leaf]
+"""`pile: leaf`; length ought to be less than `leavesTotal`: when length equals `leavesTotal`, ought to convert to `Folding`."""
+

mapFolding/_e/algorithms/__init__.py

@@ -0,0 +1 @@
+"""Hand-made algorithms and formulas."""

mapFolding/_e/algorithms/constraintPropagation.py

@@ -0,0 +1,158 @@
+from pprint import pprint
+from concurrent.futures import as_completed, Future, ProcessPoolExecutor
+from cytoolz.itertoolz import last
+from itertools import pairwise, product as CartesianProduct
+from mapFolding import packageSettings
+from mapFolding._e import (
+	getIteratorOfLeaves, indicesMapShapeDimensionLengthsAreEqual, Leaf, leafOrigin, mapShapeIs2上nDimensions, pileOrigin,
+	PilesWithPileRangeOfLeaves, PinnedLeaves)
+from mapFolding._e.dataBaskets import EliminationState
+from mapFolding._e.filters import between, extractPilesWithPileRangeOfLeaves, extractPinnedLeaves
+from math import factorial, prod
+from ortools.sat.python import cp_model
+from pathlib import Path
+from tqdm import tqdm
+import csv
+import uuid
+
+def count(state: EliminationState) -> EliminationState:
+	model = cp_model.CpModel()
+
+	listLeavesInPileOrder: list[cp_model.IntVar] = [model.new_int_var(pileOrigin, state.pileLast, f"leafInPile[{pile}]") for pile in range(state.leavesTotal)]
+	listPilingsInLeafOrder: list[cp_model.IntVar] = [model.new_int_var(leafOrigin, state.leafLast, f"pileOfLeaf[{leaf}]") for leaf in range(state.leavesTotal)]
+	model.add_inverse(listLeavesInPileOrder, listPilingsInLeafOrder)
+
+#======== Manual concurrency and targeted constraints ============================
+	dictionaryOfPileLeaf: PinnedLeaves = extractPinnedLeaves(state.permutationSpace)
+	for aPile, aLeaf in dictionaryOfPileLeaf.items():
+		model.add(listLeavesInPileOrder[aPile] == aLeaf)
+
+	pilesWithPileRangeOfLeaves: PilesWithPileRangeOfLeaves = extractPilesWithPileRangeOfLeaves(state.permutationSpace)
+	for aPile, aLeaf in pilesWithPileRangeOfLeaves.items():
+		model.add_allowed_assignments([listLeavesInPileOrder[aPile]], list(zip(getIteratorOfLeaves(aLeaf))))
+
+#======== Lunnon Theorem 2(a): foldsTotal is divisible by leavesTotal ============================
+	model.add(listLeavesInPileOrder[pileOrigin] == leafOrigin)
+
+#======== Lunnon Theorem 4: "G(p^d) is divisible by d!p^d." ============================
+	if 2 < max(state.mapShape):
+		for indicesSameDimensionLength in indicesMapShapeDimensionLengthsAreEqual(state.mapShape):
+			state.Theorem4Multiplier *= factorial(len(indicesSameDimensionLength))
+			for index_k, index_r in pairwise(indicesSameDimensionLength):
+				model.add(listPilingsInLeafOrder[state.productsOfDimensions[index_k]] < listPilingsInLeafOrder[state.productsOfDimensions[index_r]])
+
+#======== Rules for 2^n-dimensional maps ============================
+
+	if mapShapeIs2上nDimensions(state.mapShape):
+		pass
+
+#======== Lunnon Theorem 2(b): "If some [dimensionLength in state.mapShape] > 2, [foldsTotal] is divisible by 2 * [leavesTotal]." ============================
+	if (state.Theorem4Multiplier == 1) and (2 < max(state.mapShape)):
+		state.Theorem2Multiplier = 2
+		leafOrigin下_aDimension: int = last(filter(between(0, state.leafLast // 2), state.productsOfDimensions))
+		model.add(listPilingsInLeafOrder[leafOrigin下_aDimension] < listPilingsInLeafOrder[2 * leafOrigin下_aDimension])
+
+#======== Forbidden inequalities ============================
+	def addLessThan(comparatorLeft: Leaf, comparatorRight: Leaf) -> cp_model.IntVar:
+		ruleΩ: cp_model.IntVar = model.new_bool_var(f"this_{comparatorLeft}_lessThan_{comparatorRight}")
+		model.add(listPilingsInLeafOrder[comparatorLeft] < listPilingsInLeafOrder[comparatorRight]).only_enforce_if(ruleΩ)
+		model.add(listPilingsInLeafOrder[comparatorRight] <= listPilingsInLeafOrder[comparatorLeft]).only_enforce_if(ruleΩ.Not())
+		return ruleΩ
+
+	def addForbiddenInequalityCycle(leaf_k: Leaf, leaf_r: Leaf, leaf_kCrease: Leaf, leaf_rCrease: Leaf) -> None:
+		k__小于_r: cp_model.IntVar = addLessThan(leaf_k, leaf_r) # 小, xiǎo: small, less; as in 李小龍, Lǐ Xiǎolóng, Lǐ little dragon, aka Bruce Lee
+		r1_小于_k: cp_model.IntVar = addLessThan(leaf_rCrease, leaf_k)
+		k1_小于_r1: cp_model.IntVar = addLessThan(leaf_kCrease, leaf_rCrease)
+		model.add_bool_or([k1_小于_r1.Not(), r1_小于_k.Not(), k__小于_r.Not()])		# [k+1 < r+1 < k < r]
+
+		r__小于_k1: cp_model.IntVar = addLessThan(leaf_r, leaf_kCrease)
+		model.add_bool_or([r1_小于_k.Not(), k__小于_r.Not(), r__小于_k1.Not()])		# [r+1 < k < r < k+1]
+
+		model.add_bool_or([k__小于_r.Not(), r__小于_k1.Not(), k1_小于_r1.Not()])	# [k < r < k+1 < r+1]
+
+		k__小于_r1: cp_model.IntVar = addLessThan(leaf_k, leaf_rCrease)
+		r1_小于_k1: cp_model.IntVar = addLessThan(leaf_rCrease, leaf_kCrease)
+		k1_小于_r: cp_model.IntVar = addLessThan(leaf_kCrease, leaf_r)
+		model.add_bool_or([k__小于_r1.Not(), r1_小于_k1.Not(), k1_小于_r.Not()])	# [k < r+1 < k+1 < r]
+
+	def leaf2IndicesCartesian(leaf: Leaf) -> tuple[int, ...]:
+		return tuple((leaf // prod(state.mapShape[0:dimension])) % state.mapShape[dimension] for dimension in range(state.dimensionsTotal))
+
+	def leafCreasePost(leaf: Leaf, dimension: int) -> Leaf | None:
+		leafCrease: Leaf | None = None
+		if leaf2IndicesCartesian(leaf)[dimension] + 1 < state.mapShape[dimension]:
+			leafCrease = leaf + prod(state.mapShape[0:dimension])
+		return leafCrease
+
+	for leaf_k, leaf_r in CartesianProduct(range(state.leafLast), range(1, state.leafLast)):
+		if leaf_k == leaf_r:
+			continue
+
+		k下_indicesCartesian: tuple[int, ...] = leaf2IndicesCartesian(leaf_k) # 下, xià: below, subscript
+		r下_indicesCartesian: tuple[int, ...] = leaf2IndicesCartesian(leaf_r)
+
+		for aDimension in range(state.dimensionsTotal):
+			k1下_aDimension: Leaf | None = leafCreasePost(leaf_k, aDimension)
+			r1下_aDimension: Leaf | None = leafCreasePost(leaf_r, aDimension)
+
+			if k1下_aDimension and r1下_aDimension and ((k下_indicesCartesian[aDimension] - r下_indicesCartesian[aDimension]) % 2 == 0):
+				addForbiddenInequalityCycle(leaf_k, leaf_r, k1下_aDimension, r1下_aDimension)
+
+#======== Solver ================================
+	solver = cp_model.CpSolver()
+	solver.parameters.enumerate_all_solutions = True
+
+	solver.parameters.log_search_progress = False
+
+	class FoldingCollector(cp_model.CpSolverSolutionCallback):
+		def __init__(self, _listOfIndicesLeafInPilingsOrder: list[cp_model.IntVar]) -> None:
+			super().__init__()
+			self._listOfIndicesLeafInPilingsOrder: list[cp_model.IntVar] = _listOfIndicesLeafInPilingsOrder
+			self.listFolding: list[list[Leaf]] = []
+
+		def on_solution_callback(self) -> None:
+			self.listFolding.append([self.value(leaf) for leaf in self._listOfIndicesLeafInPilingsOrder])
+
+	foldingCollector = FoldingCollector(listLeavesInPileOrder)
+	solver.solve(model, foldingCollector)
+
+	state.listFolding = list(map(tuple, foldingCollector.listFolding))
+
+	return state
+
+def doTheNeedful(state: EliminationState, workersMaximum: int) -> EliminationState:
+	"""Do the things necessary so that `count` operates efficiently."""
+	if state.listPermutationSpace or (workersMaximum > 1):
+
+		with ProcessPoolExecutor(workersMaximum) as concurrencyManager:
+
+			if not state.listPermutationSpace:
+				pileForConcurrency: int = state.pileLast // 2
+				state.listPermutationSpace = [{pileForConcurrency: leaf} for leaf in range(state.leavesTotal)]
+
+			listClaimTickets: list[Future[EliminationState]] = [
+				concurrencyManager.submit(count, EliminationState(state.mapShape, permutationSpace=permutationSpace))
+					for permutationSpace in state.listPermutationSpace
+			]
+
+			for claimTicket in tqdm(as_completed(listClaimTickets), total=len(listClaimTickets), disable=False):
+				sherpa: EliminationState = claimTicket.result()
+
+			# TODO NOTE temporary data collection for p2d7
+				if (sherpa.dimensionsTotal == 7) and (sherpa.listFolding):
+					pathFilename: Path = packageSettings.pathPackage / "_e" / "dataRaw" / f"p2d7_{uuid.uuid4()}.csv"
+					with Path.open(pathFilename, mode="w", newline="") as fileCSV:
+						csvWriter = csv.writer(fileCSV)
+						csvWriter.writerows(sherpa.listFolding)
+
+				state.groupsOfFolds += len(sherpa.listFolding)
+				state.Theorem2aMultiplier = sherpa.Theorem2aMultiplier
+				state.Theorem2Multiplier = sherpa.Theorem2Multiplier
+				state.Theorem3Multiplier = sherpa.Theorem3Multiplier
+				state.Theorem4Multiplier = sherpa.Theorem4Multiplier
+
+	else:
+		state = count(state)
+		state.groupsOfFolds = len(state.listFolding)
+
+	return state

mapFolding/_e/algorithms/elimination.py

@@ -0,0 +1,118 @@
+from collections.abc import Iterable
+from itertools import pairwise, permutations, repeat
+from mapFolding._e import indicesMapShapeDimensionLengthsAreEqual, leafOrigin, PermutationSpace, pileOrigin
+from mapFolding._e.algorithms.iff import thisLeafFoldingIsValid
+from mapFolding._e.dataBaskets import EliminationState
+from mapFolding._e.pinIt import excludeLeaf_rBeforeLeaf_k, makeFolding
+from math import factorial
+
+# TODO make sure all permutationSpace have pile-ranges and update their pile-ranges
+
+def count(state: EliminationState) -> EliminationState:
+	state.groupsOfFolds += sum(map(countPermutationSpace, state.listPermutationSpace, repeat(state.mapShape), repeat(range(state.leavesTotal))))
+	return state
+
+def countPermutationSpace(permutationSpace: PermutationSpace, mapShape: tuple[int, ...], leavesToInsert: Iterable[int]) -> int:
+	"""# TODO Replace `permutations` with the `noDuplicates` filter on `CartesianProduct` of the domains of each leaf.
+
+	permutationSpace must be in order by `pile`.
+	filter with `oop`.
+	pileRangeOfLeaves.iter_set() returns an iterator of int corresponding to the leaves in the pile's range.
+	https://gmpy2.readthedocs.io/en/latest/advmpz.html#gmpy2.xmpz.iter_set
+	filter out "leaf" = state.leavesTotal
+	CartesianProduct over these iterators.
+	filter via noDuplicates.
+	each product tuple is a `leavesToInsert` argument to makeFolding.
+	return sum(
+		map(thisLeafFoldingIsValid
+			, map(makeFolding
+				, repeat(permutationSpace)
+				, CartesianProduct(*map(getIteratorOfLeaves, extractPilesWithPileRangeOfLeaves(permutationSpace).values()))
+			)
+			, repeat(mapShape)
+		)
+	)
+	"""
+	return sum(map(thisLeafFoldingIsValid, map(makeFolding, repeat(permutationSpace), permutations(tuple(set(leavesToInsert).difference(permutationSpace.values())))), repeat(mapShape)))
+
+
+def theorem2b(state: EliminationState) -> EliminationState:
+	"""Implement Lunnon Theorem 2(b): If some dimension pᵢ > 2 (with Theorem 4 inactive), G is divisible by 2·n.
+
+	Conditions
+	----------
+	Executed only when:
+	- `state.Theorem4Multiplier == 1` (Theorem 4 did not apply),
+	- `max(mapShape) > 2` (at least one dimension exceeds 2),
+	- `leavesTotal > 4` (non-trivial folding size).
+
+	Mechanism
+	---------
+	Select the maximal dimension, compute `k = productOfDimensions(mapShape, dimension)` and `r = 2 * k`, then eliminate
+	configurations where r precedes k (via `excludeLeafRBeforeLeafK`). This enforces the structural constraint underpinning
+	the `2·n` divisibility and sets `state.Theorem2Multiplier = 2`.
+
+	Side Effects
+	------------
+	Mutates `state.listPermutationSpace` and `state.Theorem2Multiplier` when applicable.
+
+	Returns
+	-------
+	EliminationState
+		Same state instance after potential exclusion.
+
+	See Also
+	--------
+	theorem4, excludeLeafRBeforeLeafK
+	"""
+	if state.Theorem4Multiplier == 1 and (2 < max(state.mapShape)) and (4 < state.leavesTotal):
+		state.Theorem2Multiplier = 2
+		dimension: int = state.mapShape.index(max(state.mapShape))
+		leaf_k: int = state.productsOfDimensions[dimension]
+		leaf_r: int = 2 * leaf_k
+		state = excludeLeaf_rBeforeLeaf_k(state, leaf_k, leaf_r)
+	return state
+
+def theorem4(state: EliminationState) -> EliminationState:
+	"""***Bluntly*** implement Lunnon Theorem 4 (divisibility by d! · p^d) via systematic leaf exclusions.
+
+	This function is ignorant of the actual domains of the dimension-origin leaves, so it creates `PermutationSpace` dictionaries to
+	exclude at every `pile`. The permutation space is still valid. However, for each `PermutationSpace` dictionary, for each `pile`
+	*not* in the domain of a dimension-origin leaf, the function creates approximately `leavesTotal - 1` unnecessary
+	`PermutationSpace` dictionaries. They are "unnecessary" because we didn't need to exclude the leaf from a pile in which it could
+	never appear. The net result is that the number of unnecessary dictionaries grows exponentially with the number of repeated
+	dimension magnitudes.
+
+	For a map whose shape has repeated dimension magnitudes (say a size `p` occurring `d` times), the total number of foldings
+	`G(p^d)` is divisible by `d! · p^d`. This routine encodes the constructive elimination implied by that divisibility.
+
+	Returns
+	-------
+	EliminationState
+		Same state instance after applying all required exclusions.
+
+	See Also
+	--------
+	theorem2b : Applies the complementary 2(b) divisibility if theorem4 does not apply.
+	excludeLeafRBeforeLeafK : Performs the actual leaf ordering elimination.
+	"""
+	if 2 < max(state.mapShape):
+		for indicesSameDimensionLength in indicesMapShapeDimensionLengthsAreEqual(state.mapShape):
+			state.Theorem4Multiplier *= factorial(len(indicesSameDimensionLength))
+			for index_k, index_r in pairwise(indicesSameDimensionLength):
+				state = excludeLeaf_rBeforeLeaf_k(state, state.productsOfDimensions[index_k], state.productsOfDimensions[index_r])
+	return state
+
+def doTheNeedful(state: EliminationState, workersMaximum: int) -> EliminationState:  # noqa: ARG001
+	"""Count the number of valid foldings for a given number of leaves."""
+	if state.leavesTotal == 0:
+		state.groupsOfFolds = 1
+		return state
+	if not state.listPermutationSpace:
+		"""Lunnon Theorem 2(a): `foldsTotal` is divisible by `leavesTotal`; pin `leafOrigin` at `pileOrigin`, which eliminates other leaves at `pileOrigin`."""
+		state.listPermutationSpace = [{pileOrigin: leafOrigin}]
+		state = theorem4(state)
+		state = theorem2b(state)
+
+	return count(state)
+