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

mapFolding/reference/meandersDumpingGround/matrixMeanders64retired.py

@@ -0,0 +1,160 @@
+# ruff: noqa
+import numpy
+
+indexDistinctCrossings = int(0)  # noqa: RUF046, UP018
+indexBifurcationAlpha = int(1)  # noqa: RUF046, UP018
+indexBifurcationZulu = int(2)  # noqa: RUF046, UP018
+indexCurveLocations = int(3)  # noqa: RUF046, UP018
+
+def make1array(listArrays: list[numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]]]) -> numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]]:
+	arrayCurveLocations: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]] = numpy.fromiter({element for stupidSystem in listArrays for element in stupidSystem[:, 1]}, dtype=numpy.uint64)
+
+	arrayOut = numpy.column_stack((
+		numpy.zeros(len(arrayCurveLocations), dtype=numpy.uint64)
+		, arrayCurveLocations & numpy.uint64(0x5555555555555555)
+		, (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)
+
+	return arrayOut  # The next `arrayBifurcations`
+
+def convertDictionaryToNumPy(dictionaryIn: dict[int, int]) -> numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]]:
+	arrayKeys: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]] = numpy.fromiter(dictionaryIn.keys(), dtype=numpy.uint64)
+
+	return numpy.column_stack((
+		numpy.fromiter(dictionaryIn.values(), dtype=numpy.uint64)
+		, arrayKeys & numpy.uint64(0x5555555555555555)
+		, (arrayKeys & numpy.uint64(0xaaaaaaaaaaaaaaaa)) >> numpy.uint64(1)
+		, arrayKeys
+	))
+
+def count(bridges: int, startingCurveLocations: dict[int, int]) -> int:
+	arrayBifurcations: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]] = convertDictionaryToNumPy(startingCurveLocations)
+
+	while bridges > 0:
+		bridges -= 1
+
+		listArrayCurveLocationsAnalyzed: list[numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.uint64]]] = []
+
+		# 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)
+		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)
+		selectBifurcationZuluEven: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = (arrayBifurcations[:, indexBifurcationZulu] & numpy.uint64(1)) == numpy.uint64(0)
+
+		# 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
+		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)
+		))
+		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
+		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)
+			, (numpy.uint64(1) - (arrayBifurcations[selector, indexBifurcationZulu] & numpy.uint64(1)))
+		))
+		listArrayCurveLocationsAnalyzed.append(numpy.column_stack((arrayBifurcations[selector, indexDistinctCrossings][curveLocations < curveLocationsMAXIMUM], curveLocations[curveLocations < curveLocationsMAXIMUM])))
+
+		# Z0Z_bridgesBifurcationAlphaToRepair
+		selector: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((
+			selectBifurcationAlphaCurves, selectBifurcationZuluCurves, selectBifurcationAlphaEven, ~selectBifurcationZuluEven
+		))
+
+		# Initialize
+		XOrHere2makePair = numpy.uint64(1)
+
+		while selector.any():
+			XOrHere2makePair <<= numpy.uint64(2)
+
+			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
+			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))
+		)
+
+		listArrayCurveLocationsAnalyzed.append(numpy.column_stack((arrayBifurcations[selector, indexDistinctCrossings][curveLocations < curveLocationsMAXIMUM], curveLocations[curveLocations < curveLocationsMAXIMUM])))
+
+		# Z0Z_bridgesBifurcationZuluToRepair
+		selector: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.bool_]] = numpy.logical_and.reduce((
+			selectBifurcationAlphaCurves, selectBifurcationZuluCurves, ~selectBifurcationAlphaEven, selectBifurcationZuluEven
+		))
+
+		# Initialize
+		XOrHere2makePair: numpy.uint64 = numpy.uint64(1)
+
+		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((selector, selectUnpaired_0b1))
+
+			# Modify in place
+			arrayBifurcations[selectorUnified, indexBifurcationZulu] ^= XOrHere2makePair
+
+			# Remove the modified elements from the selector
+			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))
+		)
+
+		listArrayCurveLocationsAnalyzed.append(numpy.column_stack((arrayBifurcations[selector, indexDistinctCrossings][curveLocations < curveLocationsMAXIMUM], curveLocations[curveLocations < curveLocationsMAXIMUM])))
+
+		# Z0Z_bridgesAligned
+		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))
+		)
+
+		listArrayCurveLocationsAnalyzed.append(numpy.column_stack((arrayBifurcations[selector, indexDistinctCrossings][curveLocations < curveLocationsMAXIMUM], curveLocations[curveLocations < curveLocationsMAXIMUM])))
+
+		arrayBifurcations = make1array(listArrayCurveLocationsAnalyzed)
+
+		listArrayCurveLocationsAnalyzed.clear()
+
+		# print(int(sum(arrayBifurcations[:, 0])))
+	return int(sum(arrayBifurcations[:, 0]))
+

