mapFolding 0.14.0__py3-none-any.whl → 0.15.0__py3-none-any.whl

mapFolding/_theTypes.py

@@ -1,148 +1,52 @@
-"""
-Type system architecture for map folding computational domains.
-
-(AI generated docstring)
-
-Building upon the configuration foundation, this module defines the complete type
-hierarchy that ensures type safety and semantic clarity throughout the map folding
-computational framework. The type system recognizes three distinct computational
-domains, each with specific data characteristics and performance requirements
-that emerge from Lunnon's algorithm implementation.
-
-The Leaves domain handles map sections, their indices, and dimensional parameters.
-The Elephino domain manages internal computational state, gap calculations, and
-temporary indices used during the recursive folding analysis. The Folds domain
-represents final pattern counts and computation results. Each domain employs both
-Python types for general computation and NumPy types for performance-critical
-array operations.
-
-This dual-type strategy enables the core utility functions to operate with type
-safety while maintaining the computational efficiency required for analyzing
-complex multi-dimensional folding patterns. The array types built from these
-base types provide the structured data containers that computational state
-management depends upon.
-"""
-from numpy import dtype, integer, ndarray, uint8 as numpy_uint8, uint16 as numpy_uint16, uint64 as numpy_uint64
+"""Types for defensive coding and for computation optimization."""
+
+from numpy import dtype, int_ as numpy_int, integer, ndarray, uint64 as numpy_uint64
 from typing import Any, TypeAlias, TypeVar
 
 NumPyIntegerType = TypeVar('NumPyIntegerType', bound=integer[Any], covariant=True)
-"""
-Generic type variable for NumPy integer types used in computational operations.
-
-(AI generated docstring)
-
-This type variable enables generic programming with NumPy integer types while
-maintaining type safety. It supports covariant relationships between different
-NumPy integer types and their array containers.
-"""
-
-DatatypeLeavesTotal: TypeAlias = int
-"""
-Python type for leaf-related counts and indices in map folding computations.
-
-(AI generated docstring)
-
-Represents quantities related to individual map sections (leaves), including
-total leaf counts, leaf indices, and dimensional parameters. Uses standard
-Python integers for compatibility with general computations while enabling
-conversion to NumPy types when performance optimization is needed.
-"""
-
-NumPyLeavesTotal: TypeAlias = numpy_uint8
-"""
-NumPy type for efficient leaf-related computations and array operations.
-
-(AI generated docstring)
-
-Corresponds to `DatatypeLeavesTotal` but optimized for NumPy operations.
-Uses 8-bit unsigned integers since leaf counts in practical map folding
-scenarios typically remain small (under 256).
-"""
-
-DatatypeElephino: TypeAlias = int
-"""
-Python type for internal computational indices and intermediate values.
-
-(AI generated docstring)
-
-Used for temporary variables, gap indices, and other internal computational
-state that doesn't directly correspond to leaves or final fold counts. The
-name follows the package convention for internal computational domains.
-"""
+"""Any NumPy integer type, which is usually between 8-bit signed and 64-bit unsigned."""
 
-NumPyElephino: TypeAlias = numpy_uint16
-"""
-NumPy type for internal computational operations requiring moderate value ranges.
+DatatypeLeavesTotal: TypeAlias = int  # noqa: UP040 The TypeAlias may be used to construct ("cast") a value to the type. And the identifier may be changed to a different type.
+"""Use on unsigned integers that will never exceed the magnitude of `leavesTotal`."""
 
-(AI generated docstring)
+NumPyLeavesTotal: TypeAlias = numpy_int  # noqa: UP040 The TypeAlias may be used to construct ("cast") a value to the type. And the identifier may be changed to a different type.
+"""Use in NumPy data structures whose elements are unsigned integers that will never exceed the magnitude of `leavesTotal`."""
 
-Corresponds to `DatatypeElephino` with 16-bit unsigned integer storage,
-providing sufficient range for internal computations while maintaining
-memory efficiency in array operations.
-"""
+DatatypeElephino: TypeAlias = int  # noqa: UP040 The TypeAlias may be used to construct ("cast") a value to the type. And the identifier may be changed to a different type.
+"""Use on unsigned integers that will exceed the magnitude of `leavesTotal` but that are not "colossal."
 
-DatatypeFoldsTotal: TypeAlias = int
-"""
-Python type for final fold counts and pattern totals.
+Note well
+---------
+Colossal values are found with the cross humpy inequality:
 
