mapFolding 0.15.3__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/{_oeisFormulas/matrixMeanders64.py → reference/meandersDumpingGround/matrixMeanders64retired.py}

@@ -15,7 +15,6 @@ def make1array(listArrays: list[numpy.ndarray[tuple[int, ...], numpy.dtype[numpy
 		, (arrayCurveLocations & numpy.uint64(0xaaaaaaaaaaaaaaaa)) >> numpy.uint64(1)
 		, arrayCurveLocations
 	))
-
 	for arrayCurveLocations in listArrays:
 		arrayOut[:, indexDistinctCrossings] += numpy.sum(arrayCurveLocations[:, 0] * (arrayCurveLocations[:, -1][:, numpy.newaxis] == arrayOut[:, indexCurveLocations]).T, axis=1)
 
@@ -42,31 +41,39 @@ def count(bridges: int, startingCurveLocations: dict[int, int]) -> int:
 		# Selector-adjacent
 		curveLocationsMAXIMUM: numpy.uint64 = numpy.uint64(1) << numpy.uint64(2 * bridges + 4)
 		# Selectors, general
-		selectBifurcationAlphaCurves: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = arrayBifurcations[:, indexBifurcationAlpha] > numpy.uint64(1)
+		selectBifurcationAlphaCurves: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = arrayBifurcations[:, indexBifurcationAlpha] != numpy.uint64(1)
 		selectBifurcationAlphaEven: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = (arrayBifurcations[:, indexBifurcationAlpha] & numpy.uint64(1)) == numpy.uint64(0)
-		selectBifurcationZuluCurves: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = arrayBifurcations[:, indexBifurcationZulu] > numpy.uint64(1)
+		selectBifurcationZuluCurves: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = arrayBifurcations[:, indexBifurcationZulu] != numpy.uint64(1)
 		selectBifurcationZuluEven: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = (arrayBifurcations[:, indexBifurcationZulu] & numpy.uint64(1)) == numpy.uint64(0)
 
-		# BridgesSimple
+		# bridgesSimple
 		selector: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = arrayBifurcations[:, indexDistinctCrossings] >= numpy.uint64(0) # This had better always be `True`.
 		curveLocations: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]] = (((arrayBifurcations[selector, indexBifurcationAlpha] | (arrayBifurcations[selector, indexBifurcationZulu] << numpy.uint64(1))) << numpy.uint64(2)) | numpy.uint64(3))
 		listArrayCurveLocationsAnalyzed.append(numpy.column_stack((arrayBifurcations[selector, indexDistinctCrossings][curveLocations < curveLocationsMAXIMUM], curveLocations[curveLocations < curveLocationsMAXIMUM])))
 
-		# BifurcationAlphaCurves
-		selector = selectBifurcationAlphaCurves
-		curveLocations: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]] = numpy.bitwise_or.reduce((
-			arrayBifurcations[selector, indexBifurcationAlpha] >> numpy.uint64(2)
-			, arrayBifurcations[selector, indexBifurcationZulu] << numpy.uint64(3)
-			, (numpy.uint64(1) - (arrayBifurcations[selector, indexBifurcationAlpha] & numpy.uint64(1))) << numpy.uint64(1)
+		# bifurcationAlphaCurves
+		this = numpy.bitwise_or.reduce((
+			arrayBifurcations[arrayBifurcations[:, indexBifurcationAlpha] != numpy.uint64(1), indexBifurcationAlpha] >> numpy.uint64(2)
+			, arrayBifurcations[arrayBifurcations[:, indexBifurcationAlpha] != numpy.uint64(1), indexBifurcationZulu] << numpy.uint64(3)
+			, (numpy.uint64(1) - (arrayBifurcations[arrayBifurcations[:, indexBifurcationAlpha] != numpy.uint64(1), indexBifurcationAlpha] & numpy.uint64(1))) << numpy.uint64(1)
 		))
-		listArrayCurveLocationsAnalyzed.append(numpy.column_stack((arrayBifurcations[selector, indexDistinctCrossings][curveLocations < curveLocationsMAXIMUM], curveLocations[curveLocations < curveLocationsMAXIMUM])))
+		curveLocations: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]] = numpy.where(this < curveLocationsMAXIMUM, this, numpy.uint64(0))
+		# print(curveLocations.astype(numpy.bool_))
+		print(curveLocations)
+		distinctCrossings = arrayBifurcations[arrayBifurcations[:, indexBifurcationAlpha] != numpy.uint64(1), indexDistinctCrossings]
+		print(distinctCrossings)
+		listArrayCurveLocationsAnalyzed.append(
+			numpy.column_stack((distinctCrossings, curveLocations))
+		)
+		# print(arrayBifurcations)
+		# print(listArrayCurveLocationsAnalyzed[-1])
 
