mapFolding 0.15.4__py3-none-any.whl → 0.16.0__py3-none-any.whl

mapFolding/reference/matrixMeandersAnalysis/evenEven.py

@@ -0,0 +1,144 @@
+"""
+Matrix Meanders Buckets Estimation Formula.
+
+This module provides a function to estimate the number of buckets in matrix meanders
+analysis based on parameters n and k. The formula was derived through regression
+analysis on empirical data and achieves an R² score of 0.9978.
+
+Author: Generated from Jupyter notebook analysis
+Date: September 2025
+"""
+import math
+
+def estimateBucketsFromParametersNandK(parameterN: int, parameterK: int) -> float:
+    """
+    Estimate the number of buckets in matrix meanders analysis based on parameters n and k.
+
+    This function implements a log-polynomial regression model derived from empirical data analysis
+    of matrix meanders with even-even configurations. The model was trained on 34 data points
+    and achieved an R² score of 0.9978, indicating excellent predictive performance.
+
+    The underlying formula is:
+    buckets = exp(0.087760 + 0.447340*n - 0.058715*k - 0.014116*n² + 0.072333*n*k - 0.090631*k²) - 1
+
+    Parameters
+    ----------
+    parameterN : int
+        The n parameter (must be positive integer, typically even)
+    parameterK : int
+        The k parameter (must be positive integer, typically even)
+
+    Returns
+    -------
+    float
+        Estimated number of buckets
+
+    Raises
+    ------
+    ValueError
+        If parameterN or parameterK are not positive integers
+
+    Example:
+    --------
+    >>> estimateBucketsFromParametersNandK(20, 10)
+    3656.4
+    >>> estimateBucketsFromParametersNandK(44, 22)
+    32715318.1
+
+    Notes
+    -----
+    This formula is based on empirical data and is most accurate for values
+    within the training range (n: 4-44, k: 2-22). Extrapolation beyond this
+    range should be done with caution.
+
+    The underlying mathematical relationship shows that buckets grow exponentially
+    with both n and k, with complex polynomial interactions captured in the logarithmic space.
+
+    Performance Metrics:
+    - R² Score: 0.9978
+    - Mean Absolute Error: 4.02% across all training examples
+    - Median Error: 2.69%
+    - Maximum Error: 18.86% (on smallest values)
+    """
+    # Input validation
+    if not isinstance(parameterN, int) or parameterN <= 0:
+        raise ValueError(f"parameterN must be a positive integer, got {parameterN}")
+    if not isinstance(parameterK, int) or parameterK <= 0:
+        raise ValueError(f"parameterK must be a positive integer, got {parameterK}")
+
+    # Convert to float for calculations
+    n = float(parameterN)
+    k = float(parameterK)
+
+    # Log-polynomial formula coefficients (derived from regression analysis)
+    # Formula: log(buckets + 1) = intercept + c1*n + c2*k + c3*n² + c4*n*k + c5*k²
+    interceptValue = 0.087760
+    coefficientN = 0.447340
+    coefficientK = -0.058715
+    coefficientNSquared = -0.014116
+    coefficientNTimesK = 0.072333
+    coefficientKSquared = -0.090631
+
+    # Calculate log(buckets + 1)
+    logBucketsPlusOne = (interceptValue +
+                        coefficientN * n +
+                        coefficientK * k +
+                        coefficientNSquared * (n * n) +
+                        coefficientNTimesK * (n * k) +
+                        coefficientKSquared * (k * k))
+
+    # Transform back to original scale: buckets = exp(log(buckets + 1)) - 1
+    estimatedBuckets = math.exp(logBucketsPlusOne) - 1.0
+
+    return max(0.0, estimatedBuckets)  # Ensure non-negative result
+
+
+def validateFormulaAccuracy() -> None:
+    """
+    Validate the formula against known test cases from the training data.
+
+    This function demonstrates the accuracy of the formula by testing it
+    against several known data points from the original dataset.
+    """
+    # Test cases from the original dataset (n, k, expected_buckets)
+    testCases = [
+        (4, 2, 4),
+        (20, 10, 3592),
+        (36, 18, 1666843),
+        (44, 22, 35674291)
+    ]
+
+    print("Formula Validation Results:")
+    print("-" * 50)
+    print(f"{'n':<4} {'k':<4} {'Expected':<12} {'Predicted':<12} {'Error %':<8}")
+    print("-" * 50)
+
+    totalError = 0.0
+    for n, k, expected in testCases:
+        predicted = estimateBucketsFromParametersNandK(n, k)
+        error = abs((expected - predicted) / expected) * 100
+        totalError += error
+
+        # Format large numbers appropriately
+        expectedStr = f"{expected:.0f}" if expected < 1e6 else f"{expected:.2e}"
+        predictedStr = f"{predicted:.1f}" if predicted < 1e6 else f"{predicted:.2e}"
+
+        print(f"{n:<4} {k:<4} {expectedStr:<12} {predictedStr:<12} {error:<8.1f}")
+
+    avgError = totalError / len(testCases)
+    print("-" * 50)
+    print(f"Average Error: {avgError:.2f}%")
+
+
+if __name__ == "__main__":
+    # Run validation when script is executed directly
+    validateFormulaAccuracy()
+
+    # Demonstrate usage
+    print("\nUsage Examples:")
+    print("-" * 30)
+
+    examples = [(8, 4), (20, 10), (36, 18)]
+    for n, k in examples:
+        result = estimateBucketsFromParametersNandK(n, k)
+        print(f"estimateBucketsFromParametersNandK({n}, {k}) = {result:.1f}")