mapFolding/{_oeisFormulas/matrixMeanders.py → reference/meandersDumpingGround/matrixMeandersBaselineV2.py}

@@ -13,7 +13,7 @@ def count(bridges: int, startingCurveLocations: dict[int, int]) -> int:
 (0x1555555, 0x2aaaaaa, 0x1000000),
 (0x5555555, 0xaaaaaaa, 0x4000000),
 (0x15555555, 0x2aaaaaaa, 0x10000000),
-(0x55555555, 0xaaaaaaaa, 0x40000000),
+(0x55555555, 0xaaaaaaaa, 0x40000000), # `bridges = 13`, 0xaaaaaaaa.bit_length() = 32
 (0x155555555, 0x2aaaaaaaa, 0x100000000),
 (0x555555555, 0xaaaaaaaaa, 0x400000000),
 (0x1555555555, 0x2aaaaaaaaa, 0x1000000000),
@@ -29,7 +29,7 @@ def count(bridges: int, startingCurveLocations: dict[int, int]) -> int:
 (0x155555555555555, 0x2aaaaaaaaaaaaaa, 0x100000000000000),
 (0x555555555555555, 0xaaaaaaaaaaaaaaa, 0x400000000000000),
 (0x1555555555555555, 0x2aaaaaaaaaaaaaaa, 0x1000000000000000),
-(0x5555555555555555, 0xaaaaaaaaaaaaaaaa, 0x4000000000000000),
+(0x5555555555555555, 0xaaaaaaaaaaaaaaaa, 0x4000000000000000), # 0x5000000000000000.bit_length() = 63; 0xaaaaaaaaaaaaaaaa.bit_length() = 64; 0x5555555555555555.bit_length() = 63
 (0x15555555555555555, 0x2aaaaaaaaaaaaaaaa, 0x10000000000000000),
 (0x55555555555555555, 0xaaaaaaaaaaaaaaaaa, 0x40000000000000000),
 (0x155555555555555555, 0x2aaaaaaaaaaaaaaaaa, 0x100000000000000000),
@@ -63,6 +63,11 @@ def count(bridges: int, startingCurveLocations: dict[int, int]) -> int:
 (0x15555555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x10000000000000000000000000000000),
 (0x55555555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000000000000000),
 ]
+	"""`bridges = 29`
+	0x5000000000000000.bit_length() = 63;
+	0xaaaaaaaaaaaaaaaa.bit_length() = 64;
+	0x5555555555555555.bit_length() = 63"""
+
 	listCurveMaximums = listCurveMaximums[0:bridges]
 
 	dictionaryCurveLocations: dict[int, int] = {}
@@ -70,6 +75,7 @@ def count(bridges: int, startingCurveLocations: dict[int, int]) -> int:
 		bridges -= 1
 
 		bifurcationAlphaLocator, bifurcationZuluLocator, curveLocationsMAXIMUM = listCurveMaximums[bridges]
+
 		for curveLocations, distinctCrossings in startingCurveLocations.items():
 			bifurcationAlpha = (curveLocations & bifurcationAlphaLocator)
 			bifurcationZulu = (curveLocations & bifurcationZuluLocator) >> 1
@@ -77,41 +83,41 @@ def count(bridges: int, startingCurveLocations: dict[int, int]) -> int:
 			bifurcationAlphaHasCurves = bifurcationAlpha != 1
 			bifurcationZuluHasCurves = bifurcationZulu != 1
 
-			# Curve location analysis
+			# Z0Z_simpleBridges
 			curveLocationAnalysis = ((bifurcationAlpha | (bifurcationZulu << 1)) << 2) | 3
 			if curveLocationAnalysis < curveLocationsMAXIMUM:
 				dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
 
