mapFolding 0.14.1__py3-none-any.whl → 0.15.1__py3-none-any.whl

mapFolding/reference/A005316primitiveOptimized.py

@@ -1,5 +1,5 @@
-bifurcationOddLocator = 0x55555555555555555555555555555555
-bitWidth = 1 << (bifurcationOddLocator.bit_length() - 1).bit_length()
+bifurcationAlphaLocator = 0x55555555555555555555555555555555
+bitWidth = 1 << (bifurcationAlphaLocator.bit_length() - 1).bit_length()
 
 def count(bridges: int, dictionaryCurveLocationsKnown: dict[int, int]) -> int:
 	while bridges > 0:
@@ -9,53 +9,53 @@ def count(bridges: int, dictionaryCurveLocationsKnown: dict[int, int]) -> int:
 		dictionaryCurveLocationsDiscovered: dict[int, int] = {}
 
 		for curveLocations, distinctCrossings in dictionaryCurveLocationsKnown.items():
-			global bifurcationOddLocator, bitWidth  # noqa: PLW0603
+			global bifurcationAlphaLocator, bitWidth  # noqa: PLW0603
 
-			if curveLocations > bifurcationOddLocator:
-				while curveLocations > bifurcationOddLocator:
-					bifurcationOddLocator |= bifurcationOddLocator << bitWidth
+			if curveLocations > bifurcationAlphaLocator:
+				while curveLocations > bifurcationAlphaLocator:
+					bifurcationAlphaLocator |= bifurcationAlphaLocator << bitWidth
 					bitWidth <<= 1
 
-			bifurcationOdd = curveLocations & bifurcationOddLocator
-			bifurcationEven = (curveLocations ^ bifurcationOdd) >> 1
+			bifurcationAlpha = curveLocations & bifurcationAlphaLocator
+			bifurcationZulu = (curveLocations ^ bifurcationAlpha) >> 1
 
-			bifurcationOddHasCurves = bifurcationOdd != 1
-			bifurcationEvenHasCurves = bifurcationEven != 1
-			bifurcationOddFinalZero = (bifurcationOdd & 1) == 0
-			bifurcationEvenFinalZero = (bifurcationEven & 1) == 0
+			bifurcationAlphaHasCurves = bifurcationAlpha != 1
+			bifurcationZuluHasCurves = bifurcationZulu != 1
+			bifurcationAlphaFinalZero = (bifurcationAlpha & 1) == 0
+			bifurcationZuluFinalZero = (bifurcationZulu & 1) == 0
 
-			if bifurcationOddHasCurves:
-				curveLocationAnalysis = (bifurcationOdd >> 2) | (bifurcationEven << 3) | (bifurcationOddFinalZero << 1)
+			if bifurcationAlphaHasCurves:
+				curveLocationAnalysis = (bifurcationAlpha >> 2) | (bifurcationZulu << 3) | (bifurcationAlphaFinalZero << 1)
 				if curveLocationAnalysis < curveLocationsMAXIMUM:
 					dictionaryCurveLocationsDiscovered[curveLocationAnalysis] = dictionaryCurveLocationsDiscovered.get(curveLocationAnalysis, 0) + distinctCrossings
 
-			if bifurcationEvenHasCurves:
-				curveLocationAnalysis = (bifurcationEven >> 1) | ((bifurcationOdd << 2) | bifurcationEvenFinalZero)
+			if bifurcationZuluHasCurves:
+				curveLocationAnalysis = (bifurcationZulu >> 1) | ((bifurcationAlpha << 2) | bifurcationZuluFinalZero)
 				if curveLocationAnalysis < curveLocationsMAXIMUM:
 					dictionaryCurveLocationsDiscovered[curveLocationAnalysis] = dictionaryCurveLocationsDiscovered.get(curveLocationAnalysis, 0) + distinctCrossings
 
-			curveLocationAnalysis = ((bifurcationOdd | (bifurcationEven << 1)) << 2) | 3
+			curveLocationAnalysis = ((bifurcationAlpha | (bifurcationZulu << 1)) << 2) | 3
 			if curveLocationAnalysis < curveLocationsMAXIMUM:
 				dictionaryCurveLocationsDiscovered[curveLocationAnalysis] = dictionaryCurveLocationsDiscovered.get(curveLocationAnalysis, 0) + distinctCrossings
 
-			if bifurcationOddHasCurves and bifurcationEvenHasCurves and (bifurcationOddFinalZero or bifurcationEvenFinalZero):
-				if bifurcationOddFinalZero and not bifurcationEvenFinalZero:
+			if bifurcationAlphaHasCurves and bifurcationZuluHasCurves and (bifurcationAlphaFinalZero or bifurcationZuluFinalZero):
+				if bifurcationAlphaFinalZero and not bifurcationZuluFinalZero:
 					Z0Z_idk = 0
 					Z0Z_indexIDK = 1
 					while Z0Z_idk >= 0:
 						Z0Z_indexIDK <<= 2
