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

mapFolding/tests/test_computations.py

@@ -25,50 +25,65 @@ The `test_writeJobNumba` function shows how to test dynamically generated code,
 which is useful if you're working with the code synthesis features of the package.
 """
 
-from mapFolding import countFolds, dictionaryOEIS, dictionaryOEISMapFolding, eliminateFolds, getFoldsTotalKnown, oeisIDfor_n
-from mapFolding.basecamp import NOTcountingFolds
+from mapFolding import dictionaryOEIS, dictionaryOEISMapFolding, getFoldsTotalKnown, oeisIDfor_n
+from mapFolding.basecamp import countFolds, NOTcountingFolds
 from mapFolding.dataBaskets import MapFoldingState
 from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2
 from mapFolding.someAssemblyRequired.toolkitNumba import parametersNumbaLight
 from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds
-from mapFolding.tests.conftest import mapShapeTestCountFolds, registrarRecordsTemporaryFilesystemObject, standardizedEqualToCallableReturn
+from mapFolding.tests.conftest import registrarRecordsTemporaryFilesystemObject, standardizedEqualToCallableReturn
 from numba.core.errors import NumbaPendingDeprecationWarning
 from pathlib import Path, PurePosixPath
+from typing import TYPE_CHECKING
 import importlib.util
-import multiprocessing
 import pytest
 import warnings
 
-if __name__ == '__main__':
-	multiprocessing.set_start_method('spawn')
-
-@pytest.mark.parametrize('flow', ['algorithm', 'asynchronous',  'theorem2', 'theorem2Numba', 'theorem2Trimmed'])
-def test_A007822(flow: str) -> None:
+if TYPE_CHECKING:
+	from importlib.machinery import ModuleSpec
+	from mapFolding import MetadataOEISid, MetadataOEISidMapFolding
+	from types import ModuleType
+
+@pytest.mark.parametrize(
+	"oeisIdentifier, sequenceIndex, flow, processorLimit",
+	[
+		pytest.param("A007822", 4, "algorithm", 0.5, id="algorithm"),
+		pytest.param("A007822", 4, "asynchronous", 0.5, id="asynchronous"),
+		pytest.param("A007822", 4, "theorem2", 0.5, id="theorem2"),
+		pytest.param("A007822", 4, "theorem2Numba", 0.5, id="theorem2Numba"),
+		pytest.param("A007822", 4, "theorem2Trimmed", 0.5, id="theorem2Trimmed"),
+	],
+)
+def test_A007822(oeisIdentifier: str, sequenceIndex: int, flow: str, processorLimit: float) -> None:
 	"""Test A007822 flow options.
 
 	Parameters
 	----------
+	oeisIdentifier : str
+		OEIS identifier to validate.
+	sequenceIndex : int
+		Sequence index to validate.
 	flow : str
-		The computational flow algorithm to validate.
+		Computation flow to validate.
+	processorLimit : float
+		CPU limit for the computation.
 
 	"""
-	oeisID = 'A007822'
-	CPUlimit = .5
-	warnings.filterwarnings('ignore', category=NumbaPendingDeprecationWarning)
-	oeis_n = 2
-	for oeis_n in dictionaryOEIS[oeisID]['valuesTestValidation']:
-		if oeis_n < 2:
-			continue
-
-		expected = dictionaryOEIS[oeisID]['valuesKnown'][oeis_n]
-
-		standardizedEqualToCallableReturn(
-			expected
-			, NOTcountingFolds, oeisID, oeis_n, flow, CPUlimit
-			)
-
-@pytest.mark.parametrize('flow', ['daoOfMapFolding', 'numba', 'theorem2', 'theorem2Numba', 'theorem2Trimmed'])
-def test_countFolds(mapShapeTestCountFolds: tuple[int, ...], flow: str) -> None:
+	warnings.filterwarnings("ignore", category=NumbaPendingDeprecationWarning)
+	expected: int = dictionaryOEIS[oeisIdentifier]['valuesKnown'][sequenceIndex]
+	standardizedEqualToCallableReturn(expected, NOTcountingFolds, oeisIdentifier, sequenceIndex, flow, processorLimit)
+
+@pytest.mark.parametrize(
+	"oeisIdentifier, sequenceIndex, flow, processorLimit",
+	[
+		pytest.param("A000136", 3, "daoOfMapFolding", None, id="A000136::daoOfMapFolding"),
+		pytest.param("A001415", 3, "numba", None, id="A001415::numba"),
+		pytest.param("A001416", 3, "theorem2Numba", None, id="A001416::theorem2Numba"),
+		pytest.param("A001417", 3, "theorem2", None, id="A001417::theorem2"),
+		pytest.param("A001418", 3, "theorem2Trimmed", None, id="A001418::theorem2Trimmed"),
+	],
+)
+def test_countFolds(oeisIdentifier: str, sequenceIndex: int, flow: str, processorLimit: float | None) -> None:
 	"""Validate that different computational flows produce valid results.
 
 	(AI generated docstring)