-(AI generated docstring)
+    ⎡ el  ⎤   ⎡     ⎤
+    ⎢ eph ⎥ X ⎢ rhi ⎥ <= elephino
+    ⎣ ant ⎦   ⎣ no  ⎦
 
-Represents the ultimate results of map folding computations - the total number
-of distinct folding patterns possible for a given map configuration. These
-values can grow exponentially with map size, requiring flexible integer types.
 """
 
-NumPyFoldsTotal: TypeAlias = numpy_uint64
-"""
-NumPy type for large fold count computations and high-precision results.
+NumPyElephino: TypeAlias = numpy_int  # noqa: UP040 The TypeAlias may be used to construct ("cast") a value to the type. And the identifier may be changed to a different type.
+"""Use in NumPy data structures whose elements are unsigned integers that might exceed the magnitude of `leavesTotal` but that are not 'colossal.'"""
 
-(AI generated docstring)
+DatatypeFoldsTotal: TypeAlias = int  # noqa: UP040 The TypeAlias may be used to construct ("cast") a value to the type. And the identifier may be changed to a different type.
+"""Use on unsigned integers that might have colossal magnitudes similar to `foldsTotal`."""
 
-Corresponds to `DatatypeFoldsTotal` using 64-bit unsigned integers to
-accommodate the exponentially large values that can result from map folding
-computations on even moderately-sized maps.
-"""
+NumPyFoldsTotal: TypeAlias = numpy_uint64  # noqa: UP040 The TypeAlias may be used to construct ("cast") a value to the type. And the identifier may be changed to a different type.
+"""Use in NumPy data structures whose elements are unsigned integers that might have colossal magnitudes similar to `foldsTotal`.
 
-Array3D: TypeAlias = ndarray[tuple[int, int, int], dtype[NumPyLeavesTotal]]
-"""
-Three-dimensional NumPy array type for connection graph representations.
+Note well
+---------
+If your elements might exceed 1.8 × 10^19, then you should take extra steps to ensure the integrity of the data in NumPy or use a
+different data structure."""
 
-(AI generated docstring)
+Array3DLeavesTotal: TypeAlias = ndarray[tuple[int, int, int], dtype[NumPyLeavesTotal]]  # noqa: UP040 The TypeAlias may be used to construct ("cast") a value to the type. And the identifier may be changed to a different type.
+"""A `numpy.ndarray` with three axes and elements of type `NumPyLeavesTotal`."""
 
-Used to store the connectivity relationships between map leaves in a
-3D array structure. The array uses `NumPyLeavesTotal` element type since
-the stored values represent leaf indices and connection states.
-"""
+Array1DLeavesTotal: TypeAlias = ndarray[tuple[int], dtype[NumPyLeavesTotal]]  # noqa: UP040 The TypeAlias may be used to construct ("cast") a value to the type. And the identifier may be changed to a different type.
+"""A `numpy.ndarray` with one axis and elements of type `NumPyLeavesTotal`."""
 
-Array1DLeavesTotal: TypeAlias = ndarray[tuple[int], dtype[NumPyLeavesTotal]]
-"""
-One-dimensional NumPy array type for leaf-related data sequences.
+Array1DElephino: TypeAlias = ndarray[tuple[int], dtype[NumPyElephino]]  # noqa: UP040 The TypeAlias may be used to construct ("cast") a value to the type. And the identifier may be changed to a different type.
+"""A `numpy.ndarray` with one axis and elements of type `NumPyElephino`."""
 