-			# Curve location analysis, conditional
-			if bifurcationZuluHasCurves:
-				curveLocationAnalysis = (bifurcationZulu >> 1) | (bifurcationAlpha << 2) | (bifurcationZuluIsEven := not (bifurcationZulu & 1))
+			# bifurcationAlphaCurves
+			if bifurcationAlphaHasCurves:
+				curveLocationAnalysis = (bifurcationAlphaShiftRight2 := bifurcationAlpha >> 2) | (bifurcationZulu << 3) | ((bifurcationAlphaIsEven := 1 - (bifurcationAlpha & 0b1)) << 1)
 				if curveLocationAnalysis < curveLocationsMAXIMUM:
 					dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
 
-			# Curve location analysis, conditional
-			if bifurcationAlphaHasCurves:
-				curveLocationAnalysis = (bifurcationAlphaShiftRight2 := bifurcationAlpha >> 2) | (bifurcationZulu << 3) | ((bifurcationAlphaIsEven := 1 - (bifurcationAlpha & 0b1)) << 1)
+			# bifurcationZuluCurves
+			if bifurcationZuluHasCurves:
+				curveLocationAnalysis = (bifurcationZulu >> 1) | (bifurcationAlpha << 2) | (bifurcationZuluIsEven := 1 - (bifurcationZulu & 1))
 				if curveLocationAnalysis < curveLocationsMAXIMUM:
 					dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
 
-			# Curve location analysis, uber-conditional
+			# Z0Z_alignedBridges
 			if bifurcationZuluHasCurves and bifurcationAlphaHasCurves:
 				# One Truth-check to select a code path
-				finalZeroCombination = (bifurcationZuluIsEven << 1) | bifurcationAlphaIsEven # pyright: ignore[reportPossiblyUnboundVariable]
+				bifurcationsCanBePairedTogether = (bifurcationZuluIsEven << 1) | bifurcationAlphaIsEven # pyright: ignore[reportPossiblyUnboundVariable]
 
-				if finalZeroCombination != 0:  # Case 0 (False, False)
+				if bifurcationsCanBePairedTogether != 0:  # Case 0 (False, False)
 					XOrHere2makePair = 0b1
-					findUnpairedBinary1 = 0
+					findUnpaired_0b1 = 0
 
-					if finalZeroCombination == 1:  # Case 1: (False, True)
-						while findUnpairedBinary1 >= 0:
+					if bifurcationsCanBePairedTogether == 1:  # Case 1: (False, True)
+						while findUnpaired_0b1 >= 0:
 							XOrHere2makePair <<= 2
-							findUnpairedBinary1 += 1 if (bifurcationAlpha & XOrHere2makePair) == 0 else -1
+							findUnpaired_0b1 += 1 if (bifurcationAlpha & XOrHere2makePair) == 0 else -1
 						bifurcationAlphaShiftRight2 = (bifurcationAlpha ^ XOrHere2makePair) >> 2
-					elif finalZeroCombination == 2:  # Case 2: (True, False)
-						while findUnpairedBinary1 >= 0:
+					elif bifurcationsCanBePairedTogether == 2:  # Case 2: (True, False)
+						while findUnpaired_0b1 >= 0:
 							XOrHere2makePair <<= 2
-							findUnpairedBinary1 += 1 if (bifurcationZulu & XOrHere2makePair) == 0 else -1
+							findUnpaired_0b1 += 1 if (bifurcationZulu & XOrHere2makePair) == 0 else -1
 						bifurcationZulu ^= XOrHere2makePair
 
 					# Cases 1, 2, and 3 all compute curveLocationAnalysis
@@ -120,7 +126,8 @@ def count(bridges: int, startingCurveLocations: dict[int, int]) -> int:
 					if curveLocationAnalysis < curveLocationsMAXIMUM:
 						dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
 
-		startingCurveLocations = dictionaryCurveLocations.copy()
-		dictionaryCurveLocations = {}
+		startingCurveLocations.clear()
+		startingCurveLocations, dictionaryCurveLocations = dictionaryCurveLocations, startingCurveLocations
 
 	return sum(startingCurveLocations.values())
+

mapFolding/someAssemblyRequired/A007822rawMaterials.py

@@ -21,7 +21,7 @@ def {Z0Z_identifier}(state: MapFoldingState) -> MapFoldingState:
 		ImaSymmetricFold = True
 		leafConnectee = 0
 		while leafConnectee < indexInMiddle:
