mapFolding 0.15.2__py3-none-any.whl → 0.15.4__py3-none-any.whl

mapFolding/algorithms/oeisIDbyFormula.py

@@ -0,0 +1,113 @@
+from functools import cache
+from mapFolding import countFolds
+from mapFolding.algorithms.matrixMeanders import doTheNeedful
+
+@cache
+def A000136(n: int) -> int:
+	return n * A000682(n)
+
+def A000560(n: int) -> int:
+	return A000682(n + 1) // 2
+
+def A000682getCurveLocations(n: int) -> dict[int, int]:
+	curveLocationsMAXIMUM: int = 1 << (2 * n + 4)
+
+	curveStart: int = 5 - (n & 0b1) * 4
+	listCurveLocations: list[int] = [(curveStart << 1) | curveStart]
+
+	while listCurveLocations[-1] < curveLocationsMAXIMUM:
+		curveStart = (curveStart << 4) | 0b101
+		listCurveLocations.append((curveStart << 1) | curveStart)
+
+	return dict.fromkeys(listCurveLocations, 1)
+
+@cache
+def A000682(n: int) -> int:
+	return doTheNeedful(n - 1, A000682getCurveLocations(n - 1))
+
+def A001010(n: int) -> int:
+	"""Formulas.
+
+	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 == 1:
+		foldsTotal = 1
+	elif n & 0b1:
+		foldsTotal = 2 * countFolds(oeisID='A007822', oeis_n=(n - 1)//2 + 1, flow='theorem2Numba')
+	else:
+		foldsTotal = 2 * A000682(n // 2 + 1)
+	return foldsTotal
+
+def A001011(n: int) -> int:
+	if n == 0:
+		foldsTotal = 1
+	else:
+		foldsTotal = (A001010(n) + A000136(n)) // 4
+	return foldsTotal
+
+def A005316getCurveLocations(n: int) -> dict[int, int]:
+	if n & 0b1:
+		return {22: 1}
+	else:
+		return {15: 1}
+
+@cache
+def A005316(n: int) -> int:
+	return doTheNeedful(n-1, A005316getCurveLocations(n-1))
+
+@cache
+def A005315(n: int) -> int:
+	if n == 1:
+		foldsTotal = 1
+	else:
+		foldsTotal = A005316(2 * n - 1)
+	return foldsTotal
+
+def A060206(n: int) -> int:
+	return A000682(2 * n + 1)
+
+def A077460(n: int) -> int:
+	"""Formulas.
+
+	a[0] = a[1] = 1;
+	a[n_] := If[OddQ[n], (A005316[[n + 1]] + A005316[[2n]] + A000682[[n]])/4
+	a(2n+1) = (A005315(2n+1) + A005316(2n+1) + A060206(n)) / 4.
+
+	a(2n) = (A005315(2n) + 2 * A005316(2n)) / 4.
+	(A005316[[2n]] + 2 A005316[[n + 1]])/4];
+
+	"""
+	if n in {0, 1}:
+		foldsTotal = 1
+	elif n & 0b1:
+		foldsTotal = (A005315(n) + A005316(n) + A060206((n - 1) // 2)) // 4
+	else:
+		foldsTotal = (A005315(n) + 2 * A005316(n)) // 4
+
+	return foldsTotal
+
+def A078591(n: int) -> int:
+	return A005315(n) // 2
+
+def A178961(n: int) -> int:
+	from mapFolding.oeis import dictionaryOEISMeanders  # noqa: PLC0415
+	A001010valuesKnown: dict[int, int] = dictionaryOEISMeanders['A001010']['valuesKnown']
+	foldsTotal: int = 0
+	for n下i in range(1, n+1):
+		foldsTotal += A001010valuesKnown[n下i]
+	return foldsTotal
+
+def A223094(n: int) -> int:
+	return A000136(n) - A000682(n + 1)
+# TODO A223094 For n >= 3: a(n) = n! - Sum_{k=3..n-1} (a(k)*n!/k!) - A000682(n+1). - _Roger Ford_, Aug 24 2024
+
+def A259702(n: int) -> int:
+	return A000682(n) // 2 - A000682(n - 1)
+
+def A301620(n: int) -> int:
+	return A000682(n + 2) - 2 * A000682(n + 1)
+# TODO A301620 a(n) = Sum_{k=3..floor((n+3)/2)} (A259689(n+1,k)*(k-2)). - _Roger Ford_, Dec 10 2018

mapFolding/basecamp.py

@@ -1,27 +1,4 @@
-"""
-Unified interface for map folding computation orchestration.
-
-(AI generated docstring)
-
-This module represents the culmination of the computational ecosystem, providing
-the primary entry point where users interact with the complete map folding analysis
-system. It orchestrates all preceding layers: the configuration foundation,
-type system, core utilities, state management, and persistent storage to deliver
-a seamless computational experience.
-
-The interface handles multiple computation flows including sequential algorithms,
-experimental task division strategies, and various mathematical theorem implementations.
-It provides flexible parameter validation, computation method selection, task
-division management, processor utilization control, and automatic result persistence.
-Integration with OEIS sequences enables research validation and mathematical
-verification of computed results.
-
-Through this unified interface, researchers and practitioners can access the full
-power of Lunnon's algorithm implementation while the underlying computational
-complexity remains elegantly abstracted. The interface ensures that whether
-solving simple 2D problems or complex multi-dimensional challenges, users receive
-consistent, reliable, and efficiently computed folding pattern counts.
-"""
+"""Unified interface for map folding computation."""
 
 from collections.abc import Sequence
 from mapFolding import (
@@ -31,46 +8,118 @@ from os import PathLike
 from pathlib import PurePath
 import contextlib
 
+"""TODO new flow paradigm, incomplete
+
+algorithms directory
+	manually coded algorithms or formulas
+	countFolds will be a stable interface for multidimensional map folding, including synthetic modules
+		This has special treatment because people may want to call mapShape not defined in OEIS
+	countMeanders will be a stable interface for meanders
+		This has special treatment because people may want to call meanders not defined in OEIS
+	an enhanced version of oeisIDfor_n will be a stable interface for calling by ID and n
+
+General flow structure
+	doTheNeedful
+		specific to that version of that algorithm
+		abstracts the API for that algorithm, so that algorithm (such as multidimensional map folding) has a stable interface
+		The last place to do defensive programming
+
+- Incomplete: how to count
+	- currently in parameters computationDivisions, CPUlimit, and flow
+
+- Flow in count______
+	- DEFENSIVE PROGRAMMING
+	- FAIL EARLY
+	- Implement "common foundational logic".
+		- IDK what the correct technical term is, but I'm sure other people have researched excellent ways to do this.
+		- Example: in `countFolds`, every possible flow path needs `mapShape`. Therefore, `mapShape` is foundational logic that
+			all flow paths have in common: "common foundational logic".
+		- Example: in `countFolds`, some flow paths have more than one "task division" (i.e., the computation is divided into
+			multiple tasks), while other flow paths only have one task division. One reasonable perspective is that computing task
+			divisions is NOT "common foundational logic". My perspective for this example: to compute whether or not there are
+			task divisions and if so, how many task divisions is identical for all flow paths. Therefore, I handle computing task
+			divisions as "common foundational logic".
+		- Incomplete
+	- Initialize memorialization instructions, if asked
+	- MORE DEFENSIVE PROGRAMMING
+	- FAIL EARLIER THAN EARLY
+	- Incomplete
+	- DEFENSIVE PROGRAMMING ON BEHALF of downstream modules and functions
+	- FAIL SO EARLY IT IS BEFORE THE USER INSTALLS THE APP
+	- Incomplete
+	- REPEAT MANY OR ALL OF THE DEFENSIVE PROGRAMMING YOU HAVE ALREADY DONE
+
+	- Incomplete
+	- Pass control to the correct `doTheNeedful`
+	- I don't know how to "elegantly" pass control without putting `doTheNeedful` over `count______` in the stack, therefore,
+		control will come back here.
+	- DO NOT, for the love of puppies and cookies, DO NOT use defensive programming here. Defensive programming AFTER a
+		four-week-long computation is a tacit admission of incompetent programming.
+	- Follow memorialization instructions: which means pass control to a function will tenaciously follow the instructions.
+	- return "a(n)" (as OEIS calls it), such as foldsTotal
+
+"""
+
 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
-				, CPUlimit: int | float | bool | None = None  # noqa: FBT001
+				, CPUlimit: bool | float | int | None = None  # noqa: FBT001
 				, mapShape: tuple[int, ...] | None = None
 				, oeisID: str | None = None
 				, oeis_n: int | None = None
 				, flow: str | None = None
 				) -> int:
 	"""