-(AI generated docstring)
-
-Stores sequences of leaf counts, indices, or related values in efficient
-array format. Common uses include leaf sequences, gap locations, and
-dimensional data where each element relates to the leaves domain.
-"""
-
-Array1DElephino: TypeAlias = ndarray[tuple[int], dtype[NumPyElephino]]
-"""
-One-dimensional NumPy array type for internal computational sequences.
-
-(AI generated docstring)
-
-Used for storing sequences of internal computational values such as
-gap range starts, temporary indices, and other intermediate results
-that require the elephino computational domain's value range.
-"""
-
-Array1DFoldsTotal: TypeAlias = ndarray[tuple[int], dtype[NumPyFoldsTotal]]
-"""
-One-dimensional NumPy array type for sequences of fold count results.
-
-(AI generated docstring)
-
-Stores sequences of fold totals and pattern counts, using the large
-integer type to accommodate the potentially enormous values that
-result from complex map folding computations.
-"""
+Array1DFoldsTotal: TypeAlias = ndarray[tuple[int], dtype[NumPyFoldsTotal]]  # noqa: UP040 The TypeAlias may be used to construct ("cast") a value to the type. And the identifier may be changed to a different type.
+"""A `numpy.ndarray` with one axis and elements of type `NumPyFoldsTotal`."""

mapFolding/basecamp.py

@@ -31,7 +31,7 @@ from os import PathLike
 from pathlib import PurePath
 import contextlib
 
-def countFolds(listDimensions: Sequence[int] | None = None  # noqa: C901, PLR0912, PLR0915
+def countFolds(listDimensions: Sequence[int] | None = None
 				, pathLikeWriteFoldsTotal: PathLike[str] | PurePath | None = None
 				, computationDivisions: int | str | None = None
 				# , * # TODO improve `standardizedEqualToCallableReturn` so it will work with keyword arguments

mapFolding/beDRY.py

@@ -121,12 +121,6 @@ def getTaskDivisions(computationDivisions: int | str | None, concurrencyLimit: i
 def _makeConnectionGraph(mapShape: tuple[int, ...], leavesTotal: int) -> ndarray[tuple[int, int, int], numpy_dtype[numpy_int64]]:
 	"""Implement connection graph generation for map folding.
 
-	(AI generated docstring)
-
-	This is the internal implementation that calculates all possible connections between leaves in a map folding problem
-	based on Lunnon's algorithm. The function constructs a three-dimensional array representing which leaves can be
-	connected to each other for each dimension of the map.
-
 	Parameters
 	----------
 	mapShape : tuple[int, ...]
@@ -177,12 +171,6 @@ def _makeConnectionGraph(mapShape: tuple[int, ...], leavesTotal: int) -> ndarray
 def getConnectionGraph(mapShape: tuple[int, ...], leavesTotal: int, datatype: type[NumPyIntegerType]) -> ndarray[tuple[int, int, int], numpy_dtype[NumPyIntegerType]]:
 	"""Create a properly typed connection graph for the map folding algorithm.
 
-	(AI generated docstring)
-
-	This function serves as a typed wrapper around the internal implementation that generates connection graphs. It
-	provides the correct type information for the returned array, ensuring consistency throughout the computation
-	assembly-line.
-
 	Parameters
 	----------
 	mapShape : tuple[int, ...]
@@ -204,25 +192,21 @@ def getConnectionGraph(mapShape: tuple[int, ...], leavesTotal: int, datatype: ty
 	return connectionGraph.astype(datatype)
 
 def makeDataContainer(shape: int | tuple[int, ...], datatype: type[NumPyIntegerType]) -> ndarray[Any, numpy_dtype[NumPyIntegerType]]:
-	"""Create a typed NumPy array container with initialized values.
-
-	(AI generated docstring)
+	"""Create any data container as long as it is a `numpy.ndarray` full of zeroes of type `numpy.integer`.
 
-	This function centralizes the creation of data containers used throughout the computation assembly-line, enabling
-	easy switching between different container types or implementation strategies if needed in the future.
+	By centralizing data container creation, you can more easily make global changes.
 
 	Parameters
 	----------
 	shape : int | tuple[int, ...]
-		Either an integer (for 1D arrays) or a tuple of integers (for multi-dimensional arrays) specifying the
-		dimensions of the array.
+		The array shape, either as a single axis length or a tuple of axes lengths.
 	datatype : type[NumPyIntegerType]
-		The NumPy integer type to use for the array elements, ensuring proper type consistency and memory efficiency.
+		The `numpy.integer` type for the array elements.
 
 	Returns
 	-------
 	container : ndarray[Any, numpy_dtype[NumPyIntegerType]]
-		A NumPy array of zeros with the specified shape and `datatype`.
+		A zero-filled `ndarray` with the specified `shape` and `datatype`.
 
 	"""
 	return numpy.zeros(shape, dtype=datatype)

