mapFolding 0.16.4__py3-none-any.whl → 0.17.0__py3-none-any.whl

easyRun/A000682.py

@@ -10,7 +10,7 @@ if sys.version_info >= (3, 14):
 def main():
 	oeisID = 'A000682'
 	n=45
-	print(NOTcountingFolds(oeisID, n, 'matrixNumPy'))
+	print(NOTcountingFolds(oeisID, n, 'matrixMeanders'))
 
 	from mapFolding import dictionaryOEIS
 	if n < dictionaryOEIS[oeisID]['valueUnknown']:
@@ -21,5 +21,5 @@ if __name__ == "__main__":
 
 r"""
 deactivate && C:\apps\mapFolding\.vtail\Scripts\activate.bat && title good && cls
-title running && start "running" /B /HIGH /wait py -X faulthandler=0 -X tracemalloc=0 -X frozen_modules=on easyRun\A000682.py && title I'm done || title Error
+title running && start "running" /B /HIGH /wait py -X faulthandler=0 -X tracemalloc=0 -X frozen_modules=on easyRun\A000682.py & title I'm done
 """

easyRun/NOTcountingFolds.py

@@ -1,13 +1,16 @@
 # ruff: noqa
-from mapFolding import dictionaryOEIS
+from collections import ChainMap
+from mapFolding import dictionaryOEIS, dictionaryOEISMapFolding
 from mapFolding.basecamp import NOTcountingFolds
 import sys
 import time
 
+dictionaryONE = ChainMap(dictionaryOEISMapFolding, dictionaryOEIS) # pyright: ignore[reportArgumentType]
+
 if __name__ == '__main__':
 	def _write() -> None:
 		sys.stdout.write(
-			f"{(match:=countTotal == dictionaryOEIS[oeisID]['valuesKnown'][n])}\t"
+			f"{(match:=countTotal == dictionaryONE[oeisID]['valuesKnown'][n])}\t"
 			f"\033[{(not match)*91}m"
 			f"{n}\t"
 			f"{countTotal}\t"
@@ -15,23 +18,27 @@ if __name__ == '__main__':
 			"\033[0m\n"
 		)
 
-	CPUlimit: bool | float | int | None = 3
-	# oeisID: str | None = None
-	oeis_n: int | None = None
+	CPUlimit: bool | float | int | None = -2
 	flow: str | None = None
 
-	oeisID = 'A001010'
 	oeisID = 'A007822'
 
 	flow = 'algorithm'
 	flow = 'asynchronous'
-	flow = 'theorem2Numba'
 	flow = 'theorem2Trimmed'
+	flow = 'theorem2Numba'
+	flow = 'theorem2'
 
-	# for n in range(7,10):
-	for n in range(3,8):
+	# for n in range(13,16):
+	for n in range(1,4):
 
 		timeStart = time.perf_counter()
 		countTotal = NOTcountingFolds(oeisID, n, flow, CPUlimit)
 
 		_write()
+
+r"""
+deactivate && C:\apps\mapFolding\.vtail\Scripts\activate.bat && title good && cls
+title running && start "working" /B /HIGH /wait py -X faulthandler=0 -X tracemalloc=0 -X frozen_modules=on easyRun\NOTcountingFolds.py & title I'm done
+"""
+

easyRun/countFolds.py

@@ -23,14 +23,21 @@ if __name__ == '__main__':
 	computationDivisions: int | str | None = None
 	CPUlimit: bool | float | int | None = None
 	# mapShape: tuple[int, ...] | None = None
-	flow: str | None = 'theorem2Numba'
+	flow = 'daoOfMapFolding'
+	flow = 'numba'
+	flow = 'theorem2'
+	flow = 'theorem2Numba'
+	flow: str | None = 'theorem2Trimmed'
 