mapFolding/reference/matrixMeandersAnalysis/oddEven.py

@@ -0,0 +1,54 @@
+from math import exp as math_exp, log as math_log
+
+def estimateBuckets(n: int, k: int) -> float:
+    """Estimate the number of buckets for given integers n and k.
+
+    Model form (log-space):
+        log(estimate) = a
+            + b * log(n)
+            + c * log(k)
+            + d * log(n)*log(k)
+            + e * (k / n)
+            + f * (n / k)
+
+    Coefficients were obtained via ordinary least squares fit on log(buckets)
+    using the dataset in df_oddEven.csv (38 observations). The regression achieved
+    R^2 ≈ {coefficient_determination:.5f} (log space) with MAPE ≈ {mean_absolute_percentage_error:.2f}% on training data.
+
+    NOTE: This is an empirical approximation; extrapolation outside the range
+    n ∈ [{min(n_values)}, {max(n_values)}], k ∈ [{min(k_values)}, {max(k_values)}] may be unreliable.
+
+    Parameters
+    ----------
+    n : int
+        Primary size parameter (must be > 0)
+    k : int
+        Secondary size parameter (must be > 0)
+
+    Returns
+    -------
+    float
+        Estimated bucket count (positive real number). Caller may round if an
+        integer is desired.
+    """
+    if not isinstance(n, int) or n <= 0:
+        raise ValueError(f'allegedInt n must be positive int, got {n!r}')
+    if not isinstance(k, int) or k <= 0:
+        raise ValueError(f'allegedInt k must be positive int, got {k!r}')
+
+    a = -679.088264366881
+    b =  864.829109159972
+    c = -873.871846814867
+    d =    3.487829177620
+    e =  943.512567960048
+    f = -193.640628682536
+
+    ln_n = math_log(n)
+    ln_k = math_log(k)
+    value_log = (a
+                 + b * ln_n
+                 + c * ln_k
+                 + d * ln_n * ln_k
+                 + e * (k / n)
+                 + f * (n / k))
+    return math_exp(value_log)

mapFolding/someAssemblyRequired/A007822/A007822rawMaterials.py

