code wiki / _hdl_build / nx_flip_real.nx
`nx_flip_real.nx` source

↩ module page · 276 lines · 13025 B
1// nx_flip_real.nx -- REAL-VALUE vs NOMINAL-PRICE discriminator + triangulated manipulation gate.
2// Value = bottom-up NET TANGIBLE (goodwill/intangibles EXCLUDED as accounting air). A balance sheet
3// IS a part list. backing_bps = net_tangible*10000/nominal ; air_bps = 10000-backing.
4// MANIPULATION GATE (feedback-market-intelligence-captain-moroni-discipline): PROVEN only on THREE
5// independent evidence sources; <3 = UNPROVEN (reported, never acted on, never amplified). No concept
6// of a group or person by construction. COVERAGE: TANGIBLE with no offsetting LIABILITY = REFUSED.
7// PRECEDENCE: manipulation(3) > incomplete(4) > value.
8//
9// CONVERTED ONTO THE SHARED BASE nx_flip_lib.nx (fx_*); only fr_ev_present (evidence-cell presence)
10// stays local. Equivalence PROVEN by nx_flip_gate staying 16/16 across the swap.
11// license_tier: ORIGINAL   No hw writes (Rule 26).   expect_exit: 0
12import "nx_flip_lib.nx"
13import "nx_syscalls.nx"
14
15const FR_ARGC_MIN: i64 = 5
16const FR_ARG_PFX: i64 = 5
17const FR_EVIDENCE_N: i64 = 3
18const FR_CFG_MINBACK: i64 = 1
19const FR_CFG_REQTRI: i64 = 3
20const FR_CFG_REQLIAB: i64 = 5
21const FR_V_ASSET: i64 = 1
22const FR_V_COMP: i64 = 2
23const FR_V_KIND: i64 = 3
24const FR_V_AMT: i64 = 4
25const FR_M_ASSET: i64 = 1
26const FR_M_PRACTICE: i64 = 2
27const FR_M_EV0: i64 = 3
28
29// an evidence cell counts ONLY if non-empty and not the '-' placeholder (real-specific)
30func fr_ev_present(b: *u8, ls: i64, le: i64, idx: i64, sp: *i64) -> i64 {
  if fx_col(b, ls, le, idx, sp) == 0 { return 0 }
  if sp[1] <= sp[0] { return 0 }
  if fx_slice_eqs(b, sp[0], sp[1], "-" as *u8) == 1 { return 0 }
  return 1
35}
36
37func main(argc: i64, argv: *i64) -> i64 {
  if argc < FR_ARGC_MIN {
      fx_puts("usage: nx_flip_real <class> <asset> <nominal-price> <days> [plane-prefix-root]\n" as *u8)
      fx_puts("  real value is read from <root>val- ; manipulation flags from <root>manip- ; thresholds from <root>realcfg-\n" as *u8)
      sys_exit(FX_EXIT_USAGE)
      return FX_EXIT_USAGE
  }
  let cls: *u8 = argv[1] as *u8
  let asset: *u8 = argv[2] as *u8
  let nominal: i64 = fx_atoi(argv[3] as *u8)
  let days: i64 = fx_atoi(argv[4] as *u8)
48
  var root: *u8 = "flip-" as *u8
  if argc > FR_ARG_PFX { root = argv[FR_ARG_PFX] as *u8 }
  let ncp: *i64 = sts_mm(FX_SCRATCH) as *i64
  let nvp: *i64 = sts_mm(FX_SCRATCH) as *i64
  let nmp: *i64 = sts_mm(FX_SCRATCH) as *i64
  let bc: *u8 = fx_plane(root, "realcfg-" as *u8, ncp)
  let bv: *u8 = fx_plane(root, "val-" as *u8, nvp)
  let bm: *u8 = fx_plane(root, "manip-" as *u8, nmp)
  let nc: i64 = ncp[0]
  let nv: i64 = nvp[0]
  let nm: i64 = nmp[0]
60
  let sp: *i64 = sts_mm(FX_SCRATCH) as *i64
  let cr: *i64 = sts_mm(FX_SCRATCH) as *i64
  let cs: *i64 = sts_mm(FX_SCRATCH) as *i64
  let pb: *u8 = sts_mm(FX_BUF)
  var po: i64 = 0
66
  if nc == 0 {
      fx_puts("FLIP-RED reason=realcfg-plane-empty prefix=" as *u8); fx_puts(fx_cat2(root, "realcfg-" as *u8)); fx_puts("\n" as *u8)
      sys_exit(FX_EXIT_REFUSED)
      return FX_EXIT_REFUSED
  }
  if fx_row_by_id(bc, nc, cls, cr, sp) == 0 {
      fx_puts("FLIP-RED reason=unknown-real-value-class class=" as *u8); fx_puts(cls); fx_puts("\n" as *u8)
      sys_exit(FX_EXIT_REFUSED)
      return FX_EXIT_REFUSED
  }
  let min_back: i64 = fx_col_atoi(bc, cr[0], cr[1], FR_CFG_MINBACK, sp)
  let req_tri: i64 = fx_col_atoi(bc, cr[0], cr[1], FR_CFG_REQTRI, sp)
79
  // ---- value components: the balance sheet IS a part list ----
  var tangible: i64 = 0
  var intangible: i64 = 0
  var liab: i64 = 0
  var flow: i64 = 0
  var n_comp: i64 = 0
  var n_liab: i64 = 0
  // ---- DRIVER ATTRIBUTION (added 2026-08-08). The organ already said HOW MUCH of the price
  // is real (backing_bps); it never said WHICH components drive it. "Exact feedback on what is
  // driving value" needs a per-driver share AND a partition that reconciles -- a partition is a
  // claim, so the parts must sum and the residual must be PRINTED, not assumed to be zero.
  var top_share: i64 = 0
  var have_top: i64 = 0
  var sum_pos_bps: i64 = 0
  var sum_neg_bps: i64 = 0
  let tops: *i64 = sts_mm(FX_SCRATCH) as *i64
  var i: i64 = 0
  while i < nv {
      let le: i64 = fx_line_end(bv, nv, i)
      if le > i {
          if fx_col(bv, i, le, FR_V_ASSET, sp) == 1 {
              if fx_slice_eqs(bv, sp[0], sp[1], asset) == 1 {
                  n_comp = n_comp + 1
                  fx_col(bv, i, le, FR_V_COMP, cs)
                  let amt: i64 = fx_col_atoi(bv, i, le, FR_V_AMT, sp)
                  var kind: i64 = 0
                  if fx_col(bv, i, le, FR_V_KIND, sp) == 1 {
                      if fx_slice_eqs(bv, sp[0], sp[1], "TANGIBLE" as *u8) == 1 { kind = 1 }
                      if fx_slice_eqs(bv, sp[0], sp[1], "INTANGIBLE" as *u8) == 1 { kind = 2 }
                      if fx_slice_eqs(bv, sp[0], sp[1], "LIABILITY" as *u8) == 1 { kind = 3 }
                      if fx_slice_eqs(bv, sp[0], sp[1], "FLOW" as *u8) == 1 { kind = 4 }
                  }
                  if kind == 1 { tangible = tangible + amt }
                  if kind == 2 { intangible = intangible + amt }
                  if kind == 3 { liab = liab + amt; n_liab = n_liab + 1 }
                  if kind == 4 { flow = flow + amt }
                  // Share of the NOMINAL PRICE this component explains. TANGIBLE adds,
                  // LIABILITY subtracts, INTANGIBLE contributes ZERO to backing by design --
                  // it is the air, and saying so per-component is the whole point.
                  var share: i64 = 0
                  if nominal > 0 {
                      if kind == 1 { share = amt * FX_BPS / nominal; sum_pos_bps = sum_pos_bps + share }
                      if kind == 3 { share = 0 - (amt * FX_BPS / nominal); sum_neg_bps = sum_neg_bps + (0 - share) }
                  }
                  var mag: i64 = share
                  if mag < 0 { mag = 0 - mag }
                  if mag > top_share { top_share = mag; tops[0] = cs[0]; tops[1] = cs[1]; have_top = 1 }
                  po = fx_bcat(pb, po, "COMP " as *u8)
                  po = fx_bcatsl(pb, po, bv, cs[0], cs[1])
                  po = fx_bcat(pb, po, " amount=" as *u8); po = fx_bcatn(pb, po, amt)
                  po = fx_bcat(pb, po, " share_bps=" as *u8); po = fx_bcatn(pb, po, share)
                  po = fx_bcat(pb, po, " kind=" as *u8)
                  if kind == 1 { po = fx_bcat(pb, po, "TANGIBLE-counts" as *u8) }
                  if kind == 2 { po = fx_bcat(pb, po, "INTANGIBLE-EXCLUDED-this-is-the-air" as *u8) }
                  if kind == 3 { po = fx_bcat(pb, po, "LIABILITY-subtracts" as *u8) }
                  if kind == 4 { po = fx_bcat(pb, po, "FLOW-reported-only" as *u8) }
                  if kind == 0 { po = fx_bcat(pb, po, "UNKNOWN-KIND-ignored" as *u8) }
                  po = fx_bcat(pb, po, "\n" as *u8)
              }
          }
      }
      i = le + 1
  }
143
  // ---- manipulation: PROVEN only on 3 independent evidence sources ----
  var man_proven: i64 = 0
  var man_unproven: i64 = 0
  i = 0
  while i < nm {
      let le: i64 = fx_line_end(bm, nm, i)
      if le > i {
          if fx_col(bm, i, le, FR_M_ASSET, sp) == 1 {
              if fx_slice_eqs(bm, sp[0], sp[1], asset) == 1 {
                  var ev: i64 = 0
                  var k: i64 = 0
                  while k < FR_EVIDENCE_N {
                      ev = ev + fr_ev_present(bm, i, le, FR_M_EV0 + k, sp)
                      k = k + 1
                  }
                  fx_col(bm, i, le, FR_M_PRACTICE, cs)
                  po = fx_bcat(pb, po, "MANIP " as *u8)
                  po = fx_bcatsl(pb, po, bm, cs[0], cs[1])
                  po = fx_bcat(pb, po, " evidence_sources=" as *u8); po = fx_bcatn(pb, po, ev)
                  po = fx_bcat(pb, po, " status=" as *u8)
                  if ev >= FR_EVIDENCE_N {
                      man_proven = man_proven + 1
                      po = fx_bcat(pb, po, "TRIANGULATED-BLOCKS-TRADE" as *u8)
                  } else {
                      man_unproven = man_unproven + 1
                      po = fx_bcat(pb, po, "UNPROVEN-reported-never-acted-on-never-amplified" as *u8)
                  }
                  po = fx_bcat(pb, po, "\n" as *u8)
              }
          }
      }
      i = le + 1
  }
177
  if nominal <= 0 {
      fx_puts("FLIP-RED reason=nominal-price-must-be-positive\n" as *u8)
      fx_puts("verdict=REFUSED\n" as *u8)
      sys_exit(FX_EXIT_REFUSED)
      return FX_EXIT_REFUSED
  }
  if n_comp == 0 {
      fx_puts("FLIP-RED reason=no-value-components-for-asset asset=" as *u8); fx_puts(asset); fx_puts("\n" as *u8)
      fx_puts("verdict=REFUSED\n" as *u8)
      fx_puts("rule=absent-analysis-is-not-clean-analysis\n" as *u8)
      sys_exit(FX_EXIT_REFUSED)
      return FX_EXIT_REFUSED
  }
191
  let net_tangible: i64 = tangible - liab
  let backing: i64 = net_tangible * FX_BPS / nominal
  let air: i64 = FX_BPS - backing
195
  var blocked: i64 = 0
  if req_tri == 1 {
      if man_proven > 0 { blocked = 1 }
  } else {
      if man_proven + man_unproven > 0 { blocked = 1 }
  }
202
  let req_liab: i64 = fx_col_atoi(bc, cr[0], cr[1], FR_CFG_REQLIAB, sp)
  var incomplete: i64 = 0
  if req_liab == 1 { if n_liab == 0 { incomplete = 1 } }
206
  var vcode: i64 = 0
  if blocked == 1 { vcode = 3 } else { if incomplete == 1 { vcode = 4 } else { if backing >= min_back { vcode = 1 } } }
209
  fx_puts("FLIP-REAL\n" as *u8)
  fx_puts("class=" as *u8); fx_puts(cls); fx_puts(" asset=" as *u8); fx_puts(asset); fx_puts("\n" as *u8)
  fx_puts("verdict=" as *u8)
  if vcode == 3 { fx_puts("REFUSED" as *u8) }
  if vcode == 4 { fx_puts("REFUSED" as *u8) }
  if vcode == 1 { fx_puts("BUY" as *u8) }
  if vcode == 0 { fx_puts("PASS" as *u8) }
  fx_puts(" liability_rows=" as *u8); fx_putn(n_liab)
  fx_puts(" backing_bps=" as *u8); fx_putn(backing)
  fx_puts(" air_bps=" as *u8); fx_putn(air)
  fx_puts(" manip_proven=" as *u8); fx_putn(man_proven)
  fx_puts(" manip_unproven=" as *u8); fx_putn(man_unproven)
  fx_puts("\n" as *u8)
  fx_puts("rule=" as *u8)
  if vcode == 3 { fx_puts("triangulated-manipulation-blocks-trade\n" as *u8) }
  if vcode == 4 { fx_puts("incomplete-balance-sheet-tangible-with-no-offsetting-liability-overstates-real-value\n" as *u8) }
  if vcode == 1 { fx_puts("net-tangible-value-covers-nominal-price\n" as *u8) }
  if vcode == 0 { fx_puts("price-not-covered-by-real-value-the-rest-is-inflation\n" as *u8) }
228
  fx_kv("components" as *u8, n_comp)
  fx_kv("tangible" as *u8, tangible)
  fx_kv("liabilities" as *u8, liab)
  fx_kv("net_tangible" as *u8, net_tangible)
  fx_kv("intangible_excluded" as *u8, intangible)
  fx_kv("flow_reported" as *u8, flow)
  fx_kv("nominal" as *u8, nominal)
  fx_kv("backing_bps" as *u8, backing)
237
  // ---- DRIVER ATTRIBUTION: the partition, and it MUST RECONCILE ----
  // `backing` is computed ONCE from the totals; `sum_pos - sum_neg` sums the SAME quantity
  // component-by-component. The two can differ only by per-component integer truncation, so
  // the residual is a genuine check: a large one means a component was double-counted,
  // dropped, or classified into a bucket that does not participate in value.
  // NOT printed: a "total_bps" of tangible+air+residual, because that is 10000 BY ALGEBRA no
  // matter what the data says -- a tautology that prints a number and reads as evidence.
  let attrib_sum_bps: i64 = sum_pos_bps - sum_neg_bps
  let residual_bps: i64 = backing - attrib_sum_bps
  var recon_tol: i64 = n_comp + 1
  var reconciles: i64 = 0
  var resmag: i64 = residual_bps
  if resmag < 0 { resmag = 0 - resmag }
  if resmag <= recon_tol { reconciles = 1 }
  fx_kv("attrib_tangible_bps" as *u8, sum_pos_bps)
  fx_kv("attrib_liability_bps" as *u8, sum_neg_bps)
  fx_kv("attrib_sum_bps" as *u8, attrib_sum_bps)
  fx_kv("attrib_air_bps" as *u8, air)
  fx_kv("attrib_residual_bps" as *u8, residual_bps)
  fx_kv("attrib_reconciles" as *u8, reconciles)
  // THE QUALITATIVE HALF, counted rather than left as prose: each practice row is a market
  // driver that carries no dollar amount, and PROVEN vs UNPROVEN is the triangulation verdict.
  fx_kv("qual_drivers" as *u8, man_proven + man_unproven)
  fx_kv("qual_drivers_proven" as *u8, man_proven)
  if have_top == 1 {
      fx_puts("top_value_driver=" as *u8)
      fx_putslice(bv, tops[0], tops[1])
      fx_puts(" share_bps=" as *u8); fx_putn(top_share)
      fx_puts("\n" as *u8)
  }
  fx_kv("air_bps" as *u8, air)
  fx_kv("min_backing_bps" as *u8, min_back)
  fx_kv("require_triangulation" as *u8, req_tri)
  fx_kv("days" as *u8, days)
272
  sys_write(FX_OUT, pb, po)
  sys_exit(0)
  return 0
276}
nx_flip_real.nx source

`nx_flip_real.nx` source
