mapFolding 0.8.1__py3-none-any.whl → 0.8.2__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/synthesizeNumbaFlow.py

@@ -77,18 +77,13 @@ def makeNumbaFlow(numbaFlow: RecipeSynthesizeFlow = RecipeSynthesizeFlow()) -> N
 	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)
 
@@ -133,6 +128,8 @@ def makeNumbaFlow(numbaFlow: RecipeSynthesizeFlow = RecipeSynthesizeFlow()) -> N
 		, doThat = Then.replaceWith(Make.astAssign(listTargets=[shatteredDataclass.astTuple4AssignTargetsToFragments], value=Make.astCall(Make.astName(numbaFlow.sequentialCallable), shatteredDataclass.listNameDataclassFragments4Parameters)))
 			).visit(ingredientsDispatcher.astFunctionDef)
 
+	ingredientsDispatcher.astFunctionDef.name = numbaFlow.dispatcherCallable
+
 	# ===========================================================
 	sourcePython = numbaFlow.sourceInitializeCallable
 	astFunctionDef = extractFunctionDef(sourcePython, numbaFlow.source_astModule)

mapFolding/someAssemblyRequired/transformDataStructures.py

@@ -21,7 +21,7 @@ designed to be applicable to various data structure transformation scenarios.
 """
 
 from collections.abc import Sequence
-from importlib import import_module
+from importlib import import_module as importlib_import_module
 from inspect import getsource as inspect_getsource
 from mapFolding.beDRY import outfitCountFolds, validateListDimensions
 from mapFolding.filesystem import getPathFilenameFoldsTotal
@@ -36,7 +36,7 @@ from mapFolding.someAssemblyRequired import (
 	Then,
 	Z0Z_executeActionUnlessDescendantMatches,
 )
-from mapFolding.theSSOT import ComputationState, getSourceAlgorithm
+from mapFolding.theSSOT import ComputationState, The
 from pathlib import Path
 from types import ModuleType
 from typing import Any, Literal, overload
@@ -69,7 +69,9 @@ def shatter_dataclassesDOTdataclass(logicalPathModule: strDotStrCuzPyStoopid, da
 		dataclass_Identifier: The identifier of the dataclass to be dismantled.
 		instance_Identifier: In the synthesized module/function/scope, the identifier that will be used for the instance.
 	"""
-	module: ast.Module = ast.parse(inspect_getsource(import_module(logicalPathModule)))
+	# TODO learn whether dataclasses.make_dataclass would be useful to transform the target dataclass into the `ShatteredDataclass`
+
+	module: ast.Module = ast.parse(inspect_getsource(importlib_import_module(logicalPathModule)))
 	astName_dataclassesDOTdataclass = Make.astName(dataclass_Identifier)
 
 	dataclass = extractClassDef(dataclass_Identifier, module)