-	Count the total number of possible foldings for a given map dimensions.
+	Count the total number of distinct ways to fold a map.
 
-	(AI generated docstring)
-
-	This function serves as the main public interface to the map folding algorithm, handling all parameter validation,
-	computation state management, and result persistence in a user-friendly way.
+	Mathematicians also describe this as folding a strip of stamps, and they usually call the total "number of distinct ways to
+	fold" a map the map's "foldings."
 
 	Parameters
 	----------
-	listDimensions
+	listDimensions : Sequence[int] | None = None
 		List of integers representing the dimensions of the map to be folded.
-	pathLikeWriteFoldsTotal: None
-		Path, filename, or pathFilename to write the total fold count to. If a directory is provided, creates a file
-		with a default name based on map dimensions.
-	computationDivisions: None
+	pathLikeWriteFoldsTotal : PathLike[str] | PurePath | None = None
+		A filename, a path of only directories, or a path with directories and a filename to which `countFolds` will write the
+		value of `foldsTotal`. If `pathLikeWriteFoldsTotal` is a path of only directories, `countFolds` creates a filename based
+		on the map dimensions.
+	computationDivisions : int | str | None = None
 		Whether and how to divide the computational work.
-		- `None`: no division of the computation into tasks; sets task divisions to 0.
-		- int: directly set the number of task divisions; cannot exceed the map's total leaves.
-		- `'maximum'`: divides into `leavesTotal`-many `taskDivisions`.
-		- `'cpu'`: limits the divisions to the number of available CPUs: i.e., `concurrencyLimit`.
-	CPUlimit: None
-		This is only relevant if there are `computationDivisions`: whether and how to limit the CPU usage.
+		- `None`: no division of the computation into tasks.
+		- `int`: into how many tasks `countFolds` will divide the computation. The values 0 or 1 are identical to `None`. It is
+		mathematically impossible to divide the computation into more tasks than the map's total leaves.
+		- 'maximum': divides the computation into `leavesTotal`-many tasks.
+		- 'cpu': divides the computation into the number of available CPUs.
+	CPUlimit : bool | float | int | None = None
+		If relevant, whether and how to limit the number of processors `countFolds` will use. `CPUlimit` is an irrelevant setting
+		unless the computation is divided into more than one task with the `computationDivisions` parameter.
 		- `False`, `None`, or `0`: No limits on processor usage; uses all available processors. All other values will
 		potentially limit processor usage.
 		- `True`: Yes, limit the processor usage; limits to 1 processor.
