hclang 0.47.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,880 +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)”]",
2735
- "",
2736
- ].join("\n"),
2737
- ],
2738
- [
2739
- "hc/denum.hc",
2740
- [
2741
- "#!/usr/bin/env hc",
2742
- "```",
2743
- "Denum and its derived CD view (occurrence/figure 007.31, 007.32, 007.32b, 007.35,",
2744
- "007.35b, 007.36)",
2745
- "",
2746
- "There is one public constructor of retained state, `Denum [Count, loads]`, over",
2747
- "a Count and a nonempty ordered list of nonnegative integer loads, one per",
2748
- "channel, of any positive arity. It stores no rank and no schema, and it is not a",
2749
- "conventional number. The signed Cayley–Dickson algebra is a *view* of a Denum,",
2750
- "requested by `d.cd ()`:",
2751
- "",
2752
- " d = Denum [7, [3, 2, 1, 4]] the only retained state",
2753
- " e = x.#2 a ranked observation: a Denum, never a view",
2754
- " c = d.cd () an explicit Cayley–Dickson view of d",
2755
- " t = (Denum [7, [3, 2, 1]]).cd () refused: $!.denum-unsupported-arity",
2756
- "",
2757
- "**One constructor, one retained Figure.** There is no `CD [Count, loads]`",
2758
- "constructor, no `Denum.cd [Count, loads]` and no conversion constructor. The",
2759
- "view holds the state of the Denum it was derived from and reads its `count` and",
2760
- "`loads` from that state; it has no Count, loads, rank or schema of its own that",
2761
- "could disagree. Every view operation answers a view of a newly derived Denum",
2762
- "state, and `v.denum ()` recovers that state as a Denum. The algebra is supplied",
2763
- "by the request, not inferred from the arity: a Denum with four, eight or",
2764
- "thirty-two loads is generic until `.cd ()` is asked, and the arity alone never",
2765
- "selects the multiplication law. The only algebra published here is the binary",
2766
- "Cayley–Dickson ladder, CD[0] to CD[5]: there is no Fano primitive and no",
2767
- "algebraic reconstruction claim.",
2768
- "",
2769
- "Both are ordinary HC classes, like `Demi`. The view arithmetic is the",
2770
- "Cayley–Dickson recurrence `(a,b)(c,d) = (ac − d̄b, da + bc̄)`, computed by the one",
2771
- "pure native seam `denum-engine` (`lib/ops/denum.ts`, over the typed reference in",
2772
- "`lib/frames/denum.ts`), so no multiplication table is written in HC or in",
2773
- "TypeScript. The engine's CD operations accept only native view frames, which",
2774
- "only the `view` operation makes, and only from a native Denum state, so a raw",
2775
- "`[count, loads]` payload, a lookalike aggregate or a bare `2ⁿ`-load array has no",
2776
- "CD capability. Everything else either type does is in this file.",
2777
- "",
2778
- "**The generic Denum.** `Denum [count, loads]` accepts every positive arity",
2779
- "(1, 2, 3, 4, 5, 6, 8, 33, 64, ...). Its observers are `d.count`, `d.loads`,",
2780
- "`d.#` (the Count), `d.##` (the total load), `d.rank ()` (`⌊log₂ A⌋` of the arity",
2781
- "`A = d.loads.#`, by integer arithmetic and never from the Count), `d.schema ()`",
2782
- "(always `Arity[A]`, even at A = 1, 2, 4, 8, 16, 32) and text",
2783
- "`Denum(Arity[A], C=.., W=[..])`. Its one operation is `+` with another Denum of",
2784
- "the same arity: Counts add, loads add componentwise, nothing cancels and the",
2785
- "result is a fresh Denum. A different arity is `$!.denum-arity-mismatch`; nothing",
2786
- "is padded, truncated or aligned. Everything that needs a signature law (`-`,",
2787
- "`*`, `opp`, `conj`, `promote`, `coordinates`, `observe`, `signatures`, `d.###`)",
2788
- "answers the named refusal `$!.denum-not-cd`, whatever the arity: a generic Denum",
2789
- "has no residual, opposite or product. These methods are defined, to refuse,",
2790
- "rather than absent. A Denum of zero loads is present, not nil.",
2791
- "",
2792
- "**The view.** `d.cd ()` is a unary, pure observation. It needs one of the",
2793
- "shipped channel arities 1, 2, 4, 8, 16, 32; any other arity is",
2794
- "`$!.denum-unsupported-arity`. Any argument but nil is `$!!.unary-observation`.",
2795
- "The source is neither changed nor reordered, and asking twice answers equal",
2796
- "views. The rank `v.rank ()` is again derived, `v.schema ()` is `CD[n]` with text",
2797
- "`CD[n](C=.., W=[..])`. View identity is the class, not the arity: a `+`, `-` or",
2798
- "`*` operand must equal the view that `.cd ()` derives from its own `count` and",
2799
- "`loads`, so a lookalike aggregate with the same fields is `$!!.invalid-denum`,",
2800
- "and a Denum with the same fields is not a view. A view is not a source for the",
2801
- "ranked hash, and a Denum is not an operand of a view operation.",
2802
- "",
2803
- "**Ranks and channels of a view.** On rank n the schema is `CD[n]`, the rung of",
2804
- "the step ladder. Rank 0 has one unsigned channel, `e_ε`. Rank n of 1 or more has",
2805
- "2ⁿ channels, `±e_b` for every direction `b` of n−1 bits, positives first and",
2806
- "then negatives, each in direction order:",
2807
- "",
2808
- " CD[0] e_ε",
2809
- " CD[1] e_ε, -e_ε",
2810
- " CD[2] e_0, e_1, -e_0, -e_1",
2811
- " CD[3] e_00, e_01, e_10, e_11, -e_00, -e_01, -e_10, -e_11",
2812
- " CD[4] ±e_b for b in {0,1}³ 16 channels",
2813
- " CD[5] ±e_b for b in {0,1}⁴ 32 channels",
2814
- "",
2815
- "A minus names a *signature*, never a negative load: every load is a Count.",
2816
- "`v.signatures ()` lists the native names in channel order. Opposite channels stay",
2817
- "separately counted after every operation, so `X + Opp X` is a present, nonempty",
2818
- "view that merely observes as zero. The conventional algebraic value is an",
2819
- "observation, `v.coordinates ()`.",
2820
- "",
2821
- "**State.** `d.count` (the full application Count, kept apart from the loads)",
2822
- "and `d.loads` (one Count per channel) are the whole retained state. The",
2823
- "observers `d.rank ()` and `d.schema ()` are computed from the loads on each call,",
2824
- "so there is no stored rank to drift; the v0.46.0 data spelling `d.rank` and",
2825
- "`d.schema` is replaced by these calls. Anything that is not a Count and a",
2826
- "nonempty list of Counts, including the old three-field `[rank, count, loads]`,",
2827
- "is refused with `$!!.invalid-denum`. `Denum [0, [0]]`, an explicit zero-load",
2828
- "state, is present: it is neither the missing host that `[].#0` leaves nil nor a",
2829
- "nonempty value that observes as zero.",
2830
- "",
2831
- "**View arithmetic.** `+`, `-` and `*` take another view, and only a view.",
2832
- "Operands of different rank are both promoted to the larger rank first",
2833
- "(`promote`), and the result is a view of a fresh Denum of that rank:",
2834
- "",
2835
- "- `a + b` adds corresponding loads and keeps opposite channels separate.",
2836
- "- `a * b` is the ordered Cartesian product of weighted signatures: loads",
2837
- " multiply, the signed destination is the recurrence's, and only identical full",
2838
- " signatures aggregate. Operand order and parentheses are kept, and from",
2839
- " rank 4 the product is not associative.",
2840
- "- `a - b` is `a + b.opp ()`: subtraction is addition of the opposite, observed,",
2841
- " never erased.",
2842
- "- `v.opp ()` swaps the loads of `+e_b` and `-e_b`; a D0 is promoted to D1 first.",
2843
- "- `v.conj ()` keeps the scalar signatures and swaps every other pair.",
2844
- "- `v.promote k` embeds into rank k by the old-summand map, `±e_b ↦ ±e_(0b)`,",
2845
- " keeping Count and loads and starting new channels at zero. A lower k is",
2846
- " `$!.denum-demotion`.",
2847
- "- `v.coordinates ()` is the algebraic observation: the signed coordinate of each",
2848
- " direction, positive load minus negative load, `S_b = W₊,b − W₋,b`.",
2849
- " `v.coordinates <>` is the directional observation: the unsigned coordinate,",
2850
- " positive load plus negative load, `U_b = W₊,b + W₋,b`, which forgets the",
2851
- " signature and keeps all load. Each is an ordered list of integers, width 1 at",
2852
- " rank 0 and 2ⁿ⁻¹ at rank n, and not the view; neither changes the view or",
2853
- " returns its Count. At rank 0 both are `[W_ε]`. The only arguments are nil",
2854
- " `()` and true `<>`; any other argument (a Count, text, a list) is",
2855
- " `$!!.unary-observation`, never coerced by truthiness.",
2856
- "- `v.observe ()` is the deprecated v0.45.0 spelling of `v.coordinates ()`,",
2857
- " kept only as a compatibility alias with exactly the signed result. It takes",
2858
- " no unsigned argument; use `v.coordinates`.",
2859
- "",
2860
- "**Mixed operands.** A generic Denum and a view never combine, in either order, at",
2861
- "equal arity or equal rank: `Denum + view` and `view + Denum` answer",
2862
- "`$!.denum-mixed`, as do a view `-` or `*` with a Denum operand. A generic `-` or",
2863
- "`*` is already the CD-only refusal `$!.denum-not-cd`. Nothing is reinterpreted",
2864
- "and nothing is coerced.",
2865
- "",
2866
- "**Count.** The candidate laws of 007.32 section 6 hold for these new operations",
2867
- "only: `C(a+b) = C(a)+C(b)` (generic and view), `C(a*b) = C(a)·C(b)` and",
2868
- "`C(Opp a) = C(a)` for views, and promotion and conjugation keep Count. Count is",
2869
- "carried, never derived from the loads, and it is not the application phase",
2870
- "`C mod arity`. `Demi` and its `+`, `-`, `*` and `./` are unchanged. This is a",
2871
- "software construction of a supplied recurrence, not a derivation of it from bare",
2872
- "counting.",
2873
- "",
2874
- "**Observers.** Both types declare their own Count (`d.#`) and Size (`d.##`, the",
2875
- "total load). A view also declares its residual (`v.###`, positive minus negative",
2876
- "total, 0 at rank 0), so its `.####` is the ordinary derived Demi of those three,",
2877
- "which is binary and forgets the directions. A generic Denum has no residual",
2878
- "(`d.###` is `$!.denum-not-cd`).",
2879
- "",
2880
- "**The ranked hash.** `x.#n` is an explicit rung operation, n from 0 to 5, and",
2881
- "there is no `#n=`. It answers a generic Denum, never a view. For any Frame x that",
2882
- "is not a Denum or a view, `x.#n` answers the Denum of rank n, `nil` when x has no",
2883
- "Count or Count zero, as `x.####` does. For an ordinary or binary host `x.#1` has",
2884
- "the Count and the left and right loads of `x.####`. A `RotorRouter` of more than",
2885
- "two channels is the exception: `.####` answers its channel Demi, and `.#n` does",
2886
- "not special-case it, so it is the two-channel projection of the router's Count,",
2887
- "Size and residual. Bare `x.#` is still the Count. The host is built from the",
2888
- "three observers it answers, Count C, Size s and residual r: rank 0 keeps the load",
2889
- "s, and rank n ≥ 1 puts (s+r)/2 on the first channel and (s−r)/2 on the first",
2890
- "channel of the second half, the two the fourth hash reads as left and right,",
2891
- "with every other channel zero. A host's applications carry no higher signature,",
2892
- "so none is routed to them. That is construction, and it is not promotion. A Denum",
2893
- "of a shipped binary arity (1, 2, 4, 8, 16, 32) answers `x.#n` by the structural",
2894
- "load-preserving embedding at rung n, keeping Count and loads, and",
2895
- "`$!.denum-demotion` below its own rank. The embedding does not invoke the view,",
2896
- "so the answer is a Denum; it is the same map `v.promote` applies, with no CD",
2897
- "operation attached. A Denum of another arity has no embedding and answers",
2898
- "`$!.denum-unsupported-arity`: nothing is truncated, padded or read as `2^rank`.",
2899
- "A view is not a source: `x.#n` answers `$!.denum-view-source` for it (ask the",
2900
- "Denum it views, `v.denum ()`). A forged lookalike is not recognized as either.",
2901
- "A rank above 5 is `$!.denum-rank`.",
2902
- "",
2903
- "The classes are evaluated from the compiled-in bundle the first time a ranked",
2904
- "hash needs them, in a namespace of its own (`lib/execute/denum-prologue.ts`), so",
2905
- "this file must not import.",
2906
- "```",
2907
- ".denum-state {.s _; .c (s .0); .l (s .1); [",
2908
- " .state s;",
2909
- " .rank {.u ((_ = ()) ? {1} : {0}); .me _^;",
2910
- " (u = 1) ? {denum-engine [11, (me .count), (me .loads)]} : {$!!.unary-observation}};",
2911
- " .schema {.u ((_ = ()) ? {1} : {0}); .me _^;",
2912
- " (u = 1) ? {denum-engine [13, (me .count), (me .loads)]} : {$!!.unary-observation}};",
2913
- " .count c;",
2914
- " .loads l;",
2915
- " .# {_^.count};",
2916
- " .## {(_^ .loads).##};",
2917
- " .### {denum-engine [15]};",
2918
- " .+ {.o (_^^ .operand-denum _); .me _^; .f (_^^ .finish-denum);",
2919
- " (f (denum-engine [12, (me .count), (me .loads), (o .count), (o .loads)]))};",
2920
- " .- {denum-engine [15]};",
2921
- " .* {denum-engine [15]};",
2922
- " .promote {denum-engine [15]};",
2923
- " .opp {denum-engine [15]};",
2924
- " .conj {denum-engine [15]};",
2925
- " .coordinates {denum-engine [15]};",
2926
- " .observe {denum-engine [15]};",
2927
- " .signatures {denum-engine [15]};",
2928
- " .cd {.u ((_ = ()) ? {1} : {0}); .me _^; .f (_^^ .finish-cd);",
2929
- " (u = 1) ? {(f (denum-engine [14, (me .state)]))} : {$!!.unary-observation}};",
2930
- " .toText {“Denum(” (_^ .schema ()) “, C=” (_^ .count) “, W=” (_^ .loads) “)”}",
2931
- " ]};",
2932
- ".cd-state {.s _; .c (s .0); .l (s .1); [",
2933
- " .state s;",
2934
- " .rank {.u ((_ = ()) ? {1} : {0}); .me _^;",
2935
- " (u = 1) ? {denum-engine [11, (me .count), (me .loads)]} : {$!!.unary-observation}};",
2936
- " .schema {.u ((_ = ()) ? {1} : {0}); .me _^;",
2937
- " (u = 1) ? {denum-engine [9, (me .state)]} : {$!!.unary-observation}};",
2938
- " .count c;",
2939
- " .loads l;",
2940
- " .# {_^.count};",
2941
- " .## {(_^ .loads).##};",
2942
- " .### {denum-engine [10, (_^ .state)]};",
2943
- " .+ {.o (_^^ .operand-cd _); .me _^; .f (_^^ .finish-cd);",
2944
- " (f (denum-engine [1, (me .state), (o .state)]))};",
2945
- " .- {.o (_^^ .operand-cd _); .me _^; .f (_^^ .finish-cd);",
2946
- " (f (denum-engine [2, (me .state), (o .state)]))};",
2947
- " .* {.o (_^^ .operand-cd _); .me _^; .f (_^^ .finish-cd);",
2948
- " (f (denum-engine [3, (me .state), (o .state)]))};",
2949
- " .promote {.k _; .me _^; .f (_^^ .finish-cd);",
2950
- " (f (denum-engine [6, (me .state), k]))};",
2951
- " .opp {.u ((_ = ()) ? {1} : {0}); .me _^; .f (_^^ .finish-cd);",
2952
- " (u = 1) ? {(f (denum-engine [4, (me .state)]))} : {$!!.unary-observation}};",
2953
- " .conj {.u ((_ = ()) ? {1} : {0}); .me _^; .f (_^^ .finish-cd);",
2954
- " (u = 1) ? {(f (denum-engine [5, (me .state)]))} : {$!!.unary-observation}};",
2955
- " .coordinates {.s ((_ = ()) ? {1} : {0}); .t ((_ = <>) ? {1} : {0}); .me _^;",
2956
- " ((s + t) = 1) ? {denum-engine [7, (me .state), t]} : {$!!.unary-observation}};",
2957
- " .observe {.u ((_ = ()) ? {1} : {0}); .me _^;",
2958
- " (u = 1) ? {denum-engine [7, (me .state), 0]} : {$!!.unary-observation}};",
2959
- " .signatures {.u ((_ = ()) ? {1} : {0}); .me _^;",
2960
- " (u = 1) ? {denum-engine [8, (me .state)]} : {$!!.unary-observation}};",
2961
- " .denum {.u ((_ = ()) ? {1} : {0}); .me _^; .d (_^^ .Denum);",
2962
- " (u = 1) ? {(d [(me .count), (me .loads)])} : {$!!.unary-observation}};",
2963
- " .toText {(_^ .schema ()) “(C=” (_^ .count) “, W=” (_^ .loads) “)”}",
2964
- " ]};",
2965
- ".view-of {.d _; (d .cd ())};",
2966
- ".operand-denum {.o _; .r (Denum [(o .count), (o .loads)]);",
2967
- " (o = r) ? {o} : {(refuse-operand o)}};",
2968
- ".viewable {.g _; ((g ~ ([].<>)) ? {(denum-engine [17, (g .state)])} : {0})};",
2969
- ".operand-cd {.o _; .g (Denum [(o .count), (o .loads)]);",
2970
- " ((viewable g) = 1) ? {.r (view-of g); (o = r) ? {o} : {(refuse-operand o)}} : {(refuse-operand o)}};",
2971
- ".refuse-operand {.o _; .g (Denum [(o .count), (o .loads)]);",
2972
- " .ig (((g ~ ([].<>)) ? {(o = g)}) ? {1} : {0});",
2973
- " .ic (((viewable g) = 1) ? {.c (view-of g); (o = c) ? {1} : {0}} : {0});",
2974
- " ((ig + ic) = 1) ? {denum-engine [16]} : {$!!.invalid-denum}};",
2975
- ".finish-denum {.s _; ((s ~ ([].<>)) ? {denum-state s} : {s})};",
2976
- ".finish-cd {.s _; ((s ~ ([].<>)) ? {cd-state s} : {s})};",
2977
- ".Denum {.a _; ((a ~ ([].<>)) ? {(a .#) = 2}) ? {.s (denum-engine [0, (a .0), (a .1)]);",
2978
- " (s ~ ([].<>)) ? {denum-state s} : {$!!.invalid-denum}} : {$!!.invalid-denum}}",
2979
- "```",
2980
- "## Construction",
2981
- "",
2982
- "There is one public constructor of retained state, `Denum [count, loads]`, and",
2983
- "the explicit Cayley–Dickson interpretation is a request on the result, `d.cd ()`.",
2984
- "Both views and Denums hold only the Count and one load per channel; the rank",
2985
- "and schema are observed from the loads, never stored. In this file `V [count,",
2986
- "loads]` is shorthand for `(Denum [count, loads]).cd ()`, defined once for the",
2987
- "examples. It is not a constructor of the bundled classes: there is no `CD` name",
2988
- "in them, and `V` exists only in these examples",
2989
- "```",
2990
- "; .V {.d (Denum _); (d .cd ())};",
2991
- "; .z (V [0, [0]]);",
2992
- "; [z.rank (), z.schema (), z.count, z.loads, z.#, z.##, z.###, “” z]",
2993
- "# [0, “CD[0]”, 0, [0], 0, 0, 0, “CD[0](C=0, W=[0])”]",
2994
- "```",
2995
- "A Denum of zero loads is equally present: it is not nil and not a view",
2996
- "```",
2997
- "; .gz (Denum [0, [0, 0, 0, 0]]);",
2998
- "; [“” gz, gz.rank (), gz.schema (), gz.count, gz.loads, gz.##, gz = ()]",
2999
- "# [“Denum(Arity[4], C=0, W=[0, 0, 0, 0])”, 2, “Arity[4]”, 0, [0, 0, 0, 0], 0, ()]",
3000
- "```",
3001
- "The loads are Counts, one per channel, and the Count is kept apart from them: a",
3002
- "state may hold loads at Count zero, or a Count over zero loads. A negative Count",
3003
- "or load, a fractional load, an empty load list, the legacy three-field",
3004
- "`[rank, count, loads]` constructor and a non-list (a bare Count or text for the",
3005
- "loads included) are refused by `Denum`, and so by every view request, because no",
3006
- "view exists without a Denum",
3007
- "```",
3008
- "; [“” (V [7, [3, 2, 0, 1]]), “” (V [0, [4, 0]]), “” (V [5, [0, 0]])]",
3009
- "# [“CD[2](C=7, W=[3, 2, 0, 1])”, “CD[1](C=0, W=[4, 0])”, “CD[1](C=5, W=[0, 0])”]",
3010
- "; [Denum [(0 - 1), [0, 0]], Denum [0, [0, (0 - 1)]], Denum [0, [0, 1.5]], Denum [0, []], Denum 5, Denum [0], Denum [1, 0, [0, 0]], Denum [2, 7, [3, 2, 0, 1]], Denum [0, [0, 0], 9], Denum [0, 5], Denum [0, “x”]]",
3011
- "# [$!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum]",
3012
- "```",
3013
- "## One constructor, a derived view",
3014
- "",
3015
- "`Denum [7, [3, 2, 1, 4]]` is generic. It has the arity 4, the rank 2, the Count 7",
3016
- "and the Size 10, but the channel count does not select the algebra: only the",
3017
- "request `.cd ()` does, and it answers a different type. The Denum schema is",
3018
- "`Arity[4]`, the view's `CD[2]`, the texts differ, and the two are not equal. The",
3019
- "view reads its Count and loads from the Denum it was derived from, and the Denum",
3020
- "is unchanged",
3021
- "```",
3022
- "; .gd (Denum [7, [3, 2, 1, 4]]); .dc (gd.cd ());",
3023
- "; [gd.#, dc.#, gd.##, dc.##, gd.rank (), dc.rank (), gd.schema (), dc.schema ()]",
3024
- "# [7, 7, 10, 10, 2, 2, “Arity[4]”, “CD[2]”]",
3025
- "; [“” gd, “” dc, gd = dc, dc = gd, gd.loads = dc.loads, gd.count = dc.count]",
3026
- "# [“Denum(Arity[4], C=7, W=[3, 2, 1, 4])”, “CD[2](C=7, W=[3, 2, 1, 4])”, (), (), <>, <>]",
3027
- "```",
3028
- "Deriving the view again is deterministic, and the source is untouched: still",
3029
- "generic, still equal to its own reconstruction. The Denum behind a view is",
3030
- "recovered with `v.denum ()`, equal to the original",
3031
- "```",
3032
- "; [gd.cd () = dc, dc.denum () = gd, “” (dc.denum ()), gd.loads, gd.count, gd = (Denum [7, [3, 2, 1, 4]])]",
3033
- "# [<>, <>, “Denum(Arity[4], C=7, W=[3, 2, 1, 4])”, [3, 2, 1, 4], 7, <>]",
3034
- "```",
3035
- "Only the view has the signed and unsigned coordinates and the signatures. The",
3036
- "Denum has no CD interpretation: every CD-only operation on it answers the named",
3037
- "refusal `$!.denum-not-cd`, whatever its arity, and its loads are untouched",
3038
- "```",
3039
- "; [dc.coordinates (), dc.coordinates <>, dc.signatures (), dc.###]",
3040
- "# [[2, -2], [4, 6], [“e_0”, “e_1”, “-e_0”, “-e_1”], 0]",
3041
- "; [gd.coordinates (), gd.coordinates <>, gd.observe (), gd.signatures (), gd.###]",
3042
- "# [$!.denum-not-cd, $!.denum-not-cd, $!.denum-not-cd, $!.denum-not-cd, $!.denum-not-cd]",
3043
- "; [gd.opp (), gd.conj (), gd.promote 3, gd * gd, gd - gd, gd.loads, gd.count]",
3044
- "# [$!.denum-not-cd, $!.denum-not-cd, $!.denum-not-cd, $!.denum-not-cd, $!.denum-not-cd, [3, 2, 1, 4], 7]",
3045
- "```",
3046
- "The request is unary. Any argument but nil is refused by name, and the Denum is",
3047
- "unchanged. A view has no `.cd`, and none of the old constructor spellings exist",
3048
- "```",
3049
- "; [gd.cd 1, gd.cd <>, gd.cd “x”, gd.cd [1]]",
3050
- "# [$!!.unary-observation, $!!.unary-observation, $!!.unary-observation, $!!.unary-observation]",
3051
- "; [dc.denum 1, dc.denum <>, gd.loads]",
3052
- "# [$!!.unary-observation, $!!.unary-observation, [3, 2, 1, 4]]",
3053
- "```",
3054
- "## Derived rank and arbitrary arity",
3055
- "",
3056
- "The rank is `⌊log₂ A⌋` of the arity `A = d.loads.#`, by integer arithmetic. It is",
3057
- "never the Count `d.#`, and there is no rank field: `d.rank ()` computes it from",
3058
- "the loads alone each time it is asked. This is an explicit call, so the v0.46.0",
3059
- "data spelling `d.rank` is gone, and any argument but `()` is",
3060
- "`$!!.unary-observation`. Any positive number of loads is a Denum, so",
3061
- "`Denum [7, [3, 2, 1]]` has Count 7, three loads, Size 6 and rank 1, and no",
3062
- "channel is dropped or added",
3063
- "```",
3064
- "; .three (Denum [7, [3, 2, 1]]);",
3065
- "; [three.#, three.loads, three.loads.#, three.##, three.rank (), three.schema ()]",
3066
- "# [7, [3, 2, 1], 3, 6, 1, “Arity[3]”]",
3067
- "; [three.rank 1, three.rank <>, “” three]",
3068
- "# [$!!.unary-observation, $!!.unary-observation, “Denum(Arity[3], C=7, W=[3, 2, 1])”]",
3069
- "```",
3070
- "The rank steps at every power of two, whatever the loads or the Count, and the",
3071
- "same holds for the view observer",
3072
- "```",
3073
- "; .z4 [0, 0, 0, 0]; .z8 [0, 0, 0, 0, 0, 0, 0, 0];",
3074
- "; [(Denum [0, [0]]).rank (), (Denum [0, [0, 0]]).rank (), three.rank (), (Denum [0, z4]).rank (), (Denum [0, [1, 2, 3, 4, 5]]).rank (), (Denum [0, [1, 2, 3, 4, 5, 6]]).rank (), (Denum [0, [1, 2, 3, 4, 5, 6, 7]]).rank (), (Denum [0, z8]).rank ()]",
3075
- "# [0, 1, 1, 2, 2, 2, 2, 3]",
3076
- "; [(V [0, [0]]).rank (), (V [0, [0, 0]]).rank (), (V [0, z4]).rank (), (V [0, z8]).rank ()]",
3077
- "# [0, 1, 2, 3]",
3078
- "```",
3079
- "Identical loads at different Counts have the same rank, and the Count never",
3080
- "enters it",
3081
- "```",
3082
- "; [(Denum [0, [3, 2, 1]]).rank (), (Denum [99, [3, 2, 1]]).rank (), (Denum [1000, [0]]).rank (), (Denum [1000, [0, 0]]).rank ()]",
3083
- "# [1, 1, 0, 1]",
3084
- "```",
3085
- "A Denum accepts every positive arity, including 5, 6, 33 and 64, whose rank 6 is",
3086
- "above the shipped CD rung 5. Its schema text is `Arity[A]`",
3087
- "```",
3088
- "; .t6 (Denum [1, [1, 2, 3, 4, 5, 6]]);",
3089
- "; .t33 (Denum [1, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]); .t64 (Denum [2, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]);",
3090
- "; [t6.schema (), t6.rank (), t33.schema (), t33.rank (), t64.schema (), t64.rank (), t64.loads.#, t64.##, (Denum [0, [0, 0, 0, 0, 0]]).schema ()]",
3091
- "# [“Arity[6]”, 2, “Arity[33]”, 5, “Arity[64]”, 6, 64, 0, “Arity[5]”]",
3092
- "```",
3093
- "## Generic addition",
3094
- "",
3095
- "Two Denums of the same arity add componentwise: Counts add, loads add, nothing",
3096
- "cancels, and the result is a fresh Denum of that arity. This is true at an odd",
3097
- "arity and at a power of two alike, and the Count is independent of the Size",
3098
- "```",
3099
- "; .p3 (Denum [7, [3, 2, 1]]); .q3 (Denum [2, [4, 0, 0]]); .r3 (p3 + q3);",
3100
- "; [r3.count, r3.loads, r3.##, r3.rank (), r3.schema (), “” r3, p3.loads, q3.loads]",
3101
- "# [9, [7, 2, 1], 10, 1, “Arity[3]”, “Denum(Arity[3], C=9, W=[7, 2, 1])”, [3, 2, 1], [4, 0, 0]]",
3102
- "; .p4 (Denum [7, [3, 2, 1, 4]]); .q4 (Denum [2, [4, 0, 0, 5]]); .r4 (p4 + q4);",
3103
- "; [r4.count, r4.loads, r4.##, r4.rank (), r4.schema (), “” r4]",
3104
- "# [9, [7, 2, 1, 9], 19, 2, “Arity[4]”, “Denum(Arity[4], C=9, W=[7, 2, 1, 9])”]",
3105
- "```",
3106
- "Opposite-looking channels are only loads here. They add, with no sign and no",
3107
- "cancellation, and a sum is a new value, not an operand. Chaining stays generic",
3108
- "```",
3109
- "; .o4 (Denum [1, [2, 0, 1, 0]]); .u4 (Denum [1, [0, 3, 0, 2]]);",
3110
- "; [(o4 + u4).loads, (o4 + u4).count, (o4 + u4) = o4, (o4 + u4) = (o4 + u4), ((o4 + u4) + o4).loads, “” ((o4 + u4) + o4)]",
3111
- "# [[2, 3, 1, 2], 2, (), <>, [4, 3, 2, 2], “Denum(Arity[4], C=3, W=[4, 3, 2, 2])”]",
3112
- "; [((Denum [1, [2]]) + (Denum [2, [5]])).loads, ((Denum [1, [2]]) + (Denum [2, [5]])).count, ((Denum [0, [1, 2, 3, 4, 5]]) + (Denum [0, [5, 4, 3, 2, 1]])).loads]",
3113
- "# [[7], 3, [6, 6, 6, 6, 6]]",
3114
- "```",
3115
- "Different arities are refused by name (`$!.denum-arity-mismatch`); nothing is",
3116
- "padded, truncated or aligned",
3117
- "```",
3118
- "; [p3 + p4, p4 + p3, p3 + (Denum [1, [1]]), (Denum [1, [1, 2]]) + p3]",
3119
- "# [$!.denum-arity-mismatch, $!.denum-arity-mismatch, $!.denum-arity-mismatch, $!.denum-arity-mismatch]",
3120
- "```",
3121
- "## View eligibility",
3122
- "",
3123
- "`d.cd ()` needs one of the shipped channel arities 1, 2, 4, 8, 16 or 32. Any",
3124
- "other arity is the named refusal `$!.denum-unsupported-arity`; no channel is",
3125
- "padded, truncated or dropped, and the Denum is unchanged",
3126
- "```",
3127
- "; [“” ((Denum [7, [3, 2, 1, 4]]).cd ()), “” ((Denum [0, [0]]).cd ())]",
3128
- "# [“CD[2](C=7, W=[3, 2, 1, 4])”, “CD[0](C=0, W=[0])”]",
3129
- "; .zeros33 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];",
3130
- "; [(Denum [7, [3, 2, 1]]).cd (), (Denum [7, [3, 2, 1, 4, 5]]).cd (), (Denum [1, [1, 2, 3, 4, 5, 6]]).cd (), (Denum [0, zeros33]).cd (), t64.cd ()]",
3131
- "# [$!.denum-unsupported-arity, $!.denum-unsupported-arity, $!.denum-unsupported-arity, $!.denum-unsupported-arity, $!.denum-unsupported-arity]",
3132
- "```",
3133
- "There is no way to ask for a view without a Denum. A view of a Denum is not a",
3134
- "new constructor of state: its Count and loads are the Denum's, and the Denum",
3135
- "behind it is recovered, equal, with `v.denum ()`. A fresh Denum built from the",
3136
- "same fields is the same Denum, and so derives the same view",
3137
- "```",
3138
- "; .src (Denum [7, [3, 2, 1, 4]]); .made ((Denum [(src.count), (src.loads)]).cd ());",
3139
- "; [“” made, made = src, made = (src.cd ()), src.schema (), made.schema (), src.loads]",
3140
- "# [“CD[2](C=7, W=[3, 2, 1, 4])”, (), <>, “Arity[4]”, “CD[2]”, [3, 2, 1, 4]]",
3141
- "```",
3142
- "## Mixed operands",
3143
- "",
3144
- "A Denum and a view never combine, in either order and at any arity or rank. The",
3145
- "Denum is not reinterpreted as a view at a matching arity, and a view is not read",
3146
- "as a Denum either. `+` answers `$!.denum-mixed`; a generic `-` or `*` is the",
3147
- "CD-only refusal `$!.denum-not-cd` on its own, and a view `-` or `*` with a Denum",
3148
- "operand is `$!.denum-mixed`",
3149
- "```",
3150
- "; [gd + dc, dc + gd, dc - gd, dc * gd, gd - dc, gd * dc]",
3151
- "# [$!.denum-mixed, $!.denum-mixed, $!.denum-mixed, $!.denum-mixed, $!.denum-not-cd, $!.denum-not-cd]",
3152
- "; .dc1 (V [1, [1, 0]]); .gd1 (Denum [1, [1, 0]]); .gd2 (Denum [1, [1]]); .dc0 (V [1, [1]]);",
3153
- "; [dc1 + gd1, gd1 + dc1, dc1 * gd1, dc0 + gd2, gd2 + dc0, dc + (Denum [1, [1, 2, 3]]), (Denum [1, [1, 2, 3]]) + dc]",
3154
- "# [$!.denum-mixed, $!.denum-mixed, $!.denum-mixed, $!.denum-mixed, $!.denum-mixed, $!.denum-mixed, $!.denum-mixed]",
3155
- "```",
3156
- "Neither identity is forged by copying `count` and `loads`: a plain aggregate with",
3157
- "the same fields is neither a Denum nor a view, whatever the operation or the",
3158
- "order",
3159
- "```",
3160
- "; .fake [.count 7; .loads [3, 2, 1, 4]];",
3161
- "; [gd + fake, dc + fake, dc - fake, dc * fake, gd + [.count 7; .loads [3, 2, 1]], dc + [.count 7; .loads [3, 2, 1]]]",
3162
- "# [$!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum]",
3163
- "; .lookalike [.count 7; .loads [3, 2, 1, 4]; .rank {2}; .schema {“CD[2]”}];",
3164
- "; [dc + lookalike, gd + lookalike, dc * lookalike, fake = dc, fake = gd]",
3165
- "# [$!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, (), ()]",
3166
- "```",
3167
- "## Native capability",
3168
- "",
3169
- "The engine's CD operations do not take payloads. They take native view frames,",
3170
- "which only the `view` operation makes, and only from a native Denum state. An",
3171
- "arbitrary `[count, loads]` payload, a state built by hand, a lookalike with a",
3172
- "`state` field and a bare `2ⁿ`-load array all lack that capability. The raw",
3173
- "spelling of the old operations is refused by name, and so is a view request on a",
3174
- "payload (`$!!.invalid-denum`)",
3175
- "```",
3176
- "; [denum-engine [3, 1, [0, 1, 0, 0], 1, [0, 1, 0, 0]], denum-engine [1, 7, [3, 2, 1, 4], 1, [0, 1, 0, 0]], denum-engine [7, 7, [3, 2, 1, 4]], denum-engine [14, 7, [3, 2, 1, 4]]]",
3177
- "# [$!.denum-not-view, $!.denum-not-view, $!.denum-not-view, $!!.invalid-denum]",
3178
- "; .forged [.count 7; .loads [3, 2, 1, 4]; .state [7, [3, 2, 1, 4]]];",
3179
- "; [denum-engine [14, (forged .state)], denum-engine [7, (forged .state), 0], denum-engine [14, [7, [3, 2, 1, 4]]], denum-engine [9, [7, [3, 2, 1, 4]]], denum-engine [10, gd]]",
3180
- "# [$!!.invalid-denum, $!.denum-not-view, $!!.invalid-denum, $!.denum-not-view, $!.denum-not-view]",
3181
- "```",
3182
- "A real view derived by `.cd ()` carries the capability, and a Denum state does not",
3183
- "turn into a view without the request: the `view` operation on a view, or on the",
3184
- "state of a view, is the same refusal",
3185
- "```",
3186
- "; [denum-engine [9, (dc .state)], denum-engine [9, (gd .state)], denum-engine [14, (dc .state)], denum-engine [9, (denum-engine [14, (gd .state)])]]",
3187
- "# [“CD[2]”, $!.denum-not-view, $!!.invalid-denum, “CD[2]”]",
3188
- "```",
3189
- "## Signatures",
3190
- "",
3191
- "The native spelling has no sign bit: the direction is a bitstring of rank − 1",
3192
- "bits, and a minus names the opposite signature. Rank 0 has only `e_ε`",
3193
- "```",
3194
- "; [(V [0, [0]]).signatures (), (V [0, [0, 0]]).signatures (), (V [0, [0, 0, 0, 0]]).signatures ()]",
3195
- "# [[“e_ε”], [“e_ε”, “-e_ε”], [“e_0”, “e_1”, “-e_0”, “-e_1”]]",
3196
- "; (V [0, [0, 0, 0, 0, 0, 0, 0, 0]]).signatures ()",
3197
- "# [“e_00”, “e_01”, “e_10”, “e_11”, “-e_00”, “-e_01”, “-e_10”, “-e_11”]",
3198
- "; (V [0, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]).signatures () .# ",
3199
- "# 16",
3200
- "; ((V [0, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]).signatures ()) .# ",
3201
- "# 32",
3202
- "```",
3203
- "## Rank 0 and rank 1: Size and signed integers",
3204
- "",
3205
- "D0 adds and multiplies unsigned Size, and Counts add and multiply with it. D1",
3206
- "has the two signatures `e_ε` and `-e_ε`, and the product of two minus signatures",
3207
- "is the plus signature, `(-e_ε)(-e_ε) = e_ε`, while every load stays a Count",
3208
- "```",
3209
- "; .a (V [2, [3]]); .b (V [5, [4]]);",
3210
- "; [(a + b).loads, (a + b).count, (a * b).loads, (a * b).count]",
3211
- "# [[7], 7, [12], 10]",
3212
- "; .p (V [1, [1, 0]]); .m (V [1, [0, 1]]);",
3213
- "; [(m * m).loads, (m * p).loads, (p * m).loads, (p * p).loads]",
3214
- "# [[1, 0], [0, 1], [0, 1], [1, 0]]",
3215
- "; [((V [1, [0, 2]]) * (V [1, [0, 3]])).loads, ((V [1, [0, 2]]) * (V [1, [0, 3]])).coordinates ()]",
3216
- "# [[6, 0], [6]]",
3217
- "```",
3218
- "Opposite swaps the two channels and subtraction adds the opposite. The balanced",
3219
- "result observes as zero yet is a present, nonempty Denum with both loads",
3220
- "```",
3221
- "; .x (V [1, [5, 2]]); .y (V [1, [3, 0]]);",
3222
- "; [x.coordinates (), (x.opp ()).loads, (x - y).loads, (x - y).coordinates (), (x - y).count]",
3223
- "# [[3], [2, 5], [5, 5], [0], 2]",
3224
- "; .s (V [1, [4, 4]]);",
3225
- "; [s.coordinates (), s.loads, s.#, s.##, s.###]",
3226
- "# [[0], [4, 4], 1, 8, 0]",
3227
- "```",
3228
- "A D0 has no negative signature, so its opposite is promoted to D1 first",
3229
- "```",
3230
- "; ((V [3, [4]]).opp ()).loads",
3231
- "# [0, 4]",
3232
- "; ((V [3, [4]]).opp ()).schema ()",
3233
- "# “CD[1]”",
3234
- "```",
3235
- "## Operands are views only",
3236
- "",
3237
- "A view's `+`, `-` and `*` refuse a right operand that is not a view, even when",
3238
- "it carries the same `count` and `loads` fields, as `x.#n` refuses a forged source.",
3239
- "A Denum with those fields is `$!.denum-mixed`, shown above",
3240
- "```",
3241
- "; .dp (V [1, [1, 0]]); .lookalike [.count 1; .loads [1, 0]];",
3242
- "; [dp + lookalike, dp - lookalike, dp * lookalike, dp + [1, 1, [1, 0]], dp * 2]",
3243
- "# [$!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum, $!!.invalid-denum]",
3244
- "; [(dp + dp).loads, (dp * (dp + dp)).loads, (dp + (dp.opp ())).loads, “” (dp + dp)]",
3245
- "# [[2, 0], [2, 0], [1, 1], “CD[1](C=2, W=[2, 0])”]",
3246
- "```",
3247
- "## Rank 2: J² = −1 and the four-step cycle",
3248
- "",
3249
- "`e_1` is the direction bit of J. Its square is the opposite scalar `-e_0`, and",
3250
- "the fourth power is back at `e_0`, observed",
3251
- "```",
3252
- "; .j (V [1, [0, 1, 0, 0]]);",
3253
- "; [(j * j).loads, (j * j).coordinates (), ((j * j) * (j * j)).loads, ((j * j) * (j * j)).coordinates ()]",
3254
- "# [[0, 0, 1, 0], [-1, 0], [1, 0, 0, 0], [1, 0]]",
3255
- "```",
3256
- "## Rank 3: order matters",
3257
- "",
3258
- "With J = `e_01`, I = `e_10` and K = `e_11`, J·I = K and I·J = −K",
3259
- "```",
3260
- "; .J (V [1, [0, 1, 0, 0, 0, 0, 0, 0]]); .I (V [1, [0, 0, 1, 0, 0, 0, 0, 0]]);",
3261
- "; [(J * I).loads, (I * J).loads]",
3262
- "# [[0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1]]",
3263
- "```",
3264
- "## Rank 4: the octonion associator",
3265
- "",
3266
- "`(e_001 e_010) e_100` is `+e_111` and `e_001 (e_010 e_100)` is `-e_111`. The",
3267
- "view keeps the parentheses, so the two groupings differ",
3268
- "```",
3269
- "; .o1 (V [1, [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]); .o2 (V [1, [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]); .o4 (V [1, [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]);",
3270
- "; [((o1 * o2) * o4).loads, (o1 * (o2 * o4)).loads]",
3271
- "# [[0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]]",
3272
- "; [((o1 * o2) * o4).coordinates () = (o1 * (o2 * o4)).coordinates ()]",
3273
- "# [()]",
3274
- "```",
3275
- "Through rank 3 the product is associative, so the same three directions in the",
3276
- "quaternions agree",
3277
- "```",
3278
- "; [(J * I) * J = (J * (I * J)), ((J * I) * J).coordinates ()]",
3279
- "# [<>, [0, 0, 1, 0]]",
3280
- "```",
3281
- "## Rank 5: sedenion zero divisors",
3282
- "",
3283
- "`(e_0001 + e_1010)(e_0100 − e_1111)` observes as zero though neither factor does.",
3284
- "The product is not an empty view: it holds four loads, in cancelling pairs",
3285
- "```",
3286
- "; .u (V [1, [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]); .v (V [1, [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]]);",
3287
- "; [u.coordinates (), v.coordinates ()]",
3288
- "# [[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1]]",
3289
- "; .w (u * v);",
3290
- "; [w.coordinates (), w.count, w.##, w.###, w.loads]",
3291
- "# [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 1, 4, 0, [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]]",
3292
- "```",
3293
- "## Promotion across the ladder",
3294
- "",
3295
- "Promotion embeds a lower rung into a higher one as the old summand,",
3296
- "`±e_b ↦ ±e_(0b)`, keeping the Count and every load and starting the new channels",
3297
- "at zero. D0 goes to the positive scalar, so the new minus channel is empty, and",
3298
- "the map is path independent",
3299
- "```",
3300
- "; .t (V [4, [6]]);",
3301
- "; [(t.promote 1).loads, (t.promote 2).loads, ((t.promote 1).promote 2).loads = (t.promote 2).loads, (t.promote 3).count]",
3302
- "# [[6, 0], [6, 0, 0, 0], <>, 4]",
3303
- "; .k (V [3, [2, 5]]);",
3304
- "; [(k.promote 2).loads, (k.promote 3).loads, ((k.promote 2).promote 3).loads = (k.promote 3).loads, k.loads, k.rank ()]",
3305
- "# [[2, 0, 5, 0], [2, 0, 0, 0, 5, 0, 0, 0], <>, [2, 5], 1]",
3306
- "; [((V [1, [0, 1, 0, 0]]).promote 3).loads, ((V [1, [0, 0, 0, 1]]).promote 3).loads]",
3307
- "# [[0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0]]",
3308
- "```",
3309
- "A lower rank is refused, and so is a rank above 5 or something that is not a",
3310
- "Count. The source is never changed",
3311
- "```",
3312
- "; [(V [1, [0, 0, 0, 0, 0, 0, 0, 0]]).promote 2, k.promote 6, k.promote (0 - 1), k.promote “x”]",
3313
- "# [$!.denum-demotion, $!.denum-rank, $!.denum-rank, $!.denum-rank]",
3314
- "```",
3315
- "Mixed ranks promote to the larger one before the operation, and the product keeps",
3316
- "its operand order. A rank 2 and a rank 3 view multiply as two rank 3 views",
3317
- "```",
3318
- "; .c2 (V [2, [0, 1, 0, 0]]); .c3 (V [3, [0, 0, 1, 0, 0, 0, 0, 0]]);",
3319
- "; [(c2 * c3).schema (), (c2 * c3).loads, (c3 * c2).loads, (c2 * c3).loads = ((c2.promote 3) * c3).loads, (c2 + c3).schema (), (c2 + c3).count]",
3320
- "# [“CD[3]”, [0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1], <>, “CD[3]”, 5]",
3321
- "; [((c3.promote 5) * (V [1, [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])).loads = ((c3 * (V [1, [0, 1, 0, 0, 0, 0, 0, 0]])).promote 5).loads]",
3322
- "# [<>]",
3323
- "```",
3324
- "## Conjugation",
3325
- "",
3326
- "Conjugation fixes the scalar signatures and swaps the two channels of every",
3327
- "other direction. It keeps the Count and the loads. A product conjugates in",
3328
- "reverse order, observed",
3329
- "```",
3330
- "; .g (V [4, [1, 2, 3, 4]]);",
3331
- "; [(g.conj ()).loads, (g.conj ()).count, (g.conj ()).coordinates (), g.coordinates ()]",
3332
- "# [[1, 4, 3, 2], 4, [-2, 2], [-2, -2]]",
3333
- "; [(((J * I).conj ()).coordinates ()) = (((I.conj ()) * (J.conj ())).coordinates ()), ((V [1, [4]]).conj ()).loads]",
3334
- "# [<>, [4]]",
3335
- "```",
3336
- "## Count",
3337
- "",
3338
- "Count is carried and never derived from the loads. For these view operations",
3339
- "it adds under `+`, multiplies under `*`, and survives the opposite, conjugation",
3340
- "and promotion. A Count of zero may hold nonzero loads",
3341
- "```",
3342
- "; .e (V [3, [1, 0, 0, 2]]); .f (V [4, [0, 5, 1, 0]]);",
3343
- "; [(e + f).count, (e * f).count, (e.opp ()).count, (e.conj ()).count, (e.promote 4).count, (e - f).count]",
3344
- "# [7, 12, 3, 3, 3, 7]",
3345
- "; .odd (V [0, [3, 0, 0, 0]]);",
3346
- "; [odd.count, odd.##, (odd * f).count, (odd * f).loads, (odd + f).count]",
3347
- "# [0, 3, 0, [0, 15, 3, 0], 4]",
3348
- "```",
3349
- "## Coordinates: signed and unsigned",
3350
- "",
3351
- "One method reads the preserved view two ways. `d.coordinates ()` is the signed",
3352
- "coordinate `S_b = W₊,b − W₋,b` and `d.coordinates <>` is the unsigned",
3353
- "coordinate `U_b = W₊,b + W₋,b`, one integer per direction in the order of the",
3354
- "channels. They are observations: they never change the view, and the Count is",
3355
- "neither used nor returned. `U` is not `|S|`: opposing loads 3 and 1 give",
3356
- "`S = 2` and `U = 4`, and the Count 1 below is not a coordinate",
3357
- "```",
3358
- "; .q (V [1, [3, 2, 1, 4]]);",
3359
- "; [q.coordinates (), q.coordinates <>, q.observe (), q.count, q.loads]",
3360
- "# [[2, -2], [4, 6], [2, -2], 1, [3, 2, 1, 4]]",
3361
- "```",
3362
- "The Count is independent: the same loads at another Count, even zero, give the",
3363
- "same coordinates, and a positive Count over zero loads gives zero coordinates",
3364
- "```",
3365
- "; .q9 (V [9, [3, 2, 1, 4]]); .q0 (V [0, [3, 2, 1, 4]]); .qz (V [5, [0, 0, 0, 0]]);",
3366
- "; [q9.coordinates (), q9.coordinates <>, q0.coordinates <>, qz.coordinates (), qz.coordinates <>, qz.count]",
3367
- "# [[2, -2], [4, 6], [4, 6], [0, 0], [0, 0], 5]",
3368
- "```",
3369
- "Rank 0 has one unsigned channel, so both readings are its one load. Higher ranks",
3370
- "have width 2ⁿ⁻¹",
3371
- "```",
3372
- "; .r0 (V [2, [3]]); .r1 (V [2, [4, 2]]); .r3 (V [0, [1, 2, 3, 4, 0, 0, 0, 0]]);",
3373
- "; [r0.coordinates (), r0.coordinates <>, r1.coordinates (), r1.coordinates <>, r3.coordinates (), r3.coordinates <>]",
3374
- "# [[3], [3], [2], [6], [1, 2, 3, 4], [1, 2, 3, 4]]",
3375
- "```",
3376
- "Balanced opposing loads observe as zero in `S` and not in `U`, and the present",
3377
- "view is still distinct from the missing host",
3378
- "```",
3379
- "; .bal (V [1, [4, 4]]);",
3380
- "; [bal.coordinates (), bal.coordinates <>, (V [0, [0]]).coordinates <>, [].#0]",
3381
- "# [[0], [8], [0], ()]",
3382
- "```",
3383
- "Only nil and true are arguments. A Count, text, a list, a block or a truthy",
3384
- "Frame is refused by name, not coerced, and `observe` accepts only nil",
3385
- "```",
3386
- "; [q.coordinates 1, q.coordinates 0, q.coordinates “x”, q.coordinates [1], q.coordinates [], q.coordinates {1}, q.observe <>, q.observe 1]",
3387
- "# [$!!.unary-observation, $!!.unary-observation, $!!.unary-observation, $!!.unary-observation, $!!.unary-observation, $!!.unary-observation, $!!.unary-observation, $!!.unary-observation]",
3388
- "```",
3389
- "Rank 4 has eight directions and rank 5 sixteen, each in channel order. Here",
3390
- "positive loads 1 to 8 (or 1 to 16) sit over negative loads 10 times as large",
3391
- "```",
3392
- "; .q4 (V [0, [1, 2, 3, 4, 5, 6, 7, 8, 10, 20, 30, 40, 50, 60, 70, 80]]);",
3393
- "; [q4.coordinates (), q4.coordinates <>]",
3394
- "# [[-9, -18, -27, -36, -45, -54, -63, -72], [11, 22, 33, 44, 55, 66, 77, 88]]",
3395
- "; .q5 (V [0, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160]]);",
3396
- "; [q5.coordinates () .#, q5.coordinates <> .#, (q5.coordinates <>).0, (q5.coordinates <>).15, (q5.coordinates ()).15]",
3397
- "# [16, 16, 11, 176, -144]",
3398
- "```",
3399
- "The seven nonzero directions of rank 4 are the prospective Fano points, and a",
3400
- "line is the unsigned direction of the product of two of them. Nothing here is a",
3401
- "table: each direction below is read from the shipped product. The signs of",
3402
- "`e_001 e_010` and `e_010 e_001` differ and the direction `011` does not",
3403
- "```",
3404
- "; .p1 (V [1, [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]); .p2 (V [1, [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]); .p4 (V [1, [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]);",
3405
- "; [(p1 * p2).coordinates <>, (p2 * p1).coordinates <>, (p1 * p2).coordinates (), (p2 * p1).coordinates ()]",
3406
- "# [[0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, -1, 0, 0, 0, 0]]",
3407
- "; [(p1 * p4).coordinates <>, (p2 * p4).coordinates <>]",
3408
- "# [[0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0]]",
3409
- "```",
3410
- "Through the same projection the unsigned coordinate of a product is the XOR",
3411
- "convolution of the unsigned coordinates, and the signed associator at rank 4",
3412
- "collapses to one direction (`111`) under `<>`",
3413
- "```",
3414
- "; [(((o1 * o2) * o4).coordinates <>) = ((o1 * (o2 * o4)).coordinates <>), (((o1 * o2) * o4).coordinates ()) = ((o1 * (o2 * o4)).coordinates ()), ((o1 * o2) * o4).coordinates <>]",
3415
- "# [<>, (), [0, 0, 0, 0, 0, 0, 0, 1]]",
3416
- "```",
3417
- "## Coordinates and the native observers",
3418
- "",
3419
- "The two coordinate readings are projections of the same loads that `d.##` and",
3420
- "`d.###` already report, so the observers cannot drift apart. For every rank the",
3421
- "unsigned coordinates total the Size, `Σ U_b = d.## = Σ W`. For rank 1 and above",
3422
- "the signed coordinates total the residual, `Σ S_b = d.###`. At rank 0 the one",
3423
- "coordinate is `W_ε` in both readings, but the declared residual is 0 by design,",
3424
- "so `Σ S = W_ε` and `d.### = 0` differ there. The Count is none of these",
3425
- "```",
3426
- "; .c0 (V [4, [3]]); .c1 (V [0, [4, 1]]); .c2 (V [1, [3, 2, 1, 4]]);",
3427
- "; .c0s (c0.coordinates ()); .c1s (c1.coordinates ()); .c2s (c2.coordinates ());",
3428
- "; .tc0 (c0s.0); .tc1 (c1s.0); .tc2 ((c2s.0) + (c2s.1));",
3429
- "; [(c0.coordinates <>).##, c0.##, tc0, c0.###, c0.#]",
3430
- "# [3, 3, 3, 0, 4]",
3431
- "; [(c1.coordinates <>).##, c1.##, tc1, c1.###, c1.#]",
3432
- "# [5, 5, 3, 3, 0]",
3433
- "; [(c2.coordinates <>).##, c2.##, tc2, c2.###, c2.#]",
3434
- "# [10, 10, 0, 0, 1]",
3435
- "```",
3436
- "The same holds when the residual is negative, when loads are empty or balanced,",
3437
- "and at every higher rank, whatever the Count. Each row is the unsigned total, the",
3438
- "Size, the signed total, the residual and the Count",
3439
- "```",
3440
- "; .n2 (V [0, [0, 1, 5, 3]]); .e2 (V [7, [0, 0, 0, 0]]); .b3 (V [2, [2, 0, 5, 0, 2, 0, 5, 0]]);",
3441
- "; .n4 (V [0, [1, 2, 3, 4, 5, 6, 7, 8, 10, 20, 30, 40, 50, 60, 70, 80]]);",
3442
- "; .n5 (V [3, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160]]);",
3443
- "; .n2s (n2.coordinates ()); .tn2 ((n2s.0) + (n2s.1));",
3444
- "; .n4s (n4.coordinates ()); .tn4 ((n4s.0) + (n4s.1) + (n4s.2) + (n4s.3) + (n4s.4) + (n4s.5) + (n4s.6) + (n4s.7));",
3445
- "; .n5s (n5.coordinates ()); .tn5 ((n5s.0) + (n5s.1) + (n5s.2) + (n5s.3) + (n5s.4) + (n5s.5) + (n5s.6) + (n5s.7) + (n5s.8) + (n5s.9) + (n5s.10) + (n5s.11) + (n5s.12) + (n5s.13) + (n5s.14) + (n5s.15));",
3446
- "; [(n2.coordinates <>).##, n2.##, tn2, n2.###, n2.#]",
3447
- "# [9, 9, -7, -7, 0]",
3448
- "; [(e2.coordinates <>).##, e2.##, (e2.coordinates ()).###, e2.###, e2.#]",
3449
- "# [0, 0, 0, 0, 7]",
3450
- "; [(b3.coordinates <>).##, b3.##, (b3.coordinates ()).###, b3.###, b3.#]",
3451
- "# [14, 14, 0, 0, 2]",
3452
- "; [(n4.coordinates <>).##, n4.##, tn4, n4.###, n4.#]",
3453
- "# [396, 396, -324, -324, 0]",
3454
- "; [(n5.coordinates <>).##, n5.##, tn5, n5.###, n5.#]",
3455
- "# [1496, 1496, -1224, -1224, 3]",
3456
- "```",
3457
- "D0 is the only exception, and it is by design. Its residual is 0 though its one",
3458
- "coordinate is the load, so no rank-0 row may be fixed by changing the residual",
3459
- "```",
3460
- "; .z0 (V [0, [0]]); .p0 (V [0, [9]]);",
3461
- "; [z0.coordinates (), z0.coordinates <>, z0.##, z0.###, p0.coordinates (), p0.coordinates <>, p0.##, p0.###]",
3462
- "# [[0], [0], 0, 0, [9], [9], 9, 0]",
3463
- "```",
3464
- "",
3465
- "`x.#n` is the Denum of rung n for n from 0 to 5, and bare `x.#` is still the",
3466
- "Count. It never answers a view. A host answers its Count C, Size s and residual",
3467
- "r, so `[1, 2, 3]` has C = 3, s = 6 and r = 2. Rank 0 keeps the one load s, rank 1",
3468
- "puts (s+r)/2 on the first channel and (s−r)/2 on the second, which are the Demi's",
3469
- "left and right loads, and a higher rank puts the same two on the first channel of",
3470
- "each half. The answer has no CD multiplication: it is an ordinary Denum, and",
3471
- "`.cd ()` is the only request for the interpretation",
3472
- "```",
3473
- "; .xs [1, 2, 3];",
3474
- "; [xs.#, xs.##, xs.###, “” (xs.####)]",
3475
- "# [3, 6, 2, “Demi(3,4,2)”]",
3476
- "; [“” (xs.#0), “” (xs.#1), “” (xs.#2)]",
3477
- "# [“Denum(Arity[1], C=3, W=[6])”, “Denum(Arity[2], C=3, W=[4, 2])”, “Denum(Arity[4], C=3, W=[4, 0, 2, 0])”]",
3478
- "; [(xs.#3).loads, (xs.#4).##, (xs.#5).schema (), (xs.#5).loads .#, (xs.#5).rank ()]",
3479
- "# [[4, 0, 0, 0, 2, 0, 0, 0], 6, “Arity[32]”, 32, 5]",
3480
- "; [xs.#1.loads = xs.####.loads, xs.#1.count = xs.####.count]",
3481
- "# [<>, <>]",
3482
- "```",
3483
- "The answer is a Denum with no CD capability. It has no coordinates or product,",
3484
- "and a view is the explicit, separate request on it",
3485
- "```",
3486
- "; [xs.#2.coordinates (), xs.#2 * xs.#2, xs.#2.opp (), xs.#2.signatures ()]",
3487
- "# [$!.denum-not-cd, $!.denum-not-cd, $!.denum-not-cd, $!.denum-not-cd]",
3488
- "; [“” (xs.#2.cd ()), (xs.#2.cd ()).coordinates (), (xs.#2 + xs.#2).loads, ((xs.#2).cd ()) = ((xs.#2).cd ())]",
3489
- "# [“CD[2](C=3, W=[4, 0, 2, 0])”, [2, 0], [8, 0, 4, 0], <>]",
3490
- "```",
3491
- "A router of more than two channels keeps its channel Demi under `.####`, and",
3492
- "`.#1` is the binary projection of the same three observers, which is what the",
3493
- "fourth hash derives for a binary router. Both answers are pinned",
3494
- "```",
3495
- "; Routers <- './hc/rotor-router.hc';",
3496
- "; .RotorRouter Routers.RotorRouter;",
3497
- "; .r3 (RotorRouter [[5, 8], [6], [7]]); .r2 (RotorRouter [[5], [6]]);",
3498
- "; [r3.#, r3.##, r3.###, “” r3.####, “” r3.#1, “” r3.#2, (r3.#1).count = r3.####.count]",
3499
- "# [4, 26, 14, “Demi(4,[13, 6, 7])”, “Denum(Arity[2], C=4, W=[20, 6])”, “Denum(Arity[4], C=4, W=[20, 0, 6, 0])”, <>]",
3500
- "; [“” r2.####, “” r2.#1, (r2.#1).loads = [(r2.####).left, (r2.####).right]]",
3501
- "# [“Demi(2,5,6)”, “Denum(Arity[2], C=2, W=[5, 6])”, <>]",
3502
- "```",
3503
- "It is construction, not promotion. Promotion of an existing Demi-shaped host",
3504
- "adds nothing, because a host's applications carry no higher signature. Each",
3505
- "observer is read once, and a Frame without a Count has no Denum, as it has no",
3506
- "Demi. An empty host, zero Count and nil answer nil at every rank",
3507
- "```",
3508
- "; [[].#0, [].#1, [].#5, ().#2, 0.#3]",
3509
- "# [(), (), (), (), ()]",
3510
- "; [“”.#1, “” (“a”.#0), ({5 + 3}.#1).loads = ({5 + 3}.####).loads, ({5 + 3}.#1).count]",
3511
- "# [(), “Denum(Arity[1], C=1, W=[1])”, <>, 3]",
3512
- "```",
3513
- "Application to a zero Size still counts, so a Denum of zero loads can have a",
3514
- "positive Count, and it is present. It is not the missing host",
3515
- "```",
3516
- "; .zs [0, 0];",
3517
- "; [“” (zs.#0), “” (zs.#1), zs.#0 = (), (Denum [0, [0]]) = ()]",
3518
- "# [“Denum(Arity[1], C=2, W=[0])”, “Denum(Arity[2], C=2, W=[0, 0])”, (), ()]",
3519
- "```",
3520
- "A Denum of a shipped binary arity answers the ranked hash by the structural",
3521
- "embedding of its own state, at every Count including zero, and",
3522
- "`$!.denum-demotion` below its rank. It keeps Count and loads, starts the new",
3523
- "channels at zero and answers a Denum. This is the embedding that `v.promote`",
3524
- "applies, without the CD interpretation. Nothing the source declares can steer",
3525
- "it: a lookalike aggregate with the same fields is an ordinary host and is",
3526
- "measured like any other",
3527
- "```",
3528
- "; .dn (Denum [0, [3, 1]]);",
3529
- "; [“” (dn.#1), “” (dn.#3), (dn.#2).loads, (dn.#5).count, dn.#0]",
3530
- "# [“Denum(Arity[2], C=0, W=[3, 1])”, “Denum(Arity[8], C=0, W=[3, 0, 0, 0, 1, 0, 0, 0])”, [3, 0, 1, 0], 0, $!.denum-demotion]",
3531
- "; .fake [.count 9; .loads [3, 1]; .# {99}; .## {99}; .### {99}];",
3532
- "; [“” (fake.#1), “” (fake.#0), fake.#]",
3533
- "# [“Denum(Arity[2], C=99, W=[99, 0])”, “Denum(Arity[1], C=99, W=[99])”, 99]",
3534
- "; [xs.#6, xs.#7, xs.#99]",
3535
- "# [$!.denum-rank, $!.denum-rank, $!.denum-rank]",
3536
- "```",
3537
- "The promotion is the same at A = 1, 2, 4, 8, 16 and 32, and equal to the",
3538
- "embedding the view applies. It is a Denum at every rung, never a view",
3539
- "```",
3540
- "; .gh (Denum [7, [3, 2, 1, 4]]); .gh1 (Denum [4, [5]]);",
3541
- "; [“” (gh.#2), “” (gh.#3), (gh.#5).schema (), (gh.#5).loads.#, gh.#1, “” (gh1.#0), (gh1.#1).loads, (gh1.#2).schema ()]",
3542
- "# [“Denum(Arity[4], C=7, W=[3, 2, 1, 4])”, “Denum(Arity[8], C=7, W=[3, 2, 0, 0, 1, 4, 0, 0])”, “Arity[32]”, 32, $!.denum-demotion, “Denum(Arity[1], C=4, W=[5])”, [5, 0], “Arity[4]”]",
3543
- "; [(gh.#3).loads = ((gh.cd ()).promote 3).loads, (gh.#3).cd () = ((gh.cd ()).promote 3), gh.#3 = ((gh.cd ()).promote 3)]",
3544
- "# [<>, <>, ()]",
3545
- "```",
3546
- "A Denum of another arity has no ranked embedding. It is not padded, truncated or",
3547
- "read as `2^rank`, and it is not measured as a host from its Count and Size. The",
3548
- "answer is `$!.denum-unsupported-arity` at every rung, and the Denum is unchanged.",
3549
- "The rank check comes first, so a rank above 5 is `$!.denum-rank`",
3550
- "```",
3551
- "; .gh3 (Denum [2, [1, 2, 3]]); .gh5 (Denum [1, [1, 2, 3, 4, 5]]);",
3552
- "; [gh3.#0, gh3.#1, gh3.#2, gh3.#5, gh5.#3, t64.#2, t33.#4]",
3553
- "# [$!.denum-unsupported-arity, $!.denum-unsupported-arity, $!.denum-unsupported-arity, $!.denum-unsupported-arity, $!.denum-unsupported-arity, $!.denum-unsupported-arity, $!.denum-unsupported-arity]",
3554
- "; [gh3.#6, gh.#6, gh3.count, gh3.loads, gh3.schema (), gh3.rank ()]",
3555
- "# [$!.denum-rank, $!.denum-rank, 2, [1, 2, 3], “Arity[3]”, 1]",
3556
- "```",
3557
- "A view is never a source of the ranked hash. It is not promoted, not measured as",
3558
- "a host from its Count and Size, and not rebuilt into a Denum behind the caller's",
3559
- "back. The answer is the named refusal `$!.denum-view-source`, at every rung, and",
3560
- "the view is unchanged. Ask the Denum it views, `v.denum ()`, for the embedding",
3561
- "```",
3562
- "; .vh (gh.cd ());",
3563
- "; [vh.#0, vh.#2, vh.#5, vh.#6, (vh.denum ()).#3 .loads, vh.count, vh.loads, vh.schema ()]",
3564
- "# [$!.denum-view-source, $!.denum-view-source, $!.denum-view-source, $!.denum-rank, [3, 2, 0, 0, 1, 4, 0, 0], 7, [3, 2, 1, 4], “CD[2]”]",
3565
- "```",
3566
- "The derived hash of a view is the ordinary derived Demi of its three",
3567
- "observers, which is binary and forgets directions. `x.#n` is the Denum, and the",
3568
- "algebraic value is an observation of a view, never the return of `#n`",
3569
- "```",
3570
- "; [dn.####, “” ((V [5, [1, 2, 3, 4]]).####)]",
3571
- "# [(), “Demi(5,3,7)”]",
3572
- "```",
3573
- "`Demi` keeps its own contracts. Its `+`, `-`, `*` and `./` are not Denum or view",
3574
- "arithmetic, and a view is not a Demi",
3575
- "```",
3576
- "; .d (xs.####);",
3577
- "; [“” (d + 5), “” (d * 2), “” (d ./ 3), xs.#1 + 5]",
3578
- "# [“Demi(3,4,7)”, “Demi(3,8,4)”, “Demi(3,[2, 2, 2])”, $!!.invalid-denum]",
3579
- "```",
3580
- "## Syntax boundaries",
3581
- "",
3582
- "The ranked hash is `.#` followed directly by decimal digits. A space ends it,",
3583
- "and `.##` and `.###` are unchanged. A plain `#` still starts a comment, and the",
3584
- "lexer cases are pinned in `lib/frames/frame-name.test.ts`",
3585
- "```",
3586
- "; [xs.# 2, xs.##, xs.###, xs.##]",
3587
- "# [6, 6, 2, 6]",
2859
+ "; Denums <- './hc/denum.hc';",
2860
+ "; [(Denums.Denum [2, 5, 3]) = [5, 3].####, “” ((Denums.Denum [0, 0, 0]) 4)]",
2861
+ "# [<>, “Denum(1,4,0)”]",
3588
2862
  "",
3589
2863
  ].join("\n"),
3590
2864
  ],