mapFolding/dataBaskets.py

@@ -21,7 +21,7 @@ integrity throughout the recursive analysis while providing the structured data
 access patterns that enable efficient result persistence and retrieval.
 """
 from mapFolding import (
-	Array1DElephino, Array1DLeavesTotal, Array3D, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
+	Array1DElephino, Array1DLeavesTotal, Array3DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal,
 	getConnectionGraph, getLeavesTotal, makeDataContainer)
 import dataclasses
 
@@ -63,7 +63,9 @@ class MapFoldingState:
 		Array tracking the leaves above to the current leaf, `leaf1ndex`, during computation.
 	leafBelow : Array1DLeavesTotal = None
 		Array tracking the leaves below to the current leaf, `leaf1ndex`, during computation.
-	connectionGraph : Array3D
+	leafComparison : Array1DLeavesTotal = None
+		Array for finding symmetric folds.
+	connectionGraph : Array3DLeavesTotal
 		Unchanging array representing connections between all leaves.
 	dimensionsTotal : DatatypeLeavesTotal
 		Unchanging total number of dimensions in the map.
@@ -106,8 +108,10 @@ class MapFoldingState:
 	"""Array tracking the leaves above to the current leaf, `leaf1ndex`, during computation."""
 	leafBelow: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
 	"""Array tracking the leaves below to the current leaf, `leaf1ndex`, during computation."""
+	leafComparison: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	"""Array for finding symmetric folds."""
 
-	connectionGraph: Array3D = dataclasses.field(init=False, metadata={'dtype': Array3D.__args__[1].__args__[0]}) # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
+	connectionGraph: Array3DLeavesTotal = dataclasses.field(init=False, metadata={'dtype': Array3DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
 	"""Unchanging array representing connections between all leaves."""
 	dimensionsTotal: DatatypeLeavesTotal = dataclasses.field(init=False)
 	"""Unchanging total number of dimensions in the map."""
@@ -147,6 +151,7 @@ class MapFoldingState:
 		if self.gapRangeStart is None: self.gapRangeStart = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['gapRangeStart'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]  # noqa: E701
 		if self.leafAbove is None: self.leafAbove = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafAbove'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]  # noqa: E701
 		if self.leafBelow is None: self.leafBelow = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafBelow'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]  # noqa: E701
+		if self.leafComparison is None: self.leafComparison = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafComparison'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]  # noqa: E701
 
 @dataclasses.dataclass
 class ParallelMapFoldingState(MapFoldingState):

mapFolding/oeis.py

@@ -31,7 +31,7 @@ from itertools import chain
 from mapFolding import countFolds
 from mapFolding._theSSOT import cacheDays, pathCache, settingsOEISManuallySelected
 from pathlib import Path
-from typing import Any, Final, TypedDict
+from typing import Final, TypedDict
 from urllib.request import urlopen
 import argparse
 import sys
@@ -331,8 +331,8 @@ def makeDictionaryFoldsTotalKnown() -> dict[tuple[int, ...], int]:
 		of distinct folding patterns for those shapes.
 
 	"""