-		- Integer `>= 1`: Limits usage to the specified number of processors.
-		- Decimal value (`float`) between 0 and 1: Fraction of total processors to use.
-		- Decimal value (`float`) between -1 and 0: Fraction of processors to _not_ use.
-		- Integer `<= -1`: Subtract the absolute value from total processors.
+		- `int >= 1`: The maximum number of available processors to use.
+		- `0 < float < 1`: The maximum number of processors to use expressed as a fraction of available processors.
+		- `-1 < float < 0`: The number of processors to *not* use expressed as a fraction of available processors.
+		- `int <= -1`: The number of available processors to *not* use.
+		- If the value of `CPUlimit` is a `float` greater than 1 or less than -1, `countFolds` truncates the value to an `int`
+		with the same sign as the `float`.
+	mapShape : tuple[int, ...] | None = None
+		Tuple of integers representing the dimensions of the map to be folded. Mathematicians almost always use the term
+		"dimensions", such as in the seminal paper, "Multi-dimensional map-folding". Nevertheless, in contemporary Python
+		programming, in the context of these algorithms, the term "shape" makes it much easier to align the mathematics with the
+		syntax of the programming language.
+	oeisID : str | None = None
+		The On-Line Encyclopedia of Integer Sequences (OEIS) ID for which to compute a(n) for value of 'n' set in `oeis_n`.
+	oeis_n : int | None = None
+		The 'n' value for the `oeisID`.
+	flow : str | None = None
+		My stupid way of selecting the version of the algorithm to use in the computation. There are certainly better ways to do
+		this, but I have not yet solved this issue. As of 2025 Aug 14, these values will work:
+		- 'daoOfMapFolding'
+		- 'numba'
+		- 'theorem2'
+		- 'theorem2Numba'
+		- 'theorem2Trimmed'
 
 	Returns
 	-------