@@ -0,0 +1,55 @@
+from astToolkit import extractFunctionDef, Make  # noqa: D100
+from hunterMakesPy import raiseIfNone
+from mapFolding.someAssemblyRequired import (
+	identifierCallableSourceDEFAULT, identifierCallableSourceDispatcherDEFAULT, identifierCountingDEFAULT,
+	identifierDataclassInstanceDEFAULT, logicalPathInfixDEFAULT)
+import ast
+
+identifierDataclass: str = identifierDataclassInstanceDEFAULT
+identifierCounting: str = identifierCountingDEFAULT
+logicalPathInfixA007822: str = logicalPathInfixDEFAULT + '.A007822'
+sourceCallableDispatcherA007822: str = identifierCallableSourceDispatcherDEFAULT
+sourceCallableIdentifierA007822: str = identifierCallableSourceDEFAULT
+
+identifier_filterAsymmetricFolds = 'filterAsymmetricFolds'
+
+ImaString = f"""
+def {identifier_filterAsymmetricFolds}({identifierDataclass}: MapFoldingState) -> MapFoldingState:
+	{identifierDataclass}.indexLeaf = 0
+	leafConnectee = 0
+	while leafConnectee < {identifierDataclass}.leavesTotal + 1:
+		leafNumber = int({identifierDataclass}.leafBelow[{identifierDataclass}.indexLeaf])
+		{identifierDataclass}.leafComparison[leafConnectee] = (leafNumber - {identifierDataclass}.indexLeaf + {identifierDataclass}.leavesTotal) % {identifierDataclass}.leavesTotal
+		{identifierDataclass}.indexLeaf = leafNumber
+		leafConnectee += 1
+
+	indexInMiddle = {identifierDataclass}.leavesTotal // 2
+	{identifierDataclass}.indexMiniGap = 0
+	while {identifierDataclass}.indexMiniGap < {identifierDataclass}.leavesTotal + 1:
+		ImaSymmetricFold = True
+		leafConnectee = 0
+		while leafConnectee < indexInMiddle:
+			if {identifierDataclass}.leafComparison[({identifierDataclass}.indexMiniGap + leafConnectee) % ({identifierDataclass}.leavesTotal + 1)] != {identifierDataclass}.leafComparison[({identifierDataclass}.indexMiniGap + {identifierDataclass}.leavesTotal - 1 - leafConnectee) % ({identifierDataclass}.leavesTotal + 1)]:
+				ImaSymmetricFold = False
+				break
+			leafConnectee += 1
+		if ImaSymmetricFold:
+			{identifierDataclass}.{identifierCounting} += 1
+		{identifierDataclass}.indexMiniGap += 1
+
+	return {identifierDataclass}
+"""  # noqa: E501
+
+FunctionDef_filterAsymmetricFolds: ast.FunctionDef = raiseIfNone(extractFunctionDef(ast.parse(ImaString), identifier_filterAsymmetricFolds))
+del ImaString
+
+ImaString = f"{identifierDataclass} = {identifier_filterAsymmetricFolds}({identifierDataclass})"
+A007822incrementCount = ast.parse(ImaString).body[0]
+del ImaString
+
+ImaString = f'{identifierDataclass}.{identifierCounting} = ({identifierDataclass}.{identifierCounting} + 1) // 2'
+A007822adjustFoldsTotal = ast.parse(ImaString).body[0]
+del ImaString
+
+astExprCall_filterAsymmetricFoldsDataclass: ast.Expr = Make.Expr(Make.Call(Make.Name(identifier_filterAsymmetricFolds), listParameters=[Make.Attribute(Make.Name(identifierDataclass), 'leafBelow')]))
+astExprCall_filterAsymmetricFoldsLeafBelow: ast.Expr = Make.Expr(Make.Call(Make.Name(identifier_filterAsymmetricFolds), listParameters=[Make.Name('leafBelow')]))

mapFolding/someAssemblyRequired/A007822/makeA007822AsynchronousModules.py

