Struct InfonIndex 

pub struct InfonIndex<B: Postings> { /* private fields */ }

Implementations

impl<B: Postings> InfonIndex<B>

pub fn from_postings(raw: HashMap<String, Vec<u32>>, n: u32) -> Self

Build from token -> ascending sids. Callers accumulate sids in id order during a scan.

pub fn add_infon_polar(&mut self, sid: u32, token: &str, level: f32)

Record a token membership at sid with a Dempster-Shafer polarity level ∈ {-1, -0.5, +0.5, +1} (paper §4). +1 strong-for, +0.5 weak-for, -0.5 weak-against, -1 strong-against. Presence is always asserted; sign/magnitude are stored in the neg/weak auxiliary sets.

pub fn signed_mass(&self, token: &str, scope: &B) -> f64

SIMD belief aggregation (paper §4.1): net signed mass of token over scope, computed as a weighted POPCNT over roaring sets — +1·|strong-for| +0.5·|weak-for| −0.5·|weak-against| −1·|strong-against|, all within scope ∩ post(token).

pub fn evidence_set(&self, token: &str, min_bel: f64) -> B

Situations where token holds with per-situation belief ≥ min_bel, using the discrete level map (+1→1.0 strong-for, +0.5→0.5 weak-for, present→>0). Powers IKL (evidence … :min-bel b).

pub fn belief_interval(&self, token: &str, scope: &B) -> (f64, f64)

Dempster-Shafer belief interval [Bel, Pl] for token over scope (paper §4.1): Bel = fraction of scope with strong-for evidence (lower certainty bound); Pl = fraction not strongly refuted (upper bound 1 − Bel(¬A)). Returns (bel, pl) in [0,1].

pub fn add_number(&mut self, sid: u32, field: &str, value: f64)

Record a numeric field value for a situation (columnar numeric layer).

pub fn numeric_fields(&self) -> impl Iterator<Item = &String>

Numeric fields present (for schema/agent discovery).

pub fn add(&mut self, tokens: &[String]) -> u32

Append one situation’s tokens as a new sid (incremental / realtime ingest). Tokens should be de-duplicated by the caller. Returns the new sid.

pub fn vocab_size(&self) -> usize

pub fn tokens(&self) -> impl Iterator<Item = &String>

pub fn post(&self, token: &str) -> B

The posting set for an exact token (clone; empty if absent). Unlike atom, no glob handling — the analytics programs address concrete tokens they discovered from the vocabulary.

pub fn post_len(&self, token: &str) -> usize

pub fn facet_members(&self, facet: &str) -> Vec<&String>

Every token under a facet (first path segment), unsorted and untruncated — the analytics programs partition/rank over the full facet, not just the top-N tokens_in_facet returns.

pub fn tokens_in_facet(&self, facet: &str, limit: usize) -> Vec<(String, usize)>

The most frequent tokens under a facet, with posting sizes — so an agent can learn the queryable vocabulary of a facet before composing IKL.

pub fn postings(&self) -> impl Iterator<Item = (&String, &B)>

Every (tag, postings) pair in the symbol table — the incidence matrix, row by row.

pub fn situations(&self) -> u32

pub fn postings_native_bytes(&self) -> usize

Total native bytes across all postings (memory proxy for the chosen backend).

pub fn postings_deltagap_bytes(&self) -> usize

Total portable delta-gap bytes (same for every backend — the on-disk posting size).

impl<B: Postings> InfonIndex<B>

pub fn s_path_tokens(&self, a: &str, b: &str, s: usize) -> Option<Vec<String>>

Tokens on an s-path from a to b: a chain where consecutive tokens share at least s situations (paper §3.3). Returns None when either endpoint is unknown or no such chain exists.

Raising s is what suppresses semantic drift — at s = 1 a single shared situation links two tokens, which lets a walk wander somewhere unrelated to where it began.

Breadth-first, so the chain found is the shortest. Neighbour discovery scans the symbol table, which is linear per expansion; the paper’s answer to that cost is to filter the scope first, and the (constraint …) clause in the query form is how a caller does it.

Trait Implementations

impl<B: Postings> TokenStore<B> for InfonIndex<B>

fn evidence(&self, token: &str, min_bel: f64) -> B

The evidence atom of §6.1, backed by the polarity layer: situations where this token holds with per-situation belief at or above the threshold. The trait default is plain membership, which would ignore polarity entirely and quietly include refuted situations.

fn s_path(&self, a: &str, b: &str, s: usize) -> Option<B>

The situations an s-path passes through: the union of the postings of the tokens on the chain, so the result composes with the rest of the set algebra.

fn atom(&self, pattern: &str) -> B

fn universe(&self) -> B

fn numeric(&self, field: &str, op: &str, value: f64) -> B

Situations whose numeric field satisfies field op value (op ∈ ge|gt|le|lt|eq|ne). Stores without a numeric layer return empty.