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

mapFolding/oeis.py

@@ -26,147 +26,58 @@ completes the journey from configuration foundation to mathematical discovery.
 
 from collections.abc import Callable
 from datetime import datetime, timedelta, UTC
-from functools import cache
 from hunterMakesPy import writeStringToHere
-from mapFolding import countFolds, packageSettings
+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 urllib.request import urlopen
 import argparse
-import random
 import sys
 import time
 import warnings
 
-cacheDays = 30
-"""Number of days to retain cached OEIS data before refreshing from the online source."""
-
-pathCache: Path = packageSettings.pathPackage / ".cache"
-"""Local directory path for storing cached OEIS sequence data and metadata."""
-
-class SettingsOEIS(TypedDict):
-	"""Complete configuration settings for a single OEIS sequence implementation.
-
-	(AI generated docstring)
-
-	This `TypedDict` defines the structure for storing all metadata, known values, and operational parameters
-	needed to work with an OEIS sequence within the map folding context.
-
-	"""
+class MetadataOEISid(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."""
 
-class SettingsOEIShardcodedValues(TypedDict):
-	"""Hardcoded configuration values for OEIS sequences defined within the module.
-
-	(AI generated docstring)
-
-	This `TypedDict` contains the static configuration data that is embedded in the source code
-	rather than retrieved from external sources.
-
-	"""
-
-	getMapShape: Callable[[int], tuple[int, ...]]
-	valuesBenchmark: list[int]
-	valuesTestParallelization: list[int]
-	valuesTestValidation: list[int]
-
-settingsOEIShardcodedValues: dict[str, SettingsOEIShardcodedValues] = {
-	'A000136': {
-		'getMapShape': lambda n: tuple(sorted([1, n])),
-		'valuesBenchmark': [14],
-		'valuesTestParallelization': [*range(3, 7)],
-		'valuesTestValidation': [random.randint(2, 9)],  # noqa: S311
-	},
-	'A001415': {
-		'getMapShape': lambda n: tuple(sorted([2, n])),
-		'valuesBenchmark': [14],
-		'valuesTestParallelization': [*range(3, 7)],
-		'valuesTestValidation': [random.randint(2, 9)],  # noqa: S311
-	},
-	'A001416': {
-		'getMapShape': lambda n: tuple(sorted([3, n])),
-		'valuesBenchmark': [9],
-		'valuesTestParallelization': [*range(3, 5)],
-		'valuesTestValidation': [random.randint(2, 6)],  # noqa: S311
-	},
-	'A001417': {
-		'getMapShape': lambda n: tuple(2 for _dimension in range(n)),
-		'valuesBenchmark': [6],
-		'valuesTestParallelization': [*range(2, 4)],
-		'valuesTestValidation': [random.randint(2, 4)],  # noqa: S311
-	},
-	'A195646': {
-		'getMapShape': lambda n: tuple(3 for _dimension in range(n)),
-		'valuesBenchmark': [3],
-		'valuesTestParallelization': [*range(2, 3)],
-		'valuesTestValidation': [2],
-	},
-	'A001418': {
-		'getMapShape': lambda n: (n, n),
-		'valuesBenchmark': [5],
-		'valuesTestParallelization': [*range(2, 4)],
-		'valuesTestValidation': [random.randint(2, 4)],  # noqa: S311
-	},
-}
-"""
-Registry of hardcoded OEIS sequence configurations implemented in this module.
-
-Each key is a standardized OEIS sequence identifier (e.g., 'A001415'), and each value contains
-the static configuration needed to work with that sequence, including the mapping function from
-sequence index to map shape and various test parameter sets.
-"""
-
-oeisIDsImplemented: Final[list[str]]  = sorted([oeisID.upper().strip() for oeisID in settingsOEIShardcodedValues])
+oeisIDsImplemented: Final[list[str]]  = sorted([oeisID.upper().strip() for oeisID in settingsOEISManuallySelected])
 """Directly implemented OEIS IDs; standardized, e.g., 'A001415'."""
 
-def validateOEISid(oeisIDcandidate: str) -> str:
-	"""Validate an OEIS sequence ID against implemented sequences.
-
-	(AI generated docstring)
-
-	If the provided ID is recognized within the application's implemented OEIS sequences, the function returns the
-	verified ID in uppercase. Otherwise, a KeyError is raised indicating that the sequence is not directly supported.
+def _standardizeOEISid(oeisID: str) -> str:
+	"""Standardize an OEIS sequence ID to uppercase and without whitespace.
 
 	Parameters
 	----------
-	oeisIDcandidate : str
-		The OEIS sequence identifier to validate.
+	oeisID : str
+		The OEIS sequence identifier to standardize.
 
 	Returns
 	-------
-	str
-		The validated and possibly modified OEIS sequence ID, if recognized.
-
-	Raises
-	------
-	KeyError
-		If the provided sequence ID is not directly implemented.
+	oeisIDstandardized : str
+		Uppercase, alphanumeric OEIS ID.
 
 	"""
-	if oeisIDcandidate in oeisIDsImplemented:
-		return oeisIDcandidate
-	else:
-		oeisIDcleaned: str = str(oeisIDcandidate).upper().strip()
-		if oeisIDcleaned in oeisIDsImplemented:
-			return oeisIDcleaned
-		else:
-			message = (
-				f"OEIS ID {oeisIDcandidate} is not directly implemented.\n"
-				f"Available sequences:\n{_formatOEISsequenceInfo()}"
-			)
-			raise KeyError(
-				message
-			)
-
-def getFilenameOEISbFile(oeisID: str) -> str:
+	return str(oeisID).upper().strip()
+
+def _getFilenameOEISbFile(oeisID: str) -> str:
 	"""Generate the filename for an OEIS b-file given a sequence ID.
 
 	(AI generated docstring)
@@ -185,7 +96,7 @@ def getFilenameOEISbFile(oeisID: str) -> str:
 		The corresponding b-file filename for the given sequence ID.
 
 	"""
-	oeisID = validateOEISid(oeisID)
+	oeisID = _standardizeOEISid(oeisID)
 	return f"b{oeisID[1:]}.txt"
 
 def _parseBFileOEIS(OEISbFile: str) -> dict[int, int]:
@@ -222,7 +133,7 @@ def _parseBFileOEIS(OEISbFile: str) -> dict[int, int]:
 		OEISsequence[n] = aOFn
 	return OEISsequence
 
-def getOEISofficial(pathFilenameCache: Path, url: str) -> None | str:
+def _getOEISofficial(pathFilenameCache: Path, url: str) -> None | str:
 	"""Retrieve OEIS sequence data from cache or online source with intelligent caching.
 
 	(AI generated docstring)
@@ -263,7 +174,8 @@ def getOEISofficial(pathFilenameCache: Path, url: str) -> None | str:
 
 	if not tryCache:
 		if not url.startswith(("http:", "https:")):
-			raise ValueError("URL must start with 'http:' or 'https:'")
+			message = "URL must start with 'http:' or 'https:'"
+			raise ValueError(message)
 		with urlopen(url) as response:
 			oeisInformationRaw = response.read().decode('utf-8')
 		oeisInformation = str(oeisInformationRaw)
@@ -302,10 +214,10 @@ def getOEISidValues(oeisID: str) -> dict[int, int]:
 		If there is an error reading from or writing to the local cache.
 
 	"""
-	pathFilenameCache: Path = pathCache / getFilenameOEISbFile(oeisID)
-	url: str = f"https://oeis.org/{oeisID}/{getFilenameOEISbFile(oeisID)}"
+	pathFilenameCache: Path = pathCache / _getFilenameOEISbFile(oeisID)
+	url: str = f"https://oeis.org/{oeisID}/{_getFilenameOEISbFile(oeisID)}"
 
-	oeisInformation: None | str = getOEISofficial(pathFilenameCache, url)
+	oeisInformation: None | str = _getOEISofficial(pathFilenameCache, url)
 
 	if oeisInformation:
 		return _parseBFileOEIS(oeisInformation)
@@ -338,11 +250,11 @@ def getOEISidInformation(oeisID: str) -> tuple[str, int]:
 	be retrieved, warning messages are issued and fallback values are returned.
 
 	"""
-	oeisID = validateOEISid(oeisID)
+	oeisID = _standardizeOEISid(oeisID)
 	pathFilenameCache: Path = pathCache / f"{oeisID}.txt"
 	url: str = f"https://oeis.org/search?q=id:{oeisID}&fmt=text"
 
-	oeisInformation: None | str = getOEISofficial(pathFilenameCache, url)
+	oeisInformation: None | str = _getOEISofficial(pathFilenameCache, url)
 
 	if not oeisInformation:
 		return "Not found", -1
@@ -350,7 +262,7 @@ def getOEISidInformation(oeisID: str) -> tuple[str, int]:
 	offset = None
 	for lineOEIS in oeisInformation.splitlines():
 		lineOEIS = lineOEIS.strip()  # noqa: PLW2901
-		if not lineOEIS or len(lineOEIS.split()) < 3:  # noqa: PLR2004
+		if not lineOEIS or len(lineOEIS.split()) < 3:
 			continue
 		fieldCode, sequenceID, fieldData = lineOEIS.split(maxsplit=2)
 		if fieldCode == '%N' and sequenceID == oeisID:
@@ -367,7 +279,7 @@ def getOEISidInformation(oeisID: str) -> tuple[str, int]:
 	description: str = ' '.join(listDescriptionDeconstructed)
 	return description, offset
 
-def makeSettingsOEIS() -> dict[str, SettingsOEIS]:
+def _makeDictionaryOEIS() -> dict[str, MetadataOEISid]:
 	"""Construct the comprehensive settings dictionary for all implemented OEIS sequences.
 
 	(AI generated docstring)
@@ -390,60 +302,37 @@ def makeSettingsOEIS() -> dict[str, SettingsOEIS]:
 		objects, containing all metadata and known values needed for computation and validation.
 
 	"""
-	settingsTarget: dict[str, SettingsOEIS] = {}
+	dictionaryOEIS: dict[str, MetadataOEISid] = {}
 	for oeisID in oeisIDsImplemented:
 		valuesKnownSherpa: dict[int, int] = getOEISidValues(oeisID)
 		descriptionSherpa, offsetSherpa = getOEISidInformation(oeisID)
-		settingsTarget[oeisID] = SettingsOEIS(
+		dictionaryOEIS[oeisID] = MetadataOEISid(
 			description=descriptionSherpa,
 			offset=offsetSherpa,
-			getMapShape=settingsOEIShardcodedValues[oeisID]['getMapShape'],
-			valuesBenchmark=settingsOEIShardcodedValues[oeisID]['valuesBenchmark'],
-			valuesTestParallelization=settingsOEIShardcodedValues[oeisID]['valuesTestParallelization'],
-			valuesTestValidation=settingsOEIShardcodedValues[oeisID]['valuesTestValidation'] + list(range(offsetSherpa, 2)),
+			getMapShape=settingsOEISManuallySelected[oeisID]['getMapShape'],
+			valuesBenchmark=settingsOEISManuallySelected[oeisID]['valuesBenchmark'],
+			valuesTestParallelization=settingsOEISManuallySelected[oeisID]['valuesTestParallelization'],
+			valuesTestValidation=settingsOEISManuallySelected[oeisID]['valuesTestValidation'] + list(range(offsetSherpa, 2)),
 			valuesKnown=valuesKnownSherpa,
 			valueUnknown=max(valuesKnownSherpa.keys(), default=0) + 1
 		)
-	return settingsTarget
+	return dictionaryOEIS
 
-settingsOEIS: dict[str, SettingsOEIS] = makeSettingsOEIS()
-"""
-Complete settings and metadata for all implemented OEIS sequences.
-
-This dictionary contains the comprehensive configuration for each OEIS sequence supported by the module,
-including known values retrieved from OEIS, mathematical descriptions, offset information, and all
-operational parameters needed for computation and testing. The dictionary is populated by combining
-hardcoded configurations with dynamically retrieved OEIS data during module initialization.
-"""
+dictionaryOEIS: dict[str, MetadataOEISid] = _makeDictionaryOEIS()
+"""Metadata for each OEIS sequence ID."""
 
-@cache
 def makeDictionaryFoldsTotalKnown() -> dict[tuple[int, ...], int]:
-	"""Create a cached lookup dictionary mapping map shapes to their known folding totals.
-
-	(AI generated docstring)
-
-	This function processes all known sequence values from implemented OEIS sequences and creates
-	a unified dictionary that maps map dimension tuples to their corresponding folding totals. The
-	resulting dictionary enables rapid lookup of known values without requiring knowledge of which
-	specific OEIS sequence contains the data.
+	"""Make a `mapShape` to known `foldsTotal` dictionary.
 
 	Returns
 	-------
-	dictionaryMapDimensionsToFoldsTotalKnown : dict[tuple[int, ...], int]
+	dictionaryFoldsTotalKnown : dict[tuple[int, ...], int]
 		A dictionary where keys are tuples representing map shapes and values are the total number
 		of distinct folding patterns for those shapes.
 
 	"""
-	dictionaryMapDimensionsToFoldsTotalKnown: dict[tuple[int, ...], int] = {}
-
-	for settings in settingsOEIS.values():
-		sequence = settings['valuesKnown']
-
-		for n, foldingsTotal in sequence.items():
-			mapShape = settings['getMapShape'](n)
-			mapShape = tuple(mapShape)
-			dictionaryMapDimensionsToFoldsTotalKnown[mapShape] = foldingsTotal
-	return dictionaryMapDimensionsToFoldsTotalKnown
+	return dict(chain.from_iterable(zip(map(oeisID['getMapShape'], oeisID['valuesKnown'].keys())
+	, oeisID['valuesKnown'].values(), strict=True) for oeisID in dictionaryOEIS.values()))
 
 def getFoldsTotalKnown(mapShape: tuple[int, ...]) -> int:
 	"""Retrieve the known total number of distinct folding patterns for a given map shape.
@@ -489,7 +378,7 @@ def _formatHelpText() -> str:
 
 	"""
 	exampleOEISid: str = oeisIDsImplemented[0]
-	exampleN: int = settingsOEIS[exampleOEISid]['valuesTestValidation'][-1]
+	exampleN: int = dictionaryOEIS[exampleOEISid]['valuesTestValidation'][-1]
 
 	return (
 		"\nAvailable OEIS sequences:\n"
@@ -517,7 +406,7 @@ def _formatOEISsequenceInfo() -> str:
 
 	"""
 	return "\n".join(
-		f"  {oeisID}: {settingsOEIS[oeisID]['description']}"
+		f"  {oeisID}: {dictionaryOEIS[oeisID]['description']}"
 		for oeisID in oeisIDsImplemented
 	)
 
@@ -553,20 +442,20 @@ def oeisIDfor_n(oeisID: str, n: int | Any) -> int:
 		If n is below the sequence's defined offset.
 
 	"""
-	oeisID = validateOEISid(oeisID)
+	oeisID = _standardizeOEISid(oeisID)
 
 	if not isinstance(n, int) or n < 0:
 		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, ...] = settingsOEIS[oeisID]['getMapShape'](n)
+	mapShape: tuple[int, ...] = dictionaryOEIS[oeisID]['getMapShape'](n)
 
-	if n <= 1 or len(mapShape) < 2:  # noqa: PLR2004
-		offset: int = settingsOEIS[oeisID]['offset']
+	if n <= 1 or len(mapShape) < 2:
+		offset: int = dictionaryOEIS[oeisID]['offset']
 		if n < offset:
 			message = f"OEIS sequence {oeisID} is not defined at {n = }."
 			raise ArithmeticError(message)
-		foldsTotal: int = settingsOEIS[oeisID]['valuesKnown'][n]
+		foldsTotal: int = dictionaryOEIS[oeisID]['valuesKnown'][n]
 		return foldsTotal
 	return countFolds(mapShape)
 
@@ -630,9 +519,9 @@ def clearOEIScache() -> None:
 	if not pathCache.exists():
 		print(f"Cache directory, {pathCache}, not found - nothing to clear.")  # noqa: T201
 		return
-	for oeisID in settingsOEIS:
+	for oeisID in dictionaryOEIS:
 		( pathCache / f"{oeisID}.txt" ).unlink(missing_ok=True)
-		( pathCache / getFilenameOEISbFile(oeisID) ).unlink(missing_ok=True)
+		( pathCache / _getFilenameOEISbFile(oeisID) ).unlink(missing_ok=True)
 	print(f"Cache cleared from {pathCache}")  # noqa: T201
 
 def getOEISids() -> None:

mapFolding/reference/A005316JavaPort.py

@@ -0,0 +1,134 @@
+from collections.abc import Iterable
+from hunterMakesPy import raiseIfNone
+from typing import Final
+
+# Constants for bit manipulation
+WORD_SHIFT: Final[int] = 2
+ODD_BITS: Final[int] = 0x5555555555555555
+
+class BasicMeanderProblem:
+	"""Processing component to determine number of meanders."""
+
+	def __init__(self, remainingBridges: int) -> None:
+		self.remainingBridges = remainingBridges
+		self.archStateLimit = 1 << (2 + (WORD_SHIFT * (remainingBridges + 1)))
+		self.bridgesTotalIsOdd = (remainingBridges & 1) == 1
+
+	def initialStates(self) -> list[int]:
+		"""Initialize states to enumerate open meanders (A005316)."""
+		if self.bridgesTotalIsOdd:
+			bitPattern = (1 << WORD_SHIFT) | 1
+			bitPattern <<= WORD_SHIFT
+			return [bitPattern | 1 << 1]
+		else:
+			bitPattern = (1 << WORD_SHIFT) | 1
+			return [bitPattern | bitPattern << 1]
+
+	def semiMeanderInitialStates(self) -> list[int]:
+		"""Initialize states used to enumerate semi-meanders (A000682)."""
+		initialStatesList: list[int] = []
+		bitPattern = 1 if self.bridgesTotalIsOdd else ((1 << WORD_SHIFT) | 1)
+
+		packedState = bitPattern | bitPattern << 1
+		while packedState < self.archStateLimit:
+			initialStatesList.append(packedState)
+			bitPattern = ((bitPattern << WORD_SHIFT) | 1) << WORD_SHIFT | 1
+			packedState = bitPattern | bitPattern << 1
+
+		return initialStatesList
+
+	def enumerate(self, packedState: int) -> list[int]:  # noqa: C901
+		"""Enumerate next states from previous state."""
+		bitMask = ODD_BITS
+		bitWidth = 64
+		while bitMask < packedState:
+			bitMask |= bitMask << bitWidth
+			bitWidth += bitWidth
+		lower: int = packedState & bitMask
+		upper: int = (packedState - lower) >> 1
+		nextStatesList: list[int] = []
+
+		# Leg crosses from below road to above road
+		if lower != 1:
+			nextState: int = (lower >> WORD_SHIFT | (((upper << WORD_SHIFT) ^ (1 if (lower & 1) == 0 else 0)) << 1))
+			if nextState < self.archStateLimit:
+				nextStatesList.append(nextState)
+
+		# Leg crosses from above road to below road
+		if upper != 1:
+			nextState = (((lower << WORD_SHIFT) ^ (1 if (upper & 1) == 0 else 0)) | (upper >> WORD_SHIFT) << 1)
+			if nextState < self.archStateLimit:
+				nextStatesList.append(nextState)
+
+		# Introduction of new arch
+		nextState = ((lower << WORD_SHIFT) | 1 | ((upper << WORD_SHIFT) | 1) << 1)
+		if nextState < self.archStateLimit:
+			nextStatesList.append(nextState)
+
+		# Arch connection, only for JOIN_ARCH, not CLOSE_LOOP for semi-meanders
+		if lower != 1 and upper != 1 and ((lower & 1) == 0 or (upper & 1) == 0):  # JOIN_ARCH condition
+			if (lower & 1) == 0 and (upper & 1) == 1:
+				archBalance = 0
+				bitPosition = 1
+				while archBalance >= 0:
+					bitPosition <<= WORD_SHIFT
+					archBalance += 1 if (lower & bitPosition) == 0 else -1
+				lower ^= bitPosition
+			if (upper & 1) == 0 and (lower & 1) == 1:
+				archBalance = 0
+				bitPosition = 1
+				while archBalance >= 0:
+					bitPosition <<= WORD_SHIFT
+					archBalance += 1 if (upper & bitPosition) == 0 else -1
+				upper ^= bitPosition
+			nextState = (lower >> WORD_SHIFT | (upper >> WORD_SHIFT) << 1)
+			if nextState < self.archStateLimit:
+				nextStatesList.append(nextState)
+
+		return nextStatesList
+
+class SimpleProcessor:
+	"""Simple processing engine for state enumeration."""
+
+	def __init__(self) -> None:
+		self.createStateMachine: type | None = None
+		self.totalTransitions = 0
+
+	def setCreateStateMachine(self, stateMachineCreator: type) -> None:
+		"""Set state creation machine."""
+		self.createStateMachine = stateMachineCreator
+
+	def process(self, bridgesCount: int, initialStates: Iterable[int]) -> int:
+		"""Process initial states down to final count."""
+		stateCounts: list[tuple[int, int]] = [(state, 1) for state in initialStates]
+
+		self.createStateMachine = raiseIfNone(self.createStateMachine, "State machine creator must be set before processing.")
+		bridgesRemaining: int = bridgesCount
+		while bridgesRemaining > 0:
+			bridgesRemaining -= 1
+			stateCounts = self._accumulate(self.createStateMachine(bridgesRemaining), stateCounts)
+
+		return sum(count for state, count in stateCounts)
+
+	def _accumulate(self, layer: BasicMeanderProblem, previousCounts: list[tuple[int, int]]) -> list[tuple[int, int]]:
+		"""Accumulate state transitions for one layer."""
+		stateCountsDict: dict[int, int] = {}
+		transitions: int = 0
+
+		for state, count in previousCounts:
+			for nextState in layer.enumerate(state):
+				if nextState in stateCountsDict:
+					stateCountsDict[nextState] += count
+				else:
+					stateCountsDict[nextState] = count
+				transitions += 1
+
+		self.totalTransitions += transitions
+		return list(stateCountsDict.items())
+
+def A005316(n: int) -> int:
+	"""Meandric numbers: number of ways a river can cross a road n times."""
+	processor = SimpleProcessor()
+	processor.setCreateStateMachine(BasicMeanderProblem)
+	meanderProblem = BasicMeanderProblem(n)
+	return processor.process(n, meanderProblem.initialStates())

mapFolding/reference/A005316imperative.py

@@ -0,0 +1,101 @@
+def count(bridges: int, dictionaryStateToTotal: dict[int, int]) -> int:  # noqa: C901, PLR0912
+    while bridges > 0:
+        bridges -= 1
+        archStateLimit = 1 << (2 + (2 * (bridges + 1)))
+
+        dictionaryStateToTotalNext: dict[int, int] = {}
+
+        for state, totalCurrent in dictionaryStateToTotal.items():
+            maskBits = 0x5555555555555555
+            if state > maskBits:
+                bitWidth = 64
+                while maskBits < state:
+                    maskBits |= maskBits << bitWidth
+                    bitWidth <<= 1
+
+            lower = state & maskBits
+            upper = (state ^ lower) >> 1
+
+            listNextStates: list[int] = []
+
+            lower_not_one = lower != 1
+            upper_not_one = upper != 1
+            lower_even = (lower & 1) == 0
+            upper_even = (upper & 1) == 0
+
+            if lower_not_one:
+                nextState = (lower >> 2) | (((upper << 2) ^ (1 if lower_even else 0)) << 1)
+                if nextState < archStateLimit:
+                    listNextStates.append(nextState)
+
+            if upper_not_one:
+                nextState = ((lower << 2) ^ (1 if upper_even else 0)) | ((upper >> 2) << 1)
+                if nextState < archStateLimit:
+                    listNextStates.append(nextState)
+
+            nextState = ((lower << 2) | 1) | (((upper << 2) | 1) << 1)
+            if nextState < archStateLimit:
+                listNextStates.append(nextState)
+
+            if lower_not_one and upper_not_one and (lower_even or upper_even):
+                temp_lower, temp_upper = lower, upper
+
+                if lower_even and not upper_even:
+                    archBalance = 0
+                    bitPosition = 1
+                    while archBalance >= 0:
+                        bitPosition <<= 2
+                        archBalance += 1 if (temp_lower & bitPosition) == 0 else -1
+                    temp_lower ^= bitPosition
+
+                if upper_even and not lower_even:
+                    archBalance = 0
+                    bitPosition = 1
+                    while archBalance >= 0:
+                        bitPosition <<= 2
+                        archBalance += 1 if (temp_upper & bitPosition) == 0 else -1
+                    temp_upper ^= bitPosition
+
+                nextState = (temp_lower >> 2) | ((temp_upper >> 2) << 1)
+                if nextState < archStateLimit:
+                    listNextStates.append(nextState)
+
+            for nextState in listNextStates:
+                dictionaryStateToTotalNext[nextState] = dictionaryStateToTotalNext.get(nextState, 0) + totalCurrent
+
+        dictionaryStateToTotal = dictionaryStateToTotalNext
+
+    return sum(dictionaryStateToTotal.values())
+
+def initializeA005316(remainingBridges: int) -> dict[int, int]:
+	bridgesTotalIsOdd = (remainingBridges & 1) == 1
+	if bridgesTotalIsOdd:
+		arrayBitPattern = (1 << 2) | 1
+		arrayBitPattern <<= 2
+		initialState = arrayBitPattern | 1 << 1
+		return {initialState: 1}
+	else:
+		arrayBitPattern = (1 << 2) | 1
+		initialState = arrayBitPattern | arrayBitPattern << 1
+		return {initialState: 1}
+
+def initializeA000682(remainingBridges: int) -> dict[int, int]:
+	bridgesTotalIsOdd = (remainingBridges & 1) == 1
+	archStateLimit = 1 << (2 + (2 * (remainingBridges + 1)))
+
+	dictionaryStateToTotal: dict[int, int] = {}
+	arrayBitPattern = 1 if bridgesTotalIsOdd else ((1 << 2) | 1)
+
+	arrayPackedState = arrayBitPattern | arrayBitPattern << 1
+	while arrayPackedState < archStateLimit:
+		dictionaryStateToTotal[arrayPackedState] = 1
+		arrayBitPattern = ((arrayBitPattern << 2) | 1) << 2 | 1
+		arrayPackedState = arrayBitPattern | arrayBitPattern << 1
+
+	return dictionaryStateToTotal
+
+def A005316(n: int) -> int:
+	return count(n, initializeA005316(n))
+
+def A000682(n: int) -> int:
+	return count(n - 1, initializeA000682(n - 1))