-						Z0Z_idk += 1 if (bifurcationOdd & Z0Z_indexIDK) == 0 else -1
-					bifurcationOdd ^= Z0Z_indexIDK
+						Z0Z_idk += 1 if (bifurcationAlpha & Z0Z_indexIDK) == 0 else -1
+					bifurcationAlpha ^= Z0Z_indexIDK
 
-				if bifurcationEvenFinalZero and not bifurcationOddFinalZero:
+				if bifurcationZuluFinalZero and not bifurcationAlphaFinalZero:
 					Z0Z_idk = 0
 					Z0Z_indexIDK = 1
 					while Z0Z_idk >= 0:
 						Z0Z_indexIDK <<= 2
-						Z0Z_idk += 1 if (bifurcationEven & Z0Z_indexIDK) == 0 else -1
-					bifurcationEven ^= Z0Z_indexIDK
+						Z0Z_idk += 1 if (bifurcationZulu & Z0Z_indexIDK) == 0 else -1
+					bifurcationZulu ^= Z0Z_indexIDK
 
-				curveLocationAnalysis = (bifurcationOdd >> 2) | ((bifurcationEven >> 2) << 1)
+				curveLocationAnalysis = (bifurcationAlpha >> 2) | ((bifurcationZulu >> 2) << 1)
 				if curveLocationAnalysis < curveLocationsMAXIMUM:
 					dictionaryCurveLocationsDiscovered[curveLocationAnalysis] = dictionaryCurveLocationsDiscovered.get(curveLocationAnalysis, 0) + distinctCrossings
 

mapFolding/reference/A005316redis.py

@@ -34,41 +34,41 @@ def count(bridges: int, curveLocationsKnown: dict[int, int]) -> int:
 			curveLocations = int(str(keyName).split(":")[1])
 			distinctCrossings = int(str(redisClient.get(keyName)))
 
-			bifurcationOdd = curveLocations & 0x5555555555555555555555555555555555555555555555555555555555555555
-			bifurcationEven = (curveLocations ^ bifurcationOdd) >> 1
+			bifurcationAlpha = curveLocations & 0x5555555555555555555555555555555555555555555555555555555555555555
+			bifurcationZulu = (curveLocations ^ bifurcationAlpha) >> 1
 
-			bifurcationOddHasCurves = bifurcationOdd != 1
-			bifurcationEvenHasCurves = bifurcationEven != 1
-			bifurcationOddFinalZero = not bifurcationOdd & 1
-			bifurcationEvenFinalZero = not bifurcationEven & 1
+			bifurcationAlphaHasCurves = bifurcationAlpha != 1
+			bifurcationZuluHasCurves = bifurcationZulu != 1
+			bifurcationAlphaFinalZero = not bifurcationAlpha & 1
+			bifurcationZuluFinalZero = not bifurcationZulu & 1
 
-			if bifurcationOddHasCurves:
-				curveLocationAnalysis = (bifurcationOdd >> 2) | (bifurcationEven << 3) | (bifurcationOddFinalZero << 1)
+			if bifurcationAlphaHasCurves:
+				curveLocationAnalysis = (bifurcationAlpha >> 2) | (bifurcationZulu << 3) | (bifurcationAlphaFinalZero << 1)
 				storeCurveLocations(curveLocationAnalysis, distinctCrossings)
 
-			if bifurcationEvenHasCurves:
-				curveLocationAnalysis = (bifurcationEven >> 1) | (bifurcationOdd << 2) | bifurcationEvenFinalZero
+			if bifurcationZuluHasCurves:
+				curveLocationAnalysis = (bifurcationZulu >> 1) | (bifurcationAlpha << 2) | bifurcationZuluFinalZero
 				storeCurveLocations(curveLocationAnalysis, distinctCrossings)
 
-			curveLocationAnalysis = ((bifurcationOdd | (bifurcationEven << 1)) << 2) | 3
+			curveLocationAnalysis = ((bifurcationAlpha | (bifurcationZulu << 1)) << 2) | 3
 			storeCurveLocations(curveLocationAnalysis, distinctCrossings)
 
-			if bifurcationOddHasCurves and bifurcationEvenHasCurves and (bifurcationOddFinalZero or bifurcationEvenFinalZero):
+			if bifurcationAlphaHasCurves and bifurcationZuluHasCurves and (bifurcationAlphaFinalZero or bifurcationZuluFinalZero):
 				XOrHere2makePair = 0b1
 				findUnpairedBinary1 = 0
-				if bifurcationOddFinalZero and not bifurcationEvenFinalZero:
+				if bifurcationAlphaFinalZero and not bifurcationZuluFinalZero:
 					while findUnpairedBinary1 >= 0:
 						XOrHere2makePair <<= 2