@@ -82,31 +97,32 @@ def test_countFolds(mapShapeTestCountFolds: tuple[int, ...], flow: str) -> None:
 
 	Parameters
 	----------
-	mapShapeTestCountFolds : tuple[int, ...]
-		The map shape dimensions to test fold counting for.
+	oeisIdentifier : str
+		OEIS identifier to validate.
+	sequenceIndex : int
+		Sequence index to validate.
 	flow : str
-		The computational flow algorithm to validate.
+		Computation flow to validate.
+	processorLimit : float | None
+		CPU limit for the computation.
 
 	"""
-	standardizedEqualToCallableReturn(getFoldsTotalKnown(mapShapeTestCountFolds), countFolds, None, None, None, None, mapShapeTestCountFolds, flow)
-
-# @pytest.mark.parametrize('flow', ['constraintPropagation', 'elimination'])
-# def test_eliminateFolds(mapShapeTestParallelization: tuple[int, ...], flow: str) -> None:
-# 	"""Validate `eliminateFolds` and different flows produce valid results.
-
-# 	Parameters
-# 	----------
-# 	mapShapeTestCountFolds : tuple[int, ...]
-# 		The map shape dimensions to test fold counting for.
-# 	flow : str
-# 		The computational flow algorithm to validate.
-# 	"""
-# 	pathLikeWriteFoldsTotal: None = None
-# 	CPUlimit: bool | float | int | None = .25
-# 	standardizedEqualToCallableReturn(getFoldsTotalKnown(mapShapeTestParallelization), eliminateFolds, mapShapeTestParallelization, pathLikeWriteFoldsTotal, CPUlimit, flow)
-
-@pytest.mark.parametrize('flow', ['matrixMeanders', 'matrixNumPy', 'matrixPandas'])
-def test_meanders(oeisIDmeanders: str, flow: str) -> None:
+	mapShape: tuple[int, ...] = dictionaryOEISMapFolding[oeisIdentifier]['getMapShape'](sequenceIndex)
+	expected: int = dictionaryOEISMapFolding[oeisIdentifier]['valuesKnown'][sequenceIndex]
+	standardizedEqualToCallableReturn(expected, countFolds, None, None, None, processorLimit, mapShape, flow)
+
+@pytest.mark.parametrize(
+	"oeisIdentifier, sequenceIndex, flow",
+	[
+		pytest.param("A000682", 3, "matrixMeanders", id="A000682::matrixMeanders"),
+		pytest.param("A005316", 3, "matrixMeanders", id="A005316::matrixMeanders"),
+		pytest.param("A000682", 3, "matrixNumPy", id="A000682::matrixNumPy"),
+		pytest.param("A005316", 3, "matrixNumPy", id="A005316::matrixNumPy"),
+		pytest.param("A000682", 3, "matrixPandas", id="A000682::matrixPandas"),
+		pytest.param("A005316", 3, "matrixPandas", id="A005316::matrixPandas"),
+	],
+)
+def test_meanders(oeisIdentifier: str, sequenceIndex: int, flow: str) -> None:
 	"""Verify Meanders OEIS sequence value calculations against known reference values.
 
 	Tests the functions in `mapFolding.algorithms.oeisIDbyFormula` by comparing their
@@ -114,18 +130,39 @@ def test_meanders(oeisIDmeanders: str, flow: str) -> None:
 
 	Parameters
 	----------
-	oeisIDMeanders : str
-		The Meanders OEIS sequence identifier to test calculations for.
+	oeisIdentifier : str
+		OEIS identifier to validate.
+	sequenceIndex : int
+		Sequence index to validate.
+	flow : str
+		Computation flow to validate.
 
 	"""
