@turing-machine-js/library-binary-numbers 6.4.0 → 7.0.0-alpha.2

package/dist/index.cjs

@@ -72,11 +72,11 @@ const goToNumbersStart = new machine.State({
         },
     },
 }, 'goToNumberStart');
-// deleteNumber — 5 nodes
+// deleteNumber — 4 nodes
 //
 // Composition: go to the number's '^', then sweep right erasing every cell
 // (digits, '^', '$') until the number is gone. Implemented as
-// goToNumbersStart.withOverrodeHaltState(deleteNumberInternal): when
+// goToNumbersStart.withOverriddenHaltState(deleteNumberInternal): when
 // goToNumbersStart would halt at '^', it falls through to the eraser instead.
 const deleteNumberInternal = new machine.State({
     [symbol('$')]: {
@@ -94,16 +94,16 @@ const deleteNumberInternal = new machine.State({
 }, 'deleteNumberInternal');
 const deleteNumber = new machine.State({
     [symbol('^10$')]: {
-        nextState: goToNumbersStart.withOverrodeHaltState(deleteNumberInternal),
+        nextState: goToNumbersStart.withOverriddenHaltState(deleteNumberInternal),
     },
     [machine.ifOtherSymbol]: {
         nextState: machine.haltState,
     },
 }, 'deleteNumber');
-// invertNumber — 5 nodes
+// invertNumber — 4 nodes
 //
 // Composition: go to '^', then sweep right flipping each bit until '$'.
-// Same shape as deleteNumber (goToNumbersStart.withOverrodeHaltState(...)) but
+// Same shape as deleteNumber (goToNumbersStart.withOverriddenHaltState(...)) but
 // the inner state writes the complement instead of erasing.
 const invertNumberGoToNumberWithInversion = new machine.State({
     [symbol('^')]: {
@@ -129,13 +129,13 @@ const invertNumberGoToNumberWithInversion = new machine.State({
 }, 'invertNumberGoToNumberWithInversion');
 const invertNumber = new machine.State({
     [symbol('^10$')]: {
-        nextState: goToNumbersStart.withOverrodeHaltState(invertNumberGoToNumberWithInversion),
+        nextState: goToNumbersStart.withOverriddenHaltState(invertNumberGoToNumberWithInversion),
     },
     [machine.ifOtherSymbol]: {
         nextState: machine.haltState,
     },
 }, 'invertNumber');
-// normalizeNumber — 7 nodes
+// normalizeNumber — 6 nodes
 //
 // Strips leading zeros by erasing them and re-planting '^' just before the first
 // '1' (or before '$' if the entire number was zero — preserving "0" as "^$").
@@ -165,7 +165,7 @@ const normalizeNumberMoveNumberStart = new machine.State({
 }, 'normalizeNumberMoveNumberStart');
 const normalizeNumber = new machine.State({
     [symbol('^10$')]: {
-        nextState: goToNumbersStart.withOverrodeHaltState(normalizeNumberMoveNumberStart),
+        nextState: goToNumbersStart.withOverriddenHaltState(normalizeNumberMoveNumberStart),
     },
     [machine.ifOtherSymbol]: {
         nextState: machine.haltState,
@@ -244,16 +244,18 @@ const plusOne = new machine.State({
         nextState: machine.haltState,
     },
 }, 'plusOne');
-// minusOne — 17 nodes (the largest in this library)
+// minusOne — 15 nodes (the largest in this library, per `summarize().stateCount`)
 //
 // Computes x − 1 via the two's-complement identity:  x − 1 == ~(~x + 1)
 // (every step is a state we already have), composed with three nested
-// withOverrodeHaltState calls to chain invert → plusOne → invert → normalize.
+// withOverriddenHaltState calls to chain invert → plusOne → invert → normalize.
+// The chain has 4 state names but 3 wrapper hops — `normalizeNumber` at the
+// inner end is the terminal override target, not another wrapper level.
 //
 // This is *deliberately* the heavy version. It exists side-by-side with
-// minusOneFast (10 nodes, direct borrow) to make the cost of "compose existing
+// minusOneFast (8 nodes, direct borrow) to make the cost of "compose existing
 // pieces" vs "write a dedicated algorithm" visible. See ../states.md for the
-// dotted onHalt edges that show the four-deep subroutine chain.
+// dotted onHalt edges that show the three-deep wrapper chain.
 const minusOne = new machine.State({
     [symbol('^10')]: {
         command: {
@@ -262,15 +264,15 @@ const minusOne = new machine.State({
     },
     [symbol('$')]: {
         nextState: invertNumber
-            .withOverrodeHaltState(plusOne
-            .withOverrodeHaltState(invertNumber
-            .withOverrodeHaltState(normalizeNumber))),
+            .withOverriddenHaltState(plusOne
+            .withOverriddenHaltState(invertNumber
+            .withOverriddenHaltState(normalizeNumber))),
     },
     [machine.ifOtherSymbol]: {
         nextState: machine.haltState,
     },
 }, 'minusOne');
-// minusOneFast — 10 nodes (direct borrow propagation)
+// minusOneFast — 8 nodes (direct borrow propagation)
 //
 // Walks left from the LSB: 0→1 keeps borrowing; 1→0 stops; ^ is underflow.
 // Falls through to normalizeNumber to strip the leading zero introduced when the
@@ -278,7 +280,7 @@ const minusOne = new machine.State({
 //
 // Same algorithm as minusOne in @turing-machine-js/library-binary-numbers-bare
 // (which is 3 nodes there). The extra 7 nodes here are the cost of: scanning
-// past '^' on entry, the goToNumberStart path and its withOverrodeHaltState
+// past '^' on entry, the goToNumberStart path and its withOverriddenHaltState
 // wrapper for normalize, and normalizeNumber's own marker-relocation chain.
 const minusOneFastBorrow = new machine.State({
     [symbol('1')]: {
@@ -307,7 +309,7 @@ const minusOneFast = new machine.State({
         command: {
             movement: machine.movements.left,
         },
-        nextState: minusOneFastBorrow.withOverrodeHaltState(normalizeNumber),
+        nextState: minusOneFastBorrow.withOverriddenHaltState(normalizeNumber),
     },
     [machine.ifOtherSymbol]: {
         nextState: machine.haltState,

package/dist/index.mjs

@@ -70,11 +70,11 @@ const goToNumbersStart = new State({
         },
     },
 }, 'goToNumberStart');
-// deleteNumber — 5 nodes
+// deleteNumber — 4 nodes
 //
 // Composition: go to the number's '^', then sweep right erasing every cell
 // (digits, '^', '$') until the number is gone. Implemented as
-// goToNumbersStart.withOverrodeHaltState(deleteNumberInternal): when
+// goToNumbersStart.withOverriddenHaltState(deleteNumberInternal): when
 // goToNumbersStart would halt at '^', it falls through to the eraser instead.
 const deleteNumberInternal = new State({
     [symbol('$')]: {
@@ -92,16 +92,16 @@ const deleteNumberInternal = new State({
 }, 'deleteNumberInternal');
 const deleteNumber = new State({
     [symbol('^10$')]: {
-        nextState: goToNumbersStart.withOverrodeHaltState(deleteNumberInternal),
+        nextState: goToNumbersStart.withOverriddenHaltState(deleteNumberInternal),
     },
     [ifOtherSymbol]: {
         nextState: haltState,
     },
 }, 'deleteNumber');
-// invertNumber — 5 nodes
+// invertNumber — 4 nodes
 //
 // Composition: go to '^', then sweep right flipping each bit until '$'.
-// Same shape as deleteNumber (goToNumbersStart.withOverrodeHaltState(...)) but
+// Same shape as deleteNumber (goToNumbersStart.withOverriddenHaltState(...)) but
 // the inner state writes the complement instead of erasing.
 const invertNumberGoToNumberWithInversion = new State({
     [symbol('^')]: {
@@ -127,13 +127,13 @@ const invertNumberGoToNumberWithInversion = new State({
 }, 'invertNumberGoToNumberWithInversion');
 const invertNumber = new State({
     [symbol('^10$')]: {
-        nextState: goToNumbersStart.withOverrodeHaltState(invertNumberGoToNumberWithInversion),
+        nextState: goToNumbersStart.withOverriddenHaltState(invertNumberGoToNumberWithInversion),
     },
     [ifOtherSymbol]: {
         nextState: haltState,
     },
 }, 'invertNumber');
-// normalizeNumber — 7 nodes
+// normalizeNumber — 6 nodes
 //
 // Strips leading zeros by erasing them and re-planting '^' just before the first
 // '1' (or before '$' if the entire number was zero — preserving "0" as "^$").
@@ -163,7 +163,7 @@ const normalizeNumberMoveNumberStart = new State({
 }, 'normalizeNumberMoveNumberStart');
 const normalizeNumber = new State({
     [symbol('^10$')]: {
-        nextState: goToNumbersStart.withOverrodeHaltState(normalizeNumberMoveNumberStart),
+        nextState: goToNumbersStart.withOverriddenHaltState(normalizeNumberMoveNumberStart),
     },
     [ifOtherSymbol]: {
         nextState: haltState,
@@ -242,16 +242,18 @@ const plusOne = new State({
         nextState: haltState,
     },
 }, 'plusOne');
-// minusOne — 17 nodes (the largest in this library)
+// minusOne — 15 nodes (the largest in this library, per `summarize().stateCount`)
 //
 // Computes x − 1 via the two's-complement identity:  x − 1 == ~(~x + 1)
 // (every step is a state we already have), composed with three nested
-// withOverrodeHaltState calls to chain invert → plusOne → invert → normalize.
+// withOverriddenHaltState calls to chain invert → plusOne → invert → normalize.
+// The chain has 4 state names but 3 wrapper hops — `normalizeNumber` at the
+// inner end is the terminal override target, not another wrapper level.
 //
 // This is *deliberately* the heavy version. It exists side-by-side with
-// minusOneFast (10 nodes, direct borrow) to make the cost of "compose existing
+// minusOneFast (8 nodes, direct borrow) to make the cost of "compose existing
 // pieces" vs "write a dedicated algorithm" visible. See ../states.md for the
-// dotted onHalt edges that show the four-deep subroutine chain.
+// dotted onHalt edges that show the three-deep wrapper chain.
 const minusOne = new State({
     [symbol('^10')]: {
         command: {
@@ -260,15 +262,15 @@ const minusOne = new State({
     },
     [symbol('$')]: {
         nextState: invertNumber
-            .withOverrodeHaltState(plusOne
-            .withOverrodeHaltState(invertNumber
-            .withOverrodeHaltState(normalizeNumber))),
+            .withOverriddenHaltState(plusOne
+            .withOverriddenHaltState(invertNumber
+            .withOverriddenHaltState(normalizeNumber))),
     },
     [ifOtherSymbol]: {
         nextState: haltState,
     },
 }, 'minusOne');
-// minusOneFast — 10 nodes (direct borrow propagation)
+// minusOneFast — 8 nodes (direct borrow propagation)
 //
 // Walks left from the LSB: 0→1 keeps borrowing; 1→0 stops; ^ is underflow.
 // Falls through to normalizeNumber to strip the leading zero introduced when the
@@ -276,7 +278,7 @@ const minusOne = new State({
 //
 // Same algorithm as minusOne in @turing-machine-js/library-binary-numbers-bare
 // (which is 3 nodes there). The extra 7 nodes here are the cost of: scanning
-// past '^' on entry, the goToNumberStart path and its withOverrodeHaltState
+// past '^' on entry, the goToNumberStart path and its withOverriddenHaltState
 // wrapper for normalize, and normalizeNumber's own marker-relocation chain.
 const minusOneFastBorrow = new State({
     [symbol('1')]: {
@@ -305,7 +307,7 @@ const minusOneFast = new State({
         command: {
             movement: movements.left,
         },
-        nextState: minusOneFastBorrow.withOverrodeHaltState(normalizeNumber),
+        nextState: minusOneFastBorrow.withOverriddenHaltState(normalizeNumber),
     },
     [ifOtherSymbol]: {
         nextState: haltState,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turing-machine-js/library-binary-numbers",
-  "version": "6.4.0",
+  "version": "7.0.0-alpha.2",
   "description": "A standard library for working with binary numbers",
   "engines": {
     "npm": ">=7.0.0"
@@ -27,7 +27,7 @@
     "numbers"
   ],
   "peerDependencies": {
-    "@turing-machine-js/machine": "^6.0.0"
+    "@turing-machine-js/machine": "^7.0.0-alpha.2"
   },
   "scripts": {
     "build": "tsc --build --verbose tsconfig.build.json && node ../../scripts/build-node-entries.mjs --package=@turing-machine-js/library-binary-numbers",
@@ -44,5 +44,5 @@
       "default": "./dist/index.mjs"
     }
   },
-  "gitHead": "a8228b8a5f7f9acd1f6219af80db86368848cdbc"
+  "gitHead": "163c0f818365241bac2c2de5e489124056703d8b"
 }

package/states.md

@@ -2,139 +2,162 @@
 
 ## goToNumber
 
-*2 states (including `haltState`)*
+*2 states; 2 transitions; has cycles*
 
 ```mermaid
 flowchart TD
 %% alphabets: [[" ","^","$","0","1"]]
   s0(((halt)))
-  s1(("goToNumber"))
-  s1 -- "$ → ·/S" --> s0
-  s1 -- "* → ·/R" --> s1
+  s1["goToNumber"]
+  idle([idle])
+  idle -. enter .-> s1
+  s1 -- "['$'] → [K]/[S]" --> s0
+  s1 -- "[*] → [K]/[R]" --> s1
 ```
 
 ## goToNextNumber
 
-*3 states (including `haltState`)*
+*3 states; 3 transitions; has cycles*
 
 ```mermaid
 flowchart TD
 %% alphabets: [[" ","^","$","0","1"]]
   s0(((halt)))
   s1["goToNumber"]
-  s2(("goToNextNumber"))
-  s1 -- "$ → ·/S" --> s0
-  s1 -- "* → ·/R" --> s1
-  s2 -- "* → ·/R" --> s1
+  s2["goToNextNumber"]
+  idle([idle])
+  idle -. enter .-> s2
+  s1 -- "['$'] → [K]/[S]" --> s0
+  s1 -- "[*] → [K]/[R]" --> s1
+  s2 -- "[*] → [K]/[R]" --> s1
 ```
 
 ## goToPreviousNumber
 
-*3 states (including `haltState`)*
+*3 states; 3 transitions; has cycles*
 
 ```mermaid
 flowchart TD
 %% alphabets: [[" ","^","$","0","1"]]
   s0(((halt)))
   s3["goToPreviousNumberInternal"]
-  s4(("goToPreviousNumber"))
-  s3 -- "$ → ·/S" --> s0
-  s3 -- "* → ·/L" --> s3
-  s4 -- "* → ·/L" --> s3
+  s4["goToPreviousNumber"]
+  idle([idle])
+  idle -. enter .-> s4
+  s3 -- "['$'] → [K]/[S]" --> s0
+  s3 -- "[*] → [K]/[L]" --> s3
+  s4 -- "[*] → [K]/[L]" --> s3
 ```
 
 ## deleteNumber
 
-*5 states (including `haltState`)*
+*5 states; 6 transitions; 1 wrapper (max nesting depth 1); has cycles*
 
 ```mermaid
 flowchart TD
 %% alphabets: [[" ","^","$","0","1"]]
   s0(((halt)))
-  s5["goToNumberStart"]
   s6["deleteNumberInternal"]
-  s7["goToNumberStart>deleteNumberInternal"]
-  s8(("deleteNumber"))
-  s5 -- "^ → ·/S" --> s0
-  s5 -- "* → ·/L" --> s5
-  s6 -- "$ → ⌫/S" --> s0
-  s6 -- "* → ⌫/R" --> s6
-  s7 -- "^ → ·/S" --> s0
-  s7 -- "* → ·/L" --> s5
-  s7 -. onHalt .-> s6
-  s8 -- "^|1|0|$ → ·/S" --> s7
-  s8 -- "* → ·/S" --> s0
+  s8["deleteNumber"]
+  s7[["goToNumberStart(deleteNumberInternal)"]]
+  idle([idle])
+  subgraph w_5["callable subtree of goToNumberStart"]
+    s5["goToNumberStart"]
+    c5(((halt)))
+  end
+  idle -. enter .-> s8
+  s7 == "call" ==> s5
+  w_5 -. "return" .-> s7
+  s7 --> s6
+  s5 -- "['^'] → [K]/[S]" --> c5
+  s5 -- "[*] → [K]/[L]" --> s5
+  s6 -- "['$'] → [E]/[S]" --> s0
+  s6 -- "[*] → [E]/[R]" --> s6
+  s8 -- "['^']|['1']|['0']|['$'] → [K]/[S]" --> s7
+  s8 -- "[*] → [K]/[S]" --> s0
 ```
 
 ## goToNumbersStart
 
-*2 states (including `haltState`)*
+*2 states; 2 transitions; has cycles*
 
 ```mermaid
 flowchart TD
 %% alphabets: [[" ","^","$","0","1"]]
   s0(((halt)))
-  s5(("goToNumberStart"))
-  s5 -- "^ → ·/S" --> s0
-  s5 -- "* → ·/L" --> s5
+  s5["goToNumberStart"]
+  idle([idle])
+  idle -. enter .-> s5
+  s5 -- "['^'] → [K]/[S]" --> s0
+  s5 -- "[*] → [K]/[L]" --> s5
 ```
 
 ## invertNumber
 
-*5 states (including `haltState`)*
+*5 states; 8 transitions; 1 wrapper (max nesting depth 1); has cycles*
 
 ```mermaid
 flowchart TD
 %% alphabets: [[" ","^","$","0","1"]]
   s0(((halt)))
-  s5["goToNumberStart"]
   s9["invertNumberGoToNumberWithInversion"]
-  s10["goToNumberStart>invertNumberGoToNumberWithInversion"]
-  s11(("invertNumber"))
-  s5 -- "^ → ·/S" --> s0
-  s5 -- "* → ·/L" --> s5
-  s9 -- "^ → ·/R" --> s9
-  s9 -- "1 → 0/R" --> s9
-  s9 -- "0 → 1/R" --> s9
-  s9 -- "$ → ·/S" --> s0
-  s10 -- "^ → ·/S" --> s0
-  s10 -- "* → ·/L" --> s5
-  s10 -. onHalt .-> s9
-  s11 -- "^|1|0|$ → ·/S" --> s10
-  s11 -- "* → ·/S" --> s0
+  s11["invertNumber"]
+  s10[["goToNumberStart(invertNumberGoToNumberWithInversion)"]]
+  idle([idle])
+  subgraph w_5["callable subtree of goToNumberStart"]
+    s5["goToNumberStart"]
+    c5(((halt)))
+  end
+  idle -. enter .-> s11
+  s10 == "call" ==> s5
+  w_5 -. "return" .-> s10
+  s10 --> s9
+  s5 -- "['^'] → [K]/[S]" --> c5
+  s5 -- "[*] → [K]/[L]" --> s5
+  s9 -- "['^'] → [K]/[R]" --> s9
+  s9 -- "['1'] → ['0']/[R]" --> s9
+  s9 -- "['0'] → ['1']/[R]" --> s9
+  s9 -- "['$'] → [K]/[S]" --> s0
+  s11 -- "['^']|['1']|['0']|['$'] → [K]/[S]" --> s10
+  s11 -- "[*] → [K]/[S]" --> s0
 ```
 
 ## normalizeNumber
 
-*7 states (including `haltState`)*
+*7 states; 9 transitions; 1 wrapper (max nesting depth 1); has cycles*
 
 ```mermaid
 flowchart TD
 %% alphabets: [[" ","^","$","0","1"]]
   s0(((halt)))
   s1["goToNumber"]
-  s5["goToNumberStart"]
   s12["normalizeNumberPutNewStartSymbol"]
   s13["normalizeNumberMoveNumberStart"]
-  s14["goToNumberStart>normalizeNumberMoveNumberStart"]
-  s15(("normalizeNumber"))
-  s1 -- "$ → ·/S" --> s0
-  s1 -- "* → ·/R" --> s1
-  s5 -- "^ → ·/S" --> s0
-  s5 -- "* → ·/L" --> s5
-  s12 -- "- → ^/S" --> s1
-  s13 -- "^|0 → ⌫/R" --> s13
-  s13 -- "1|$ → ·/L" --> s12
-  s14 -- "^ → ·/S" --> s0
-  s14 -- "* → ·/L" --> s5
-  s14 -. onHalt .-> s13
-  s15 -- "^|1|0|$ → ·/S" --> s14
-  s15 -- "* → ·/S" --> s0
+  s15["normalizeNumber"]
+  s14[["goToNumberStart(normalizeNumberMoveNumberStart)"]]
+  idle([idle])
+  subgraph w_5["callable subtree of goToNumberStart"]
+    s5["goToNumberStart"]
+    c5(((halt)))
+  end
+  idle -. enter .-> s15
+  s14 == "call" ==> s5
+  w_5 -. "return" .-> s14
+  s14 --> s13
+  s1 -- "['$'] → [K]/[S]" --> s0
+  s1 -- "[*] → [K]/[R]" --> s1
+  s5 -- "['^'] → [K]/[S]" --> c5
+  s5 -- "[*] → [K]/[L]" --> s5
+  s12 -- "[B] → ['^']/[S]" --> s1
+  s13 -- "['^']|['0'] → [E]/[R]" --> s13
+  s13 -- "['1']|['$'] → [K]/[L]" --> s12
+  s15 -- "['^']|['1']|['0']|['$'] → [K]/[S]" --> s14
+  s15 -- "[*] → [K]/[S]" --> s0
 ```
 
 ## plusOne
 
-*5 states (including `haltState`)*
+*5 states; 10 transitions; has cycles*
 
 ```mermaid
 flowchart TD
@@ -143,124 +166,142 @@ flowchart TD
   s16["plusOneFillZeros"]
   s17["plusOneAddNumberStart"]
   s18["plusOneCaryOne"]
-  s19(("plusOne"))
-  s16 -- "1 → 0/R" --> s16
-  s16 -- "$ → ·/S" --> s0
-  s17 -- "- → ^/R" --> s17
-  s17 -- "1 → ·/R" --> s16
-  s18 -- "0 → 1/R" --> s16
-  s18 -- "1 → ·/L" --> s18
-  s18 -- "^ → 1/L" --> s17
-  s19 -- "^|1|0 → ·/R" --> s19
-  s19 -- "$ → ·/L" --> s18
-  s19 -- "* → ·/S" --> s0
+  s19["plusOne"]
+  idle([idle])
+  idle -. enter .-> s19
+  s16 -- "['1'] → ['0']/[R]" --> s16
+  s16 -- "['$'] → [K]/[S]" --> s0
+  s17 -- "[B] → ['^']/[R]" --> s17
+  s17 -- "['1'] → [K]/[R]" --> s16
+  s18 -- "['0'] → ['1']/[R]" --> s16
+  s18 -- "['1'] → [K]/[L]" --> s18
+  s18 -- "['^'] → ['1']/[L]" --> s17
+  s19 -- "['^']|['1']|['0'] → [K]/[R]" --> s19
+  s19 -- "['$'] → [K]/[L]" --> s18
+  s19 -- "[*] → [K]/[S]" --> s0
 ```
 
 ## minusOne
 
-*17 states (including `haltState`)*
+*18 states; 28 transitions; 5 wrappers (max nesting depth 3); has cycles*
 
 ```mermaid
 flowchart TD
 %% alphabets: [[" ","^","$","0","1"]]
   s0(((halt)))
   s1["goToNumber"]
-  s5["goToNumberStart"]
   s9["invertNumberGoToNumberWithInversion"]
-  s10["goToNumberStart>invertNumberGoToNumberWithInversion"]
   s12["normalizeNumberPutNewStartSymbol"]
   s13["normalizeNumberMoveNumberStart"]
-  s14["goToNumberStart>normalizeNumberMoveNumberStart"]
   s15["normalizeNumber"]
-  s16["plusOneFillZeros"]
-  s17["plusOneAddNumberStart"]
-  s18["plusOneCaryOne"]
-  s19["plusOne"]
-  s20["invertNumber>normalizeNumber"]
-  s21["plusOne>invertNumber>normalizeNumber"]
-  s22["invertNumber>plusOne>invertNumber>normalizeNumber"]
-  s23(("minusOne"))
-  s1 -- "$ → ·/S" --> s0
-  s1 -- "* → ·/R" --> s1
-  s5 -- "^ → ·/S" --> s0
-  s5 -- "* → ·/L" --> s5
-  s9 -- "^ → ·/R" --> s9
-  s9 -- "1 → 0/R" --> s9
-  s9 -- "0 → 1/R" --> s9
-  s9 -- "$ → ·/S" --> s0
-  s10 -- "^ → ·/S" --> s0
-  s10 -- "* → ·/L" --> s5
-  s10 -. onHalt .-> s9
-  s12 -- "- → ^/S" --> s1
-  s13 -- "^|0 → ⌫/R" --> s13
-  s13 -- "1|$ → ·/L" --> s12
-  s14 -- "^ → ·/S" --> s0
-  s14 -- "* → ·/L" --> s5
-  s14 -. onHalt .-> s13
-  s15 -- "^|1|0|$ → ·/S" --> s14
-  s15 -- "* → ·/S" --> s0
-  s16 -- "1 → 0/R" --> s16
-  s16 -- "$ → ·/S" --> s0
-  s17 -- "- → ^/R" --> s17
-  s17 -- "1 → ·/R" --> s16
-  s18 -- "0 → 1/R" --> s16
-  s18 -- "1 → ·/L" --> s18
-  s18 -- "^ → 1/L" --> s17
-  s19 -- "^|1|0 → ·/R" --> s19
-  s19 -- "$ → ·/L" --> s18
-  s19 -- "* → ·/S" --> s0
-  s20 -- "^|1|0|$ → ·/S" --> s10
-  s20 -- "* → ·/S" --> s0
-  s20 -. onHalt .-> s15
-  s21 -- "^|1|0 → ·/R" --> s19
-  s21 -- "$ → ·/L" --> s18
-  s21 -- "* → ·/S" --> s0
-  s21 -. onHalt .-> s20
-  s22 -- "^|1|0|$ → ·/S" --> s10
-  s22 -- "* → ·/S" --> s0
-  s22 -. onHalt .-> s21
-  s23 -- "^|1|0 → ·/R" --> s23
-  s23 -- "$ → ·/S" --> s22
-  s23 -- "* → ·/S" --> s0
+  s23["minusOne"]
+  s10[["goToNumberStart(invertNumberGoToNumberWithInversion)"]]
+  s14[["goToNumberStart(normalizeNumberMoveNumberStart)"]]
+  s20[["invertNumber(normalizeNumber)"]]
+  s21[["plusOne(invertNumber(normalizeNumber))"]]
+  s22[["invertNumber(plusOne(invertNumber(normalizeNumber)))"]]
+  idle([idle])
+  subgraph w_5["callable subtree of goToNumberStart"]
+    s5["goToNumberStart"]
+    c5(((halt)))
+  end
+  subgraph w_11["callable subtree of invertNumber"]
+    s11["invertNumber"]
+    c11(((halt)))
+  end
+  subgraph w_19["callable subtree of plusOne"]
+    s16["plusOneFillZeros"]
+    s17["plusOneAddNumberStart"]
+    s18["plusOneCaryOne"]
+    s19["plusOne"]
+    c19(((halt)))
+  end
+  idle -. enter .-> s23
+  s10 & s14 == "call" ==> s5
+  s20 & s22 == "call" ==> s11
+  s21 == "call" ==> s19
+  w_5 -. "return" .-> s10 & s14
+  w_11 -. "return" .-> s20 & s22
+  w_19 -. "return" .-> s21
+  s10 --> s9
+  s14 --> s13
+  s20 --> s15
+  s21 --> s20
+  s22 --> s21
+  s1 -- "['$'] → [K]/[S]" --> s0
+  s1 -- "[*] → [K]/[R]" --> s1
+  s5 -- "['^'] → [K]/[S]" --> c5
+  s5 -- "[*] → [K]/[L]" --> s5
+  s9 -- "['^'] → [K]/[R]" --> s9
+  s9 -- "['1'] → ['0']/[R]" --> s9
+  s9 -- "['0'] → ['1']/[R]" --> s9
+  s9 -- "['$'] → [K]/[S]" --> s0
+  s11 -- "['^']|['1']|['0']|['$'] → [K]/[S]" --> s10
+  s11 -- "[*] → [K]/[S]" --> c11
+  s12 -- "[B] → ['^']/[S]" --> s1
+  s13 -- "['^']|['0'] → [E]/[R]" --> s13
+  s13 -- "['1']|['$'] → [K]/[L]" --> s12
+  s15 -- "['^']|['1']|['0']|['$'] → [K]/[S]" --> s14
+  s15 -- "[*] → [K]/[S]" --> s0
+  s16 -- "['1'] → ['0']/[R]" --> s16
+  s16 -- "['$'] → [K]/[S]" --> c19
+  s17 -- "[B] → ['^']/[R]" --> s17
+  s17 -- "['1'] → [K]/[R]" --> s16
+  s18 -- "['0'] → ['1']/[R]" --> s16
+  s18 -- "['1'] → [K]/[L]" --> s18
+  s18 -- "['^'] → ['1']/[L]" --> s17
+  s19 -- "['^']|['1']|['0'] → [K]/[R]" --> s19
+  s19 -- "['$'] → [K]/[L]" --> s18
+  s19 -- "[*] → [K]/[S]" --> c19
+  s23 -- "['^']|['1']|['0'] → [K]/[R]" --> s23
+  s23 -- "['$'] → [K]/[S]" --> s22
+  s23 -- "[*] → [K]/[S]" --> s0
 ```
 
 ## minusOneFast
 
-*10 states (including `haltState`)*
+*10 states; 15 transitions; 2 wrappers (max nesting depth 1); has cycles*
 
 ```mermaid
 flowchart TD
 %% alphabets: [[" ","^","$","0","1"]]
   s0(((halt)))
   s1["goToNumber"]
-  s5["goToNumberStart"]
   s12["normalizeNumberPutNewStartSymbol"]
   s13["normalizeNumberMoveNumberStart"]
-  s14["goToNumberStart>normalizeNumberMoveNumberStart"]
   s15["normalizeNumber"]
-  s24["minusOneFastBorrow"]
-  s25["minusOneFastBorrow>normalizeNumber"]
-  s26(("minusOneFast"))
-  s1 -- "$ → ·/S" --> s0
-  s1 -- "* → ·/R" --> s1
-  s5 -- "^ → ·/S" --> s0
-  s5 -- "* → ·/L" --> s5
-  s12 -- "- → ^/S" --> s1
-  s13 -- "^|0 → ⌫/R" --> s13
-  s13 -- "1|$ → ·/L" --> s12
-  s14 -- "^ → ·/S" --> s0
-  s14 -- "* → ·/L" --> s5
-  s14 -. onHalt .-> s13
-  s15 -- "^|1|0|$ → ·/S" --> s14
-  s15 -- "* → ·/S" --> s0
-  s24 -- "1 → 0/S" --> s0
-  s24 -- "0 → 1/L" --> s24
-  s24 -- "^ → ·/S" --> s0
-  s25 -- "1 → 0/S" --> s0
-  s25 -- "0 → 1/L" --> s24
-  s25 -- "^ → ·/S" --> s0
-  s25 -. onHalt .-> s15
-  s26 -- "^|1|0 → ·/R" --> s26
-  s26 -- "$ → ·/L" --> s25
-  s26 -- "* → ·/S" --> s0
+  s26["minusOneFast"]
+  s14[["goToNumberStart(normalizeNumberMoveNumberStart)"]]
+  s25[["minusOneFastBorrow(normalizeNumber)"]]
+  idle([idle])
+  subgraph w_5["callable subtree of goToNumberStart"]
+    s5["goToNumberStart"]
+    c5(((halt)))
+  end
+  subgraph w_24["callable subtree of minusOneFastBorrow"]
+    s24["minusOneFastBorrow"]
+    c24(((halt)))
+  end
+  idle -. enter .-> s26
+  s14 == "call" ==> s5
+  s25 == "call" ==> s24
+  w_5 -. "return" .-> s14
+  w_24 -. "return" .-> s25
+  s14 --> s13
+  s25 --> s15
+  s1 -- "['$'] → [K]/[S]" --> s0
+  s1 -- "[*] → [K]/[R]" --> s1
+  s5 -- "['^'] → [K]/[S]" --> c5
+  s5 -- "[*] → [K]/[L]" --> s5
+  s12 -- "[B] → ['^']/[S]" --> s1
+  s13 -- "['^']|['0'] → [E]/[R]" --> s13
+  s13 -- "['1']|['$'] → [K]/[L]" --> s12
+  s15 -- "['^']|['1']|['0']|['$'] → [K]/[S]" --> s14
+  s15 -- "[*] → [K]/[S]" --> s0
+  s24 -- "['1'] → ['0']/[S]" --> c24
+  s24 -- "['0'] → ['1']/[L]" --> s24
+  s24 -- "['^'] → [K]/[S]" --> c24
+  s26 -- "['^']|['1']|['0'] → [K]/[R]" --> s26
+  s26 -- "['$'] → [K]/[L]" --> s25
+  s26 -- "[*] → [K]/[S]" --> s0
 ```