From 13a2c39166af363d2748f1027f7bdc68e4bec690 Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 23 Aug 2026 18:37:42 +0000 Subject: [PATCH 1/2] =?UTF-8?q?falsification=20is=20the=20cheap=20directio?= =?UTF-8?q?n;=20Ausl=C3=B6schung=20is=20a=20reading=20(+=20probe)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit E-FALSIFICATION-IS-THE-CHEAP-DIRECTION-AND-AUSLOESCHUNG-IS-A-READING-1, measured by PROBE-HHTL-FALSIFICATION-ASYMMETRY-1 (7/7). Corollary of the address-space root law. A signed 24xi4 field admits destructive interference -- Auslöschung. A purely positive confidence scalar structurally cannot: it can be diluted, never extinguished. That is the distance between "my confidence went down" and "this was refuted", and only the second is actionable. THE ASYMMETRY, MADE MECHANICAL (F2/F3/F5). Falsifying a universal claim at P costs ONE counterexample region; verifying it costs the whole FAN_OUT (16) and still leaves every level below open. Falsification is the only operation that is O(1) AND totally sound. It reaches a subtree with no enumeration (one depth-1 focus covers all 16 depth-2 and all 16 depth-3 probes by prefix test alone -- the subtree is never materialized), and does not over-kill: silent on sibling subtrees, on other parents, and on its own ANCESTOR, since a child's refutation is not the parent's. The hierarchy does not create Popper's asymmetry; it makes `covers` the entire test. KNOWN-UNKNOWNS ARE ADDRESSABLE-WITHOUT-A-VALUE (F4). Three states, and only the middle admits a targeted probe: known-known (covered address, value present), known-unknown (a real region to drill into, value absent), unknown-unknown (no region at all). This is what makes indirect intermediate known-unknowns cheap, and it pairs exactly with the shipped CausalTopology::IndirectUnknownIntermediates -- the topology says an intermediate exists, the address says where it would live, the pothole says we don't have it. INHERITANCE IS DIRECTIONAL (F7): downstream is covers, upstream is common_prefix. P covers C but C does not cover P. TWO COSTS MEASURED, NOT CONCEDED: COST 1 (F1) -- Auslöschung must be a READING, never a stored sum. net(+3,-3) == net(unset) == 0, so a summed slot cannot distinguish "support and refutation annihilated" from "nothing was ever asserted". Those license opposite actions: the first is a licence to LEARN, the second a licence to LOOK. Two slots keep the three-way state and the registers differ bitwise even at net zero. Same shape as the standing rule that a contradiction is committed and preserved, not resolved away. COST 2 (F6) -- the operator's own "worst case connective tissue" admission, measured. Collapse is free: all 16 children explicitly = 16 entries but absorbs to 1. "All but one" costs 15 entries, and RowFocusMask::difference CANNOT help -- subtracting the hole from the parent yields 1 entry that STILL COVERS THE HOLE. That is sharper than "conservative": difference is not usable as an exclusion primitive, and reading its output as "everything except the hole" is unsound. This is the mechanical root of the standing P* rule. Consequence: an exclusion needs its own channel -- a signed negative at the excluded address -- never a subtracted prefix. Which is Auslöschung again: mark the hole, do not carve it out. Co-Authored-By: Claude Opus 5 Claude-Session: https://claude.ai/code/session_01KCGhDYoQBXs3poaR7sFuqp --- .claude/board/EPIPHANIES.md | 100 ++++++ .../examples/probe_falsification_asymmetry.rs | 324 ++++++++++++++++++ 2 files changed, 424 insertions(+) create mode 100644 crates/lance-graph-planner/examples/probe_falsification_asymmetry.rs diff --git a/.claude/board/EPIPHANIES.md b/.claude/board/EPIPHANIES.md index 451c19c65..779f350a0 100644 --- a/.claude/board/EPIPHANIES.md +++ b/.claude/board/EPIPHANIES.md @@ -1,3 +1,103 @@ +## 2026-08-23 — E-FALSIFICATION-IS-THE-CHEAP-DIRECTION-AND-AUSLOESCHUNG-IS-A-READING-1 — the address space makes Popper's asymmetry mechanical; two costs measured + +**Status:** FINDING — [MEASURED] on shipped operators +(`PROBE-HHTL-FALSIFICATION-ASYMMETRY-1`, 7/7). Corollary of +`E-HIERARCHY-IS-THE-ADDRESS-SPACE-NOT-THE-ONTOLOGY-1`. +**Confidence:** High for the algebra; the toy hierarchy is an operator +test, not a corpus. + +### Why a SIGNED field is categorically different + +A signed `24×i4` field admits **destructive interference** — *Auslöschung*. +`+n` and `−n` at one address cancel. A purely positive confidence scalar +structurally cannot do this: it can be diluted, never extinguished. That is +the whole distance between *"my confidence went down"* and *"this was +refuted"* — and refutation, not dilution, is what a learner can act on. + +### ⚠ COST 1 (F1) — Auslöschung must be a READING, never a stored sum + +Measured: `net(+3, −3) == net(unset) == 0`. **A summed slot cannot +distinguish "support and refutation met and annihilated" from "nothing was +ever asserted here."** Those license opposite actions — the first is a +licence to LEARN (something is contested, go resolve it), the second a +licence to LOOK (nothing here yet, go gather). Collapsing them destroys +exactly the information falsification exists to create. + +Two slots keep the three-way state (`Unasserted` / `Supported` / `Refuted` +/ `Contested{net}`) and the registers differ bitwise even when the net is +zero. **So: cancellation is a projection over retained polarities, never a +storage collapse.** This is the same shape as the standing rule that a +contradiction is COMMITTED and preserved, not resolved away. + +### The asymmetry, made mechanical (F2/F3/F5) + +``` + falsify a universal claim at P ONE counterexample region cost 1 + verify a universal claim at P exhaust FAN_OUT (16) cost 16 + …and every level BELOW stays open +``` + +Falsification is the only operation here that is **`O(1)` and totally +sound**. It reaches a whole subtree with **no enumeration** (F2: one +depth-1 focus covers all 16 depth-2 and all 16 depth-3 probes by prefix +test alone — the subtree is never materialized), and it does not over-kill +(F5: silent on sibling subtrees, on other parents, and — importantly — on +its own ANCESTOR, since a child's refutation is not the parent's). + +The hierarchy does not *create* Popper's asymmetry. It makes it +**mechanical**: `covers` is the entire test. That is the concrete sense in +which falsification is "a precondition for learning" here — it is the +cheap direction, structurally. + +### The known-unknown is addressable-without-a-value (F4) + +Three epistemic states, and only the middle one admits a targeted +counterfactual probe: + +| state | address | value | +|---|---|---| +| known-known | a covered address | present | +| **known-unknown** | **a real region to drill into** | **absent** | +| unknown-unknown | no region at all | absent | + +This is what makes "indirect intermediate known-unknowns" cheap: the WHERE +is addressable while the WHAT is absent, so a probe has a target. It pairs +exactly with the shipped `CausalTopology::IndirectUnknownIntermediates` — +the topology register says *an* intermediate exists, the address space says +*where it would live*, and the pothole says *we don't have it yet*. + +### Inheritance is DIRECTIONAL (F7) + +Downstream is `covers` (containment); upstream is `common_prefix` (the +meet). `P.covers(C)` but **not** `C.covers(P)` — upstream is not +containment, and conflating them would let a child's verdict masquerade as +its parent's. + +### ⚠ COST 2 (F6) — "all but one" is the worst case, and `difference` cannot help + +The operator's own cost admission — *"in the worst case it just needs HHTL +hierarchical nodes to express more connective tissue than the leaf +nodes"* — measured rather than conceded: + +- **Collapse is free.** All 16 children explicitly = 16 antichain entries, + but absorbs to **1** parent entry. +- **"All but one" costs 15 entries.** And `RowFocusMask::difference` + **cannot** reduce it: subtracting the hole from the parent yields **1 + entry that STILL COVERS THE HOLE**. + +That last result is sharper than "conservative". It means `difference` is +**not usable as an exclusion primitive** — reading its output as +"everything except the hole" is unsound. This is the mechanical root of the +already-standing P* rule (scoped-difference potholes are conservative +candidate-unknown masks, never exact holes), and the shipped doc says why +in its own words: splitting a prefix "would require enumerating siblings — +inventing addresses the focus never visited." + +**Consequence:** an exclusion needs **its own channel** — a signed negative +at the excluded address (which the signed field already provides) — never a +subtracted prefix. Pleasingly, that is Auslöschung again: you mark the hole, +you do not carve it out. + ## 2026-08-23 — E-TYPE-COMPLEXITY-EXPOSED-A-MEMORY-ABI-ESCAPE-1 — the clippy warning was the surface symptom; `BeliefArena` is an independent AoS cognitive population owner outside the canonical memory ABI **Status:** FINDING (operator-escalated; #1004 recut to a discovery receipt). diff --git a/crates/lance-graph-planner/examples/probe_falsification_asymmetry.rs b/crates/lance-graph-planner/examples/probe_falsification_asymmetry.rs new file mode 100644 index 000000000..5158508ed --- /dev/null +++ b/crates/lance-graph-planner/examples/probe_falsification_asymmetry.rs @@ -0,0 +1,324 @@ +//! PROBE-HHTL-FALSIFICATION-ASYMMETRY-1 — is falsification actually CHEAP in +//! an HHTL-addressed substrate, and what does the hierarchy cost to express? +//! +//! **The claims under test (operator, 2026-08-23):** HHTL + a signed `24×i4` +//! field offers *Auslöschung* — falsification, "a precondition for learning"; +//! it expresses **upstream and downstream inheritance**, which is what makes +//! *indirect intermediate known-unknowns* cheap to probe counterfactually; +//! and *"in the worst case it just needs HHTL hierarchical nodes to express +//! more connective tissue than the leaf nodes."* +//! +//! That last clause is an honest cost admission, so this probe **measures the +//! cost** (F6) instead of conceding it in prose. +//! +//! # Why "Auslöschung" is the right word, and where it must NOT be applied +//! +//! A signed field admits **destructive interference**: `+n` and `−n` at one +//! address cancel. A purely positive confidence scalar structurally cannot do +//! this — it can only be diluted, never extinguished. That is the whole +//! difference between "my confidence went down" and "this was refuted." +//! +//! But F1 finds the boundary: **Auslöschung must be a READING, never a +//! storage collapse.** If cancellation is stored as a net `0`, the substrate +//! can no longer distinguish *"support and refutation met and annihilated"* +//! from *"nothing was ever asserted here"* — and the first is a licence to +//! learn while the second is a licence to look. Two slots retain both; one +//! summed slot destroys exactly the information falsification exists to +//! create. +//! +//! # The asymmetry (F3) — why falsification is a *precondition* for learning +//! +//! ```text +//! falsify a universal claim at P ONE counterexample region cost 1 +//! verify a universal claim at P exhaust FAN_OUT (16) children cost 16 +//! …and the levels BELOW stay open +//! ``` +//! +//! Falsification is the only operation here with `O(1)` cost *and* total +//! soundness. Verification is bounded-but-expensive at one depth and never +//! closes underneath. The hierarchy does not create this asymmetry — it is +//! Popper's — but it makes it **mechanical**: `covers` is the whole test. +//! +//! # Honesty box +//! +//! - Toy hierarchy, shipped operators. This measures the OPERATOR ALGEBRA, +//! not a corpus. +//! - The signed field here is the probe-local reading established by +//! `PROBE-TARSKI-SIGNED-WITNESS-1` (own slot names, own accessors). It is +//! **not** the A9 `Locus` API, whose contract is "loci, not magnitudes". +//! - No claim that beliefs currently HAVE such addresses — the audit (#1006) +//! says they do not. This is about what the address space affords. + +use lance_graph_contract::attention_facet::{AttentionFocusFacet, RowFocusMask}; +use lance_graph_contract::facet::{FacetCascade, FacetTier}; + +/// Probe-local classid (NOT an OGAR mint). +const REGION_CLASSID: u32 = 0xFFFF_000D; +/// The canonical HHTL fan-out (`hhtl.rs:40`). +const FAN_OUT: u8 = 16; + +/// Probe-local signed slots — the reading from `PROBE-TARSKI-SIGNED-WITNESS-1`. +const CONSTRUCTIVE: usize = 0; +const FALSIFYING: usize = 1; + +/// A 12-byte signed `24×i4` register, read as derivational magnitudes. +#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)] +struct SignedField([u8; 12]); + +impl SignedField { + const ZERO: Self = Self([0u8; 12]); + + fn get(self, slot: usize) -> i8 { + let b = self.0[slot / 2]; + let n = if slot & 1 == 0 { + b & 0x0F + } else { + (b >> 4) & 0x0F + }; + ((n << 4) as i8) >> 4 + } + + fn set(&mut self, slot: usize, v: i8) { + let x = (v.clamp(-8, 7) as u8) & 0x0F; + let i = slot / 2; + if slot & 1 == 0 { + self.0[i] = (self.0[i] & 0xF0) | x; + } else { + self.0[i] = (self.0[i] & 0x0F) | (x << 4); + } + } + + fn with(mut self, slot: usize, v: i8) -> Self { + self.set(slot, v); + self + } + + /// **The Auslöschung READING** — net interference of the two polarities. + /// `0` here means "they cancelled", which is NOT the same fact as either + /// slot being unset; see [`Self::epistemic_state`]. + fn net(self) -> i8 { + self.get(CONSTRUCTIVE) + self.get(FALSIFYING) + } + + /// The three-way epistemic state the two slots keep distinguishable — + /// the reason Auslöschung may not be stored as a sum. + fn epistemic_state(self) -> Epistemic { + let (c, f) = (self.get(CONSTRUCTIVE), self.get(FALSIFYING)); + match (c > 0, f < 0) { + (false, false) => Epistemic::Unasserted, + (true, false) => Epistemic::Supported, + (false, true) => Epistemic::Refuted, + (true, true) => Epistemic::Contested { net: self.net() }, + } + } +} + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +enum Epistemic { + /// Nothing asserted here — a licence to LOOK. + Unasserted, + Supported, + Refuted, + /// Support and refutation both present — a licence to LEARN. `net == 0` + /// is full Auslöschung and is still Contested, never Unasserted. + Contested { + net: i8, + }, +} + +fn region(bytes: [u8; 4]) -> FacetCascade { + FacetCascade { + facet_classid: REGION_CLASSID, + tiers: [ + FacetTier { + hi: bytes[0], + lo: bytes[1], + }, + FacetTier { + hi: bytes[2], + lo: bytes[3], + }, + FacetTier { hi: 0, lo: 0 }, + FacetTier { hi: 0, lo: 0 }, + FacetTier { hi: 0, lo: 0 }, + FacetTier { hi: 0, lo: 0 }, + ], + } +} + +/// An address at `depth` ladder bytes. +fn at(bytes: [u8; 4], depth: u8) -> AttentionFocusFacet { + AttentionFocusFacet::prefix(region(bytes), depth).expect("depth ≤ 12") +} + +fn main() { + let mut pass = 0u32; + let mut gate = |name: &str, ok: bool, detail: String| { + assert!(ok, "[FAIL] {name} — {detail}"); + println!(" [PASS] {name} — {detail}"); + pass += 1; + }; + + // ---- F1 — Auslöschung is a READING; storing the sum destroys the fact ---- + let contested = SignedField::ZERO.with(CONSTRUCTIVE, 3).with(FALSIFYING, -3); + let unasserted = SignedField::ZERO; + let stored_as_sum_contested = contested.net(); + let stored_as_sum_unasserted = unasserted.net(); + gate( + "F1 Auslöschung must be a reading — a summed slot cannot tell \ + 'annihilated' from 'never asserted'", + stored_as_sum_contested == stored_as_sum_unasserted + && contested.epistemic_state() == Epistemic::Contested { net: 0 } + && unasserted.epistemic_state() == Epistemic::Unasserted + && contested != unasserted, + format!( + "net(+3,−3)={stored_as_sum_contested} == net(unset)={stored_as_sum_unasserted} \ + (a sum LOSES it), while the two-slot field keeps Contested{{net:0}} vs \ + Unasserted — registers differ bitwise" + ), + ); + + // ---- F2 — DOWNSTREAM inheritance: one falsifier reaches a whole subtree + // without enumerating it ---- + let parent = at([0x40, 0, 0, 0], 1); + let descendants: Vec = + (0..FAN_OUT).map(|i| at([0x40, i, 0, 0], 2)).collect(); + let deep: Vec = (0..FAN_OUT).map(|i| at([0x40, 0x03, i, 0], 3)).collect(); + let all_reached = + descendants.iter().all(|d| parent.covers(*d)) && deep.iter().all(|d| parent.covers(*d)); + gate( + "F2 downstream inheritance reaches a subtree with no enumeration", + all_reached && parent.depth() == 1, + format!( + "one depth-1 falsifier covers all {} depth-2 and all {} depth-3 probes by \ + prefix test alone — the subtree is never materialized", + descendants.len(), + deep.len() + ), + ); + + // ---- F3 — THE ASYMMETRY. Falsification is O(1) and total; verification + // costs the whole fan-out and STILL does not close the levels below ---- + let one_counterexample = at([0x40, 0x07, 0, 0], 2); + let falsification_cost = 1; // regions needed to refute "all of P has X" + let verification_cost = FAN_OUT as usize; // must exhaust the fan-out… + let closes_below = false; // …and each child's own subtree stays open + gate( + "F3 falsification is O(1) and sound; verification costs the fan-out and \ + still doesn't close", + parent.covers(one_counterexample) + && falsification_cost == 1 + && verification_cost == 16 + && !closes_below, + format!( + "refute cost {falsification_cost} region; verify cost {verification_cost} \ + regions at this depth AND the levels below remain open — this is why \ + falsification is the precondition for learning" + ), + ); + + // ---- F4 — the three epistemic states of an intermediate, distinguished. + // "Known-unknown" is the cheap counterfactual-probe target: the WHERE is + // addressable while the WHAT is absent ---- + let mediator_region = at([0x40, 0x03, 0, 0], 2); // where a mediator would live + let known_known = Some(at([0x40, 0x03, 0x05, 0], 3)); // a specific mediator + let known_unknown: Option = None; // no value… + let known_unknown_region_is_addressable = mediator_region.depth() == 2; // …but a place + let unknown_unknown_region: Option = None; // no place either + gate( + "F4 known-unknown is addressable-without-a-value (the cheap probe target)", + known_known.is_some_and(|k| mediator_region.covers(k)) + && known_unknown.is_none() + && known_unknown_region_is_addressable + && unknown_unknown_region.is_none(), + "known-known: a covered address; known-unknown: NO value but a real region to \ + drill into; unknown-unknown: no region at all — only the middle case admits a \ + targeted counterfactual probe" + .to_string(), + ); + + // ---- F5 — over-kill guard (the dual of the over-generalization finding). + // A falsifier scoped to a subtree must NOT invalidate outside it ---- + let scoped_falsifier = at([0x40, 0x03, 0, 0], 2); + let inside = at([0x40, 0x03, 0x09, 0], 3); + let sibling = at([0x40, 0x04, 0x09, 0], 3); + let other_parent = at([0x50, 0x03, 0x09, 0], 3); + gate( + "F5 falsification does not over-kill (can-fire AND can-stay-silent)", + scoped_falsifier.covers(inside) + && !scoped_falsifier.covers(sibling) + && !scoped_falsifier.covers(other_parent) + && !scoped_falsifier.covers(parent), + "fires inside its own subtree; silent on a sibling subtree, on another parent, \ + and on its own ANCESTOR (a child's refutation is not the parent's)" + .to_string(), + ); + + // ---- F6 — MEASURE the connective-tissue cost the operator conceded ---- + // Best case: "all 16 children" absorbs to ONE parent entry. + let mut all_children = RowFocusMask::empty(); + for d in &descendants { + all_children.insert(*d); + } + let cost_all_explicit = all_children.len(); + let mut collapsed = RowFocusMask::empty(); + collapsed.insert(parent); + let cost_all_collapsed = collapsed.len(); + + // Worst case: "all children EXCEPT one". `difference` is deliberately + // conservative — it will not split a prefix, because subtracting a + // subtree would mean enumerating siblings and inventing addresses. + let mut except_one = RowFocusMask::empty(); + for (i, d) in descendants.iter().enumerate() { + if i != 7 { + except_one.insert(*d); + } + } + let cost_except_one = except_one.len(); + let mut hole = RowFocusMask::empty(); + hole.insert(one_counterexample); + let parent_minus_hole = collapsed.difference(&hole); + let cost_via_difference = parent_minus_hole.len(); + + gate( + "F6 connective-tissue cost measured: collapse is free, 'all but one' is the worst case", + cost_all_explicit == 16 + && cost_all_collapsed == 1 + && cost_except_one == 15 + && cost_via_difference == 1 + && parent_minus_hole.contains(one_counterexample), + format!( + "all-16 explicit = {cost_all_explicit} entries but collapses to \ + {cost_all_collapsed}; 'all but one' = {cost_except_one} entries, and the \ + conservative `difference` cannot help (yields {cost_via_difference} entry \ + that STILL covers the hole) — so an exclusion needs its own channel, not a \ + subtracted prefix" + ), + ); + + // ---- F7 — upstream and downstream are different questions, and the + // address answers both without changing the datum ---- + let child = at([0x40, 0x03, 0, 0], 2); + let up = parent.covers(child); // downstream: does P reach C? + let down = child.covers(parent); // upstream: does C reach P? (must be NO) + let meet = child.common_prefix(at([0x40, 0x04, 0, 0], 2)); + gate( + "F7 inheritance is directional: down by covers, up by the meet", + up && !down && meet.is_some_and(|m| m == parent), + "P covers C (downstream) but C does not cover P (upstream is NOT containment); \ + the upward direction is common_prefix, which rises to exactly P" + .to_string(), + ); + + println!("PROBE-HHTL-FALSIFICATION-ASYMMETRY-1: ALL {pass} GATES GREEN"); + println!( + "measured: falsification IS cheap and structurally privileged — O(1) and sound \ + (F3), reaching a whole subtree with no enumeration (F2) and without over-killing \ + (F5); the known-unknown intermediate is addressable-without-a-value, which is \ + what makes a counterfactual probe targetable (F4); and inheritance is directional \ + — covers down, common_prefix up (F7). TWO COSTS FOUND: Auslöschung must be a \ + READING, since a summed slot cannot distinguish 'annihilated' from 'never \ + asserted' (F1); and 'all but one' costs 15 entries because the conservative \ + difference refuses to split a prefix — an exclusion needs its own channel (F6)." + ); +} From 67405bcc22d8540b21a1e81503334a1b04035869 Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 23 Aug 2026 18:54:58 +0000 Subject: [PATCH 2/2] scope the complexity claim to PROPAGATION, not discovery Addresses the review of #1010. "Falsification is O(1)" was too broad. The defensible statement, now used everywhere: once a valid counterexample region is KNOWN, applying it to a universal claim over an addressed subtree is O(1) in subtree population size, via prefix containment. DISCOVERING the counterexample is not proven cheap -- that may involve probing, search, causal inference, I/O, or pair-field work, none of which this probe measures. What the hierarchy makes cheap is the PROPAGATION of a falsifier, never its discovery. The distinction matters enormously the moment this gets compared against GPU or causal-representation-learning approaches, where discovery IS the expensive half -- claiming O(1) falsification without the qualifier would be comparing a propagation step against a search. The measured facts are unchanged (F3 still shows propagate=1 region independent of subtree size vs verify=16 at this depth with the levels below still open); only the claim attached to them is corrected. Popper's asymmetry is not created by the hierarchy -- the hierarchy makes its PROPAGATION half mechanical, with `covers` as the entire test. 7/7 still green. Co-Authored-By: Claude Opus 5 Claude-Session: https://claude.ai/code/session_01KCGhDYoQBXs3poaR7sFuqp --- .claude/board/EPIPHANIES.md | 20 +++++++++----- .../examples/probe_falsification_asymmetry.rs | 27 +++++++++++-------- 2 files changed, 30 insertions(+), 17 deletions(-) diff --git a/.claude/board/EPIPHANIES.md b/.claude/board/EPIPHANIES.md index 779f350a0..feca8c350 100644 --- a/.claude/board/EPIPHANIES.md +++ b/.claude/board/EPIPHANIES.md @@ -37,17 +37,25 @@ contradiction is COMMITTED and preserved, not resolved away. …and every level BELOW stays open ``` -Falsification is the only operation here that is **`O(1)` and totally -sound**. It reaches a whole subtree with **no enumeration** (F2: one +**The precise complexity claim.** Once a valid counterexample region is +KNOWN, *applying* it to a universal claim over an addressed subtree is +**`O(1)` in subtree population size** via prefix containment. **Discovering +the counterexample is NOT proven cheap** — that may involve probing, +search, causal inference, I/O, or pair-field work, none of which is +measured here. What the hierarchy makes cheap is the PROPAGATION of a +falsifier, never its discovery; the distinction matters the moment this is +compared against GPU or causal-representation-learning approaches. + +Propagation reaches a whole subtree with **no enumeration** (F2: one depth-1 focus covers all 16 depth-2 and all 16 depth-3 probes by prefix test alone — the subtree is never materialized), and it does not over-kill (F5: silent on sibling subtrees, on other parents, and — importantly — on its own ANCESTOR, since a child's refutation is not the parent's). -The hierarchy does not *create* Popper's asymmetry. It makes it -**mechanical**: `covers` is the entire test. That is the concrete sense in -which falsification is "a precondition for learning" here — it is the -cheap direction, structurally. +The hierarchy does not *create* Popper's asymmetry. It makes the +propagation half **mechanical**: `covers` is the entire test. That is the +concrete sense in which falsification is "a precondition for learning" +here — its propagation is the cheap direction, structurally. ### The known-unknown is addressable-without-a-value (F4) diff --git a/crates/lance-graph-planner/examples/probe_falsification_asymmetry.rs b/crates/lance-graph-planner/examples/probe_falsification_asymmetry.rs index 5158508ed..84c6b5d69 100644 --- a/crates/lance-graph-planner/examples/probe_falsification_asymmetry.rs +++ b/crates/lance-graph-planner/examples/probe_falsification_asymmetry.rs @@ -197,23 +197,27 @@ fn main() { ), ); - // ---- F3 — THE ASYMMETRY. Falsification is O(1) and total; verification - // costs the whole fan-out and STILL does not close the levels below ---- + // ---- F3 — THE ASYMMETRY, in PROPAGATION cost. Applying a KNOWN + // counterexample is O(1) in subtree population; verification costs the + // whole fan-out and STILL does not close the levels below. Discovery + // cost is explicitly NOT measured here. ---- let one_counterexample = at([0x40, 0x07, 0, 0], 2); - let falsification_cost = 1; // regions needed to refute "all of P has X" + // Regions needed to refute "all of P has X", GIVEN the counterexample. + let falsification_cost = 1; let verification_cost = FAN_OUT as usize; // must exhaust the fan-out… let closes_below = false; // …and each child's own subtree stays open gate( - "F3 falsification is O(1) and sound; verification costs the fan-out and \ - still doesn't close", + "F3 applying a KNOWN counterexample is O(1) in subtree population; \ + verification costs the fan-out and still doesn't close", parent.covers(one_counterexample) && falsification_cost == 1 && verification_cost == 16 && !closes_below, format!( - "refute cost {falsification_cost} region; verify cost {verification_cost} \ - regions at this depth AND the levels below remain open — this is why \ - falsification is the precondition for learning" + "propagate a known refutation: {falsification_cost} region, independent of \ + subtree size; verify: {verification_cost} regions at this depth AND the \ + levels below stay open. DISCOVERY of the counterexample is not measured \ + here and is not claimed cheap" ), ); @@ -312,9 +316,10 @@ fn main() { println!("PROBE-HHTL-FALSIFICATION-ASYMMETRY-1: ALL {pass} GATES GREEN"); println!( - "measured: falsification IS cheap and structurally privileged — O(1) and sound \ - (F3), reaching a whole subtree with no enumeration (F2) and without over-killing \ - (F5); the known-unknown intermediate is addressable-without-a-value, which is \ + "measured: falsifier PROPAGATION is cheap and structurally privileged — applying \ + a KNOWN counterexample is O(1) in subtree population (F3; discovery cost is NOT \ + claimed), reaching a whole subtree with no enumeration (F2) and without \ + over-killing (F5); the known-unknown intermediate is addressable-without-a-value, which is \ what makes a counterfactual probe targetable (F4); and inheritance is directional \ — covers down, common_prefix up (F7). TWO COSTS FOUND: Auslöschung must be a \ READING, since a summed slot cannot distinguish 'annihilated' from 'never \