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

mapFolding/algorithms/constraintPropagation.py

@@ -1,184 +0,0 @@
-# ruff: noqa: ERA001
-from concurrent.futures import as_completed, Future, ProcessPoolExecutor
-from copy import deepcopy
-from itertools import pairwise, product as CartesianProduct
-from mapFolding.algorithms.patternFinder import getDictionaryIndexLeafRanges
-from mapFolding.algorithms.pinning2Dn import pinByFormula, secondOrderLeaves, secondOrderPilings
-from mapFolding.dataBaskets import EliminationState
-from math import factorial, prod
-from more_itertools import iter_index, unique
-from ortools.sat.python import cp_model
-from tqdm import tqdm
-from typing import Final
-
-def findValidFoldings(state: EliminationState) -> int:
-	model = cp_model.CpModel()
-
-	listIndicesLeafInPilingsOrder: list[cp_model.IntVar] = [model.NewIntVar(0, state.leavesTotal - 1, f"indexLeafInPile[{pile}]") for pile in range(state.leavesTotal)]
-	listPilingsInIndexLeafOrder: list[cp_model.IntVar] = [model.NewIntVar(0, state.leavesTotal - 1, f"pileOfIndexLeaf[{indexLeaf}]") for indexLeaf in range(state.leavesTotal)]
-	model.AddInverse(listIndicesLeafInPilingsOrder, listPilingsInIndexLeafOrder)
-
-# ------- Leaf domain restrictions from dictionaryLeafRanges -----------------------------
-	if (state.dimensionsTotal > 2) and (state.mapShape[0] == 2):
-		dictionaryLeafRanges: Final[dict[int, range]] = getDictionaryIndexLeafRanges(state)
-		for indexLeaf, rangePilings in dictionaryLeafRanges.items():
-			if indexLeaf < 2:
-				continue
-			model.AddAllowedAssignments([listPilingsInIndexLeafOrder[indexLeaf]], [(pile,) for pile in rangePilings])
-
-		if state.leavesTotal in [64, 128]:
-			from mapFolding.algorithms.patternFinder import getDictionaryAddends4Next  # noqa: PLC0415
-			dictionaryAddends4Next: Final[dict[int, list[int]]] = getDictionaryAddends4Next(state)
-			dictionaryNextLeaf: dict[int, list[int]] = {}
-			for indexLeaf, listDifferences in dictionaryAddends4Next.items():
-				listAllowedNextLeaves: list[int] = []
-				for difference in listDifferences:
-					listAllowedNextLeaves.append(indexLeaf + difference)  # noqa: PERF401
-				dictionaryNextLeaf[indexLeaf] = listAllowedNextLeaves
-
-	# ------- Constraints from dictionaryNextLeaf -----------------------------
-			for indexLeaf, listAllowedNextLeaves in dictionaryNextLeaf.items():
-				if not listAllowedNextLeaves:
-					continue
-				for pile in range(state.leavesTotal - 1):
-					currentLeafAtThisPile: cp_model.IntVar = listIndicesLeafInPilingsOrder[pile]
-					nextLeafAtNextPile: cp_model.IntVar = listIndicesLeafInPilingsOrder[pile + 1]
-
-					isCurrentLeafEqualToIndexLeaf: cp_model.IntVar = model.NewBoolVar(f"pile{pile}_leaf{indexLeaf}")
-					model.Add(currentLeafAtThisPile == indexLeaf).OnlyEnforceIf(isCurrentLeafEqualToIndexLeaf)
-					model.Add(currentLeafAtThisPile != indexLeaf).OnlyEnforceIf(isCurrentLeafEqualToIndexLeaf.Not())
-
-					model.AddAllowedAssignments([nextLeafAtNextPile], [(leaf,) for leaf in listAllowedNextLeaves]).OnlyEnforceIf(isCurrentLeafEqualToIndexLeaf)
-
-# ------- Manual concurrency -----------------------------
-	for pile, indexLeaf in state.pinnedLeaves.items():
-		model.Add(listIndicesLeafInPilingsOrder[pile] == indexLeaf)
-
-# ------- Lunnon Theorem 2(a): foldsTotal is divisible by leavesTotal; fix in pile at 0, indexLeaf at 0 -----------------------------
-	model.Add(listIndicesLeafInPilingsOrder[0] == 0)
-
-# ------- Lunnon Theorem 4: "G(p^d) is divisible by d!p^d." ---------------
-	for listIndicesSameMagnitude in [list(iter_index(state.mapShape, magnitude)) for magnitude in unique(state.mapShape)]:
-		if len(listIndicesSameMagnitude) > 1:
-			state.subsetsTheorem4 *= factorial(len(listIndicesSameMagnitude))
-			for dimensionAlpha, dimensionBeta in pairwise(listIndicesSameMagnitude):
-				k, r = (prod(state.mapShape[0:dimension]) for dimension in (dimensionAlpha, dimensionBeta))
-				model.Add(listPilingsInIndexLeafOrder[k] < listPilingsInIndexLeafOrder[r])
-
-# ------- Lunnon Theorem 2(b): "If some [magnitude in state.mapShape] > 2, [foldsTotal] is divisible by 2 * [leavesTotal]." -----------------------------
-	if state.subsetsTheorem4 == 1:
-		for aDimension in range(state.dimensionsTotal - 1, -1, -1):
-			if state.mapShape[aDimension] > 2:
-				state.subsetsTheorem2 = 2
-				indexLeafOrigin下_aDimension: int = prod(state.mapShape[0:aDimension])
-				model.Add(listPilingsInIndexLeafOrder[indexLeafOrigin下_aDimension] < listPilingsInIndexLeafOrder[2 * indexLeafOrigin下_aDimension])
-				break
-
-# ------- Forbidden inequalities -----------------------------
-	def addLessThan(comparatorLeft: int, comparatorRight: int) -> cp_model.IntVar:
-		ruleΩ: cp_model.IntVar = model.NewBoolVar(f"this_{comparatorLeft}_lessThan_{comparatorRight}")
-		model.Add(listPilingsInIndexLeafOrder[comparatorLeft] < listPilingsInIndexLeafOrder[comparatorRight]).OnlyEnforceIf(ruleΩ)
-		model.Add(listPilingsInIndexLeafOrder[comparatorLeft] >= listPilingsInIndexLeafOrder[comparatorRight]).OnlyEnforceIf(ruleΩ.Not())
-		return ruleΩ
-
-	def addForbiddenInequalityCycle(k: int, r: int, k1: int, r1: int) -> None:
-		k__小于_r: cp_model.IntVar = addLessThan(k, r) # 小, xiǎo: small, less; as in 李小龍, Lǐ Xiǎolóng, Lǐ little dragon, aka Bruce Lee
-		r1_小于_k: cp_model.IntVar = addLessThan(r1, k)
-		k1_小于_r1: cp_model.IntVar = addLessThan(k1, r1)
-		model.AddBoolOr([k1_小于_r1.Not(), r1_小于_k.Not(), k__小于_r.Not()])	# [k+1 < r+1 < k < r]
-
-		r__小于_k1: cp_model.IntVar = addLessThan(r, k1)
-		model.AddBoolOr([r1_小于_k.Not(), k__小于_r.Not(), r__小于_k1.Not()])	# [r+1 < k < r < k+1]
-
-		model.AddBoolOr([k__小于_r.Not(), r__小于_k1.Not(), k1_小于_r1.Not()])	# [k < r < k+1 < r+1]
-
-		k__小于_r1: cp_model.IntVar = addLessThan(k, r1)
-		r1_小于_k1: cp_model.IntVar = addLessThan(r1, k1)
-		k1_小于_r: cp_model.IntVar = addLessThan(k1, r)
-		model.AddBoolOr([k__小于_r1.Not(), r1_小于_k1.Not(), k1_小于_r.Not()])	# [k < r+1 < k+1 < r]
-
-	def indexLeaf2IndicesCartesian(indexLeaf: int) -> tuple[int, ...]:
-		return tuple((indexLeaf // prod(state.mapShape[0:dimension])) % state.mapShape[dimension] for dimension in range(state.dimensionsTotal))
-
-	def indexLeafNextCrease(indexLeaf: int, dimension: int) -> int | None:
-		indexLeafNext: int | None = None
-		if indexLeaf2IndicesCartesian(indexLeaf)[dimension] + 1 < state.mapShape[dimension]:
-			indexLeafNext = indexLeaf + prod(state.mapShape[0:dimension])
-		return indexLeafNext
-
-	for k, r in CartesianProduct(range(state.leavesTotal-1), range(1, state.leavesTotal-1)):
-		if k == r:
-			continue
-
-		k下_indicesCartesian: tuple[int, ...] = indexLeaf2IndicesCartesian(k) # 下, xià: below, subscript
-		r下_indicesCartesian: tuple[int, ...] = indexLeaf2IndicesCartesian(r)
-
-		for aDimension in range(state.dimensionsTotal):
-			k1下_aDimension: int | None = indexLeafNextCrease(k, aDimension)
-			r1下_aDimension: int | None = indexLeafNextCrease(r, aDimension)
-
-			if k1下_aDimension and r1下_aDimension and ((k下_indicesCartesian[aDimension] - r下_indicesCartesian[aDimension]) % 2 == 0):
-				addForbiddenInequalityCycle(k, 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.listFoldings: list[list[int]] = []
-
-		def OnSolutionCallback(self) -> None:
-			self.listFoldings.append([self.Value(indexLeaf) for indexLeaf in self._listOfIndicesLeafInPilingsOrder]) # pyright: ignore[reportUnknownMemberType]
-
-	foldingCollector = FoldingCollector(listIndicesLeafInPilingsOrder)
-	solver.Solve(model, foldingCollector)
-
-	# if not foldingCollector.listFoldings:
-	# 	print("\n",state.pinnedLeaves)
-	# if foldingCollector.listFoldings:
-	# 	print(*foldingCollector.listFoldings, sep="\n")
-
-	return len(foldingCollector.listFoldings) * state.subsetsTheorem2 * state.subsetsTheorem4
-
-def doTheNeedful(state: EliminationState, workersMaximum: int) -> EliminationState:
-	"""Find the quantity of valid foldings for a given map."""
-	# state = pinByFormula(state)
-	# state = secondOrderLeaves(state)
-	# state = secondOrderPilings(state)
-
-	if state.listPinnedLeaves:
-
-		with ProcessPoolExecutor(workersMaximum) as concurrencyManager:
-			listClaimTickets: list[Future[int]] = []
-
-			listPinnedLeavesCopy: list[dict[int, int]] = deepcopy(state.listPinnedLeaves)
-			state.listPinnedLeaves = []
-			for pinnedLeaves in listPinnedLeavesCopy:
-				stateCopy: EliminationState = deepcopy(state)
-				stateCopy.pinnedLeaves = pinnedLeaves
-				listClaimTickets.append(concurrencyManager.submit(findValidFoldings, stateCopy))
-
-			for claimTicket in tqdm(as_completed(listClaimTickets), total=len(listClaimTickets), disable=False):
-				state.groupsOfFolds += claimTicket.result()
-
-	elif workersMaximum > 1:
-		pile = 2
-		with ProcessPoolExecutor(workersMaximum) as concurrencyManager:
-			listClaimTickets: list[Future[int]] = []
-			for indicesLeaf in range(1, state.leavesTotal):
-				stateCopy: EliminationState = deepcopy(state)
-				stateCopy.pinnedLeaves = {pile: indicesLeaf}
-				listClaimTickets.append(concurrencyManager.submit(findValidFoldings, stateCopy))
-
-			for claimTicket in listClaimTickets:
-				state.groupsOfFolds += claimTicket.result()
-
-	else:
-		state.groupsOfFolds = findValidFoldings(deepcopy(state))
-
-	return state

mapFolding/algorithms/elimination.py

@@ -1,131 +0,0 @@
-from cytoolz.functoolz import curry as syntacticCurry
-from cytoolz.itertoolz import groupby as toolz_groupby
-from itertools import pairwise, repeat
-from mapFolding.algorithms.eliminationCount import count, permutands
-from mapFolding.algorithms.iff import productOfDimensions
-from mapFolding.algorithms.pinning2Dn import pinByFormula
-from mapFolding.dataBaskets import EliminationState
-from math import factorial
-from more_itertools import flatten, iter_index, unique
-from typing import Any, TYPE_CHECKING
-
-if TYPE_CHECKING:
-	from collections.abc import Callable
-
-@syntacticCurry
-def _excludeLeafAtColumn(sequencePinnedLeaves: list[dict[int, int]], leaf: int, column: int, leavesTotal: int) -> list[dict[int, int]]:
-	listPinnedLeaves: list[dict[int, int]] = []
-	for pinnedLeaves in sequencePinnedLeaves:
-		leafAtColumn: int | None = pinnedLeaves.get(column)
-		if leaf == leafAtColumn:
-			continue																						# Exclude `leaf` previously fixed at `column`.
-		if (leafAtColumn is not None) or (leaf in pinnedLeaves.values()):									# `column` is occupied, which excludes `leaf`.
-			listPinnedLeaves.append(pinnedLeaves)															# Or `leaf` is pinned, but not at `column`.
-			continue
-		deconstructedPinnedLeaves: dict[int, dict[int, int]] = deconstructPinnedLeaves(pinnedLeaves, column, leavesTotal)
-		deconstructedPinnedLeaves.pop(leaf)																	# Exclude dictionary with `leaf` fixed at `column`.
-		listPinnedLeaves.extend(deconstructedPinnedLeaves.values())
-	return listPinnedLeaves
-
-def pinLeafAtColumn(sequencePinnedLeaves: list[dict[int, int]], leaf: int, column: int, leavesTotal: int) -> list[dict[int, int]]:
-	listPinnedLeaves: list[dict[int, int]] = []
-	for pinnedLeaves in sequencePinnedLeaves:
-		leafAtColumn: int | None = pinnedLeaves.get(column)
-		if leaf == leafAtColumn:
-			listPinnedLeaves.append(pinnedLeaves)															# That was easy.
-			continue
-		if leafAtColumn is not None:																		# `column` is occupied, but not by `leaf`, so exclude it.
-			continue
-		listPinnedLeaves.append(deconstructPinnedLeaves(pinnedLeaves, column, leavesTotal).pop(leaf))		# Keep the dictionary with `leaf` fixed at `column`.
-	return listPinnedLeaves
-
-@syntacticCurry
-def _isPinnedAtColumn(pinnedLeaves: dict[int, int], leaf: int, column: int) -> bool:
-	return leaf == pinnedLeaves.get(column)
-
-def _segregatePinnedAtColumn(listPinnedLeaves: list[dict[int, int]], leaf: int, column: int) -> tuple[list[dict[int, int]], list[dict[int, int]]]:
-	isPinned: Callable[[dict[int, int]], bool] = _isPinnedAtColumn(leaf=leaf, column=column)
-	grouped: dict[bool, list[dict[int, int]]] = toolz_groupby(isPinned, listPinnedLeaves)
-	return (grouped.get(False, []), grouped.get(True, []))
-
-@syntacticCurry
-def atColumnPinLeaf(pinnedLeaves: dict[int, int], column: int, leaf: int) -> dict[int, int]:
-	dictionaryPinnedLeaves: dict[int, int] = dict(pinnedLeaves)
-	dictionaryPinnedLeaves[column] = leaf
-	return dictionaryPinnedLeaves
-
-def deconstructPinnedLeaves(pinnedLeaves: dict[int, int], column: int, leavesTotal: int) -> dict[int, dict[int, int]]:
-	"""Replace `pinnedLeaves`, which doesn't pin a leaf at `column`, with the equivalent group of dictionaries, which each pin a distinct leaf at `column`.
-
-	Parameters
-	----------
-	pinnedLeaves : dict[int, int]
-		Dictionary to divide and replace.
-	column : int
-		Column in which to pin a leaf.
-
-	Returns
-	-------
-	deconstructedPinnedLeaves : dict[int, dict[int, int]]
-		Dictionary mapping from `leaf` pinned at `column` to the dictionary with the `leaf` pinned at `column`.
-	"""
-	leafAtColumn: int | None = pinnedLeaves.get(column)
-	if leafAtColumn is not None:
-		deconstructedPinnedLeaves: dict[int, dict[int, int]] = {leafAtColumn: pinnedLeaves}
-	else:
-		pin: Callable[[int], dict[int, int]] = atColumnPinLeaf(pinnedLeaves, column)
-		deconstructedPinnedLeaves = {leaf: pin(leaf) for leaf in permutands(pinnedLeaves, leavesTotal)}
-	return deconstructedPinnedLeaves
-
-def DOTvalues[个](dictionary: dict[Any, 个]) -> list[个]:
-	return list(dictionary.values())
-
-def deconstructListPinnedLeaves(listPinnedLeaves: list[dict[int, int]], column: int, leavesTotal: int) -> list[dict[int, int]]:
-	return list(flatten(map(DOTvalues, map(deconstructPinnedLeaves, listPinnedLeaves, repeat(column), repeat(leavesTotal)))))
-
-def _excludeLeafRBeforeLeafK(state: EliminationState, k: int, r: int, columnK: int, listPinnedLeaves: list[dict[int, int]]) -> list[dict[int, int]]:
-	listPinnedLeaves = deconstructListPinnedLeaves(listPinnedLeaves, columnK, state.leavesTotal)
-	listPinned: list[dict[int, int]] = []
-	for column in range(columnK, state.columnLast + 1):
-		(listPinnedLeaves, listPinnedAtColumn) = _segregatePinnedAtColumn(listPinnedLeaves, k, column)
-		listPinned.extend(listPinnedAtColumn)
-	listPinnedLeaves.extend(_excludeLeafAtColumn(listPinned, r, columnK - 1, state.leavesTotal))
-	return listPinnedLeaves
-
-def excludeLeafRBeforeLeafK(state: EliminationState, k: int, r: int) -> EliminationState:
-	for columnK in range(state.columnLast, 0, -1):
-		state.listPinnedLeaves = _excludeLeafRBeforeLeafK(state, k, r, columnK, state.listPinnedLeaves)
-	return state
-
-def theorem4(state: EliminationState) -> EliminationState:
-# ------- Lunnon Theorem 4: "G(p^d) is divisible by d!p^d." ---------------
-	for listIndicesSameMagnitude in [list(iter_index(state.mapShape, magnitude)) for magnitude in unique(state.mapShape)]:
-		if len(listIndicesSameMagnitude) > 1:
-			state.subsetsTheorem4 = factorial(len(listIndicesSameMagnitude))
-			for dimensionAlpha, dimensionBeta in pairwise(listIndicesSameMagnitude):
-				k, r = (productOfDimensions(state.mapShape, dimension) + 1 for dimension in (dimensionAlpha, dimensionBeta))
-				state = excludeLeafRBeforeLeafK(state, k, r)
-	return state
-
-def theorem2b(state: EliminationState) -> EliminationState:
-# ------- Lunnon Theorem 2(b): "If some pᵢ > 2, G is divisible by 2n." -----------------------------
-	if state.subsetsTheorem4 == 1 and max(state.mapShape) > 2:
-		state.subsetsTheorem2 = 2
-		dimension: int = state.mapShape.index(max(state.mapShape))
-		k: int = productOfDimensions(state.mapShape, dimension) + 1
-		r: int = 2 * k
-		state = excludeLeafRBeforeLeafK(state, k, r)
-
-	return state
-
-def doTheNeedful(state: EliminationState, workersMaximum: int) -> EliminationState:  # noqa: ARG001
-	"""Count the number of valid foldings for a given number of leaves."""
-# ------- Lunnon Theorem 2(a): foldsTotal is divisible by leavesTotal; Pin leaf1 in column0 and exclude leaf2--leafN at column0 ----------------------------
-	state.listPinnedLeaves = [{0: 1}]
-
-	state = theorem4(state)
-	state = theorem2b(state)
-	state = pinByFormula(state)
-	state = count(state)
-
-	return state

mapFolding/algorithms/eliminationCount.py

@@ -1,26 +0,0 @@
-from collections.abc import Iterator
-from cytoolz.functoolz import memoize
-from itertools import permutations, repeat
-from mapFolding.algorithms.iff import thisLeafFoldingIsValid
-from mapFolding.dataBaskets import EliminationState
-
-def _makeFolding(pinnedLeaves: dict[int, int], permutandsPermutation: tuple[int, ...], leavesTotal: int) -> tuple[int, ...]:
-	permutand: Iterator[int] = iter(permutandsPermutation)
-	return tuple([pinnedLeaves.get(column) or next(permutand) for column in range(leavesTotal)])
-
-@memoize
-def setOfLeaves(leavesTotal: int) -> set[int]:
-	return set(range(1, leavesTotal + 1))
-
-def permutands(pinnedLeaves: dict[int, int], leavesTotal: int) -> tuple[int, ...]:
-	return tuple(setOfLeaves(leavesTotal).difference(pinnedLeaves.values()))
-
-def permutePermutands(pinnedLeaves: dict[int, int], leavesTotal: int) -> Iterator[tuple[int, ...]]:
-	return permutations(permutands(pinnedLeaves, leavesTotal))
-
-def countPinnedLeaves(pinnedLeaves: dict[int, int], mapShape: tuple[int, ...], leavesTotal: int) -> int:
-	return sum(map(thisLeafFoldingIsValid, map(_makeFolding, repeat(pinnedLeaves), permutePermutands(pinnedLeaves, leavesTotal), repeat(leavesTotal)), repeat(mapShape)))
-
-def count(state: EliminationState) -> EliminationState:
-	state.groupsOfFolds += sum(map(countPinnedLeaves, state.listPinnedLeaves, repeat(state.mapShape), repeat(state.leavesTotal)))
-	return state

mapFolding/algorithms/eliminationPinned.py

@@ -1,35 +0,0 @@
-from concurrent.futures import as_completed, Future, ProcessPoolExecutor
-from copy import deepcopy
-from mapFolding.algorithms.eliminationCount import count
-from mapFolding.algorithms.pinning2Dn import pinByFormula
-from mapFolding.dataBaskets import EliminationState
-from math import e, factorial
-from more_itertools import chunked_even
-from tqdm import tqdm
-
-def doTheNeedful(state: EliminationState, workersMaximum: int) -> EliminationState:
-	"""Find the quantity of valid foldings for a given map."""
-	state = pinByFormula(state)
-
-	groupsOfFolds:int = 0
-
-	with ProcessPoolExecutor(workersMaximum) as concurrencyManager:
-		listClaimTickets: list[Future[EliminationState]] = []
-
-		listPinnedLeavesCopy: list[dict[int, int]] = deepcopy(state.listPinnedLeaves)
-		state.listPinnedLeaves = []
-
-		# lengthChunk:int = max(1, int(len(listPinnedLeavesCopy) / (e * workersMaximum)))
-		lengthChunk:int = 5
-
-		for listPinnedLeaves in chunked_even(listPinnedLeavesCopy, lengthChunk):
-			stateCopy: EliminationState = deepcopy(state)
-			stateCopy.listPinnedLeaves = listPinnedLeaves
-			listClaimTickets.append(concurrencyManager.submit(count, stateCopy))
-
-		for claimTicket in tqdm(as_completed(listClaimTickets), total=len(listClaimTickets), disable=False):
-			groupsOfFolds += claimTicket.result().groupsOfFolds
-
-	state.subsetsTheorem4 = factorial(state.dimensionsTotal)
-
-	return state

mapFolding/algorithms/iff.py

@@ -1,206 +0,0 @@
-"""Verify that a folding sequence is possible.
-
-Notes
------
-Eight forbidden inequalities of matching parity k and r *à la* Koehler (1968), indices of:
-	[k < r < k+1 < r+1] [r < k+1 < r+1 < k] [k+1 < r+1 < k < r] [r+1 < k < r < k+1]
-	[r < k < r+1 < k+1] [k < r+1 < k+1 < r] [r+1 < k+1 < r < k] [k+1 < r < k < r+1]
-
-Four forbidden inequalities of matching parity k and r *à la* Legendre (2014), indices of:
-	[k < r < k+1 < r+1] [k+1 < r+1 < k < r] [r+1 < k < r < k+1] [k < r+1 < k+1 < r]
-
-Citations
----------
-- John E. Koehler, Folding a strip of stamps, Journal of Combinatorial Theory, Volume 5, Issue 2, 1968, Pages 135-152, ISSN
-0021-9800, https://doi.org/10.1016/S0021-9800(68)80048-1.
-- Stéphane Legendre, Foldings and meanders, The Australasian Journal of Combinatorics, Volume 58, Part 2, 2014, Pages 275-291,
-ISSN 2202-3518, https://ajc.maths.uq.edu.au/pdf/58/ajc_v58_p275.pdf.
-
-See Also
---------
-- "[Annotated, corrected, scanned copy]" of Koehler (1968) at https://oeis.org/A001011.
-- Citations in BibTeX format "mapFolding/citations".
-"""
-from collections.abc import Callable
-from cytoolz.curried import get
-from cytoolz.functoolz import curry as syntacticCurry
-from functools import cache
-from itertools import combinations, filterfalse, product as CartesianProduct
-from mapFolding import getLeavesTotal
-from mapFolding.dataBaskets import EliminationState
-from math import prod
-from operator import indexOf
-
-def thisIsAViolation(column: int, columnComparand: int, getLeafNextCrease: Callable[[], int | None], getComparandNextCrease: Callable[[], int | None], columnOf: Callable[[int], int | None]) -> bool:  # noqa: PLR0911
-	"""Validate.
-
-	Mathematical reasons for the design of this function
-	----------------------------------------------------
-
-	1. To confirm that a multidimensional folding is valid, confirm that each of the constituent one-dimensional¹ foldings is valid.
-	2. To confirm that a one-dimensional folding is valid, check that all creases that might cross do not cross.
-
-	A "crease" is a convenient lie: it is a shorthand description of two leaves that are physically connected to each other.
-	Leaves in a one-dimensional folding are physically connected to at most two other leaves: the prior leaf and the next leaf.
-	When talking about a one-dimensional section of a multidimensional folding, we ignore the other dimension and still
-	reference the prior and next leaves. To check whether two creases cross, we must compare the four leaves of the two creases.
-
-	¹ A so-called one-dimensional folding, map, or strip of stamps has two dimensions, but one of the dimensions has a width of 1.
-
-	Idiosyncratic reasons for the design of this function
-	-----------------------------------------------------
-
-	I name the first leaf of the first crease `leaf`. I name the leaf to which I am comparing it `comparand`. A crease² is a leaf
-	and the next leaf, therefore, the crease of `leaf` connects it to `leafNextCrease`, and the crease of `comparand` connects it
-	to `comparandNextCrease`. Nearly everyone else uses letters for names, such as k, k+1, r, and r+1. (Which stand for Kahlo and
-	Rivera, of course.)
-
-	² "increase" from Latin *in-* "in" + *crescere* "to grow" (from PIE root ⋆ker- "to grow"). https://www.etymonline.com/word/increase
-
-	Computational reasons for the design of this function
-	-----------------------------------------------------
-
-	If `leaf` and `comparand` do not have matching parity in the dimension, then their creases cannot cross. To call this
-	function, you need `leaf` and `comparand`, and because determining parity-by-dimension is easiest when you first select `leaf`
-	and `comparand`, this function will not check the parity of `leaf` and `comparand`.
-
-	Computing the next leaf is not expensive, but 100,000,000 unnecessary but cheap computations is expensive. Therefore, instead of
-	passing `leafNextCrease` and `comparandNextCrease`, pass the functions by which those values may be computed on demand.
-
-	Finally, we need to compare the relative positions of the leaves, so pass a function that returns the position of the "next" leaf.
-
-	"""
-	if column < columnComparand:
-
-		comparandNextCrease: int | None = getComparandNextCrease()
-		if comparandNextCrease is None:
-			return False
-
-		leafNextCrease: int | None = getLeafNextCrease()
-		if leafNextCrease is None:
-			return False
-
-		columnComparandNextCrease: int | None = columnOf(comparandNextCrease)
-		if columnComparandNextCrease is None:
-			return False
-		columnLeafNextCrease: int | None = columnOf(leafNextCrease)
-		if columnLeafNextCrease is None:
-			return False
-
-		if columnComparandNextCrease < column:
-			if columnLeafNextCrease < columnComparandNextCrease:							# [k+1 < r+1 < k < r]
-				return True
-			return columnComparand < columnLeafNextCrease									# [r+1 < k < r < k+1]
-
-		if columnComparand < columnLeafNextCrease:
-			if columnLeafNextCrease < columnComparandNextCrease:							# [k < r < k+1 < r+1]
-				return True
-		elif column < columnComparandNextCrease < columnLeafNextCrease < columnComparand:	# [k < r+1 < k+1 < r]
-			return True
-	return False
-
-# ------- ad hoc computations -----------------------------
-# @cache
-def _dimensionsTotal(mapShape: tuple[int, ...]) -> int:
-	return len(mapShape)
-
-@cache
-def _leavesTotal(mapShape: tuple[int, ...]) -> int:
-	return getLeavesTotal(mapShape)
-
-# @cache
-def productOfDimensions(mapShape: tuple[int, ...], dimension: int) -> int:
-	return prod(mapShape[0:dimension])
-
-# ------- Functions for 'leaf', named 1, 2, ... n, not for 'indexLeaf' -------------
-
-@cache
-def ImaOddLeaf(mapShape: tuple[int, ...], leaf: int, dimension: int) -> int:
-	# NOTE `leaf-1` because `leaf` is not zero-based indexing.
-	return (((leaf-1) // productOfDimensions(mapShape, dimension)) % mapShape[dimension]) & 1
-
-def _matchingParityLeaf(mapShape: tuple[int, ...], leaf: int, comparand: int, dimension: int) -> bool:
-	return ImaOddLeaf(mapShape, leaf, dimension) == ImaOddLeaf(mapShape, comparand, dimension)
-
-@syntacticCurry
-def matchingParityLeaf(mapShape: tuple[int, ...]) -> Callable[[tuple[tuple[tuple[int, int], tuple[int, int]], int]], bool]:
-	def repack(aCartesianProduct: tuple[tuple[tuple[int, int], tuple[int, int]], int]) -> bool:
-		((_column, leaf), (_columnComparand, comparand)), dimension = aCartesianProduct
-		return _matchingParityLeaf(mapShape, leaf, comparand, dimension)
-	return repack
-
-@cache
-def nextCreaseLeaf(mapShape: tuple[int, ...], leaf: int, dimension: int) -> int | None:
-	leafNext: int | None = None
-	if (((leaf-1) // productOfDimensions(mapShape, dimension)) % mapShape[dimension]) + 1 < mapShape[dimension]:
-		leafNext = leaf + productOfDimensions(mapShape, dimension)
-	return leafNext
-
-inThis_pileOf = syntacticCurry(indexOf)
-
-def howToGetNextCreaseLeaf(mapShape: tuple[int, ...], leaf: int, dimension: int) -> Callable[[], int | None]:
-	return lambda: nextCreaseLeaf(mapShape, leaf, dimension)
-
-def thisLeafFoldingIsValid(folding: tuple[int, ...], mapShape: tuple[int, ...]) -> bool:
-	"""Return `True` if the folding is valid."""
-	foldingFiltered: filterfalse[tuple[int, int]] = filterfalse(lambda columnLeaf: columnLeaf[1] == _leavesTotal(mapShape), enumerate(folding)) # leafNPlus1 does not exist.
-	leafAndComparand: combinations[tuple[tuple[int, int], tuple[int, int]]] = combinations(foldingFiltered, 2)
-
-	leafAndComparandAcrossDimensions: CartesianProduct[tuple[tuple[tuple[int, int], tuple[int, int]], int]] = CartesianProduct(leafAndComparand, range(_dimensionsTotal(mapShape)))
-	parityInThisDimension: Callable[[tuple[tuple[tuple[int, int], tuple[int, int]], int]], bool] = matchingParityLeaf(mapShape)
-	leafAndComparandAcrossDimensionsFiltered: filter[tuple[tuple[tuple[int, int], tuple[int, int]], int]] = filter(parityInThisDimension, leafAndComparandAcrossDimensions)
-
-	return all(not thisIsAViolation(column, columnComparand, howToGetNextCreaseLeaf(mapShape, leaf, aDimension), howToGetNextCreaseLeaf(mapShape, comparand, aDimension), inThis_pileOf(folding))
-			for ((column, leaf), (columnComparand, comparand)), aDimension in leafAndComparandAcrossDimensionsFiltered)
-
-# ------- Functions for `indexLeaf`, named 0, 1, ... n-1, not for `leaf` -------------
-
-@cache
-def ImaOddIndexLeaf(mapShape: tuple[int, ...], indexLeaf: int, dimension: int) -> int:
-	return ((indexLeaf // productOfDimensions(mapShape, dimension)) % mapShape[dimension]) & 1
-
-def _matchingParityIndexLeaf(mapShape: tuple[int, ...], indexLeaf: int, comparand: int, dimension: int) -> bool:
-	return ImaOddIndexLeaf(mapShape, indexLeaf, dimension) == ImaOddIndexLeaf(mapShape, comparand, dimension)
-
-@syntacticCurry
-def matchingParityIndexLeaf(mapShape: tuple[int, ...]) -> Callable[[tuple[tuple[tuple[int, int], tuple[int, int]], int]], bool]:
-	def repack(aCartesianProduct: tuple[tuple[tuple[int, int], tuple[int, int]], int]) -> bool:
-		((_pile, indexLeaf), (_pileComparand, comparand)), dimension = aCartesianProduct
-		return _matchingParityIndexLeaf(mapShape, indexLeaf, comparand, dimension)
-	return repack
-
-@cache
-def nextCreaseIndexLeaf(mapShape: tuple[int, ...], indexLeaf: int, dimension: int) -> int | None:
-	indexLeafNext: int | None = None
-	if ((indexLeaf // productOfDimensions(mapShape, dimension)) % mapShape[dimension]) + 1 < mapShape[dimension]:
-		indexLeafNext = indexLeaf + productOfDimensions(mapShape, dimension)
-	return indexLeafNext
-
-inThis_pileOf = syntacticCurry(indexOf)
-
-def getNextCreaseIndexLeaf(mapShape: tuple[int, ...], indexLeaf: int, dimension: int) -> Callable[[], int | None]:
-	return lambda: nextCreaseIndexLeaf(mapShape, indexLeaf, dimension)
-
-def thisIndexLeafFoldingIsValid(folding: tuple[int, ...], mapShape: tuple[int, ...]) -> bool:
-	"""Return `True` if the folding is valid."""
-	foldingFiltered: filterfalse[tuple[int, int]] = filterfalse(lambda pileIndexLeaf: pileIndexLeaf[1] == _leavesTotal(mapShape) - 1, enumerate(folding)) # indexLeafNPlus1 does not exist.
-	indexLeafAndComparand: combinations[tuple[tuple[int, int], tuple[int, int]]] = combinations(foldingFiltered, 2)
-
-	indexLeafAndComparandAcrossDimensions: CartesianProduct[tuple[tuple[tuple[int, int], tuple[int, int]], int]] = CartesianProduct(indexLeafAndComparand, range(_dimensionsTotal(mapShape)))
-	parityInThisDimension: Callable[[tuple[tuple[tuple[int, int], tuple[int, int]], int]], bool] = matchingParityIndexLeaf(mapShape)
-	indexLeafAndComparandAcrossDimensionsFiltered: filter[tuple[tuple[tuple[int, int], tuple[int, int]], int]] = filter(parityInThisDimension, indexLeafAndComparandAcrossDimensions)
-
-	return all(not thisIsAViolation(pile, pileComparand, getNextCreaseIndexLeaf(mapShape, indexLeaf, aDimension), getNextCreaseIndexLeaf(mapShape, comparand, aDimension), inThis_pileOf(folding))
-			for ((pile, indexLeaf), (pileComparand, comparand)), aDimension in indexLeafAndComparandAcrossDimensionsFiltered)
-
-# ------- Functions for `indexLeaf` in `pinnedLeaves` dictionary, not for `leaf` in `folding` -------------
-
-def pinnedLeavesHasAViolation(state: EliminationState, indexLeaf: int) -> bool:
-	"""Return `True` if `state.pinnedLeaves` or the addition of `indexLeaf` at `state.pile` has a violation."""
-	pinnedLeaves: dict[int, int] = state.pinnedLeaves.copy()
-	pinnedLeaves[state.pile] = indexLeaf
-	indexLeaf2pile: dict[int, int] = {indexLeaf: pile for pile, indexLeaf in pinnedLeaves.items()}
-	pinnedLeavesFiltered: filterfalse[tuple[int, int]] = filterfalse(lambda pileIndexLeaf: pileIndexLeaf[1] == state.leavesTotal, pinnedLeaves.items()) # indexLeafNPlus1 does not exist.
-	indexLeafAndComparandAcrossDimensions = filter(matchingParityIndexLeaf(state.mapShape), CartesianProduct(combinations(pinnedLeavesFiltered, 2), range(state.dimensionsTotal)))
-	return any(thisIsAViolation(pile, pileComparand, getNextCreaseIndexLeaf(state.mapShape, indexLeaf, aDimension), getNextCreaseIndexLeaf(state.mapShape, comparand, aDimension), get(seq=indexLeaf2pile, default=None))
-			for ((pile, indexLeaf), (pileComparand, comparand)), aDimension in indexLeafAndComparandAcrossDimensions)