-	return dict(chain.from_iterable(zip(map(oeisID['getMapShape'], oeisID['valuesKnown'].keys())
-	, oeisID['valuesKnown'].values(), strict=True) for oeisID in dictionaryOEIS.values()))
+	return dict(chain.from_iterable(zip(map(oeisIDmetadata['getMapShape'], oeisIDmetadata['valuesKnown'].keys())
+	, oeisIDmetadata['valuesKnown'].values(), strict=True) for oeisID, oeisIDmetadata in dictionaryOEIS.items() if oeisID != 'A007822'))
 
 def getFoldsTotalKnown(mapShape: tuple[int, ...]) -> int:
 	"""Retrieve the known total number of distinct folding patterns for a given map shape.
@@ -410,26 +410,19 @@ def _formatOEISsequenceInfo() -> str:
 		for oeisID in oeisIDsImplemented
 	)
 
-def oeisIDfor_n(oeisID: str, n: int | Any) -> int:
-	"""Calculate the value a(n) for a specified OEIS sequence and index.
-
-	(AI generated docstring)
-
-	This function serves as the primary interface for computing OEIS sequence values within the map folding
-	context. For small values or values within the known range, it returns cached OEIS data. For larger
-	values, it computes the result using the map folding algorithm with the appropriate map shape derived
-	from the sequence definition.
+def oeisIDfor_n(oeisID: str, n: int) -> int:
+	"""Calculate the value a(n) for a specified OEIS ID and index.
 
 	Parameters
 	----------
 	oeisID : str
 		The identifier of the OEIS sequence to evaluate.
-	n : int | Any
+	n : int
 		A non-negative integer index for which to calculate the sequence value.
 
 	Returns
 	-------
-	int
+	a(n) : int
 		The value a(n) of the specified OEIS sequence.
 
 	Raises
@@ -448,7 +441,7 @@ def oeisIDfor_n(oeisID: str, n: int | Any) -> int:
 		message = f"I received `{n = }` in the form of `{type(n) = }`, but it must be non-negative integer in the form of `{int}`."
 		raise ValueError(message)
 
-	mapShape: tuple[int, ...] = dictionaryOEIS[oeisID]['getMapShape'](n)
+	mapShape = dictionaryOEIS[oeisID]['getMapShape'](n)
 
 	if n <= 1 or len(mapShape) < 2:
 		offset: int = dictionaryOEIS[oeisID]['offset']
@@ -457,6 +450,11 @@ def oeisIDfor_n(oeisID: str, n: int | Any) -> int:
 			raise ArithmeticError(message)
 		foldsTotal: int = dictionaryOEIS[oeisID]['valuesKnown'][n]
 		return foldsTotal
+
+	if oeisID == 'A007822':
+		from mapFolding._A007822 import Z0Z_flowNeedsFixing  # noqa: PLC0415
+		return Z0Z_flowNeedsFixing(mapShape)
+
 	return countFolds(mapShape)
 
 def OEIS_for_n() -> None:

mapFolding/reference/A005316optimized128bit.py

@@ -5,44 +5,44 @@ def count(bridges: int, dictionaryCurveLocationsKnown: dict[int, int]) -> int:
 		dictionaryCurveLocationsDiscovered: dict[int, int] = {}
 
 		for curveLocations, distinctCrossings in dictionaryCurveLocationsKnown.items():
-			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)
 				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 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)
 				if curveLocationAnalysis < curveLocationsMAXIMUM:
 					dictionaryCurveLocationsDiscovered[curveLocationAnalysis] = dictionaryCurveLocationsDiscovered.get(curveLocationAnalysis, 0) + distinctCrossings
 

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