nx_cost_anatomy.nx source
↩ module page · 278 lines · 14751 B
1// nx_cost_anatomy.nx -- data-driven COST-ANATOMY + INFLATION-ATTRIBUTION engine. Generalizes nx_cost_decompose
2// (which hard-coded a battery) into an engine that reads a per-good cost-layer PACK (knowledge/anatomy/<good>.pack)
3// and answers WHERE each retail dollar goes AND WHY the price rose -- attributing the increase to DRIVER CLASSES
4// (farm/labor/energy/freight/materials/margin/rent/policy). Mode `all` aggregates across every good in packs.list to
5// surface the SYSTEMIC ROOT of everyday-goods inflation. LIAR-KILLED: layers must sum to an INDEPENDENT retail
6// anchor (a mis-entered layer breaks it), every layer maps to a KNOWN driver class (no silent other), attribution
7// conserves (sum of class deltas == measured increase), >=1 grounded anchor, driver-link non-empty, neg-control
8// (a bogus class does NOT map to a real bucket). Magnitudes tagged grounded/estimate; estimates reground via the
9// researcher (USDA ERS food-dollar, BLS CPI). Build: _offc/nx_sov_build_run.elf nx_cost_anatomy license_tier: ORIGINAL
10import "nx_syscalls.nx"
11
12func gp(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
13func gn(v0: i64) -> i64 {
14 var v: i64 = v0; if v < 0 { sys_write(1, "-" as *u8, 1); v = 0 - v }
15 let b: *u8 = sys_mmap(24); var k: i64 = 0; if v == 0 { b[0] = 48 as u8; k = 1 }
16 while v > 0 { b[k] = (48 + (v % 10)) as u8; v = v / 10; k = k + 1 }
17 let o: *u8 = sys_mmap(24); var j: i64 = 0; while j < k { o[j] = b[k-1-j]; j = j + 1 } sys_write(1, o, k); return 0
18}
19func slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
20func streq(a: *u8, b: *u8) -> i64 { var i: i64 = 0; while a[i] != (0 as u8) { if a[i] != b[i] { return 0 } i = i + 1 } if b[i] != (0 as u8) { return 0 } return 1 }
21func startswith(s: *u8, pfx: *u8) -> i64 { var i: i64 = 0; while pfx[i] != (0 as u8) { if s[i] != pfx[i] { return 0 } i = i + 1 } return 1 }
22func pint(s: *u8) -> i64 {
23 var v: i64 = 0; var i: i64 = 0; var neg: i64 = 0
24 if s[0] == (45 as u8) { neg = 1; i = 1 }
25 while s[i] != (0 as u8) { let c: i64 = s[i] as i64; if c >= 48 { if c <= 57 { v = v * 10 + (c - 48) } } i = i + 1 }
26 if neg == 1 { return 0 - v }
27 return v
28}
29
30func ev_read(path: *u8, buf: *u8, cap: i64) -> i64 {
31 let fd: i64 = sys_openat_rd(path); if fd < 0 { return 0 - 1 }
32 var tot: i64 = 0; var go: i64 = 1
33 while go == 1 {
34 if tot >= cap { go = 0 } else {
35 let r: i64 = sys_read(fd, (buf as i64 + tot) as *u8, cap - tot)
36 if r <= 0 { go = 0 } else { tot = tot + r }
37 }
38 }
39 sys_close(fd); return tot
40}
41
42func field_count(line: *u8, ln: i64) -> i64 { var n: i64 = 1; var i: i64 = 0; while i < ln { if line[i] == (124 as u8) { n = n + 1 } i = i + 1 } return n }
43
44func field_k(line: *u8, ln: i64, kk: i64, dst: *u8, cap: i64) -> i64 {
45 var field: i64 = 0; var s: i64 = 0; var i: i64 = 0
46 var fstart: i64 = 0; var fend: i64 = 0; var got: i64 = 0
47 while i <= ln {
48 var is_end: i64 = 0
49 if i == ln { is_end = 1 } else { if line[i] == (124 as u8) { is_end = 1 } }
50 if is_end == 1 { if field == kk { fstart = s; fend = i; got = 1 } field = field + 1; s = i + 1 }
51 i = i + 1
52 }
53 var t: i64 = 0
54 if got == 1 { var p: i64 = fstart; while p < fend { if t < cap - 1 { dst[t] = line[p]; t = t + 1 } p = p + 1 } }
55 dst[t] = 0 as u8
56 return t
57}
58
59func class_idx(n: *u8) -> i64 {
60 if streq(n, "farm" as *u8) == 1 { return 0 }
61 if streq(n, "labor" as *u8) == 1 { return 1 }
62 if streq(n, "energy" as *u8) == 1 { return 2 }
63 if streq(n, "freight" as *u8) == 1 { return 3 }
64 if streq(n, "materials" as *u8) == 1 { return 4 }
65 if streq(n, "margin" as *u8) == 1 { return 5 }
66 if streq(n, "rent" as *u8) == 1 { return 6 }
67 if streq(n, "policy" as *u8) == 1 { return 7 }
68 if streq(n, "finance" as *u8) == 1 { return 8 }
69 return 9
70}
71func class_name(i: i64) -> *u8 {
72 if i == 0 { return "farm/supply-shock" as *u8 }
73 if i == 1 { return "labor/wages " as *u8 }
74 if i == 2 { return "energy/fuel " as *u8 }
75 if i == 3 { return "freight/logistic" as *u8 }
76 if i == 4 { return "materials/inputs" as *u8 }
77 if i == 5 { return "corporate-margin" as *u8 }
78 if i == 6 { return "rent/realestate " as *u8 }
79 if i == 7 { return "policy/tariff " as *u8 }
80 if i == 8 { return "finance/interest" as *u8 }
81 return "other/unknown " as *u8
82}
83
84func print_classes(cd: *i64, total: i64) -> i64 {
85 let done: *i64 = sys_mmap(8 * 10) as *i64
86 var i: i64 = 0
87 while i < 10 { done[i] = 0; i = i + 1 }
88 var k: i64 = 0
89 while k < 10 {
90 var bi: i64 = 0 - 1; var bv: i64 = 0 - 1000000; var c: i64 = 0
91 while c < 10 { if done[c] == 0 { if cd[c] > bv { bv = cd[c]; bi = c } } c = c + 1 }
92 if bi >= 0 {
93 done[bi] = 1
94 if cd[bi] != 0 {
95 var pct: i64 = 0
96 if total > 0 { pct = cd[bi] * 100 / total }
97 gp(" " as *u8); gp(class_name(bi)); gp(" +" as *u8); gn(cd[bi]); gp("c " as *u8); gn(pct); gp("% of the increase\n" as *u8)
98 }
99 }
100 k = k + 1
101 }
102 return 0
103}
104
105// analyze one pack. single=1 prints the full decomposition; accumulates class deltas into cacc; writes stats to out:
106// out[0]=sum_base out[1]=sum_now out[2]=base_anchor out[3]=now_anchor out[4]=grounded out[5]=layers out[6]=driver_empty out[7]=other_class_delta
107func analyze_pack(good: *u8, single: i64, cacc: *i64, out: *i64) -> i64 {
108 let path: *u8 = sys_mmap(256)
109 var o: i64 = 0
110 let pre: *u8 = "knowledge/anatomy/"
111 var i: i64 = 0
112 while pre[i] != (0 as u8) { path[o] = pre[i]; o = o + 1; i = i + 1 }
113 i = 0
114 while good[i] != (0 as u8) { path[o] = good[i]; o = o + 1; i = i + 1 }
115 let sfx: *u8 = ".pack"
116 i = 0
117 while sfx[i] != (0 as u8) { path[o] = sfx[i]; o = o + 1; i = i + 1 }
118 path[o] = 0 as u8
119
120 let buf: *u8 = sys_mmap(65536)
121 let mn: i64 = ev_read(path, buf, 65536)
122 var sum_base: i64 = 0; var sum_now: i64 = 0; var base_anchor: i64 = 0; var now_anchor: i64 = 0
123 var wt: i64 = 1
124 var grounded: i64 = 0; var layers: i64 = 0; var driver_empty: i64 = 0
125 let lcd: *i64 = sys_mmap(8 * 10) as *i64
126 var cc: i64 = 0
127 while cc < 10 { lcd[cc] = 0; cc = cc + 1 }
128 let line: *u8 = sys_mmap(1024)
129 let f0: *u8 = sys_mmap(256)
130 let f1: *u8 = sys_mmap(64)
131 let f2: *u8 = sys_mmap(256)
132 let f3: *u8 = sys_mmap(32)
133 let f4: *u8 = sys_mmap(32)
134 let f5: *u8 = sys_mmap(16)
135 let gname: *u8 = sys_mmap(256)
136 gname[0] = 0 as u8
137
138 if mn <= 0 { if single == 1 { gp(" (pack missing: " as *u8); gp(good); gp(")\n" as *u8) } out[0] = 0; out[1] = 0; out[2] = 0; out[3] = 0; out[4] = 0; out[5] = 0; out[6] = 99; out[7] = 99; return 1 }
139
140 var p: i64 = 0
141 while p < mn {
142 var e: i64 = p; var go: i64 = 1
143 while go == 1 { if e >= mn { go = 0 } else { if buf[e] == (10 as u8) { go = 0 } else { e = e + 1 } } }
144 let ll: i64 = e - p
145 if ll > 0 {
146 var t: i64 = 0
147 while t < ll { if t < 1023 { line[t] = buf[p + t] } t = t + 1 }
148 line[ll] = 0 as u8
149 let c0: i64 = line[0] as i64
150 if c0 == 64 {
151 if startswith(line, "@good " as *u8) == 1 { var q: i64 = 6; var r: i64 = 0; while line[q] != (0 as u8) { gname[r] = line[q]; r = r + 1; q = q + 1 } gname[r] = 0 as u8 }
152 if startswith(line, "@base_anchor " as *u8) == 1 { base_anchor = pint((line as i64 + 13) as *u8) }
153 if startswith(line, "@now_anchor " as *u8) == 1 { now_anchor = pint((line as i64 + 12) as *u8) }
154 if startswith(line, "@weight " as *u8) == 1 { wt = pint((line as i64 + 8) as *u8) }
155 }
156 if c0 != 64 { if c0 != 35 {
157 let nf: i64 = field_count(line, ll)
158 if nf >= 6 {
159 field_k(line, ll, 0, f0, 256)
160 field_k(line, ll, 1, f1, 64)
161 field_k(line, ll, 2, f2, 256)
162 field_k(line, ll, 3, f3, 32)
163 field_k(line, ll, 4, f4, 32)
164 field_k(line, ll, 5, f5, 16)
165 let base: i64 = pint(f3)
166 let now: i64 = pint(f4)
167 let grd: i64 = pint(f5)
168 let cls: i64 = class_idx(f1)
169 sum_base = sum_base + base
170 sum_now = sum_now + now
171 lcd[cls] = lcd[cls] + (now - base)
172 if grd == 1 { grounded = grounded + 1 }
173 if slen(f2) == 0 { driver_empty = driver_empty + 1 }
174 layers = layers + 1
175 if single == 1 {
176 var pct: i64 = 0
177 if now_anchor > 0 { pct = now * 100 / now_anchor }
178 gp(" " as *u8); gp(f0); gp(" now=" as *u8); gn(now); gp("c (" as *u8); gn(pct); gp("%) d=+" as *u8); gn(now - base)
179 gp(" [" as *u8); gp(class_name(cls)); gp("] <- " as *u8); gp(f2)
180 if grd == 1 { gp(" [grounded]\n" as *u8) } else { gp(" [estimate]\n" as *u8) }
181 }
182 }
183 } }
184 }
185 p = e + 1
186 }
187 cc = 0
188 while cc < 10 { cacc[cc] = cacc[cc] + lcd[cc] * wt; cc = cc + 1 }
189 out[0] = sum_base; out[1] = sum_now; out[2] = base_anchor; out[3] = now_anchor
190 out[4] = grounded; out[5] = layers; out[6] = driver_empty; out[7] = lcd[9]; out[8] = wt
191
192 if single == 1 {
193 let td: i64 = sum_now - sum_base
194 gp(" ---\n " as *u8); gp(gname); gp(": base=" as *u8); gn(base_anchor); gp("c -> now=" as *u8); gn(now_anchor)
195 var infl: i64 = 0
196 if base_anchor > 0 { infl = td * 100 / base_anchor }
197 gp("c cumulative inflation = +" as *u8); gn(infl); gp("%\n" as *u8)
198 gp(" WHY (attribution of the +" as *u8); gn(td); gp("c increase, ranked by driver class):\n" as *u8)
199 print_classes(lcd, td)
200 }
201 return 0
202}
203
204func main(argc: i64, argv: *i64) -> i64 {
205 let cacc: *i64 = sys_mmap(8 * 10) as *i64
206 var c: i64 = 0
207 while c < 10 { cacc[c] = 0; c = c + 1 }
208 let out: *i64 = sys_mmap(8 * 12) as *i64
209
210 var good: *u8 = "all" as *u8
211 if argc >= 2 { good = argv[1] as *u8 }
212
213 if streq(good, "all" as *u8) == 0 {
214 gp("=== nx_cost_anatomy: " as *u8); gp(good); gp(" -- where each dollar goes + WHY it rose (cents per base-100 dollar) ===\n" as *u8)
215 analyze_pack(good, 1, cacc, out)
216 gp(" (structure anchors grounded per-pack (USDA/BLS/NAHB/Freddie); per-layer split = estimate to reground via the researcher. attribution conserves to the measured total.)\n" as *u8)
217 sys_exit(0); return 0
218 }
219
220 gp("=== nx_cost_anatomy ALL: the SYSTEMIC ROOT of everyday-essentials inflation (aggregated across packs.list) ===\n" as *u8)
221 let man: *u8 = sys_mmap(8192)
222 let mn: i64 = ev_read("knowledge/anatomy/packs.list" as *u8, man, 8192)
223 if mn <= 0 { gp(" packs.list missing pass=0 fail=1 verdict=RED\n" as *u8); sys_exit(1); return 1 }
224 var grand_base: i64 = 0; var grand_now: i64 = 0; var packs: i64 = 0; var fails: i64 = 0
225 let gname: *u8 = sys_mmap(64)
226 var p: i64 = 0
227 while p < mn {
228 var e: i64 = p; var go: i64 = 1
229 while go == 1 { if e >= mn { go = 0 } else { if man[e] == (10 as u8) { go = 0 } else { e = e + 1 } } }
230 let ll: i64 = e - p
231 if ll > 0 { if man[p] != (35 as u8) {
232 var t: i64 = 0
233 while t < ll { if t < 63 { gname[t] = man[p + t] } t = t + 1 }
234 gname[ll] = 0 as u8
235 analyze_pack(gname, 0, cacc, out)
236 grand_base = grand_base + out[2] * out[8]
237 grand_now = grand_now + out[3] * out[8]
238 packs = packs + 1
239 if out[0] != out[2] { fails = fails + 1; gp(" FAIL " as *u8); gp(gname); gp(" base layers sum != anchor\n" as *u8) }
240 if out[1] != out[3] { fails = fails + 1; gp(" FAIL " as *u8); gp(gname); gp(" now layers sum != anchor\n" as *u8) }
241 if out[7] != 0 { fails = fails + 1; gp(" FAIL " as *u8); gp(gname); gp(" a layer has an unknown driver class\n" as *u8) }
242 if out[4] < 1 { fails = fails + 1; gp(" FAIL " as *u8); gp(gname); gp(" no grounded anchor\n" as *u8) }
243 if out[6] > 0 { fails = fails + 1; gp(" FAIL " as *u8); gp(gname); gp(" an empty driver link\n" as *u8) }
244 let td: i64 = out[1] - out[0]
245 var infl: i64 = 0
246 if out[0] > 0 { infl = td * 100 / out[0] }
247 gp(" " as *u8); gp(gname); gp(": +" as *u8); gn(infl); gp("% cumulative (base=" as *u8); gn(out[2]); gp(" now=" as *u8); gn(out[3]); gp(" w=" as *u8); gn(out[8]); gp(")\n" as *u8)
248 } }
249 p = e + 1
250 }
251 let gd: i64 = grand_now - grand_base
252 gp("\n === WHY US ESSENTIALS KEEP RISING -- systemic driver ranking across " as *u8); gn(packs); gp(" goods (attribution of the aggregate increase) ===\n" as *u8)
253 print_classes(cacc, gd)
254 var ginfl: i64 = 0
255 if grand_base > 0 { ginfl = gd * 100 / grand_base }
256 gp(" aggregate basket (HOUSEHOLD-WEIGHTED): +" as *u8); gn(ginfl); gp("% cumulative; the top class is the ROOT to attack first.\n" as *u8)
257 gp(" weights = household budget shares (BLS CES-style, structural estimates); newbuild w=0 = supply-side explainer, not a household line item.\n" as *u8)
258 gp(" the finance wedge falls on NEW ENTRANTS (renters + first-time buyers + movers); incumbents locked at ~3pct do not feel it -- the crisis is generational.\n" as *u8)
259
260 let negc: i64 = class_idx("ZZ_bogus_class_QQ" as *u8)
261 let realc: i64 = class_idx("farm" as *u8)
262 var pass: i64 = 0
263 var fl: i64 = 0
264 if fails == 0 { pass = pass + 1 } else { fl = fl + 1 }
265 if packs >= 2 { pass = pass + 1 } else { fl = fl + 1; gp(" FAIL fewer than 2 packs\n" as *u8) }
266 if gd > 0 { pass = pass + 1 } else { fl = fl + 1; gp(" FAIL no measured increase\n" as *u8) }
267 var a4: i64 = 0
268 if negc == 9 { if realc == 0 { a4 = 1 } }
269 if a4 == 1 { pass = pass + 1 } else { fl = fl + 1; gp(" FAIL class neg-control (bogus mapped to a real bucket)\n" as *u8) }
270 var csum: i64 = 0
271 c = 0
272 while c < 10 { csum = csum + cacc[c]; c = c + 1 }
273 if csum == gd { pass = pass + 1 } else { fl = fl + 1; gp(" FAIL attribution not conserved (sum of class deltas != measured increase)\n" as *u8) }
274
275 gp("\nCOST-ANATOMY pass=" as *u8); gn(pass); gp(" fail=" as *u8); gn(fl)
276 if fl == 0 { gp(" verdict=GREEN (every pack sums to its anchor, every layer has a known driver + link, attribution conserves, neg-control clean)\n" as *u8); sys_exit(0); return 0 }
277 gp(" verdict=RED\n" as *u8); sys_exit(1); return 1
278}