@@ -83,7 +132,7 @@ def countFolds(listDimensions: Sequence[int] | None = None
 	If you want to compute a large `foldsTotal`, dividing the computation into tasks is usually a bad idea. Dividing the
 	algorithm into tasks is inherently inefficient: efficient division into tasks means there would be no overlap in the
 	work performed by each task. When dividing this algorithm, the amount of overlap is between 50% and 90% by all
-	tasks: at least 50% of the work done by every task must be done by _all_ tasks. If you improve the computation time,
+	tasks: at least 50% of the work done by every task must be done by each task. If you improve the computation time,
 	it will only change by -10 to -50% depending on (at the very least) the ratio of the map dimensions and the number
 	of leaves. If an undivided computation would take 10 hours on your computer, for example, the computation will still
 	take at least 5 hours but you might reduce the time to 9 hours. Most of the time, however, you will increase the
@@ -96,9 +145,9 @@ def countFolds(listDimensions: Sequence[int] | None = None
 		pass
 	else:
 		if oeisID and oeis_n:
-			from mapFolding.oeis import dictionaryOEIS  # noqa: PLC0415
+			from mapFolding.oeis import dictionaryOEISMapFolding  # noqa: PLC0415
 			with contextlib.suppress(KeyError):
-				mapShape = dictionaryOEIS[oeisID]['getMapShape'](oeis_n)
+				mapShape = dictionaryOEISMapFolding[oeisID]['getMapShape'](oeis_n)
 		if not mapShape and listDimensions:
 			mapShape = validateListDimensions(listDimensions)
 
@@ -136,27 +185,16 @@ def countFolds(listDimensions: Sequence[int] | None = None
 
 	# A007822 flow control until I can figure out a good way ---------------------------------
 	if oeisID == 'A007822':
-		"""Temporary notes.
-
-		The REAL motivation for integrating into basecamp is to integrate into the test modules. No, wait: to stop having to work
-		around the test modules.
-
-		I put `if oeisID == 'A007822'` in the `elif flow ==` cascade, before the `flow` checks because I want to remove A007822
-		from those flow paths. It is fundamentally incompatible and it will cause `Exception` or incorrect computations.
+		"""To use A007822, oeisID is mandatory.
 
-		To use A007822, oeisID is mandatory.
-
-		Parameters:
-			listDimensions should work. mapShape should work. oeis_n should work. `pathLikeWriteFoldsTotal` should work!!! I
-			didn't think about that, and I like it.
+		`if oeisID == 'A007822'` precedes the `elif flow ==` cascade because A007822 is fundamentally incompatible with those flow
+		paths and it will cause `Exception` or incorrect computations.
 
 		Parallel version:
-			idk. The computation division logic will try to execute. As of 2025 Aug 6 at 7 PM, I haven't tried or thought about a
-			parallel version. TODO Watch out for errors.
-
-		`flow`:
-			It looks like I will need to make decisions tree just for A007822. That's probably not a big deal since all of the
-			possible routes are predictable.
+			idk. The computation division logic will try to execute. As of 2025 Aug 13 at 11 PM, I haven't tried or thought about
+			a parallel version. And I don't really care. Potential parallelism is certainly present in `filterAsymmetricFolds`.
+			But, if I want to implement that, I should almost certainly replace `filterAsymmetricFolds` with a non-blocking
+			function to which `count` can pass the necessary values to. TODO Watch out for errors.
 
 		"""
 		match flow:
@@ -210,7 +248,7 @@ def countFolds(listDimensions: Sequence[int] | None = None
 		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
 		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 
-		from mapFolding.daoOfMapFolding import doTheNeedful  # noqa: PLC0415
+		from mapFolding.algorithms.daoOfMapFolding import doTheNeedful  # noqa: PLC0415
 		mapFoldingState = doTheNeedful(mapFoldingState)
 		foldsTotal = mapFoldingState.foldsTotal
 

mapFolding/oeis.py

@@ -24,41 +24,20 @@ redundant computation, or extending mathematical knowledge, this integration
 completes the journey from configuration foundation to mathematical discovery.
 """
 
-from collections.abc import Callable
 from datetime import datetime, timedelta, UTC
 from hunterMakesPy import writeStringToHere
 from itertools import chain
-from mapFolding import countFolds
-from mapFolding._theSSOT import cacheDays, pathCache, settingsOEISManuallySelected
+from mapFolding import countFolds, MetadataOEISidMapFolding, MetadataOEISidMeanders, packageSettings
+from mapFolding._theSSOT import pathCache
 from pathlib import Path
-from typing import Final, TypedDict
+from typing import Final
 from urllib.request import urlopen
 import argparse
 import sys
 import time
 import warnings
 
-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."""
-
-oeisIDsImplemented: Final[list[str]]  = sorted([oeisID.upper().strip() for oeisID in settingsOEISManuallySelected])
+oeisIDsImplemented: Final[list[str]]  = sorted([oeisID.upper().strip() for oeisID in packageSettings.OEISidMapFoldingManuallySet])
 """Directly implemented OEIS IDs; standardized, e.g., 'A001415'."""
 
 def _standardizeOEISid(oeisID: str) -> str:
@@ -134,13 +113,7 @@ def _parseBFileOEIS(OEISbFile: str) -> dict[int, int]:
 	return OEISsequence
 
 def _getOEISofficial(pathFilenameCache: Path, url: str) -> None | str:
-	"""Retrieve OEIS sequence data from cache or online source with intelligent caching.
-
-	(AI generated docstring)
-
-	This function implements a caching strategy that prioritizes local cached data when it exists and
-	has not expired. Fresh data is retrieved from the OEIS website when the cache is stale or missing,
-	and the cache is updated for future use.
+	"""Retrieve OEIS ID data from oeis.org or local cache.
 
 	Parameters
 	----------
@@ -154,16 +127,11 @@ def _getOEISofficial(pathFilenameCache: Path, url: str) -> None | str:
 	oeisInformation : str | None
 		The retrieved OEIS sequence information as a string, or `None` if retrieval failed.
 
-	Notes
-	-----
-	Cache expiration is controlled by the module-level `cacheDays` variable. The function validates
-	URL schemes and issues warnings for failed retrievals.
-
 	"""
 	tryCache: bool = False
 	if pathFilenameCache.exists():
 		fileAge: timedelta = datetime.now(tz=UTC) - datetime.fromtimestamp(pathFilenameCache.stat().st_mtime, tz=UTC)
-		tryCache = fileAge < timedelta(days=cacheDays)
+		tryCache = fileAge < timedelta(days=packageSettings.cacheDays)
 
 	oeisInformation: str | None = None
 	if tryCache:
@@ -176,7 +144,8 @@ def _getOEISofficial(pathFilenameCache: Path, url: str) -> None | str:
 		if not url.startswith(("http:", "https:")):
 			message = "URL must start with 'http:' or 'https:'"
 			raise ValueError(message)
-		with urlopen(url) as response:
+
+		with urlopen(url) as response:  # noqa: S310
 			oeisInformationRaw = response.read().decode('utf-8')
 		oeisInformation = str(oeisInformationRaw)
 		writeStringToHere(oeisInformation, pathFilenameCache)
@@ -279,7 +248,7 @@ def getOEISidInformation(oeisID: str) -> tuple[str, int]:
 	description: str = ' '.join(listDescriptionDeconstructed)
 	return description, offset
 
-def _makeDictionaryOEIS() -> dict[str, MetadataOEISid]:
+def _makeDictionaryOEIS() -> dict[str, MetadataOEISidMapFolding]:
 	"""Construct the comprehensive settings dictionary for all implemented OEIS sequences.
 
 	(AI generated docstring)
@@ -302,23 +271,23 @@ def _makeDictionaryOEIS() -> dict[str, MetadataOEISid]:
 		objects, containing all metadata and known values needed for computation and validation.
 
 	"""
-	dictionaryOEIS: dict[str, MetadataOEISid] = {}
+	dictionaryOEIS: dict[str, MetadataOEISidMapFolding] = {}
 	for oeisID in oeisIDsImplemented:
 		valuesKnownSherpa: dict[int, int] = getOEISidValues(oeisID)
 		descriptionSherpa, offsetSherpa = getOEISidInformation(oeisID)
-		dictionaryOEIS[oeisID] = MetadataOEISid(
+		dictionaryOEIS[oeisID] = MetadataOEISidMapFolding(
 			description=descriptionSherpa,
 			offset=offsetSherpa,
-			getMapShape=settingsOEISManuallySelected[oeisID]['getMapShape'],
-			valuesBenchmark=settingsOEISManuallySelected[oeisID]['valuesBenchmark'],
-			valuesTestParallelization=settingsOEISManuallySelected[oeisID]['valuesTestParallelization'],
-			valuesTestValidation=settingsOEISManuallySelected[oeisID]['valuesTestValidation'] + list(range(offsetSherpa, 2)),
+			getMapShape=packageSettings.OEISidMapFoldingManuallySet[oeisID]['getMapShape'],
+			valuesBenchmark=packageSettings.OEISidMapFoldingManuallySet[oeisID]['valuesBenchmark'],
+			valuesTestParallelization=packageSettings.OEISidMapFoldingManuallySet[oeisID]['valuesTestParallelization'],
+			valuesTestValidation=packageSettings.OEISidMapFoldingManuallySet[oeisID]['valuesTestValidation'] + list(range(offsetSherpa, 2)),
 			valuesKnown=valuesKnownSherpa,
 			valueUnknown=max(valuesKnownSherpa.keys(), default=0) + 1
 		)
 	return dictionaryOEIS
 
-dictionaryOEIS: dict[str, MetadataOEISid] = _makeDictionaryOEIS()
+dictionaryOEISMapFolding: dict[str, MetadataOEISidMapFolding] = _makeDictionaryOEIS()
 """Metadata for each OEIS sequence ID."""
 
 def makeDictionaryFoldsTotalKnown() -> dict[tuple[int, ...], int]:
@@ -332,7 +301,7 @@ def makeDictionaryFoldsTotalKnown() -> dict[tuple[int, ...], int]:
 
 	"""
 	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'))
+	, oeisIDmetadata['valuesKnown'].values(), strict=True) for oeisID, oeisIDmetadata in dictionaryOEISMapFolding.items() if oeisID != 'A007822'))
 
 def getFoldsTotalKnown(mapShape: tuple[int, ...]) -> int:
 	"""Retrieve the known total number of distinct folding patterns for a given map shape.
@@ -378,7 +347,7 @@ def _formatHelpText() -> str:
 
 	"""
 	exampleOEISid: str = oeisIDsImplemented[0]
-	exampleN: int = dictionaryOEIS[exampleOEISid]['valuesTestValidation'][-1]
+	exampleN: int = dictionaryOEISMapFolding[exampleOEISid]['valuesTestValidation'][-1]
 
 	return (
 		"\nAvailable OEIS sequences:\n"
@@ -406,7 +375,7 @@ def _formatOEISsequenceInfo() -> str:
 
 	"""
 	return "\n".join(
-		f"  {oeisID}: {dictionaryOEIS[oeisID]['description']}"
+		f"  {oeisID}: {dictionaryOEISMapFolding[oeisID]['description']}"
 		for oeisID in oeisIDsImplemented
 	)
 
@@ -441,14 +410,14 @@ def oeisIDfor_n(oeisID: str, n: int) -> 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 = dictionaryOEIS[oeisID]['getMapShape'](n)
+	mapShape = dictionaryOEISMapFolding[oeisID]['getMapShape'](n)
 
 	if n <= 1 or len(mapShape) < 2:
-		offset: int = dictionaryOEIS[oeisID]['offset']
+		offset: int = dictionaryOEISMapFolding[oeisID]['offset']
 		if n < offset:
 			message = f"OEIS sequence {oeisID} is not defined at {n = }."
 			raise ArithmeticError(message)
-		foldsTotal: int = dictionaryOEIS[oeisID]['valuesKnown'][n]
+		foldsTotal: int = dictionaryOEISMapFolding[oeisID]['valuesKnown'][n]
 		return foldsTotal
 
 	return countFolds(mapShape, oeisID=oeisID)
@@ -513,7 +482,7 @@ def clearOEIScache() -> None:
 	if not pathCache.exists():
 		print(f"Cache directory, {pathCache}, not found - nothing to clear.")  # noqa: T201
 		return
-	for oeisID in dictionaryOEIS:
+	for oeisID in dictionaryOEISMapFolding:
 		( pathCache / f"{oeisID}.txt" ).unlink(missing_ok=True)
 		( pathCache / _getFilenameOEISbFile(oeisID) ).unlink(missing_ok=True)
 	print(f"Cache cleared from {pathCache}")  # noqa: T201
@@ -534,5 +503,22 @@ def getOEISids() -> None:
 	"""
 	print(_formatHelpText())  # noqa: T201
 
+def _makeDictionaryOEISMeanders() -> dict[str, MetadataOEISidMeanders]:
+	dictionary: dict[str, MetadataOEISidMeanders] = {}
+	for oeisID in packageSettings.OEISidMeandersManuallySet:
+		valuesKnownSherpa: dict[int, int] = getOEISidValues(oeisID)
+		descriptionSherpa, offsetSherpa = getOEISidInformation(oeisID)
+		dictionary[oeisID] = MetadataOEISidMeanders(
+			description=descriptionSherpa,
+			offset=offsetSherpa,
+			valuesKnown=valuesKnownSherpa,
+			valuesTestValidation=packageSettings.OEISidMeandersManuallySet[oeisID]['valuesTestValidation'],
+			valueUnknown=max(valuesKnownSherpa.keys(), default=0) + 1,
+		)
+	return dictionary
+
+dictionaryOEISMeanders: dict[str, MetadataOEISidMeanders] = _makeDictionaryOEISMeanders()
+
 if __name__ == "__main__":
 	getOEISids()
+