-			if state.leafComparison[(state.indexMiniGap + leafConnectee) % (state.leavesTotal + 1)] != state.leafComparison[(state.indexMiniGap + state.leavesTotal + 1 - 2 - leafConnectee) % (state.leavesTotal + 1)]:
+			if state.leafComparison[(state.indexMiniGap + leafConnectee) % (state.leavesTotal + 1)] != state.leafComparison[(state.indexMiniGap + state.leavesTotal - 1 - leafConnectee) % (state.leavesTotal + 1)]:
 				ImaSymmetricFold = False
 				break
 			leafConnectee += 1

mapFolding/someAssemblyRequired/makeAllModules.py

@@ -711,16 +711,16 @@ def trimTheorem2(astModule: ast.Module, moduleIdentifier: str, callableIdentifie
 	return pathFilename
 
 if __name__ == '__main__':
-	astModule = _getModule(logicalPathInfix=None)
+	astModule = _getModule(logicalPathInfix='algorithms')
 	pathFilename: PurePath = makeDaoOfMapFoldingNumba(astModule, 'daoOfMapFoldingNumba', None, logicalPathInfixDEFAULT, sourceCallableDispatcherDEFAULT)
 
-	astModule = _getModule(logicalPathInfix=None)
+	astModule = _getModule(logicalPathInfix='algorithms')
 	pathFilename = makeDaoOfMapFoldingParallelNumba(astModule, 'countParallelNumba', None, logicalPathInfixDEFAULT, sourceCallableDispatcherDEFAULT)
 
-	astModule: ast.Module = _getModule(logicalPathInfix=None)
+	astModule: ast.Module = _getModule(logicalPathInfix='algorithms')
 	makeInitializeState(astModule, 'initializeState', 'transitionOnGroupsOfFolds', logicalPathInfixDEFAULT)
 
-	astModule = _getModule(logicalPathInfix=None)
+	astModule = _getModule(logicalPathInfix='algorithms')
 	pathFilename = makeTheorem2(astModule, 'theorem2', None, logicalPathInfixDEFAULT, None)
 
 	astModule = parsePathFilename2astModule(pathFilename)
@@ -733,7 +733,7 @@ if __name__ == '__main__':
 	makeUnRePackDataclass(astImportFrom)
 
 # A007822 -----------------------------------------------------------
-	astModule = _getModule(logicalPathInfix=None)
+	astModule = _getModule(logicalPathInfix='algorithms')
 	pathFilename = addSymmetryCheck(astModule, 'algorithmA007822', None, logicalPathInfixDEFAULT, None)
 
 	astModule = _getModule(moduleIdentifier='algorithmA007822')

mapFolding/someAssemblyRequired/makeJobTheorem2codon.py

@@ -5,13 +5,13 @@ https://docs.exaloop.io/start/install/
 
 from astToolkit import (
 	Be, DOT, extractFunctionDef, Grab, identifierDotAttribute, IngredientsFunction, IngredientsModule, Make, NodeChanger,
-	NodeTourist, Then)
+	NodeTourist, parseLogicalPath2astModule, Then)
 from astToolkit.transformationTools import removeUnusedParameters, write_astModule
 from hunterMakesPy import autoDecodingRLE, raiseIfNone
 from mapFolding import DatatypeLeavesTotal, getPathFilenameFoldsTotal, MapFoldingState
 from mapFolding.someAssemblyRequired import IfThis
 from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2
-from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds
+from mapFolding.syntheticModules.initializeStateA007822 import transitionOnGroupsOfFolds
 from pathlib import Path, PurePosixPath
 from typing import cast, NamedTuple, TYPE_CHECKING
 import ast
