mapFolding 0.8.1__py3-none-any.whl → 0.8.3__py3-none-any.whl

mapFolding/reference/total_countPlus1vsPlusN.py

@@ -1,211 +1,234 @@
+"""
+Comparison of two nearly identical counting implementations with vastly different performance.
+
+This file provides a direct comparison between two variants of the map folding algorithm
+that differ only in their approach to incrementing the folding counter. Despite their apparent
+similarity, one implementation demonstrates orders of magnitude better performance than the other.
+
+Key characteristics:
+- Both implementations use Numba for performance optimization
+- Both use identical data structures and array initializations
+- `foldings_plus_1`: Increments the counter by 1 for each valid folding
+- `foldings`: Increments the counter by n (total leaves) when certain conditions are met
+
+The performance difference illustrates how subtle algorithmic changes can dramatically
+impact computational efficiency, even when the overall algorithm structure remains unchanged.
+This example serves as a compelling demonstration of the importance of algorithm analysis
+and optimization for combinatorial problems.
+
+Note: These functions are isolated for educational purposes to highlight the specific
+optimization technique. The main package uses more comprehensive optimizations derived
+from this and other lessons.
+"""
+
 from numba import njit
 import numpy
 
 @njit(cache=True)
 def foldings_plus_1(p: list[int], computationDivisions: int = 0, computationIndex: int = 0) -> int:
-	n: int = 1  # Total number of leaves
-	for dimension in p:
-		n *= dimension
-
-	d = len(p)  # Number of dimensions
-	# Compute arrays P, C, D as per the algorithm
-	P = numpy.ones(d + 1, dtype=numpy.int64)
-	for i in range(1, d + 1):
-		P[i] = P[i - 1] * p[i - 1]
-
-	# C[i][m] holds the i-th coordinate of leaf m
-	C = numpy.zeros((d + 1, n + 1), dtype=numpy.int64)
-	for i in range(1, d + 1):
-		for m in range(1, n + 1):
-			C[i][m] = ((m - 1) // P[i - 1]) - ((m - 1) // P[i]) * p[i - 1] + 1
-
-	# D[i][l][m] computes the leaf connected to m in section i when inserting l
-	D = numpy.zeros((d + 1, n + 1, n + 1), dtype=numpy.int64)
-	for i in range(1, d + 1):
-		for l in range(1, n + 1):
-			for m in range(1, l + 1):
-				delta = C[i][l] - C[i][m]
-				if delta % 2 == 0:
-					# If delta is even
-					if C[i][m] == 1:
-						D[i][l][m] = m
-					else:
-						D[i][l][m] = m - P[i - 1]
-				else:
-					# If delta is odd
-					if C[i][m] == p[i - 1] or m + P[i - 1] > l:
-						D[i][l][m] = m
-					else:
-						D[i][l][m] = m + P[i - 1]
-	# Initialize arrays/lists
-	A = numpy.zeros(n + 1, dtype=numpy.int64)	   # Leaf above leaf m
-	B = numpy.zeros(n + 1, dtype=numpy.int64)	   # Leaf below leaf m
-	count = numpy.zeros(n + 1, dtype=numpy.int64)   # Counts for potential gaps
-	gapter = numpy.zeros(n + 1, dtype=numpy.int64)  # Indices for gap stack per leaf
-	gap = numpy.zeros(n * n + 1, dtype=numpy.int64) # Stack of potential gaps
-
-
-	# Initialize variables for backtracking
-	total_count = 0  # Total number of foldings
-	g = 0			# Gap index
-	l = 1			# Current leaf
-
-	# Start backtracking loop
-	while l > 0:
-		# If we have processed all leaves, increment total count
-		if l > n:
-			total_count += 1
-		else:
-			dd = 0	 # Number of sections where leaf l is unconstrained
-			gg = g	 # Temporary gap index
-			g = gapter[l - 1]  # Reset gap index for current leaf
-
-			# Count possible gaps for leaf l in each section
-			for i in range(1, d + 1):
-				if D[i][l][l] == l:
-					dd += 1
-				else:
-					m = D[i][l][l]
-					while m != l:
-						if computationDivisions == 0 or l != computationDivisions or m % computationDivisions == computationIndex:
-							gap[gg] = m
-							if count[m] == 0:
-								gg += 1
-							count[m] += 1
-						m = D[i][l][B[m]]
-
-			# If leaf l is unconstrained in all sections, it can be inserted anywhere
-			if dd == d:
-				for m in range(l):
-					gap[gg] = m
-					gg += 1
-
-			# Filter gaps that are common to all sections
-			for j in range(g, gg):
-				gap[g] = gap[j]
-				if count[gap[j]] == d - dd:
-					g += 1
-				count[gap[j]] = 0  # Reset count for next iteration
-
-		# Recursive backtracking steps
-		while l > 0 and g == gapter[l - 1]:
-			l -= 1
-			B[A[l]] = B[l]
-			A[B[l]] = A[l]
-
-		if l > 0:
-			g -= 1
-			A[l] = gap[g]
-			B[l] = B[A[l]]
-			B[A[l]] = l
-			A[B[l]] = l
-			gapter[l] = g  # Save current gap index
-			l += 1		 # Move to next leaf
-
-	return total_count
+    n: int = 1  # Total number of leaves
+    for dimension in p:
+        n *= dimension
+
+    d = len(p)  # Number of dimensions
+    # Compute arrays P, C, D as per the algorithm
+    P = numpy.ones(d + 1, dtype=numpy.int64)
+    for i in range(1, d + 1):
+        P[i] = P[i - 1] * p[i - 1]
+
+    # C[i][m] holds the i-th coordinate of leaf m
+    C = numpy.zeros((d + 1, n + 1), dtype=numpy.int64)
+    for i in range(1, d + 1):
+        for m in range(1, n + 1):
+            C[i][m] = ((m - 1) // P[i - 1]) - ((m - 1) // P[i]) * p[i - 1] + 1
+
+    # D[i][l][m] computes the leaf connected to m in section i when inserting l
+    D = numpy.zeros((d + 1, n + 1, n + 1), dtype=numpy.int64)
+    for i in range(1, d + 1):
+        for l in range(1, n + 1):
+            for m in range(1, l + 1):
+                delta = C[i][l] - C[i][m]
+                if delta % 2 == 0:
+                    # If delta is even
+                    if C[i][m] == 1:
+                        D[i][l][m] = m
+                    else:
+                        D[i][l][m] = m - P[i - 1]
+                else:
+                    # If delta is odd
+                    if C[i][m] == p[i - 1] or m + P[i - 1] > l:
+                        D[i][l][m] = m
+                    else:
+                        D[i][l][m] = m + P[i - 1]
+    # Initialize arrays/lists
+    A = numpy.zeros(n + 1, dtype=numpy.int64)	   # Leaf above leaf m
+    B = numpy.zeros(n + 1, dtype=numpy.int64)	   # Leaf below leaf m
+    count = numpy.zeros(n + 1, dtype=numpy.int64)   # Counts for potential gaps
+    gapter = numpy.zeros(n + 1, dtype=numpy.int64)  # Indices for gap stack per leaf
+    gap = numpy.zeros(n * n + 1, dtype=numpy.int64) # Stack of potential gaps
+
+
+    # Initialize variables for backtracking
+    total_count = 0  # Total number of foldings
+    g = 0            # Gap index
+    l = 1            # Current leaf
+
+    # Start backtracking loop
+    while l > 0:
+        # If we have processed all leaves, increment total count
+        if l > n:
+            total_count += 1
+        else:
+            dd = 0    # Number of sections where leaf l is unconstrained
+            gg = g    # Temporary gap index
+            g = gapter[l - 1]  # Reset gap index for current leaf
+
+            # Count possible gaps for leaf l in each section
+            for i in range(1, d + 1):
+                if D[i][l][l] == l:
+                    dd += 1
+                else:
+                    m = D[i][l][l]
+                    while m != l:
+                        if computationDivisions == 0 or l != computationDivisions or m % computationDivisions == computationIndex:
+                            gap[gg] = m
+                            if count[m] == 0:
+                                gg += 1
+                            count[m] += 1
+                        m = D[i][l][B[m]]
+
+            # If leaf l is unconstrained in all sections, it can be inserted anywhere
+            if dd == d:
+                for m in range(l):
+                    gap[gg] = m
+                    gg += 1
+
+            # Filter gaps that are common to all sections
+            for j in range(g, gg):
+                gap[g] = gap[j]
+                if count[gap[j]] == d - dd:
+                    g += 1
+                count[gap[j]] = 0  # Reset count for next iteration
+
+        # Recursive backtracking steps
+        while l > 0 and g == gapter[l - 1]:
+            l -= 1
+            B[A[l]] = B[l]
+            A[B[l]] = A[l]
+
+        if l > 0:
+            g -= 1
+            A[l] = gap[g]
+            B[l] = B[A[l]]
+            B[A[l]] = l
+            A[B[l]] = l
+            gapter[l] = g  # Save current gap index
+            l += 1		 # Move to next leaf
+
+    return total_count
 
 @njit(cache=True)
 def foldings(p: list[int], computationDivisions: int = 0, computationIndex: int = 0) -> int:
-	n: int = 1  # Total number of leaves
-	for dimension in p:
-		n *= dimension
-
-	d = len(p)  # Number of dimensions
-	# Compute arrays P, C, D as per the algorithm
-	P = numpy.ones(d + 1, dtype=numpy.int64)
-	for i in range(1, d + 1):
-		P[i] = P[i - 1] * p[i - 1]
-
-	# C[i][m] holds the i-th coordinate of leaf m
-	C = numpy.zeros((d + 1, n + 1), dtype=numpy.int64)
-	for i in range(1, d + 1):
-		for m in range(1, n + 1):
-			C[i][m] = ((m - 1) // P[i - 1]) - ((m - 1) // P[i]) * p[i - 1] + 1
-			# C[i][m] = ((m - 1) // P[i - 1]) % p[i - 1] + 1 # NOTE different, but either one works
-
-	# D[i][l][m] computes the leaf connected to m in section i when inserting l
-	D = numpy.zeros((d + 1, n + 1, n + 1), dtype=numpy.int64)
-	for i in range(1, d + 1):
-		for l in range(1, n + 1):
-			for m in range(1, l + 1):
-				delta = C[i][l] - C[i][m]
-				if delta % 2 == 0:
-					# If delta is even
-					if C[i][m] == 1:
-						D[i][l][m] = m
-					else:
-						D[i][l][m] = m - P[i - 1]
-				else:
-					# If delta is odd
-					if C[i][m] == p[i - 1] or m + P[i - 1] > l:
-						D[i][l][m] = m
-					else:
-						D[i][l][m] = m + P[i - 1]
-	# Initialize arrays/lists
-	A = numpy.zeros(n + 1, dtype=numpy.int64)	   # Leaf above leaf m
-	B = numpy.zeros(n + 1, dtype=numpy.int64)	   # Leaf below leaf m
-	count = numpy.zeros(n + 1, dtype=numpy.int64)   # Counts for potential gaps
-	gapter = numpy.zeros(n + 1, dtype=numpy.int64)  # Indices for gap stack per leaf
-	gap = numpy.zeros(n * n + 1, dtype=numpy.int64) # Stack of potential gaps
-
-
-	# Initialize variables for backtracking
-	total_count = 0  # Total number of foldings
-	g = 0			# Gap index
-	l = 1			# Current leaf
-
-	# Start backtracking loop
-	while l > 0:
-		if l <= 1 or B[0] == 1: # NOTE different
-			# NOTE the above `if` statement encloses the the if/else block below
-			# NOTE these changes increase the throughput by more than an order of magnitude
-			if l > n:
-				total_count += n
-			else:
-				dd = 0	 # Number of sections where leaf l is unconstrained
-				gg = gapter[l - 1]  # Track possible gaps # NOTE different, but not important
-				g = gg # NOTE different, but not important
-
-				# Count possible gaps for leaf l in each section
-				for i in range(1, d + 1):
-					if D[i][l][l] == l:
-						dd += 1
-					else:
-						m = D[i][l][l]
-						while m != l:
-							if computationDivisions == 0 or l != computationDivisions or m % computationDivisions == computationIndex:
-								gap[gg] = m
-								if count[m] == 0:
-									gg += 1
-								count[m] += 1
-							m = D[i][l][B[m]]
-
-				# If leaf l is unconstrained in all sections, it can be inserted anywhere
-				if dd == d:
-					for m in range(l):
-						gap[gg] = m
-						gg += 1
-
-				# Filter gaps that are common to all sections
-				for j in range(g, gg):
-					gap[g] = gap[j]
-					if count[gap[j]] == d - dd:
-						g += 1
-					count[gap[j]] = 0  # Reset count for next iteration
-
-		# Recursive backtracking steps
-		while l > 0 and g == gapter[l - 1]:
-			l -= 1
-			B[A[l]] = B[l]
-			A[B[l]] = A[l]
-
-		if l > 0:
-			g -= 1
-			A[l] = gap[g]
-			B[l] = B[A[l]]
-			B[A[l]] = l
-			A[B[l]] = l
-			gapter[l] = g  # Save current gap index
-			l += 1		 # Move to next leaf
-
-	return total_count
+    n: int = 1  # Total number of leaves
+    for dimension in p:
+        n *= dimension
+
+    d = len(p)  # Number of dimensions
+    # Compute arrays P, C, D as per the algorithm
+    P = numpy.ones(d + 1, dtype=numpy.int64)
+    for i in range(1, d + 1):
+        P[i] = P[i - 1] * p[i - 1]
+
+    # C[i][m] holds the i-th coordinate of leaf m
+    C = numpy.zeros((d + 1, n + 1), dtype=numpy.int64)
+    for i in range(1, d + 1):
+        for m in range(1, n + 1):
+            C[i][m] = ((m - 1) // P[i - 1]) - ((m - 1) // P[i]) * p[i - 1] + 1
+            # C[i][m] = ((m - 1) // P[i - 1]) % p[i - 1] + 1 # NOTE different, but either one works
+
+    # D[i][l][m] computes the leaf connected to m in section i when inserting l
+    D = numpy.zeros((d + 1, n + 1, n + 1), dtype=numpy.int64)
+    for i in range(1, d + 1):
+        for l in range(1, n + 1):
+            for m in range(1, l + 1):
+                delta = C[i][l] - C[i][m]
+                if delta % 2 == 0:
+                    # If delta is even
+                    if C[i][m] == 1:
+                        D[i][l][m] = m
+                    else:
+                        D[i][l][m] = m - P[i - 1]
+                else:
+                    # If delta is odd
+                    if C[i][m] == p[i - 1] or m + P[i - 1] > l:
+                        D[i][l][m] = m
+                    else:
+                        D[i][l][m] = m + P[i - 1]
+    # Initialize arrays/lists
+    A = numpy.zeros(n + 1, dtype=numpy.int64)       # Leaf above leaf m
+    B = numpy.zeros(n + 1, dtype=numpy.int64)       # Leaf below leaf m
+    count = numpy.zeros(n + 1, dtype=numpy.int64)   # Counts for potential gaps
+    gapter = numpy.zeros(n + 1, dtype=numpy.int64)  # Indices for gap stack per leaf
+    gap = numpy.zeros(n * n + 1, dtype=numpy.int64) # Stack of potential gaps
+
+
+    # Initialize variables for backtracking
+    total_count = 0  # Total number of foldings
+    g = 0            # Gap index
+    l = 1            # Current leaf
+
+    # Start backtracking loop
+    while l > 0:
+        if l <= 1 or B[0] == 1: # NOTE different
+            # NOTE the above `if` statement encloses the the if/else block below
+            # NOTE these changes increase the throughput by more than an order of magnitude
+            if l > n:
+                total_count += n
+            else:
+                dd = 0    # Number of sections where leaf l is unconstrained
+                gg = gapter[l - 1]  # Track possible gaps # NOTE different, but not important
+                g = gg # NOTE different, but not important
+
+                # Count possible gaps for leaf l in each section
+                for i in range(1, d + 1):
+                    if D[i][l][l] == l:
+                        dd += 1
+                    else:
+                        m = D[i][l][l]
+                        while m != l:
+                            if computationDivisions == 0 or l != computationDivisions or m % computationDivisions == computationIndex:
+                                gap[gg] = m
+                                if count[m] == 0:
+                                    gg += 1
+                                count[m] += 1
+                            m = D[i][l][B[m]]
+
+                # If leaf l is unconstrained in all sections, it can be inserted anywhere
+                if dd == d:
+                    for m in range(l):
+                        gap[gg] = m
+                        gg += 1
+
+                # Filter gaps that are common to all sections
+                for j in range(g, gg):
+                    gap[g] = gap[j]
+                    if count[gap[j]] == d - dd:
+                        g += 1
+                    count[gap[j]] = 0  # Reset count for next iteration
+
+        # Recursive backtracking steps
+        while l > 0 and g == gapter[l - 1]:
+            l -= 1
+            B[A[l]] = B[l]
+            A[B[l]] = A[l]
+
+        if l > 0:
+            g -= 1
+            A[l] = gap[g]
+            B[l] = B[A[l]]
+            B[A[l]] = l
+            A[B[l]] = l
+            gapter[l] = g  # Save current gap index
+            l += 1         # Move to next leaf
+
+    return total_count

mapFolding/someAssemblyRequired/getLLVMforNoReason.py

@@ -12,6 +12,14 @@ The extracted LLVM IR can be valuable for debugging, optimization analysis, or e
 purposes, as it provides a view into how high-level Python code is translated into
 lower-level representations for machine execution.
 
+Example of successful use:
+The LLVM IR for the groundbreaking 2x19 map calculation can be found at:
+mapFolding/reference/jobsCompleted/[2x19]/[2x19].ll
+
+This file demonstrates the low-level optimizations that made this previously
+intractable calculation possible. The IR reveals how the abstract algorithm was
+transformed into efficient machine code through Numba's compilation pipeline.
+
 While originally part of a tighter integration with the code generation pipeline,
 this module now operates as a standalone utility that can be applied to any module
 containing Numba-compiled functions.
@@ -23,7 +31,18 @@ import importlib.util
 import llvmlite.binding
 
 def writeModuleLLVM(pathFilename: Path, identifierCallable: str) -> Path:
-    """Import the generated module directly and get its LLVM IR."""
+    """Import the generated module directly and get its LLVM IR.
+
+    Parameters
+        pathFilename: Path to the Python module file containing the Numba-compiled function
+        identifierCallable: Name of the function within the module to extract LLVM IR from
+
+    Returns
+        Path to the generated .ll file containing the extracted LLVM IR
+
+    For an example of the output, see reference/jobsCompleted/[2x19]/[2x19].ll,
+    which contains the IR for the historically significant 2x19 map calculation.
+    """
     specTarget: ModuleSpec | None = importlib.util.spec_from_file_location("generatedModule", pathFilename)
     if specTarget is None or specTarget.loader is None:
         raise ImportError(f"Could not create module spec or loader for {pathFilename}")

mapFolding/someAssemblyRequired/synthesizeNumbaFlow.py

@@ -22,6 +22,7 @@ to generate a fresh optimized implementation.
 """
 
 from mapFolding.someAssemblyRequired import (
+	ast_Identifier,
 	extractFunctionDef,
 	ifThis,
 	IngredientsFunction,
@@ -42,7 +43,17 @@ from mapFolding.someAssemblyRequired.transformDataStructures import shatter_data
 from mapFolding.theSSOT import raiseIfNoneGitHubIssueNumber3
 import ast
 
+def astModuleToIngredientsFunction(astModule: ast.Module, identifierFunctionDef: ast_Identifier) -> IngredientsFunction:
+	astFunctionDef = extractFunctionDef(astModule, identifierFunctionDef)
+	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
+	return IngredientsFunction(astFunctionDef, LedgerOfImports(astModule))
+
+
 def makeNumbaFlow(numbaFlow: RecipeSynthesizeFlow = RecipeSynthesizeFlow()) -> None:
+	# TODO a tool to automatically remove unused variables from the ArgumentsSpecification (return, and returns) _might_ be nice.
+	# TODO remember that `sequentialCallable` and `sourceSequentialCallable` are two different values.
+	# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
+	# ===========================================================
 	"""
 	Think about a better organization of this function.
 
@@ -61,34 +72,51 @@ def makeNumbaFlow(numbaFlow: RecipeSynthesizeFlow = RecipeSynthesizeFlow()) -> N
 	would be automatically triggered. I have no idea how that would happen, but the transformations are highly predictable,
 	so using a programming language to construct if-this-then-that cascades shouldn't be a problem, you know?
 
-	# TODO a tool to automatically remove unused variables from the ArgumentsSpecification (return, and returns) _might_ be nice.
 	"""
-	dictionaryReplacementStatements = makeDictionaryReplacementStatements(numbaFlow.source_astModule)
-	# TODO remember that `sequentialCallable` and `sourceSequentialCallable` are two different values.
-	# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
+	ingredientsDispatcher: IngredientsFunction = astModuleToIngredientsFunction(numbaFlow.source_astModule, numbaFlow.sourceDispatcherCallable)
+	ingredientsInitialize: IngredientsFunction = astModuleToIngredientsFunction(numbaFlow.source_astModule, numbaFlow.sourceInitializeCallable)
+	ingredientsParallel: IngredientsFunction = astModuleToIngredientsFunction(numbaFlow.source_astModule, numbaFlow.sourceParallelCallable)
+	ingredientsSequential: IngredientsFunction = astModuleToIngredientsFunction(numbaFlow.source_astModule, numbaFlow.sourceSequentialCallable)
 
+	# Inline functions
+	# NOTE Replacements statements are based on the identifiers in the _source_
+	dictionaryReplacementStatements = makeDictionaryReplacementStatements(numbaFlow.source_astModule)
+	ingredientsInitialize.astFunctionDef = inlineThisFunctionWithTheseValues(ingredientsInitialize.astFunctionDef, dictionaryReplacementStatements)
+	ingredientsParallel.astFunctionDef = inlineThisFunctionWithTheseValues(ingredientsParallel.astFunctionDef, dictionaryReplacementStatements)
+	ingredientsSequential.astFunctionDef = inlineThisFunctionWithTheseValues(ingredientsSequential.astFunctionDef, dictionaryReplacementStatements)
+
+	# Assign CALLABLE identifiers per the recipe.
+	# TODO Assign the other identifiers.
+	listIngredientsFunctions = [ingredientsDispatcher, ingredientsInitialize, ingredientsParallel, ingredientsSequential]
+	listFindReplace = [(numbaFlow.sourceDispatcherCallable, numbaFlow.dispatcherCallable),
+		(numbaFlow.sourceInitializeCallable, numbaFlow.initializeCallable),
+		(numbaFlow.sourceParallelCallable, numbaFlow.parallelCallable),
+		(numbaFlow.sourceSequentialCallable, numbaFlow.sequentialCallable)]
+	for ingredients in listIngredientsFunctions:
+		ImaNode = ingredients.astFunctionDef
+		for source_Identifier, Z0Z_Identifier in listFindReplace:
+			findThis = ifThis.isCall_Identifier(source_Identifier)
+			doThis = Then.replaceDOTfuncWith(Make.astName(Z0Z_Identifier))
+			NodeReplacer(findThis, doThis).visit(ImaNode)
+
+	ingredientsDispatcher.astFunctionDef.name = numbaFlow.dispatcherCallable
+	ingredientsInitialize.astFunctionDef.name = numbaFlow.initializeCallable
+	ingredientsParallel.astFunctionDef.name = numbaFlow.parallelCallable
+	ingredientsSequential.astFunctionDef.name = numbaFlow.sequentialCallable
 	# ===========================================================
-	sourcePython = numbaFlow.sourceDispatcherCallable
-	astFunctionDef = extractFunctionDef(sourcePython, numbaFlow.source_astModule)
-	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
-	ingredientsDispatcher = IngredientsFunction(astFunctionDef, LedgerOfImports(numbaFlow.source_astModule))
+	# Old organization
 
 	# sourceParallelCallable
 	shatteredDataclass = shatter_dataclassesDOTdataclass(numbaFlow.logicalPathModuleDataclass, numbaFlow.sourceDataclassIdentifier, numbaFlow.sourceDataclassInstanceTaskDistribution)
 	ingredientsDispatcher.imports.update(shatteredDataclass.ledgerDataclassANDFragments)
 
-	# TODO remove hardcoding
-	namespaceHARDCODED = 'concurrencyManager'
-	identifierHARDCODED = 'submit'
-	sourceNamespace = namespaceHARDCODED
-	sourceIdentifier = identifierHARDCODED
 	NodeReplacer(
-		findThis = ifThis.isAssignAndValueIsCallNamespace_Identifier(sourceNamespace, sourceIdentifier)
+		findThis = ifThis.isAssignAndValueIsCallNamespace_Identifier(numbaFlow.sourceConcurrencyManagerNamespace, numbaFlow.sourceConcurrencyManagerIdentifier)
 		, doThat = Then.insertThisAbove(shatteredDataclass.listAnnAssign4DataclassUnpack)
 			).visit(ingredientsDispatcher.astFunctionDef)
 	NodeReplacer(
-		findThis = ifThis.isCallNamespace_Identifier(sourceNamespace, sourceIdentifier)
-		, doThat = Then.replaceWith(Make.astCall(Make.astAttribute(Make.astName(sourceNamespace), sourceIdentifier)
+		findThis = ifThis.isCallNamespace_Identifier(numbaFlow.sourceConcurrencyManagerNamespace, numbaFlow.sourceConcurrencyManagerIdentifier)
+		, doThat = Then.replaceWith(Make.astCall(Make.astAttribute(Make.astName(numbaFlow.sourceConcurrencyManagerNamespace), numbaFlow.sourceConcurrencyManagerIdentifier)
 									, listArguments=[Make.astName(numbaFlow.parallelCallable)] + shatteredDataclass.listNameDataclassFragments4Parameters))
 			).visit(ingredientsDispatcher.astFunctionDef)
 
@@ -121,32 +149,20 @@ def makeNumbaFlow(numbaFlow: RecipeSynthesizeFlow = RecipeSynthesizeFlow()) -> N
 	ingredientsDispatcher.imports.update(shatteredDataclass.ledgerDataclassANDFragments)
 
 	NodeReplacer(
-		findThis = ifThis.isAssignAndValueIsCall_Identifier(numbaFlow.sourceSequentialCallable)
+		findThis = ifThis.isAssignAndValueIsCall_Identifier(numbaFlow.sourceSequentialCallable) # NOTE source
 		, doThat = Then.insertThisAbove(shatteredDataclass.listAnnAssign4DataclassUnpack)
 			).visit(ingredientsDispatcher.astFunctionDef)
 	NodeReplacer(
-		findThis = ifThis.isAssignAndValueIsCall_Identifier(numbaFlow.sourceSequentialCallable)
+		findThis = ifThis.isAssignAndValueIsCall_Identifier(numbaFlow.sourceSequentialCallable) # NOTE source
 		, doThat = Then.insertThisBelow([shatteredDataclass.astAssignDataclassRepack])
 			).visit(ingredientsDispatcher.astFunctionDef)
 	NodeReplacer(
-		findThis = ifThis.isAssignAndValueIsCall_Identifier(numbaFlow.sourceSequentialCallable)
+		findThis = ifThis.isAssignAndValueIsCall_Identifier(numbaFlow.sourceSequentialCallable) # NOTE source
 		, doThat = Then.replaceWith(Make.astAssign(listTargets=[shatteredDataclass.astTuple4AssignTargetsToFragments], value=Make.astCall(Make.astName(numbaFlow.sequentialCallable), shatteredDataclass.listNameDataclassFragments4Parameters)))
 			).visit(ingredientsDispatcher.astFunctionDef)
 
-	# ===========================================================
-	sourcePython = numbaFlow.sourceInitializeCallable
-	astFunctionDef = extractFunctionDef(sourcePython, numbaFlow.source_astModule)
-	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
-	astFunctionDef = inlineThisFunctionWithTheseValues(astFunctionDef, dictionaryReplacementStatements)
-	ingredientsInitialize = IngredientsFunction(astFunctionDef, LedgerOfImports(numbaFlow.source_astModule))
 
 	# ===========================================================
-	sourcePython = numbaFlow.sourceParallelCallable
-	astFunctionDef = extractFunctionDef(sourcePython, numbaFlow.source_astModule)
-	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
-	astFunctionDef = inlineThisFunctionWithTheseValues(astFunctionDef, dictionaryReplacementStatements)
-	ingredientsParallel = IngredientsFunction(astFunctionDef, LedgerOfImports(numbaFlow.source_astModule))
-	ingredientsParallel.astFunctionDef.name = numbaFlow.parallelCallable
 	ingredientsParallel.astFunctionDef.args = Make.astArgumentsSpecification(args=shatteredDataclass.list_ast_argAnnotated4ArgumentsSpecification)
 	NodeReplacer(
 		findThis = ifThis.isReturn
@@ -163,12 +179,6 @@ def makeNumbaFlow(numbaFlow: RecipeSynthesizeFlow = RecipeSynthesizeFlow()) -> N
 	ingredientsParallel = decorateCallableWithNumba(ingredientsParallel)
 
 	# ===========================================================
-	sourcePython = numbaFlow.sourceSequentialCallable
-	astFunctionDef = extractFunctionDef(sourcePython, numbaFlow.source_astModule)
-	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
-	astFunctionDef = inlineThisFunctionWithTheseValues(astFunctionDef, dictionaryReplacementStatements)
-	ingredientsSequential = IngredientsFunction(astFunctionDef, LedgerOfImports(numbaFlow.source_astModule))
-	ingredientsSequential.astFunctionDef.name = numbaFlow.sequentialCallable
 	ingredientsSequential.astFunctionDef.args = Make.astArgumentsSpecification(args=shatteredDataclass.list_ast_argAnnotated4ArgumentsSpecification)
 	NodeReplacer(
 		findThis = ifThis.isReturn
@@ -182,8 +192,13 @@ def makeNumbaFlow(numbaFlow: RecipeSynthesizeFlow = RecipeSynthesizeFlow()) -> N
 	replacementMap = {statement.value: statement.target for statement in shatteredDataclass.listAnnAssign4DataclassUnpack}
 	ingredientsSequential.astFunctionDef = Z0Z_replaceMatchingASTnodes(ingredientsSequential.astFunctionDef, replacementMap) # type: ignore
 	ingredientsSequential = decorateCallableWithNumba(ingredientsSequential)
+	# End old organization
+	# ===========================================================
 
 	# ===========================================================
+	# End function-level transformations
+	# ===========================================================
+	# Module-level transformations
 	ingredientsModuleNumbaUnified = IngredientsModule(
 		ingredientsFunction=[ingredientsInitialize,
 							ingredientsParallel,