@@ -0,0 +1,185 @@
+"""addSymmetryCheckAsynchronous."""
+from astToolkit import Be, extractFunctionDef, Grab, Make, NodeChanger, NodeTourist, parsePathFilename2astModule, Then
+from hunterMakesPy import raiseIfNone
+from mapFolding import packageSettings
+from mapFolding.someAssemblyRequired import IfThis, logicalPathInfixAlgorithmDEFAULT
+from mapFolding.someAssemblyRequired.A007822.A007822rawMaterials import (
+	A007822adjustFoldsTotal, astExprCall_filterAsymmetricFoldsDataclass, identifier_filterAsymmetricFolds,
+	identifierCounting, identifierDataclass, logicalPathInfixA007822, sourceCallableDispatcherA007822,
+	sourceCallableIdentifierA007822)
+from mapFolding.someAssemblyRequired.makingModules_count import makeTheorem2, numbaOnTheorem2, trimTheorem2
+from mapFolding.someAssemblyRequired.toolkitMakeModules import getModule, getPathFilename, write_astModule
+from os import PathLike
+from pathlib import PurePath
+import ast
+
+identifier_initializeConcurrencyManager = 'initializeConcurrencyManager'
+
+astExprCall_initializeConcurrencyManager = Make.Expr(Make.Call(Make.Name(identifier_initializeConcurrencyManager)))
+identifier_getAsymmetricFoldsTotal = 'getAsymmetricFoldsTotal'
+AssignTotal2CountingIdentifier: ast.Assign = Make.Assign(
+	[Make.Attribute(Make.Name(identifierDataclass), identifierCounting, context=Make.Store())]
+	, value=Make.Call(Make.Name(identifier_getAsymmetricFoldsTotal))
+)
+identifier_processCompletedFutures = '_processCompletedFutures'
+
+def addSymmetryCheckAsynchronous(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: PathLike[str] | PurePath | str | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
+	"""Add symmetry check to the counting function."""
+	astFunctionDef_count: ast.FunctionDef = raiseIfNone(NodeTourist(
+		findThis = Be.FunctionDef.nameIs(IfThis.isIdentifier(sourceCallableIdentifierA007822))
+		, doThat = Then.extractIt
+		).captureLastMatch(astModule))
+
+	NodeChanger(Be.Return, Then.insertThisAbove([A007822adjustFoldsTotal])).visit(astFunctionDef_count)
+
+	NodeChanger(
+		findThis=Be.AugAssign.targetIs(IfThis.isAttributeNamespaceIdentifier(identifierDataclass, identifierCounting))
+		, doThat=Then.replaceWith(astExprCall_filterAsymmetricFoldsDataclass)
+		).visit(astFunctionDef_count)
+
+	NodeChanger(
+		findThis=Be.While.testIs(IfThis.isCallIdentifier('activeLeafGreaterThan0'))
+		, doThat=Grab.orelseAttribute(Then.replaceWith([AssignTotal2CountingIdentifier]))
+	).visit(astFunctionDef_count)
+
+	NodeChanger(
+		findThis=Be.FunctionDef.nameIs(IfThis.isIdentifier(sourceCallableIdentifierA007822))
+		, doThat=Then.replaceWith(astFunctionDef_count)
+		).visit(astModule)
+
+	astFunctionDef_doTheNeedful: ast.FunctionDef = raiseIfNone(NodeTourist(
+		findThis = Be.FunctionDef.nameIs(IfThis.isIdentifier(sourceCallableDispatcher))
+		, doThat = Then.extractIt
+		).captureLastMatch(astModule))
+
+	astFunctionDef_doTheNeedful.body.insert(0, astExprCall_initializeConcurrencyManager)
+
+	NodeChanger(
+		findThis=Be.FunctionDef.nameIs(IfThis.isIdentifier(sourceCallableDispatcher))
+		, doThat=Then.replaceWith(astFunctionDef_doTheNeedful)
+		).visit(astModule)
+
+	astImportFrom = ast.ImportFrom(f'{packageSettings.identifierPackage}.{logicalPathInfix}.{moduleIdentifier}Annex'
+			, [Make.alias(identifier_filterAsymmetricFolds), Make.alias(identifier_getAsymmetricFoldsTotal), Make.alias(identifier_initializeConcurrencyManager)], 0)
+
+	astModule.body.insert(0, astImportFrom)
+
+	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier)
+	pathFilenameAnnex: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier + 'Annex')
+
+	write_astModule(astModule, pathFilename, packageSettings.identifierPackage)
+	del astModule
+# ----------------- Ingredients Module Annex ------------------------------------------------------------------------------
+	ImaString = """from concurrent.futures import Future as ConcurrentFuture, ProcessPoolExecutor
+from hunterMakesPy import raiseIfNone
+from mapFolding import Array1DLeavesTotal
+from queue import Empty, Queue
+from threading import Thread
+import numpy"""
+
+	astModule = ast.parse(ImaString)
+	del ImaString
+
+	ImaString = f"""concurrencyManager = None
+{identifierCounting}Total: int = 0
+processingThread = None
+queueFutures: Queue[ConcurrentFuture[int]] = Queue()
+	"""
+	astModule.body.extend(ast.parse(ImaString).body)
+	del ImaString
+
+	ImaString = f"""def {identifier_initializeConcurrencyManager}(maxWorkers: int | None = None, {identifierCounting}: int = 0) -> None:
+	global concurrencyManager, queueFutures, {identifierCounting}Total, processingThread
+	concurrencyManager = ProcessPoolExecutor(max_workers=maxWorkers)
+	queueFutures = Queue()
+	{identifierCounting}Total = {identifierCounting}
+	processingThread = Thread(target={identifier_processCompletedFutures})
+	processingThread.start()
+	"""
+	astModule.body.append(raiseIfNone(extractFunctionDef(ast.parse(ImaString), identifier_initializeConcurrencyManager)))
+	del ImaString
+
+	ImaString = f"""def {identifier_processCompletedFutures}() -> None:
+	global queueFutures, {identifierCounting}Total
+	while True:
+		try:
+			claimTicket: ConcurrentFuture[int] = queueFutures.get(timeout=1)
+			if claimTicket is None:
+				break
+			{identifierCounting}Total += claimTicket.result()
+		except Empty:
+			continue
+	"""
+	astModule.body.append(raiseIfNone(extractFunctionDef(ast.parse(ImaString), identifier_processCompletedFutures)))
+	del ImaString
+
+	ImaString = f"""def _{identifier_filterAsymmetricFolds}(leafBelow: Array1DLeavesTotal) -> int:
+	{identifierCounting} = 0
+	leafComparison: Array1DLeavesTotal = numpy.zeros_like(leafBelow)
+	leavesTotal = leafBelow.size - 1
+
+	indexLeaf = 0
+	leafConnectee = 0
+	while leafConnectee < leavesTotal + 1:
+		leafNumber = int(leafBelow[indexLeaf])
+		leafComparison[leafConnectee] = (leafNumber - indexLeaf + leavesTotal) % leavesTotal
+		indexLeaf = leafNumber
+		leafConnectee += 1
+
+	indexInMiddle = leavesTotal // 2
+	indexDistance = 0
+	while indexDistance < leavesTotal + 1:
+		ImaSymmetricFold = True
+		leafConnectee = 0
+		while leafConnectee < indexInMiddle:
+			if leafComparison[(indexDistance + leafConnectee) % (leavesTotal + 1)] != leafComparison[(indexDistance + leavesTotal - 1 - leafConnectee) % (leavesTotal + 1)]:
+				ImaSymmetricFold = False
+				break
+			leafConnectee += 1
+		if ImaSymmetricFold:
+			{identifierCounting} += 1
+		indexDistance += 1
+	return {identifierCounting}
+	"""
+	astModule.body.append(raiseIfNone(extractFunctionDef(ast.parse(ImaString), f'_{identifier_filterAsymmetricFolds}')))
+	del ImaString
+
+	ImaString = f"""
+def {identifier_filterAsymmetricFolds}(leafBelow: Array1DLeavesTotal) -> None:
+	global concurrencyManager, queueFutures
+	queueFutures.put(raiseIfNone(concurrencyManager).submit(_{identifier_filterAsymmetricFolds}, leafBelow.copy()))
+	"""
+	astModule.body.append(raiseIfNone(extractFunctionDef(ast.parse(ImaString), identifier_filterAsymmetricFolds)))
+	del ImaString
+
+	ImaString = f"""
+def {identifier_getAsymmetricFoldsTotal}() -> int:
+	global concurrencyManager, queueFutures, processingThread
+	raiseIfNone(concurrencyManager).shutdown(wait=True)
+	queueFutures.put(None)
+	raiseIfNone(processingThread).join()
+	return {identifierCounting}Total
+	"""
+	astModule.body.append(raiseIfNone(extractFunctionDef(ast.parse(ImaString), identifier_getAsymmetricFoldsTotal)))
+	del ImaString
+
+	write_astModule(astModule, pathFilenameAnnex, packageSettings.identifierPackage)
+
+	return pathFilename
+
+def _makeA007822AsynchronousModules() -> None:
+
+	astModule = getModule(logicalPathInfix=logicalPathInfixAlgorithmDEFAULT)
+	pathFilename = addSymmetryCheckAsynchronous(astModule, 'asynchronous', None, logicalPathInfixA007822, sourceCallableDispatcherA007822)
+
+	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, moduleIdentifier='asynchronous')
+	pathFilename = makeTheorem2(astModule, 'asynchronousTheorem2', None, logicalPathInfixA007822, None)
+
+	astModule = parsePathFilename2astModule(pathFilename)
+	pathFilename = trimTheorem2(astModule, 'asynchronousTrimmed', None, logicalPathInfixA007822, None)
+
+	# astModule = parsePathFilename2astModule(pathFilename)
+	# pathFilename = numbaOnTheorem2(astModule, 'asynchronousNumba', None, logicalPathInfixA007822, identifier_filterAsymmetricFolds)
+
+if __name__ == '__main__':
+	_makeA007822AsynchronousModules()