-						findUnpairedBinary1 += 1 if (bifurcationOdd & XOrHere2makePair) == 0 else -1
-					bifurcationOdd ^= XOrHere2makePair
+						findUnpairedBinary1 += 1 if (bifurcationAlpha & XOrHere2makePair) == 0 else -1
+					bifurcationAlpha ^= XOrHere2makePair
 
-				elif bifurcationEvenFinalZero and not bifurcationOddFinalZero:
+				elif bifurcationZuluFinalZero and not bifurcationAlphaFinalZero:
 					while findUnpairedBinary1 >= 0:
 						XOrHere2makePair <<= 2
-						findUnpairedBinary1 += 1 if (bifurcationEven & XOrHere2makePair) == 0 else -1
-					bifurcationEven ^= XOrHere2makePair
+						findUnpairedBinary1 += 1 if (bifurcationZulu & XOrHere2makePair) == 0 else -1
+					bifurcationZulu ^= XOrHere2makePair
 
-				curveLocationAnalysis = (bifurcationOdd >> 2) | ((bifurcationEven >> 2) << 1)
+				curveLocationAnalysis = (bifurcationAlpha >> 2) | ((bifurcationZulu >> 2) << 1)
 				storeCurveLocations(curveLocationAnalysis, distinctCrossings)
 
 		# Move discovered data to known for next iteration

mapFolding/reference/A005316write2disk.py

