hclang 0.48.0 → 0.49.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -699,8 +699,8 @@ export const HC_SOURCES = new Map([
699
699
  "Sizes; schemas retain their description/alternative quantities. Other opaque",
700
700
  "values have Size 1. `.###` alternates child Sizes on non-schema lists, or returns",
701
701
  "Count parity (`.# mod 2`) on every other value with a Count; schemas have nil",
702
- "residual, and `<>` observes as `[]`. `.####` derives a Demi, an instance of",
703
- "the class in `hc/demi.hc`, which keeps the source's whole Count, returning nil at",
702
+ "residual, and `<>` observes as `[]`. `.####` derives a Denum, an instance of",
703
+ "the class in `hc/denum.hc`, which keeps the source's whole Count, returning nil at",
704
704
  "zero Count or nil residual and propagating failed observations.",
705
705
  "```",
706
706
  "; [.meta 1; 2, 3] .#",
@@ -1637,7 +1637,7 @@ export const HC_SOURCES = new Map([
1637
1637
  [
1638
1638
  "#!/usr/bin/env hc",
1639
1639
  "```",
1640
- "Demi constructed physical state: VACT witness and scope (Explore 022.06)",
1640
+ "Denum constructed physical state: VACT witness and scope (Explore 022.06)",
1641
1641
  "",
1642
1642
  "Implements the corrected handoff in occurrence/explore 022.05a, pinned at",
1643
1643
  "9d966bd95a783849c0363d82ee295586e0ffc6db581815b443140d746843eec8:",
@@ -1663,7 +1663,7 @@ export const HC_SOURCES = new Map([
1663
1663
  "read such a host; it is outside the closed Inlay construction family. No declared hash methods, declared parents, cycles, or arbitrary",
1664
1664
  "property-editing operations are in the uniform contract. This is a domain for",
1665
1665
  "this construction/observation experiment, not a special ontology of pure Figures.",
1666
- "Other finite Frames can have Demi readings; their constructor laws require their",
1666
+ "Other finite Frames can have Denum readings; their constructor laws require their",
1667
1667
  "own domain checks. In particular, mixed-array append is illustrated below but",
1668
1668
  "mixed-array Star is outside this contract.",
1669
1669
  "",
@@ -1673,14 +1673,14 @@ export const HC_SOURCES = new Map([
1673
1673
  "children, starting +. Properties do not enter these sums. D(X) = X.#### is",
1674
1674
  "nil for the empty host; otherwise it has Count n, loads L = (S+A)/2, R = (S-A)/2",
1675
1675
  "and phase p = 2 for even n (left next), 1 for odd n (right next). Read these",
1676
- "with `.count` (or `.#`), `.left`, `.right`, `.phase`. n is kept whole (007.25c);",
1676
+ "with `.count` (or `.#`), `.left ()`, `.right ()`, `.phase ()`. n is kept whole (007.25c);",
1677
1677
  "the phase is its parity. Nesting, identities, properties and the distribution",
1678
1678
  "within each load are forgotten.",
1679
1679
  "```",
1680
1680
  "; .E []; .X [[], [[], []], []];",
1681
1681
  "; [E.#, E.##, E.###, E.####]",
1682
1682
  "# [0, 1, 0, ()]",
1683
- "; [X.#, X.##, X.###, X.####.phase, X.####.left, X.####.right]",
1683
+ "; [X.#, X.##, X.###, X.####.phase (), X.####.left (), X.####.right ()]",
1684
1684
  "# [3, 4, 0, 1, 2, 2]",
1685
1685
  "; .decorated [.label 99; [], [[], []], []];",
1686
1686
  "; [decorated.#### = X.####, decorated.label, X.#### = X.####]",
@@ -1693,7 +1693,7 @@ export const HC_SOURCES = new Map([
1693
1693
  "```",
1694
1694
  "Generation and selective compression",
1695
1695
  "",
1696
- "No Demi is initialized when building X. The native reading derives from the",
1696
+ "No Denum is initialized when building X. The native reading derives from the",
1697
1697
  "constructed host. Equal readings can hide different nesting, while another",
1698
1698
  "construction gives a different reading. The reading keeps the Count, so two",
1699
1699
  "hosts with the same loads and phase but different Counts have different",
@@ -1703,10 +1703,10 @@ export const HC_SOURCES = new Map([
1703
1703
  "; [A = B, A.#### = B.####, A.#### === B.####]",
1704
1704
  "# [(), <>, ()]",
1705
1705
  "; .C [[[], []], [[], []]]; .F [[], [], [], []];",
1706
- "; [C.#, F.#, C = F, C.#### = F.####, C.####.left = F.####.left, C.####.right = F.####.right, C.####.phase = F.####.phase, A.#### = C.####]",
1706
+ "; [C.#, F.#, C = F, C.#### = F.####, (C.####.left ()) = (F.####.left ()), (C.####.right ()) = (F.####.right ()), (C.####.phase ()) = (F.####.phase ()), A.#### = C.####]",
1707
1707
  "# [2, 4, (), (), <>, <>, <>, ()]",
1708
1708
  "; [“” A.####, “” C.####, “” F.####, “” [[], [[], []]].####]",
1709
- "# [“Demi(1,1,0)”, “Demi(2,2,2)”, “Demi(4,2,2)”, “Demi(2,1,2)”]",
1709
+ "# [“Denum(1,1,0)”, “Denum(2,2,2)”, “Denum(4,2,2)”, “Denum(2,1,2)”]",
1710
1710
  "```",
1711
1711
  "Uniform append and Inlay, including successive compositions",
1712
1712
  "",
@@ -1720,7 +1720,7 @@ export const HC_SOURCES = new Map([
1720
1720
  "; [(A Y).#### = (A.#### Y), (C Y).#### = (C.#### Y), (X Y).#### = (X.#### Y)]",
1721
1721
  "# [<>, <>, <>]",
1722
1722
  "; [“” (A Y).####, “” (C Y).####, “” ((C Y) []).####]",
1723
- "# [“Demi(2,1,3)”, “Demi(3,5,2)”, “Demi(4,5,3)”]",
1723
+ "# [“Denum(2,1,3)”, “Denum(3,5,2)”, “Denum(4,5,3)”]",
1724
1724
  "; ([5, “ab”] []).#### = ([5, “ab”].#### [])",
1725
1725
  "# <>",
1726
1726
  "```",
@@ -1742,41 +1742,41 @@ export const HC_SOURCES = new Map([
1742
1742
  "```",
1743
1743
  "Origin and channel names",
1744
1744
  "",
1745
- "The empty host has no Demi, despite Size 1. Its first append generates a",
1745
+ "The empty host has no Denum, despite Size 1. Its first append generates a",
1746
1746
  "present reading. Applying nil is not the append update; a zero-load phase-2",
1747
- "Demi of Count zero is an explicit initialized-router convention, not a",
1747
+ "Denum of Count zero is an explicit initialized-router convention, not a",
1748
1748
  "preconstruction state secretly stored in []. A zero Size deposit still adds one",
1749
1749
  "to the Count and so changes routing phase.",
1750
1750
  "```",
1751
- "; [([] []).####.phase, ([] []).####.left, ([] []).####.right]",
1751
+ "; [([] []).####.phase (), ([] []).####.left (), ([] []).####.right ()]",
1752
1752
  "# [1, 1, 0]",
1753
1753
  "; [([] Y).#### = ([].#### Y), ([] * Y).#### = Y.####]",
1754
1754
  "# [(), <>]",
1755
- "; Demis <- './hc/demi.hc';",
1756
- "; ([] Y).#### = ((Demis.Demi [0, 0, 0]) Y)",
1755
+ "; Denums <- './hc/denum.hc';",
1756
+ "; ([] Y).#### = ((Denums.Denum [0, 0, 0]) Y)",
1757
1757
  "# <>",
1758
- "; [“” [0].####, “” ([0].#### 0), [].#### = [0].####, [].#### = (Demis.Demi [0, 0, 0]), (Demis.Demi [0, 0, 0]).#### = (Demis.Demi [0, 0, 0])]",
1759
- "# [“Demi(1,0,0)”, “Demi(2,0,0)”, (), (), <>]",
1758
+ "; [“” [0].####, “” ([0].#### 0), [].#### = [0].####, [].#### = (Denums.Denum [0, 0, 0]), (Denums.Denum [0, 0, 0]).#### = (Denums.Denum [0, 0, 0])]",
1759
+ "# [“Denum(1,0,0)”, “Denum(2,0,0)”, (), (), <>]",
1760
1760
  "```",
1761
1761
  "For a proposed relabeling, exchange the loads AND toggle which named channel",
1762
1762
  "is next: J(n,L,R) = (n+1,R,L). Toggling the phase changes the parity of the",
1763
- "Count, and a Demi derives its phase from its Count, so the relabeling moves the",
1763
+ "Count, and a Denum derives its phase from its Count, so the relabeling moves the",
1764
1764
  "Count by one rather than leaving it fixed; the Count has no mirror image of its",
1765
1765
  "own. Total load stays fixed and residual changes sign. J commutes with deposit",
1766
1766
  "and scale; this is equivariance of a named router representation, not",
1767
1767
  "invariance of its signed readout, not reversal of the host, and not a new native",
1768
1768
  "constructor. Applying J twice returns the loads and the phase, with the Count",
1769
1769
  "two higher, so it is an involution on phase and loads and not on Count. The",
1770
- "following closure only checks that explicit relabeling using the existing Demi",
1770
+ "following closure only checks that explicit relabeling using the existing Denum",
1771
1771
  "class.",
1772
1772
  "```",
1773
- "; .swap {.d _; Demis.Demi [(d.count + 1), d.right, d.left]};",
1773
+ "; .swap {.d _; Denums.Denum [(d.count + 1), d.right (), d.left ()]};",
1774
1774
  "; .q [[], [[], []]].####;",
1775
1775
  "; [“” q, “” (swap q), (swap q).## = q.##, (swap q).### = (0 - q.###)]",
1776
- "# [“Demi(2,1,2)”, “Demi(3,2,1)”, <>, <>]",
1776
+ "# [“Denum(2,1,2)”, “Denum(3,2,1)”, <>, <>]",
1777
1777
  "; [(swap (q Y)) = ((swap q) Y), (swap ((q Y) [])) = (((swap q) Y) []), (swap (q.scale_ 3)) = ((swap q).scale_ 3)]",
1778
1778
  "# [<>, <>, <>]",
1779
- "; [(swap (swap q)).phase = q.phase, (swap (swap q)).left = q.left, (swap (swap q)).right = q.right, (swap (swap q)).count = (q.count + 2), (swap (swap q)) = q]",
1779
+ "; [((swap (swap q)).phase ()) = (q.phase ()), ((swap (swap q)).left ()) = (q.left ()), ((swap (swap q)).right ()) = (q.right ()), (swap (swap q)).count = (q.count + 2), (swap (swap q)) = q]",
1780
1780
  "# [<>, <>, <>, <>, ()]",
1781
1781
  "```",
1782
1782
  "Future sufficiency, at its earned scope",
@@ -1812,7 +1812,7 @@ export const HC_SOURCES = new Map([
1812
1812
  "position repeats only in parity, S by counting all",
1813
1813
  "terminal sticks, and A by subtracting the bin populations. No separately",
1814
1814
  "supplied state vector or stochastic routing law is needed. The empty host's",
1815
- "one terminal stick is not an immediate child deposit: report no Demi until",
1815
+ "one terminal stick is not an immediate child deposit: report no Denum until",
1816
1816
  "construction places a first child. A physical pointer's initial left choice",
1817
1817
  "is part of this selected measurement convention.",
1818
1818
  "",
@@ -1836,13 +1836,13 @@ export const HC_SOURCES = new Map([
1836
1836
  "Five-criterion verdict and evidence scope",
1837
1837
  "",
1838
1838
  "1. Derived: VACTED by execution for the examples; uniformly vacted under the",
1839
- " construction/observer contract. Hosts are built before their Demi is read.",
1839
+ " construction/observer contract. Hosts are built before their Denum is read.",
1840
1840
  "2. Compressive: VACTED by distinct equal-reading constructions. Representation",
1841
1841
  " has three unbounded Counts, n, L and R, with the phase derived from n; fixed",
1842
1842
  " dimension is not bounded bits.",
1843
1843
  "3. Forced update: VACTED by execution for the displayed compositions; uniformly",
1844
1844
  " vacted by the append and substitution recipes on the declared domain.",
1845
- "4. Origin: VACTED for no supplied host Demi and the first-construction boundary.",
1845
+ "4. Origin: VACTED for no supplied host Denum and the first-construction boundary.",
1846
1846
  " Channel relabeling is CONDITIONALLY VACTED as the explicit router",
1847
1847
  " equivariance above. Full origin/gauge invariance is NOT YET VACTED.",
1848
1848
  "5. Earned forgetting: uniformly vacted for the specified future constructor",
@@ -1929,84 +1929,98 @@ export const HC_SOURCES = new Map([
1929
1929
  ].join("\n"),
1930
1930
  ],
1931
1931
  [
1932
- "hc/demi.hc",
1932
+ "hc/denum.hc",
1933
1933
  [
1934
1934
  "#!/usr/bin/env hc",
1935
1935
  "```",
1936
- "Demi (occurrence/figure 011.20, 007.25c)",
1936
+ "Denum (occurrence/figure 011.20, 007.25c)",
1937
1937
  "",
1938
- "A Demi is a closed two-channel state: a Count and two loads, left and right.",
1939
- "Applying a Demi to a Frame deposits that Frame's Size into the channel the",
1940
- "Count's parity selects and adds one to the Count, so a Demi follows alternating",
1938
+ "A Denum is a closed two-channel state: a Count and two loads, left and right.",
1939
+ "Applying a Denum to a Frame deposits that Frame's Size into the channel the",
1940
+ "Count's parity selects and adds one to the Count, so a Denum follows alternating",
1941
1941
  "construction one observation at a time and remembers how many it has seen. It",
1942
- "is what the fourth hash answers: `x.####` is the Demi of x's Count, Size and",
1942
+ "is what the fourth hash answers: `x.####` is the Denum of x's Count, Size and",
1943
1943
  "residual, with Count x.#, left load (Size + residual)/2 and right load",
1944
1944
  "(Size − residual)/2.",
1945
1945
  "",
1946
- "`Demi` is an ordinary HC class: a constructor closure answering a fresh",
1946
+ "`Denum` is an ordinary HC class: a constructor closure answering a fresh",
1947
1947
  "aggregate whose fields are its state and whose methods are the class. Nothing",
1948
1948
  "about it is native. The fourth hash keeps only its derivation and builds its",
1949
1949
  "answer with this constructor, which the evaluator reads from this file, compiled",
1950
1950
  "in, the first time `.####` needs one. So this file is both the definition every",
1951
1951
  "evaluator uses and its specification, and it works without a resource root.",
1952
- "Import it to construct Demis directly: `Demis <- './hc/demi.hc'`, then",
1953
- "`Demis.Demi [0, 0, 0]`.",
1952
+ "Import it to construct Denums directly: `Denums <- './hc/denum.hc'`, then",
1953
+ "`Denums.Denum [0, 0, 0]`.",
1954
1954
  "",
1955
- "**State (007.25c).** `Demi [C, L, R]` takes three Counts, any of them zero",
1956
- '(`Demi [C, loads]` takes a Count and a list of loads; see "Channels and',
1955
+ "**State (007.25c).** `Denum [C, L, R]` takes three Counts, any of them zero",
1956
+ '(`Denum [C, loads]` takes a Count and a list of loads; see "Channels and',
1957
1957
  'division" below). `C`',
1958
1958
  "is the full application Count the state has recorded, not its parity, so",
1959
- "`Demi [2, 5, 1]` and `Demi [4, 5, 1]` are different states that agree in phase",
1960
- "and in both loads. Anything else is refused with `$!!.invalid-demi`, a named",
1959
+ "`Denum [2, 5, 1]` and `Denum [4, 5, 1]` are different states that agree in phase",
1960
+ "and in both loads. Anything else is refused with `$!!.invalid-denum`, a named",
1961
1961
  "error, as Figures refuses an unsupported host. This replaces the phase-only",
1962
- "`Demi [phase, L, R]` of earlier versions, where `phase` was 1 or 2 and the",
1963
- 'number of applications was forgotten: `Demi [2, 5, 3]` used to mean "an even',
1962
+ "`Denum [phase, L, R]` of earlier versions, where `phase` was 1 or 2 and the",
1963
+ 'number of applications was forgotten: `Denum [2, 5, 3]` used to mean "an even',
1964
1964
  'number of applications, left next", and it now means exactly two. Nothing converts an old state to a new one, because the old one never recorded',
1965
- "its Count. `Demi [0, 0, 0]` is the neutral start.",
1966
- "",
1967
- "**Count and phase.** `d.count` and `d.#` are the stored `C`. The phase is a",
1968
- "derived field, `d.phase`, a two-state reading of the Count's parity and never",
1969
- "the integer `C %% 2`: 2 when `C` is even, `C = 0` included, left next, and 1",
1970
- "when it is odd, right next. It is a Count rather than all or nil because a",
1971
- "field cannot hold nil, and a Count keeps the odd phase present. It is derived,",
1972
- "not independent state: it is written only together with `C`, so the fields are",
1973
- "the whole state and two Demis are `=` exactly when their Count and loads are.",
1974
- "States with the same phase and loads but different Counts stay distinguishable.",
1975
- "",
1976
- "**Observers.** A Demi declares its own Count, Size and residual (011.20): its",
1965
+ "its Count. `Denum [0, 0, 0]` is the neutral start.",
1966
+ "",
1967
+ "**Default Count (007.40).** `Denum [loads]`, a single list of loads, is the",
1968
+ "default-Count form, with `C = 1`: `Denum [[2, 5]]` is `Denum [1, [2, 5]]`. It is",
1969
+ "a constructor convention, not a claim that the state was reached by one",
1970
+ "application. An explicit Count always wins, so `Denum [0, [2, 5]]` keeps Count",
1971
+ "zero. A host declaration such as `(.# C;)` is not a constructor option.",
1972
+ "",
1973
+ "**State is Count and loads (007.40).** A Denum stores exactly two fields:",
1974
+ "`count`, the Count `C`, and `loads`, its ordered channel loads. Nothing else is",
1975
+ "stored, so nothing else can disagree with them. `d.count` and `d.#` are `C`,",
1976
+ "and `d.loads` is the list. Two Denums are `=` exactly when their Count and loads",
1977
+ "are. States with the same phase and loads but different Counts stay",
1978
+ "distinguishable.",
1979
+ "",
1980
+ "**Derived readings.** A binary Denum answers three readings computed from that",
1981
+ "state when applied to nil, as the ratios are: `d.phase ()`, `d.left ()` and",
1982
+ "`d.right ()`. `d.phase ()` reads the Count's parity and never the integer",
1983
+ "`C %% 2`: 2 when `C` is even, `C = 0` included, left next, and 1 when it is",
1984
+ "odd, right next. It is a Count rather than all or nil, so the odd phase is",
1985
+ "present. `d.left ()` and `d.right ()` are `d.loads .0` and `d.loads .1`. Any",
1986
+ "other operand is `$!!.unary-observation`. Before 007.40 these were stored fields",
1987
+ "written alongside the Count and loads; they are readings now, so application",
1988
+ "routes by the Count's parity and no write can make them diverge.",
1989
+ "",
1990
+ "**Observers.** A Denum declares its own Count, Size and residual (011.20): its",
1977
1991
  "Count `C`, its total load `L+R` and the signed difference `L−R`. An aggregate",
1978
- "otherwise observes its elements, and a Demi has none, so without these it",
1992
+ "otherwise observes its elements, and a Denum has none, so without these it",
1979
1993
  "would observe as 0, 1, 0. Its fourth hash is not declared: no class can",
1980
1994
  "declare `.####`. The derivation from the three observers cannot tell an empty",
1981
- "host from a Demi of Count zero, because both read 0, 0, 0, and it answers nil",
1982
- "for either. A Demi of Count zero is a present state, so the fourth hash",
1995
+ "host from a Denum of Count zero, because both read 0, 0, 0, and it answers nil",
1996
+ "for either. A Denum of Count zero is a present state, so the fourth hash",
1983
1997
  "recognizes an instance of this class intrinsically (007.25e,",
1984
- "`lib/frames/fourth-hash.ts`): a Frame whose stored `count`, `left` and `right`",
1985
- "are Counts and which is `==` to the Demi this constructor builds from them",
1986
- "answers that fresh reconstruction, an equal instance for every `C`. Nothing of",
1998
+ "`lib/frames/fourth-hash.ts`): a Frame whose stored `count` is a Count and whose",
1999
+ "stored `loads` is a nonempty list of Counts, and which is `==` to the Denum this",
2000
+ "constructor builds from them, answers that fresh reconstruction, an equal instance for every `C`. Nothing of",
1987
2001
  "the source runs, so a foreign aggregate that forges `#`, `##`, `###` or a",
1988
2002
  "`.####` method gets only the ordinary derived fourth hash. `[].####` and",
1989
2003
  "`0.####` stay nil: those are hosts with no children, and a host with no",
1990
- "children has no Demi.",
2004
+ "children has no Denum.",
1991
2005
  "",
1992
2006
  "**Application**, `d x`: observe x's Size once, deposit it into the channel the",
1993
2007
  "phase selects (left in phase 2, right in phase 1) and add one to the Count,",
1994
2008
  "which flips the phase. A Size of zero still counts. If x has no Size, its",
1995
2009
  "failure is the answer rather than a deposit. It is a mutating method, `apply_`,",
1996
- "so through a name, `d x` is a functional update: it answers a new Demi and",
2010
+ "so through a name, `d x` is a functional update: it answers a new Denum and",
1997
2011
  "leaves d unchanged.",
1998
2012
  "",
1999
2013
  "**Scaling**, `d.scale_ k`: multiply both loads by a Count k, keeping the",
2000
2014
  "Count. It is the numerical shadow of Star: `(x * y).####` is",
2001
2015
  "`x.####.scale_ (y.##)` for a nonempty host x, Count included. `scale_` stays,",
2002
2016
  "as the name the fourth hash and Star correspondence use; `d * k` answers the",
2003
- "same Demi through the operator below.",
2017
+ "same Denum through the operator below.",
2004
2018
  "",
2005
2019
  "**Arithmetic**, `d + x`, `d - x` and `d * x` (015.11). A class answers an",
2006
2020
  "operator by declaring a method under its name, found on the operand and its",
2007
2021
  "declared parents, the chain its other methods come from, so an operator in a",
2008
2022
  "method body keeps its global meaning rather than recurring into the class that",
2009
- "is running. All three **construct a fresh Demi state** from the one Size",
2023
+ "is running. All three **construct a fresh Denum state** from the one Size",
2010
2024
  "observation `x.##` of their operand, keeping Figure 008's distinction between",
2011
2025
  "construction and observation. They are **fixed-channel load transformations**",
2012
2026
  "on the two-load shadow, consistent with the channel loads of a `RotorRouter`",
@@ -2019,27 +2033,27 @@ export const HC_SOURCES = new Map([
2019
2033
  "no run of applications reaches, such as `C = 0` with a nonzero load.",
2020
2034
  "",
2021
2035
  "- `d + x` is the **tally** operator: it deposits `x.##` on the **right**,",
2022
- " `Demi [C, L, R + x.##]`. A sizeless host's failure is the answer, as it is for",
2036
+ " `Denum [C, L, R + x.##]`. A sizeless host's failure is the answer, as it is for",
2023
2037
  " application. It is `d.deposit-right_ (x.##)`, a load-only functional update.",
2024
2038
  "- `d - x` is the **alternator** operator: it deposits on the **left**,",
2025
- " `Demi [C, L + x.##, R]`, as `d.deposit-left_ (x.##)`. It is not subtraction: a deposit only ever adds, so",
2039
+ " `Denum [C, L + x.##, R]`, as `d.deposit-left_ (x.##)`. It is not subtraction: a deposit only ever adds, so",
2026
2040
  " a load never goes negative and stays a whole Count. Right deposition lowers",
2027
2041
  " the signed residual `L − R` and left deposition raises it, the reverse of",
2028
2042
  " ordinary signed-scalar `+` and `-`.",
2029
2043
  "- `d * x` is the **inlay** operator: it scales both loads by the operand's Size",
2030
- " `x.##`, `Demi [C, sL, sR]` for `s = x.##`, keeping `C`. It reads the operand",
2044
+ " `x.##`, `Denum [C, sL, sR]` for `s = x.##`, keeping `C`. It reads the operand",
2031
2045
  " through the one Size observer, as `+` and `-` do, so any sized Frame scales a",
2032
- " Demi, not only a bare Count. It is literally `d.scale_ (x.##)`.",
2046
+ " Denum, not only a bare Count. It is literally `d.scale_ (x.##)`.",
2033
2047
  "",
2034
- "None of the three names the `Demi` constructor inside its method. A bare name",
2048
+ "None of the three names the `Denum` constructor inside its method. A bare name",
2035
2049
  "in a method is looked up on the argument first (spec 7), and a decimal is",
2036
- "unit-taggable, so inside `d + 2.5` the name `Demi` read `2.5.Demi`, a tagged",
2050
+ "unit-taggable, so inside `d + 2.5` the name `Denum` read `2.5.Denum`, a tagged",
2037
2051
  "number, and applying that to `[C, L, R]` was `$!.repetition-domain` (007.25e,",
2038
2052
  "PR #480 review). Each operator now hands the one Size it observed to a",
2039
2053
  "load-only functional update on the receiver, `deposit-right_`, `deposit-left_`",
2040
2054
  "or `scale_`, so `D + 2.5`, `D - 2.5` and `D * 2.5` all read `(2.5).## = 2`.",
2041
2055
  "`deposit-right_ k` and `deposit-left_ k` take a Count and refuse anything else",
2042
- "with `$!!.invalid-demi`, since a negative deposit is no Demi.",
2056
+ "with `$!!.invalid-denum`, since a negative deposit is no Denum.",
2043
2057
  "",
2044
2058
  "**Rational readings (007.25).** Because `C` is kept, two exact ratios are read",
2045
2059
  "from the state. They are unary observations of the stored state, not `/` and",
@@ -2063,45 +2077,45 @@ export const HC_SOURCES = new Map([
2063
2077
  "and `S / C` and `Δ / C` are arithmetic readings of it, not a construction of",
2064
2078
  "rational geometry.",
2065
2079
  "",
2066
- "**Text.** A Demi prints as what it is, an aggregate of fields and methods. As",
2067
- "text it reads `Demi(C,L,R)`, with the Count and both loads.",
2080
+ "**Text.** A Denum prints as what it is, an aggregate of fields and methods. As",
2081
+ "text it reads `Denum(C,L,R)`, with the Count and both loads.",
2068
2082
  "",
2069
2083
  "**Channels and division (007.27).** The two loads are the arity-two case of an",
2070
- "ordered list of channel loads. `Demi [C, loads]` takes a Count and a nonempty",
2071
- "list of Counts: two loads are this binary Demi, the same instance",
2072
- "`Demi [C, L, R]` builds, and any other number is a channel Demi. Every Demi",
2073
- "stores `count` and `loads`; only the binary one also has `left`, `right` and",
2074
- "`phase`, which it writes together with `loads`. A channel Demi of arity k",
2084
+ "ordered list of channel loads. `Denum [C, loads]` takes a Count and a nonempty",
2085
+ "list of Counts: two loads are this binary Denum, the same instance",
2086
+ "`Denum [C, L, R]` builds, and any other number is a channel Denum. Every Denum",
2087
+ "stores `count` and `loads` and nothing else; only the binary one also answers",
2088
+ "the readings `phase ()`, `left ()` and `right ()`. A channel Denum of arity k",
2075
2089
  "deposits into channel `C mod k`, which for k = 2 is the phase's channel. Its",
2076
2090
  "Size is the sum of its loads and its residual their alternating sum",
2077
2091
  "`e0 − e1 + e2 − …`, the list residual, which for two loads is `L − R`. Its",
2078
- "fourth hash is intrinsic too: a fresh equal Demi of the same arity. Its `*`,",
2092
+ "fourth hash is intrinsic too: a fresh equal Denum of the same arity. Its `*`,",
2079
2093
  "`scale_` and ratios are as here. Its `+` and `-` follow the residual's signs:",
2080
2094
  "`-` deposits on the first even load, load 0, raising the residual, and `+` on",
2081
2095
  "the first odd load, load 1, lowering it, which for two loads are left and",
2082
- "right; with one load `+` is `$!!.invalid-arity`. Text reads `Demi(C,[e0, e1,",
2096
+ "right; with one load `+` is `$!!.invalid-arity`. Text reads `Denum(C,[e0, e1,",
2083
2097
  "…])`.",
2084
2098
  "",
2085
2099
  "`d ./ n`, also spelled `d / n`, redistributes the Size: it keeps C and the",
2086
2100
  "total S and deals S Size units round-robin into n channels, so the first",
2087
2101
  "S mod n hold ⌈S/n⌉ and the rest ⌊S/n⌋. It is idempotent, `(d ./ n) ./ m` is",
2088
- "`d ./ m`, and equal Count and Size give equal results, so `Demi(3,[5,2])` and",
2089
- "`Demi(3,[4,3])` divide into the same `Demi(3,[3,2,2])`. It is not scalar",
2102
+ "`d ./ m`, and equal Count and Size give equal results, so `Denum(3,[5,2])` and",
2103
+ "`Denum(3,[4,3])` divide into the same `Denum(3,[3,2,2])`. It is not scalar",
2090
2104
  "division and not the ratios: no number is answered. The divisor is a positive",
2091
2105
  "Count, refused as a list refuses it (`$!.division-by-zero /`,",
2092
2106
  "`$!.division-domain /`), never read as a Size. `hc/division.hc` is its",
2093
2107
  "specification, with the list and RotorRouter divisions beside it.",
2094
2108
  "",
2095
2109
  "**Methods read their own state through `_^`.** A bare name inside a method is",
2096
- "looked up on the argument first (spec 7), and a Demi is applied to arbitrary",
2110
+ "looked up on the argument first (spec 7), and a Denum is applied to arbitrary",
2097
2111
  "Frames, so a bare `left` could read the argument's field. `_^` is the receiver",
2098
2112
  "from a method's body, and `_^^` from a block one level in, because carets",
2099
2113
  "count lexically (spec a06). What a branch needs is bound as a local at method",
2100
2114
  "level, where nested blocks read it. The file's own names, the constructor",
2101
- "`Demi` and the helpers `deposit-at` (a cursor that adds a Size at one channel",
2115
+ "`Denum` and the helpers `deposit-at` (a cursor that adds a Size at one channel",
2102
2116
  "index, applied by reduce) and `redistribution` (the round-robin loads of S",
2103
2117
  "units in n channels), are read the same way, through the scope a caret ladder",
2104
- "reaches, `(_^^^ .Demi)` from a branch, so an argument's fields never stand in",
2118
+ "reaches, `(_^^^ .Denum)` from a branch, so an argument's fields never stand in",
2105
2119
  "for them.",
2106
2120
  "```",
2107
2121
  ".deposit-at {.at (_ .0); .by (_ .1); [.index 0; .target at; .amount by; .out [];",
@@ -2109,23 +2123,26 @@ export const HC_SOURCES = new Map([
2109
2123
  " @out (o ((i = t) ? {v + a} : {v})); @index (i + 1);}]};",
2110
2124
  ".redistribution {.s (_ .0); .ways (_ .1); .r (s %% ways); .q (((s - r) / ways).##);",
2111
2125
  " ((ways - r) [q]) | (r [(q + 1)])};",
2112
- ".binary-demi {.c (_ .0); .l (_ .1); .r (_ .2); .p (((c %% 2) = 0) ? {2} : {1}); [",
2126
+ ".binary-denum {.c (_ .0); .l (_ .1); .r (_ .2); [",
2113
2127
  " .count c;",
2114
- " .phase p;",
2115
- " .left l;",
2116
- " .right r;",
2117
2128
  " .loads [l, r];",
2118
2129
  " .# {_^.count};",
2119
- " .## {_^.left + _^.right};",
2120
- " .### {_^.left - _^.right};",
2121
- " .apply_ {.s (_ .##); .c (_^ .count); .l (_^ .left); .r (_^ .right); .p (_^ .phase);",
2122
- " (s ~ (0.<>)) ? {(p = 2) ? {@left (l + s); @loads [(l + s), r]; @phase 1;} : {@right (r + s); @loads [l, (r + s)]; @phase 2;}; @count (c + 1); _^^} : {s}};",
2123
- " .scale_ {.k _; .l (_^ .left); .r (_^ .right);",
2124
- " (k ~ (0.<>)) ? {@left (l * k); @right (r * k); @loads [(l * k), (r * k)]; _^^} : {$!!.invalid-scale}};",
2125
- " .deposit-right_ {.k _; .l (_^ .left); .r (_^ .right);",
2126
- " (k ~ (0.<>)) ? {@right (r + k); @loads [l, (r + k)]; _^^} : {$!!.invalid-demi}};",
2127
- " .deposit-left_ {.k _; .l (_^ .left); .r (_^ .right);",
2128
- " (k ~ (0.<>)) ? {@left (l + k); @loads [(l + k), r]; _^^} : {$!!.invalid-demi}};",
2130
+ " .## {(_^ .loads).##};",
2131
+ " .### {(_^ .loads).###};",
2132
+ " .phase {.c (_^ .count); .u ((_ = ()) ? {1} : {0});",
2133
+ " (u = 1) ? {((c %% 2) = 0) ? {2} : {1}} : {$!!.unary-observation}};",
2134
+ " .left {.e (_^ .loads); .u ((_ = ()) ? {1} : {0});",
2135
+ " (u = 1) ? {e .0} : {$!!.unary-observation}};",
2136
+ " .right {.e (_^ .loads); .u ((_ = ()) ? {1} : {0});",
2137
+ " (u = 1) ? {e .1} : {$!!.unary-observation}};",
2138
+ " .apply_ {.s (_ .##); .c (_^ .count); .e (_^ .loads); .l (e .0); .r (e .1);",
2139
+ " (s ~ (0.<>)) ? {((c %% 2) = 0) ? {@loads [(l + s), r];} : {@loads [l, (r + s)];}; @count (c + 1); _^^} : {s}};",
2140
+ " .scale_ {.k _; .e (_^ .loads); .l (e .0); .r (e .1);",
2141
+ " (k ~ (0.<>)) ? {@loads [(l * k), (r * k)]; _^^} : {$!!.invalid-scale}};",
2142
+ " .deposit-right_ {.k _; .e (_^ .loads); .l (e .0); .r (e .1);",
2143
+ " (k ~ (0.<>)) ? {@loads [l, (r + k)]; _^^} : {$!!.invalid-denum}};",
2144
+ " .deposit-left_ {.k _; .e (_^ .loads); .l (e .0); .r (e .1);",
2145
+ " (k ~ (0.<>)) ? {@loads [(l + k), r]; _^^} : {$!!.invalid-denum}};",
2129
2146
  " .+ {.s (_ .##);",
2130
2147
  " (s ~ (0.<>)) ? {(_^^ .deposit-right_ s)} : {s}};",
2131
2148
  " .- {.s (_ .##);",
@@ -2133,14 +2150,14 @@ export const HC_SOURCES = new Map([
2133
2150
  " .* {.s (_ .##);",
2134
2151
  " (s ~ (0.<>)) ? {(_^^ .scale_ s)} : {s}};",
2135
2152
  " ./ {.ways _; .c (_^ .count); .s (_^ .##); .v ([] / ways);",
2136
- " (v ~ ([].<>)) ? {(_^^^ .Demi) [c, ((_^^^ .redistribution) [s, ways])]} : {v}};",
2153
+ " (v ~ ([].<>)) ? {(_^^^ .Denum) [c, ((_^^^ .redistribution) [s, ways])]} : {v}};",
2137
2154
  " .size-ratio {.c (_^ .count); .s (_^ .##); .u ((_ = ()) ? {1} : {0});",
2138
2155
  " (c .> 0) ? {(u = 1) ? {s / c} : {$!!.unary-observation}}};",
2139
2156
  " .residual-ratio {.c (_^ .count); .d (_^ .###); .u ((_ = ()) ? {1} : {0});",
2140
2157
  " (c .> 0) ? {(u = 1) ? {d / c} : {$!!.unary-observation}}};",
2141
- " .toText {“Demi(” (_^ .count) “,” (_^ .left) “,” (_^ .right) “)”}",
2158
+ " .toText {.e (_^ .loads); “Denum(” (_^ .count) “,” (e .0) “,” (e .1) “)”}",
2142
2159
  " ]};",
2143
- ".channel-demi {.c (_ .0); .e (_ .1); [",
2160
+ ".channel-denum {.c (_ .0); .e (_ .1); [",
2144
2161
  " .count c;",
2145
2162
  " .loads e;",
2146
2163
  " .# {_^.count};",
@@ -2151,9 +2168,9 @@ export const HC_SOURCES = new Map([
2151
2168
  " .scale_ {.k _; .e (_^ .loads);",
2152
2169
  " (k ~ (0.<>)) ? {@loads (e & {_ * k}); _^^} : {$!!.invalid-scale}};",
2153
2170
  " .deposit-right_ {.k _; .e (_^ .loads);",
2154
- " ((k ~ (0.<>)) ? {(e.#) .> 1}) ? {@loads ((e | ((_^^^ .deposit-at) [1, k])) .out); _^^} : {(k ~ (0.<>)) ? {$!!.invalid-arity} : {$!!.invalid-demi}}};",
2171
+ " ((k ~ (0.<>)) ? {(e.#) .> 1}) ? {@loads ((e | ((_^^^ .deposit-at) [1, k])) .out); _^^} : {(k ~ (0.<>)) ? {$!!.invalid-arity} : {$!!.invalid-denum}}};",
2155
2172
  " .deposit-left_ {.k _; .e (_^ .loads);",
2156
- " (k ~ (0.<>)) ? {@loads ((e | ((_^^^ .deposit-at) [0, k])) .out); _^^} : {$!!.invalid-demi}};",
2173
+ " (k ~ (0.<>)) ? {@loads ((e | ((_^^^ .deposit-at) [0, k])) .out); _^^} : {$!!.invalid-denum}};",
2157
2174
  " .+ {.s (_ .##);",
2158
2175
  " (s ~ (0.<>)) ? {(_^^ .deposit-right_ s)} : {s}};",
2159
2176
  " .- {.s (_ .##);",
@@ -2161,48 +2178,93 @@ export const HC_SOURCES = new Map([
2161
2178
  " .* {.s (_ .##);",
2162
2179
  " (s ~ (0.<>)) ? {(_^^ .scale_ s)} : {s}};",
2163
2180
  " ./ {.ways _; .c (_^ .count); .s (_^ .##); .v ([] / ways);",
2164
- " (v ~ ([].<>)) ? {(_^^^ .Demi) [c, ((_^^^ .redistribution) [s, ways])]} : {v}};",
2181
+ " (v ~ ([].<>)) ? {(_^^^ .Denum) [c, ((_^^^ .redistribution) [s, ways])]} : {v}};",
2165
2182
  " .size-ratio {.c (_^ .count); .s (_^ .##); .u ((_ = ()) ? {1} : {0});",
2166
2183
  " (c .> 0) ? {(u = 1) ? {s / c} : {$!!.unary-observation}}};",
2167
2184
  " .residual-ratio {.c (_^ .count); .d (_^ .###); .u ((_ = ()) ? {1} : {0});",
2168
2185
  " (c .> 0) ? {(u = 1) ? {d / c} : {$!!.unary-observation}}};",
2169
- " .toText {“Demi(” (_^ .count) “,” (_^ .loads) “)”}",
2186
+ " .toText {“Denum(” (_^ .count) “,” (_^ .loads) “)”}",
2170
2187
  " ]};",
2171
- ".Demi {((_ ~ ([].<>)) ? {(__ .#) ~ <2, 3>}) ? {.a __; .c (a .0);",
2172
- " .boxed (((a.#) = 3) ? {[[a .1, a .2]]} : {[a .1]});",
2188
+ ".Denum {((_ ~ ([].<>)) ? {(__ .#) ~ <1, 2, 3>}) ? {.a __; .n (a.#);",
2189
+ " .c ((n = 1) ? {1} : {a .0});",
2190
+ " .boxed ((n = 3) ? {[[a .1, a .2]]} : {(n = 2) ? {[a .1]} : {[a .0]}});",
2173
2191
  " ((c ~ (0.<>)) ? {(boxed .0) ~ ([].<>)}) ? {.e (boxed .0); .k (e.#);",
2174
2192
  " ((k .> 0) ? {(e &| {.x _; (x ~ (0.<>)) ? {[]} : {[x]}}).# = 0}) ? {",
2175
- " (k = 2) ? {binary-demi [c, (e .0), (e .1)]} : {channel-demi [c, (e | [])]}",
2176
- " } : {$!!.invalid-demi}} : {$!!.invalid-demi}} : {$!!.invalid-demi}};",
2193
+ " (k = 2) ? {binary-denum [c, (e .0), (e .1)]} : {channel-denum [c, (e | [])]}",
2194
+ " } : {$!!.invalid-denum}} : {$!!.invalid-denum}} : {$!!.invalid-denum}};",
2177
2195
  "```",
2178
2196
  "## Construction",
2179
2197
  "",
2180
- "A Demi holds its Count and its two loads, and the phase that Count fixes. Each",
2198
+ "A Denum holds its Count and its two loads; its phase is read from that Count. Each",
2181
2199
  "instance is its own: two built from the same constructor share nothing. The",
2182
- "neutral start `Demi [0, 0, 0]` is present, in phase 2",
2200
+ "neutral start `Denum [0, 0, 0]` is present, in phase 2",
2183
2201
  "```",
2184
- "; .d (Demi [0, 0, 0]);",
2185
- "; [d.count, d.phase, d.left, d.right, d.#, d.##, d.###, “” d]",
2186
- "# [0, 2, 0, 0, 0, 0, 0, “Demi(0,0,0)”]",
2187
- "; .a (Demi [2, 5, 3]); .b (Demi [1, 7, 0]);",
2188
- "; [“” a, “” b, a.left, b.left, a.phase, b.phase]",
2189
- "# [“Demi(2,5,3)”, “Demi(1,7,0)”, 5, 7, 2, 1]",
2202
+ "; .d (Denum [0, 0, 0]);",
2203
+ "; [d.count, d.phase (), d.left (), d.right (), d.loads, d.#, d.##, d.###, “” d]",
2204
+ "# [0, 2, 0, 0, [0, 0], 0, 0, 0, “Denum(0,0,0)”]",
2205
+ "; .a (Denum [2, 5, 3]); .b (Denum [1, 7, 0]);",
2206
+ "; [“” a, “” b, a.left (), b.left (), a.phase (), b.phase ()]",
2207
+ "# [“Denum(2,5,3)”, “Denum(1,7,0)”, 5, 7, 2, 1]",
2190
2208
  "```",
2191
2209
  "Any Counts are a state. The phase is read from the parity of the Count, never",
2192
2210
  "from the Count itself: even is phase 2, zero included, and odd is phase 1",
2193
2211
  "```",
2194
- "; [0, 1, 2, 3, 4, 5, 100, 101] & {(Demi [_, 5, 3]).phase}",
2212
+ "; [0, 1, 2, 3, 4, 5, 100, 101] & {(Denum [_, 5, 3]).phase ()}",
2195
2213
  "# [2, 1, 2, 1, 2, 1, 2, 1]",
2196
- "; [(Demi [2, 5, 3]).#, (Demi [4, 5, 3]).#, (Demi [100, 5, 3]).count, (Demi [100, 5, 3]).phase, (Demi [3, 5, 3]).phase]",
2214
+ "; [(Denum [2, 5, 3]).#, (Denum [4, 5, 3]).#, (Denum [100, 5, 3]).count, (Denum [100, 5, 3]).phase (), (Denum [3, 5, 3]).phase ()]",
2197
2215
  "# [2, 4, 100, 2, 1]",
2198
2216
  "```",
2199
2217
  "A positive Count over empty loads and nonzero loads over a zero Count are both",
2200
2218
  "states. Anything that is not three Counts is refused",
2201
2219
  "```",
2202
- "; [“” (Demi [3, 0, 0]), “” (Demi [0, 3, 0]), “” (Demi [0, 0, 4])]",
2203
- "# [“Demi(3,0,0)”, “Demi(0,3,0)”, “Demi(0,0,4)”]",
2204
- "; [Demi [2, (0 - 1), 0], Demi [(0 - 1), 1, 1], Demi [(5 - 3), (5 - 7), 0], Demi [2, 1], Demi 5, Demi [2, 1.5, 0], Demi [2, 1, 0, 0]]",
2205
- "# [$!!.invalid-demi, $!!.invalid-demi, $!!.invalid-demi, $!!.invalid-demi, $!!.invalid-demi, $!!.invalid-demi, $!!.invalid-demi]",
2220
+ "; [“” (Denum [3, 0, 0]), “” (Denum [0, 3, 0]), “” (Denum [0, 0, 4])]",
2221
+ "# [“Denum(3,0,0)”, “Denum(0,3,0)”, “Denum(0,0,4)”]",
2222
+ "; [Denum [2, (0 - 1), 0], Denum [(0 - 1), 1, 1], Denum [(5 - 3), (5 - 7), 0], Denum [2, 1], Denum 5, Denum [2, 1.5, 0], Denum [2, 1, 0, 0]]",
2223
+ "# [$!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum]",
2224
+ "```",
2225
+ "## Constructor forms",
2226
+ "",
2227
+ "`Denum [loads]` is the default-Count form: the Count is 1. It is a constructor",
2228
+ "convention. An explicit Count, zero included, is kept as given. `[C, loads]` and",
2229
+ "the binary `[C, L, R]` are the explicit forms, and any arity of one or more",
2230
+ "loads is a Denum",
2231
+ "```",
2232
+ "; [“” (Denum [[2, 5]]), “” (Denum [0, [2, 5]]), “” (Denum [[7]]), “” (Denum [[2, 5, 3]])]",
2233
+ "# [“Denum(1,2,5)”, “Denum(0,2,5)”, “Denum(1,[7])”, “Denum(1,[2, 5, 3])”]",
2234
+ "; [“” (Denum [3, [2, 5, 3, 7, 4]]), “” (Denum [0, [1]]), “” (Denum [2, 2, 5]), “” (Denum [3, [4]])]",
2235
+ "# [“Denum(3,[2, 5, 3, 7, 4])”, “Denum(0,[1])”, “Denum(2,2,5)”, “Denum(3,[4])”]",
2236
+ "; [(Denum [[2, 5]]).#, (Denum [[2, 5]]).##, (Denum [[2, 5]]) = (Denum [1, [2, 5]]), (Denum [[2, 5]]) = (Denum [1, 2, 5])]",
2237
+ "# [1, 7, <>, <>]",
2238
+ "; (Denum [[123456789012345678901234567890, 5, 3]]).##",
2239
+ "# 123456789012345678901234567898",
2240
+ "```",
2241
+ "A default form is refused like an explicit one when its loads are not whole,",
2242
+ "and the one-argument form takes a list of loads, never a bare number",
2243
+ "```",
2244
+ "; [Denum [[]], Denum [[1, (0 - 1)]], Denum [[1.5, 2]], Denum [[“a”]], Denum [5], Denum [(0 - 1)], Denum [[[1]]], Denum [[2, 5], [1]], Denum []]",
2245
+ "# [$!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum]",
2246
+ "; [Denum [1.5, [2, 5]], Denum [(0 - 1), [2, 5]], Denum [“a”, [2, 5]], Denum [2, [2, (0 - 1)]], Denum [2, []], Denum [2, 5], Denum [2, 1, 2, 3]]",
2247
+ "# [$!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum]",
2248
+ "```",
2249
+ "The binary Denum's phase is not state. It is read from the Count's parity, so",
2250
+ "routing follows the Count alone, in both parities, with the Count alone",
2251
+ "deciding the next channel",
2252
+ "```",
2253
+ "; [(Denum [2, 0, 0]) 5, (Denum [3, 0, 0]) 5] & {“” _}",
2254
+ "# [“Denum(3,5,0)”, “Denum(4,0,5)”]",
2255
+ "```",
2256
+ "A Denum stores its Count and loads and nothing else, so its readings cannot",
2257
+ "drift from them. Along any run of applications, deposits and scalings, in",
2258
+ "either parity, the phase is the Count's parity, the left and right loads are",
2259
+ "the stored loads, the Size is their sum, and the fourth hash is the state",
2260
+ "itself. The readings are applied to nil; any other operand is refused",
2261
+ "```",
2262
+ "; .walk {.s _; [s, (s 5), ((s 5) - 2), (((s 5) - 2) + 3), ((((s 5) - 2) + 3) * 2), (((((s 5) - 2) + 3) * 2) 0)]};",
2263
+ "; .agree {.k _; .p (((k.# %% 2) = 0) ? {2} : {1}); ((((k.phase ()) = p) ? {[k.left (), k.right ()] = k.loads}) ? {k.## = (k.loads).##}) ? {k.#### = k}};",
2264
+ "; [(walk (Denum [0, 0, 0])) & agree, (walk (Denum [1, 4, 1])) & agree]",
2265
+ "# [[<>, <>, <>, <>, <>, <>], [<>, <>, <>, <>, <>, <>]]",
2266
+ "; [(Denum [3, 5, 1]).phase 0, (Denum [3, 5, 1]).left [], (Denum [3, 5, 1]).right “a”]",
2267
+ "# [$!!.unary-observation, $!!.unary-observation, $!!.unary-observation]",
2206
2268
  "```",
2207
2269
  "## Application",
2208
2270
  "",
@@ -2211,15 +2273,15 @@ export const HC_SOURCES = new Map([
2211
2273
  "as it was",
2212
2274
  "```",
2213
2275
  "; “” (d [5, 3])",
2214
- "# “Demi(1,8,0)”",
2276
+ "# “Denum(1,8,0)”",
2215
2277
  "; “” d",
2216
- "# “Demi(0,0,0)”",
2278
+ "# “Denum(0,0,0)”",
2217
2279
  "; “” (((d 5) 3) 7)",
2218
- "# “Demi(3,12,3)”",
2280
+ "# “Denum(3,12,3)”",
2219
2281
  "```",
2220
2282
  "A Size of zero deposits nothing and still counts, in both phases",
2221
2283
  "```",
2222
- "; [(d 0).count, ((d 0) 0).count, (d 0).phase, ((d 0) 0).phase, (d 0).left, ((d 0) 0).right]",
2284
+ "; [(d 0).count, ((d 0) 0).count, (d 0).phase (), ((d 0) 0).phase (), (d 0).left (), ((d 0) 0).right ()]",
2223
2285
  "# [1, 2, 1, 2, 0, 0]",
2224
2286
  "```",
2225
2287
  "Any Frame is applied by its Size, measured without running it: text, the",
@@ -2227,43 +2289,43 @@ export const HC_SOURCES = new Map([
2227
2289
  "word, so `{5 + 3}` is 9), empty text, and loads too large for a machine integer",
2228
2290
  "```",
2229
2291
  "; “” ((((((d “hello”) []) <>) [[1, 2], [3]]) {5 + 3}) “”)",
2230
- "# “Demi(6,15,7)”",
2292
+ "# “Denum(6,15,7)”",
2231
2293
  "; “” ((d 123456789012345678901234567890) 987654321098765432109876543210)",
2232
- "# “Demi(2,123456789012345678901234567890,987654321098765432109876543210)”",
2294
+ "# “Denum(2,123456789012345678901234567890,987654321098765432109876543210)”",
2233
2295
  "```",
2234
2296
  "A Frame without a Size is not deposited: its failure is the answer",
2235
2297
  "```",
2236
2298
  "; d ([].nope)",
2237
2299
  "# $!.name-missing “...",
2238
2300
  "; “” d",
2239
- "# “Demi(0,0,0)”",
2301
+ "# “Denum(0,0,0)”",
2240
2302
  "```",
2241
2303
  "Deposit reads the receiver through `_^`, so an argument that holds fields of",
2242
2304
  "the same names deposits by its Size and nothing else",
2243
2305
  "```",
2244
2306
  "; “” (d [.count 50; .left 99; .phase 1; .s 100; 4])",
2245
- "# “Demi(1,4,0)”",
2246
- "; “” ((Demi [2, 5, 3]) [.count 50; .left 99; .right 7; 4])",
2247
- "# “Demi(3,9,3)”",
2307
+ "# “Denum(1,4,0)”",
2308
+ "; “” ((Denum [2, 5, 3]) [.count 50; .left 99; .right 7; 4])",
2309
+ "# “Denum(3,9,3)”",
2248
2310
  "```",
2249
- "A Demi captured by a closure, mapped, or reduced is applied the same way, and",
2311
+ "A Denum captured by a closure, mapped, or reduced is applied the same way, and",
2250
2312
  "the captured one stays as it was",
2251
2313
  "```",
2252
- "; .start (Demi [0, 0, 0]); .step {start _};",
2314
+ "; .start (Denum [0, 0, 0]); .step {start _};",
2253
2315
  "; [“” (step 5), “” (step 3), “” start]",
2254
- "# [“Demi(1,5,0)”, “Demi(1,3,0)”, “Demi(0,0,0)”]",
2316
+ "# [“Denum(1,5,0)”, “Denum(1,3,0)”, “Denum(0,0,0)”]",
2255
2317
  "; [d, a] & {“” (_ 5)}",
2256
- "# [“Demi(1,5,0)”, “Demi(3,10,3)”]",
2257
- "; “” ([5, 3, 7] | (Demi [0, 0, 0]))",
2258
- "# “Demi(3,12,3)”",
2318
+ "# [“Denum(1,5,0)”, “Denum(3,10,3)”]",
2319
+ "; “” ([5, 3, 7] | (Denum [0, 0, 0]))",
2320
+ "# “Denum(3,12,3)”",
2259
2321
  "```",
2260
- "Through a mutable name, application writes the Demi in place",
2322
+ "Through a mutable name, application writes the Denum in place",
2261
2323
  "```",
2262
- "; .m_ (Demi [0, 0, 0]);",
2324
+ "; .m_ (Denum [0, 0, 0]);",
2263
2325
  "; m_ 5;",
2264
2326
  "; m_ 3;",
2265
- "; [“” m_, m_.count, m_.phase]",
2266
- "# [“Demi(2,5,3)”, 2, 2]",
2327
+ "; [“” m_, m_.count, m_.phase ()]",
2328
+ "# [“Denum(2,5,3)”, 2, 2]",
2267
2329
  "```",
2268
2330
  "## Application counts",
2269
2331
  "",
@@ -2272,10 +2334,10 @@ export const HC_SOURCES = new Map([
2272
2334
  "Size and residual are the alternating route's, from the left or from the right",
2273
2335
  "```",
2274
2336
  "; .chain {.s _; [s, (s 5), ((s 5) 3), (((s 5) 3) 7), ((((s 5) 3) 7) 2)]};",
2275
- "; .c0 (chain (Demi [0, 0, 0])); .c1 (chain (Demi [1, 0, 0]));",
2276
- "; [c0 & {_.count}, c0 & {_.phase}, c0 & {_.##}, c0 & {_.###}]",
2337
+ "; .c0 (chain (Denum [0, 0, 0])); .c1 (chain (Denum [1, 0, 0]));",
2338
+ "; [c0 & {_.count}, c0 & {_.phase ()}, c0 & {_.##}, c0 & {_.###}]",
2277
2339
  "# [[0, 1, 2, 3, 4], [2, 1, 2, 1, 2], [0, 5, 8, 15, 17], [0, 5, 2, 9, 7]]",
2278
- "; [c1 & {_.count}, c1 & {_.phase}, c1 & {_.##}, c1 & {_.###}]",
2340
+ "; [c1 & {_.count}, c1 & {_.phase ()}, c1 & {_.##}, c1 & {_.###}]",
2279
2341
  "# [[1, 2, 3, 4, 5], [1, 2, 1, 2, 1], [0, 5, 8, 15, 17], [0, -5, -2, -9, -7]]",
2280
2342
  "```",
2281
2343
  "The Count and the loads together are the state, and the fourth hash of each step",
@@ -2286,38 +2348,38 @@ export const HC_SOURCES = new Map([
2286
2348
  "```",
2287
2349
  "## Observers",
2288
2350
  "",
2289
- "A Demi's Count is its stored Count, its Size the total load and its residual the",
2290
- "signed difference, including a present zero-load Demi in either phase",
2351
+ "A Denum's Count is its stored Count, its Size the total load and its residual the",
2352
+ "signed difference, including a present zero-load Denum in either phase",
2291
2353
  "```",
2292
- "; .e (Demi [3, 12, 3]);",
2293
- "; [e.#, e.##, e.###, e.phase]",
2354
+ "; .e (Denum [3, 12, 3]);",
2355
+ "; [e.#, e.##, e.###, e.phase ()]",
2294
2356
  "# [3, 15, 9, 1]",
2295
- "; [d.#, d.##, d.###, (Demi [1, 0, 0]).#, (Demi [1, 0, 0]).phase]",
2357
+ "; [d.#, d.##, d.###, (Denum [1, 0, 0]).#, (Denum [1, 0, 0]).phase ()]",
2296
2358
  "# [0, 0, 0, 1, 1]",
2297
2359
  "```",
2298
2360
  "Count is `.#`, not phase. The same phase and loads with a different Count are",
2299
2361
  "different states with the same Size and residual",
2300
2362
  "```",
2301
- "; .f2 (Demi [2, 5, 1]); .f4 (Demi [4, 5, 1]);",
2302
- "; [f2.phase = f4.phase, f2.## = f4.##, f2.### = f4.###, f2.# = f4.#, f2 = f4, f2 = (Demi [2, 5, 1])]",
2363
+ "; .f2 (Denum [2, 5, 1]); .f4 (Denum [4, 5, 1]);",
2364
+ "; [(f2.phase ()) = (f4.phase ()), f2.## = f4.##, f2.### = f4.###, f2.# = f4.#, f2 = f4, f2 = (Denum [2, 5, 1])]",
2303
2365
  "# [<>, <>, <>, (), (), <>]",
2304
- "; [f2.#, f4.#, f2.##, f2.###, f2.phase, f4.phase]",
2366
+ "; [f2.#, f4.#, f2.##, f2.###, f2.phase (), f4.phase ()]",
2305
2367
  "# [2, 4, 6, 4, 2, 2]",
2306
2368
  "```",
2307
- "A Demi inside an aggregate contributes its declared Size",
2369
+ "A Denum inside an aggregate contributes its declared Size",
2308
2370
  "```",
2309
- "; [[e, e].##, [e, d].###, [e].#### = (Demi [1, 15, 0])]",
2371
+ "; [[e, e].##, [e, d].###, [e].#### = (Denum [1, 15, 0])]",
2310
2372
  "# [30, 15, <>]",
2311
2373
  "```",
2312
2374
  "## The fourth hash",
2313
2375
  "",
2314
- "`.####` of a Demi is that Demi, however often it is taken. It is equal, not",
2376
+ "`.####` of a Denum is that Denum, however often it is taken. It is equal, not",
2315
2377
  "identical: each observation builds a new instance. Its Count is kept for every",
2316
2378
  "Count, including zero",
2317
2379
  "```",
2318
2380
  "; [e.#### = e, e.#### === e, e.#### == e, ((e.####).####).#### = e, (e.####).# = e.#]",
2319
2381
  "# [<>, (), <>, <>, <>]",
2320
- "; [d.#### = d, (Demi [1, 0, 0]).#### = (Demi [1, 0, 0]), (Demi [100, 5, 3]).####.count, (Demi [0, 3, 0]).#### = (Demi [0, 3, 0])]",
2382
+ "; [d.#### = d, (Denum [1, 0, 0]).#### = (Denum [1, 0, 0]), (Denum [100, 5, 3]).####.count, (Denum [0, 3, 0]).#### = (Denum [0, 3, 0])]",
2321
2383
  "# [<>, <>, 100, <>]",
2322
2384
  "; [f2.####.# , f4.####.#, f2.#### = f4.####, f2.#### = f2]",
2323
2385
  "# [2, 4, (), <>]",
@@ -2326,47 +2388,47 @@ export const HC_SOURCES = new Map([
2326
2388
  "so it compares equal to one built here. The host's whole Count is kept: it is",
2327
2389
  "not reduced to its parity",
2328
2390
  "```",
2329
- "; [[5, 3].#### = (Demi [2, 5, 3]), “hello”.#### = (Demi [5, 3, 2]), [0].#### = (Demi [1, 0, 0])]",
2391
+ "; [[5, 3].#### = (Denum [2, 5, 3]), “hello”.#### = (Denum [5, 3, 2]), [0].#### = (Denum [1, 0, 0])]",
2330
2392
  "# [<>, <>, <>]",
2331
- "; [[5, 3].####.#, “hello”.####.#, “hello”.####.phase, [5, 3, 7].####.#, [5, 3, 7].####.phase]",
2393
+ "; [[5, 3].####.#, “hello”.####.#, “hello”.####.phase (), [5, 3, 7].####.#, [5, 3, 7].####.phase ()]",
2332
2394
  "# [2, 5, 1, 3, 1]",
2333
2395
  "; “” [5, 3, 7].####",
2334
- "# “Demi(3,12,3)”",
2396
+ "# “Denum(3,12,3)”",
2335
2397
  "```",
2336
2398
  "Hosts whose Counts differ by an even number do not share a fourth hash, though",
2337
2399
  "they share phase and, here, loads",
2338
2400
  "```",
2339
- "; [[5, 3].#### = [5, 3, 0, 0].####, [5, 3].####.phase = [5, 3, 0, 0].####.phase, [5, 3].####.## = [5, 3, 0, 0].####.##]",
2401
+ "; [[5, 3].#### = [5, 3, 0, 0].####, ([5, 3].####.phase ()) = ([5, 3, 0, 0].####.phase ()), [5, 3].####.## = [5, 3, 0, 0].####.##]",
2340
2402
  "# [(), <>, <>]",
2341
2403
  "```",
2342
- "It is nil where there is no Demi: an empty host, Count zero, no Count, or no",
2343
- "residual. A host with no children is not a Demi of Count zero. Properties are",
2404
+ "It is nil where there is no Denum: an empty host, Count zero, no Count, or no",
2405
+ "residual. A host with no children is not a Denum of Count zero. Properties are",
2344
2406
  "not elements, sharing counts each occurrence, and a group observes as its",
2345
2407
  "elements",
2346
2408
  "```",
2347
2409
  "; [[].####, 0.####, ().####, <2,3,5>.####, “”.####]",
2348
2410
  "# [(), (), (), (), ()]",
2349
2411
  "; .shared [1, 2];",
2350
- "; [[.a 100; 5, 3].#### = [5, 3].####, [shared, shared].#### = (Demi [2, 3, 3]), (5, 3).#### = (Demi [2, 5, 3])]",
2412
+ "; [[.a 100; 5, 3].#### = [5, 3].####, [shared, shared].#### = (Denum [2, 3, 3]), (5, 3).#### = (Denum [2, 5, 3])]",
2351
2413
  "# [<>, <>, <>]",
2352
2414
  "```",
2353
- "The two zero-Count cases are different. A constructed `Demi [0, 0, 0]` is a",
2415
+ "The two zero-Count cases are different. A constructed `Denum [0, 0, 0]` is a",
2354
2416
  "present value, while the empty host and the Count 0 have none. They agree on",
2355
2417
  "Count, Size and residual, so the difference is not read from the observers: the",
2356
2418
  "fourth hash recognizes an instance of this class (007.25e)",
2357
2419
  "```",
2358
2420
  "; [[].# = d.#, [].## = d.##, 0.## = d.##, 0.### = d.###]",
2359
2421
  "# [<>, (), <>, <>]",
2360
- "; [[].#### = (), 0.#### = (), d.#### = d, ((Demi [0, 0, 0]).####).count]",
2422
+ "; [[].#### = (), 0.#### = (), d.#### = d, ((Denum [0, 0, 0]).####).count]",
2361
2423
  "# [<>, <>, <>, 0]",
2362
2424
  "```",
2363
- "Zero-Count Demis reached without an application are present too, and so is",
2425
+ "Zero-Count Denums reached without an application are present too, and so is",
2364
2426
  "each functional update of one",
2365
2427
  "```",
2366
- "; [“” ((Demi [0, 3, 0]).####), “” ((d + 4).####), “” ((d - 2.5).####), “” ((d * 7).####)]",
2367
- "# [“Demi(0,3,0)”, “Demi(0,0,4)”, “Demi(0,2,0)”, “Demi(0,0,0)”]",
2428
+ "; [“” ((Denum [0, 3, 0]).####), “” ((d + 4).####), “” ((d - 2.5).####), “” ((d * 7).####)]",
2429
+ "# [“Denum(0,3,0)”, “Denum(0,0,4)”, “Denum(0,2,0)”, “Denum(0,0,0)”]",
2368
2430
  "```",
2369
- "## Only a Demi is a Demi",
2431
+ "## Only a Denum is a Denum",
2370
2432
  "",
2371
2433
  "No class declares its own `.####`. An aggregate that declares a method under",
2372
2434
  "that name keeps it as an ordinary property, which the fourth hash never runs:",
@@ -2376,30 +2438,30 @@ export const HC_SOURCES = new Map([
2376
2438
  "```",
2377
2439
  "; .noted_ [.n 0; .bump_ {@n (_^.n + 1);}];",
2378
2440
  "; .Liar [.#### {[.# {0}; .## {0}; .### {0}]}];",
2379
- "; .Loud [.#### {noted_.bump_ (); Demi [0, 0, 0]}];",
2441
+ "; .Loud [.#### {noted_.bump_ (); Denum [0, 0, 0]}];",
2380
2442
  "; .Selfish [.#### {_^.####}];",
2381
2443
  "; .Broken [.#### {[].nope}];",
2382
2444
  "; [Liar.####, Loud.####, Selfish.####, Broken.####, noted_.n]",
2383
2445
  "# [(), (), (), (), 0]",
2384
- "; [“” ([.#### {Demi [9, 9, 9]}; 5, 3].####), [.#### {Demi [9, 9, 9]}; 5, 3].#### = [5, 3].####]",
2385
- "# [“Demi(2,5,3)”, <>]",
2446
+ "; [“” ([.#### {Denum [9, 9, 9]}; 5, 3].####), [.#### {Denum [9, 9, 9]}; 5, 3].#### = [5, 3].####]",
2447
+ "# [“Denum(2,5,3)”, <>]",
2386
2448
  "```",
2387
- "Forged observers do not make a Demi. An aggregate declaring Count, Size and",
2388
- "residual 0, 0, 0 reads exactly as `Demi [0, 0, 0]` does, and still has no Demi,",
2389
- "because it is not one; with a nonzero Count it gets the derived Demi of those",
2449
+ "Forged observers do not make a Denum. An aggregate declaring Count, Size and",
2450
+ "residual 0, 0, 0 reads exactly as `Denum [0, 0, 0]` does, and still has no Denum,",
2451
+ "because it is not one; with a nonzero Count it gets the derived Denum of those",
2390
2452
  "observers, a fresh instance of this class, never the aggregate itself",
2391
2453
  "```",
2392
2454
  "; .Zero [.# {0}; .## {0}; .### {0}];",
2393
2455
  "; .Three [.# {3}; .## {5}; .### {1}];",
2394
2456
  "; [[Zero.#, Zero.##, Zero.###] = [d.#, d.##, d.###], Zero.####, “” Three.####, Three.#### = Three]",
2395
- "# [<>, (), “Demi(3,3,2)”, ()]",
2457
+ "# [<>, (), “Denum(3,3,2)”, ()]",
2396
2458
  "```",
2397
- "Fields named like a Demi's are not enough either. Recognition compares the",
2398
- "whole instance, fields and methods, by typed equality `==` with the Demi the",
2399
- "constructor builds from the stored `count`, `left` and `right`. So a bare record",
2459
+ "Fields named like a Denum's are not enough either. Recognition compares the",
2460
+ "whole instance, fields and methods, by typed equality `==` with the Denum the",
2461
+ "constructor builds from the stored `count` and `loads`. So a bare record",
2400
2462
  "of those fields, one whose phase disagrees with its Count, one whose Count is a",
2401
2463
  "decimal, and one that adds a field are foreign, and with Count zero they have",
2402
- "no Demi",
2464
+ "no Denum",
2403
2465
  "```",
2404
2466
  "; .Rec [.count 0; .phase 2; .left 0; .right 0];",
2405
2467
  "; .Fake [.count 0; .phase 1; .left 0; .right 0; .# {_^ .count}; .## {_^ .left + _^ .right}; .### {_^ .left - _^ .right}];",
@@ -2407,15 +2469,15 @@ export const HC_SOURCES = new Map([
2407
2469
  "; [Rec.####, Fake.####, Dec.####, [.extra 1; .count 0; .left 0; .right 0].####]",
2408
2470
  "# [(), (), (), ()]",
2409
2471
  "```",
2410
- "A Demi with a Count is recognized as one, and what it answers is a fresh",
2472
+ "A Denum with a Count is recognized as one, and what it answers is a fresh",
2411
2473
  "reconstruction from its stored state, equal to it and not it",
2412
2474
  "```",
2413
- "; [(Demi [3, 5, 1]).#### == (Demi [3, 5, 1]), (Demi [3, 5, 1]).#### === (Demi [3, 5, 1]), “” (Demi [3, 5, 1]).####]",
2414
- "# [<>, (), “Demi(3,5,1)”]",
2475
+ "; [(Denum [3, 5, 1]).#### == (Denum [3, 5, 1]), (Denum [3, 5, 1]).#### === (Denum [3, 5, 1]), “” (Denum [3, 5, 1]).####]",
2476
+ "# [<>, (), “Denum(3,5,1)”]",
2415
2477
  "```",
2416
2478
  "## Observing commutes with applying",
2417
2479
  "",
2418
- "For a nonempty host X, observing X Y is applying X's Demi to Y, and both equal",
2480
+ "For a nonempty host X, observing X Y is applying X's Denum to Y, and both equal",
2419
2481
  "the observation of the array X Y constructs, with Count one greater",
2420
2482
  "```",
2421
2483
  "; .X [5, “ab”, [1, 2]];",
@@ -2424,13 +2486,13 @@ export const HC_SOURCES = new Map([
2424
2486
  "```",
2425
2487
  "The empty host is the boundary. `[].####` is nil, a choice of convention",
2426
2488
  "(011.15g) rather than a theorem, and applying nil answers the argument, so",
2427
- "the equation as written fails there. Lifting the empty host to the Demi of",
2489
+ "the equation as written fails there. Lifting the empty host to the Denum of",
2428
2490
  "Count zero restores it: that is the initialized-router reading, and it is also",
2429
2491
  "what a reduce starts from",
2430
2492
  "```",
2431
- "; [([] 7).#### = ([].#### 7), ([] 7).#### = ((Demi [0, 0, 0]) 7), ([] 7).#### = ([7] | (Demi [0, 0, 0]))]",
2493
+ "; [([] 7).#### = ([].#### 7), ([] 7).#### = ((Denum [0, 0, 0]) 7), ([] 7).#### = ([7] | (Denum [0, 0, 0]))]",
2432
2494
  "# [(), <>, <>]",
2433
- "; [] | (Demi [0, 0, 0]) = (Demi [0, 0, 0])",
2495
+ "; [] | (Denum [0, 0, 0]) = (Denum [0, 0, 0])",
2434
2496
  "# <>",
2435
2497
  "```",
2436
2498
  "## Scaling and Star",
@@ -2439,7 +2501,7 @@ export const HC_SOURCES = new Map([
2439
2501
  "one is the identity, and scaling composes",
2440
2502
  "```",
2441
2503
  "; [“” (e.scale_ 2), “” (e.scale_ 0), (e.scale_ 1) = e, ((e.scale_ 2).scale_ 3) = (e.scale_ 6), (e.scale_ 2).#]",
2442
- "# [“Demi(3,24,6)”, “Demi(3,0,0)”, <>, <>, 3]",
2504
+ "# [“Denum(3,24,6)”, “Denum(3,0,0)”, <>, <>, 3]",
2443
2505
  "; e.scale_ (0 - 2)",
2444
2506
  "# $!!.invalid-scale",
2445
2507
  "```",
@@ -2450,34 +2512,34 @@ export const HC_SOURCES = new Map([
2450
2512
  "```",
2451
2513
  "## Arithmetic",
2452
2514
  "",
2453
- "Three operators act on a Demi's state, each reading its operand through the one",
2515
+ "Three operators act on a Denum's state, each reading its operand through the one",
2454
2516
  "Size observer `x.##`. They are fixed-channel load transformations consistent",
2455
2517
  "with a `RotorRouter`'s channel loads (`hc/rotor-router.hc`), not named Router",
2456
- "methods. `+`, `-` and `*` **construct a fresh Demi** from observations of their",
2518
+ "methods. `+`, `-` and `*` **construct a fresh Denum** from observations of their",
2457
2519
  "operands: `+` is tally, depositing `x.##` on the right; `-` is alternator,",
2458
2520
  "depositing on the left; and `*` is inlay, scaling both loads by `x.##` through",
2459
2521
  "`scale_`, the Star shadow. Each keeps the Count, and so the phase, answers a",
2460
2522
  "fresh value and leaves its operand as it was, so they compose by nesting",
2461
2523
  "```",
2462
- "; .D (Demi [2, 5, 3]);",
2524
+ "; .D (Denum [2, 5, 3]);",
2463
2525
  "; [“” (D + 4), “” (D - 4), “” (D * 3)]",
2464
- "# [“Demi(2,5,7)”, “Demi(2,9,3)”, “Demi(2,15,9)”]",
2526
+ "# [“Denum(2,5,7)”, “Denum(2,9,3)”, “Denum(2,15,9)”]",
2465
2527
  "; [“” ((D + 4) - 2), “” ((D - 2) + 4), “” ((D + 4) * 3)]",
2466
- "# [“Demi(2,7,7)”, “Demi(2,7,7)”, “Demi(2,15,21)”]",
2528
+ "# [“Denum(2,7,7)”, “Denum(2,7,7)”, “Denum(2,15,21)”]",
2467
2529
  "; “” D",
2468
- "# “Demi(2,5,3)”",
2530
+ "# “Denum(2,5,3)”",
2469
2531
  "```",
2470
2532
  "A deposit keeps the Count and phase, including phase 1, where application would",
2471
- "flip it, and a zero Size deposits nothing while still answering a Demi. The",
2533
+ "flip it, and a zero Size deposits nothing while still answering a Denum. The",
2472
2534
  "operand is measured by its Size, so any sized Frame deposits",
2473
2535
  "```",
2474
- "; [(D + 4).#, (D - 4).#, (D * 3).#, (D + 4).count, (D + 4).phase]",
2536
+ "; [(D + 4).#, (D - 4).#, (D * 3).#, (D + 4).count, (D + 4).phase ()]",
2475
2537
  "# [2, 2, 2, 2, 2]",
2476
- "; .P (Demi [1, 5, 3]);",
2477
- "; [“” (P + 4), (P + 4).#, (P + 4).phase, “” (P - 4)]",
2478
- "# [“Demi(1,5,7)”, 1, 1, “Demi(1,9,3)”]",
2538
+ "; .P (Denum [1, 5, 3]);",
2539
+ "; [“” (P + 4), (P + 4).#, (P + 4).phase (), “” (P - 4)]",
2540
+ "# [“Denum(1,5,7)”, 1, 1, “Denum(1,9,3)”]",
2479
2541
  "; [“” (D + 0), “” (D - 0), “” (D [3, 4])]",
2480
- "# [“Demi(2,5,3)”, “Demi(2,5,3)”, “Demi(3,12,3)”]",
2542
+ "# [“Denum(2,5,3)”, “Denum(2,5,3)”, “Denum(3,12,3)”]",
2481
2543
  "```",
2482
2544
  "Deposit is not application and deposit is not subtraction. `D x` adds one to the",
2483
2545
  "Count and flips the phase, and `D + x` does not, so they reach different",
@@ -2486,7 +2548,7 @@ export const HC_SOURCES = new Map([
2486
2548
  "```",
2487
2549
  "; [(D + 4).###, (D - 4).###, D.###]",
2488
2550
  "# [-2, 6, 2]",
2489
- "; [((D 4).# = (D + 4).#), (D 4).###, (D + 4).###, (D 4).#, (D 4).phase]",
2551
+ "; [((D 4).# = (D + 4).#), (D 4).###, (D + 4).###, (D 4).#, (D 4).phase ()]",
2490
2552
  "# [(), 6, -2, 3, 1]",
2491
2553
  "```",
2492
2554
  "Order of a right then a left deposit does not matter, and scaling after a",
@@ -2497,7 +2559,7 @@ export const HC_SOURCES = new Map([
2497
2559
  "```",
2498
2560
  "A sizeless host refuses on all three operators, its failure the answer, as",
2499
2561
  "application refuses it. `*` reads its operand's Size rather than demanding a",
2500
- "bare Count, so a Demi, an aggregate or a decimal works through its `.##`, while",
2562
+ "bare Count, so a Denum, an aggregate or a decimal works through its `.##`, while",
2501
2563
  "`D * 0` still annihilates",
2502
2564
  "```",
2503
2565
  "; [D + ([].nope), D - ([].nope), D * ([].nope)]",
@@ -2507,55 +2569,55 @@ export const HC_SOURCES = new Map([
2507
2569
  "",
2508
2570
  "`+` and `-` read their operand through the one Size observer as `*` does, so",
2509
2571
  "any sized Frame deposits its Size: a decimal its truncated magnitude, text its",
2510
- "characters, an aggregate its element count, a Demi `L + R`, and a closure one",
2511
- "per word. These are the review's own examples, from `Demi [0, 0, 0]`",
2572
+ "characters, an aggregate its element count, a Denum `L + R`, and a closure one",
2573
+ "per word. These are the review's own examples, from `Denum [0, 0, 0]`",
2512
2574
  "```",
2513
2575
  "; [(2.5).##, (1.5).##, (0 - 1.5).##]",
2514
2576
  "# [2, 1, 1]",
2515
- "; [“” ((Demi [0, 0, 0]) + 2), “” ((Demi [0, 0, 0]) + 2.5), “” ((Demi [0, 0, 0]) - 1.5), “” ((Demi [1, 2, 2]) * 2.5)]",
2516
- "# [“Demi(0,0,2)”, “Demi(0,0,2)”, “Demi(0,1,0)”, “Demi(1,4,4)”]",
2577
+ "; [“” ((Denum [0, 0, 0]) + 2), “” ((Denum [0, 0, 0]) + 2.5), “” ((Denum [0, 0, 0]) - 1.5), “” ((Denum [1, 2, 2]) * 2.5)]",
2578
+ "# [“Denum(0,0,2)”, “Denum(0,0,2)”, “Denum(0,1,0)”, “Denum(1,4,4)”]",
2517
2579
  "; [“” (D + 2.5), “” (D - 2.5), “” (P + 0.5), “” (P - (0 - 3.5))]",
2518
- "# [“Demi(2,5,5)”, “Demi(2,7,3)”, “Demi(1,5,3)”, “Demi(1,8,3)”]",
2519
- "; [“” (D + “abc”), “” (D - [[], []]), “” (D + (Demi [1, 2, 4])), “” (D - {5 + 3}), “” (D + <>), “” (D - [])]",
2520
- "# [“Demi(2,5,6)”, “Demi(2,7,3)”, “Demi(2,5,9)”, “Demi(2,14,3)”, “Demi(2,5,4)”, “Demi(2,6,3)”]",
2580
+ "# [“Denum(2,5,5)”, “Denum(2,7,3)”, “Denum(1,5,3)”, “Denum(1,8,3)”]",
2581
+ "; [“” (D + “abc”), “” (D - [[], []]), “” (D + (Denum [1, 2, 4])), “” (D - {5 + 3}), “” (D + <>), “” (D - [])]",
2582
+ "# [“Denum(2,5,6)”, “Denum(2,7,3)”, “Denum(2,5,9)”, “Denum(2,14,3)”, “Denum(2,5,4)”, “Denum(2,6,3)”]",
2521
2583
  "```",
2522
2584
  "Each keeps the full Count, and with it the phase, in both parities; leaves the",
2523
2585
  "receiver as it was, even through a mutable name; and refuses a sizeless operand",
2524
2586
  "with its failure",
2525
2587
  "```",
2526
- "; [(D + 2.5).#, (D + 2.5).phase, (P - 1.5).#, (P - 1.5).phase, “” D, “” P]",
2527
- "# [2, 2, 1, 1, “Demi(2,5,3)”, “Demi(1,5,3)”]",
2528
- "; .q_ (Demi [2, 5, 3]);",
2588
+ "; [(D + 2.5).#, (D + 2.5).phase (), (P - 1.5).#, (P - 1.5).phase (), “” D, “” P]",
2589
+ "# [2, 2, 1, 1, “Denum(2,5,3)”, “Denum(1,5,3)”]",
2590
+ "; .q_ (Denum [2, 5, 3]);",
2529
2591
  "; [“” (q_ + 2.5), “” (q_ - 2.5), “” (q_ * 2.5), “” q_]",
2530
- "# [“Demi(2,5,5)”, “Demi(2,7,3)”, “Demi(2,10,6)”, “Demi(2,5,3)”]",
2531
- "; [D + ([2.5].nope), D - ([2.5].nope), (Demi [0, 0, 0]) + ([].nope)]",
2592
+ "# [“Denum(2,5,5)”, “Denum(2,7,3)”, “Denum(2,10,6)”, “Denum(2,5,3)”]",
2593
+ "; [D + ([2.5].nope), D - ([2.5].nope), (Denum [0, 0, 0]) + ([].nope)]",
2532
2594
  "# [$!.name-missing “..., $!.name-missing “..., $!.name-missing “...]",
2533
2595
  "```",
2534
2596
  "The argument cannot reach the receiver's names. A decimal is unit-taggable,",
2535
- "`2.5.Demi` is a tagged number, and an aggregate can hold fields named like the",
2597
+ "`2.5.Denum` is a tagged number, and an aggregate can hold fields named like the",
2536
2598
  "receiver's or its locals; none of them changes which state is updated, and",
2537
2599
  "such an aggregate deposits only its elements' Size, here 4",
2538
2600
  "```",
2539
- "; (2.5).Demi",
2540
- "# 2.5.Demi",
2541
- "; [“” (D + [.Demi 9; .right 99; .left 99; .count 7; .k 50; 4]), “” (D - [.Demi 9; .left 99; .l 99; .s 50; 4])]",
2542
- "# [“Demi(2,5,7)”, “Demi(2,9,3)”]",
2601
+ "; (2.5).Denum",
2602
+ "# 2.5.Denum",
2603
+ "; [“” (D + [.Denum 9; .right 99; .left 99; .count 7; .k 50; 4]), “” (D - [.Denum 9; .left 99; .l 99; .s 50; 4])]",
2604
+ "# [“Denum(2,5,7)”, “Denum(2,9,3)”]",
2543
2605
  "```",
2544
2606
  "The functional updates behind them take a Count, so a negative or fractional",
2545
- "deposit is not a Demi",
2607
+ "deposit is not a Denum",
2546
2608
  "```",
2547
2609
  "; [D.deposit-right_ (0 - 1), D.deposit-left_ 2.5, “” (D.deposit-right_ 2), “” (D.deposit-left_ 2), “” D]",
2548
- "# [$!!.invalid-demi, $!!.invalid-demi, “Demi(2,5,5)”, “Demi(2,7,3)”, “Demi(2,5,3)”]",
2610
+ "# [$!!.invalid-denum, $!!.invalid-denum, “Denum(2,5,5)”, “Denum(2,7,3)”, “Denum(2,5,3)”]",
2549
2611
  "```",
2550
- "`*` scales by the operand's Size, so its domain is every sized Frame: a Demi",
2612
+ "`*` scales by the operand's Size, so its domain is every sized Frame: a Denum",
2551
2613
  "contributes `L + R`, an aggregate its element count, a decimal its truncated",
2552
2614
  "magnitude, and a zero Size annihilates both loads. `D * 3` is unchanged, since",
2553
2615
  "`3.## = 3`, and the result keeps the Count in either parity",
2554
2616
  "```",
2555
- "; [“” (D * (Demi [1, 2, 4])), “” (D * [[], []]), “” (D * 2.5), “” (D * 0)]",
2556
- "# [“Demi(2,30,18)”, “Demi(2,10,6)”, “Demi(2,10,6)”, “Demi(2,0,0)”]",
2617
+ "; [“” (D * (Denum [1, 2, 4])), “” (D * [[], []]), “” (D * 2.5), “” (D * 0)]",
2618
+ "# [“Denum(2,30,18)”, “Denum(2,10,6)”, “Denum(2,10,6)”, “Denum(2,0,0)”]",
2557
2619
  "; [“” (D * 1), (D * 3).#, (P * 3).#, “” (P * 3)]",
2558
- "# [“Demi(2,5,3)”, 2, 1, “Demi(1,15,9)”]",
2620
+ "# [“Denum(2,5,3)”, 2, 1, “Denum(1,15,9)”]",
2559
2621
  "```",
2560
2622
  "The signed-scalar reading misleads: `+` lowers the residual and `-` raises it,",
2561
2623
  "so `D + 4` is not “larger” than `D`, and `D - 4` is not `D` made smaller",
@@ -2567,11 +2629,11 @@ export const HC_SOURCES = new Map([
2567
2629
  "Count and can leave a zero Count over nonzero loads. That state is present, and",
2568
2630
  "its Size and residual read",
2569
2631
  "```",
2570
- "; .Y ((Demi [0, 0, 0]) + 4);",
2571
- "; [“” Y, “” ((Demi [0, 0, 0]) - 4), Y.count, Y.phase, Y.##, Y.###]",
2572
- "# [“Demi(0,0,4)”, “Demi(0,4,0)”, 0, 2, 4, -4]",
2573
- "; [“” (D * 3), (D.scale_ 2).#, ((D + 4) 1).#, ((D + 4) 1).phase]",
2574
- "# [“Demi(2,15,9)”, 2, 3, 1]",
2632
+ "; .Y ((Denum [0, 0, 0]) + 4);",
2633
+ "; [“” Y, “” ((Denum [0, 0, 0]) - 4), Y.count, Y.phase (), Y.##, Y.###]",
2634
+ "# [“Denum(0,0,4)”, “Denum(0,4,0)”, 0, 2, 4, -4]",
2635
+ "; [“” (D * 3), (D.scale_ 2).#, ((D + 4) 1).#, ((D + 4) 1).phase ()]",
2636
+ "# [“Denum(2,15,9)”, 2, 3, 1]",
2575
2637
  "```",
2576
2638
  "## Rational readings",
2577
2639
  "",
@@ -2580,7 +2642,7 @@ export const HC_SOURCES = new Map([
2580
2642
  "loads swapped the Size reading is unchanged and the residual reading changes",
2581
2643
  "sign. With `L = 5`, `R = 0` they are the improper 5/2, neither 2 nor 3",
2582
2644
  "```",
2583
- "; .A (Demi [2, 5, 1]); .B (Demi [2, 1, 5]); .D5 (Demi [2, 5, 0]);",
2645
+ "; .A (Denum [2, 5, 1]); .B (Denum [2, 1, 5]); .D5 (Denum [2, 5, 0]);",
2584
2646
  "; [[A.##, A.###, A.size-ratio (), A.residual-ratio ()], [B.##, B.###, B.size-ratio (), B.residual-ratio ()], [D5.##, D5.###, D5.size-ratio (), D5.residual-ratio ()]]",
2585
2647
  "# [[6, 4, 3, 2], [6, -4, 3, -2], [5, 5, 5/2, 5/2]]",
2586
2648
  "```",
@@ -2588,13 +2650,13 @@ export const HC_SOURCES = new Map([
2588
2650
  "reduces them: 6/4 reads 3/2, 8/6 reads 4/3. At `C = 1` they are the Size and the",
2589
2651
  "residual, and an odd Count works as an even one does",
2590
2652
  "```",
2591
- "; [(Demi [2, 3, 2]).size-ratio (), (Demi [2, 3, 2]).residual-ratio ()]",
2653
+ "; [(Denum [2, 3, 2]).size-ratio (), (Denum [2, 3, 2]).residual-ratio ()]",
2592
2654
  "# [5/2, 1/2]",
2593
- "; [(Demi [4, 6, 0]).size-ratio (), (Demi [4, 6, 0]).residual-ratio (), (Demi [4, 5, 1]).size-ratio (), (Demi [4, 5, 1]).residual-ratio ()]",
2655
+ "; [(Denum [4, 6, 0]).size-ratio (), (Denum [4, 6, 0]).residual-ratio (), (Denum [4, 5, 1]).size-ratio (), (Denum [4, 5, 1]).residual-ratio ()]",
2594
2656
  "# [3/2, 3/2, 3/2, 1]",
2595
- "; [(Demi [6, 10, 2]).size-ratio (), (Demi [6, 10, 2]).residual-ratio (), (Demi [3, 5, 1]).size-ratio (), (Demi [3, 5, 1]).residual-ratio ()]",
2657
+ "; [(Denum [6, 10, 2]).size-ratio (), (Denum [6, 10, 2]).residual-ratio (), (Denum [3, 5, 1]).size-ratio (), (Denum [3, 5, 1]).residual-ratio ()]",
2596
2658
  "# [2, 4/3, 2, 4/3]",
2597
- "; [(Demi [1, 7, 2]).size-ratio (), (Demi [1, 7, 2]).residual-ratio (), (Demi [1, 2, 7]).size-ratio (), (Demi [1, 2, 7]).residual-ratio ()]",
2659
+ "; [(Denum [1, 7, 2]).size-ratio (), (Denum [1, 7, 2]).residual-ratio (), (Denum [1, 2, 7]).size-ratio (), (Denum [1, 2, 7]).residual-ratio ()]",
2598
2660
  "# [9, 5, 9, -5]",
2599
2661
  "```",
2600
2662
  "Two Counts with the same phase and loads give different ratios, as they are",
@@ -2609,7 +2671,7 @@ export const HC_SOURCES = new Map([
2609
2671
  "is a FrameInt, a non-whole one a FrameRational, and the residual reading is",
2610
2672
  "signed",
2611
2673
  "```",
2612
- "; [(Demi [3, 1, 0]).size-ratio (), (Demi [3, 0, 1]).residual-ratio (), ((Demi [3, 1, 0]).size-ratio ()) * 3]",
2674
+ "; [(Denum [3, 1, 0]).size-ratio (), (Denum [3, 0, 1]).residual-ratio (), ((Denum [3, 1, 0]).size-ratio ()) * 3]",
2613
2675
  "# [1/3, -1/3, 1]",
2614
2676
  "; [(A.size-ratio ()) * A.count = A.##, (A.residual-ratio ()) * A.count = A.###, (B.residual-ratio ()) * B.count = B.###, (D5.size-ratio ()) * D5.count = D5.##]",
2615
2677
  "# [<>, <>, <>, <>]",
@@ -2619,14 +2681,14 @@ export const HC_SOURCES = new Map([
2619
2681
  "An empty state, a balanced nonempty one and a positive Count over empty loads all",
2620
2682
  "read zero, in either phase",
2621
2683
  "```",
2622
- "; [(Demi [2, 0, 0]).size-ratio (), (Demi [1, 0, 0]).size-ratio (), (Demi [3, 0, 0]).residual-ratio ()]",
2684
+ "; [(Denum [2, 0, 0]).size-ratio (), (Denum [1, 0, 0]).size-ratio (), (Denum [3, 0, 0]).residual-ratio ()]",
2623
2685
  "# [0, 0, 0]",
2624
- "; [(Demi [2, 3, 3]).size-ratio (), (Demi [2, 3, 3]).residual-ratio (), (Demi [1, 3, 3]).size-ratio (), (Demi [1, 3, 3]).residual-ratio ()]",
2686
+ "; [(Denum [2, 3, 3]).size-ratio (), (Denum [2, 3, 3]).residual-ratio (), (Denum [1, 3, 3]).size-ratio (), (Denum [1, 3, 3]).residual-ratio ()]",
2625
2687
  "# [3, 0, 6, 0]",
2626
2688
  "```",
2627
2689
  "Loads too large for a machine integer give the same exact readings",
2628
2690
  "```",
2629
- "; .G (Demi [1000000007, 123456789012345678901234567890, 987654321098765432109876543210]);",
2691
+ "; .G (Denum [1000000007, 123456789012345678901234567890, 987654321098765432109876543210]);",
2630
2692
  "; [(G.size-ratio ()) * G.count = G.##, (G.residual-ratio ()) * G.count = G.###, G.###]",
2631
2693
  "# [<>, <>, -864197532086419753208641975320]",
2632
2694
  "```",
@@ -2636,7 +2698,7 @@ export const HC_SOURCES = new Map([
2636
2698
  "and its Size and residual still read, including after loads were added without",
2637
2699
  "any application. This is absence, not a zero, a division error or an infinity",
2638
2700
  "```",
2639
- "; .Z0 (Demi [0, 3, 0]); .Z1 (Demi [0, 0, 0]); .Z2 ((Demi [0, 0, 0]) + 4);",
2701
+ "; .Z0 (Denum [0, 3, 0]); .Z1 (Denum [0, 0, 0]); .Z2 ((Denum [0, 0, 0]) + 4);",
2640
2702
  "; [[Z0.##, Z0.###, Z0.size-ratio (), Z0.residual-ratio ()], [Z1.##, Z1.###, Z1.size-ratio (), Z1.residual-ratio ()], [Z2.##, Z2.###, Z2.size-ratio (), Z2.residual-ratio ()]]",
2641
2703
  "# [[3, 3, (), ()], [0, 0, (), ()], [4, -4, (), ()]]",
2642
2704
  "```",
@@ -2652,13 +2714,13 @@ export const HC_SOURCES = new Map([
2652
2714
  "rather than read as the divisor, so it is neither `/` nor `%%`. The class",
2653
2715
  "declares no `%%`, which answers nil as for any aggregate without one. Its `/`,",
2654
2716
  "also spelled `./`, is not a ratio either: it redistributes the Size into that",
2655
- "many channels and keeps the Count (007.27, below), so `A / 4` is a Demi of four",
2717
+ "many channels and keeps the Count (007.27, below), so `A / 4` is a Denum of four",
2656
2718
  "loads and no number",
2657
2719
  "```",
2658
2720
  "; [A.size-ratio 4, A.residual-ratio [], A.size-ratio 0, A.residual-ratio “abc”]",
2659
2721
  "# [$!!.unary-observation, $!!.unary-observation, $!!.unary-observation, $!!.unary-observation]",
2660
2722
  "; [“” (A / 4), A %% 4]",
2661
- "# [“Demi(2,[2, 2, 1, 1])”, ()]",
2723
+ "# [“Denum(2,[2, 2, 1, 1])”, ()]",
2662
2724
  "```",
2663
2725
  "A reading at the wrong depth fails safe. Inside a branch `_^` is not the",
2664
2726
  "receiver, so a reading written that way answers `$!.name-missing` and no ratio",
@@ -2674,12 +2736,12 @@ export const HC_SOURCES = new Map([
2674
2736
  "the 25 states have both readings absent",
2675
2737
  "```",
2676
2738
  "; .ccs [1, 2, 3, 4, 5]; .ls [0, 1, 2, 3, 4];",
2677
- "; .statesP (ccs &| {.c _; ls &| {.l _; ls & {Demi [c, l, _]}}});",
2739
+ "; .statesP (ccs &| {.c _; ls &| {.l _; ls & {Denum [c, l, _]}}});",
2678
2740
  "; .lawP {.k _; .c (k.count); [(((k.size-ratio ()) * c) = k.##), (((k.residual-ratio ()) * c) = k.###)]};",
2679
2741
  "; .checksP (statesP &| lawP);",
2680
2742
  "; [statesP.#, checksP.#, checksP = (checksP & {<>})]",
2681
2743
  "# [125, 250, <>]",
2682
- "; .statesZ (ls &| {.l _; ls & {Demi [0, l, _]}});",
2744
+ "; .statesZ (ls &| {.l _; ls & {Denum [0, l, _]}});",
2683
2745
  "; .lawZ {.k _; [(k.size-ratio () = ()), (k.residual-ratio () = ())]};",
2684
2746
  "; .checksZ (statesZ &| lawZ);",
2685
2747
  "; [statesZ.#, checksZ.#, checksZ = (checksZ & {<>})]",
@@ -2711,27 +2773,92 @@ export const HC_SOURCES = new Map([
2711
2773
  "children it has routed, `left.# + right.#`, and its Size and residual from the",
2712
2774
  "Sizes of those children. That is a structural count of the stored channels, not",
2713
2775
  "a counter and not its phase. A router that routed two children from the empty",
2714
- "state shares its Count, Size and residual with the Demi that applied the same",
2776
+ "state shares its Count, Size and residual with the Denum that applied the same",
2715
2777
  "two Sizes, and so does its fourth hash. This is a comparison of readings, not",
2716
- "an identity: the router keeps the Frames and a Demi forgets them",
2778
+ "an identity: the router keeps the Frames and a Denum forgets them",
2717
2779
  "```",
2718
2780
  "; Routers <- './hc/rotor-router.hc';",
2719
2781
  "; .rr (((Routers.RotorRouter [[], []]) 5) 1);",
2720
- "; .kk (((Demi [0, 0, 0]) 5) 1);",
2721
- "; [rr.#, rr.##, rr.###, kk.count, kk.#, kk.##, kk.###, (rr.left.# + rr.right.#), rr.#### = kk.####, rr.phase = kk.phase]",
2782
+ "; .kk (((Denum [0, 0, 0]) 5) 1);",
2783
+ "; [rr.#, rr.##, rr.###, kk.count, kk.#, kk.##, kk.###, (rr.left.# + rr.right.#), rr.#### = kk.####, rr.phase = (kk.phase ())]",
2722
2784
  "# [2, 6, 4, 2, 2, 6, 4, 2, <>, <>]",
2723
2785
  "; .r4 (((rr 7) 2)); .k4 (((kk 7) 2));",
2724
- "; [r4.#, k4.count, r4.phase, k4.phase, r4.#### = k4.####, (k4.size-ratio ()), (k4.residual-ratio ())]",
2786
+ "; [r4.#, k4.count, r4.phase, k4.phase (), r4.#### = k4.####, (k4.size-ratio ()), (k4.residual-ratio ())]",
2725
2787
  "# [4, 4, 2, 2, <>, 15/4, 9/4]",
2726
2788
  "```",
2789
+ "## Count binding, `.#%`",
2790
+ "",
2791
+ "`d.#%` binds a Denum to its own Count (occurrence/figure 007.39a). For",
2792
+ "`d = (C; [a0, …, a(A−1)])` with `C > 0` it answers a new Denum of Count C and",
2793
+ "exactly C loads, where load j is the sum of every source load whose index is",
2794
+ "congruent to j mod C. With fewer loads than C the loads are copied and the rest",
2795
+ "are zero; with exactly C they are kept; with more, each further load folds onto",
2796
+ "the load its index names mod C. Nothing is cycled, replicated or cancelled. It",
2797
+ "is not the redistribution `./ n`, which deals Size units and ignores the",
2798
+ "order of the loads, and it is not a rank: it answers a Denum, never a number",
2799
+ "```",
2800
+ "; [“” ((Denum [3, [2, 5]]).#%), “” ((Denum [3, [2, 5, 3]]).#%), “” ((Denum [3, [2, 5, 3, 7]]).#%), “” ((Denum [3, [2, 5, 3, 7, 4]]).#%)]",
2801
+ "# [“Denum(3,[2, 5, 0])”, “Denum(3,[2, 5, 3])”, “Denum(3,[9, 5, 3])”, “Denum(3,[9, 9, 3])”]",
2802
+ "; [“” ((Denum [[2, 5, 3, 7, 4]]).#%), “” ((Denum [4, [6]]).#%), “” ((Denum [2, [4]]).#%), “” ((Denum [3, [0, 0, 0, 0, 0]]).#%), “” ((Denum [2, 5, 3]).#%)]",
2803
+ "# [“Denum(1,[21])”, “Denum(4,[6, 0, 0, 0])”, “Denum(2,4,0)”, “Denum(3,[0, 0, 0])”, “Denum(2,5,3)”]",
2804
+ "```",
2805
+ "It keeps the Count, the total Size and nonnegative loads, its arity is the",
2806
+ "Count, it is idempotent, and its answer is an instance of this same class, so",
2807
+ "its fourth hash is itself. The receiver is left as it was",
2808
+ "```",
2809
+ "; .Bd (Denum [3, [2, 5, 3, 7, 4]]); .Bn (Bd.#%);",
2810
+ "; [Bn.#, Bn.##, Bd.##, Bn.loads.#, (Bn.#%) = Bn, Bn.#### = Bn, “” Bd]",
2811
+ "# [3, 21, 21, 3, <>, <>, “Denum(3,[2, 5, 3, 7, 4])”]",
2812
+ "; .lawB {.k _; .n (k.#%); [n.# = k.#, n.## = k.##, n.loads.# = k.#, (n.#%) = n]};",
2813
+ "; [Denum [1, [4, 4]], Denum [2, [1, 2, 3]], Denum [5, [9]], Denum [4, [1, 2, 3, 4, 5, 6, 7, 8, 9]], Denum [3, 123456789012345678901234567890, 1]] &| lawB",
2814
+ "# [<>, <>, <>, <>, <>, <>, <>, <>, <>, <>, <>, <>, <>, <>, <>, <>, <>, <>, <>, <>]",
2815
+ "```",
2816
+ "Order matters. The same loads in another order can bind differently, so",
2817
+ "binding is neither permutation-invariant nor invertible",
2818
+ "```",
2819
+ "; [“” ((Denum [2, [1, 2, 3]]).#%), “” ((Denum [2, [3, 2, 1]]).#%), “” ((Denum [2, [2, 1, 3]]).#%), (Denum [2, [3, 1]]).#% = (Denum [2, [1, 3]]).#%]",
2820
+ "# [“Denum(2,4,2)”, “Denum(2,4,2)”, “Denum(2,5,1)”, ()]",
2821
+ "```",
2822
+ "Binding follows application: a Denum whose Count has grown past its arity binds",
2823
+ "into as many loads as it has seen",
2824
+ "```",
2825
+ "; .G3 ((((Denum [0, [0, 0]]) 2) 5) 3);",
2826
+ "; [“” G3, “” (G3.#%)]",
2827
+ "# [“Denum(3,5,5)”, “Denum(3,[5, 5, 0])”]",
2828
+ "```",
2829
+ "A Denum of Count zero is present, under `.####` too, but has no channel to bind",
2830
+ "into, so `.#%` refuses it with a stable named failure rather than nil, an empty",
2831
+ "Denum or a division by zero. Anything that is not a Denum is refused too, the",
2832
+ "way `.####` recognizes one: hosts, numbers, nil, forged records and aggregates",
2833
+ "that declare a `#%` of their own. A Count too large to materialize is refused",
2834
+ "separately, and nothing is allocated. The limit is 65536 loads: a Count of",
2835
+ "exactly 65536 binds into 65536 loads, and 65537 is refused",
2836
+ "```",
2837
+ "; .Z (Denum [0, [2, 5]]);",
2838
+ "; [Z.#### = Z, Z.#%, (Z.####).#%, [].####]",
2839
+ "# [<>, $!.denum-binding-zero-count, $!.denum-binding-zero-count, ()]",
2840
+ "; [[5, 3].#%, 3.#%, ().#%, “ab”.#%, {1}.#%, [.count 3; .loads [1, 2]].#%, [.#% {Denum [1, [1]]}].#%]",
2841
+ "# [$!.denum-binding-receiver, $!.denum-binding-receiver, $!.denum-binding-receiver, $!.denum-binding-receiver, $!.denum-binding-receiver, $!.denum-binding-receiver, $!.denum-binding-receiver]",
2842
+ "; [(Denum [70000, [1]]).#%, (Denum [123456789012345678901234567890, [1]]).#%, ([].nope).#%]",
2843
+ "# [$!.denum-binding-capacity, $!.denum-binding-capacity, $!.name-missing “...]",
2844
+ "; .Edge ((Denum [65536, [1, 2]]).#%);",
2845
+ "; [Edge.#, (Edge.loads).#, Edge.##, (Edge.loads) .0, (Edge.loads) .1, (Edge.loads) .65535, (Denum [65537, [1, 2]]).#%]",
2846
+ "# [65536, 65536, 3, 1, 2, 0, $!.denum-binding-capacity]",
2847
+ "```",
2848
+ "`.#%` is one token. `.#`, `%%` and a comment are read as before, and `.#%%`,",
2849
+ "which could be either, is refused by the lexer: write `.# %%`",
2850
+ "```",
2851
+ "; [[5, 3, 1].# %% 2, (Denum [3, [1]]).# %% 2, (Denum [3, [1]]).#% .#] # a comment after",
2852
+ "# [1, 1, 3]",
2853
+ "```",
2727
2854
  "## Importing",
2728
2855
  "",
2729
2856
  "Imported, the file binds the same class. The import is an example line, so",
2730
2857
  "the evaluator, which reads this file without a root, never runs it",
2731
2858
  "```",
2732
- "; Demis <- './hc/demi.hc';",
2733
- "; [(Demis.Demi [2, 5, 3]) = [5, 3].####, “” ((Demis.Demi [0, 0, 0]) 4)]",
2734
- "# [<>, “Demi(1,4,0)”]",
2859
+ "; Denums <- './hc/denum.hc';",
2860
+ "; [(Denums.Denum [2, 5, 3]) = [5, 3].####, “” ((Denums.Denum [0, 0, 0]) 4)]",
2861
+ "# [<>, “Denum(1,4,0)”]",
2735
2862
  "",
2736
2863
  ].join("\n"),
2737
2864
  ],
@@ -2767,21 +2894,21 @@ export const HC_SOURCES = new Map([
2767
2894
  " channels, which a round-robin history fixes, and routes that history through",
2768
2895
  " a fresh router of n channels. Its Count is unchanged and its next route goes",
2769
2896
  " to channel C mod n.",
2770
- "- **A Demi** (`hc/demi.hc`) forgot its Frames and kept only their Sizes, so it",
2897
+ "- **A Denum** (`hc/denum.hc`) forgot its Frames and kept only their Sizes, so it",
2771
2898
  " deals Size units. `D ./ n` keeps the Count C and the total Size S and",
2772
2899
  " canonicalizes the loads to S units dealt round-robin into n channels, so the",
2773
2900
  " first S mod n channels hold ⌈S/n⌉ and the rest ⌊S/n⌋. Its next application",
2774
2901
  " deposits into channel C mod n.",
2775
2902
  "",
2776
- "Router and list deal whole Frames, and a Demi deals Size units. Both conserve",
2903
+ "Router and list deal whole Frames, and a Denum deals Size units. Both conserve",
2777
2904
  "the summed Size, but their channel loads differ in general: children of Sizes",
2778
- "5 and 2 dealt whole into two channels load them 5 and 2, while a Demi of Size 7",
2905
+ "5 and 2 dealt whole into two channels load them 5 and 2, while a Denum of Size 7",
2779
2906
  "normalizes to 4 and 3. No law makes them commute, and none is claimed here.",
2780
2907
  "",
2781
2908
  "Refusals are the native ones for all three: a divisor of zero is",
2782
2909
  "`$!.division-by-zero /`, as it is for numbers, and anything but a Count is",
2783
2910
  "`$!.division-domain /`, a negative or fractional number, a decimal, text, an",
2784
- "aggregate or a Demi included. A divisor above both 1,000,000 and the element count is `$!.repetition-size 1000000`, checked before anything is built; up to the element count is always allowed, so the answer stays proportional to the list.",
2911
+ "aggregate or a Denum included. A divisor above both 1,000,000 and the element count is `$!.repetition-size 1000000`, checked before anything is built; up to the element count is always allowed, so the answer stays proportional to the list.",
2785
2912
  "```",
2786
2913
  "```",
2787
2914
  "## Lists",
@@ -2869,7 +2996,7 @@ export const HC_SOURCES = new Map([
2869
2996
  "",
2870
2997
  "The divisor is a positive Count. Zero is division by zero, and anything else is",
2871
2998
  "outside the domain, whatever its Size: a negative or fractional number, a",
2872
- "decimal, text, an aggregate, a Demi. A divisor that is already an error is",
2999
+ "decimal, text, an aggregate, a Denum. A divisor that is already an error is",
2873
3000
  "answered as it is",
2874
3001
  "```",
2875
3002
  "; [[1, 2] ./ 0, [1, 2] ./ (3 - 1), [1, 2] ./ (0 - 2), [1, 2] ./ (1 / 2), [1, 2] ./ 1.5, [1, 2] ./ “two”, [1, 2] ./ [2]]",
@@ -2912,34 +3039,34 @@ export const HC_SOURCES = new Map([
2912
3039
  "; ([Failing, 1] ./ 2).##",
2913
3040
  "# $!.name-missing “...",
2914
3041
  "```",
2915
- "## Demi",
3042
+ "## Denum",
2916
3043
  "",
2917
- "A Demi of any arity is `Demi [C, loads]`, a Count and a nonempty list of",
2918
- "Counts. Two loads are the binary Demi `Demi [C, L, R]` itself, the same",
3044
+ "A Denum of any arity is `Denum [C, loads]`, a Count and a nonempty list of",
3045
+ "Counts. Two loads are the binary Denum `Denum [C, L, R]` itself, the same",
2919
3046
  "instance, with its `left`, `right` and `phase`; any other arity is a channel",
2920
- "Demi, which reads as `Demi(C,[…])`. Every Demi stores `count` and `loads`",
3047
+ "Denum, which reads as `Denum(C,[…])`. Every Denum stores `count` and `loads`",
2921
3048
  "```",
2922
- "; Demis <- './hc/demi.hc';",
2923
- "; .Demi Demis.Demi;",
2924
- "; [“” (Demi [3, [5, 2]]), (Demi [3, [5, 2]]) == (Demi [3, 5, 2]), (Demi [3, [5, 2]]).left, (Demi [3, 5, 2]).loads]",
2925
- "# [“Demi(3,5,2)”, <>, 5, [5, 2]]",
2926
- "; [“” (Demi [0, [0, 0, 0]]), “” (Demi [4, [7]]), “” (Demi [2, [1, 2, 3, 4]]), (Demi [2, [1, 2, 3]]).loads, (Demi [2, [1, 2, 3]]).count]",
2927
- "# [“Demi(0,[0, 0, 0])”, “Demi(4,[7])”, “Demi(2,[1, 2, 3, 4])”, [1, 2, 3], 2]",
3049
+ "; Denums <- './hc/denum.hc';",
3050
+ "; .Denum Denums.Denum;",
3051
+ "; [“” (Denum [3, [5, 2]]), (Denum [3, [5, 2]]) == (Denum [3, 5, 2]), (Denum [3, [5, 2]]).left (), (Denum [3, 5, 2]).loads]",
3052
+ "# [“Denum(3,5,2)”, <>, 5, [5, 2]]",
3053
+ "; [“” (Denum [0, [0, 0, 0]]), “” (Denum [4, [7]]), “” (Denum [2, [1, 2, 3, 4]]), (Denum [2, [1, 2, 3]]).loads, (Denum [2, [1, 2, 3]]).count]",
3054
+ "# [“Denum(0,[0, 0, 0])”, “Denum(4,[7])”, “Denum(2,[1, 2, 3, 4])”, [1, 2, 3], 2]",
2928
3055
  "```",
2929
3056
  "No channels, a load that is not a Count, and any other shape are refused",
2930
3057
  "```",
2931
- "; [Demi [2, []], Demi [2, [1, (0 - 1), 3]], Demi [2, [1, 1.5]], Demi [2, [1, [2]]], Demi [(0 - 2), [1]], Demi [2, 5], Demi [2, [1], 3], Demi [2, [1, 2], 3, 4]]",
2932
- "# [$!!.invalid-demi, $!!.invalid-demi, $!!.invalid-demi, $!!.invalid-demi, $!!.invalid-demi, $!!.invalid-demi, $!!.invalid-demi, $!!.invalid-demi]",
3058
+ "; [Denum [2, []], Denum [2, [1, (0 - 1), 3]], Denum [2, [1, 1.5]], Denum [2, [1, [2]]], Denum [(0 - 2), [1]], Denum [2, 5], Denum [2, [1], 3], Denum [2, [1, 2], 3, 4]]",
3059
+ "# [$!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum]",
2933
3060
  "```",
2934
- "A channel Demi observes as its loads do: its Count is C, its Size the sum of",
3061
+ "A channel Denum observes as its loads do: its Count is C, its Size the sum of",
2935
3062
  "its loads, and its residual their alternating sum, `e0 − e1 + e2 − …`, the",
2936
3063
  "list residual, which for two loads is `L − R`",
2937
3064
  "```",
2938
- "; .d7 (Demi [3, 5, 2]); .q3 (d7 ./ 3);",
3065
+ "; .d7 (Denum [3, 5, 2]); .q3 (d7 ./ 3);",
2939
3066
  "; [q3.#, q3.##, q3.###, q3.count, q3.loads]",
2940
3067
  "# [3, 7, 3, 3, [3, 2, 2]]",
2941
3068
  "```",
2942
- "## Demi division redistributes Size units",
3069
+ "## Denum division redistributes Size units",
2943
3070
  "",
2944
3071
  "`D ./ n` keeps the Count and the Size and deals the Size units round-robin into",
2945
3072
  "n channels. For S = 7: into 2, 4 and 3; into 3, 3, 2 and 2; into 4, 2, 2, 2",
@@ -2947,30 +3074,30 @@ export const HC_SOURCES = new Map([
2947
3074
  "the last are empty",
2948
3075
  "```",
2949
3076
  "; [“” (d7 ./ 2), “” (d7 ./ 3), “” (d7 ./ 4), “” (d7 ./ 1), “” (d7 ./ 9)]",
2950
- "# [“Demi(3,4,3)”, “Demi(3,[3, 2, 2])”, “Demi(3,[2, 2, 2, 1])”, “Demi(3,[7])”, “Demi(3,[1, 1, 1, 1, 1, 1, 1, 0, 0])”]",
3077
+ "# [“Denum(3,4,3)”, “Denum(3,[3, 2, 2])”, “Denum(3,[2, 2, 2, 1])”, “Denum(3,[7])”, “Denum(3,[1, 1, 1, 1, 1, 1, 1, 0, 0])”]",
2951
3078
  "```",
2952
- "`Demi(3,[5,2]) ./ 3` is `Demi(3,[3,2,2])`, and so is the different state",
2953
- "`Demi(3,[4,3]) ./ 3`. Normalization is many-to-one: equal Count and Size give",
3079
+ "`Denum(3,[5,2]) ./ 3` is `Denum(3,[3,2,2])`, and so is the different state",
3080
+ "`Denum(3,[4,3]) ./ 3`. Normalization is many-to-one: equal Count and Size give",
2954
3081
  "the same result, and the original distribution cannot be recovered",
2955
3082
  "```",
2956
- "; [q3 = (Demi [3, [3, 2, 2]]), ((Demi [3, 4, 3]) ./ 3) = q3, (Demi [3, 4, 3]) = d7, (d7 / 3) = q3, q3 = d7]",
3083
+ "; [q3 = (Denum [3, [3, 2, 2]]), ((Denum [3, 4, 3]) ./ 3) = q3, (Denum [3, 4, 3]) = d7, (d7 / 3) = q3, q3 = d7]",
2957
3084
  "# [<>, <>, (), <>, ()]",
2958
3085
  "```",
2959
3086
  "It is idempotent, and dividing again renormalizes from the same Count and Size,",
2960
3087
  "so the earlier division leaves no trace",
2961
3088
  "```",
2962
3089
  "; [(q3 ./ 3) = q3, (q3 ./ 2) = (d7 ./ 2), ((d7 ./ 4) ./ 3) = q3, “” (q3 ./ 2), ((q3 ./ 2) ./ 3) = q3]",
2963
- "# [<>, <>, <>, “Demi(3,4,3)”, <>]",
3090
+ "# [<>, <>, <>, “Denum(3,4,3)”, <>]",
2964
3091
  "```",
2965
3092
  "Zero Size, zero Count, one channel, and more channels than Size or Count",
2966
3093
  "```",
2967
- "; [“” ((Demi [0, 0, 0]) ./ 3), “” ((Demi [0, 9, 0]) ./ 4), “” ((Demi [0, 9, 0]) ./ 1), “” ((Demi [2, 1, 1]) ./ 5), “” ((Demi [1, 0, 0]) ./ 2)]",
2968
- "# [“Demi(0,[0, 0, 0])”, “Demi(0,[3, 2, 2, 2])”, “Demi(0,[9])”, “Demi(2,[1, 1, 0, 0, 0])”, “Demi(1,0,0)”]",
3094
+ "; [“” ((Denum [0, 0, 0]) ./ 3), “” ((Denum [0, 9, 0]) ./ 4), “” ((Denum [0, 9, 0]) ./ 1), “” ((Denum [2, 1, 1]) ./ 5), “” ((Denum [1, 0, 0]) ./ 2)]",
3095
+ "# [“Denum(0,[0, 0, 0])”, “Denum(0,[3, 2, 2, 2])”, “Denum(0,[9])”, “Denum(2,[1, 1, 0, 0, 0])”, “Denum(1,0,0)”]",
2969
3096
  "```",
2970
3097
  "The divisor is a channel Count, refused as a list refuses it, never coerced to",
2971
3098
  "its Size",
2972
3099
  "```",
2973
- "; [d7 ./ 0, d7 ./ (3 - 1), d7 ./ 1.5, d7 ./ (1 / 2), d7 ./ [3], d7 ./ “three”, d7 ./ (Demi [1, 1, 1])]",
3100
+ "; [d7 ./ 0, d7 ./ (3 - 1), d7 ./ 1.5, d7 ./ (1 / 2), d7 ./ [3], d7 ./ “three”, d7 ./ (Denum [1, 1, 1])]",
2974
3101
  "# [$!.division-by-zero /, $!.division-domain /, $!.division-domain /, $!.division-domain /, $!.division-domain /, $!.division-domain /, $!.division-domain /]",
2975
3102
  "```",
2976
3103
  "## Applying after division",
@@ -2980,23 +3107,23 @@ export const HC_SOURCES = new Map([
2980
3107
  "channels 0, 1, 2, 0 in turn",
2981
3108
  "```",
2982
3109
  "; [“” (q3 10), “” ((q3 10) 1), “” (((q3 10) 1) 1), “” ((((q3 10) 1) 1) 1)]",
2983
- "# [“Demi(4,[13, 2, 2])”, “Demi(5,[13, 3, 2])”, “Demi(6,[13, 3, 3])”, “Demi(7,[14, 3, 3])”]",
2984
- "; [“” ((Demi [0, [0, 0, 0]]) 4), “” (((Demi [0, [0, 0, 0]]) 4) 0), “” ((((Demi [0, [0, 0, 0]]) 4) 0) 6)]",
2985
- "# [“Demi(1,[4, 0, 0])”, “Demi(2,[4, 0, 0])”, “Demi(3,[4, 0, 6])”]",
3110
+ "# [“Denum(4,[13, 2, 2])”, “Denum(5,[13, 3, 2])”, “Denum(6,[13, 3, 3])”, “Denum(7,[14, 3, 3])”]",
3111
+ "; [“” ((Denum [0, [0, 0, 0]]) 4), “” (((Denum [0, [0, 0, 0]]) 4) 0), “” ((((Denum [0, [0, 0, 0]]) 4) 0) 6)]",
3112
+ "# [“Denum(1,[4, 0, 0])”, “Denum(2,[4, 0, 0])”, “Denum(3,[4, 0, 6])”]",
2986
3113
  "```",
2987
3114
  "A reduce applies it the same way, and through a mutable name it writes in",
2988
- "place. One channel takes every deposit, and two channels are the binary Demi's",
3115
+ "place. One channel takes every deposit, and two channels are the binary Denum's",
2989
3116
  "parity",
2990
3117
  "```",
2991
- "; “” ([5, 2, 7, 1, 0] | (Demi [0, [0, 0, 0]]))",
2992
- "# “Demi(5,[6, 2, 7])”",
2993
- "; .m_ (Demi [0, [0, 0, 0]]);",
3118
+ "; “” ([5, 2, 7, 1, 0] | (Denum [0, [0, 0, 0]]))",
3119
+ "# “Denum(5,[6, 2, 7])”",
3120
+ "; .m_ (Denum [0, [0, 0, 0]]);",
2994
3121
  "; m_ 5;",
2995
3122
  "; m_ 6;",
2996
3123
  "; [“” m_, “” ((d7 ./ 1) 4), “” ((d7 ./ 2) 4), “” (d7 4)]",
2997
- "# [“Demi(2,[5, 6, 0])”, “Demi(4,[11])”, “Demi(4,4,7)”, “Demi(4,5,6)”]",
3124
+ "# [“Denum(2,[5, 6, 0])”, “Denum(4,[11])”, “Denum(4,4,7)”, “Denum(4,5,6)”]",
2998
3125
  "```",
2999
- "## Demi laws",
3126
+ "## Denum laws",
3000
3127
  "",
3001
3128
  "For every Count 0 to 3, every pair of loads 0 to 4 (100 states) and every n",
3002
3129
  "from 1 to 4: the Count and Size are kept, there are n loads, they are the",
@@ -3004,44 +3131,44 @@ export const HC_SOURCES = new Map([
3004
3131
  "m from 1 to 4 dividing by n then m is dividing by m",
3005
3132
  "```",
3006
3133
  "; .cs [0, 1, 2, 3]; .ls [0, 1, 2, 3, 4]; .ns [1, 2, 3, 4];",
3007
- "; .states (cs &| {.c _; ls &| {.l _; ls & {Demi [c, l, _]}}});",
3134
+ "; .states (cs &| {.c _; ls &| {.l _; ls & {Denum [c, l, _]}}});",
3008
3135
  "; .law {.k _; ns &| {.n _; .q (k ./ n); [q.# = k.#, q.## = k.##, q.loads.# = n, q.loads = (((k.## [1]) ./ n).channels & {_.#}), (q ./ n) = q]}};",
3009
3136
  "; .renorm {.k _; ns &| {.n _; ns & {.m _; ((k ./ n) ./ m) = (k ./ m)}}};",
3010
3137
  "; .checks ((states &| law) | (states &| renorm));",
3011
3138
  "; [states.#, checks.#, checks = (checks & {<>})]",
3012
3139
  "# [100, 3600, <>]",
3013
3140
  "```",
3014
- "## Channel Demi operations",
3141
+ "## Channel Denum operations",
3015
3142
  "",
3016
- "Its fourth hash is intrinsic, as for the binary Demi: a fresh equal channel Demi",
3143
+ "Its fourth hash is intrinsic, as for the binary Denum: a fresh equal channel Denum",
3017
3144
  "of the same arity, Count zero included. A record that only spells the fields is",
3018
- "not one, and forged observers give the ordinary derived binary Demi",
3145
+ "not one, and forged observers give the ordinary derived binary Denum",
3019
3146
  "```",
3020
- "; [(q3.####) == q3, (q3.####) === q3, ((Demi [0, [0, 0, 0]]).####) = (Demi [0, [0, 0, 0]]), ([5, 2].#### ./ 3) = (Demi [2, [3, 2, 2]])]",
3147
+ "; [(q3.####) == q3, (q3.####) === q3, ((Denum [0, [0, 0, 0]]).####) = (Denum [0, [0, 0, 0]]), ([5, 2].#### ./ 3) = (Denum [2, [3, 2, 2]])]",
3021
3148
  "# [<>, (), <>, <>]",
3022
3149
  "; [[.count 3; .loads [3, 2, 2]].####, “” ([.count 3; .loads [3, 2, 2]; .# {3}; .## {7}; .### {3}].####)]",
3023
- "# [(), “Demi(3,5,2)”]",
3150
+ "# [(), “Denum(3,5,2)”]",
3024
3151
  "```",
3025
3152
  "`*` and `scale_` scale every load and keep the Count; the ratios read Size and",
3026
3153
  "residual over the Count, nil at Count zero",
3027
3154
  "```",
3028
- "; [“” (q3 * 2), “” (q3.scale_ 3), q3.size-ratio (), q3.residual-ratio (), (Demi [0, [3, 2, 2]]).size-ratio ()]",
3029
- "# [“Demi(3,[6, 4, 4])”, “Demi(3,[9, 6, 6])”, 7/3, 1, ()]",
3155
+ "; [“” (q3 * 2), “” (q3.scale_ 3), q3.size-ratio (), q3.residual-ratio (), (Denum [0, [3, 2, 2]]).size-ratio ()]",
3156
+ "# [“Denum(3,[6, 4, 4])”, “Denum(3,[9, 6, 6])”, 7/3, 1, ()]",
3030
3157
  "```",
3031
3158
  "`+` and `-` follow the residual's signs. The residual adds the loads at even",
3032
3159
  "indices and subtracts those at odd ones, so `-` deposits `x.##` on the first",
3033
3160
  "even load, load 0, and raises the residual, and `+` deposits on the first odd",
3034
- "load, load 1, and lowers it. For two loads these are the binary Demi's left and",
3161
+ "load, load 1, and lowers it. For two loads these are the binary Denum's left and",
3035
3162
  "right. Both keep the Count, and both are `deposit-left_` and `deposit-right_`",
3036
3163
  "by the operand's Size. One load has no odd index, so there `+` is",
3037
3164
  "`$!!.invalid-arity`",
3038
3165
  "```",
3039
3166
  "; [“” (q3 + 1), “” (q3 - 1), q3.###, (q3 + 1).###, (q3 - 1).###, (q3 + 1).#]",
3040
- "# [“Demi(3,[3, 3, 2])”, “Demi(3,[4, 2, 2])”, 3, 2, 4, 3]",
3167
+ "# [“Denum(3,[3, 3, 2])”, “Denum(3,[4, 2, 2])”, 3, 2, 4, 3]",
3041
3168
  "; [“” ((d7 ./ 4) + 1), “” ((d7 ./ 4) - 2.5), (d7 ./ 1) + 1, “” ((d7 ./ 1) - 1), “” (d7 + 1), “” (d7 - 1)]",
3042
- "# [“Demi(3,[2, 3, 2, 1])”, “Demi(3,[4, 2, 2, 1])”, $!!.invalid-arity, “Demi(3,[8])”, “Demi(3,5,3)”, “Demi(3,6,2)”]",
3169
+ "# [“Denum(3,[2, 3, 2, 1])”, “Denum(3,[4, 2, 2, 1])”, $!!.invalid-arity, “Denum(3,[8])”, “Denum(3,5,3)”, “Denum(3,6,2)”]",
3043
3170
  "; [((q3 + 4) - 2) = ((q3 - 2) + 4), ((q3 + 1) ./ 3) = ((q3 - 1) ./ 3), q3 + ([].nope), q3.deposit-right_ (0 - 1), q3.deposit-left_ 1.5, “” q3]",
3044
- "# [<>, <>, $!.name-missing “..., $!!.invalid-demi, $!!.invalid-demi, “Demi(3,[3, 2, 2])”]",
3171
+ "# [<>, <>, $!.name-missing “..., $!!.invalid-denum, $!!.invalid-denum, “Denum(3,[3, 2, 2])”]",
3045
3172
  "```",
3046
3173
  "## RotorRouter",
3047
3174
  "",
@@ -3135,23 +3262,23 @@ export const HC_SOURCES = new Map([
3135
3262
  "```",
3136
3263
  "The divisor is refused as for a list",
3137
3264
  "```",
3138
- "; [r7 ./ 0, r7 ./ (3 - 1), r7 ./ 1.5, r7 ./ [2], r7 ./ (Demi [1, 1, 1]), r7 ./ “two”]",
3265
+ "; [r7 ./ 0, r7 ./ (3 - 1), r7 ./ 1.5, r7 ./ [2], r7 ./ (Denum [1, 1, 1]), r7 ./ “two”]",
3139
3266
  "# [$!.division-by-zero /, $!.division-domain /, $!.division-domain /, $!.division-domain /, $!.division-domain /, $!.division-domain /]",
3140
3267
  "```",
3141
3268
  "## A router's observers and fourth hash",
3142
3269
  "",
3143
3270
  "A router of any arity declares its Count C, its Size, the sum of its channel",
3144
- "loads, and its residual, their alternating sum, as a channel Demi does. Its",
3145
- "fourth hash is the Demi of the same arity: a router of k channels other than",
3271
+ "loads, and its residual, their alternating sum, as a channel Denum does. Its",
3272
+ "fourth hash is the Denum of the same arity: a router of k channels other than",
3146
3273
  "two is recognized intrinsically, as an instance of the shipped class, and",
3147
- "answers `Demi [C, loads]`, one load per channel, so it routes to channel",
3148
- "C mod k as its Demi deposits there. The binary router answers the binary Demi",
3149
- "it always did. At Count zero there is no Demi, for any arity",
3274
+ "answers `Denum [C, loads]`, one load per channel, so it routes to channel",
3275
+ "C mod k as its Denum deposits there. The binary router answers the binary Denum",
3276
+ "it always did. At Count zero there is no Denum, for any arity",
3150
3277
  "```",
3151
- "; [t3.#, t3.##, t3.###, “” t3.####, t3.#### = (Demi [7, [14, 6, 22]]), t3.####.## = t3.##, t3.####.### = t3.###]",
3152
- "# [7, 42, 30, “Demi(7,[14, 6, 22])”, <>, <>, <>]",
3278
+ "; [t3.#, t3.##, t3.###, “” t3.####, t3.#### = (Denum [7, [14, 6, 22]]), t3.####.## = t3.##, t3.####.### = t3.###]",
3279
+ "# [7, 42, 30, “Denum(7,[14, 6, 22])”, <>, <>, <>]",
3153
3280
  "; [“” (r7.####), ([] ./ 3).####, (RotorRouter [[], [], []]).####, “” ((([] ./ 3) 5).####)]",
3154
- "# [“Demi(7,24,18)”, (), (), “Demi(1,[5, 0, 0])”]",
3281
+ "# [“Denum(7,24,18)”, (), (), “Denum(1,[5, 0, 0])”]",
3155
3282
  "```",
3156
3283
  "So the projection law `(r y).#### = r.#### y` holds for every arity: routing y",
3157
3284
  "to channel C mod k and observing is depositing `y.##` there",
@@ -3160,7 +3287,7 @@ export const HC_SOURCES = new Map([
3160
3287
  "; [1, 2, 3, 4, 5] & {.r (nine ./ _); ((r 10).####) = ((r.####) 10)}",
3161
3288
  "# [<>, <>, <>, <>, <>]",
3162
3289
  "; [“” ((t3 10).####), “” ((nine ./ 1).####), “” ((nine ./ 4).####)]",
3163
- "# [“Demi(8,[14, 16, 22])”, “Demi(9,[45])”, “Demi(9,[15, 8, 10, 12])”]",
3290
+ "# [“Denum(8,[14, 16, 22])”, “Denum(9,[45])”, “Denum(9,[15, 8, 10, 12])”]",
3164
3291
  "```",
3165
3292
  "Recognition reads nothing the router computes: a record that only spells",
3166
3293
  "`channels` is not a router, and a failed child Size is answered as it is",
@@ -3172,12 +3299,12 @@ export const HC_SOURCES = new Map([
3172
3299
  "",
3173
3300
  "Whole-Frame division and Size-unit division agree on the total and differ on",
3174
3301
  "the channels. Children of Sizes 5 and 2 dealt into two channels load them 5",
3175
- "and 2, as list and router; the Demi of the same list, normalized, loads them 4",
3302
+ "and 2, as list and router; the Denum of the same list, normalized, loads them 4",
3176
3303
  "and 3. They are different states with the same Size, and neither is wrong",
3177
3304
  "```",
3178
3305
  "; .two [5, 2];",
3179
3306
  "; [loads (two ./ 2).channels, ((two | r0) ./ 2).channels & {load _}, “” (two.#### ./ 2), ((two | r0) ./ 2).#### = (two.#### ./ 2), ((two | r0) ./ 2).####.## = (two.#### ./ 2).##]",
3180
- "# [[5, 2], [5, 2], “Demi(2,4,3)”, (), <>]",
3307
+ "# [[5, 2], [5, 2], “Denum(2,4,3)”, (), <>]",
3181
3308
  "```",
3182
3309
  "They agree when every child has Size one, since then each Frame is one Size",
3183
3310
  "unit. With other Sizes they need not",
@@ -3394,41 +3521,41 @@ export const HC_SOURCES = new Map([
3394
3521
  "; [.tag 1;] * [[]]",
3395
3522
  "# $!.star-metadata *",
3396
3523
  "```",
3397
- "The fourth observer derives a Demi from Count, Size and residual.",
3398
- "A zero Count or absent residual gives no Demi; errors propagate. A schema used",
3399
- "as an explicit element contributes Size normally, even though its own Demi is nil.",
3400
- "A present Demi has Count C, Size L+R and residual L−R. Its Count is its full",
3524
+ "The fourth observer derives a Denum from Count, Size and residual.",
3525
+ "A zero Count or absent residual gives no Denum; errors propagate. A schema used",
3526
+ "as an explicit element contributes Size normally, even though its own Denum is nil.",
3527
+ "A present Denum has Count C, Size L+R and residual L−R. Its Count is its full",
3401
3528
  "application Count (007.25c), and its phase is derived from the parity of that",
3402
3529
  "Count: 2 for even and 1 for odd. The derivation therefore reconstructs its data",
3403
- "value on repeated fourth observation, including present zero loads; a Demi of",
3530
+ "value on repeated fourth observation, including present zero loads; a Denum of",
3404
3531
  "Count zero, which the observers cannot tell from an empty host, declares its own",
3405
- "fourth hash (`hc/demi.hc`).",
3406
- "A present Demi is an instance of the HC class in `hc/demi.hc` (011.20), and",
3407
- "reads as text `Demi(count,left,right)`. Applying a Demi to Y deposits Y's Size",
3532
+ "fourth hash (`hc/denum.hc`).",
3533
+ "A present Denum is an instance of the HC class in `hc/denum.hc` (011.20), and",
3534
+ "reads as text `Denum(count,left,right)`. Applying a Denum to Y deposits Y's Size",
3408
3535
  "and adds one to the Count, so for a nonempty Figure host X, (X Y).#### is",
3409
- "X.#### Y; for an empty host, start from the Demi of Count zero instead,",
3536
+ "X.#### Y; for an empty host, start from the Denum of Count zero instead,",
3410
3537
  "because [].#### is nil. Scaling is the method `scale_`, the shadow of Star:",
3411
3538
  "(X * Y).#### is X.####.scale_ (Y.##) for a nonempty host. Count is a terminal",
3412
3539
  "quantity: positive Counts agree with pure Figures of that terminal Size, but 0",
3413
- "has Size 0 while [] has Size 1. Mixed values may have present zero-load Demis,",
3540
+ "has Size 0 while [] has Size 1. Mixed values may have present zero-load Denums,",
3414
3541
  "including [0].####.",
3415
3542
  "```",
3416
3543
  "; [[].####, 0.####, “” “hello”.####, <2,3,5>.####]",
3417
- "# [(), (), “Demi(5,3,2)”, ()]",
3544
+ "# [(), (), “Denum(5,3,2)”, ()]",
3418
3545
  "; [(10 - 5).#### = 5.####, (0 - 5).#### = 5.####, (5.0).#### = 5.####, “hello”.#### = 5.####]",
3419
3546
  "# [<>, <>, <>, <>]",
3420
3547
  "; [<>.#, <>.##, <>.###, ().##]",
3421
3548
  "# [0, 1, 0, 1]",
3422
3549
  "; [1, 2, 3, 7] & {“” _.####}",
3423
- "# [“Demi(1,1,0)”, “Demi(2,1,1)”, “Demi(3,2,1)”, “Demi(7,4,3)”]",
3550
+ "# [“Denum(1,1,0)”, “Denum(2,1,1)”, “Denum(3,2,1)”, “Denum(7,4,3)”]",
3424
3551
  "; [[0], [“hello”], [<2,3,5>,2], {5 + 3}] & {“” _.####}",
3425
- "# [“Demi(1,0,0)”, “Demi(1,5,0)”, “Demi(2,3,2)”, “Demi(3,8,1)”]",
3552
+ "# [“Denum(1,0,0)”, “Denum(1,5,0)”, “Denum(2,3,2)”, “Denum(3,8,1)”]",
3426
3553
  "; [“” ([[],[]].#### 3), “” (7.####.scale_ 2), ([[],[]] 3).#### = ([[],[]].#### 3)]",
3427
- "# [“Demi(3,4,1)”, “Demi(7,8,6)”, <>]",
3554
+ "# [“Denum(3,4,1)”, “Denum(7,8,6)”, <>]",
3428
3555
  "```",
3429
3556
  "A RotorRouter, the class in `hc/rotor-router.hc` (011.21), keeps the routed",
3430
3557
  "Figures themselves in two ordered channels and declares the observers that make",
3431
- "its fourth hash their Demi. Routing a Figure's children in turn from the initial",
3558
+ "its fourth hash their Denum. Routing a Figure's children in turn from the initial",
3432
3559
  "router sends the even positions left and the odd ones right, and that router's",
3433
3560
  "fourth hash is the Figure's.",
3434
3561
  "```",
@@ -4063,11 +4190,11 @@ export const HC_SOURCES = new Map([
4063
4190
  "A RotorRouter is a two-channel router that keeps what it routes. Its state is",
4064
4191
  "two ordered arrays, left and right, of the Frames routed into them, and nothing",
4065
4192
  "else. Applying a router to a Frame appends that Frame, the same Frame, to the",
4066
- "channel its Count selects. A Demi follows the same alternation by Size alone; a",
4067
- "router keeps the children, so its numerical shadow is a Demi and its state is",
4193
+ "channel its Count selects. A Denum follows the same alternation by Size alone; a",
4194
+ "router keeps the children, so its numerical shadow is a Denum and its state is",
4068
4195
  "everything that shadow forgets: which Frames, in what order, and which channel.",
4069
4196
  "",
4070
- "`RotorRouter` is an ordinary HC class, like `Demi` in `hc/demi.hc`: a",
4197
+ "`RotorRouter` is an ordinary HC class, like `Denum` in `hc/denum.hc`: a",
4071
4198
  "constructor closure answering a fresh aggregate whose fields are its state and",
4072
4199
  "whose methods are the class. Import it with",
4073
4200
  "`Routers <- './hc/rotor-router.hc'`, then `Routers.RotorRouter [[], []]`.",
@@ -4075,17 +4202,17 @@ export const HC_SOURCES = new Map([
4075
4202
  "**State (007.25e).** `RotorRouter [left, right]` takes two arrays, the two",
4076
4203
  "ordered channels. There is no phase argument: the router's Count is",
4077
4204
  "`C = left.# + right.#`, the children it holds, and its phase is read from the",
4078
- "parity of C exactly as a Demi's is, 2 when C is even (left next) and 1 when C is",
4205
+ "parity of C exactly as a Denum's is, 2 when C is even (left next) and 1 when C is",
4079
4206
  "odd (right next). Earlier versions took `RotorRouter [phase, left, right]`, a",
4080
4207
  "free phase beside the channels; that form is removed, with no alias, so the",
4081
- "router's routing phase, its Count and the phase of its Demi are one fact.",
4208
+ "router's routing phase, its Count and the phase of its Denum are one fact.",
4082
4209
  "",
4083
4210
  "**Admissibility.** Routing from empty channels starts left and alternates, so",
4084
4211
  "every routed history has `left.# = right.#` (C even) or",
4085
4212
  "`left.# = right.# + 1` (C odd), and conversely every such pair is the one",
4086
4213
  "history that sent `left.0`, `right.0`, `left.1`, … in turn. The constructor",
4087
4214
  "admits exactly those pairs and refuses every other pair with",
4088
- "`$!!.invalid-router`, a named error, as `Demi` refuses with `$!!.invalid-demi`:",
4215
+ "`$!!.invalid-router`, a named error, as `Denum` refuses with `$!!.invalid-denum`:",
4089
4216
  "`RotorRouter [[A], [B, C]]` and `RotorRouter [[A, B], []]` are not histories,",
4090
4217
  "and no history or offset is invented for them. Routing keeps the invariant, so",
4091
4218
  "every router a program can hold satisfies it. A channel is its elements: an",
@@ -4105,30 +4232,30 @@ export const HC_SOURCES = new Map([
4105
4232
  "mutating method, `apply_`, so through a name it is a functional update that",
4106
4233
  "leaves the router as it was, and through a mutable name it writes the router in",
4107
4234
  "place. Routing nil routes nothing and leaves the router as it was, as applying a",
4108
- "Demi to nil does. A flagged error such as `1 / 0` is the answer of the",
4235
+ "Denum to nil does. A flagged error such as `1 / 0` is the answer of the",
4109
4236
  "expression that applies the router, so it is never routed.",
4110
4237
  "",
4111
- "**Observers.** A router declares its Count, Size and residual as a Demi does",
4238
+ "**Observers.** A router declares its Count, Size and residual as a Denum does",
4112
4239
  "(007.25c): its Count C, its total load L+R and the signed difference L−R, where",
4113
4240
  "each load is the sum of the Sizes of the children routed into that channel. So",
4114
- "`router.####` derives the router's Demi as it derives any Frame's,",
4115
- "`Demi(C, L, R)`, and that Demi is the router's numerical shadow. Its phase is",
4241
+ "`router.####` derives the router's Denum as it derives any Frame's,",
4242
+ "`Denum(C, L, R)`, and that Denum is the router's numerical shadow. Its phase is",
4116
4243
  "the router's phase, because both are the parity of the same C. An empty channel",
4117
4244
  "has load 0, the empty sum; a nonempty channel's load is its native Size, which",
4118
4245
  "is that sum. Observation is where children are measured, so it is where their",
4119
4246
  "failures show, and declared observers run only when the router is observed:",
4120
- "routing runs none of them, and observing writes nothing. The Demi forgets which",
4247
+ "routing runs none of them, and observing writes nothing. The Denum forgets which",
4121
4248
  "Frames were routed and their order, so distinct routers can share one.",
4122
4249
  "",
4123
4250
  "**The projection law.** For every router r whose fourth hash exists, that is",
4124
4251
  "every router with C ≥ 1 whose children have Sizes, and every Frame y,",
4125
4252
  "`(r y).#### = (r.####) y`: routing y into the channel the parity of C selects",
4126
4253
  "and then observing adds `y.##` to that channel's load and one to C, which is",
4127
- "exactly what applying `Demi(C, L, R)` to y does. The empty router `[[], []]` is",
4254
+ "exactly what applying `Denum(C, L, R)` to y does. The empty router `[[], []]` is",
4128
4255
  "the boundary: it has routed nothing, so like the empty host `[]` its Count is",
4129
- "zero and `.####` is nil, not a Demi conjured to make the equation look true.",
4130
- "There the law reads through the zero-Count lifting the Demi class names,",
4131
- "`(r0 y).#### = (Demi [0, 0, 0]) y`.",
4256
+ "zero and `.####` is nil, not a Denum conjured to make the equation look true.",
4257
+ "There the law reads through the zero-Count lifting the Denum class names,",
4258
+ "`(r0 y).#### = (Denum [0, 0, 0]) y`.",
4132
4259
  "",
4133
4260
  "**Text.** A router prints as its fields and methods, and as text reads",
4134
4261
  "`RotorRouter([…],[…])`, each channel as its spelling, the constructor's own",
@@ -4148,12 +4275,12 @@ export const HC_SOURCES = new Map([
4148
4275
  "list of channels with the Frame added to that one, so a route costs one pass",
4149
4276
  "over the k channels and never replays the history (PR #482 review).",
4150
4277
  "Its Size is the sum of its channel loads and its residual their alternating",
4151
- "sum, as a channel Demi's are. Its fourth hash is the channel Demi of its",
4152
- "Count and channel loads, `Demi [C, [load0, …]]`: the fourth hash recognizes an",
4278
+ "sum, as a channel Denum's are. Its fourth hash is the channel Denum of its",
4279
+ "Count and channel loads, `Denum [C, [load0, …]]`: the fourth hash recognizes an",
4153
4280
  "instance of this class with other than two channels intrinsically, as it",
4154
- "recognizes a Demi, because the binary Demi the observers derive follows",
4281
+ "recognizes a Denum, because the binary Denum the observers derive follows",
4155
4282
  "parity and not C mod k. So the projection law `(r y).#### = r.#### y` holds",
4156
- "for every arity; at Count zero there is no Demi. Text reads `RotorRouter([ch0, ch1, …])`.",
4283
+ "for every arity; at Count zero there is no Denum. Text reads `RotorRouter([ch0, ch1, …])`.",
4157
4284
  "",
4158
4285
  "`router ./ n`, also spelled `router / n`, re-deals the Frames it holds: it",
4159
4286
  "reconstructs the order they were routed in from its channels, which their",
@@ -4374,7 +4501,7 @@ export const HC_SOURCES = new Map([
4374
4501
  "; (r0 Cyclic).####",
4375
4502
  "# $!.cyclic-observation .##",
4376
4503
  "; “” ((r0 Counted).####)",
4377
- "# “Demi(1,5,0)”",
4504
+ "# “Denum(1,5,0)”",
4378
4505
  "; counter_.n",
4379
4506
  "# 2",
4380
4507
  "```",
@@ -4395,14 +4522,14 @@ export const HC_SOURCES = new Map([
4395
4522
  "## Empty and zero",
4396
4523
  "",
4397
4524
  "The initial router has routed no children, so its Count is zero, and like the",
4398
- "empty host it has no Demi. Its Size and residual still read zero, and it is a",
4399
- "present router in phase 2. The Demi of Count zero is a different thing, a Demi",
4525
+ "empty host it has no Denum. Its Size and residual still read zero, and it is a",
4526
+ "present router in phase 2. The Denum of Count zero is a different thing, a Denum",
4400
4527
  "constructed as such, which routing from the router reaches after one route",
4401
4528
  "```",
4402
4529
  "; [r0.#, r0.##, r0.###, r0.phase, r0.####, [].####]",
4403
4530
  "# [0, 0, 0, 2, (), ()]",
4404
- "; Demis <- './hc/demi.hc';",
4405
- "; [((r0 0).####) = ((Demis.Demi [0, 0, 0]) 0), ((r0 []).####) = ([] []).####]",
4531
+ "; Denums <- './hc/denum.hc';",
4532
+ "; [((r0 0).####) = ((Denums.Denum [0, 0, 0]) 0), ((r0 []).####) = ([] []).####]",
4406
4533
  "# [<>, <>]",
4407
4534
  "```",
4408
4535
  "A Frame of Size zero takes a slot and flips the phase, and an empty array",
@@ -4410,11 +4537,11 @@ export const HC_SOURCES = new Map([
4410
4537
  "```",
4411
4538
  "; .z (r0 0);",
4412
4539
  "; [z.phase, z.left, z.#, “” (z.####)]",
4413
- "# [1, [0], 1, “Demi(1,0,0)”]",
4540
+ "# [1, [0], 1, “Denum(1,0,0)”]",
4414
4541
  "; [“” ((r0 []).####), “” (((r0 []) []).####), “” ((((r0 0) 0) 0).####)]",
4415
- "# [“Demi(1,1,0)”, “Demi(2,1,1)”, “Demi(3,0,0)”]",
4542
+ "# [“Denum(1,1,0)”, “Denum(2,1,1)”, “Denum(3,0,0)”]",
4416
4543
  "```",
4417
- "## The router's Demi",
4544
+ "## The router's Denum",
4418
4545
  "",
4419
4546
  "Each load is the sum of its channel's child Sizes, as exact Counts, over text,",
4420
4547
  "numbers, nested arrays, groups, closures, all, and a Frame routed twice, which",
@@ -4425,17 +4552,17 @@ export const HC_SOURCES = new Map([
4425
4552
  "; [mix.left, mix.right]",
4426
4553
  "# [[“hello”, [[1, 2], [3]], [[], []], { 5 + 3 }], [7, (4, 5), [[], []], <>]]",
4427
4554
  "; [mix.left & {_.##}, mix.right & {_.##}, “” (mix.####)]",
4428
- "# [[5, 6, 2, 9], [7, 9, 2, 1], “Demi(8,22,19)”]",
4555
+ "# [[5, 6, 2, 9], [7, 9, 2, 1], “Denum(8,22,19)”]",
4429
4556
  "; “” (((r0 123456789012345678901234567890) 987654321098765432109876543210).####)",
4430
- "# “Demi(2,123456789012345678901234567890,987654321098765432109876543210)”",
4557
+ "# “Denum(2,123456789012345678901234567890,987654321098765432109876543210)”",
4431
4558
  "```",
4432
- "A router's Demi is `Demi(C, L, R)` of its own channels, and its phase is the",
4559
+ "A router's Denum is `Denum(C, L, R)` of its own channels, and its phase is the",
4433
4560
  "router's phase, for every Count from 1 to 6 and for preloads",
4434
4561
  "```",
4435
4562
  "; .sh (steps & {_.####});",
4436
4563
  "; [sh & {_ = ()}, sh & {_.#}]",
4437
4564
  "# [[<>, (), (), (), (), (), ()], [(), 1, 2, 3, 4, 5, 6]]",
4438
- "; [steps &| {.k _; (k.# .> 0) ? {[k.phase = k.####.phase]} : {[]}}, (RotorRouter [[2, 3], [1]]).#### = (Demis.Demi [3, 5, 1])]",
4565
+ "; [steps &| {.k _; (k.# .> 0) ? {[k.phase = (k.####.phase ())]} : {[]}}, (RotorRouter [[2, 3], [1]]).#### = (Denums.Denum [3, 5, 1])]",
4439
4566
  "# [[<>, <>, <>, <>, <>, <>], <>]",
4440
4567
  "```",
4441
4568
  "## Observing commutes with routing",
@@ -4452,7 +4579,7 @@ export const HC_SOURCES = new Map([
4452
4579
  "# [[5, [1, 2]], [“ab”], 1, <>]",
4453
4580
  "```",
4454
4581
  "For every router whose fourth hash exists, routing Y then observing is applying",
4455
- "the router's Demi to Y, which adds one to the Count. Its fourth hash is X's,",
4582
+ "the router's Denum to Y, which adds one to the Count. Its fourth hash is X's,",
4456
4583
  "Count included. The law holds for routers built by routing and for admissible",
4457
4584
  "preloads alike, in both phases, and for a zero-Size child",
4458
4585
  "```",
@@ -4462,38 +4589,38 @@ export const HC_SOURCES = new Map([
4462
4589
  "; [((p1 Y).####) = ((p1.####) Y), ((p2 {5 + 3}).####) = ((p2.####) {5 + 3}), ((p1 0).####) = ((p1.####) 0)]",
4463
4590
  "# [<>, <>, <>]",
4464
4591
  "; .pre [RotorRouter [[A], []], RotorRouter [[A], [B]], RotorRouter [[A, B], [C]], RotorRouter [[1, 2, 3, 4], [5, 6, 7, 8]], RotorRouter [[1, 2, 3, 4, 5], [6, 7, 8, 9]]];",
4465
- "; [pre & {((_ Y).####) = ((_.####) Y)}, pre & {((_ 0).####) = ((_.####) 0)}, pre & {(_ Y).phase = ((_.####) Y).phase}]",
4592
+ "; [pre & {((_ Y).####) = ((_.####) Y)}, pre & {((_ 0).####) = ((_.####) 0)}, pre & {(_ Y).phase = (((_.####) Y).phase ())}]",
4466
4593
  "# [[<>, <>, <>, <>, <>], [<>, <>, <>, <>, <>], [<>, <>, <>, <>, <>]]",
4467
4594
  "```",
4468
4595
  "The same holds at every step of a walk, Count 1 to 6, and a router can never",
4469
- "route to the channel its Demi does not deposit into",
4596
+ "route to the channel its Denum does not deposit into",
4470
4597
  "```",
4471
4598
  "; steps &| {.k _; (k.# .> 0) ? {[((k Y).####) = ((k.####) Y)]} : {[]}}",
4472
4599
  "# [<>, <>, <>, <>, <>, <>]",
4473
- "; steps &| {.k _; (k.# .> 0) ? {[[((k 4).left.# - k.left.#), (((k.####) 4).left - k.####.left)]]} : {[]}}",
4600
+ "; steps &| {.k _; (k.# .> 0) ? {[[((k 4).left.# - k.left.#), ((((k.####) 4).left ()) - (k.####.left ()))]]} : {[]}}",
4474
4601
  "# [[0, 0], [1, 4], [0, 0], [1, 4], [0, 0], [1, 4]]",
4475
4602
  "```",
4476
4603
  "A failed Size is the answer on both sides: the router routes the Frame and its",
4477
- "Demi fails when observed, and the Demi refuses the deposit with the same error",
4604
+ "Denum fails when observed, and the Denum refuses the deposit with the same error",
4478
4605
  "```",
4479
4606
  "; [((p1 Failing).####), ((p1.####) Failing)]",
4480
4607
  "# [$!.name-missing “..., $!.name-missing “...]",
4481
4608
  "```",
4482
4609
  "The empty host is the boundary. `[].####` is nil, so `X.####` fails the first",
4483
4610
  "equation when X is empty, and so does the initial router, which has routed",
4484
- "nothing and so has Count zero: it has no Demi, and none is faked. The law there",
4485
- "reads through the Demi class's zero-Count lifting, `Demi [0, 0, 0]`, and after",
4611
+ "nothing and so has Count zero: it has no Denum, and none is faked. The law there",
4612
+ "reads through the Denum class's zero-Count lifting, `Denum [0, 0, 0]`, and after",
4486
4613
  "one route the equation holds again",
4487
4614
  "```",
4488
- "; [r0.####, ([] | r0) = r0, (([] | r0).####) = [].####, (([Y] | r0).####) = ([] Y).####, ((r0 Y).####) = ((Demis.Demi [0, 0, 0]) Y), ((r0 0).####) = ((Demis.Demi [0, 0, 0]) 0)]",
4615
+ "; [r0.####, ([] | r0) = r0, (([] | r0).####) = [].####, (([Y] | r0).####) = ([] Y).####, ((r0 Y).####) = ((Denums.Denum [0, 0, 0]) Y), ((r0 0).####) = ((Denums.Denum [0, 0, 0]) 0)]",
4489
4616
  "# [(), <>, <>, <>, <>, <>]",
4490
4617
  "```",
4491
- "## The Demi forgets",
4618
+ "## The Denum forgets",
4492
4619
  "",
4493
- "Distinct routers can share a Demi: the fourth hash keeps only the Count and two",
4620
+ "Distinct routers can share a Denum: the fourth hash keeps only the Count and two",
4494
4621
  "sums, not which Frames were routed, nor their order, nor how the load was split",
4495
4622
  "among them. It does keep how many were routed, so a router with fewer children",
4496
- "and the same loads has a different Demi",
4623
+ "and the same loads has a different Denum",
4497
4624
  "```",
4498
4625
  "; .s1 (RotorRouter [[2, 3], [1]]); .s2 (RotorRouter [[5], [1]]); .s3 (RotorRouter [[3, 2], [1]]); .s4 (RotorRouter [[1, 4], [1]]);",
4499
4626
  "; [s1 = s2, s1 = s3, (s1.####) = (s3.####), (s1.####) = (s4.####), (s1.####) = (s2.####), s1.#, s2.#, s1.##, s2.##]",
@@ -4501,10 +4628,10 @@ export const HC_SOURCES = new Map([
4501
4628
  "```",
4502
4629
  "## Observers, declared",
4503
4630
  "",
4504
- "A router's Count, Size and residual are its Demi's, and its fourth hash is a",
4505
- "Demi, not the router: equal, it would have to be the same class. Its channels",
4631
+ "A router's Count, Size and residual are its Denum's, and its fourth hash is a",
4632
+ "Denum, not the router: equal, it would have to be the same class. Its channels",
4506
4633
  "are fields, not elements, so iterating a router yields nothing. A router",
4507
- "inside an aggregate contributes its declared Size, as a Demi does",
4634
+ "inside an aggregate contributes its declared Size, as a Denum does",
4508
4635
  "```",
4509
4636
  "; [[r3.#, r3.##, r3.###] = [r3.####.#, r3.####.##, r3.####.###], r3.#### = r3, r3.####.#### = r3.####]",
4510
4637
  "# [<>, (), <>]",