mapFolding/someAssemblyRequired/A007822/makeA007822Modules.py

@@ -0,0 +1,71 @@
+"""addSymmetryCheck."""
+from astToolkit import Be, Make, NodeChanger, NodeTourist, parsePathFilename2astModule, Then
+from hunterMakesPy import raiseIfNone
+from mapFolding import packageSettings
+from mapFolding.someAssemblyRequired import (
+	identifierCallableSourceDEFAULT, identifierCountingDEFAULT, identifierDataclassInstanceDEFAULT, IfThis)
+from mapFolding.someAssemblyRequired.A007822.A007822rawMaterials import (
+	A007822adjustFoldsTotal, A007822incrementCount, FunctionDef_filterAsymmetricFolds, logicalPathInfixA007822,
+	sourceCallableDispatcherA007822, sourceCallableIdentifierA007822)
+from mapFolding.someAssemblyRequired.makingModules_count import (
+	makeDaoOfMapFoldingNumba, makeTheorem2, numbaOnTheorem2, trimTheorem2)
+from mapFolding.someAssemblyRequired.makingModules_doTheNeedful import makeInitializeState, makeUnRePackDataclass
+from mapFolding.someAssemblyRequired.toolkitMakeModules import (
+	getLogicalPath, getModule, getPathFilename, write_astModule)
+from os import PathLike
+from pathlib import PurePath
+import ast
+
+def addSymmetryCheck(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: PathLike[str] | PurePath | str | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
+	"""Add logic to check for symmetric folds."""
+# NOTE HEY HEY! Are you trying to figure out why there is more than one copy of `filterAsymmetricFolds`? See the TODO NOTE, below.
+
+	astFunctionDef_count: ast.FunctionDef = raiseIfNone(NodeTourist(
+		findThis = Be.FunctionDef.nameIs(IfThis.isIdentifier(identifierCallableSourceDEFAULT))
+		, doThat = Then.extractIt
+		).captureLastMatch(astModule))
+	astFunctionDef_count.name = sourceCallableIdentifierA007822
+
+	NodeChanger(Be.Return, Then.insertThisAbove([A007822adjustFoldsTotal])).visit(astFunctionDef_count)
+
+	NodeChanger(
+		findThis=Be.AugAssign.targetIs(IfThis.isAttributeNamespaceIdentifier(identifierDataclassInstanceDEFAULT, identifierCountingDEFAULT))
+		, doThat=Then.replaceWith(A007822incrementCount)
+		).visit(astFunctionDef_count)
+
+# TODO NOTE This will insert a copy of `filterAsymmetricFolds` for each `ast.ImportFrom` in the source module. Find or make a
+# system to replace the `Ingredients` paradigm.
+	NodeChanger(Be.ImportFrom, Then.insertThisBelow([FunctionDef_filterAsymmetricFolds])).visit(astModule)
+
+	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier)
+
+	write_astModule(astModule, pathFilename, packageSettings.identifierPackage)
+
+	return pathFilename
+
+def _makeA007822Modules() -> None:
+	astModule = getModule(logicalPathInfix='algorithms')
+	pathFilename = addSymmetryCheck(astModule, 'algorithm', None, logicalPathInfixA007822, None)
+
+	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, moduleIdentifier='algorithm')
+	pathFilename: PurePath = makeDaoOfMapFoldingNumba(astModule, 'algorithmNumba', None, logicalPathInfixA007822, sourceCallableDispatcherA007822)
+
+	# NOTE I can't handle parallel right now.
+
+	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, moduleIdentifier='algorithm')
+	makeInitializeState(astModule, 'initializeState', 'transitionOnGroupsOfFolds', logicalPathInfixA007822)
+
+	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, moduleIdentifier='algorithm')
+	pathFilename = makeTheorem2(astModule, 'theorem2', None, logicalPathInfixA007822, None)
+
+	astModule = parsePathFilename2astModule(pathFilename)
+	pathFilename = trimTheorem2(astModule, 'theorem2Trimmed', None, logicalPathInfixA007822, None)
+
+	astModule = parsePathFilename2astModule(pathFilename)
+	pathFilename = numbaOnTheorem2(astModule, 'theorem2Numba', None, logicalPathInfixA007822, None)
+
+	astImportFrom: ast.ImportFrom = Make.ImportFrom(getLogicalPath(packageSettings.identifierPackage, logicalPathInfixA007822, 'theorem2Numba'), list_alias=[Make.alias(sourceCallableIdentifierA007822)])
+	makeUnRePackDataclass(astImportFrom, 'dataPackingA007822')
+
+if __name__ == '__main__':
+	_makeA007822Modules()