@@ -86,41 +86,41 @@ def recordAnalysis(bridges: int, curveLocationAnalysis: int, distinctCrossings:
 	bookkeeper.start()
 
 def analyzeCurves(bridges: int, curveLocations: int, distinctCrossings: int) -> None:
-	bifurcationOdd = curveLocations & 0x5555555555555555555555555555555555555555555555555555555555555555
-	bifurcationEven = (curveLocations ^ bifurcationOdd) >> 1
+	bifurcationAlpha = curveLocations & 0x5555555555555555555555555555555555555555555555555555555555555555
+	bifurcationZulu = (curveLocations ^ bifurcationAlpha) >> 1
 
-	bifurcationOddHasCurves = bifurcationOdd != 1
-	bifurcationEvenHasCurves = bifurcationEven != 1
-	bifurcationOddFinalZero = not bifurcationOdd & 1
-	bifurcationEvenFinalZero = not bifurcationEven & 1
+	bifurcationAlphaHasCurves = bifurcationAlpha != 1
+	bifurcationZuluHasCurves = bifurcationZulu != 1
+	bifurcationAlphaFinalZero = not bifurcationAlpha & 1
+	bifurcationZuluFinalZero = not bifurcationZulu & 1
 
-	if bifurcationOddHasCurves:
-		curveLocationAnalysis = (bifurcationOdd >> 2) | (bifurcationEven << 3) | (bifurcationOddFinalZero << 1)
+	if bifurcationAlphaHasCurves:
+		curveLocationAnalysis = (bifurcationAlpha >> 2) | (bifurcationZulu << 3) | (bifurcationAlphaFinalZero << 1)
 		recordAnalysis(bridges, curveLocationAnalysis, distinctCrossings)
 
-	if bifurcationEvenHasCurves:
-		curveLocationAnalysis = (bifurcationEven >> 1) | (bifurcationOdd << 2) | bifurcationEvenFinalZero
+	if bifurcationZuluHasCurves:
+		curveLocationAnalysis = (bifurcationZulu >> 1) | (bifurcationAlpha << 2) | bifurcationZuluFinalZero
 		recordAnalysis(bridges, curveLocationAnalysis, distinctCrossings)
 
-	curveLocationAnalysis = ((bifurcationOdd | (bifurcationEven << 1)) << 2) | 3
+	curveLocationAnalysis = ((bifurcationAlpha | (bifurcationZulu << 1)) << 2) | 3
 	recordAnalysis(bridges, curveLocationAnalysis, distinctCrossings)
 
-	if bifurcationOddHasCurves and bifurcationEvenHasCurves and (bifurcationOddFinalZero or bifurcationEvenFinalZero):
+	if bifurcationAlphaHasCurves and bifurcationZuluHasCurves and (bifurcationAlphaFinalZero or bifurcationZuluFinalZero):
 		XOrHere2makePair = 0b1
 		findUnpairedBinary1 = 0
-		if bifurcationOddFinalZero and not bifurcationEvenFinalZero:
+		if bifurcationAlphaFinalZero and not bifurcationZuluFinalZero:
 			while findUnpairedBinary1 >= 0:
 				XOrHere2makePair <<= 2
-				findUnpairedBinary1 += 1 if (bifurcationOdd & XOrHere2makePair) == 0 else -1
-			bifurcationOdd ^= XOrHere2makePair
+				findUnpairedBinary1 += 1 if (bifurcationAlpha & XOrHere2makePair) == 0 else -1
+			bifurcationAlpha ^= XOrHere2makePair
 
-		elif bifurcationEvenFinalZero and not bifurcationOddFinalZero:
+		elif bifurcationZuluFinalZero and not bifurcationAlphaFinalZero:
 			while findUnpairedBinary1 >= 0:
 				XOrHere2makePair <<= 2
-				findUnpairedBinary1 += 1 if (bifurcationEven & XOrHere2makePair) == 0 else -1
-			bifurcationEven ^= XOrHere2makePair
+				findUnpairedBinary1 += 1 if (bifurcationZulu & XOrHere2makePair) == 0 else -1
+			bifurcationZulu ^= XOrHere2makePair
 
-		curveLocationAnalysis = (bifurcationOdd >> 2) | ((bifurcationEven >> 2) << 1)
+		curveLocationAnalysis = (bifurcationAlpha >> 2) | ((bifurcationZulu >> 2) << 1)
 		recordAnalysis(bridges, curveLocationAnalysis, distinctCrossings)
 
 def count(bridges: int, dictionaryCurveLocations: dict[int, int]) -> int:

mapFolding/reference/jaxCount.py

@@ -18,7 +18,7 @@ over other approaches and presented additional complexity. It serves as a valuab
 for exploring alternative acceleration strategies and understanding the limitations of
 different computational frameworks for this specific algorithm.
 """
-from flattened import validateListDimensions, getLeavesTotal, makeConnectionGraph
+from flattened import getLeavesTotal, makeConnectionGraph, validateListDimensions
 from numpy.typing import NDArray
 from typing import Any
 import jax

mapFolding/reference/matrixMeandersBaseline.py

@@ -21,45 +21,45 @@ def count(bridges: int, startingCurveLocations: dict[int, int]) -> int:
 
 	while bridges > 0:
 		bridges -= 1
-		curveLocationsMAXIMUM, bifurcationEvenLocator, bifurcationOddLocator = curveMaximum[bridges]
+		curveLocationsMAXIMUM, bifurcationZuluLocator, bifurcationAlphaLocator = curveMaximum[bridges]
 
 		for curveLocations, distinctCrossings in getCurveLocations().items():
-			bifurcationEven = (curveLocations & bifurcationEvenLocator) >> 1
-			bifurcationOdd = curveLocations & bifurcationOddLocator
+			bifurcationZulu = (curveLocations & bifurcationZuluLocator) >> 1
+			bifurcationAlpha = curveLocations & bifurcationAlphaLocator
 
-			bifurcationEvenFinalZero = (bifurcationEven & 0b1) == 0
-			bifurcationEvenHasCurves = bifurcationEven != 1
-			bifurcationOddFinalZero = (bifurcationOdd & 0b1) == 0
-			bifurcationOddHasCurves = bifurcationOdd != 1
+			bifurcationZuluFinalZero = (bifurcationZulu & 0b1) == 0
+			bifurcationZuluHasCurves = bifurcationZulu != 1
+			bifurcationAlphaFinalZero = (bifurcationAlpha & 0b1) == 0
+			bifurcationAlphaHasCurves = bifurcationAlpha != 1
 
-			if bifurcationEvenHasCurves:
-				curveLocationAnalysis = (bifurcationEven >> 1) | (bifurcationOdd << 2) | bifurcationEvenFinalZero
+			if bifurcationZuluHasCurves:
+				curveLocationAnalysis = (bifurcationZulu >> 1) | (bifurcationAlpha << 2) | bifurcationZuluFinalZero
 				recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
 
-			if bifurcationOddHasCurves:
-				curveLocationAnalysis = (bifurcationOdd >> 2) | (bifurcationEven << 3) | (bifurcationOddFinalZero << 1)
+			if bifurcationAlphaHasCurves:
+				curveLocationAnalysis = (bifurcationAlpha >> 2) | (bifurcationZulu << 3) | (bifurcationAlphaFinalZero << 1)
 				recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
 
-			curveLocationAnalysis = ((bifurcationOdd | (bifurcationEven << 1)) << 2) | 3
+			curveLocationAnalysis = ((bifurcationAlpha | (bifurcationZulu << 1)) << 2) | 3
 			recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
 
-			if bifurcationEvenHasCurves and bifurcationOddHasCurves and (bifurcationEvenFinalZero or bifurcationOddFinalZero):
+			if bifurcationZuluHasCurves and bifurcationAlphaHasCurves and (bifurcationZuluFinalZero or bifurcationAlphaFinalZero):
 				XOrHere2makePair = 0b1
 				findUnpairedBinary1 = 0
 
-				if bifurcationEvenFinalZero and not bifurcationOddFinalZero:
+				if bifurcationZuluFinalZero and not bifurcationAlphaFinalZero:
 					while findUnpairedBinary1 >= 0:
 						XOrHere2makePair <<= 2
-						findUnpairedBinary1 += 1 if (bifurcationEven & XOrHere2makePair) == 0 else -1
-					bifurcationEven ^= XOrHere2makePair
+						findUnpairedBinary1 += 1 if (bifurcationZulu & XOrHere2makePair) == 0 else -1
+					bifurcationZulu ^= XOrHere2makePair
 
-				elif bifurcationOddFinalZero and not bifurcationEvenFinalZero:
+				elif bifurcationAlphaFinalZero and not bifurcationZuluFinalZero:
 					while findUnpairedBinary1 >= 0:
 						XOrHere2makePair <<= 2
-						findUnpairedBinary1 += 1 if (bifurcationOdd & XOrHere2makePair) == 0 else -1
-					bifurcationOdd ^= XOrHere2makePair
+						findUnpairedBinary1 += 1 if (bifurcationAlpha & XOrHere2makePair) == 0 else -1
+					bifurcationAlpha ^= XOrHere2makePair
 
-				curveLocationAnalysis = ((bifurcationEven >> 2) << 1) | (bifurcationOdd >> 2)
+				curveLocationAnalysis = ((bifurcationZulu >> 2) << 1) | (bifurcationAlpha >> 2)
 				recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
 
 	return sum(getCurveLocations().values())

mapFolding/reference/matrixMeandersBaselineAnnex.py

@@ -3,8 +3,8 @@ import sys
 
 class limitLocators(NamedTuple):
 	curveLocationsMAXIMUM: int
-	bifurcationEvenLocator: int
-	bifurcationOddLocator: int
+	bifurcationZuluLocator: int
+	bifurcationAlphaLocator: int
 
 curveMaximum: dict[int, limitLocators] = {
 0: limitLocators(16, 0x2a, 0x15),
@@ -75,8 +75,8 @@ def makeCurveMaximum() -> None:
 	sys.stdout.write("curveMaximum: dict[int, limitLocators] = {\n")
 	for n in range(62):
 		curveLocationsMAXIMUM = 1 << (2 * n + 4)
-		bifurcationOddLocator = int('01' * ((curveLocationsMAXIMUM.bit_length() + 1) // 2), 2)
-		sys.stdout.write(f"{n}: limitLocators({curveLocationsMAXIMUM}, {hex(bifurcationOddLocator << 1)}, {hex(bifurcationOddLocator)}),\n")
+		bifurcationAlphaLocator = int('01' * ((curveLocationsMAXIMUM.bit_length() + 1) // 2), 2)
+		sys.stdout.write(f"{n}: limitLocators({curveLocationsMAXIMUM}, {hex(bifurcationAlphaLocator << 1)}, {hex(bifurcationAlphaLocator)}),\n")
 	sys.stdout.write("}\n")
 
 if __name__ == '__main__':

mapFolding/reference/matrixMeandersSimpleQueue.py

@@ -0,0 +1,90 @@
+from mapFolding._oeisFormulas.matrixMeandersAnnex import curveMaximum as curveMaximum
+from queue import Empty, SimpleQueue
+from typing import NamedTuple
+import contextlib
+
+class BifurcatedCurves(NamedTuple):
+    bifurcationZulu: int
+    bifurcationAlpha: int
+    distinctCrossings: int
+    curveLocationsMAXIMUM: int
+
+dictionaryCurveLocations: dict[int, int] = {}
+simpleQueueCurveLocations: SimpleQueue[tuple[int, int]] = SimpleQueue()
+
+def unpackQueue() -> dict[int, int]:
+	with contextlib.suppress(Empty):
+		while True:
+			curveLocations, distinctCrossings = simpleQueueCurveLocations.get_nowait()
+			dictionaryCurveLocations[curveLocations] = dictionaryCurveLocations.get(curveLocations, 0) + distinctCrossings
+
+	return dictionaryCurveLocations
+
+def getCurveLocations(bridges: int) -> list[BifurcatedCurves]:
+	global dictionaryCurveLocations  # noqa: PLW0603
+	dictionaryCurveLocations = unpackQueue()
+	curveLocationsMAXIMUM, bifurcationZuluLocator, bifurcationAlphaLocator = curveMaximum[bridges]
+	listBifurcatedCurves: list[BifurcatedCurves] = []
+	# TODO This is ready for concurrency and/or vectorization.
+	for curveLocations, distinctCrossings in dictionaryCurveLocations.items():
+		bifurcationZulu = (curveLocations & bifurcationZuluLocator) >> 1
+		bifurcationAlpha = (curveLocations & bifurcationAlphaLocator)
+		listBifurcatedCurves.append(BifurcatedCurves(bifurcationZulu, bifurcationAlpha, distinctCrossings, curveLocationsMAXIMUM))
+	dictionaryCurveLocations = {}
+	return listBifurcatedCurves
+
+def recordAnalysis(curveLocationAnalysis: int, curveLocationsMAXIMUM: int, distinctCrossings: int) -> None:
+	if curveLocationAnalysis < curveLocationsMAXIMUM:
+		simpleQueueCurveLocations.put((curveLocationAnalysis, distinctCrossings))
+
+def analyzeCurve(bifurcationZulu: int, bifurcationAlpha: int, distinctCrossings: int, curveLocationsMAXIMUM: int) -> None:
+	bifurcationZuluFinalZero = (bifurcationZulu & 0b1) == 0
+	bifurcationZuluHasCurves = bifurcationZulu != 1
+	bifurcationAlphaFinalZero = (bifurcationAlpha & 0b1) == 0
+	bifurcationAlphaHasCurves = bifurcationAlpha != 1
+
+	if bifurcationZuluHasCurves:
+		curveLocationAnalysis = (bifurcationZulu >> 1) | (bifurcationAlpha << 2) | bifurcationZuluFinalZero
+		recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
+
+	if bifurcationAlphaHasCurves:
+		curveLocationAnalysis = (bifurcationAlpha >> 2) | (bifurcationZulu << 3) | (bifurcationAlphaFinalZero << 1)
+		recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
+
+	curveLocationAnalysis = ((bifurcationAlpha | (bifurcationZulu << 1)) << 2) | 3
+	recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
+
+	if bifurcationZuluHasCurves and bifurcationAlphaHasCurves and (bifurcationZuluFinalZero or bifurcationAlphaFinalZero):
+		XOrHere2makePair = 0b1
+		findUnpairedBinary1 = 0
+
+		if bifurcationZuluFinalZero and not bifurcationAlphaFinalZero:
+			while findUnpairedBinary1 >= 0:
+				XOrHere2makePair <<= 2
+				findUnpairedBinary1 += 1 if (bifurcationZulu & XOrHere2makePair) == 0 else -1
+			bifurcationZulu ^= XOrHere2makePair
+
+		elif bifurcationAlphaFinalZero and not bifurcationZuluFinalZero:
+			while findUnpairedBinary1 >= 0:
+				XOrHere2makePair <<= 2
+				findUnpairedBinary1 += 1 if (bifurcationAlpha & XOrHere2makePair) == 0 else -1
+			bifurcationAlpha ^= XOrHere2makePair
+
+		curveLocationAnalysis = ((bifurcationZulu >> 2) << 1) | (bifurcationAlpha >> 2)
+		recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
+
+def initializeCurveLocations(startingCurveLocations: dict[int, int]) -> None:
+	global dictionaryCurveLocations  # noqa: PLW0603
+	dictionaryCurveLocations = startingCurveLocations.copy()
+
+def count(bridges: int, startingCurveLocations: dict[int, int]) -> int:
+	initializeCurveLocations(startingCurveLocations)
+
+	while bridges > 0:
+		bridges -= 1
+
+		# TODO This could be parallelized when `recordAnalysis` is thread-safe
+		for bifurcatedCurve in getCurveLocations(bridges):
+			analyzeCurve(*bifurcatedCurve)
+
+	return getCurveLocations(bridges)[0].distinctCrossings

mapFolding/reference/matrixMeandersSlicePop.py

@@ -0,0 +1,104 @@
+def count(bridges: int, startingCurveLocations: dict[int, int]) -> int:
+	listCurveMaximums: list[tuple[int, int, int]] = [
+	(16, 0x2a, 0x15),
+	(64, 0xaa, 0x55),
+	(256, 0x2aa, 0x155),
+	(1024, 0xaaa, 0x555),
+	(4096, 0x2aaa, 0x1555),
+	(16384, 0xaaaa, 0x5555),
+	(65536, 0x2aaaa, 0x15555),
+	(262144, 0xaaaaa, 0x55555),
+	(1048576, 0x2aaaaa, 0x155555),
+	(4194304, 0xaaaaaa, 0x555555),
+	(16777216, 0x2aaaaaa, 0x1555555),
+	(67108864, 0xaaaaaaa, 0x5555555),
+	(268435456, 0x2aaaaaaa, 0x15555555),
+	(1073741824, 0xaaaaaaaa, 0x55555555),
+	(4294967296, 0x2aaaaaaaa, 0x155555555),
+	(17179869184, 0xaaaaaaaaa, 0x555555555),
+	(68719476736, 0x2aaaaaaaaa, 0x1555555555),
+	(274877906944, 0xaaaaaaaaaa, 0x5555555555),
+	(1099511627776, 0x2aaaaaaaaaa, 0x15555555555),
+	(4398046511104, 0xaaaaaaaaaaa, 0x55555555555),
+	(17592186044416, 0x2aaaaaaaaaaa, 0x155555555555),
+	(70368744177664, 0xaaaaaaaaaaaa, 0x555555555555),
+	(281474976710656, 0x2aaaaaaaaaaaa, 0x1555555555555),
+	(1125899906842624, 0xaaaaaaaaaaaaa, 0x5555555555555),
+	(4503599627370496, 0x2aaaaaaaaaaaaa, 0x15555555555555),
+	(18014398509481984, 0xaaaaaaaaaaaaaa, 0x55555555555555),
+	(72057594037927936, 0x2aaaaaaaaaaaaaa, 0x155555555555555),
+	(288230376151711744, 0xaaaaaaaaaaaaaaa, 0x555555555555555),
+	(1152921504606846976, 0x2aaaaaaaaaaaaaaa, 0x1555555555555555), # 0x2aaaaaaaaaaaaaaa.bit_length() = 62
+	(4611686018427387904, 0xaaaaaaaaaaaaaaaa, 0x5555555555555555),
+	(18446744073709551616, 0x2aaaaaaaaaaaaaaaa, 0x15555555555555555),
+	(73786976294838206464, 0xaaaaaaaaaaaaaaaaa, 0x55555555555555555),
+	(295147905179352825856, 0x2aaaaaaaaaaaaaaaaa, 0x155555555555555555),
+	(1180591620717411303424, 0xaaaaaaaaaaaaaaaaaa, 0x555555555555555555),
+	(4722366482869645213696, 0x2aaaaaaaaaaaaaaaaaa, 0x1555555555555555555),
+	(18889465931478580854784, 0xaaaaaaaaaaaaaaaaaaa, 0x5555555555555555555),
+	(75557863725914323419136, 0x2aaaaaaaaaaaaaaaaaaa, 0x15555555555555555555),
+	(302231454903657293676544, 0xaaaaaaaaaaaaaaaaaaaa, 0x55555555555555555555),
+	(1208925819614629174706176, 0x2aaaaaaaaaaaaaaaaaaaa, 0x155555555555555555555),
+	(4835703278458516698824704, 0xaaaaaaaaaaaaaaaaaaaaa, 0x555555555555555555555),
+	(19342813113834066795298816, 0x2aaaaaaaaaaaaaaaaaaaaa, 0x1555555555555555555555),
+	(77371252455336267181195264, 0xaaaaaaaaaaaaaaaaaaaaaa, 0x5555555555555555555555),
+	(309485009821345068724781056, 0x2aaaaaaaaaaaaaaaaaaaaaa, 0x15555555555555555555555),
+	(1237940039285380274899124224, 0xaaaaaaaaaaaaaaaaaaaaaaa, 0x55555555555555555555555),
+	(4951760157141521099596496896, 0x2aaaaaaaaaaaaaaaaaaaaaaa, 0x155555555555555555555555),
+	(19807040628566084398385987584, 0xaaaaaaaaaaaaaaaaaaaaaaaa, 0x555555555555555555555555),
+	]
+
+	listCurveMaximums = listCurveMaximums[0:bridges]
+	dictionaryCurveLocations: dict[int, int] = {}
+
+	while bridges > 0:
+		bridges -= 1
+
+		curveLocationsMAXIMUM, bifurcationZuluLocator, bifurcationAlphaLocator = listCurveMaximums.pop()
+
+		for curveLocations, distinctCrossings in startingCurveLocations.items():
+			bifurcationZulu = (curveLocations & bifurcationZuluLocator) >> 1
+			bifurcationAlpha = (curveLocations & bifurcationAlphaLocator)
+			bifurcationZuluFinalZero = (bifurcationZulu & 0b1) == 0
+			bifurcationZuluHasCurves = bifurcationZulu != 1
+			bifurcationAlphaFinalZero = (bifurcationAlpha & 0b1) == 0
+			bifurcationAlphaHasCurves = bifurcationAlpha != 1
+
+			if bifurcationZuluHasCurves:
+				curveLocationAnalysis = (bifurcationZulu >> 1) | (bifurcationAlpha << 2) | bifurcationZuluFinalZero
+				if curveLocationAnalysis < curveLocationsMAXIMUM:
+					dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+
+			if bifurcationAlphaHasCurves:
+				curveLocationAnalysis = (bifurcationAlpha >> 2) | (bifurcationZulu << 3) | (bifurcationAlphaFinalZero << 1)
+				if curveLocationAnalysis < curveLocationsMAXIMUM:
+					dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+
+			curveLocationAnalysis = ((bifurcationAlpha | (bifurcationZulu << 1)) << 2) | 3
+			if curveLocationAnalysis < curveLocationsMAXIMUM:
+				dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+
+			if bifurcationZuluHasCurves and bifurcationAlphaHasCurves and (bifurcationZuluFinalZero or bifurcationAlphaFinalZero):
+				XOrHere2makePair = 0b1
+				findUnpairedBinary1 = 0
+
+				if bifurcationZuluFinalZero and not bifurcationAlphaFinalZero:
+					while findUnpairedBinary1 >= 0:
+						XOrHere2makePair <<= 2
+						findUnpairedBinary1 += 1 if (bifurcationZulu & XOrHere2makePair) == 0 else -1
+					bifurcationZulu ^= XOrHere2makePair
+
+				elif bifurcationAlphaFinalZero and not bifurcationZuluFinalZero:
+					while findUnpairedBinary1 >= 0:
+						XOrHere2makePair <<= 2
+						findUnpairedBinary1 += 1 if (bifurcationAlpha & XOrHere2makePair) == 0 else -1
+					bifurcationAlpha ^= XOrHere2makePair
+
+				curveLocationAnalysis = ((bifurcationZulu >> 2) << 1) | (bifurcationAlpha >> 2)
+				if curveLocationAnalysis < curveLocationsMAXIMUM:
+					dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+
+		startingCurveLocations = dictionaryCurveLocations.copy()
+		dictionaryCurveLocations = {}
+
+	return sum(startingCurveLocations.values())

mapFolding/reference/rotatedEntryPoint.py

@@ -18,8 +18,8 @@ structure can be creatively redesigned while maintaining the core computational
 
 from mapFolding import outfitFoldings
 from numba import njit
-import numpy
 from numpy.typing import NDArray
+import numpy
 
 """
 It is possible to enter the main `while` loop from an arbitrary point. This version is "rotated" to effectively enter at the modulo operator.

mapFolding/someAssemblyRequired/A007822rawMaterials.py

@@ -0,0 +1,46 @@
+from astToolkit import extractFunctionDef  # noqa: D100
+from hunterMakesPy import raiseIfNone
+from mapFolding.someAssemblyRequired.infoBooth import (
+	dataclassInstanceIdentifierDEFAULT, sourceCallableIdentifierDEFAULT, theCountingIdentifierDEFAULT)
+import ast
+
+Z0Z_identifier = 'filterAsymmetricFolds'
+ImaString = f"""
+def {Z0Z_identifier}(state: MapFoldingState) -> MapFoldingState:
+	state.indexLeaf = 0
+	leafConnectee = 0
+	while leafConnectee < state.leavesTotal + 1:
+		leafNumber = int(state.leafBelow[state.indexLeaf])
+		state.leafComparison[leafConnectee] = (leafNumber - state.indexLeaf + state.leavesTotal) % state.leavesTotal
+		state.indexLeaf = leafNumber
+		leafConnectee += 1
+
+	indexInMiddle = state.leavesTotal // 2
+	state.indexMiniGap = 0
+	while state.indexMiniGap < state.leavesTotal + 1:
+		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)]:
+				ImaSymmetricFold = False
+				break
+			leafConnectee += 1
+		if ImaSymmetricFold:
+			state.groupsOfFolds += 1
+		state.indexMiniGap += 1
+
+	return state
+"""
+
+FunctionDef_filterAsymmetricFolds: ast.FunctionDef = raiseIfNone(extractFunctionDef(ast.parse(ImaString), Z0Z_identifier))
+del ImaString
+
+ImaString = f"{dataclassInstanceIdentifierDEFAULT} = {Z0Z_identifier}({dataclassInstanceIdentifierDEFAULT})"
+Z0Z_incrementCount = ast.parse(ImaString).body[0]
+del ImaString
+
+
+ImaString = 'state.groupsOfFolds = (state.groupsOfFolds + 1) // 2'
+Z0Z_adjustFoldsTotal = ast.parse(ImaString).body[0]
+del ImaString
+

mapFolding/someAssemblyRequired/_toolkitContainers.py

@@ -232,7 +232,7 @@ class DeReConstructField2ast:
 			self.ledger.addImportFrom_asStr(moduleWithLogicalPath, 'dtype')
 			axesSubscript = Make.Subscript(Make.Name('tuple'), Make.Name('uint8'))
 			dtype_asnameName: ast.Name = self.astAnnotation
-			if dtype_asnameName.id == 'Array3D':
+			if dtype_asnameName.id == 'Array3DLeavesTotal':
 				axesSubscript = Make.Subscript(Make.Name('tuple'), Make.Tuple([Make.Name('uint8'), Make.Name('uint8'), Make.Name('uint8')]))
 			ast_expr = Make.Subscript(Make.Name(annotationType), Make.Tuple([axesSubscript, Make.Subscript(Make.Name('dtype'), dtype_asnameName)]))
 			constructor = 'array'