-		# BifurcationZuluCurves
+		# bifurcationZuluCurves
 		selector = selectBifurcationZuluCurves
 		curveLocations: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]] = numpy.bitwise_or.reduce((
 			arrayBifurcations[selector, indexBifurcationZulu] >> numpy.uint64(1)
 			, arrayBifurcations[selector, indexBifurcationAlpha] << numpy.uint64(2)
-			, (1 - (arrayBifurcations[selector, indexBifurcationZulu] & numpy.uint64(1)))
+			, (numpy.uint64(1) - (arrayBifurcations[selector, indexBifurcationZulu] & numpy.uint64(1)))
 		))
 		listArrayCurveLocationsAnalyzed.append(numpy.column_stack((arrayBifurcations[selector, indexDistinctCrossings][curveLocations < curveLocationsMAXIMUM], curveLocations[curveLocations < curveLocationsMAXIMUM])))
 
@@ -75,24 +82,24 @@ def count(bridges: int, startingCurveLocations: dict[int, int]) -> int:
 			selectBifurcationAlphaCurves, selectBifurcationZuluCurves, selectBifurcationAlphaEven, ~selectBifurcationZuluEven
 		))
 
-			# Initialize
-		Z0Z_selectBridgesBifurcationAlphaToModify = selector.copy()
+		# Initialize
 		XOrHere2makePair = numpy.uint64(1)
-		selectToModifyByXOR: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.array([])
-		selectorUnified: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.array([])
 
-		while Z0Z_selectBridgesBifurcationAlphaToModify.any():
+		while selector.any():
 			XOrHere2makePair <<= numpy.uint64(2)
 
-			selectToModifyByXOR: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = (arrayBifurcations[:, indexBifurcationAlpha] & XOrHere2makePair) == numpy.uint64(0)
-			selectorUnified: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((Z0Z_selectBridgesBifurcationAlphaToModify, selectToModifyByXOR))
+			selectUnpaired_0b1: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = (arrayBifurcations[:, indexBifurcationAlpha] & XOrHere2makePair) == numpy.uint64(0)
+			selectorUnified: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((selector, selectUnpaired_0b1))
 
 			# Modify in place
 			arrayBifurcations[selectorUnified, indexBifurcationAlpha] ^= XOrHere2makePair
 
 			# Remove the modified elements
-			Z0Z_selectBridgesBifurcationAlphaToModify: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((Z0Z_selectBridgesBifurcationAlphaToModify, ~selectorUnified))
+			selector: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((selector, ~selectorUnified))
 
+		selector: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((
+			selectBifurcationAlphaCurves, selectBifurcationZuluCurves, selectBifurcationAlphaEven, ~selectBifurcationZuluEven
+		))
 		curveLocations: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]] = (
 			((arrayBifurcations[selector, indexBifurcationZulu] >> numpy.uint64(2)) << numpy.uint64(1))
 			| (arrayBifurcations[selector, indexBifurcationAlpha] >> numpy.uint64(2))
@@ -105,24 +112,25 @@ def count(bridges: int, startingCurveLocations: dict[int, int]) -> int:
 			selectBifurcationAlphaCurves, selectBifurcationZuluCurves, ~selectBifurcationAlphaEven, selectBifurcationZuluEven
 		))
 
-			# Initialize
-		Z0Z_selectBridgesBifurcationZuluToModify: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = selector.copy()
+		# Initialize
 		XOrHere2makePair: numpy.uint64 = numpy.uint64(1)
-		selectToModifyByXOR: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.array([])
-		selectorUnified: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.array([])
 
-		while Z0Z_selectBridgesBifurcationZuluToModify.any():
+		while selector.any():
 			XOrHere2makePair <<= numpy.uint64(2)
 
 			# New condition
 			selectUnpaired_0b1: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = (arrayBifurcations[:, indexBifurcationZulu] & XOrHere2makePair) == numpy.uint64(0)
-			selectorUnified: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((Z0Z_selectBridgesBifurcationZuluToModify, selectUnpaired_0b1))
+			selectorUnified: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((selector, selectUnpaired_0b1))
 
 			# Modify in place
 			arrayBifurcations[selectorUnified, indexBifurcationZulu] ^= XOrHere2makePair
 
 			# Remove the modified elements from the selector
-			Z0Z_selectBridgesBifurcationZuluToModify: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((Z0Z_selectBridgesBifurcationZuluToModify, ~selectorUnified))
+			selector: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((selector, ~selectorUnified))
+
+		selector: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((
+			selectBifurcationAlphaCurves, selectBifurcationZuluCurves, ~selectBifurcationAlphaEven, selectBifurcationZuluEven
+		))
 
 		curveLocations: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]] = (
 			((arrayBifurcations[selector, indexBifurcationZulu] >> numpy.uint64(2)) << numpy.uint64(1))
@@ -147,6 +155,6 @@ def count(bridges: int, startingCurveLocations: dict[int, int]) -> int:
 
 		listArrayCurveLocationsAnalyzed.clear()
 
-		print(int(sum(arrayBifurcations[:, 0])))
+		# print(int(sum(arrayBifurcations[:, 0])))
 	return int(sum(arrayBifurcations[:, 0]))
 

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