-	dictionary = dictionaryOEISMapFolding if oeisIDmeanders in dictionaryOEISMapFolding else dictionaryOEIS
-	for n in dictionary[oeisIDmeanders]['valuesTestValidation']:
-		standardizedEqualToCallableReturn(
-			dictionary[oeisIDmeanders]['valuesKnown'][n]
-			, NOTcountingFolds, oeisIDmeanders, n, flow, None
-			)
-
-def test_NOTcountingFolds(oeisIDother: str) -> None:
+	dictionaryCurrent: dict[str, MetadataOEISidMapFolding] | dict[str, MetadataOEISid] = dictionaryOEISMapFolding if oeisIdentifier in dictionaryOEISMapFolding else dictionaryOEIS
+	expected: int = dictionaryCurrent[oeisIdentifier]['valuesKnown'][sequenceIndex]
+	standardizedEqualToCallableReturn(expected, NOTcountingFolds, oeisIdentifier, sequenceIndex, flow, None)
+
+@pytest.mark.parametrize(
+	"oeisIdentifier, sequenceIndex",
+	[
+		pytest.param("A000560", 3, id="A000560::n3"),
+		pytest.param("A000682", 3, id="A000682::n3"),
+		pytest.param("A001010", 3, id="A001010::n3"),
+		pytest.param("A001011", 3, id="A001011::n3"),
+		pytest.param("A005315", 3, id="A005315::n3"),
+		pytest.param("A005316", 3, id="A005316::n3"),
+		pytest.param("A007822", 3, id="A007822::n3"),
+		pytest.param("A060206", 3, id="A060206::n3"),
+		pytest.param("A077460", 3, id="A077460::n3"),
+		pytest.param("A078591", 3, id="A078591::n3"),
+		pytest.param("A086345", 3, id="A086345::n3"),
+		pytest.param("A178961", 3, id="A178961::n3"),
+		pytest.param("A223094", 3, id="A223094::n3"),
+		pytest.param("A259702", 3, id="A259702::n3"),
+		pytest.param("A301620", 3, id="A301620::n3"),
+	],
+)
+def test_NOTcountingFolds(oeisIdentifier: str, sequenceIndex: int) -> None:
 	"""Verify Meanders OEIS sequence value calculations against known reference values.
 
 	Tests the functions in `mapFolding.algorithms.oeisIDbyFormula` by comparing their
@@ -133,18 +170,28 @@ def test_NOTcountingFolds(oeisIDother: str) -> None:
 
 	Parameters
 	----------
-	oeisIDMeanders : str
-		The Meanders OEIS sequence identifier to test calculations for.
+	oeisIdentifier : str
+		OEIS identifier to validate.
+	sequenceIndex : int
+		Sequence index to validate.
 
 	"""