mapFolding/someAssemblyRequired/RecipeJob.py

@@ -6,7 +6,7 @@ from mapFolding import (
 	DatatypeElephino as TheDatatypeElephino, DatatypeFoldsTotal as TheDatatypeFoldsTotal,
 	DatatypeLeavesTotal as TheDatatypeLeavesTotal, getPathFilenameFoldsTotal, getPathRootJobDEFAULT, MapFoldingState,
 	packageSettings)
-from mapFolding.someAssemblyRequired import dataclassInstanceIdentifierDEFAULT, ShatteredDataclass
+from mapFolding.someAssemblyRequired import identifierDataclassInstanceDEFAULT, ShatteredDataclass
 from mapFolding.someAssemblyRequired.transformationTools import shatter_dataclassesDOTdataclass
 from pathlib import Path, PurePosixPath
 import dataclasses
@@ -98,7 +98,7 @@ class RecipeJobTheorem2:
 	"""Logical path to the dataclass module."""
 	sourceDataclassIdentifier: str = 'MapFoldingState'
 	"""Name of the source dataclass."""
-	sourceDataclassInstance: str = dataclassInstanceIdentifierDEFAULT
+	sourceDataclassInstance: str = identifierDataclassInstanceDEFAULT
 	"""Instance identifier for the dataclass."""
 
 	sourcePathPackage: PurePosixPath | None = PurePosixPath(packageSettings.pathPackage)  # noqa: RUF009