-	oeisID: str = 'A001416'
-	for n in range(3,8):
+
+	oeisID: str = 'A001415'
+	oeisID: str = 'A000136'
+	for n in range(1,4):
 
 		mapShape: tuple[int, ...] = dictionaryOEISMapFolding[oeisID]['getMapShape'](n)
 
 		timeStart = time.perf_counter()
+		# foldsTotal: int = countFolds(listDimensions=None, pathLikeWriteFoldsTotal=None, computationDivisions=None, CPUlimit=None, mapShape=(2, 3), flow='theorem2Trimmed')
 		foldsTotal: int = countFolds(listDimensions=listDimensions
 						, pathLikeWriteFoldsTotal=pathLikeWriteFoldsTotal
 						, computationDivisions=computationDivisions

easyRun/meanders.py

@@ -24,8 +24,8 @@ if __name__ == '__main__':
 	if sys.version_info >= (3, 14):
 		warnings.filterwarnings("ignore", category=FutureWarning)
 
-	flow = 'matrixMeanders'
 	flow = 'matrixPandas'
+	flow = 'matrixMeanders'
 	flow = 'matrixNumPy'
 
 	for oeisID in [
@@ -46,8 +46,8 @@ if __name__ == '__main__':
 
 		nList: list[int] = []
 		nList.extend(range(2, 10))
-		# nList.extend(range(2, 28))
-		nList.extend(range(28,33))
+		# nList.extend(range(10, 28))
+		# nList.extend(range(28,33))
 		# nList.extend(range(33,38))
 		# nList.extend(range(38,43))
 		# nList.extend(range(43,45))

mapFolding/algorithms/A000136constraintPropagation.py

@@ -0,0 +1,95 @@
+from ortools.sat.python import cp_model
+
+def findValidFoldings(leavesTotal: int, workersMaximum: int) -> list[list[int]]:  # noqa: ARG001
+	model = cp_model.CpModel()
+	listIndexAsIntVar: list[cp_model.IntVar] = [model.NewIntVar(0, leavesTotal - 1, f"leafIndexAtPosition[{positionIndex}]") for positionIndex in range(leavesTotal)]
+	indexOfLeafInIndexOfPosition: list[cp_model.IntVar] = [model.NewIntVar(0, leavesTotal - 1, f"positionOfLeafIndex[{leafNumber}]") for leafNumber in range(1, leavesTotal + 1)]
+	model.AddInverse(listIndexAsIntVar, indexOfLeafInIndexOfPosition)
+	model.Add(listIndexAsIntVar[0] == 0) # Fix leaf 1 at position 0
+
+	if leavesTotal > 2:
+		leavesTotalIsOdd: bool = leavesTotal % 2 == 1
+		if leavesTotalIsOdd:
+			leafTwoOccupiesPositionTwo: cp_model.IntVar = model.NewBoolVar("leafTwoOccupiesPositionTwo")
+			model.Add(indexOfLeafInIndexOfPosition[1] == 2).OnlyEnforceIf(leafTwoOccupiesPositionTwo)
+			model.Add(indexOfLeafInIndexOfPosition[1] != 2).OnlyEnforceIf(leafTwoOccupiesPositionTwo.Not())
+			model.Add(listIndexAsIntVar[1] == leavesTotal - 1).OnlyEnforceIf(leafTwoOccupiesPositionTwo)
+		else:
+			model.Add(indexOfLeafInIndexOfPosition[1] != 2)
+
+	if leavesTotal > 3:
+		leafTwoOccupiesFinalPosition: cp_model.IntVar = model.NewBoolVar("leafTwoOccupiesFinalPosition")
+		model.Add(indexOfLeafInIndexOfPosition[1] == leavesTotal - 1).OnlyEnforceIf(leafTwoOccupiesFinalPosition)
+		model.Add(indexOfLeafInIndexOfPosition[1] != leavesTotal - 1).OnlyEnforceIf(leafTwoOccupiesFinalPosition.Not())
+		leavesTotalIsEven: bool = leavesTotal % 2 == 0
+		if leavesTotalIsEven:
+			leafThreeOccupiesIndexTwoFromEnd: cp_model.IntVar = model.NewBoolVar("leafThreeOccupiesIndexTwoFromEnd")
+			model.Add(indexOfLeafInIndexOfPosition[2] == leavesTotal - 3).OnlyEnforceIf(leafThreeOccupiesIndexTwoFromEnd)
+			model.Add(indexOfLeafInIndexOfPosition[2] != leavesTotal - 3).OnlyEnforceIf(leafThreeOccupiesIndexTwoFromEnd.Not())
+			lastLeafOccupiesPenultimatePosition: cp_model.IntVar = model.NewBoolVar("lastLeafOccupiesPenultimatePosition")
+			model.Add(listIndexAsIntVar[leavesTotal - 2] == leavesTotal - 1).OnlyEnforceIf(lastLeafOccupiesPenultimatePosition)
+			model.Add(listIndexAsIntVar[leavesTotal - 2] != leavesTotal - 1).OnlyEnforceIf(lastLeafOccupiesPenultimatePosition.Not())
+			model.AddBoolOr([
+				leafTwoOccupiesFinalPosition.Not(),
+				leafThreeOccupiesIndexTwoFromEnd.Not(),
+				lastLeafOccupiesPenultimatePosition,
+			])
+		else:
+			model.Add(indexOfLeafInIndexOfPosition[2] != leavesTotal - 3).OnlyEnforceIf(leafTwoOccupiesFinalPosition)
+
+	listForbiddenInequalitiesDeconstructed: list[tuple[tuple[int, int], tuple[int, int], tuple[int, int]]] = []
+	for k in range(1, leavesTotal):
+		for r in range(2, leavesTotal):
+			if r == k or (k - r) % 2 != 0:
+				continue
+			k1: int = k + 1
+			r1: int = r + 1
+
+			"""All 8 forbidden forms, index of:
+				[k < r < k+1 < r+1] [r < k+1 < r+1 < k] [k+1 < r+1 < k < r] [r+1 < k < r < k+1]
+				[r < k < r+1 < k+1] [k < r+1 < k+1 < r] [r+1 < k+1 < r < k] [k+1 < r < k < r+1]
+			"""
+			listForbiddenInequalitiesDeconstructed.extend([
+				((k-1, r-1), (r-1, k1-1), (k1-1, r1-1)),
+				((k1-1, r1-1), (r1-1, k-1), (k-1, r-1)),
+				((r1-1, k-1), (k-1, r-1), (r-1, k1-1)),
+				((k-1, r1-1), (r1-1, k1-1), (k1-1, r-1)),
+				# ((r-1, k1-1), (k1-1, r1-1), (r1-1, k-1)), ((r-1, k-1), (k-1, r1-1), (r1-1, k1-1)), ((r1-1, k1-1), (k1-1, r-1), (r-1, k-1)), ((k1-1, r-1), (r-1, k-1), (k-1, r1-1)),  # noqa: ERA001
+			])
+	for tupleIndices in listForbiddenInequalitiesDeconstructed:
+		listOfInequalities: list[cp_model.IntVar] = []
+		for indexLeft, indexRight in tupleIndices:
+			inequalityOf2Indices: cp_model.IntVar = model.NewBoolVar(f"order_{indexLeft}_{indexRight}")
+			model.Add(indexOfLeafInIndexOfPosition[indexLeft] < indexOfLeafInIndexOfPosition[indexRight]).OnlyEnforceIf(inequalityOf2Indices)
+			model.Add(indexOfLeafInIndexOfPosition[indexLeft] >= indexOfLeafInIndexOfPosition[indexRight]).OnlyEnforceIf(inequalityOf2Indices.Not())
+			listOfInequalities.append(inequalityOf2Indices)
+		# At least one inequality must be false to avoid forbidden pattern
+		model.AddBoolOr([inequality.Not() for inequality in listOfInequalities])
+
+	solver = cp_model.CpSolver()
+	solver.parameters.enumerate_all_solutions = True
+
+	solver.parameters.cp_model_presolve = True
+	solver.parameters.use_combined_no_overlap = True
+	solver.parameters.use_disjunctive_constraint_in_cumulative = True
+	solver.parameters.use_objective_shaving_search = True
+	solver.parameters.use_precedences_in_disjunctive_constraint = True
+	# solver.parameters.num_workers = 2  # noqa: ERA001
+	solver.parameters.num_workers = 1
+
+	class FoldingCollector(cp_model.CpSolverSolutionCallback):
+		def __init__(self, leafIndexAtPositionInput: list[cp_model.IntVar]) -> None:
+			super().__init__()
+			self.leafIndexAtPositionInput = leafIndexAtPositionInput
+			self.listFoldings: list[list[int]] = []
+
+		def OnSolutionCallback(self) -> None:
+			self.listFoldings.append([self.Value(positionVariable) + 1 for positionVariable in self.leafIndexAtPositionInput]) # pyright: ignore[reportUnknownMemberType]
+
+	foldingCollector = FoldingCollector(listIndexAsIntVar)
+	solver.Solve(model, foldingCollector)
+	return foldingCollector.listFoldings
+
+def doTheNeedful(leavesTotal: int, workersMaximum: int = 1) -> int:
+	"""Count the number of valid foldings for a given number of leaves."""
+	return len(findValidFoldings(leavesTotal, workersMaximum)) * leavesTotal

mapFolding/algorithms/A000136elimination.py

@@ -0,0 +1,163 @@
+from itertools import permutations, starmap
+from typing import Final
+
+def isThisValid(folding: tuple[int, ...]) -> bool:
+	"""Verify that a folding sequence is possible.
+
+	Parameters
+	----------
+	folding : list[int]
+		List of integers representing the folding sequence.
+
+	Returns
+	-------
+	valid : bool
+		True if the folding sequence is valid, False otherwise.
+
+	Notes
+	-----
+	All 8 forbidden forms
+		[k, r, k+1, r+1] [r, k+1, r+1, k] [k+1, r+1, k, r] [r+1, k, r, k+1]
+		[r, k, r+1, k+1] [k, r+1, k+1, r] [r+1, k+1, r, k] [k+1, r, k, r+1]
+
+	I selected the four forms in which k precedes r. Because of the flow, I _think_ that is why these four are sufficient.
+
+	Citation
+	--------
+	John E. Koehler, Folding a strip of stamps, Journal of Combinatorial Theory, Volume 5, Issue 2, 1968, Pages 135-152, ISSN
+	0021-9800, https://doi.org/10.1016/S0021-9800(68)80048-1.
+	(https://www.sciencedirect.com/science/article/pii/S0021980068800481)
+
+	See Also
+	--------
+	- "[Annotated, corrected, scanned copy]" at https://oeis.org/A001011.
+	- Citation in BibTeX format "citations/KOEHLER1968135.bib".
+	"""
+	leavesTotal: int = len(folding)
+	for index, leaf in enumerate(folding[0:-1]):												# `[0:-1]` No room to interpose
+		if leaf == leavesTotal:
+			continue
+		indexLeafRightSide: int = folding.index(leaf+1)
+		leafIsOdd: int = leaf & 1
+
+		for indexInterposer, interposer in enumerate(folding[index + 1:None], start=index + 1):	# [k != r]
+			if leafIsOdd != (interposer & 1):													# [k%2 == r%2]
+				continue
+			if interposer == leavesTotal:
+				continue
+
+			indexInterposerRightSide: int = folding.index(interposer + 1)
+
+			if (index < indexInterposer < indexLeafRightSide < indexInterposerRightSide			# [k, r, k+1, r+1]
+			or  index < indexInterposerRightSide < indexLeafRightSide < indexInterposer			# [k, r+1, k+1, r]
+			or  indexLeafRightSide < indexInterposerRightSide < index < indexInterposer			# [k+1, r+1, k, r]
+			or  indexInterposerRightSide < index < indexInterposer < indexLeafRightSide			# [r+1, k, r, k+1]
+				):
+				return False
+	return True
+
+def count(prefix: list[int], permutands: list[int], postfix: list[int]) -> int:
+	"""Count the number of valid foldings for a given fixed start and remaining leaves.
+
+	Parameters
+	----------
+	prefix : list[int]
+		List of integers representing the fixed start of the folding sequence.
+	permutands : list[int]
+		List of elements to permute into permutations.
+	postfix : list[int]
+		List of integers representing the fixed end of the folding sequence.
+
+	Returns
+	-------
+	groupsOfFolds : int
+		Number of valid foldings, which each represent a group of folds, for the given configuration.
+	"""
+	groupsOfFolds: int = 0
+	for aPermutation in permutations(permutands):
+		groupsOfFolds += isThisValid((*prefix, *aPermutation, *postfix))
+	return groupsOfFolds
+
+def staging(prefix: list[int], permutands: list[int]) -> int:
+	"""Segregate sequences with a final `2`: necessary as part of excluding leading `1,2`.
+
+	Parameters
+	----------
+	prefix : list[int]
+		List of integers representing the fixed start of the folding sequence.
+	permutands : list[int]
+		List of elements to permute into permutations.
+
+	Notes
+	-----
+	Transformation indices:
+
+	1,3,4,5,6,2,
+	1,2,6,5,4,3,
+
+	All valid sequences that end with '2' are in the first half.
+	All valid sequences that start with '1,2' are in the second half.
+	The remaining valid sequences are evenly split between the two halves.
+	Therefore:
+		1. Filter out all '1,2' before checking validity.
+		2. If a valid sequence ends in '2', add 2 to the total count.
+		3. If a valid sequence does not end in '2', add 1 to the total count.
+
+	`leaf = leavesTotal` is evenly distributed in each half like this: (ex. from A007822(7))
+	^1,14, ,14,$ 612
+	,14,$ ^1,14, 1486
+	"""
+	groupsOfFolds: int = 0
+	postfix: list[int] = []
+	if 2 in permutands:
+		postfix.append(2)
+		postfixComplement: list[int] = permutands.copy()
+		postfixComplement.remove(2)
+		groupsOfFolds += count(prefix, postfixComplement, postfix) * 2
+		for leafPostfix in postfixComplement:
+			groupsOfFolds += count(prefix, [leaf for leaf in permutands if leaf != leafPostfix], [leafPostfix])
+	else:
+		groupsOfFolds += count(prefix, permutands, postfix)
+	return groupsOfFolds
+
+def doTheNeedful(n: int) -> int:
+	"""Count the number of valid foldings for a given number of leaves."""
+	leavesTotal: Final[int] = n
+	listToPermute: list[tuple[list[int], list[int]]] = []
+
+	prefix: list[int] = [1]
+	listLeaves: Final[list[int]] = list(range(leavesTotal, 1, -1))
+
+	permutands: list[int] = listLeaves.copy()
+
+# ------- Exclude leading 2 -------------------------------
+# NOTE 1,{3..n},{2..n}...
+	excludeLeading2: list[int] = permutands.copy()
+	excludeLeading2.remove(2)
+	listToPermute.extend([([*prefix, leafPrefix], [leaf for leaf in permutands if leaf != leafPrefix]) for leafPrefix in excludeLeading2])
+	del excludeLeading2
+
+# ------- Exclude interposed 2 ----------------------------
+# NOTE 1,{3..n},{3..n},{2..n}...
+# NOTE 1,{n,if n&1},{2..n-1}...
+	for aTuple in listToPermute.copy():
+		if len(aTuple[0]) != 2 or leavesTotal < 4:
+			continue
+		interposer: int = aTuple[0][1]
+		excludeInterposed2: list[int] = permutands.copy()
+		excludeInterposed2.remove(2)
+		excludeInterposed2.remove(interposer)
+		if interposer == leavesTotal and interposer & 1:
+			listToPermute.append(([*aTuple[0], 2], excludeInterposed2))
+		listToPermute.extend([([*aTuple[0], leafPrefix], [leaf for leaf in permutands if leaf not in (leafPrefix, interposer)]) for leafPrefix in excludeInterposed2])
+		listToPermute.remove(aTuple)
+		del aTuple, excludeInterposed2, interposer
+
+	return sum(starmap(staging, listToPermute)) * leavesTotal
+
+# ------- Exclude interposed 3 ----------------------------
+# NOTE 1,{3..n},{3..n},{2..n}...,{3..n}
+# NOTE 1,{3..n},{3..n},{3..n}...,{4..n},{3..n},{2}
+# NOTE 1,{3..n-1},...,{n,if ~n&1},{2}
+# NOTE 1,{n,if n&1},{2..n-1}...
+

mapFolding/algorithms/A000136eliminationParallel.py

@@ -0,0 +1,77 @@
+from concurrent.futures import Future, ProcessPoolExecutor
+from itertools import permutations
+
+def isThisValid(folding: list[int]) -> bool:
+	"""Verify that a folding sequence is possible.
+
+	Parameters
+	----------
+	folding : list[int]
+		List of integers representing the folding sequence.
+
+	Returns
+	-------
+	valid : bool
+		True if the folding sequence is valid, False otherwise.
+	"""
+	leavesTotal: int = len(folding)
+	for index, leaf in enumerate(folding[0:-1]):	# Last leaf cannot interpose
+		if leaf == leavesTotal:
+			continue
+		indexLeafRightSide: int = folding.index(leaf+1)
+		leafIsOdd: int = leaf & 1
+
+		for indexInterposer, interposer in enumerate(folding[index + 1:None], start=index + 1):	# [k != r]
+			if leafIsOdd != (interposer & 1):											# [k%2 == r%2]
+				continue
+			if interposer == leavesTotal:
+				continue
+
+			indexInterposerRightSide: int = folding.index(interposer + 1)
+
+			if (index < indexInterposer < indexLeafRightSide < indexInterposerRightSide	# [k, r, k+1, r+1]
+			or  index < indexInterposerRightSide < indexLeafRightSide < indexInterposer	# [k, r+1, k+1, r]
+			or  indexLeafRightSide < indexInterposerRightSide < index < indexInterposer	# [k+1, r+1, k, r]
+			or  indexInterposerRightSide < index < indexInterposer < indexLeafRightSide	# [r+1, k, r, k+1]
+				):
+				return False
+	return True
+
+def count(fixed: list[int], permutands: list[int]) -> int:
+	"""Count the number of valid foldings for a given fixed start and remaining leaves.
+
+	Parameters
+	----------
+	fixed : list[int]
+		List of integers representing the fixed start of the folding sequence.
+	permutands : list[int]
+		List of elements to permute into permutations.
+	"""
+	validTotal: int = 0
+	for aPermutation in permutations(permutands):
+		validTotal += isThisValid([*fixed, *aPermutation])
+	return validTotal
+
+def doTheNeedful(n: int, processesMaximum: int) -> int:
+	"""Count the number of valid foldings for a given number of leaves."""
+	validTotal: int = 0
+	listLeavesTruncated: list[int] = list(range(2, n + 1))
+# NOTE Design goals:
+# Minimize creation/destruction of processes.
+# Use all processes until the end.
+# A valid sequence takes many times more cycles to process than a sequence that is proved invalid in the first few elements.
+# So, dividing purely on the number of sequences is not optimal.
+# Prefer generators of lists over lists of lists.
+
+# In the current system, each `Future` leads to a returned value, which is then summed. But, I don't care about any specific
+# `Future`. I would rather have the processes "consume" work from a common well and return their results when the work is done.
+	workers: int = min(processesMaximum, n - 1)
+	with ProcessPoolExecutor(max_workers=workers) as processPool:
+		listFutures: list[Future[int]] = []
+		for index in range(len(listLeavesTruncated)):
+			permutands: list[int] = listLeavesTruncated.copy()
+			fixedLeaves: list[int] = [1, permutands.pop(index)]
+			listFutures.append(processPool.submit(count, fixedLeaves, permutands))
+		for futureCount in listFutures:
+			validTotal += futureCount.result()
+	return validTotal * n

mapFolding/algorithms/matrixMeanders.py

@@ -1,6 +1,44 @@
-from mapFolding.algorithms.matrixMeandersBeDry import walkDyckPath
+from functools import cache
 from mapFolding.dataBaskets import MatrixMeandersState
 
+@cache
+def walkDyckPath(intWithExtra_0b1: int) -> int:
+    """Find the bit position for flipping paired curve endpoints in meander transfer matrices.
+
+    Parameters
+    ----------
+    intWithExtra_0b1 : int
+        Binary representation of curve locations with an extra bit encoding parity information.
+
+    Returns
+    -------
+    flipExtra_0b1_Here : int
+        Bit mask indicating the position where the balance condition fails, formatted as 2^(2k).
+
+    3L33T H@X0R
+    ------------
+    Binary search for first negative balance in shifted bit pairs. Returns 2^(2k) mask for
+    bit position k where cumulative balance counter transitions from non-negative to negative.
+
+    Mathematics
+    -----------
+    Implements the Dyck path balance verification algorithm from Jensen's transfer matrix
+    enumeration. Computes the position where ∑(i=0 to k) (-1)^b_i < 0 for the first time,
+    where b_i are the bits of the input at positions 2i.
+
+    """
+    findTheExtra_0b1: int = 0
+    flipExtra_0b1_Here: int = 1
+    while True:
+        flipExtra_0b1_Here <<= 2
+        if intWithExtra_0b1 & flipExtra_0b1_Here == 0:
+            findTheExtra_0b1 += 1
+        else:
+            findTheExtra_0b1 -= 1
+        if findTheExtra_0b1 < 0:
+            break
+    return flipExtra_0b1_Here
+
 def count(state: MatrixMeandersState) -> MatrixMeandersState:
     """Count meanders with matrix transfer algorithm using Python `int` (*int*eger) contained in a Python `dict` (*dict*ionary).
 
@@ -11,52 +49,53 @@ def count(state: MatrixMeandersState) -> MatrixMeandersState:
 
     Notes
     -----
-    The matrix transfer algorithm is sophisticated, but this implementation is straightforward: compute each index one at a time,
-    compute each `arcCode` one at a time, and compute each type of analysis one at a time.
+    The matrix transfer algorithm is sophisticated, but this implementation is straightforward: compute each `boundary` one at a
+    time, compute each `arcCode` one at a time, and compute each type of analysis one at a time.
     """
     dictionaryArcCodeToCrossings: dict[int, int] = {}
 
     while state.boundary > 0:
-        state.boundary -= 1
-        state.bitWidth = max(state.dictionaryMeanders.keys()).bit_length()
+        state.reduceBoundary()
 
         dictionaryArcCodeToCrossings = state.dictionaryMeanders.copy()
         state.dictionaryMeanders = {}
 
-        for arcCode, crossings in dictionaryArcCodeToCrossings.items():
-            bitsAlpha: int = arcCode & state.locatorBits
-            bitsZulu: int = (arcCode >> 1) & state.locatorBits
+        def analyzeArcCode(arcCode: int, crossings: int) -> None:
+            bitsAlpha: int = arcCode & state.bitsLocator
             bitsAlphaHasArcs: bool = bitsAlpha > 1
-            bitsZuluHasArcs: bool = bitsZulu > 1
             bitsAlphaIsEven: int = bitsAlpha & 1 ^ 1
+
+            bitsZulu: int = arcCode >> 1 & state.bitsLocator
+            bitsZuluHasArcs: bool = bitsZulu > 1
             bitsZuluIsEven: int = bitsZulu & 1 ^ 1
 
-            arcCodeAnalysis = ((bitsAlpha | (bitsZulu << 1)) << 2) | 3
-            # simple
+            arcCodeAnalysis: int = (bitsZulu << 1 | bitsAlpha) << 2 | 3  # Evaluate formula step-wise left to right: (parentheses) override precedence.
             if arcCodeAnalysis < state.MAXIMUMarcCode:
                 state.dictionaryMeanders[arcCodeAnalysis] = state.dictionaryMeanders.get(arcCodeAnalysis, 0) + crossings
 
             if bitsAlphaHasArcs:
-                arcCodeAnalysis = (bitsAlpha >> 2) | (bitsZulu << 3) | (bitsAlphaIsEven << 1)
+                arcCodeAnalysis = bitsAlphaIsEven << 1 | bitsAlpha >> 2 | bitsZulu << 3
                 if arcCodeAnalysis < state.MAXIMUMarcCode:
                     state.dictionaryMeanders[arcCodeAnalysis] = state.dictionaryMeanders.get(arcCodeAnalysis, 0) + crossings
 
             if bitsZuluHasArcs:
-                arcCodeAnalysis = (bitsZulu >> 1) | (bitsAlpha << 2) | bitsZuluIsEven
+                arcCodeAnalysis = bitsZuluIsEven | bitsAlpha << 2 | bitsZulu >> 1
                 if arcCodeAnalysis < state.MAXIMUMarcCode:
                     state.dictionaryMeanders[arcCodeAnalysis] = state.dictionaryMeanders.get(arcCodeAnalysis, 0) + crossings
 
             if bitsAlphaHasArcs and bitsZuluHasArcs and (bitsAlphaIsEven or bitsZuluIsEven):
-                # aligned
+                # NOTE This analysis might modify `bitsAlpha` or `bitsZulu`, so it should be last.
                 if bitsAlphaIsEven and not bitsZuluIsEven:
                     bitsAlpha ^= walkDyckPath(bitsAlpha)
                 elif bitsZuluIsEven and not bitsAlphaIsEven:
                     bitsZulu ^= walkDyckPath(bitsZulu)
 
-                arcCodeAnalysis: int = ((bitsZulu >> 2) << 1) | (bitsAlpha >> 2)
+                arcCodeAnalysis = (bitsZulu >> 2 << 3 | bitsAlpha) >> 2  # Evaluate formula step-wise left to right: (parentheses) override precedence.
                 if arcCodeAnalysis < state.MAXIMUMarcCode:
                     state.dictionaryMeanders[arcCodeAnalysis] = state.dictionaryMeanders.get(arcCodeAnalysis, 0) + crossings
 
+        set(map(analyzeArcCode, dictionaryArcCodeToCrossings.keys(), dictionaryArcCodeToCrossings.values()))
+
         dictionaryArcCodeToCrossings = {}
 
     return state
@@ -74,14 +113,16 @@ def doTheNeedful(state: MatrixMeandersState) -> int:
     crossings : int
         The computed value of `crossings`.
 
-    Notes
-    -----
-    Citation: https://github.com/hunterhogan/mapFolding/blob/main/citations/Jensen.bibtex
+    Citations
+    ---------
+    - https://github.com/hunterhogan/mapFolding/blob/main/citations/Jensen.bib
+    - https://github.com/hunterhogan/mapFolding/blob/main/citations/Howroyd.bib
 
     See Also
     --------
     https://oeis.org/A000682
     https://oeis.org/A005316
+    https://github.com/archmageirvine/joeis/blob/5dc2148344bff42182e2128a6c99df78044558c5/src/irvine/oeis/a005/A005316.java
     """
     state = count(state)