-	dictionary = dictionaryOEISMapFolding if oeisIDother in dictionaryOEISMapFolding else dictionaryOEIS
-	for n in dictionary[oeisIDother]['valuesTestValidation']:
-		standardizedEqualToCallableReturn(
-			dictionary[oeisIDother]['valuesKnown'][n]
-			, NOTcountingFolds, oeisIDother, n, None, None
-			)
-
-def test_oeisIDfor_n(oeisIDmapFolding: str) -> None:
+	dictionaryCurrent: dict[str, MetadataOEISidMapFolding] | dict[str, MetadataOEISid] = dictionaryOEISMapFolding if oeisIdentifier in dictionaryOEISMapFolding else dictionaryOEIS
+	expected: int = dictionaryCurrent[oeisIdentifier]['valuesKnown'][sequenceIndex]
+	standardizedEqualToCallableReturn(expected, NOTcountingFolds, oeisIdentifier, sequenceIndex, None, None)
+
+@pytest.mark.parametrize(
+	"oeisIdentifier, sequenceIndex",
+	[
+		pytest.param("A000136", 3, id="A000136::n3"),
+		pytest.param("A001415", 3, id="A001415::n3"),
+		pytest.param("A001416", 3, id="A001416::n3"),
+		pytest.param("A001417", 3, id="A001417::n3"),
+		pytest.param("A001418", 3, id="A001418::n3"),
+		pytest.param("A195646", 2, id="A195646::n2"),
+	],
+)
+def test_oeisIDfor_n(oeisIdentifier: str, sequenceIndex: int) -> None:
 	"""Verify OEIS sequence value calculations against known reference values.
 
 	Tests the `oeisIDfor_n` function by comparing its calculated output against
@@ -157,12 +204,19 @@ def test_oeisIDfor_n(oeisIDmapFolding: str) -> None:
 
 	Parameters
 	----------
-	oeisID : str
-		The OEIS sequence identifier to test calculations for.
+	oeisIdentifier : str
+		OEIS identifier to validate.
+	sequenceIndex : int
+		Sequence index to validate.
 
 	"""
-	for n in dictionaryOEISMapFolding[oeisIDmapFolding]['valuesTestValidation']:
-		standardizedEqualToCallableReturn(dictionaryOEISMapFolding[oeisIDmapFolding]['valuesKnown'][n], oeisIDfor_n, oeisIDmapFolding, n)
+	expected: int = dictionaryOEISMapFolding[oeisIdentifier]['valuesKnown'][sequenceIndex]
+	standardizedEqualToCallableReturn(expected, oeisIDfor_n, oeisIdentifier, sequenceIndex)
+
+@pytest.fixture
+def oneTestCuzTestsOverwritingTests() -> tuple[int, ...]: # NOTE TO AI: DO NOT CHANGE THIS IDENTIFIER NAME.
+	"""Return one deterministic map shape suitable for code generation tests."""
+	return dictionaryOEISMapFolding["A000136"]["getMapShape"](3)
 
 @pytest.mark.parametrize('pathFilename_tmpTesting', ['.py'], indirect=True)
 def test_writeJobNumba(oneTestCuzTestsOverwritingTests: tuple[int, ...], pathFilename_tmpTesting: Path) -> None:
@@ -188,11 +242,11 @@ def test_writeJobNumba(oneTestCuzTestsOverwritingTests: tuple[int, ...], pathFil
 	"""
 	from mapFolding.someAssemblyRequired.makeJobTheorem2Numba import makeJobNumba  # noqa: PLC0415
 	from mapFolding.someAssemblyRequired.toolkitNumba import SpicesJobNumba  # noqa: PLC0415
-	mapShape = oneTestCuzTestsOverwritingTests
-	state = transitionOnGroupsOfFolds(MapFoldingState(mapShape))
+	mapShape: tuple[int, ...] = oneTestCuzTestsOverwritingTests
+	state: MapFoldingState = transitionOnGroupsOfFolds(MapFoldingState(mapShape))
 
-	pathFilenameModule = pathFilename_tmpTesting.absolute()
-	pathFilenameFoldsTotal = pathFilenameModule.with_suffix('.foldsTotalTesting')
+	pathFilenameModule: Path = pathFilename_tmpTesting.absolute()
+	pathFilenameFoldsTotal: Path = pathFilenameModule.with_suffix('.foldsTotalTesting')
 	registrarRecordsTemporaryFilesystemObject(pathFilenameFoldsTotal)
 
 	jobTest = RecipeJobTheorem2(state
@@ -202,14 +256,14 @@ def test_writeJobNumba(oneTestCuzTestsOverwritingTests: tuple[int, ...], pathFil
 	spices = SpicesJobNumba(useNumbaProgressBar=False, parametersNumba=parametersNumbaLight)
 	makeJobNumba(jobTest, spices)
 
-	Don_Lapre_Road_to_Self_Improvement = importlib.util.spec_from_file_location("__main__", pathFilenameModule)
+	Don_Lapre_Road_to_Self_Improvement: ModuleSpec | None = importlib.util.spec_from_file_location("__main__", pathFilenameModule)
 	if Don_Lapre_Road_to_Self_Improvement is None:
-		message = f"Failed to create module specification from {pathFilenameModule}"
+		message: str = f"Failed to create module specification from {pathFilenameModule}"
 		raise ImportError(message)
 	if Don_Lapre_Road_to_Self_Improvement.loader is None:
 		message = f"Failed to get loader for module {pathFilenameModule}"
 		raise ImportError(message)
-	module = importlib.util.module_from_spec(Don_Lapre_Road_to_Self_Improvement)
+	module: ModuleType = importlib.util.module_from_spec(Don_Lapre_Road_to_Self_Improvement)
 
 	module.__name__ = "__main__"
 	Don_Lapre_Road_to_Self_Improvement.loader.exec_module(module)

mapFolding/tests/test_e_computations.py

@@ -0,0 +1,42 @@
+from mapFolding import dictionaryOEISMapFolding
+from mapFolding._e.basecamp import eliminateFolds
+from mapFolding.tests.conftest import standardizedEqualToCallableReturn
+import pytest
+
+@pytest.mark.parametrize(
+	"oeisID, n, flow, CPUlimit",
+	[
+		pytest.param("A001417", 4, "crease", 0.25),
+
+		pytest.param("A000136", 5, "constraintPropagation", 0.25),
+		pytest.param("A001415", 5, "constraintPropagation", 0.25),
+		pytest.param("A001416", 4, "constraintPropagation", 0.25),
+		pytest.param("A001417", 4, "constraintPropagation", 0.25),
+		pytest.param("A001418", 3, "constraintPropagation", 0.25),
+		pytest.param("A195646", 2, "constraintPropagation", 0.25),
+		# *[pytest.param(oeisID, metadata["offset"], flow, 1)
+		# 	for oeisID, metadata in dictionaryOEISMapFolding.items()
+		# 		for flow in ["elimination"]]
+
+
+	],
+)
+def test_eliminateFoldsMapShape(oeisID: str, n: int, flow: str, CPUlimit: float) -> None:
+	"""Validate `eliminateFolds` and different flows produce valid results.
+
+	Parameters
+	----------
+	oeisID : str
+		OEIS identifier to validate.
+	sequenceIndex : int
+		Sequence index to validate.
+	flow : str
+		Computation flow to validate.
+	processorLimit : float
+		CPU limit for the computation.
+	"""
+	mapShape: tuple[int, ...] = dictionaryOEISMapFolding[oeisID]["getMapShape"](n)
+	state = None
+	pathLikeWriteFoldsTotal: None = None
+	expected: int = dictionaryOEISMapFolding[oeisID]['valuesKnown'][n]
+	standardizedEqualToCallableReturn(expected, eliminateFolds, mapShape, state, pathLikeWriteFoldsTotal, CPUlimit, flow)

mapFolding/tests/test_e_dataDynamic.py

@@ -0,0 +1,189 @@
+"""Tests for elimination algorithm data functions.
+
+These tests verify the correctness of functions in `mapFolding._e._data` that compute
+leaf domains, pile ranges, and addend dictionaries for map folding elimination algorithms.
+
+The test data is stored in `tests/dataSamples/A001417.py` and supports multiple `mapShape`
+configurations. Currently, data exists for:
+- (2,)*4 → 16 leaves (2d4)
+- (2,)*5 → 32 leaves (2d5)
+- (2,)*6 → 64 leaves (2d6)
+
+When adding new test data for additional `mapShape` values, add the data to `A001417.py`
+and the tests will automatically pick them up via parametrization.
+"""
+
+from collections.abc import Callable, Iterable, Sequence
+from mapFolding._e import (
+	getDictionaryLeafDomains, getDictionaryPileRanges, getDomainDimension一, getDomainDimension二, getDomainDimension首二,
+	getDomain二一零and二一, getDomain二零and二, getDomain首零一二and首一二, getDomain首零二and首二, getLeafDomain, getLeavesCreaseAnte,
+	getLeavesCreasePost, getPileRange)
+from mapFolding._e.dataBaskets import EliminationState
+from mapFolding.tests.dataSamples import (
+	A001417, p2DnDomain3_2_首一_首零一, p2DnDomain5_4, p2DnDomain6_7_5_4, p2DnDomain7_6, p2DnDomain首二_首零二_首零一二_首一二,
+	p2DnDomain首零一二_首一二, p2DnDomain首零二_首二)
+from more_itertools import all_unique, unique_to_each
+from types import ModuleType
+import pytest
+
+@pytest.mark.parametrize("mapShape", list(A001417.dictionaryLeafDomainKnown), ids=[f"mapShape={shape}" for shape in A001417.dictionaryLeafDomainKnown])
+def test_getDictionaryLeafDomains(mapShape: tuple[int, ...]) -> None:
+	"""Verify getDictionaryLeafDomains against authoritative leaf domain data for all leaves."""
+	state = EliminationState(mapShape=mapShape)
+	dictionaryLeafDomainsAuthoritativeData = A001417.dictionaryLeafDomainKnown[mapShape]
+
+	dictionaryLeafDomainsActual = getDictionaryLeafDomains(state)
+
+	assert len(dictionaryLeafDomainsActual) == state.leavesTotal, (
+		f"getDictionaryLeafDomains: dictionary length {len(dictionaryLeafDomainsActual)} != {state.leavesTotal} for {mapShape=}."
+	)
+
+	for leaf in range(state.leavesTotal):
+		rangeActual = dictionaryLeafDomainsActual[leaf]
+		startAuthoritativeData, stopAuthoritativeData, stepAuthoritativeData = dictionaryLeafDomainsAuthoritativeData[leaf]
+		assert rangeActual.start == startAuthoritativeData, (
+			f"getDictionaryLeafDomains: range.start mismatch at {leaf=} for {mapShape=}. "
+			f"Expected {startAuthoritativeData}, got {rangeActual.start}."
+		)
+		assert rangeActual.stop == stopAuthoritativeData, (
+			f"getDictionaryLeafDomains: range.stop mismatch at {leaf=} for {mapShape=}. "
+			f"Expected {stopAuthoritativeData}, got {rangeActual.stop}."
+		)
+		assert rangeActual.step == stepAuthoritativeData, (
+			f"getDictionaryLeafDomains: range.step mismatch at {leaf=} for {mapShape=}. "
+			f"Expected {stepAuthoritativeData}, got {rangeActual.step}."
+		)
+
+@pytest.mark.parametrize("mapShape", list(A001417.dictionaryPileRangesKnown), ids=[f"mapShape={shape}" for shape in A001417.dictionaryPileRangesKnown])
+def test_getDictionaryPileRanges(mapShape: tuple[int, ...]) -> None:
+	"""Verify getDictionaryPileRanges against authoritative pile range data for all piles."""
+	state = EliminationState(mapShape=mapShape)
+	dictionaryPileRangesAuthoritativeData = A001417.dictionaryPileRangesKnown[mapShape]
+
+	dictionaryPileRangesActual = getDictionaryPileRanges(state)
+
+	assert len(dictionaryPileRangesActual) == state.leavesTotal, (
+		f"getDictionaryPileRanges: dictionary length {len(dictionaryPileRangesActual)} != {state.leavesTotal} for {mapShape=}."
+	)
+
+	for pile in range(state.leavesTotal):
+		assert dictionaryPileRangesActual[pile] == dictionaryPileRangesAuthoritativeData[pile], (
+			f"getDictionaryPileRanges: mismatch at {pile=} for {mapShape=}. "
+			f"Expected {dictionaryPileRangesAuthoritativeData[pile]}, got {dictionaryPileRangesActual[pile]}."
+		)
+
+@pytest.mark.parametrize("mapShape", list(A001417.dictionaryLeafDomainKnown), ids=[f"mapShape={shape}" for shape in A001417.dictionaryLeafDomainKnown])
+def test_getLeafDomain(mapShape: tuple[int, ...]) -> None:
+	"""Verify getLeafDomain against authoritative leaf domain data for all leaves."""
+	state = EliminationState(mapShape=mapShape)
+	dictionaryLeafDomainsAuthoritativeData = A001417.dictionaryLeafDomainKnown[mapShape]
+
+	for leaf in range(state.leavesTotal):
+		rangeActual = getLeafDomain(state, leaf)
+		startAuthoritativeData, stopAuthoritativeData, stepAuthoritativeData = dictionaryLeafDomainsAuthoritativeData[leaf]
+		assert rangeActual.start == startAuthoritativeData, (
+			f"getLeafDomain: range.start mismatch at {leaf=} for {mapShape=}. "
+			f"Expected {startAuthoritativeData}, got {rangeActual.start}."
+		)
+		assert rangeActual.stop == stopAuthoritativeData, (
+			f"getLeafDomain: range.stop mismatch at {leaf=} for {mapShape=}. "
+			f"Expected {stopAuthoritativeData}, got {rangeActual.stop}."
+		)
+		assert rangeActual.step == stepAuthoritativeData, (
+			f"getLeafDomain: range.step mismatch at {leaf=} for {mapShape=}. "
+			f"Expected {stepAuthoritativeData}, got {rangeActual.step}."
+		)
+
+@pytest.mark.parametrize("dimensionsTotal", [5, 6], ids=lambda dimensionsTotal: f"2d{dimensionsTotal}")
+@pytest.mark.parametrize("domainFunction,moduleAuthoritativeData", [
+	(getDomainDimension一, p2DnDomain3_2_首一_首零一),
+	(getDomainDimension二, p2DnDomain6_7_5_4),
+	(getDomainDimension首二, p2DnDomain首二_首零二_首零一二_首一二),
+	(getDomain二一零and二一, p2DnDomain7_6),
+	(getDomain二零and二, p2DnDomain5_4),
+	(getDomain首零一二and首一二, p2DnDomain首零一二_首一二),
+	(getDomain首零二and首二, p2DnDomain首零二_首二),
+], ids=lambda domainFunction: domainFunction.__name__)
+def test_getLeafDomainsCombined(domainFunction: Callable[[EliminationState], Sequence[tuple[int, ...]]], moduleAuthoritativeData: ModuleType, dimensionsTotal: int) -> None:
+	"""Verify combined domain function against authoritative dataset: completeness, uniqueness, correctness."""
+	mapShape: tuple[int, ...] = (2,) * dimensionsTotal
+	state = EliminationState(mapShape=mapShape)
+	tuplesDomainActual: tuple[tuple[int, ...], ...] = tuple(domainFunction(state))
+	tuplesDomainAuthoritativeData: tuple[tuple[int, ...], ...] = getattr(moduleAuthoritativeData, f"listDomain2D{dimensionsTotal}")
+
+	tuplesMissingFromActual, tuplesExtraInActual = unique_to_each(tuplesDomainAuthoritativeData, tuplesDomainActual)
+	tuplesMissingFromActual = tuple(tuplesMissingFromActual)
+	tuplesExtraInActual = tuple(tuplesExtraInActual)
+	hasAllUnique: bool = all_unique(tuplesDomainActual)
+
+	assert hasAllUnique, (
+		f"{domainFunction.__name__}: returned duplicate tuples for {mapShape=}."
+	)
+	assert len(tuplesMissingFromActual) == 0, (
+		f"{domainFunction.__name__}: missing {len(tuplesMissingFromActual)} tuples from authoritative data for {mapShape=}. "
+		f"Missing samples: {sorted(tuplesMissingFromActual)[:3]}"
+	)
+	assert len(tuplesExtraInActual) == 0, (
+		f"{domainFunction.__name__}: returned {len(tuplesExtraInActual)} tuples not in authoritative data for {mapShape=}. "
+		f"Extra samples: {sorted(tuplesExtraInActual)[:3]}"
+	)
+
+@pytest.mark.parametrize("mapShape", list(A001417.dictionaryPileRangesKnown), ids=[f"mapShape={shape}" for shape in A001417.dictionaryPileRangesKnown])
+def test_getPileRange(mapShape: tuple[int, ...]) -> None:
+	"""Verify getPileRange against authoritative pile range data for all piles."""
+	state = EliminationState(mapShape=mapShape)
+	dictionaryPileRangesAuthoritativeData: dict[int, tuple[int, ...]] = A001417.dictionaryPileRangesKnown[mapShape]
+
+	for pile in range(state.leavesTotal):
+		tupleLeavesPileActual: tuple[int, ...] = tuple(getPileRange(state, pile))
+		tupleLeavesPileAuthoritativeData: tuple[int, ...] = dictionaryPileRangesAuthoritativeData[pile]
+
+		assert tupleLeavesPileActual == tupleLeavesPileAuthoritativeData, (
+			f"getPileRange: mismatch at {pile=} for {mapShape=}. "
+			f"Expected {tupleLeavesPileAuthoritativeData}, got {tupleLeavesPileActual}."
+		)
+
+@pytest.mark.parametrize("dimensionsTotal", [5, 6], ids=lambda dimensionsTotal: f"2d{dimensionsTotal}")
+@pytest.mark.parametrize(
+	"creaseKind,creaseFunction,dictionaryExpectedByMapShape",
+	[
+		("increase", getLeavesCreasePost, A001417.dictionaryCreasesIncreaseKnown),
+		("decrease", getLeavesCreaseAnte, A001417.dictionaryCreasesDecreaseKnown),
+	],
+	ids=["increase", "decrease"],
+)
+def test_getLeavesCrease(creaseKind: str, creaseFunction: Callable[[EliminationState, int], Iterable[int]], dictionaryExpectedByMapShape: dict[tuple[int, ...], dict[int, list[int]]], dimensionsTotal: int) -> None:
+	mapShape: tuple[int, ...] = (2,) * dimensionsTotal
+	state: EliminationState = EliminationState(mapShape=mapShape)
+	dictionaryExpectedByLeaf: dict[int, list[int]] = dictionaryExpectedByMapShape[mapShape]
+
+	for leaf in range(state.leavesTotal):
+		listLeavesActual: list[int] = list(creaseFunction(state, leaf))
+		listLeavesExpectedSorted: list[int] = dictionaryExpectedByLeaf[leaf]
+
+		assert sorted(listLeavesActual) == listLeavesExpectedSorted, (
+			f"{creaseFunction.__name__} ({creaseKind}): mismatch for {mapShape=}, {leaf=}. "
+			f"Expected(sorted)={listLeavesExpectedSorted}, got(sorted)={sorted(listLeavesActual)}."
+		)
+
+		assert all_unique(listLeavesActual), (
+			f"{creaseFunction.__name__} ({creaseKind}): duplicates found for {mapShape=}, {leaf=}. "
+			f"Actual={listLeavesActual}."
+		)
+
+		for leafPost in listLeavesActual:
+			assert 0 <= leafPost < state.leavesTotal, (
+				f"{creaseFunction.__name__} ({creaseKind}): out-of-range value for {mapShape=}, {leaf=}. "
+				f"Got {leafPost}, expected 0 <= leafPost < {state.leavesTotal}."
+			)
+			bitFlip: int = leaf ^ leafPost
+			assert (bitFlip > 0) and ((bitFlip & (bitFlip - 1)) == 0), (
+				f"{creaseFunction.__name__} ({creaseKind}): expected one-bit flip for {mapShape=}, {leaf=}. "
+				f"Got {leafPost=}, {bitFlip=} (leaf^leafPost)."
+			)
+
+		listBitFlips: list[int] = [leaf ^ leafPost for leafPost in listLeavesActual]
+		assert listBitFlips == sorted(listBitFlips), (
+			f"{creaseFunction.__name__} ({creaseKind}): expected bit flips in increasing dimension order for {mapShape=}, {leaf=}. "
+			f"Got bit flips {listBitFlips}."
+		)