mapFolding/someAssemblyRequired/__init__.py

@@ -73,8 +73,15 @@ calculations through the strategic application of compiler optimization techniqu
 """
 
 from mapFolding.someAssemblyRequired.infoBooth import (
-	dataclassInstanceIdentifierDEFAULT as dataclassInstanceIdentifierDEFAULT,
-	sourceCallableDispatcherDEFAULT as sourceCallableDispatcherDEFAULT,
+	dictionaryEstimatesMapFolding as dictionaryEstimatesMapFolding,
+	identifierCallableSourceDEFAULT as identifierCallableSourceDEFAULT,
+	identifierCallableSourceDispatcherDEFAULT as identifierCallableSourceDispatcherDEFAULT,
+	identifierCountingDEFAULT as identifierCountingDEFAULT,
+	identifierDataclassInstanceDEFAULT as identifierDataclassInstanceDEFAULT,
+	identifierModuleDataPackingDEFAULT as identifierModuleDataPackingDEFAULT,
+	identifierModuleSourceAlgorithmDEFAULT as identifierModuleSourceAlgorithmDEFAULT,
+	logicalPathInfixAlgorithmDEFAULT as logicalPathInfixAlgorithmDEFAULT,
+	logicalPathInfixDEFAULT as logicalPathInfixDEFAULT,
 )
 
 from mapFolding.someAssemblyRequired._toolIfThis import IfThis as IfThis

mapFolding/someAssemblyRequired/_toolIfThis.py

@@ -67,7 +67,7 @@ class IfThis(astToolkit_IfThis):
 
 		"""
 		return lambda node: (Be.Compare.leftIs(IfThis.isAttributeNamespaceIdentifier(namespace, identifier))(node)
-					and Be.Compare.opsIs(lambda at: Be.LtE(at[0]))(node)
+					and Be.Compare.opsIs(Be.at(0, Be.LtE))(node)
 				)
 
 	@staticmethod
