mapFolding 0.15.1__tar.gz → 0.15.3__tar.gz

{mapfolding-0.15.1 → mapfolding-0.15.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.15.1
+Version: 0.15.3
 Summary: Map folding, meanders, stamp folding, semi-meanders. Experiment with algorithm transformations and code optimization.
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -8,7 +8,7 @@ Project-URL: Donate, https://www.patreon.com/integrated
 Project-URL: Homepage, https://github.com/hunterhogan/mapFolding
 Project-URL: Issues, https://github.com/hunterhogan/mapFolding/issues
 Project-URL: Repository, https://github.com/hunterhogan/mapFolding.git
-Keywords: A000136,A000560,A000682,A001415,A001416,A001417,A001418,A005315,A005316,A007822,A195646,A223094,A259702,A301620,abstract syntax tree,algorithmic combinatorics,algorithmic optimization,arch configurations,AST manipulation,automated code generation,bit-packed arrays,bitwise state machines,cache-efficient algorithms,closed meandric numbers,code generation,code optimization,code synthesis,code transformation,codon optimization,combinatorial computing,combinatorial enumeration,combinatorial geometry,combinatorial mathematics,combinatorial problem solver,combinatorics,computational combinatorics,computational geometry,crossing patterns,curve crossings,dataclass transformation,discrete mathematics,dynamic compilation,enumerative combinatorics,folding pattern enumeration,folding problems,GPU acceleration,high-performance computing,integer sequences,JIT compilation,just-in-time compilation,kernel optimization,labeled stamp folding,low-level computation,map folding,mapFolding,mathematical algorithms,mathematical modeling,mathematical optimization,mathematical patterns,mathematical software,mathematical tool,mathematical visualization,meander enumeration,meanders,meandric systems,memory-efficient enumeration,metaprogramming,Numba optimization,numerical algorithms,numerical computation,OEIS,open meandric systems,paper folding mathematics,parallel computing,pattern recognition,performance optimization,permutation patterns,permutations,post-setup optimization,pyproject,Python optimization,scientific computing,semi-meanders,sequence analysis,sequence calculator,sequence enumeration,sequence explorer,sequence generation,source code analysis,stamp folding,symbolic computation,symmetric foldings,topological combinatorics,topological patterns,typed Python
+Keywords: A000136,A000560,A000682,A001010,A001011,A001415,A001416,A001417,A001418,A005315,A005316,A007822,A195646,A223094,A259702,A301620,AST manipulation,GPU acceleration,JIT compilation,Numba optimization,OEIS,Python optimization,abstract syntax tree,algorithmic combinatorics,algorithmic optimization,arch configurations,automated code generation,bit-packed arrays,bitwise state machines,cache-efficient algorithms,closed meandric numbers,code generation,code optimization,code synthesis,code transformation,codon optimization,combinatorial computing,combinatorial enumeration,combinatorial geometry,combinatorial mathematics,combinatorial problem solver,combinatorics,computational combinatorics,computational geometry,crossing patterns,curve crossings,dataclass transformation,discrete mathematics,dynamic compilation,enumerative combinatorics,folding pattern enumeration,folding problems,high-performance computing,integer sequences,just-in-time compilation,kernel optimization,labeled stamp folding,low-level computation,map folding,mapFolding,mathematical algorithms,mathematical modeling,mathematical optimization,mathematical patterns,mathematical software,mathematical tool,mathematical visualization,meander enumeration,meanders,meandric systems,memory-efficient enumeration,metaprogramming,numerical algorithms,numerical computation,open meandric systems,paper folding mathematics,parallel computing,pattern recognition,performance optimization,permutation patterns,permutations,post-setup optimization,pyproject,scientific computing,semi-meanders,sequence analysis,sequence calculator,sequence enumeration,sequence explorer,sequence generation,source code analysis,stamp folding,symbolic computation,symmetric foldings,topological combinatorics,topological patterns,typed Python
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -39,6 +39,7 @@ Requires-Dist: hunterMakesPy
 Requires-Dist: numpy
 Requires-Dist: platformdirs
 Provides-Extra: development
+Requires-Dist: memray; sys_platform == "linux" and extra == "development"
 Requires-Dist: mypy; extra == "development"
 Requires-Dist: pyupgrade; extra == "development"
 Requires-Dist: py-spy; extra == "development"

mapfolding-0.15.3/mapFolding/_oeisFormulas/A000682.py

@@ -0,0 +1,85 @@
+"""Semi-meanders.
+
+n = 3   `startingCurveLocations` keys = 3
+n = 4   `startingCurveLocations` keys = 4
+n = 5   `startingCurveLocations` keys = 4
+n = 6   `startingCurveLocations` keys = 5
+n = 7   `startingCurveLocations` keys = 5
+n = 8   `startingCurveLocations` keys = 6
+n = 9   `startingCurveLocations` keys = 6
+n = 10  `startingCurveLocations` keys = 7
+n = 11  `startingCurveLocations` keys = 7
+n = 12  `startingCurveLocations` keys = 8
+n = 13  `startingCurveLocations` keys = 8
+n = 14  `startingCurveLocations` keys = 9
+n = 15  `startingCurveLocations` keys = 9
+n = 16  `startingCurveLocations` keys = 10
+n = 17  `startingCurveLocations` keys = 10
+n = 18  `startingCurveLocations` keys = 11
+n = 19  `startingCurveLocations` keys = 11
+n = 20  `startingCurveLocations` keys = 12
+n = 21  `startingCurveLocations` keys = 12
+n = 22  `startingCurveLocations` keys = 13
+n = 23  `startingCurveLocations` keys = 13
+n = 24  `startingCurveLocations` keys = 14
+n = 25  `startingCurveLocations` keys = 14
+n = 26  `startingCurveLocations` keys = 15
+n = 27  `startingCurveLocations` keys = 15
+n = 28  `startingCurveLocations` keys = 16
+n = 29  `startingCurveLocations` keys = 16
+n = 30  `startingCurveLocations` keys = 17
+n = 31  `startingCurveLocations` keys = 17
+n = 32  `startingCurveLocations` keys = 18
+n = 33  `startingCurveLocations` keys = 18
+n = 34  `startingCurveLocations` keys = 19
+n = 35  `startingCurveLocations` keys = 19
+n = 36  `startingCurveLocations` keys = 20
+n = 37  `startingCurveLocations` keys = 20
+n = 38  `startingCurveLocations` keys = 21
+n = 39  `startingCurveLocations` keys = 21
+n = 40  `startingCurveLocations` keys = 22
+n = 41  `startingCurveLocations` keys = 22
+n = 42  `startingCurveLocations` keys = 23
+n = 43  `startingCurveLocations` keys = 23
+n = 44  `startingCurveLocations` keys = 24
+n = 45  `startingCurveLocations` keys = 24
+n = 46  `startingCurveLocations` keys = 25
+n = 47  `startingCurveLocations` keys = 25
+n = 48  `startingCurveLocations` keys = 26
+n = 49  `startingCurveLocations` keys = 26
+n = 50  `startingCurveLocations` keys = 27
+n = 51  `startingCurveLocations` keys = 27
+n = 52  `startingCurveLocations` keys = 28
+n = 53  `startingCurveLocations` keys = 28
+n = 54  `startingCurveLocations` keys = 29
+n = 55  `startingCurveLocations` keys = 29
+n = 56  `startingCurveLocations` keys = 30
+n = 57  `startingCurveLocations` keys = 30
+n = 58  `startingCurveLocations` keys = 31
+n = 59  `startingCurveLocations` keys = 31
+n = 60  `startingCurveLocations` keys = 32
+n = 61  `startingCurveLocations` keys = 32
+"""
+
+# TODO figure out how to call the correct module
+# In other situations, I use a so-called dispatcher amd that has helped make code transformation easier, too.
+from mapFolding._oeisFormulas.matrixMeanders import count  # noqa: ERA001
+from mapFolding._oeisFormulas.matrixMeanders64 import count as count64
+
+def initializeA000682(n: int) -> dict[int, int]:
+	curveLocationsMAXIMUM = 1 << (2 * n + 4)
+
+	curveSeed: int = 5 - (n & 0b1) * 4
+	listCurveLocations = [(curveSeed << 1) | curveSeed]
+
+	while listCurveLocations[-1] < curveLocationsMAXIMUM:
+		curveSeed = (curveSeed << 4) | 0b101
+		listCurveLocations.append((curveSeed << 1) | curveSeed)
+
+	return dict.fromkeys(listCurveLocations, 1)
+
+def A000682(n: int) -> int:
+	# count64(n - 1, initializeA000682(n - 1))
+	# print()
+	return count(n - 1, initializeA000682(n - 1))
+	# return count64(n - 1, initializeA000682(n - 1))

mapfolding-0.15.3/mapFolding/_oeisFormulas/A001010.py

@@ -0,0 +1,19 @@
+from mapFolding import countFolds
+from mapFolding._oeisFormulas.A000682 import A000682
+
+def A001010(n: int) -> int:
+	"""Complicated.
+
+	a(2n-1) = 2*A007822(n)
+	OddQ[n], 2*A007822[[(n - 1)/2 + 1]]]
+
+	a(2n) = 2*A000682(n+1)
+	EvenQ[n], 2*A000682[[n/2 + 1]]
+	"""
+	if n & 0b1:
+		foldsTotal = 2 * countFolds(oeisID='A007822', oeis_n=(n - 1)//2 + 1, flow='theorem2Numba')
+	else:
+		foldsTotal = 2 * A000682(n // 2 + 1)
+
+	return foldsTotal
+

mapfolding-0.15.3/mapFolding/_oeisFormulas/A001011.py

@@ -0,0 +1,5 @@
+from mapFolding._oeisFormulas.A000136 import A000136
+from mapFolding._oeisFormulas.A001010 import A001010
+
+def A001011(n: int) -> int:
+    return (A001010(n) + A000136(n)) // 4

mapfolding-0.15.3/mapFolding/_oeisFormulas/Z0Z_aOFn.py

@@ -0,0 +1,34 @@
+# pyright: reportUnusedImport=false
+from mapFolding._oeisFormulas.A000136 import A000136
+from mapFolding._oeisFormulas.A000682 import A000682
+from mapFolding._oeisFormulas.A001010 import A001010
+from mapFolding._oeisFormulas.Z0Z_oeisMeanders import dictionaryOEISMeanders
+from mapFolding.oeis import dictionaryOEIS
+import sys
+import time
+
+# ruff: noqa: ERA001
+
+if __name__ == '__main__':
+	def _write() -> None:
+		sys.stdout.write(
+			f"{(booleanColor:=(foldsTotal == dictionaryOEISMeanders[oeisID]['valuesKnown'][n]))}\t" # pyright: ignore[reportIndexIssue, reportUnknownVariableType]
+			f"\033[{(not booleanColor)*91}m"
+			f"{n}\t"
+			f"{foldsTotal}\t"
+			# f"{dictionaryOEISMeanders[oeisID]['valuesKnown'][n]=}\t"
+			f"{time.perf_counter() - timeStart:.2f}\t"
+			# f"{description}\t"
+			"\033[0m\n"
+		)
+	oeisID = 'A001010'
+	oeisID = 'A000136'
+	oeisID = 'A000682'
+	for n in range(3,17):
+
+		# sys.stdout.write(f"{n = }\n")
+
+		timeStart = time.perf_counter()
+		foldsTotal = eval(oeisID)(n)  # noqa: S307
+		# sys.stdout.write(f"{n} {foldsTotal} {time.perf_counter() - timeStart:.2f}\n")
+		_write()

mapfolding-0.15.3/mapFolding/_oeisFormulas/Z0Z_notes.py

@@ -0,0 +1,16 @@
+"""Half-formed thoughts.
+
+I have unintentionally made `bridges -= 1` almost meaningless.
+
+Unlike multidimensional map folding, the computation of curveLocations_sub_i for bridges=p does not need to happen during the
+series of computation for bridges=p. Each curveLocations_sub_i produces between no curveLocations, curveLocations_sub_q,
+curveLocations_sub_r, curveLocations_sub_s, and curveLocations_sub_t, which are recorded as keys in dictionaryCurveLocations.
+
+`while bridges > 0: bridges -= 1` tacitly attaches metadata to each key in dictionaryCurveLocations: specifically the value of
+`bridges`. The computation is not complete until the `bridges` value of each key reaches 0.
+
+Therefore, it is hypothetically possible to use one dictionary and to explicitly track the `bridges` value for each key. In
+that scenario, the dictionary is effectively a list of jobs. And instead of being at the mercy of the amount of resources
+needed by each decrement, bridges -= 1, we can use well-researched techniques to manage resources and the order of
+execution.
+"""

mapfolding-0.15.3/mapFolding/_oeisFormulas/Z0Z_oeisMeanders.py

@@ -0,0 +1,74 @@
+from mapFolding._oeisFormulas.A000560 import A000560
+from mapFolding._oeisFormulas.A000682 import A000682
+from mapFolding._oeisFormulas.A001010 import A001010
+from mapFolding._oeisFormulas.A001011 import A001011
+from mapFolding._oeisFormulas.A005315 import A005315
+from mapFolding._oeisFormulas.A005316 import A005316
+from mapFolding._oeisFormulas.A223094 import A223094
+from mapFolding._oeisFormulas.A259702 import A259702
+from mapFolding._oeisFormulas.A301620 import A301620
+from mapFolding.oeis import getOEISidInformation, getOEISidValues
+from typing import TypedDict
+import sys
+
+oeisIDsMeanders: list[str] = [
+	'A000560',
+	'A000682',
+	'A001010',
+	'A001011',
+	'A005315',
+	'A005316',
+	'A223094',
+	'A259702',
+	'A301620',
+]
+
+# ruff: noqa: ERA001
+class MetadataOEISidMeanders(TypedDict):
+	"""Settings for an implemented OEIS sequence."""
+
+	description: str
+	"""The OEIS.org description of the integer sequence."""
+	# getMapShape: Callable[[int], tuple[int, ...]]
+	"""Function to convert the OEIS sequence index, 'n', to its `mapShape` tuple."""
+	offset: int
+	"""The starting index, 'n', of the sequence, typically 0 or 1."""
+	# valuesBenchmark: list[int]
+	"""List of index values, 'n', to use when benchmarking the algorithm performance."""
+	valuesKnown: dict[int, int]
+	"""Dictionary of sequence indices, 'n', to their known values, `foldsTotal`."""
+	# valuesTestParallelization: list[int]
+	"""List of index values, 'n', to use when testing parallelization performance."""
+	# valuesTestValidation: list[int]
+	"""List of index values, 'n', to use when testing validation performance."""
+	# valueUnknown: int
+	"""The smallest value of 'n' for for which `foldsTotal` is unknown."""
+
+dictionaryOEISMeanders: dict[str, MetadataOEISidMeanders] = {
+	oeisID: {
+		'description': getOEISidInformation(oeisID)[0],
+		'offset': getOEISidInformation(oeisID)[1],
+		'valuesKnown': getOEISidValues(oeisID),
+	}
+	for oeisID in oeisIDsMeanders
+}
+
+# ruff: noqa: S101
+# pyright: reportIndexIssue=false
+
+rangeTest = range(5, 13)
+
+if __name__ == '__main__':
+	for n in rangeTest:
+
+		assert A000560(n) == dictionaryOEISMeanders['A000560']['valuesKnown'][n]
+		assert A000682(n) == dictionaryOEISMeanders['A000682']['valuesKnown'][n]
+		assert A001010(n) == dictionaryOEISMeanders['A001010']['valuesKnown'][n]
+		assert A001011(n) == dictionaryOEISMeanders['A001011']['valuesKnown'][n]
+		assert A005315(n) == dictionaryOEISMeanders['A005315']['valuesKnown'][n]
+		assert A005316(n) == dictionaryOEISMeanders['A005316']['valuesKnown'][n]
+		assert A223094(n) == dictionaryOEISMeanders['A223094']['valuesKnown'][n]
+		assert A259702(n) == dictionaryOEISMeanders['A259702']['valuesKnown'][n]
+		assert A301620(n) == dictionaryOEISMeanders['A301620']['valuesKnown'][n]
+
+	sys.stdout.write(f"\nTrue for {str(rangeTest)}\n")

mapfolding-0.15.3/mapFolding/_oeisFormulas/Z0Z_symmetry.py

@@ -0,0 +1,131 @@
+from mapFolding._oeisFormulas.A000682 import A000682
+
+"""
+
+How to A000682:
+- Start A000682 for n.
+- Find A000560(n-1) in dictionaryCurveLocationsKnown or dictionaryCurveLocationsDiscovered.
+- STOP computing.
+- Double the total.
+That is A000682.
+
+
+How to A259703:
+- Start A000682 for n.
+- Find n-1 keys in dictionaryCurveLocationsKnown or dictionaryCurveLocationsDiscovered.
+- Descending sort.
+That is a A259703 row.
+
+https://oeis.org/A259703
+
+SYMMETRY!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+     1;
+     1,    1;
+     2,    1,    1;
+     5,    2,    2,   1;
+    12,    5,    4,   2,   1;
+    33,   13,   12,   4,   3,   1;
+    87,   35,   30,  12,   6,   3,  1;
+   252,   98,   90,  32,  21,   6,  4,  1;
+   703,  278,  243,  94,  54,  21,  8,  4,  1;
+  2105,  812,  745, 270, 175,  57, 32,  8,  5, 1;
+  6099, 2385, 2108, 808, 485, 181, 84, 32, 10, 5, 1;
+
+
+n+1
+Row sums are A000682. First column is A000560.
+Row sums are A000682. First column is A000560.
+Row sums are A000682. First column is A000560.
+Row sums are A000682. First column is A000560.
+Row sums are A000682. First column is A000560.
+Row sums are A000682. First column is A000560.
+Row sums are A000682. First column is A000560.
+Row sums are A000682. First column is A000560.
+
+     n/a;
+     1=    1;
+     2=    1+    1;
+     5=    2+    2+   1;
+    12=    5+    4+   2+   1;
+    33=   13+   12+   4+   3+   1;
+    87=   35+   30+  12+   6+   3+  1;
+   252=   98+   90+  32+  21+   6+  4+  1;
+   703=  278+  243+  94+  54+  21+  8+  4+  1;
+  2105=  812+  745+ 270+ 175+  57+ 32+  8+  5+ 1;
+  6099= 2385+ 2108+ 808+ 485+ 181+ 84+ 32+ 10+ 5+ 1;
+
+print(1==    1)
+print(2==    1+    1)
+print(5==    2+    2+   1)
+print(12==    5+    4+   2+   1)
+print(33==   13+   12+   4+   3+   1)
+print(87==   35+   30+  12+   6+   3+  1)
+print(252==   98+   90+  32+  21+   6+  4+  1)
+print(703==  278+  243+  94+  54+  21+  8+  4+  1)
+print(2105==  812+  745+ 270+ 175+  57+ 32+  8+  5+ 1)
+print(6099== 2385+ 2108+ 808+ 485+ 181+ 84+ 32+ 10+ 5+ 1)
+
+
+"""
+
+listA259703rowTerms = [1, 1]
+n = len(listA259703rowTerms) + 1
+rowSum = sum(listA259703rowTerms)
+A000682for_n = A000682(n)
+print(rowSum == A000682for_n, f"{n = }, {A000682for_n = }, {rowSum = }")
+
+listA259703rowTerms = [2, 1, 1]
+n = len(listA259703rowTerms) + 1
+rowSum = sum(listA259703rowTerms)
+A000682for_n = A000682(n)
+print(rowSum == A000682for_n, f"{n = }, {A000682for_n = }, {rowSum = }")
+
+listA259703rowTerms = [5, 2, 2, 1]
+n = len(listA259703rowTerms) + 1
+rowSum = sum(listA259703rowTerms)
+A000682for_n = A000682(n)
+print(rowSum == A000682for_n, f"{n = }, {A000682for_n = }, {rowSum = }")
+
+listA259703rowTerms = [12, 5, 4, 2, 1]
+n = len(listA259703rowTerms) + 1
+rowSum = sum(listA259703rowTerms)
+A000682for_n = A000682(n)
+print(rowSum == A000682for_n, f"{n = }, {A000682for_n = }, {rowSum = }")
+
+listA259703rowTerms = [33, 13, 12, 4, 3, 1]
+n = len(listA259703rowTerms) + 1
+rowSum = sum(listA259703rowTerms)
+A000682for_n = A000682(n)
+print(rowSum == A000682for_n, f"{n = }, {A000682for_n = }, {rowSum = }")
+
+listA259703rowTerms = [87, 35, 30, 12, 6, 3, 1]
+n = len(listA259703rowTerms) + 1
+rowSum = sum(listA259703rowTerms)
+A000682for_n = A000682(n)
+print(rowSum == A000682for_n, f"{n = }, {A000682for_n = }, {rowSum = }")
+
+listA259703rowTerms = [252, 98, 90, 32, 21, 6, 4, 1]
+n = len(listA259703rowTerms) + 1
+rowSum = sum(listA259703rowTerms)
+A000682for_n = A000682(n)
+print(rowSum == A000682for_n, f"{n = }, {A000682for_n = }, {rowSum = }")
+
+listA259703rowTerms = [703, 278, 243, 94, 54, 21, 8, 4, 1]
+n = len(listA259703rowTerms) + 1
+rowSum = sum(listA259703rowTerms)
+A000682for_n = A000682(n)
+print(rowSum == A000682for_n, f"{n = }, {A000682for_n = }, {rowSum = }")
+
+listA259703rowTerms = [2105, 812, 745, 270, 175, 57, 32, 8, 5, 1]
+n = len(listA259703rowTerms) + 1
+rowSum = sum(listA259703rowTerms)
+A000682for_n = A000682(n)
+print(rowSum == A000682for_n, f"{n = }, {A000682for_n = }, {rowSum = }")
+
+listA259703rowTerms = [6099, 2385, 2108, 808, 485, 181, 84, 32, 10, 5, 1]
+n = len(listA259703rowTerms) + 1
+rowSum = sum(listA259703rowTerms)
+A000682for_n = A000682(n)
+print(rowSum == A000682for_n, f"{n = }, {A000682for_n = }, {rowSum = }")
+

mapfolding-0.15.3/mapFolding/_oeisFormulas/matrixMeanders.py

@@ -0,0 +1,134 @@
+def count(bridges: int, startingCurveLocations: dict[int, int]) -> int:
+	listCurveMaximums: list[tuple[int, int, int]] = [
+(0x15, 0x2a, 0x10),
+(0x55, 0xaa, 0x40),
+(0x155, 0x2aa, 0x100),
+(0x555, 0xaaa, 0x400),
+(0x1555, 0x2aaa, 0x1000),
+(0x5555, 0xaaaa, 0x4000),
+(0x15555, 0x2aaaa, 0x10000),
+(0x55555, 0xaaaaa, 0x40000),
+(0x155555, 0x2aaaaa, 0x100000),
+(0x555555, 0xaaaaaa, 0x400000),
+(0x1555555, 0x2aaaaaa, 0x1000000),
+(0x5555555, 0xaaaaaaa, 0x4000000),
+(0x15555555, 0x2aaaaaaa, 0x10000000),
+(0x55555555, 0xaaaaaaaa, 0x40000000), # `bridges = 13`, 0xaaaaaaaa.bit_length() = 32
+(0x155555555, 0x2aaaaaaaa, 0x100000000),
+(0x555555555, 0xaaaaaaaaa, 0x400000000),
+(0x1555555555, 0x2aaaaaaaaa, 0x1000000000),
+(0x5555555555, 0xaaaaaaaaaa, 0x4000000000),
+(0x15555555555, 0x2aaaaaaaaaa, 0x10000000000),
+(0x55555555555, 0xaaaaaaaaaaa, 0x40000000000),
+(0x155555555555, 0x2aaaaaaaaaaa, 0x100000000000),
+(0x555555555555, 0xaaaaaaaaaaaa, 0x400000000000),
+(0x1555555555555, 0x2aaaaaaaaaaaa, 0x1000000000000),
+(0x5555555555555, 0xaaaaaaaaaaaaa, 0x4000000000000),
+(0x15555555555555, 0x2aaaaaaaaaaaaa, 0x10000000000000),
+(0x55555555555555, 0xaaaaaaaaaaaaaa, 0x40000000000000),
+(0x155555555555555, 0x2aaaaaaaaaaaaaa, 0x100000000000000),
+(0x555555555555555, 0xaaaaaaaaaaaaaaa, 0x400000000000000),
+(0x1555555555555555, 0x2aaaaaaaaaaaaaaa, 0x1000000000000000),
+(0x5555555555555555, 0xaaaaaaaaaaaaaaaa, 0x4000000000000000), # 0x5000000000000000.bit_length() = 63; 0xaaaaaaaaaaaaaaaa.bit_length() = 64; 0x5555555555555555.bit_length() = 63
+(0x15555555555555555, 0x2aaaaaaaaaaaaaaaa, 0x10000000000000000),
+(0x55555555555555555, 0xaaaaaaaaaaaaaaaaa, 0x40000000000000000),
+(0x155555555555555555, 0x2aaaaaaaaaaaaaaaaa, 0x100000000000000000),
+(0x555555555555555555, 0xaaaaaaaaaaaaaaaaaa, 0x400000000000000000),
+(0x1555555555555555555, 0x2aaaaaaaaaaaaaaaaaa, 0x1000000000000000000),
+(0x5555555555555555555, 0xaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000),
+(0x15555555555555555555, 0x2aaaaaaaaaaaaaaaaaaa, 0x10000000000000000000),
+(0x55555555555555555555, 0xaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000),
+(0x155555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaa, 0x100000000000000000000),
+(0x555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaa, 0x400000000000000000000),
+(0x1555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaa, 0x1000000000000000000000),
+(0x5555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000000),
+(0x15555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaa, 0x10000000000000000000000),
+(0x55555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000000),
+(0x155555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaa, 0x100000000000000000000000),
+(0x555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaa, 0x400000000000000000000000),
+(0x1555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaa, 0x1000000000000000000000000),
+(0x5555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000000000),
+(0x15555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaa, 0x10000000000000000000000000),
+(0x55555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000000000),
+(0x155555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaa, 0x100000000000000000000000000),
+(0x555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x400000000000000000000000000),
+(0x1555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x1000000000000000000000000000),
+(0x5555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000000000000),
+(0x15555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x10000000000000000000000000000),
+(0x55555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x40000000000000000000000000000),
+(0x155555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x100000000000000000000000000000),
+(0x555555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x400000000000000000000000000000),
+(0x1555555555555555555555555555555, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x1000000000000000000000000000000),
+(0x5555555555555555555555555555555, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x4000000000000000000000000000000),
+(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] = {}
+	while bridges > 0:
+		bridges -= 1
+
+		bifurcationAlphaLocator, bifurcationZuluLocator, curveLocationsMAXIMUM = listCurveMaximums[bridges]
+
+		for curveLocations, distinctCrossings in startingCurveLocations.items():
+			bifurcationAlpha = (curveLocations & bifurcationAlphaLocator)
+			bifurcationZulu = (curveLocations & bifurcationZuluLocator) >> 1
+
+			bifurcationAlphaHasCurves = bifurcationAlpha != 1
+			bifurcationZuluHasCurves = bifurcationZulu != 1
+
+			# Z0Z_simpleBridges
+			curveLocationAnalysis = ((bifurcationAlpha | (bifurcationZulu << 1)) << 2) | 3
+			if curveLocationAnalysis < curveLocationsMAXIMUM:
+				dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+
+			# bifurcationAlphaCurves
+			if bifurcationAlphaHasCurves:
+				curveLocationAnalysis = (bifurcationAlpha >> 2) | (bifurcationZulu << 3) | ((bifurcationAlphaIsEven := 1 - (bifurcationAlpha & 0b1)) << 1)
+				if curveLocationAnalysis < curveLocationsMAXIMUM:
+					dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+
+			# bifurcationZuluCurves
+			if bifurcationZuluHasCurves:
+				curveLocationAnalysis = (bifurcationZulu >> 1) | (bifurcationAlpha << 2) | (bifurcationZuluIsEven := 1 - (bifurcationZulu & 1))
+				if curveLocationAnalysis < curveLocationsMAXIMUM:
+					dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+
+			# Z0Z_alignedBridges
+			if bifurcationZuluHasCurves and bifurcationAlphaHasCurves:
+				# One Truth-check to select a code path
+				bifurcationsCanBePairedTogether = (bifurcationZuluIsEven << 1) | bifurcationAlphaIsEven # pyright: ignore[reportPossiblyUnboundVariable]
+
+				if bifurcationsCanBePairedTogether != 0:  # Case 0 (False, False)
+					XOrHere2makePair = 0b1
+					findUnpaired_0b1 = 0
+
+					if bifurcationsCanBePairedTogether == 1:  # Case 1: (False, True)
+						while findUnpaired_0b1 >= 0:
+							XOrHere2makePair <<= 2
+							findUnpaired_0b1 += 1 if (bifurcationAlpha & XOrHere2makePair) == 0 else -1
+						bifurcationAlpha ^= XOrHere2makePair
+					elif bifurcationsCanBePairedTogether == 2:  # Case 2: (True, False)
+						while findUnpaired_0b1 >= 0:
+							XOrHere2makePair <<= 2
+							findUnpaired_0b1 += 1 if (bifurcationZulu & XOrHere2makePair) == 0 else -1
+						bifurcationZulu ^= XOrHere2makePair
+
+					# Cases 1, 2, and 3 all compute curveLocationAnalysis
+# TODO https://github.com/hunterhogan/mapFolding/issues/19
+					curveLocationAnalysis = ((bifurcationZulu >> 2) << 1) | (bifurcationAlpha >> 2)
+					if curveLocationAnalysis < curveLocationsMAXIMUM:
+						dictionaryCurveLocations[curveLocationAnalysis] = dictionaryCurveLocations.get(curveLocationAnalysis, 0) + distinctCrossings
+
+		startingCurveLocations.clear()
+		startingCurveLocations, dictionaryCurveLocations = dictionaryCurveLocations, startingCurveLocations
+
+		# print(sum(startingCurveLocations.values()))
+	return sum(startingCurveLocations.values())
+