@@ -122,6 +124,10 @@ def shatter_dataclassesDOTdataclass(logicalPathModule: strDotStrCuzPyStoopid, da
 	shatteredDataclass.ledgerDataclassANDFragments.addImportFromStr(logicalPathModule, dataclass_Identifier)
 	return shatteredDataclass
 
+def getSourceAlgorithmVESTIGIAL() -> ModuleType:
+	moduleImported: ModuleType = importlib_import_module(The.logicalPathModuleSourceAlgorithm)
+	return moduleImported
+
 @overload
 def makeStateJobOUTDATED(listDimensions: Sequence[int], *, writeJob: Literal[True], **keywordArguments: Any) -> Path: ...
 @overload
@@ -145,7 +151,7 @@ def makeStateJobOUTDATED(listDimensions: Sequence[int], *, writeJob: bool = True
 	mapShape = validateListDimensions(listDimensions)
 	stateUniversal: ComputationState = outfitCountFolds(mapShape, **keywordArguments)
 
-	moduleSource: ModuleType = getSourceAlgorithm()
+	moduleSource: ModuleType = getSourceAlgorithmVESTIGIAL()
 	# TODO `countInitialize` is hardcoded
 	stateUniversal = moduleSource.countInitialize(stateUniversal)
 

mapFolding/someAssemblyRequired/transformationTools.py

@@ -26,27 +26,16 @@ from autoflake import fix_code as autoflake_fix_code
 from collections import defaultdict
 from collections.abc import Callable, Container, Sequence
 from copy import deepcopy
+from importlib import import_module as importlib_import_module
 from inspect import getsource as inspect_getsource
 from mapFolding.filesystem import writeStringToHere
 from mapFolding.theSSOT import (
-	getSourceAlgorithm,
 	raiseIfNoneGitHubIssueNumber3,
-	theDataclassIdentifier,
-	theDataclassInstance,
-	theDataclassInstanceTaskDistribution,
-	theDispatcherCallable,
-	theFileExtension,
+	The,
 	theFormatStrModuleForCallableSynthetic,
 	theFormatStrModuleSynthetic,
-	theLogicalPathModuleDataclass,
 	theLogicalPathModuleDispatcherSynthetic,
 	theModuleDispatcherSynthetic,
-	theModuleOfSyntheticModules,
-	thePackageName,
-	thePathPackage,
-	theSourceInitializeCallable,
-	theSourceParallelCallable,
-	theSourceSequentialCallable,
 )
 from os import PathLike
 from pathlib import Path, PurePath, PurePosixPath
@@ -563,25 +552,27 @@ class RecipeSynthesizeFlow:
 	"""Settings for synthesizing flow."""
 	# ========================================
 	# Source
-	sourceAlgorithm: ModuleType = getSourceAlgorithm()
+	sourceAlgorithm: ModuleType = importlib_import_module(The.logicalPathModuleSourceAlgorithm)
 	sourcePython: str = inspect_getsource(sourceAlgorithm)
 	source_astModule: ast.Module = ast.parse(sourcePython)
 
 	# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
-	sourceDispatcherCallable: str = theDispatcherCallable
-	sourceInitializeCallable: str = theSourceInitializeCallable
-	sourceParallelCallable: str = theSourceParallelCallable
-	sourceSequentialCallable: str = theSourceSequentialCallable
-
-	sourceDataclassIdentifier: str = theDataclassIdentifier
-	sourceDataclassInstance: str = theDataclassInstance
-	sourceDataclassInstanceTaskDistribution: str = theDataclassInstanceTaskDistribution
-	sourcePathModuleDataclass: str = theLogicalPathModuleDataclass
-
+	sourceDispatcherCallable: str = The.dispatcherCallable
+	sourceInitializeCallable: str = The.sourceInitializeCallable
+	sourceParallelCallable: str = The.sourceParallelCallable
+	sourceSequentialCallable: str = The.sourceSequentialCallable
+
+	sourceDataclassIdentifier: str = The.dataclassIdentifier
+	sourceDataclassInstance: str = The.dataclassInstance
+	sourceDataclassInstanceTaskDistribution: str = The.dataclassInstanceTaskDistribution
+	sourcePathModuleDataclass: str = The.logicalPathModuleDataclass
+
+	sourceConcurrencyManagerNamespace = The.sourceConcurrencyManagerNamespace
+	sourceConcurrencyManagerIdentifier = The.sourceConcurrencyManagerIdentifier
 	# ========================================
 	# Filesystem
-	pathPackage: PurePosixPath | None = PurePosixPath(thePathPackage)
-	fileExtension: str = theFileExtension
+	pathPackage: PurePosixPath | None = PurePosixPath(The.pathPackage)
+	fileExtension: str = The.fileExtension
 
 	# ========================================
 	# Logical identifiers
@@ -590,11 +581,11 @@ class RecipeSynthesizeFlow:
 	formatStrModuleForCallableSynthetic: str = theFormatStrModuleForCallableSynthetic
 
 	# Package
-	packageName: ast_Identifier | None = thePackageName
+	packageName: ast_Identifier | None = The.packageName
 
 	# Module
 	# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
-	Z0Z_flowLogicalPathRoot: str = theModuleOfSyntheticModules
+	Z0Z_flowLogicalPathRoot: str | None = The.moduleOfSyntheticModules
 	moduleDispatcher: str = theModuleDispatcherSynthetic
 	logicalPathModuleDataclass: str = sourcePathModuleDataclass
 	# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4