@@ -94,8 +94,9 @@ class IfThis(astToolkit_IfThis):
 
 		"""
 		return lambda node: (Be.Compare.leftIs(IfThis.isAttributeNamespaceIdentifier(namespace, identifier))(node)
-					and Be.Gt(node.ops[0])
-					and IfThis.isConstant_value(0)(node.comparators[0]))
+					and Be.Compare.opsIs(Be.at(0, Be.Gt))(node)
+					and Be.Compare.comparatorsIs(Be.at(0, IfThis.isConstant_value(0)))(node)
+				)
 
 	@staticmethod
 	def isIfAttributeNamespaceIdentifierGreaterThan0(namespace: str, identifier: str) -> Callable[[ast.AST], TypeIs[ast.If]]:

mapFolding/someAssemblyRequired/_toolkitContainers.py

@@ -62,10 +62,10 @@ class ShatteredDataclass:
 	countingVariableName: ast.Name
 	"""AST name node representing the counting variable identifier."""
 
-	field2AnnAssign: dict[str, ast.AnnAssign | ast.Assign] = dataclasses.field(default_factory=lambda: dict[str, ast.AnnAssign | ast.Assign]())
+	field2AnnAssign: dict[str, ast.AnnAssign | ast.Assign] = dataclasses.field(default_factory=dict[str, ast.AnnAssign | ast.Assign])
 	"""Maps field names to their corresponding AST assignment expressions for initialization."""
 
-	Z0Z_field2AnnAssign: dict[str, tuple[ast.AnnAssign | ast.Assign, str]] = dataclasses.field(default_factory=lambda: dict[str, tuple[ast.AnnAssign | ast.Assign, str]]())
+	Z0Z_field2AnnAssign: dict[str, tuple[ast.AnnAssign | ast.Assign, str]] = dataclasses.field(default_factory=dict[str, tuple[ast.AnnAssign | ast.Assign, str]])
 	"""Temporary mapping for field assignments with constructor type information."""
 
 	fragments4AssignmentOrParameters: ast.Tuple = dummyTuple
@@ -74,22 +74,22 @@ class ShatteredDataclass:
 	imports: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
 	"""Import records for the dataclass and its constituent field types."""
 
-	list_argAnnotated4ArgumentsSpecification: list[ast.arg] = dataclasses.field(default_factory=lambda: list[ast.arg]())
+	list_argAnnotated4ArgumentsSpecification: list[ast.arg] = dataclasses.field(default_factory=list[ast.arg])
 	"""Function argument nodes with type annotations for parameter specification."""
 
-	list_keyword_field__field4init: list[ast.keyword] = dataclasses.field(default_factory=lambda: list[ast.keyword]())
+	list_keyword_field__field4init: list[ast.keyword] = dataclasses.field(default_factory=list[ast.keyword])
 	"""Keyword arguments for dataclass initialization using field=field format."""
 
-	listAnnotations: list[ast.expr] = dataclasses.field(default_factory=lambda: list[ast.expr]())
+	listAnnotations: list[ast.expr] = dataclasses.field(default_factory=list[ast.expr])
 	"""Type annotations for each dataclass field in declaration order."""
 
-	listName4Parameters: list[ast.Name] = dataclasses.field(default_factory=lambda: list[ast.Name]())
+	listName4Parameters: list[ast.Name] = dataclasses.field(default_factory=list[ast.Name])
 	"""Name nodes for each dataclass field used as function parameters."""
 
-	listUnpack: list[ast.AnnAssign] = dataclasses.field(default_factory=lambda: list[ast.AnnAssign]())
+	listUnpack: list[ast.AnnAssign] = dataclasses.field(default_factory=list[ast.AnnAssign])
 	"""Annotated assignment statements to extract individual fields from dataclass instances."""
 
-	map_stateDOTfield2Name: dict[ast.AST, ast.Name] = dataclasses.field(default_factory=lambda: dict[ast.AST, ast.Name]())
+	map_stateDOTfield2Name: dict[ast.AST, ast.Name] = dataclasses.field(default_factory=dict[ast.AST, ast.Name])
 	"""Maps dataclass attribute access expressions to field name nodes for find-replace operations."""
 
 	repack: ast.Assign = dummyAssign