mapFolding 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

tests/test_other.py

@@ -1,12 +1,14 @@
-from pathlib import Path
-from typing import List, Optional, Dict, Any, Union
+import pathlib
 from tests.conftest import *
 from tests.pythons_idiotic_namespace import *
+from typing import List, Optional
+import itertools
+import numba
+import numpy
 import pytest
+import random
 import sys
 import unittest.mock
-import numpy
-import numba
 
 @pytest.mark.parametrize("listDimensions,expected_intInnit,expected_parseListDimensions,expected_validateListDimensions,expected_getLeavesTotal", [
     (None, ValueError, ValueError, ValueError, ValueError),  # None instead of list
@@ -65,7 +67,7 @@ def test_getLeavesTotal_edge_cases() -> None:
 ])
 def test_countFolds_writeFoldsTotal(
     listDimensionsTestFunctionality: List[int],
-    pathTempTesting: Path,
+    pathTempTesting: pathlib.Path,
     mockFoldingFunction,
     foldsValue: int,
     writeFoldsTarget: Optional[str]
@@ -82,7 +84,7 @@ def test_countFolds_writeFoldsTotal(
     mock_countFolds = mockFoldingFunction(foldsValue, listDimensionsTestFunctionality)
 
     with unittest.mock.patch("mapFolding.babbage._countFolds", side_effect=mock_countFolds):
-        returned = countFolds(listDimensionsTestFunctionality, writeFoldsTotal=pathWriteTarget)
+        returned = countFolds(listDimensionsTestFunctionality, pathishWriteFoldsTotal=pathWriteTarget)
 
     standardComparison(foldsValue, lambda: returned)  # Check return value
     standardComparison(str(foldsValue), lambda: (pathTempTesting / filenameFoldsTotalExpected).read_text())  # Check file content
@@ -97,18 +99,19 @@ def test_oopsieKwargsie() -> None:
     for testName, testFunction in makeTestSuiteOopsieKwargsie(oopsieKwargsie).items():
         testFunction()
 
-# TODO mock CPU counts?
-# @pytest.mark.parametrize("CPUlimit, expectedLimit", [
-#     (None, numba.config.NUMBA_DEFAULT_NUM_THREADS),
-#     (False, numba.config.NUMBA_DEFAULT_NUM_THREADS),
-#     (True, 1),
-#     (4, 4),
-#     (0.5, max(1, numba.config.NUMBA_DEFAULT_NUM_THREADS // 2)),
-#     (-0.5, max(1, numba.config.NUMBA_DEFAULT_NUM_THREADS // 2)),
-#     (-2, max(1, numba.config.NUMBA_DEFAULT_NUM_THREADS - 2)),
-# ])
-# def test_setCPUlimit(CPUlimit, expectedLimit) -> None:
-#     standardComparison(expectedLimit, setCPUlimit, CPUlimit)
+@pytest.mark.parametrize("CPUlimit, expectedLimit", [
+    (None, numba.config.NUMBA_DEFAULT_NUM_THREADS), # type: ignore
+    (False, numba.config.NUMBA_DEFAULT_NUM_THREADS), # type: ignore
+    (True, 1),
+    (4, 4),
+    (0.5, max(1, numba.config.NUMBA_DEFAULT_NUM_THREADS // 2)), # type: ignore
+    (-0.5, max(1, numba.config.NUMBA_DEFAULT_NUM_THREADS // 2)), # type: ignore
+    (-2, max(1, numba.config.NUMBA_DEFAULT_NUM_THREADS - 2)), # type: ignore
+    (0, numba.config.NUMBA_DEFAULT_NUM_THREADS), # type: ignore
+    (1, 1),
+])
+def test_setCPUlimit(CPUlimit, expectedLimit) -> None:
+    standardComparison(expectedLimit, setCPUlimit, CPUlimit)
 
 def test_makeConnectionGraph_nonNegative(listDimensionsTestFunctionality: List[int]) -> None:
     connectionGraph = makeConnectionGraph(listDimensionsTestFunctionality)
@@ -119,80 +122,147 @@ def test_makeConnectionGraph_datatype(listDimensionsTestFunctionality: List[int]
     connectionGraph = makeConnectionGraph(listDimensionsTestFunctionality, datatype=datatype)
     assert connectionGraph.dtype == datatype, f"Expected datatype {datatype}, but got {connectionGraph.dtype}."
 
-# @pytest.mark.parametrize("computationDivisions,CPUlimit,datatypeOverrides", [
-#     (None, None, {}),  # Basic case
-#     ("maximum", True, {"datatypeDefault": numpy.int32}),  # Max divisions, min CPU, custom dtype
-#     ("cpu", 4, {"datatypeLarge": numpy.int64}),  # CPU-based divisions, fixed CPU limit
-#     (3, 0.5, {}),  # Fixed divisions, fractional CPU
-# ])
-# def test_outfitCountFolds(
-#     listDimensionsTestFunctionality: List[int],
-#     computationDivisions: Optional[Union[int, str]],
-#     CPUlimit: Optional[Union[bool, float, int]],
-#     datatypeOverrides: Dict[str, Any]
-# ) -> None:
-#     """Test outfitCountFolds as a nexus of configuration and initialization.
-
-#     Strategy:
-#     1. Validate structure against computationState TypedDict
-#     2. Compare with direct function calls
-#     3. Verify enum-based indexing
-#     4. Check datatypes and shapes
-#     """
-#     # Get initialized state
+
+"""5 parameters
+listDimensionsTestFunctionality
+
+computationDivisions
+    None
+    random: int, first included: 2, first excluded: leavesTotal
+    maximum
+    cpu
+
+CPUlimit
+    None
+    True
+    False
+    0
+    1
+    -1
+    random: 0 < float < 1
+    random: -1 < float < 0
+    random: int, first included: 2, first excluded: (min(leavesTotal, 16) - 1)
+    random: int, first included: -1 * (min(leavesTotal, 16) - 1), first excluded: -1
+
+datatypeDefault
+    None
+    numpy.int64
+    numpy.intc
+    numpy.uint16
+
+datatypeLarge
+    None
+    numpy.int64
+    numpy.intp
+    numpy.uint32
+
+"""
+
+@pytest.fixture
+def parameterIterator():
+    """Generate random combinations of parameters for outfitCountFolds testing."""
+    parameterSets = {
+        'computationDivisions': [
+            None,
+            'maximum',
+            'cpu',
+        ],
+        'CPUlimit': [
+            None, True, False, 0, 1, -1,
+        ],
+        'datatypeDefault': [
+            None,
+            numpy.int64,
+            numpy.intc,
+            numpy.uint16
+        ],
+        'datatypeLarge': [
+            None,
+            numpy.int64,
+            numpy.intp,
+            numpy.uint32
+        ]
+    }
+
+    def makeParametersDynamic(listDimensions):
+        """Add context-dependent parameter values."""
+        parametersDynamic = parameterSets.copy()
+        leavesTotal = getLeavesTotal(listDimensions)
+        concurrencyLimit = min(leavesTotal, 16)
+
+        # Add dynamic computationDivisions
+        parametersDynamic['computationDivisions'].extend(
+            [random.randint(2, leavesTotal-1) for iterator in range(3)]
+        )
+
+        # Add dynamic CPUlimit values
+        parameterDynamicCPU = [
+            random.random(),  # 0 to 1
+            -random.random(), # -1 to 0
+        ]
+        parameterDynamicCPU.extend(
+            [random.randint(2, concurrencyLimit-1) for iterator in range(2)]
+        )
+        parameterDynamicCPU.extend(
+            [random.randint(-concurrencyLimit+1, -2) for iterator in range(2)]
+        )
+        parametersDynamic['CPUlimit'].extend(parameterDynamicCPU)
+
+        return parametersDynamic
+
+    def generateCombinations(listDimensions):
+        parametersDynamic = makeParametersDynamic(listDimensions)
+        parameterKeys = list(parametersDynamic.keys())
+        parameterValues = [parametersDynamic[key] for key in parameterKeys]
+
+        # Shuffle each parameter list
+        for valueList in parameterValues:
+            random.shuffle(valueList)
+
+        # Use zip_longest to iterate, filling with None when shorter lists are exhausted
+        for combination in itertools.zip_longest(*parameterValues, fillvalue=None):
+            yield dict(zip(parameterKeys, combination))
+
+    return generateCombinations
+# Must mock the set cpu count to avoid errors on GitHub
+# def test_outfitCountFolds_basic(listDimensionsTestFunctionality, parameterIterator):
+#     """Basic validation of outfitCountFolds return value structure."""
+#     parameters = next(parameterIterator(listDimensionsTestFunctionality))
+
 #     stateInitialized = outfitCountFolds(
 #         listDimensionsTestFunctionality,
-#         computationDivisions=computationDivisions,
-#         CPUlimit=CPUlimit,
-#         **datatypeOverrides
+#         **{k: v for k, v in parameters.items() if v is not None}
 #     )
 
-#     # 1. TypedDict structure validation
-#     for keyRequired in computationState.__annotations__:
-#         assert keyRequired in stateInitialized, f"Missing required key: {keyRequired}"
-#         assert stateInitialized[keyRequired] is not None, f"Key has None value: {keyRequired}"
+#     # Basic structure tests
+#     assert isinstance(stateInitialized, dict)
+#     assert len(stateInitialized) == 7  # 6 ndarray + 1 tuple
 
-#         # Type checking
-#         expectedType = computationState.__annotations__[keyRequired]
-#         assert isinstance(stateInitialized[keyRequired], expectedType), \
-#             f"Type mismatch for {keyRequired}: expected {expectedType}, got {type(stateInitialized[keyRequired])}"
+#     # Check for specific keys
+#     requiredKeys = set(computationState.__annotations__.keys())
+#     assert set(stateInitialized.keys()) == requiredKeys
 
-#     # 2. Compare with direct function calls
-#     directMapShape = tuple(sorted(validateListDimensions(listDimensionsTestFunctionality)))
-#     assert stateInitialized['mapShape'] == directMapShape
+#     # Check types more carefully
+#     for key, value in stateInitialized.items():
+#         if key == 'mapShape':
+#             assert isinstance(value, tuple)
+#             assert all(isinstance(dim, int) for dim in value)
+#         else:
+#             assert isinstance(value, numpy.ndarray), f"{key} should be ndarray but is {type(value)}"
+#             assert issubclass(value.dtype.type, numpy.integer), \
+#                 f"{key} should have integer dtype but has {value.dtype}"
 
-#     directConnectionGraph = makeConnectionGraph(
-#         directMapShape,
-#         datatype=datatypeOverrides.get('datatypeDefault', dtypeDefault)
-#     )
-#     assert numpy.array_equal(stateInitialized['connectionGraph'], directConnectionGraph)
-
-#     # 3. Enum-based indexing validation
-#     for arrayName, indexEnum in [
-#         ('my', indexMy),
-#         ('the', indexThe),
-#         ('track', indexTrack)
-#     ]:
-#         array = stateInitialized[arrayName]
-#         assert array.shape[0] >= len(indexEnum), \
-#             f"Array {arrayName} too small for enum {indexEnum.__name__}"
-
-#         # Test each enum index
-#         for enumMember in indexEnum:
-#             assert array[enumMember.value] >= 0, \
-#                 f"Negative value at {arrayName}[{enumMember.name}]"
-
-#     # 4. Special value checks
-#     assert stateInitialized['my'][indexMy.leaf1ndex.value] == 1, \
-#         "Initial leaf index should be 1"
-
-#     # 5. Shape consistency
-#     leavesTotal = getLeavesTotal(listDimensionsTestFunctionality)
-#     assert stateInitialized['foldsSubTotals'].shape == (leavesTotal,), \
-#         "foldsSubTotals shape mismatch"
-#     assert stateInitialized['gapsWhere'].shape == (leavesTotal * leavesTotal + 1,), \
-#         "gapsWhere shape mismatch"
-#     assert stateInitialized['track'].shape == (len(indexTrack), leavesTotal + 1), \
-#         "track shape mismatch"
-
-# TODO test `outfitCountFolds`; no negative values in arrays; compare datatypes to the typeddict; compare the connection graph to making a graph
+def test_pathJobDEFAULT_colab():
+    """Test that pathJobDEFAULT is set correctly when running in Google Colab."""
+    # Mock sys.modules to simulate running in Colab
+    with unittest.mock.patch.dict('sys.modules', {'google.colab': unittest.mock.MagicMock()}):
+        # Force reload of theSSOT to trigger Colab path logic
+        import importlib
+        import mapFolding.theSSOT
+        importlib.reload(mapFolding.theSSOT)
+
+        # Check that path was set to Colab-specific value
+        assert mapFolding.theSSOT.pathJobDEFAULT == pathlib.Path("/content/drive/MyDrive") / "jobs"
+
+    # Reload one more time to restore original state
+    importlib.reload(mapFolding.theSSOT)

mapFolding/JAX/taskJAX.py

@@ -1,313 +0,0 @@
-from mapFolding import validateListDimensions, getLeavesTotal
-from typing import List, Tuple
-import jax
-import jaxtyping
-
-dtypeDefault = jax.numpy.int32
-dtypeMaximum = jax.numpy.int32
-
-def countFolds(listDimensions: List[int]):
-    """Calculate foldings across multiple devices using pmap"""
-    p = validateListDimensions(listDimensions)
-    n = getLeavesTotal(p)
-
-    # Get number of devices (GPUs/TPUs)
-    deviceCount = jax.device_count()
-
-    if deviceCount > 1:
-        # Split work across devices
-        tasksPerDevice = (n + deviceCount - 1) // deviceCount
-        paddedTaskCount = tasksPerDevice * deviceCount
-
-        # Create padded array of task indices
-        arrayTaskIndices = jax.numpy.arange(paddedTaskCount, dtype=dtypeDefault)
-        arrayTaskIndices = arrayTaskIndices.reshape((deviceCount, tasksPerDevice))
-
-        # Create pmapped function
-        parallelFoldingsTask = jax.pmap(lambda x: jax.vmap(lambda y: foldingsTask(tuple(p), y))(x))
-
-        # Run computation across devices
-        arrayResults = parallelFoldingsTask(arrayTaskIndices)
-
-        # Sum valid results (ignore padding)
-        return jax.numpy.sum(arrayResults[:, :min(tasksPerDevice, n - tasksPerDevice * (deviceCount-1))])
-    else:
-        # Fall back to sequential execution if no multiple devices available
-        arrayTaskIndices = jax.numpy.arange(n, dtype=dtypeDefault)
-        batchedFoldingsTask = jax.vmap(lambda x: foldingsTask(tuple(p), x))
-        return jax.numpy.sum(batchedFoldingsTask(arrayTaskIndices))
-
-def foldingsTask(p, taskIndex) -> jaxtyping.UInt32:
-    arrayDimensions = jax.numpy.asarray(p, dtype=dtypeDefault)
-    leavesTotal = jax.numpy.prod(arrayDimensions)
-    dimensionsTotal = jax.numpy.size(arrayDimensions)
-
-    """How to build a leaf connection graph, also called a "Cartesian Product Decomposition"
-    or a "Dimensional Product Mapping", with sentinels:
-    Step 1: find the cumulative product of the map's dimensions"""
-    cumulativeProduct = jax.numpy.ones(dimensionsTotal + 1, dtype=dtypeDefault)
-    cumulativeProduct = cumulativeProduct.at[1:].set(jax.numpy.cumprod(arrayDimensions))
-
-    """Step 2: for each dimension, create a coordinate system """
-    """coordinateSystem[dimension1ndex][leaf1ndex] holds the dimension1ndex-th coordinate of leaf leaf1ndex"""
-    coordinateSystem = jax.numpy.zeros((dimensionsTotal + 1, leavesTotal + 1), dtype=dtypeDefault)
-
-    # Create mesh of indices for vectorized computation
-    dimension1ndices, leaf1ndices = jax.numpy.meshgrid(
-        jax.numpy.arange(1, dimensionsTotal + 1),
-        jax.numpy.arange(1, leavesTotal + 1),
-        indexing='ij'
-    )
-
-    # Compute all coordinates at once using broadcasting
-    coordinateSystem = coordinateSystem.at[1:, 1:].set(
-        ((leaf1ndices - 1) // cumulativeProduct.at[dimension1ndices - 1].get()) %
-        arrayDimensions.at[dimension1ndices - 1].get() + 1
-    )
-    del dimension1ndices, leaf1ndices
-
-    """Step 3: create a huge empty connection graph"""
-    connectionGraph = jax.numpy.zeros((dimensionsTotal + 1, leavesTotal + 1, leavesTotal + 1), dtype=dtypeDefault)
-
-    # Create 3D mesh of indices for vectorized computation
-    dimension1ndices, activeLeaf1ndices, connectee1ndices = jax.numpy.meshgrid(
-        jax.numpy.arange(1, dimensionsTotal + 1),
-        jax.numpy.arange(1, leavesTotal + 1),
-        jax.numpy.arange(1, leavesTotal + 1),
-        indexing='ij'
-    )
-
-    # Create masks for valid indices
-    maskActiveConnectee = connectee1ndices <= activeLeaf1ndices
-
-    # Calculate coordinate parity comparison
-    coordsParity = (coordinateSystem.at[dimension1ndices, activeLeaf1ndices].get() & 1) == \
-                    (coordinateSystem.at[dimension1ndices, connectee1ndices].get() & 1)
-
-    # Compute distance conditions
-    isFirstCoord = coordinateSystem.at[dimension1ndices, connectee1ndices].get() == 1
-    isLastCoord = coordinateSystem.at[dimension1ndices, connectee1ndices].get() == \
-                    arrayDimensions.at[dimension1ndices - 1].get()
-    exceedsActive = connectee1ndices + cumulativeProduct.at[dimension1ndices - 1].get() > activeLeaf1ndices
-
-    # Compute connection values for even and odd parities
-    evenParityValues = jax.numpy.where(
-        isFirstCoord,
-        connectee1ndices,
-        connectee1ndices - cumulativeProduct.at[dimension1ndices - 1].get()
-    )
-
-    oddParityValues = jax.numpy.where(
-        jax.numpy.logical_or(isLastCoord, exceedsActive),
-        connectee1ndices,
-        connectee1ndices + cumulativeProduct.at[dimension1ndices - 1].get()
-    )
-
-    # Combine based on parity and valid indices
-    connectionValues = jax.numpy.where(
-        coordsParity,
-        evenParityValues,
-        oddParityValues
-    )
-
-    # Update only valid connections
-    connectionGraph = connectionGraph.at[dimension1ndices, activeLeaf1ndices, connectee1ndices].set(
-        jax.numpy.where(maskActiveConnectee, connectionValues, 0)
-    )
-
-    def doNothing(argument):
-        return argument
-
-    def while_activeLeaf1ndex_greaterThan_0(comparisonValues: Tuple):
-        comparand = comparisonValues[6]
-        return comparand > 0
-
-    def countFoldings(allValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32, jaxtyping.UInt32]):
-        _0, leafBelow, _2, _3, _4, _5, activeLeaf1ndex, _7 = allValues
-
-        sentinel = leafBelow.at[0].get().astype(jax.numpy.int32)
-
-        allValues = jax.lax.cond(findGapsCondition(sentinel, activeLeaf1ndex),
-                            lambda argumentX: dao(findGapsDo(argumentX)),
-                            lambda argumentY: jax.lax.cond(incrementCondition(sentinel, activeLeaf1ndex), lambda argumentZ: dao(incrementDo(argumentZ)), dao, argumentY),
-                            allValues)
-
-        return allValues
-
-    def findGapsCondition(leafBelowSentinel, activeLeafNumber):
-        return jax.numpy.logical_or(jax.numpy.logical_and(leafBelowSentinel == 1, activeLeafNumber <= leavesTotal), activeLeafNumber <= 1)
-
-    def findGapsDo(allValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32, jaxtyping.UInt32]):
-        def for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1(comparisonValues: Tuple):
-            return comparisonValues[-1] <= dimensionsTotal
-
-        def for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1_do(for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1Values: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32, jaxtyping.UInt32]):
-            def ifLeafIsUnconstrainedCondition(comparand):
-                return jax.numpy.equal(connectionGraph[comparand, activeLeaf1ndex, activeLeaf1ndex], activeLeaf1ndex)
-
-            def ifLeafIsUnconstrainedDo(unconstrainedValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32]):
-                unconstrained_unconstrainedLeaf = unconstrainedValues[3]
-                unconstrained_unconstrainedLeaf = 1 + unconstrained_unconstrainedLeaf
-                return (unconstrainedValues[0], unconstrainedValues[1], unconstrainedValues[2], unconstrained_unconstrainedLeaf)
-
-            def ifLeafIsUnconstrainedElse(unconstrainedValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32]):
-                def while_leaf1ndexConnectee_notEquals_activeLeaf1ndex(comparisonValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32]):
-                    return comparisonValues[-1] != activeLeaf1ndex
-
-                def countGaps(countGapsDoValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32]):
-                    # if taskDivisions == False or activeLeaf1ndex != leavesTotal or leaf1ndexConnectee % leavesTotal == taskIndex:
-                    def taskDivisionComparison():
-                        return jax.numpy.logical_or(activeLeaf1ndex != leavesTotal, jax.numpy.equal(countGapsLeaf1ndexConnectee % leavesTotal, taskIndex))
-                        # return taskDivisions == False or jax.numpy.logical_or(activeLeaf1ndex != leavesTotal, jax.numpy.equal(countGapsLeaf1ndexConnectee % leavesTotal, taskIndex))
-
-                    def taskDivisionDo(taskDivisionDoValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32]):
-                        taskDivisionCountDimensionsGapped, taskDivisionPotentialGaps, taskDivisionGap1ndexLowerBound = taskDivisionDoValues
-
-                        taskDivisionPotentialGaps = taskDivisionPotentialGaps.at[taskDivisionGap1ndexLowerBound].set(countGapsLeaf1ndexConnectee)
-                        taskDivisionGap1ndexLowerBound = jax.numpy.where(
-                            jax.numpy.equal(taskDivisionCountDimensionsGapped.at[countGapsLeaf1ndexConnectee].get(), 0), taskDivisionGap1ndexLowerBound + 1, taskDivisionGap1ndexLowerBound)
-                        taskDivisionCountDimensionsGapped = taskDivisionCountDimensionsGapped.at[countGapsLeaf1ndexConnectee].add(1)
-
-                        return (taskDivisionCountDimensionsGapped, taskDivisionPotentialGaps, taskDivisionGap1ndexLowerBound)
-
-                    countGapsLeaf1ndexConnectee = countGapsDoValues[3]
-                    taskDivisionValues = (countGapsDoValues[0], countGapsDoValues[1], countGapsDoValues[2])
-                    taskDivisionValues = jax.lax.cond(taskDivisionComparison(), taskDivisionDo, doNothing, taskDivisionValues)
-
-                    countGapsLeaf1ndexConnectee = connectionGraph.at[dimensionNumber, activeLeaf1ndex, leafBelow.at[countGapsLeaf1ndexConnectee].get()].get().astype(jax.numpy.int32)
-
-                    return (taskDivisionValues[0], taskDivisionValues[1], taskDivisionValues[2], countGapsLeaf1ndexConnectee)
-
-                unconstrained_countDimensionsGapped, unconstrained_gapsWhere, unconstrained_gap1ndexCeiling, unconstrained_unconstrainedLeaf = unconstrainedValues
-
-                leaf1ndexConnectee = connectionGraph.at[dimensionNumber, activeLeaf1ndex, activeLeaf1ndex].get().astype(jax.numpy.int32)
-
-                countGapsValues = (unconstrained_countDimensionsGapped, unconstrained_gapsWhere, unconstrained_gap1ndexCeiling, leaf1ndexConnectee)
-                countGapsValues = jax.lax.while_loop(while_leaf1ndexConnectee_notEquals_activeLeaf1ndex, countGaps, countGapsValues)
-                unconstrained_countDimensionsGapped, unconstrained_gapsWhere, unconstrained_gap1ndexCeiling, leaf1ndexConnectee = countGapsValues
-
-                return (unconstrained_countDimensionsGapped, unconstrained_gapsWhere, unconstrained_gap1ndexCeiling, unconstrained_unconstrainedLeaf)
-
-            dimensions_countDimensionsGapped, dimensions_gapsWhere, dimensions_gap1ndexCeiling, dimensions_unconstrainedLeaf, dimensionNumber = for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1Values
-
-            ifLeafIsUnconstrainedValues = (dimensions_countDimensionsGapped, dimensions_gapsWhere, dimensions_gap1ndexCeiling, dimensions_unconstrainedLeaf)
-            ifLeafIsUnconstrainedValues = jax.lax.cond(ifLeafIsUnconstrainedCondition(dimensionNumber), ifLeafIsUnconstrainedDo, ifLeafIsUnconstrainedElse, ifLeafIsUnconstrainedValues)
-            dimensions_countDimensionsGapped, dimensions_gapsWhere, dimensions_gap1ndexCeiling, dimensions_unconstrainedLeaf = ifLeafIsUnconstrainedValues
-
-            dimensionNumber = 1 + dimensionNumber
-            return (dimensions_countDimensionsGapped, dimensions_gapsWhere, dimensions_gap1ndexCeiling, dimensions_unconstrainedLeaf, dimensionNumber)
-
-        def almostUselessCondition(comparand):
-            return comparand == dimensionsTotal
-
-        def almostUselessConditionDo(for_leaf1ndex_in_range_activeLeaf1ndexValues: Tuple[jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32]):
-            def for_leaf1ndex_in_range_activeLeaf1ndex(comparisonValues):
-                return comparisonValues[-1] < activeLeaf1ndex
-
-            def for_leaf1ndex_in_range_activeLeaf1ndex_do(for_leaf1ndex_in_range_activeLeaf1ndexValues: Tuple[jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32]):
-                leafInRangePotentialGaps, gapNumberLowerBound, leafNumber = for_leaf1ndex_in_range_activeLeaf1ndexValues
-                leafInRangePotentialGaps = leafInRangePotentialGaps.at[gapNumberLowerBound].set(leafNumber)
-                gapNumberLowerBound = 1 + gapNumberLowerBound
-                leafNumber = 1 + leafNumber
-                return (leafInRangePotentialGaps, gapNumberLowerBound, leafNumber)
-            return jax.lax.while_loop(for_leaf1ndex_in_range_activeLeaf1ndex, for_leaf1ndex_in_range_activeLeaf1ndex_do, for_leaf1ndex_in_range_activeLeaf1ndexValues)
-
-        def for_range_from_activeGap1ndex_to_gap1ndexCeiling(comparisonValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32]):
-            return comparisonValues[-1] < gap1ndexCeiling
-
-        def miniGapDo(gapToGapValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32]):
-            gapToGapCountDimensionsGapped, gapToGapPotentialGaps, activeGapNumber, index = gapToGapValues
-            gapToGapPotentialGaps = gapToGapPotentialGaps.at[activeGapNumber].set(gapToGapPotentialGaps.at[index].get())
-            activeGapNumber = jax.numpy.where(jax.numpy.equal(gapToGapCountDimensionsGapped.at[gapToGapPotentialGaps.at[index].get()].get(), dimensionsTotal - unconstrainedLeaf), activeGapNumber + 1, activeGapNumber).astype(jax.numpy.int32)
-            gapToGapCountDimensionsGapped = gapToGapCountDimensionsGapped.at[gapToGapPotentialGaps.at[index].get()].set(0)
-            index = 1 + index
-            return (gapToGapCountDimensionsGapped, gapToGapPotentialGaps, activeGapNumber, index)
-
-        _0, leafBelow, countDimensionsGapped, gapRangeStart, gapsWhere, _5, activeLeaf1ndex, activeGap1ndex = allValues
-
-        unconstrainedLeaf = jax.numpy.int32(0)
-        dimension1ndex = jax.numpy.int32(1)
-        gap1ndexCeiling = gapRangeStart.at[activeLeaf1ndex - 1].get().astype(jax.numpy.int32)
-        activeGap1ndex = gap1ndexCeiling
-        for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1Values = (countDimensionsGapped, gapsWhere, gap1ndexCeiling, unconstrainedLeaf, dimension1ndex)
-        for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1Values = jax.lax.while_loop(for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1, for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1_do, for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1Values)
-        countDimensionsGapped, gapsWhere, gap1ndexCeiling, unconstrainedLeaf, dimension1ndex = for_dimension1ndex_in_range_1_to_dimensionsTotalPlus1Values
-        del dimension1ndex
-
-        leaf1ndex = jax.numpy.int32(0)
-        for_leaf1ndex_in_range_activeLeaf1ndexValues = (gapsWhere, gap1ndexCeiling, leaf1ndex)
-        for_leaf1ndex_in_range_activeLeaf1ndexValues = jax.lax.cond(almostUselessCondition(unconstrainedLeaf), almostUselessConditionDo, doNothing, for_leaf1ndex_in_range_activeLeaf1ndexValues)
-        gapsWhere, gap1ndexCeiling, leaf1ndex = for_leaf1ndex_in_range_activeLeaf1ndexValues
-        del leaf1ndex
-
-        indexMiniGap = activeGap1ndex
-        miniGapValues = (countDimensionsGapped, gapsWhere, activeGap1ndex, indexMiniGap)
-        miniGapValues = jax.lax.while_loop(for_range_from_activeGap1ndex_to_gap1ndexCeiling, miniGapDo, miniGapValues)
-        countDimensionsGapped, gapsWhere, activeGap1ndex, indexMiniGap = miniGapValues
-        del indexMiniGap
-
-        return (allValues[0], leafBelow, countDimensionsGapped, gapRangeStart, gapsWhere, allValues[5], activeLeaf1ndex, activeGap1ndex)
-
-    def incrementCondition(leafBelowSentinel, activeLeafNumber):
-        return jax.numpy.logical_and(activeLeafNumber > leavesTotal, leafBelowSentinel == 1)
-
-    def incrementDo(allValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32, jaxtyping.UInt32]):
-        foldingsSubTotal = allValues[5]
-        foldingsSubTotal = leavesTotal + foldingsSubTotal
-        return (allValues[0], allValues[1], allValues[2], allValues[3], allValues[4], foldingsSubTotal, allValues[6], allValues[7])
-
-    def dao(allValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32, jaxtyping.UInt32]):
-        def whileBacktrackingCondition(backtrackingValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32]):
-            comparand = backtrackingValues[2]
-            return jax.numpy.logical_and(comparand > 0, jax.numpy.equal(activeGap1ndex, gapRangeStart.at[comparand - 1].get()))
-
-        def whileBacktrackingDo(backtrackingValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32]):
-            backtrackAbove, backtrackBelow, activeLeafNumber = backtrackingValues
-
-            activeLeafNumber = activeLeafNumber - 1
-            backtrackBelow = backtrackBelow.at[backtrackAbove.at[activeLeafNumber].get()].set(backtrackBelow.at[activeLeafNumber].get())
-            backtrackAbove = backtrackAbove.at[backtrackBelow.at[activeLeafNumber].get()].set(backtrackAbove.at[activeLeafNumber].get())
-
-            return (backtrackAbove, backtrackBelow, activeLeafNumber)
-
-        def if_activeLeaf1ndex_greaterThan_0(activeLeafNumber):
-            return activeLeafNumber > 0
-
-        def if_activeLeaf1ndex_greaterThan_0_do(leafPlacementValues: Tuple[jaxtyping.Array, jaxtyping.Array, jaxtyping.Array, jaxtyping.UInt32, jaxtyping.UInt32]):
-            placeLeafAbove, placeLeafBelow, placeGapRangeStart, activeLeafNumber, activeGapNumber = leafPlacementValues
-            activeGapNumber = activeGapNumber - 1
-            placeLeafAbove = placeLeafAbove.at[activeLeafNumber].set(gapsWhere.at[activeGapNumber].get())
-            placeLeafBelow = placeLeafBelow.at[activeLeafNumber].set(placeLeafBelow.at[placeLeafAbove.at[activeLeafNumber].get()].get())
-            placeLeafBelow = placeLeafBelow.at[placeLeafAbove.at[activeLeafNumber].get()].set(activeLeafNumber)
-            placeLeafAbove = placeLeafAbove.at[placeLeafBelow.at[activeLeafNumber].get()].set(activeLeafNumber)
-            placeGapRangeStart = placeGapRangeStart.at[activeLeafNumber].set(activeGapNumber)
-
-            activeLeafNumber = 1 + activeLeafNumber
-            return (placeLeafAbove, placeLeafBelow, placeGapRangeStart, activeLeafNumber, activeGapNumber)
-
-        leafAbove, leafBelow, _2, gapRangeStart, gapsWhere, _5, activeLeaf1ndex, activeGap1ndex = allValues
-
-        whileBacktrackingValues = (leafAbove, leafBelow, activeLeaf1ndex)
-        whileBacktrackingValues = jax.lax.while_loop(whileBacktrackingCondition, whileBacktrackingDo, whileBacktrackingValues)
-        leafAbove, leafBelow, activeLeaf1ndex = whileBacktrackingValues
-
-        if_activeLeaf1ndex_greaterThan_0_values = (leafAbove, leafBelow, gapRangeStart, activeLeaf1ndex, activeGap1ndex)
-        if_activeLeaf1ndex_greaterThan_0_values = jax.lax.cond(if_activeLeaf1ndex_greaterThan_0(activeLeaf1ndex), if_activeLeaf1ndex_greaterThan_0_do, doNothing, if_activeLeaf1ndex_greaterThan_0_values)
-        leafAbove, leafBelow, gapRangeStart, activeLeaf1ndex, activeGap1ndex = if_activeLeaf1ndex_greaterThan_0_values
-
-        return (leafAbove, leafBelow, allValues[2], gapRangeStart, gapsWhere, allValues[5], activeLeaf1ndex, activeGap1ndex)
-
-    # Dynamic values
-    A = jax.numpy.zeros(leavesTotal + 1, dtype=dtypeDefault)
-    B = jax.numpy.zeros(leavesTotal + 1, dtype=dtypeDefault)
-    count = jax.numpy.zeros(leavesTotal + 1, dtype=dtypeDefault)
-    gapter = jax.numpy.zeros(leavesTotal + 1, dtype=dtypeDefault)
-    gap = jax.numpy.zeros(leavesTotal * leavesTotal + 1, dtype=dtypeMaximum)
-
-    foldingsSubTotal = jax.numpy.int32(0)
-    l = jax.numpy.int32(1)
-    g = jax.numpy.int32(0)
-
-    foldingsValues = (A, B, count, gapter, gap, foldingsSubTotal, l, g)
-    foldingsValues = jax.lax.while_loop(while_activeLeaf1ndex_greaterThan_0, countFoldings, foldingsValues)
-    return foldingsValues[5]