mapFolding 0.2.0__tar.gz

mapfolding-0.2.0/PKG-INFO

@@ -0,0 +1,170 @@
+Metadata-Version: 2.2
+Name: mapFolding
+Version: 0.2.0
+Summary: Algorithm(s) for counting distinct ways to fold a map (or a strip of stamps)
+Author-email: Hunter Hogan <HunterHogan@pm.me>
+Project-URL: homepage, https://github.com/hunterhogan/mapFolding
+Requires-Python: <3.13,>=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numba
+Requires-Dist: numpy
+Requires-Dist: Z0Z-tools
+Provides-Extra: benchmark
+Requires-Dist: pandas; extra == "benchmark"
+Requires-Dist: jupyter; extra == "benchmark"
+Requires-Dist: ipywidgets; extra == "benchmark"
+Requires-Dist: tqdm; extra == "benchmark"
+Provides-Extra: jax
+Requires-Dist: jax; extra == "jax"
+Requires-Dist: jaxtyping; extra == "jax"
+Provides-Extra: testing
+Requires-Dist: pytest; extra == "testing"
+Requires-Dist: pytest-cov; extra == "testing"
+Requires-Dist: pytest-env; extra == "testing"
+Requires-Dist: pytest-xdist; extra == "testing"
+
+# Algorithm(s) for counting distinct ways to fold a map (or a strip of stamps)
+
+`mapFolding.countFolds()` will accept arbitrary values for the map's dimensions.
+
+```python
+from mapFolding import countFolds
+foldsTotal = countFolds( [2,10] )
+```
+
+The directory `mapFolding/reference` has
+
+- a verbatim transcription of the "procedure" published in _The Computer Journal_,
+- multiple referential versions of the procedure with explanatory comments including
+- `hunterNumba.py` a one-size-fits-all, self-contained, reasonably fast, contemporary algorithm that is nevertheless infected by _noobaceae ignorancium_, and
+- miscellaneous notes.
+
+[![Python Tests](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml/badge.svg)](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml)
+
+## Simple, easy usage based on OEIS IDs
+
+`mapFolding` directly implements some IDs from _The On-Line Encyclopedia of Integer Sequences_.
+
+### Usage: command line
+
+After installing (see below), `OEIS_for_n` will run a computation from the command line.
+
+```cmd
+(mapFolding) C:\apps\mapFolding> OEIS_for_n A001418 5
+186086600 distinct folding patterns.
+Time elapsed: 1.605 seconds
+```
+
+Use `getOEISids` to get the most up-to-date list of available OEIS IDs.
+
+```cmd
+(mapFolding) C:\apps\mapFolding> getOEISids
+
+Available OEIS sequences:
+  A001415: Number of ways of folding a 2 X n strip of stamps.
+  A001416: Number of ways of folding a 3 X n strip of stamps.
+  A001417: Number of ways of folding a 2 X 2 X ... X 2 n-dimensional map.
+  A001418: Number of ways of folding an n X n sheet of stamps.
+  A195646: Number of ways of folding a 3 X 3 X ... X 3 n-dimensional map.
+
+Usage examples:
+  Command line:
+    OEIS_for_n A001415 8
+  Python:
+    from mapFolding import oeisIDfor_n
+    foldsTotal = oeisIDfor_n('A001415', 8)
+```
+
+### Usage: Python module or REPL
+
+Use `mapFolding.oeisIDfor_n()` to compute a(n) for an OEIS ID.
+
+```python
+from mapFolding import oeisIDfor_n
+foldsTotal = oeisIDfor_n( 'A001418', 4 )
+```
+
+### An "advanced" and likely unnecessary feature: clear `mapFolding`'s cache of OEIS data
+
+Clear _The On-Line Encyclopedia of Integer Sequences_ data from the `mapFolding` cache:
+
+```sh
+(mapFolding) C:\apps\mapFolding> clearOEIScache
+Cache cleared from C:\apps\mapFolding\mapFolding\.cache
+```
+
+## Connections to "Multi-dimensional map-folding" by W. F. Lunnon
+
+### The typo-laden algorithm published in 1971
+
+The full paper, W. F. Lunnon, Multi-dimensional map-folding, _The Computer Journal_, Volume 14, Issue 1, 1971, Pages 75–80, [https://doi.org/10.1093/comjnl/14.1.75](https://doi.org/10.1093/comjnl/14.1.75) ([BibTex](mapFolding/citations/Lunnon.bibtex) citation) is available at the DOI link. (As of 3 January 2025, the paper is a PDF of images, not text, and can be accessed without cost or login.)
+
+In [`foldings.txt`](mapFolding/reference/foldings.txt), you can find a text transcription of the algorithm as it was printed in 1971. In [`foldings.AA`](mapFolding/reference/foldings.AA), I have corrected obvious transcription errors, documented with comments, and I have reformatted line breaks and indentation. For contemporary readers, the result is likely easier to read than the text transcription or the original paper are easy to read. This is especially true if you view the document with semantic highlighting, such as with [Algol 60 syntax highlighter](https://github.com/PolariTOON/language-algol60).
+
+### Java implementation(s) and improvements
+
+[archmageirvine](https://github.com/archmageirvine/joeis/blob/80e3e844b11f149704acbab520bc3a3a25ac34ff/src/irvine/oeis/a001/A001415.java) ([BibTex](mapFolding/citations/jOEIS.bibtex) citation) says about the Java code:
+
+```java
+/**
+ * A001415 Number of ways of folding a 2 X n strip of stamps.
+ * @author Fred Lunnon (ALGOL68, C versions)
+ * @author Sean A. Irvine (Java port)
+ */
+...
+  // Implements algorithm as described in "Multi-dimensional map-folding",
+  // by W. F. Lunnon, The Computer J, 14, 1, pp. 75--80.  Note the original
+  // paper contains a few omissions, so this actual code is based on a C
+  // implementation by Fred Lunnon.
+```
+
+## Map-folding Video
+
+~~This caused my neurosis:~~ I enjoyed the following video, which is what introduced me to map folding.
+
+"How Many Ways Can You Fold a Map?" by Physics for the Birds, 2024 November 13 ([BibTex](mapFolding/citations/Physics_for_the_Birds.bibtex) citation)
+
+[![How Many Ways Can You Fold a Map?](https://i.ytimg.com/vi/sfH9uIY3ln4/hq720.jpg)](https://www.youtube.com/watch?v=sfH9uIY3ln4)
+
+## Install this package
+
+### From Github
+
+```sh
+pip install mapFolding@git+https://github.com/hunterhogan/mapFolding.git
+```
+
+### From a local directory
+
+#### Windows
+
+```powershell
+git clone https://github.com/hunterhogan/mapFolding.git \path\to\mapFolding
+pip install mapFolding@file:\path\to\mapFolding
+```
+
+#### POSIX
+
+```bash
+git clone https://github.com/hunterhogan/mapFolding.git /path/to/mapFolding
+pip install mapFolding@file:/path/to/mapFolding
+```
+
+## Install updates
+
+```sh
+pip install --upgrade mapFolding@git+https://github.com/hunterhogan/mapFolding.git
+```
+
+## Creating a virtual environment before installation
+
+You can isolate `mapFolding` in a virtual environment. For example, use the following commands to create a directory for the virtual environment, activate the virtual environment, and install the package. In the future, you will likely need to activate the virtual environment before using `mapFolding` again. From the command line, in a directory you want to install in.
+
+```sh
+py -m venv mapFolding
+cd mapFolding
+cd Scripts
+activate
+cd ..
+pip install mapFolding@git+https://github.com/hunterhogan/mapFolding.git
+```

mapfolding-0.2.0/README.md

@@ -0,0 +1,145 @@
+# Algorithm(s) for counting distinct ways to fold a map (or a strip of stamps)
+
+`mapFolding.countFolds()` will accept arbitrary values for the map's dimensions.
+
+```python
+from mapFolding import countFolds
+foldsTotal = countFolds( [2,10] )
+```
+
+The directory `mapFolding/reference` has
+
+- a verbatim transcription of the "procedure" published in _The Computer Journal_,
+- multiple referential versions of the procedure with explanatory comments including
+- `hunterNumba.py` a one-size-fits-all, self-contained, reasonably fast, contemporary algorithm that is nevertheless infected by _noobaceae ignorancium_, and
+- miscellaneous notes.
+
+[![Python Tests](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml/badge.svg)](https://github.com/hunterhogan/mapFolding/actions/workflows/unittests.yml)
+
+## Simple, easy usage based on OEIS IDs
+
+`mapFolding` directly implements some IDs from _The On-Line Encyclopedia of Integer Sequences_.
+
+### Usage: command line
+
+After installing (see below), `OEIS_for_n` will run a computation from the command line.
+
+```cmd
+(mapFolding) C:\apps\mapFolding> OEIS_for_n A001418 5
+186086600 distinct folding patterns.
+Time elapsed: 1.605 seconds
+```
+
+Use `getOEISids` to get the most up-to-date list of available OEIS IDs.
+
+```cmd
+(mapFolding) C:\apps\mapFolding> getOEISids
+
+Available OEIS sequences:
+  A001415: Number of ways of folding a 2 X n strip of stamps.
+  A001416: Number of ways of folding a 3 X n strip of stamps.
+  A001417: Number of ways of folding a 2 X 2 X ... X 2 n-dimensional map.
+  A001418: Number of ways of folding an n X n sheet of stamps.
+  A195646: Number of ways of folding a 3 X 3 X ... X 3 n-dimensional map.
+
+Usage examples:
+  Command line:
+    OEIS_for_n A001415 8
+  Python:
+    from mapFolding import oeisIDfor_n
+    foldsTotal = oeisIDfor_n('A001415', 8)
+```
+
+### Usage: Python module or REPL
+
+Use `mapFolding.oeisIDfor_n()` to compute a(n) for an OEIS ID.
+
+```python
+from mapFolding import oeisIDfor_n
+foldsTotal = oeisIDfor_n( 'A001418', 4 )
+```
+
+### An "advanced" and likely unnecessary feature: clear `mapFolding`'s cache of OEIS data
+
+Clear _The On-Line Encyclopedia of Integer Sequences_ data from the `mapFolding` cache:
+
+```sh
+(mapFolding) C:\apps\mapFolding> clearOEIScache
+Cache cleared from C:\apps\mapFolding\mapFolding\.cache
+```
+
+## Connections to "Multi-dimensional map-folding" by W. F. Lunnon
+
+### The typo-laden algorithm published in 1971
+
+The full paper, W. F. Lunnon, Multi-dimensional map-folding, _The Computer Journal_, Volume 14, Issue 1, 1971, Pages 75–80, [https://doi.org/10.1093/comjnl/14.1.75](https://doi.org/10.1093/comjnl/14.1.75) ([BibTex](mapFolding/citations/Lunnon.bibtex) citation) is available at the DOI link. (As of 3 January 2025, the paper is a PDF of images, not text, and can be accessed without cost or login.)
+
+In [`foldings.txt`](mapFolding/reference/foldings.txt), you can find a text transcription of the algorithm as it was printed in 1971. In [`foldings.AA`](mapFolding/reference/foldings.AA), I have corrected obvious transcription errors, documented with comments, and I have reformatted line breaks and indentation. For contemporary readers, the result is likely easier to read than the text transcription or the original paper are easy to read. This is especially true if you view the document with semantic highlighting, such as with [Algol 60 syntax highlighter](https://github.com/PolariTOON/language-algol60).
+
+### Java implementation(s) and improvements
+
+[archmageirvine](https://github.com/archmageirvine/joeis/blob/80e3e844b11f149704acbab520bc3a3a25ac34ff/src/irvine/oeis/a001/A001415.java) ([BibTex](mapFolding/citations/jOEIS.bibtex) citation) says about the Java code:
+
+```java
+/**
+ * A001415 Number of ways of folding a 2 X n strip of stamps.
+ * @author Fred Lunnon (ALGOL68, C versions)
+ * @author Sean A. Irvine (Java port)
+ */
+...
+  // Implements algorithm as described in "Multi-dimensional map-folding",
+  // by W. F. Lunnon, The Computer J, 14, 1, pp. 75--80.  Note the original
+  // paper contains a few omissions, so this actual code is based on a C
+  // implementation by Fred Lunnon.
+```
+
+## Map-folding Video
+
+~~This caused my neurosis:~~ I enjoyed the following video, which is what introduced me to map folding.
+
+"How Many Ways Can You Fold a Map?" by Physics for the Birds, 2024 November 13 ([BibTex](mapFolding/citations/Physics_for_the_Birds.bibtex) citation)
+
+[![How Many Ways Can You Fold a Map?](https://i.ytimg.com/vi/sfH9uIY3ln4/hq720.jpg)](https://www.youtube.com/watch?v=sfH9uIY3ln4)
+
+## Install this package
+
+### From Github
+
+```sh
+pip install mapFolding@git+https://github.com/hunterhogan/mapFolding.git
+```
+
+### From a local directory
+
+#### Windows
+
+```powershell
+git clone https://github.com/hunterhogan/mapFolding.git \path\to\mapFolding
+pip install mapFolding@file:\path\to\mapFolding
+```
+
+#### POSIX
+
+```bash
+git clone https://github.com/hunterhogan/mapFolding.git /path/to/mapFolding
+pip install mapFolding@file:/path/to/mapFolding
+```
+
+## Install updates
+
+```sh
+pip install --upgrade mapFolding@git+https://github.com/hunterhogan/mapFolding.git
+```
+
+## Creating a virtual environment before installation
+
+You can isolate `mapFolding` in a virtual environment. For example, use the following commands to create a directory for the virtual environment, activate the virtual environment, and install the package. In the future, you will likely need to activate the virtual environment before using `mapFolding` again. From the command line, in a directory you want to install in.
+
+```sh
+py -m venv mapFolding
+cd mapFolding
+cd Scripts
+activate
+cd ..
+pip install mapFolding@git+https://github.com/hunterhogan/mapFolding.git
+```

mapfolding-0.2.0/mapFolding/JAX/lunnanJAX.py

@@ -0,0 +1,206 @@
+from mapFolding import validateListDimensions, getLeavesTotal, makeConnectionGraph
+from typing import List, Tuple
+import jax
+import jaxtyping
+
+dtypeDefault = jax.numpy.uint32
+dtypeMaximum = jax.numpy.uint32
+
+def countFolds(listDimensions: List[int]) -> int:
+    listDimensionsPositive: List[int] = validateListDimensions(listDimensions)
+
+    n: int = getLeavesTotal(listDimensionsPositive)
+    d: int = len(listDimensions)
+    import numpy
+    D: numpy.ndarray = makeConnectionGraph(listDimensionsPositive)
+    connectionGraph = jax.numpy.asarray(D, dtype=dtypeDefault)
+    del listDimensionsPositive
+
+    return foldingsJAX(n, d, connectionGraph)
+
+def foldingsJAX(leavesTotal: jaxtyping.UInt32, dimensionsTotal: jaxtyping.UInt32, connectionGraph: jaxtyping.Array) -> jaxtyping.UInt32:
+
+    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.uint32)
+
+        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]):
+                    countGapsCountDimensionsGapped, countGapsPotentialGaps, countGapsGap1ndexLowerBound, countGapsLeaf1ndexConnectee = countGapsDoValues
+
+                    countGapsPotentialGaps = countGapsPotentialGaps.at[countGapsGap1ndexLowerBound].set(countGapsLeaf1ndexConnectee)
+                    countGapsGap1ndexLowerBound = jax.numpy.where(jax.numpy.equal(countGapsCountDimensionsGapped[countGapsLeaf1ndexConnectee], 0), countGapsGap1ndexLowerBound + 1, countGapsGap1ndexLowerBound)
+                    countGapsCountDimensionsGapped = countGapsCountDimensionsGapped.at[countGapsLeaf1ndexConnectee].add(1)
+                    countGapsLeaf1ndexConnectee = connectionGraph.at[dimensionNumber, activeLeaf1ndex, leafBelow.at[countGapsLeaf1ndexConnectee].get()].get().astype(jax.numpy.uint32)
+
+                    return (countGapsCountDimensionsGapped, countGapsPotentialGaps, countGapsGap1ndexLowerBound, countGapsLeaf1ndexConnectee)
+
+                unconstrained_countDimensionsGapped, unconstrained_gapsWhere, unconstrained_gap1ndexCeiling, unconstrained_unconstrainedLeaf = unconstrainedValues
+
+                leaf1ndexConnectee = connectionGraph.at[dimensionNumber, activeLeaf1ndex, activeLeaf1ndex].get().astype(jax.numpy.uint32)
+
+                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.uint32)
+            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.uint32(0)
+        dimension1ndex = jax.numpy.uint32(1)
+        gap1ndexCeiling = gapRangeStart.at[activeLeaf1ndex - 1].get().astype(jax.numpy.uint32)
+        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.uint32(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)
+
+    foldingsTotal = jax.numpy.uint32(0)
+    l = jax.numpy.uint32(1)
+    g = jax.numpy.uint32(0)
+
+    foldingsValues = (A, B, count, gapter, gap, foldingsTotal, l, g)
+    foldingsValues = jax.lax.while_loop(while_activeLeaf1ndex_greaterThan_0, countFoldings, foldingsValues)
+    return foldingsValues[5]
+
+foldingsJAX = jax.jit(foldingsJAX, static_argnums=(0, 1))