@@ -3620,21 +2894,21 @@ export const HC_SOURCES = new Map([
3620
2894
  " channels, which a round-robin history fixes, and routes that history through",
3621
2895
  " a fresh router of n channels. Its Count is unchanged and its next route goes",
3622
2896
  " to channel C mod n.",
3623
- "- **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",
3624
2898
  " deals Size units. `D ./ n` keeps the Count C and the total Size S and",
3625
2899
  " canonicalizes the loads to S units dealt round-robin into n channels, so the",
3626
2900
  " first S mod n channels hold ⌈S/n⌉ and the rest ⌊S/n⌋. Its next application",
3627
2901
  " deposits into channel C mod n.",
3628
2902
  "",
3629
- "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",
3630
2904
  "the summed Size, but their channel loads differ in general: children of Sizes",
3631
- "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",
3632
2906
  "normalizes to 4 and 3. No law makes them commute, and none is claimed here.",
3633
2907
  "",
3634
2908
  "Refusals are the native ones for all three: a divisor of zero is",
3635
2909
  "`$!.division-by-zero /`, as it is for numbers, and anything but a Count is",
3636
2910
  "`$!.division-domain /`, a negative or fractional number, a decimal, text, an",
3637
- "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.",
3638
2912
  "```",
3639
2913
  "```",
3640
2914
  "## Lists",
@@ -3722,7 +2996,7 @@ export const HC_SOURCES = new Map([
3722
2996
  "",
3723
2997
  "The divisor is a positive Count. Zero is division by zero, and anything else is",
3724
2998
  "outside the domain, whatever its Size: a negative or fractional number, a",
3725
- "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",
3726
3000
  "answered as it is",
3727
3001
  "```",
3728
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]]",
@@ -3765,34 +3039,34 @@ export const HC_SOURCES = new Map([
3765
3039
  "; ([Failing, 1] ./ 2).##",
3766
3040
  "# $!.name-missing “...",
3767
3041
  "```",
3768
- "## Demi",
3042
+ "## Denum",
3769
3043
  "",
3770
- "A Demi of any arity is `Demi [C, loads]`, a Count and a nonempty list of",
3771
- "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",
3772
3046
  "instance, with its `left`, `right` and `phase`; any other arity is a channel",
3773
- "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`",
3774
3048
  "```",
3775
- "; Demis <- './hc/demi.hc';",
3776
- "; .Demi Demis.Demi;",
3777
- "; [“” (Demi [3, [5, 2]]), (Demi [3, [5, 2]]) == (Demi [3, 5, 2]), (Demi [3, [5, 2]]).left, (Demi [3, 5, 2]).loads]",
3778
- "# [“Demi(3,5,2)”, <>, 5, [5, 2]]",
3779
- "; [“” (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]",
3780
- "# [“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]",
3781
3055
  "```",
3782
3056
  "No channels, a load that is not a Count, and any other shape are refused",
3783
3057
  "```",
3784
- "; [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]]",
3785
- "# [$!!.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]",
3786
3060
  "```",
3787
- "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",
3788
3062
  "its loads, and its residual their alternating sum, `e0 − e1 + e2 − …`, the",
3789
3063
  "list residual, which for two loads is `L − R`",
3790
3064
  "```",
3791
- "; .d7 (Demi [3, 5, 2]); .q3 (d7 ./ 3);",
3065
+ "; .d7 (Denum [3, 5, 2]); .q3 (d7 ./ 3);",
3792
3066
  "; [q3.#, q3.##, q3.###, q3.count, q3.loads]",
3793
3067
  "# [3, 7, 3, 3, [3, 2, 2]]",
3794
3068
  "```",
3795
- "## Demi division redistributes Size units",
3069
+ "## Denum division redistributes Size units",
3796
3070
  "",
3797
3071
  "`D ./ n` keeps the Count and the Size and deals the Size units round-robin into",
3798
3072
  "n channels. For S = 7: into 2, 4 and 3; into 3, 3, 2 and 2; into 4, 2, 2, 2",
@@ -3800,30 +3074,30 @@ export const HC_SOURCES = new Map([
3800
3074
  "the last are empty",
3801
3075
  "```",
3802
3076
  "; [“” (d7 ./ 2), “” (d7 ./ 3), “” (d7 ./ 4), “” (d7 ./ 1), “” (d7 ./ 9)]",
3803
- "# [“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])”]",
3804
3078
  "```",
3805
- "`Demi(3,[5,2]) ./ 3` is `Demi(3,[3,2,2])`, and so is the different state",
3806
- "`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",
3807
3081
  "the same result, and the original distribution cannot be recovered",
3808
3082
  "```",
3809
- "; [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]",
3810
3084
  "# [<>, <>, (), <>, ()]",
3811
3085
  "```",
3812
3086
  "It is idempotent, and dividing again renormalizes from the same Count and Size,",
3813
3087
  "so the earlier division leaves no trace",
3814
3088
  "```",
3815
3089
  "; [(q3 ./ 3) = q3, (q3 ./ 2) = (d7 ./ 2), ((d7 ./ 4) ./ 3) = q3, “” (q3 ./ 2), ((q3 ./ 2) ./ 3) = q3]",
3816
- "# [<>, <>, <>, “Demi(3,4,3)”, <>]",
3090
+ "# [<>, <>, <>, “Denum(3,4,3)”, <>]",
3817
3091
  "```",
3818
3092
  "Zero Size, zero Count, one channel, and more channels than Size or Count",
3819
3093
  "```",
3820
- "; [“” ((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)]",
3821
- "# [“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)”]",
3822
3096
  "```",
3823
3097
  "The divisor is a channel Count, refused as a list refuses it, never coerced to",
3824
3098
  "its Size",
3825
3099
  "```",
3826
- "; [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])]",
3827
3101
  "# [$!.division-by-zero /, $!.division-domain /, $!.division-domain /, $!.division-domain /, $!.division-domain /, $!.division-domain /, $!.division-domain /]",
3828
3102
  "```",
3829
3103
  "## Applying after division",
@@ -3833,23 +3107,23 @@ export const HC_SOURCES = new Map([
3833
3107
  "channels 0, 1, 2, 0 in turn",
3834
3108
  "```",
3835
3109
  "; [“” (q3 10), “” ((q3 10) 1), “” (((q3 10) 1) 1), “” ((((q3 10) 1) 1) 1)]",
3836
- "# [“Demi(4,[13, 2, 2])”, “Demi(5,[13, 3, 2])”, “Demi(6,[13, 3, 3])”, “Demi(7,[14, 3, 3])”]",
3837
- "; [“” ((Demi [0, [0, 0, 0]]) 4), “” (((Demi [0, [0, 0, 0]]) 4) 0), “” ((((Demi [0, [0, 0, 0]]) 4) 0) 6)]",
3838
- "# [“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])”]",
3839
3113
  "```",
3840
3114
  "A reduce applies it the same way, and through a mutable name it writes in",
3841
- "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",
3842
3116
  "parity",
3843
3117
  "```",
3844
- "; “” ([5, 2, 7, 1, 0] | (Demi [0, [0, 0, 0]]))",
3845
- "# “Demi(5,[6, 2, 7])”",
3846
- "; .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]]);",
3847
3121
  "; m_ 5;",
3848
3122
  "; m_ 6;",
3849
3123
  "; [“” m_, “” ((d7 ./ 1) 4), “” ((d7 ./ 2) 4), “” (d7 4)]",
3850
- "# [“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)”]",
3851
3125
  "```",
3852
- "## Demi laws",
3126
+ "## Denum laws",
3853
3127
  "",
3854
3128
  "For every Count 0 to 3, every pair of loads 0 to 4 (100 states) and every n",
3855
3129
  "from 1 to 4: the Count and Size are kept, there are n loads, they are the",
@@ -3857,44 +3131,44 @@ export const HC_SOURCES = new Map([
3857
3131
  "m from 1 to 4 dividing by n then m is dividing by m",
3858
3132
  "```",
3859
3133
  "; .cs [0, 1, 2, 3]; .ls [0, 1, 2, 3, 4]; .ns [1, 2, 3, 4];",
3860
- "; .states (cs &| {.c _; ls &| {.l _; ls & {Demi [c, l, _]}}});",
3134
+ "; .states (cs &| {.c _; ls &| {.l _; ls & {Denum [c, l, _]}}});",
3861
3135
  "; .law {.k _; ns &| {.n _; .q (k ./ n); [q.# = k.#, q.## = k.##, q.loads.# = n, q.loads = (((k.## [1]) ./ n).channels & {_.#}), (q ./ n) = q]}};",
3862
3136
  "; .renorm {.k _; ns &| {.n _; ns & {.m _; ((k ./ n) ./ m) = (k ./ m)}}};",
3863
3137
  "; .checks ((states &| law) | (states &| renorm));",
3864
3138
  "; [states.#, checks.#, checks = (checks & {<>})]",
3865
3139
  "# [100, 3600, <>]",
3866
3140
  "```",
3867
- "## Channel Demi operations",
3141
+ "## Channel Denum operations",
3868
3142
  "",
3869
- "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",
3870
3144
  "of the same arity, Count zero included. A record that only spells the fields is",
3871
- "not one, and forged observers give the ordinary derived binary Demi",
3145
+ "not one, and forged observers give the ordinary derived binary Denum",
3872
3146
  "```",
3873
- "; [(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]])]",
3874
3148
  "# [<>, (), <>, <>]",
3875
3149
  "; [[.count 3; .loads [3, 2, 2]].####, “” ([.count 3; .loads [3, 2, 2]; .# {3}; .## {7}; .### {3}].####)]",
3876
- "# [(), “Demi(3,5,2)”]",
3150
+ "# [(), “Denum(3,5,2)”]",
3877
3151
  "```",
3878
3152
  "`*` and `scale_` scale every load and keep the Count; the ratios read Size and",
3879
3153
  "residual over the Count, nil at Count zero",
3880
3154
  "```",
3881
- "; [“” (q3 * 2), “” (q3.scale_ 3), q3.size-ratio (), q3.residual-ratio (), (Demi [0, [3, 2, 2]]).size-ratio ()]",
3882
- "# [“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, ()]",
3883
3157
  "```",
3884
3158
  "`+` and `-` follow the residual's signs. The residual adds the loads at even",
3885
3159
  "indices and subtracts those at odd ones, so `-` deposits `x.##` on the first",
3886
3160
  "even load, load 0, and raises the residual, and `+` deposits on the first odd",
3887
- "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",
3888
3162
  "right. Both keep the Count, and both are `deposit-left_` and `deposit-right_`",
3889
3163
  "by the operand's Size. One load has no odd index, so there `+` is",
3890
3164
  "`$!!.invalid-arity`",
3891
3165
  "```",
3892
3166
  "; [“” (q3 + 1), “” (q3 - 1), q3.###, (q3 + 1).###, (q3 - 1).###, (q3 + 1).#]",
3893
- "# [“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]",
3894
3168
  "; [“” ((d7 ./ 4) + 1), “” ((d7 ./ 4) - 2.5), (d7 ./ 1) + 1, “” ((d7 ./ 1) - 1), “” (d7 + 1), “” (d7 - 1)]",
3895
- "# [“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)”]",
3896
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]",
3897
- "# [<>, <>, $!.name-missing “..., $!!.invalid-demi, $!!.invalid-demi, “Demi(3,[3, 2, 2])”]",
3171
+ "# [<>, <>, $!.name-missing “..., $!!.invalid-denum, $!!.invalid-denum, “Denum(3,[3, 2, 2])”]",
3898
3172
  "```",
3899
3173
  "## RotorRouter",
3900
3174
  "",
@@ -3988,23 +3262,23 @@ export const HC_SOURCES = new Map([
3988
3262
  "```",
3989
3263
  "The divisor is refused as for a list",
3990
3264
  "```",
3991
- "; [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”]",
3992
3266
  "# [$!.division-by-zero /, $!.division-domain /, $!.division-domain /, $!.division-domain /, $!.division-domain /, $!.division-domain /]",
3993
3267
  "```",
3994
3268
  "## A router's observers and fourth hash",
3995
3269
  "",
3996
3270
  "A router of any arity declares its Count C, its Size, the sum of its channel",
3997
- "loads, and its residual, their alternating sum, as a channel Demi does. Its",
3998
- "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",
3999
3273
  "two is recognized intrinsically, as an instance of the shipped class, and",
4000
- "answers `Demi [C, loads]`, one load per channel, so it routes to channel",
4001
- "C mod k as its Demi deposits there. The binary router answers the binary Demi",
4002
- "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",
4003
3277
  "```",
4004
- "; [t3.#, t3.##, t3.###, “” t3.####, t3.#### = (Demi [7, [14, 6, 22]]), t3.####.## = t3.##, t3.####.### = t3.###]",
4005
- "# [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])”, <>, <>, <>]",
4006
3280
  "; [“” (r7.####), ([] ./ 3).####, (RotorRouter [[], [], []]).####, “” ((([] ./ 3) 5).####)]",
4007
- "# [“Demi(7,24,18)”, (), (), “Demi(1,[5, 0, 0])”]",
3281
+ "# [“Denum(7,24,18)”, (), (), “Denum(1,[5, 0, 0])”]",
4008
3282
  "```",
4009
3283
  "So the projection law `(r y).#### = r.#### y` holds for every arity: routing y",
4010
3284
  "to channel C mod k and observing is depositing `y.##` there",
@@ -4013,7 +3287,7 @@ export const HC_SOURCES = new Map([
4013
3287
  "; [1, 2, 3, 4, 5] & {.r (nine ./ _); ((r 10).####) = ((r.####) 10)}",
4014
3288
  "# [<>, <>, <>, <>, <>]",
4015
3289
  "; [“” ((t3 10).####), “” ((nine ./ 1).####), “” ((nine ./ 4).####)]",
4016
- "# [“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])”]",
4017
3291
  "```",
4018
3292
  "Recognition reads nothing the router computes: a record that only spells",
4019
3293
  "`channels` is not a router, and a failed child Size is answered as it is",
@@ -4025,12 +3299,12 @@ export const HC_SOURCES = new Map([
4025
3299
  "",
4026
3300
  "Whole-Frame division and Size-unit division agree on the total and differ on",
4027
3301
  "the channels. Children of Sizes 5 and 2 dealt into two channels load them 5",
4028
- "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",
4029
3303
  "and 3. They are different states with the same Size, and neither is wrong",
4030
3304
  "```",
4031
3305
  "; .two [5, 2];",
4032
3306
  "; [loads (two ./ 2).channels, ((two | r0) ./ 2).channels & {load _}, “” (two.#### ./ 2), ((two | r0) ./ 2).#### = (two.#### ./ 2), ((two | r0) ./ 2).####.## = (two.#### ./ 2).##]",
4033
- "# [[5, 2], [5, 2], “Demi(2,4,3)”, (), <>]",
3307
+ "# [[5, 2], [5, 2], “Denum(2,4,3)”, (), <>]",
4034
3308
  "```",
4035
3309
  "They agree when every child has Size one, since then each Frame is one Size",
4036
3310
  "unit. With other Sizes they need not",
@@ -4247,41 +3521,41 @@ export const HC_SOURCES = new Map([
4247
3521
  "; [.tag 1;] * [[]]",
4248
3522
  "# $!.star-metadata *",
4249
3523
  "```",
4250
- "The fourth observer derives a Demi from Count, Size and residual.",
4251
- "A zero Count or absent residual gives no Demi; errors propagate. A schema used",
4252
- "as an explicit element contributes Size normally, even though its own Demi is nil.",
4253
- "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",
4254
3528
  "application Count (007.25c), and its phase is derived from the parity of that",
4255
3529
  "Count: 2 for even and 1 for odd. The derivation therefore reconstructs its data",
4256
- "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",
4257
3531
  "Count zero, which the observers cannot tell from an empty host, declares its own",
4258
- "fourth hash (`hc/demi.hc`).",
4259
- "A present Demi is an instance of the HC class in `hc/demi.hc` (011.20), and",
4260
- "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",
4261
3535
  "and adds one to the Count, so for a nonempty Figure host X, (X Y).#### is",
4262
- "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,",
4263
3537
  "because [].#### is nil. Scaling is the method `scale_`, the shadow of Star:",
4264
3538
  "(X * Y).#### is X.####.scale_ (Y.##) for a nonempty host. Count is a terminal",
4265
3539
  "quantity: positive Counts agree with pure Figures of that terminal Size, but 0",
4266
- "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,",
4267
3541
  "including [0].####.",
4268
3542
  "```",
4269
3543
  "; [[].####, 0.####, “” “hello”.####, <2,3,5>.####]",
4270
- "# [(), (), “Demi(5,3,2)”, ()]",
3544
+ "# [(), (), “Denum(5,3,2)”, ()]",
4271
3545
  "; [(10 - 5).#### = 5.####, (0 - 5).#### = 5.####, (5.0).#### = 5.####, “hello”.#### = 5.####]",
4272
3546
  "# [<>, <>, <>, <>]",
4273
3547
  "; [<>.#, <>.##, <>.###, ().##]",
4274
3548
  "# [0, 1, 0, 1]",
4275
3549
  "; [1, 2, 3, 7] & {“” _.####}",
4276
- "# [“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)”]",
4277
3551
  "; [[0], [“hello”], [<2,3,5>,2], {5 + 3}] & {“” _.####}",
4278
- "# [“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)”]",
4279
3553
  "; [“” ([[],[]].#### 3), “” (7.####.scale_ 2), ([[],[]] 3).#### = ([[],[]].#### 3)]",
4280
- "# [“Demi(3,4,1)”, “Demi(7,8,6)”, <>]",
3554
+ "# [“Denum(3,4,1)”, “Denum(7,8,6)”, <>]",
4281
3555
  "```",
4282
3556
  "A RotorRouter, the class in `hc/rotor-router.hc` (011.21), keeps the routed",
4283
3557
  "Figures themselves in two ordered channels and declares the observers that make",
4284
- "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",
4285
3559
  "router sends the even positions left and the odd ones right, and that router's",
4286
3560
  "fourth hash is the Figure's.",
4287
3561
  "```",
@@ -4916,11 +4190,11 @@ export const HC_SOURCES = new Map([
4916
4190
  "A RotorRouter is a two-channel router that keeps what it routes. Its state is",
4917
4191
  "two ordered arrays, left and right, of the Frames routed into them, and nothing",
4918
4192
  "else. Applying a router to a Frame appends that Frame, the same Frame, to the",
4919
- "channel its Count selects. A Demi follows the same alternation by Size alone; a",
4920
- "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",
4921
4195
  "everything that shadow forgets: which Frames, in what order, and which channel.",
4922
4196
  "",
4923
- "`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",
4924
4198
  "constructor closure answering a fresh aggregate whose fields are its state and",
4925
4199
  "whose methods are the class. Import it with",
4926
4200
  "`Routers <- './hc/rotor-router.hc'`, then `Routers.RotorRouter [[], []]`.",
@@ -4928,17 +4202,17 @@ export const HC_SOURCES = new Map([
4928
4202
  "**State (007.25e).** `RotorRouter [left, right]` takes two arrays, the two",
4929
4203
  "ordered channels. There is no phase argument: the router's Count is",
4930
4204
  "`C = left.# + right.#`, the children it holds, and its phase is read from the",
4931
- "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",
4932
4206
  "odd (right next). Earlier versions took `RotorRouter [phase, left, right]`, a",
4933
4207
  "free phase beside the channels; that form is removed, with no alias, so the",
4934
- "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.",
4935
4209
  "",
4936
4210
  "**Admissibility.** Routing from empty channels starts left and alternates, so",
4937
4211
  "every routed history has `left.# = right.#` (C even) or",
4938
4212
  "`left.# = right.# + 1` (C odd), and conversely every such pair is the one",
4939
4213
  "history that sent `left.0`, `right.0`, `left.1`, … in turn. The constructor",
4940
4214
  "admits exactly those pairs and refuses every other pair with",
4941
- "`$!!.invalid-router`, a named error, as `Demi` refuses with `$!!.invalid-demi`:",
4215
+ "`$!!.invalid-router`, a named error, as `Denum` refuses with `$!!.invalid-denum`:",
4942
4216
  "`RotorRouter [[A], [B, C]]` and `RotorRouter [[A, B], []]` are not histories,",
4943
4217
  "and no history or offset is invented for them. Routing keeps the invariant, so",
4944
4218
  "every router a program can hold satisfies it. A channel is its elements: an",
@@ -4958,30 +4232,30 @@ export const HC_SOURCES = new Map([
4958
4232
  "mutating method, `apply_`, so through a name it is a functional update that",
4959
4233
  "leaves the router as it was, and through a mutable name it writes the router in",
4960
4234
  "place. Routing nil routes nothing and leaves the router as it was, as applying a",
4961
- "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",
4962
4236
  "expression that applies the router, so it is never routed.",
4963
4237
  "",
4964
- "**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",
4965
4239
  "(007.25c): its Count C, its total load L+R and the signed difference L−R, where",
4966
4240
  "each load is the sum of the Sizes of the children routed into that channel. So",
4967
- "`router.####` derives the router's Demi as it derives any Frame's,",
4968
- "`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",
4969
4243
  "the router's phase, because both are the parity of the same C. An empty channel",
4970
4244
  "has load 0, the empty sum; a nonempty channel's load is its native Size, which",
4971
4245
  "is that sum. Observation is where children are measured, so it is where their",
4972
4246
  "failures show, and declared observers run only when the router is observed:",
4973
- "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",
4974
4248
  "Frames were routed and their order, so distinct routers can share one.",
4975
4249
  "",
4976
4250
  "**The projection law.** For every router r whose fourth hash exists, that is",
4977
4251
  "every router with C ≥ 1 whose children have Sizes, and every Frame y,",
4978
4252
  "`(r y).#### = (r.####) y`: routing y into the channel the parity of C selects",
4979
4253
  "and then observing adds `y.##` to that channel's load and one to C, which is",
4980
- "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",
4981
4255
  "the boundary: it has routed nothing, so like the empty host `[]` its Count is",
4982
- "zero and `.####` is nil, not a Demi conjured to make the equation look true.",
4983
- "There the law reads through the zero-Count lifting the Demi class names,",
4984
- "`(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`.",
4985
4259
  "",
4986
4260
  "**Text.** A router prints as its fields and methods, and as text reads",
4987
4261
  "`RotorRouter([…],[…])`, each channel as its spelling, the constructor's own",
@@ -5001,12 +4275,12 @@ export const HC_SOURCES = new Map([
5001
4275
  "list of channels with the Frame added to that one, so a route costs one pass",
5002
4276
  "over the k channels and never replays the history (PR #482 review).",
5003
4277
  "Its Size is the sum of its channel loads and its residual their alternating",
5004
- "sum, as a channel Demi's are. Its fourth hash is the channel Demi of its",
5005
- "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",
5006
4280
  "instance of this class with other than two channels intrinsically, as it",
5007
- "recognizes a Demi, because the binary Demi the observers derive follows",
4281
+ "recognizes a Denum, because the binary Denum the observers derive follows",
5008
4282
  "parity and not C mod k. So the projection law `(r y).#### = r.#### y` holds",
5009
- "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, …])`.",
5010
4284
  "",
5011
4285
  "`router ./ n`, also spelled `router / n`, re-deals the Frames it holds: it",
5012
4286
  "reconstructs the order they were routed in from its channels, which their",
@@ -5227,7 +4501,7 @@ export const HC_SOURCES = new Map([
5227
4501
  "; (r0 Cyclic).####",
5228
4502
  "# $!.cyclic-observation .##",
5229
4503
  "; “” ((r0 Counted).####)",
5230
- "# “Demi(1,5,0)”",
4504
+ "# “Denum(1,5,0)”",
5231
4505
  "; counter_.n",
5232
4506
  "# 2",
5233
4507
  "```",
@@ -5248,14 +4522,14 @@ export const HC_SOURCES = new Map([
5248
4522
  "## Empty and zero",
5249
4523
  "",
5250
4524
  "The initial router has routed no children, so its Count is zero, and like the",
5251
- "empty host it has no Demi. Its Size and residual still read zero, and it is a",
5252
- "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",
5253
4527
  "constructed as such, which routing from the router reaches after one route",
5254
4528
  "```",
5255
4529
  "; [r0.#, r0.##, r0.###, r0.phase, r0.####, [].####]",
5256
4530
  "# [0, 0, 0, 2, (), ()]",
5257
- "; Demis <- './hc/demi.hc';",
5258
- "; [((r0 0).####) = ((Demis.Demi [0, 0, 0]) 0), ((r0 []).####) = ([] []).####]",
4531
+ "; Denums <- './hc/denum.hc';",
4532
+ "; [((r0 0).####) = ((Denums.Denum [0, 0, 0]) 0), ((r0 []).####) = ([] []).####]",
5259
4533
  "# [<>, <>]",
5260
4534
  "```",
5261
4535
  "A Frame of Size zero takes a slot and flips the phase, and an empty array",
@@ -5263,11 +4537,11 @@ export const HC_SOURCES = new Map([
5263
4537
  "```",
5264
4538
  "; .z (r0 0);",
5265
4539
  "; [z.phase, z.left, z.#, “” (z.####)]",
5266
- "# [1, [0], 1, “Demi(1,0,0)”]",
4540
+ "# [1, [0], 1, “Denum(1,0,0)”]",
5267
4541
  "; [“” ((r0 []).####), “” (((r0 []) []).####), “” ((((r0 0) 0) 0).####)]",
5268
- "# [“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)”]",
5269
4543
  "```",
5270
- "## The router's Demi",
4544
+ "## The router's Denum",
5271
4545
  "",
5272
4546
  "Each load is the sum of its channel's child Sizes, as exact Counts, over text,",
5273
4547
  "numbers, nested arrays, groups, closures, all, and a Frame routed twice, which",
@@ -5278,17 +4552,17 @@ export const HC_SOURCES = new Map([
5278
4552
  "; [mix.left, mix.right]",
5279
4553
  "# [[“hello”, [[1, 2], [3]], [[], []], { 5 + 3 }], [7, (4, 5), [[], []], <>]]",
5280
4554
  "; [mix.left & {_.##}, mix.right & {_.##}, “” (mix.####)]",
5281
- "# [[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)”]",
5282
4556
  "; “” (((r0 123456789012345678901234567890) 987654321098765432109876543210).####)",
5283
- "# “Demi(2,123456789012345678901234567890,987654321098765432109876543210)”",
4557
+ "# “Denum(2,123456789012345678901234567890,987654321098765432109876543210)”",
5284
4558
  "```",
5285
- "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",
5286
4560
  "router's phase, for every Count from 1 to 6 and for preloads",
5287
4561
  "```",
5288
4562
  "; .sh (steps & {_.####});",
5289
4563
  "; [sh & {_ = ()}, sh & {_.#}]",
5290
4564
  "# [[<>, (), (), (), (), (), ()], [(), 1, 2, 3, 4, 5, 6]]",
5291
- "; [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])]",
5292
4566
  "# [[<>, <>, <>, <>, <>, <>], <>]",
5293
4567
  "```",
5294
4568
  "## Observing commutes with routing",
@@ -5305,7 +4579,7 @@ export const HC_SOURCES = new Map([
5305
4579
  "# [[5, [1, 2]], [“ab”], 1, <>]",
5306
4580
  "```",
5307
4581
  "For every router whose fourth hash exists, routing Y then observing is applying",
5308
- "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,",
5309
4583
  "Count included. The law holds for routers built by routing and for admissible",
5310
4584
  "preloads alike, in both phases, and for a zero-Size child",
5311
4585
  "```",
@@ -5315,38 +4589,38 @@ export const HC_SOURCES = new Map([
5315
4589
  "; [((p1 Y).####) = ((p1.####) Y), ((p2 {5 + 3}).####) = ((p2.####) {5 + 3}), ((p1 0).####) = ((p1.####) 0)]",
5316
4590
  "# [<>, <>, <>]",
5317
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]]];",
5318
- "; [pre & {((_ Y).####) = ((_.####) Y)}, pre & {((_ 0).####) = ((_.####) 0)}, pre & {(_ Y).phase = ((_.####) Y).phase}]",
4592
+ "; [pre & {((_ Y).####) = ((_.####) Y)}, pre & {((_ 0).####) = ((_.####) 0)}, pre & {(_ Y).phase = (((_.####) Y).phase ())}]",
5319
4593
  "# [[<>, <>, <>, <>, <>], [<>, <>, <>, <>, <>], [<>, <>, <>, <>, <>]]",
5320
4594
  "```",
5321
4595
  "The same holds at every step of a walk, Count 1 to 6, and a router can never",
5322
- "route to the channel its Demi does not deposit into",
4596
+ "route to the channel its Denum does not deposit into",
5323
4597
  "```",
5324
4598
  "; steps &| {.k _; (k.# .> 0) ? {[((k Y).####) = ((k.####) Y)]} : {[]}}",
5325
4599
  "# [<>, <>, <>, <>, <>, <>]",
5326
- "; 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 ()))]]} : {[]}}",
5327
4601
  "# [[0, 0], [1, 4], [0, 0], [1, 4], [0, 0], [1, 4]]",
5328
4602
  "```",
5329
4603
  "A failed Size is the answer on both sides: the router routes the Frame and its",
5330
- "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",
5331
4605
  "```",
5332
4606
  "; [((p1 Failing).####), ((p1.####) Failing)]",
5333
4607
  "# [$!.name-missing “..., $!.name-missing “...]",
5334
4608
  "```",
5335
4609
  "The empty host is the boundary. `[].####` is nil, so `X.####` fails the first",
5336
4610
  "equation when X is empty, and so does the initial router, which has routed",
5337
- "nothing and so has Count zero: it has no Demi, and none is faked. The law there",
5338
- "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",
5339
4613
  "one route the equation holds again",
5340
4614
  "```",
5341
- "; [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)]",
5342
4616
  "# [(), <>, <>, <>, <>, <>]",
5343
4617
  "```",
5344
- "## The Demi forgets",
4618
+ "## The Denum forgets",
5345
4619
  "",
5346
- "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",
5347
4621
  "sums, not which Frames were routed, nor their order, nor how the load was split",
5348
4622
  "among them. It does keep how many were routed, so a router with fewer children",
5349
- "and the same loads has a different Demi",
4623
+ "and the same loads has a different Denum",
5350
4624
  "```",
5351
4625
  "; .s1 (RotorRouter [[2, 3], [1]]); .s2 (RotorRouter [[5], [1]]); .s3 (RotorRouter [[3, 2], [1]]); .s4 (RotorRouter [[1, 4], [1]]);",
5352
4626
  "; [s1 = s2, s1 = s3, (s1.####) = (s3.####), (s1.####) = (s4.####), (s1.####) = (s2.####), s1.#, s2.#, s1.##, s2.##]",
@@ -5354,10 +4628,10 @@ export const HC_SOURCES = new Map([
5354
4628
  "```",
5355
4629
  "## Observers, declared",
5356
4630
  "",
5357
- "A router's Count, Size and residual are its Demi's, and its fourth hash is a",
5358
- "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",
5359
4633
  "are fields, not elements, so iterating a router yields nothing. A router",
5360
- "inside an aggregate contributes its declared Size, as a Demi does",
4634
+ "inside an aggregate contributes its declared Size, as a Denum does",
5361
4635
  "```",
5362
4636
  "; [[r3.#, r3.##, r3.###] = [r3.####.#, r3.####.##, r3.####.###], r3.#### = r3, r3.####.#### = r3.####]",
5363
4637
  "# [<>, (), <>]",