code wiki / (root) / nx_worldpipe_erode_gate.nx
`nx_worldpipe_erode_gate.nx` source

↩ module page · 408 lines · 21820 B
1// nx_worldpipe_erode_gate.nx -- GATE for PG20: erosion as a PROCESS on the worldpipe heightfield.
2//
3// WHAT THIS GATE IS FOR. nx_water_erosion.nx shipped all seven Mei 2007 stages and was gate-proven by
4// nx_water_erosion_gate (PG18) -- and the ranker measured it LIB-UNIMPORTED: the only importer in the
5// whole estate was its own gate (nx_absent, corpus_complete=1 over 23,201 files). Meanwhile THREE of
6// the estate's own census gates carried the identical residual in their prose -- "erosion is a scalar
7// not a process". PG20 is the composition that closes both, and this gate is its referee.
8//
9// THE REFEREE, AND WHY IT IS THIS ONE. procgen.plan names two published geomorphology bands: the
10// hypsometric curve and DRAINAGE DENSITY. Only one of them is applicable here, and that is decidable
11// BEFORE any measurement is taken rather than after:
12//   * drainage density is kilometres of channel per square kilometre. Our world has no metric scale
13//     binding of any kind, so a published km/km2 band quoted against it would be a number about a
14//     subject we do not have -- the subject-mismatch defect wearing a citation. It is DECLARED OPEN
15//     here by name, not half-measured.
16//   * Strahler's hypsometric integral, (mean - min) / (max - min), is DIMENSIONLESS. It is exactly
17//     the right referee for an unscaled procedural world, and it is non-gameable for a reason that is
18//     provable rather than hoped: it is INVARIANT under h -> a*h + b for a > 0. An implementation
19//     that lowers the terrain, or flattens it, or shifts it, moves the referee NOWHERE. Two teeth
20//     below prove that invariance on real data instead of asserting it in a comment.
21//
22// WHAT IS DELIBERATELY *NOT* ASSERTED, AND WHY. The DIRECTION the integral moves under one erosion run
23// is NOT asserted. Strahler's association of a falling integral with landscape maturity is an
24// empirical statement about long-run denudation, not a per-run theorem of the pipe model: a run that
25// incises a deep channel lowers the minimum faster than the mean and can raise the integral honestly.
26// Baking a direction in would be encoding a relationship this author cannot derive. Both values are
27// MEASURED and PRINTED; the direction is reported, exactly as the
28// sibling gate reports semi-Lagrangian transport rather than asserting a conservation it does not have.
29//
30// THE ANTI-VACUITY TOOTH THAT NOISE CANNOT PASS: erosion must remove material from steep ground and
31// leave or add it on flat ground, because the pipe model's sediment capacity is proportional to local
32// slope times velocity. So the mean height delta over cells STEEPER than the terrain's own mean slope
33// must be strictly more negative than over cells flatter than it. A uniform offset scores zero on both
34// sides; added noise is uncorrelated with slope and scores the same on both sides; only material
35// actually moved downhill separates them. The divider is the terrain's OWN mean slope, measured at
36// runtime -- there is no threshold to pick.
37//
38// FIXTURE POLICY: the synthetic teeth run on caller-owned mmap, and the integration teeth run against
39// the real worldpipe surface at a fixed seed. Nothing here writes a production plane.
40
41import "nx_syscalls.nx"
42import "nx_tier.nx"
43import "nx_gate_verdict.nx"
44import "nx_worldpipe.nx"
45
46// Synthetic fixture edge, adopted from the sibling nx_water_erosion_gate's derivation (16x16 = 256
47// cells: big enough that interior cells have four neighbours and both slope halves are populated,
48// small enough to stay well inside a beat).
49const WG_GN: i64 = 16
50// Staircase step for the synthetic grid, in world units. The talus threshold below is DERIVED from it.
51const WG_STEP: i64 = 40
52// Seed for the real-terrain leg. Any fixed seed makes the run reproducible; the teeth below assert
53// properties that hold for a surface with relief, not properties of this particular seed.
54const WG_SEED: i64 = 20260825
55// Ticks for the real-terrain bake. Reported with every measurement; the teeth bind to whether material
56// MOVED, never to how much, so this is an exercise budget and not a tuned constant.
57const WG_TICKS: i64 = 8
58// THE PUBLISHED MATURITY BANDS ARE DELIBERATELY NOT QUOTED HERE. They were sought and the primary is
59// unreachable from this lane: pubs.geoscienceworld.org answered HTTP 403 with Cf-Mitigated: challenge
60// on 2026-08-25, which the estate's own refs law names as a bot wall that SAVES as a plausible body --
61// a mirror worse than none. Printing band edges from memory would be an unsourced number wearing a
62// citation, the exact defect the gap-ledger lane refused to commit over Epic's content-free JS shell.
63// The integral needs no band to BE a referee: its INVARIANCE is what makes it one, and that is proven
64// above on real data. The band stays OWED, by name, in the verdict note.
65
66func wg_abs(v: i64) -> i64 { if v < 0 { return 0-v } return v }
67
68// The x-major index convention nx_pets_voxel3d.vp_erode_pass uses, written out INDEPENDENTLY here so
69// the claim "index order does not change the result" is MEASURED rather than left as a comment.
70// Voxel law: shed exactly one unit per overhung neighbour.
71func wg_ref_vp_pass(hg: *i64, gn: i64, talus: i64, delta: *i64) -> i64 {
  var i: i64 = 0
  while i < gn*gn { delta[i] = 0; i = i + 1 }
  var z: i64 = 0
  while z < gn {
      var x: i64 = 0
      while x < gn {
          let h: i64 = hg[x*gn + z]
          if x > 0      { if h - hg[(x-1)*gn+z] > talus { delta[x*gn+z] = delta[x*gn+z] - 1; delta[(x-1)*gn+z] = delta[(x-1)*gn+z] + 1 } }
          if x < gn - 1 { if h - hg[(x+1)*gn+z] > talus { delta[x*gn+z] = delta[x*gn+z] - 1; delta[(x+1)*gn+z] = delta[(x+1)*gn+z] + 1 } }
          if z > 0      { if h - hg[x*gn+(z-1)] > talus { delta[x*gn+z] = delta[x*gn+z] - 1; delta[x*gn+(z-1)] = delta[x*gn+(z-1)] + 1 } }
          if z < gn - 1 { if h - hg[x*gn+(z+1)] > talus { delta[x*gn+z] = delta[x*gn+z] - 1; delta[x*gn+(z+1)] = delta[x*gn+(z+1)] + 1 } }
          x = x + 1
      }
      z = z + 1
  }
  var j: i64 = 0
  while j < gn*gn { hg[j] = hg[j] + delta[j]; j = j + 1 }
  return 0
90}
91
92func wg_sum(g: *i64, n: i64) -> i64 {
  var s: i64 = 0
  var i: i64 = 0
  while i < n { s = s + g[i]; i = i + 1 }
  return s
97}
98
99// A rough staircase-plus-bump surface: monotone in one axis so the talus law has real overhangs, with
100// a raised block so the field is not separable and the hypsometric integral is not degenerate.
101func wg_seed_grid(g: *i64, gn: i64) -> i64 {
  var y: i64 = 0
  while y < gn {
      var x: i64 = 0
      while x < gn {
          var v: i64 = (gn - 1 - x) * WG_STEP + y * (WG_STEP / 4)
          if x > gn/3 { if x < gn/2 { if y > gn/3 { if y < gn/2 { v = v + WG_STEP * 3 } } } }
          g[y*gn + x] = v
          x = x + 1
      }
      y = y + 1
  }
  return gn*gn
114}
115
116func wg_copy(dst: *i64, src: *i64, n: i64) -> i64 {
  var i: i64 = 0
  while i < n { dst[i] = src[i]; i = i + 1 }
  return n
120}
121
122func wg_diffcount(a: *i64, b: *i64, n: i64) -> i64 {
  var d: i64 = 0
  var i: i64 = 0
  while i < n { if a[i] != b[i] { d = d + 1 } i = i + 1 }
  return d
127}
128
129// Local slope proxy on a square grid: the largest absolute height difference to a 4-neighbour.
130func wg_slope_at(g: *i64, gn: i64, x: i64, y: i64) -> i64 {
  let k: i64 = y*gn + x
  let h: i64 = g[k]
  var m: i64 = 0
  if x > 0      { let d: i64 = wg_abs(h - g[k-1]);  if d > m { m = d } }
  if x < gn - 1 { let d: i64 = wg_abs(h - g[k+1]);  if d > m { m = d } }
  if y > 0      { let d: i64 = wg_abs(h - g[k-gn]); if d > m { m = d } }
  if y < gn - 1 { let d: i64 = wg_abs(h - g[k+gn]); if d > m { m = d } }
  return m
139}
140
141func main() -> i64 {
  let c: *i64 = gv_ctr()
  gv_head("NX-WORLDPIPE-ERODE-GATE -- PG20: the gate-proven Mei 2007 pipeline COMPOSED onto the worldpipe heightfield" as *u8)
144
  // =========================================================================================
  // PART 1 -- the talus law, in the lib that now owns it
  // =========================================================================================
  let fn2: i64 = WG_GN * WG_GN
  let ga: *i64 = sys_mmap(te_grid_bytes(WG_GN)) as *i64
  let gb: *i64 = sys_mmap(te_grid_bytes(WG_GN)) as *i64
  let d1: *i64 = sys_mmap(te_grid_bytes(WG_GN)) as *i64
  let d2: *i64 = sys_mmap(te_grid_bytes(WG_GN)) as *i64
  wg_seed_grid(ga, WG_GN)
  wg_copy(gb, ga, fn2)
  gv_subjects("cells-in-synthetic-fixture" as *u8, fn2, c)
156
  // talus DERIVED from the fixture's own staircase step: shedding must be able to fire, and it must
  // not fire everywhere, so half a step is the one value the fixture itself supplies.
  let talus: i64 = WG_STEP / 2
  let sum_before: i64 = wg_sum(ga, fn2)
  let moved: i64 = te_thermal_pass(ga, WG_GN, talus, 0, d1)
  let sum_after: i64 = wg_sum(ga, fn2)
  gv_puts("  thermal talus=" as *u8); gv_num(talus)
  gv_puts(" sum_before=" as *u8); gv_num(sum_before)
  gv_puts(" sum_after=" as *u8); gv_num(sum_after)
  gv_puts(" moved=" as *u8); gv_num(moved); gv_puts("\n" as *u8)
  gv_check("thermal-pass-conserves-terrain-mass-EXACTLY-tolerance-zero" as *u8, sum_after == sum_before, c)
  gv_check("anti-vacuity-thermal-pass-actually-moved-material" as *u8, moved > 0, c)
169
  // The equivalence that makes retiring nx_pets_voxel3d's private copy onto this owner PROVABLE.
  wg_ref_vp_pass(gb, WG_GN, talus, d2)
  let mism: i64 = wg_diffcount(ga, gb, fn2)
  gv_puts("  voxel-law equivalence mismatching_cells=" as *u8); gv_num(mism)
  gv_puts(" of=" as *u8); gv_num(fn2); gv_puts("\n" as *u8)
  gv_check("voxel-law-at-flux-zero-is-byte-identical-to-the-x-major-reference-over-every-cell" as *u8,
      mism == 0 && moved > 0, c)
177
  // NEG-CONTROL for the conservation checker: plant a one-unit leak and the SAME checker must see it.
  let clean: i64 = wg_abs(wg_sum(ga, fn2) - sum_before)
  ga[0] = ga[0] + 1
  let leaked: i64 = wg_abs(wg_sum(ga, fn2) - sum_before)
  ga[0] = ga[0] - 1
  gv_puts("  neg-control planted_leak_reads=" as *u8); gv_num(leaked)
  gv_puts(" clean_reads=" as *u8); gv_num(clean); gv_puts("\n" as *u8)
  var fires: i64 = 0
  if leaked == 1 { fires = 1 }
  var onclean: i64 = 1
  if clean == 0 { onclean = 0 }
  gv_bite("neg-control-mass-checker-fires-on-a-planted-one-unit-leak" as *u8, fires, onclean, c)
190
  // The MUSGRAVE branch must also conserve, and must move a DIFFERENT amount from the voxel branch --
  // otherwise the generalisation is decorative and one of the two laws is not being exercised.
  wg_seed_grid(gb, WG_GN)
  let msum0: i64 = wg_sum(gb, fn2)
  let mmoved: i64 = te_thermal_pass(gb, WG_GN, talus, NX_WATER_Q, d2)
  let msum1: i64 = wg_sum(gb, fn2)
  gv_puts("  musgrave branch moved=" as *u8); gv_num(mmoved)
  gv_puts(" voxel branch moved=" as *u8); gv_num(moved); gv_puts("\n" as *u8)
  gv_check("musgrave-proportional-branch-also-conserves-mass-EXACTLY" as *u8, msum1 == msum0, c)
  gv_check("the-two-laws-are-genuinely-different-not-one-law-with-a-dead-parameter" as *u8,
      mmoved > 0 && mmoved != moved, c)
202
  // =========================================================================================
  // PART 2 -- the referee, proven non-gameable on real numbers
  // =========================================================================================
  wg_seed_grid(ga, WG_GN)
  let hi_base: i64 = te_hypsometric_permil(ga, fn2)
  // offset leg: every height raised by one full step. min and mean both move by exactly that amount
  // and the range is untouched, so the integral is EXACTLY unchanged.
  wg_copy(gb, ga, fn2)
  var i2: i64 = 0
  while i2 < fn2 { gb[i2] = gb[i2] + WG_STEP; i2 = i2 + 1 }
  let hi_off: i64 = te_hypsometric_permil(gb, fn2)
  // scale leg: every height tripled. The bound is DERIVED, not picked -- the only inexactness is the
  // single truncation in the mean, amplified by the permille scale over the fixture's own range.
  var mn: i64 = ga[0]
  var mx: i64 = ga[0]
  var i3: i64 = 0
  while i3 < fn2 { if ga[i3] < mn { mn = ga[i3] } if ga[i3] > mx { mx = ga[i3] } i3 = i3 + 1 }
  let scale_bound: i64 = TE_PERMIL / (mx - mn) + 1
  wg_copy(gb, ga, fn2)
  var i4: i64 = 0
  while i4 < fn2 { gb[i4] = gb[i4] * 3; i4 = i4 + 1 }
  let hi_scl: i64 = te_hypsometric_permil(gb, fn2)
  gv_puts("  hypsometric base=" as *u8); gv_num(hi_base)
  gv_puts(" after_offset=" as *u8); gv_num(hi_off)
  gv_puts(" after_scale=" as *u8); gv_num(hi_scl)
  gv_puts(" derived_scale_bound=" as *u8); gv_num(scale_bound); gv_puts("\n" as *u8)
  gv_check("referee-is-EXACTLY-invariant-under-a-uniform-offset-so-a-shifter-cannot-move-it" as *u8,
      hi_base > 0 && hi_off == hi_base, c)
  gv_check("referee-is-invariant-under-a-uniform-positive-scale-within-the-derived-truncation-bound" as *u8,
      wg_abs(hi_scl - hi_base) <= scale_bound, c)
233
  // A field with no relief has no hypsometry. It must ABSTAIN, never return a number.
  var i5: i64 = 0
  while i5 < fn2 { gb[i5] = 7; i5 = i5 + 1 }
  let hi_flat: i64 = te_hypsometric_permil(gb, fn2)
  gv_puts("  hypsometric on a flat field reads=" as *u8); gv_num(hi_flat)
  gv_puts(" (UNOBSERVABLE is -1)\n" as *u8)
  gv_check("neg-control-referee-ABSTAINS-on-a-flat-field-instead-of-acquitting-with-a-number" as *u8,
      hi_flat == 0-1, c)
242
  // =========================================================================================
  // PART 3 -- the integration, against the real worldpipe surface
  // =========================================================================================
  wp_init(WG_SEED)
  let gn: i64 = HYW
  let n: i64 = gn * gn
  let hpre: *i64 = sys_mmap(te_grid_bytes(gn)) as *i64
  let hpost: *i64 = sys_mmap(te_grid_bytes(gn)) as *i64
  let hoff: *i64 = sys_mmap(te_grid_bytes(gn)) as *i64
  let orig: *i64 = sys_mmap(te_grid_bytes(gn)) as *i64
253
  // POPULATION DECLARED: every cell centre of the baked grid. wp_erode lands exactly on a stored
  // sample at a cell centre (the interpolation fractions are zero there), so this reads the grid the
  // bake wrote, with no sampling anywhere.
  var inert: i64 = 0
  var y1: i64 = 0
  while y1 < gn {
      var x1: i64 = 0
      while x1 < gn {
          let wx: i64 = x1*HYCELL - HYSPAN
          let wz: i64 = y1*HYCELL - HYSPAN
          hpre[y1*gn + x1] = wp_height(wx, wz)
          orig[y1*gn + x1] = wp_flow_h(wx, wz)
          if wp_erode(wx, wz) != 0 { inert = inert + 1 }
          x1 = x1 + 1
      }
      y1 = y1 + 1
  }
  gv_subjects("world-cells-probed-full-population" as *u8, n, c)
  gv_puts("  before any bake: non-zero wp_erode readings=" as *u8); gv_num(inert)
  gv_puts(" of=" as *u8); gv_num(n); gv_puts("\n" as *u8)
  gv_check("wp_erode-is-INERT-before-the-bake-so-every-existing-consumer-is-byte-unchanged" as *u8,
      inert == 0, c)
276
  // talus for the real surface, DERIVED from the terrain's own mean neighbour drop -- material sheds
  // where the ground is steeper than the ground's own average, so no threshold is picked.
  var slope_sum: i64 = 0
  var y2: i64 = 0
  while y2 < gn {
      var x2: i64 = 0
      while x2 < gn { slope_sum = slope_sum + wg_slope_at(orig, gn, x2, y2); x2 = x2 + 1 }
      y2 = y2 + 1
  }
  let mean_slope: i64 = slope_sum / n
  gv_puts("  terrain mean neighbour drop=" as *u8); gv_num(mean_slope)
  gv_puts(" world units per " as *u8); gv_num(64); gv_puts("-unit cell (talus derived from it)\n" as *u8)
  gv_check("terrain-has-relief-so-the-derived-talus-is-a-measurement-not-a-default" as *u8, mean_slope > 0, c)
290
  let cells: i64 = wp_erode_bake(WG_TICKS, NX_WATER_Q, mean_slope, NX_WATER_Q)
  let hi0: i64 = wp_erode_stat(2)
  let hi1: i64 = wp_erode_stat(3)
  let er_moved: i64 = wp_erode_stat(1)
  gv_puts("  bake cells=" as *u8); gv_num(cells)
  gv_puts(" ticks=" as *u8); gv_num(wp_erode_stat(0))
  gv_puts(" talus_moved=" as *u8); gv_num(er_moved); gv_puts("\n" as *u8)
  gv_check("bake-covered-the-whole-declared-grid" as *u8, cells == n, c)
  gv_check("anti-vacuity-the-talus-pass-moved-material-on-the-real-terrain" as *u8, er_moved > 0, c)
300
  var changed: i64 = 0
  var y3: i64 = 0
  while y3 < gn {
      var x3: i64 = 0
      while x3 < gn {
          let wx: i64 = x3*HYCELL - HYSPAN
          let wz: i64 = y3*HYCELL - HYSPAN
          let v: i64 = wp_height(wx, wz)
          hpost[y3*gn + x3] = v
          if v != hpre[y3*gn + x3] { changed = changed + 1 }
          x3 = x3 + 1
      }
      y3 = y3 + 1
  }
  gv_puts("  after bake: world cells whose height CHANGED=" as *u8); gv_num(changed)
  gv_puts(" of=" as *u8); gv_num(n); gv_puts("\n" as *u8)
  gv_check("anti-vacuity-the-composed-stage-actually-changed-the-terrain-the-world-reads" as *u8,
      changed > 0, c)
319
  // CAUSALITY: turning the stage off must restore the pre-bake height at EVERY probed cell, not most.
  wp_set_erode(0)
  var restored: i64 = 0
  var y4: i64 = 0
  while y4 < gn {
      var x4: i64 = 0
      while x4 < gn {
          let v: i64 = wp_height(x4*HYCELL - HYSPAN, y4*HYCELL - HYSPAN)
          hoff[y4*gn + x4] = v
          if v == hpre[y4*gn + x4] { restored = restored + 1 }
          x4 = x4 + 1
      }
      y4 = y4 + 1
  }
  wp_set_erode(1)
  gv_puts("  causality: cells restored with the stage off=" as *u8); gv_num(restored)
  gv_puts(" of=" as *u8); gv_num(n); gv_puts("\n" as *u8)
  gv_check("causality-stage-off-restores-the-pre-bake-height-at-EVERY-cell-in-the-population" as *u8,
      restored == n && changed > 0, c)
339
  // THE REFEREE ON REAL TERRAIN. Values measured and PRINTED. The DIRECTION is reported, never
  // asserted, and no published band is quoted -- see this file's header for both reasons.
  gv_puts("  STRAHLER hypsometric integral before=" as *u8); gv_num(hi0)
  gv_puts(" after=" as *u8); gv_num(hi1)
  gv_puts(" permille -- direction REPORTED not asserted, and the published maturity BAND is UNSOURCED" as *u8)
  gv_puts(" (primary behind a bot wall, measured; no band edge quoted from memory -- see header)\n" as *u8)
  gv_check("referee-produced-a-real-reading-on-both-sides-of-the-run-never-an-abstention" as *u8,
      hi0 >= 0 && hi1 >= 0 && hi0 <= TE_PERMIL && hi1 <= TE_PERMIL, c)
  gv_check("erosion-moved-the-referee-which-an-offset-or-a-scale-provably-cannot" as *u8, hi1 != hi0, c)
349
  // THE TOOTH NOISE CANNOT PASS: material must leave STEEP ground for FLAT ground. The divider is the
  // terrain's own mean slope, so there is no threshold here to tune.
  var steep_n: i64 = 0
  var flat_n: i64 = 0
  var steep_d: i64 = 0
  var flat_d: i64 = 0
  var y5: i64 = 0
  while y5 < gn {
      var x5: i64 = 0
      while x5 < gn {
          let d: i64 = wp_erode(x5*HYCELL - HYSPAN, y5*HYCELL - HYSPAN)
          if wg_slope_at(orig, gn, x5, y5) > mean_slope {
              steep_n = steep_n + 1
              steep_d = steep_d + d
          } else {
              flat_n = flat_n + 1
              flat_d = flat_d + d
          }
          x5 = x5 + 1
      }
      y5 = y5 + 1
  }
  gv_puts("  slope partition steep=" as *u8); gv_num(steep_n)
  gv_puts(" flat=" as *u8); gv_num(flat_n)
  gv_puts(" sum=" as *u8); gv_num(steep_n + flat_n)
  gv_puts(" of=" as *u8); gv_num(n); gv_puts("\n" as *u8)
  gv_check("slope-partition-reconciles-to-the-whole-population" as *u8, steep_n + flat_n == n, c)
  gv_check("both-slope-halves-are-populated-so-the-comparison-below-is-not-vacuous" as *u8,
      steep_n > 0 && flat_n > 0, c)
  let steep_mean: i64 = steep_d / steep_n
  let flat_mean: i64 = flat_d / flat_n
  gv_puts("  mean height delta on STEEP ground=" as *u8); gv_num(steep_mean)
  gv_puts(" on FLAT ground=" as *u8); gv_num(flat_mean); gv_puts("\n" as *u8)
  gv_check("material-left-STEEP-ground-for-FLAT-ground-a-uniform-offset-or-added-noise-scores-equal" as *u8,
      steep_mean < flat_mean, c)
385
  // DETERMINISM: the same seed and the same budget must produce the same grid, or nothing above is
  // reproducible by anybody else.
  let rebake: i64 = wp_erode_bake(WG_TICKS, NX_WATER_Q, mean_slope, NX_WATER_Q)
  var same: i64 = 0
  var y6: i64 = 0
  while y6 < gn {
      var x6: i64 = 0
      while x6 < gn {
          if wp_height(x6*HYCELL - HYSPAN, y6*HYCELL - HYSPAN) == hpost[y6*gn + x6] { same = same + 1 }
          x6 = x6 + 1
      }
      y6 = y6 + 1
  }
  gv_puts("  determinism: identical cells across two bakes=" as *u8); gv_num(same)
  gv_puts(" of=" as *u8); gv_num(n); gv_puts(" rebake_cells=" as *u8); gv_num(rebake); gv_puts("\n" as *u8)
  gv_check("two-bakes-at-one-seed-agree-at-EVERY-cell-in-the-population" as *u8, same == n, c)
402
  gv_puts("  DECLARED OPEN, not half-measured: drainage density is km of channel per km2 and this\n" as *u8)
  gv_puts("  world has no metric scale binding, so no published band for it is quoted here.\n" as *u8)
405
  return gv_verdict("nx_worldpipe_erode_gate" as *u8, c,
      "PG20: the gate-proven Mei 2007 pipeline plus the Musgrave talus companion, composed onto the worldpipe heightfield through one owner. Mass exact, inert before bake, causal on the toggle, deterministic across bakes, and judged by a dimensionless referee proven invariant to the offset and scale a fake erosion would use. Scope, declared: it says nothing about drainage density, which needs a metric scale this world does not have, and it quotes NO published maturity band because the primary is behind a bot wall -- both owed by name rather than half-measured." as *u8)
408}
nx_worldpipe_erode_gate.nx source

`nx_worldpipe_erode_gate.nx` source