@@ -214,11 +214,12 @@ def fromMapShape(mapShape: tuple[DatatypeLeavesTotal, ...]) -> None:
 	"""
 	state = transitionOnGroupsOfFolds(MapFoldingState(mapShape))
 	pathModule = PurePosixPath(Path.home(), 'mapFolding', 'jobs')
+	source_astModule = parseLogicalPath2astModule('mapFolding.syntheticModules.theorem2A007822Numba')
 	pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(state.mapShape, pathModule))
-	aJob = RecipeJobTheorem2(state, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)
+	aJob = RecipeJobTheorem2(state, source_astModule=source_astModule, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)
 	makeJob(aJob)
 
 if __name__ == '__main__':
-	mapShape = (2, 21)
+	mapShape = (1, 15)
 	fromMapShape(mapShape)
 

mapFolding/syntheticModules/algorithmA007822.py

@@ -14,7 +14,7 @@ def filterAsymmetricFolds(state: MapFoldingState) -> MapFoldingState:
         ImaSymmetricFold = True
         leafConnectee = 0
         while leafConnectee < indexInMiddle:
-            if state.leafComparison[(state.indexMiniGap + leafConnectee) % (state.leavesTotal + 1)] != state.leafComparison[(state.indexMiniGap + state.leavesTotal + 1 - 2 - leafConnectee) % (state.leavesTotal + 1)]:
+            if state.leafComparison[(state.indexMiniGap + leafConnectee) % (state.leavesTotal + 1)] != state.leafComparison[(state.indexMiniGap + state.leavesTotal - 1 - leafConnectee) % (state.leavesTotal + 1)]:
                 ImaSymmetricFold = False
                 break
             leafConnectee += 1

mapFolding/syntheticModules/algorithmA007822Numba.py

@@ -1,4 +1,6 @@
-from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, MapFoldingState
+from mapFolding.dataBaskets import (
+	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
+	MapFoldingState)
 from numba import jit
 
 @jit(cache=True, error_model='numpy', fastmath=True, forceinline=True)
@@ -19,7 +21,7 @@ def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1nde
                     ImaSymmetricFold = True
                     leafConnectee = 0
                     while leafConnectee < indexInMiddle:
-                        if leafComparison[(indexMiniGap + leafConnectee) % (leavesTotal + 1)] != leafComparison[(indexMiniGap + leavesTotal + 1 - 2 - leafConnectee) % (leavesTotal + 1)]:
+                        if leafComparison[(indexMiniGap + leafConnectee) % (leavesTotal + 1)] != leafComparison[(indexMiniGap + leavesTotal - 1 - leafConnectee) % (leavesTotal + 1)]:
                             ImaSymmetricFold = False
                             break
                         leafConnectee += 1
@@ -92,4 +94,4 @@ def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
     leavesTotal: DatatypeLeavesTotal = state.leavesTotal
     groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, connectionGraph, dimensionsTotal, leavesTotal = count(groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, connectionGraph, dimensionsTotal, leavesTotal)
     state = MapFoldingState(mapShape=mapShape, groupsOfFolds=groupsOfFolds, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, dimensionsUnconstrained=dimensionsUnconstrained, countDimensionsGapped=countDimensionsGapped, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow, leafComparison=leafComparison)
-    return state
+    return state

mapFolding/syntheticModules/dataPacking.py

@@ -1,6 +1,4 @@
-from mapFolding.dataBaskets import (
-	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
-	MapFoldingState)
+from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, MapFoldingState
 from mapFolding.syntheticModules.theorem2Numba import count
 
 def sequential(state: MapFoldingState) -> MapFoldingState:
@@ -25,4 +23,4 @@ def sequential(state: MapFoldingState) -> MapFoldingState:
     leavesTotal: DatatypeLeavesTotal = state.leavesTotal
     groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal = count(groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal)
     state = MapFoldingState(mapShape=mapShape, groupsOfFolds=groupsOfFolds, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, dimensionsUnconstrained=dimensionsUnconstrained, countDimensionsGapped=countDimensionsGapped, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow, leafComparison=leafComparison)
-    return state
+    return state

mapFolding/syntheticModules/dataPackingA007822.py

@@ -1,6 +1,4 @@
-from mapFolding.dataBaskets import (
-	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
-	MapFoldingState)
+from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, MapFoldingState
 from mapFolding.syntheticModules.theorem2A007822Numba import count
 
 def sequential(state: MapFoldingState) -> MapFoldingState:
@@ -25,4 +23,4 @@ def sequential(state: MapFoldingState) -> MapFoldingState:
     leavesTotal: DatatypeLeavesTotal = state.leavesTotal
     groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, connectionGraph, dimensionsTotal, leavesTotal = count(groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, leafComparison, connectionGraph, dimensionsTotal, leavesTotal)
     state = MapFoldingState(mapShape=mapShape, groupsOfFolds=groupsOfFolds, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, dimensionsUnconstrained=dimensionsUnconstrained, countDimensionsGapped=countDimensionsGapped, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow, leafComparison=leafComparison)
-    return state
+    return state

mapFolding/syntheticModules/initializeStateA007822.py

@@ -17,7 +17,7 @@ def transitionOnGroupsOfFolds(state: MapFoldingState) -> MapFoldingState:
                     ImaSymmetricFold = True
                     leafConnectee = 0
                     while leafConnectee < indexInMiddle:
-                        if state.leafComparison[(state.indexMiniGap + leafConnectee) % (state.leavesTotal + 1)] != state.leafComparison[(state.indexMiniGap + state.leavesTotal + 1 - 2 - leafConnectee) % (state.leavesTotal + 1)]:
+                        if state.leafComparison[(state.indexMiniGap + leafConnectee) % (state.leavesTotal + 1)] != state.leafComparison[(state.indexMiniGap + state.leavesTotal - 1 - leafConnectee) % (state.leavesTotal + 1)]:
                             ImaSymmetricFold = False
                             break
                         leafConnectee += 1

mapFolding/syntheticModules/theorem2A007822.py

@@ -17,7 +17,7 @@ def count(state: MapFoldingState) -> MapFoldingState:
                     ImaSymmetricFold = True
                     leafConnectee = 0
                     while leafConnectee < indexInMiddle:
-                        if state.leafComparison[(state.indexMiniGap + leafConnectee) % (state.leavesTotal + 1)] != state.leafComparison[(state.indexMiniGap + state.leavesTotal + 1 - 2 - leafConnectee) % (state.leavesTotal + 1)]:
+                        if state.leafComparison[(state.indexMiniGap + leafConnectee) % (state.leavesTotal + 1)] != state.leafComparison[(state.indexMiniGap + state.leavesTotal - 1 - leafConnectee) % (state.leavesTotal + 1)]:
                             ImaSymmetricFold = False
                             break
                         leafConnectee += 1

mapFolding/syntheticModules/theorem2A007822Numba.py

@@ -19,7 +19,7 @@ def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1nde
                     ImaSymmetricFold = True
                     leafConnectee = 0
                     while leafConnectee < indexInMiddle:
-                        if leafComparison[(indexMiniGap + leafConnectee) % (leavesTotal + 1)] != leafComparison[(indexMiniGap + leavesTotal + 1 - 2 - leafConnectee) % (leavesTotal + 1)]:
+                        if leafComparison[(indexMiniGap + leafConnectee) % (leavesTotal + 1)] != leafComparison[(indexMiniGap + leavesTotal - 1 - leafConnectee) % (leavesTotal + 1)]:
                             ImaSymmetricFold = False
                             break
                         leafConnectee += 1

mapFolding/syntheticModules/theorem2A007822Trimmed.py

@@ -17,7 +17,7 @@ def count(state: MapFoldingState) -> MapFoldingState:
                     ImaSymmetricFold = True
                     leafConnectee = 0
                     while leafConnectee < indexInMiddle:
-                        if state.leafComparison[(state.indexMiniGap + leafConnectee) % (state.leavesTotal + 1)] != state.leafComparison[(state.indexMiniGap + state.leavesTotal + 1 - 2 - leafConnectee) % (state.leavesTotal + 1)]:
+                        if state.leafComparison[(state.indexMiniGap + leafConnectee) % (state.leavesTotal + 1)] != state.leafComparison[(state.indexMiniGap + state.leavesTotal - 1 - leafConnectee) % (state.leavesTotal + 1)]:
                             ImaSymmetricFold = False
                             break
                         leafConnectee += 1

mapFolding/tests/conftest.py

@@ -25,7 +25,7 @@ research domain.
 
 from collections.abc import Callable, Generator, Sequence
 from mapFolding import _theSSOT, getLeavesTotal, makeDataContainer, packageSettings, validateListDimensions
-from mapFolding.oeis import dictionaryOEIS, oeisIDsImplemented
+from mapFolding.oeis import dictionaryOEISMapFolding, dictionaryOEISMeanders, oeisIDsImplemented
 from pathlib import Path
 from typing import Any
 import numpy
@@ -212,10 +212,10 @@ def oneTestCuzTestsOverwritingTests(oeisID_1random: str) -> tuple[int, ...]:
 
 	"""
 	while True:
-		n = random.choice(dictionaryOEIS[oeisID_1random]['valuesTestValidation'])
+		n = random.choice(dictionaryOEISMapFolding[oeisID_1random]['valuesTestValidation'])
 		if n < 2:
 			continue
-		listDimensionsCandidate = list(dictionaryOEIS[oeisID_1random]['getMapShape'](n))
+		listDimensionsCandidate = list(dictionaryOEISMapFolding[oeisID_1random]['getMapShape'](n))
 
 		try:
 			return validateListDimensions(listDimensionsCandidate)
@@ -224,7 +224,8 @@ def oneTestCuzTestsOverwritingTests(oeisID_1random: str) -> tuple[int, ...]:
 
 @pytest.fixture
 def mapShapeTestCountFolds(oeisID: str) -> tuple[int, ...]:
-	"""For each `oeisID` from the `pytest.fixture`, returns `listDimensions` from `valuesTestValidation` if `validateListDimensions` approves. Each `listDimensions` is suitable for testing counts.
+	"""For each `oeisID` from the `pytest.fixture`, returns `listDimensions` from `valuesTestValidation` if
+	`validateListDimensions` approves. Each `listDimensions` is suitable for testing counts.
 
 	Parameters
 	----------
@@ -238,10 +239,10 @@ def mapShapeTestCountFolds(oeisID: str) -> tuple[int, ...]:
 
 	"""
 	while True:
-		n = random.choice(dictionaryOEIS[oeisID]['valuesTestValidation'])
+		n = random.choice(dictionaryOEISMapFolding[oeisID]['valuesTestValidation'])
 		if n < 2:
 			continue
-		listDimensionsCandidate = list(dictionaryOEIS[oeisID]['getMapShape'](n))
+		listDimensionsCandidate = list(dictionaryOEISMapFolding[oeisID]['getMapShape'](n))
 
 		try:
 			return validateListDimensions(listDimensionsCandidate)
@@ -266,10 +267,10 @@ def mapShapeTestFunctionality(oeisID_1random: str) -> tuple[int, ...]:
 
 	"""
 	while True:
-		n = random.choice(dictionaryOEIS[oeisID_1random]['valuesTestValidation'])
+		n = random.choice(dictionaryOEISMapFolding[oeisID_1random]['valuesTestValidation'])
 		if n < 2:
 			continue
-		listDimensionsCandidate = list(dictionaryOEIS[oeisID_1random]['getMapShape'](n))
+		listDimensionsCandidate = list(dictionaryOEISMapFolding[oeisID_1random]['getMapShape'](n))
 
 		try:
 			return validateListDimensions(listDimensionsCandidate)
@@ -291,8 +292,8 @@ def mapShapeTestParallelization(oeisID: str) -> tuple[int, ...]:
 		Map dimensions suitable for testing parallelization features.
 
 	"""
-	n = random.choice(dictionaryOEIS[oeisID]['valuesTestParallelization'])
-	return dictionaryOEIS[oeisID]['getMapShape'](n)
+	n = random.choice(dictionaryOEISMapFolding[oeisID]['valuesTestParallelization'])
+	return dictionaryOEISMapFolding[oeisID]['getMapShape'](n)
 
 @pytest.fixture
 def mockBenchmarkTimer() -> Generator[unittest.mock.MagicMock | unittest.mock.AsyncMock, Any, None]:
@@ -349,6 +350,25 @@ def oeisID(request: pytest.FixtureRequest) -> Any:
 	"""
 	return request.param
 
+@pytest.fixture(params=tuple(dictionaryOEISMeanders.keys()))
+def oeisIDMeanders(request: pytest.FixtureRequest) -> Any:
+	"""Parametrized fixture providing all implemented Meanders OEIS sequence identifiers.
+
+	(AI generated docstring)
+
+	Parameters
+	----------
+	request : pytest.FixtureRequest
+		The pytest request object containing the current parameter value.
+
+	Returns
+	-------
+	sequenceIdentifier : Any
+		OEIS sequence identifier for testing across all implemented Meanders sequences.
+
+	"""
+	return request.param
+
 @pytest.fixture
 def oeisID_1random() -> str:
 	"""Return one random valid OEIS ID.