vaelii.impl.reads — com.vaelii/vaelii 0.24.0

The named entry points onto the index — a read as stored, or a read as believed.

The fourth invariant is that a stored sentex is not a believed one (README.md, "The model in one page"). Every IndexStore posting is storage: it holds a defeated default, a conclusion whose support was withdrawn and a spelling an equality retired, because all three are revivable and the index is not where belief lives. So a caller reading a posting has a question to answer, and until it is asked in the name of the read nothing distinguishes the caller that answered it from the one that forgot.

This namespace is where it is asked. Every raw vaelii.impl.protocols index read outside a short roster of implementers goes through an entry point here, and the entry point's own name says which answer it gives — lein lint's E16 is what keeps that true, and its roster is the one place the exceptions are written down.

The two entry points, and why they take different arguments

• as-stored-… takes the index store. An as-stored read is an index operation, so the entry point's arglist is the protocol method's and nothing else is in scope. A caller reaching one is saying it wants storage: a candidate set it filters itself, a roster that must over-approximate, a diagnostic that reports what is written. Each entry point below says what a stored-but-disbelieved answer is for.
• believed-… takes the KB. Belief lives in the JTMS, so a believed read is a question about the KB and not about the index — which is exactly the distinction the arglists carry. The filter is jtms/in?, which already drops a superseded spelling along with a defeated one (vaelii.impl.jtms's -in?), so a believed entry point means what kb/sentexes-matching means for the handles it yields.

An entry point is a wrapper and never a rewrite: one call to the protocol method it names, the same laziness, the same count-aware path. It adds no index operation, which is what keeps assert_cost_test reading the same numbers on either side of one.

Where there is only one entry point, and why

• The cardinalities (stored-count-…) count a posting set's members. Belief is not in the index, so there is no O(1) believed count and this namespace does not pretend otherwise — a believed count is (count (believed-… …)) and is O(n). The public readers state the same thing (vaelii.core/count-with-functor).
• The vocabulary (stored-terms, stored-term-count) is the roster of names the term index is keyed by. A name enters with the first sentex mentioning it and leaves with the last, so it answers what this KB talks about — a question defeat does not change.
• The watched-rule roster (watched-rule?, watched-rules, watched-rules-on) answers "which rules might need re-checking", never "does the exception hold", and stores no truth value at all (protocols/IndexStore). Filtering it by belief would narrow a re-check queue, and a missed re-check is a wrong belief where an extra one is a query nobody needed.

Two belief questions this namespace does not answer

• A rule's belief is resolution/rule-believed? and not jtms/in?: a sentex the TMS holds no node for is available rather than disbelieved, which is an arm a plain membership test does not have. So as-stored-rules-by-antecedent and its consequent twin have no believed sibling here, and a chainer asks res/rule-believed? of each handle it means to fire.
• resolution/*belief-blind* is not read here. It is a named opt-out scoped to the retrieval entry point that resolves CxEverything, and no caller of these entry points is on that path — an entry point that consulted it would extend the opt-out to reads nobody granted it to.

as-stored-at-path clj

(as-stored-at-path index pattern)

Handles whose trie path matches pattern — one walk, no records fetched, nothing interpreted. A variable token in the path is a wildcard that fans over every child.

The rawest read the index has. Level 0 of vaelii.impl.levels addresses the trie directly and interprets neither belief nor polarity, which is what makes it the floor the other levels are measured against, and vaelii.impl.decide reads one exact sentence under every context to find a stored converse.

as-stored-contexts-with-functor clj

(as-stored-contexts-with-functor index pred contexts)

[seen n]: the contexts of the set contexts (every context when nil) in which a fact with functor pred is stored, either polarity, and how many contexts state one — the predicate extent's children, no handle read and no belief consulted — or nil for an index store that keeps no extent this can reach (kv/extent-census). Costs one count read, then min(|contexts stating one|, |contexts|) membership probes when it is not zero. A defeated fact keeps its context listed, so the answer is for a caller that must over-approximate where pred is stated.

as-stored-in-context clj

(as-stored-in-context index context)

Handles stored in context — its whole extent, rules included, belief unread.

A stored-but-disbelieved answer is what a caller wants here when it is about the contents of a context rather than about what holds in it: a teardown that must remove every record it finds, an ancestor set sweep that fetches each record and decides on the record, a level-1 diagnostic reporting what the root holds.

as-stored-installed-keys clj

(as-stored-installed-keys index h)

The taxonomy keys stored handle h installs, as a set, belief unread: the keys a reconcile re-examines when h's label moves. One read.

as-stored-mint-contexts clj

(as-stored-mint-contexts index)

The contexts some filed mint is stored in, as a set.

as-stored-mint-terms clj

(as-stored-mint-terms index)

The terms some filed mint is about, as a set.

as-stored-mints-about clj

(as-stored-mints-about index term)

Handles of the mints filed about term, in every context.

as-stored-mints-in clj

(as-stored-mints-in index c)

Handles of the mints filed in context c. One leaf read.

as-stored-named clj

(as-stored-named index functor)

The handles the positive (functor (sentexHandle H)) facts stored in any context name, as a set: the children of the trie's [functor m sentexHandle] level. Where the trie is a KvIndexStore's the set is the one the backend holds (kv/children-held), so two reads with no write between them answer one object on the map backends.

as-stored-naming clj

(as-stored-naming index functor h)

(as-stored-naming index functor h contexts)

The handles of the positive (functor (sentexHandle h)) facts stored in a context of contexts (every context when nil), as a vector, or nil when there is none. The children under the prefix are filtered by contexts before a leaf is read, so a context outside contexts costs a membership test.

as-stored-naming-by-context clj

(as-stored-naming-by-context index functor h)

The positive (functor (sentexHandle h)) facts stored, as one [context handles] pair per context stating one: the children under the prefix and the leaf under each.

as-stored-opposed-bodies clj

(as-stored-opposed-bodies index)

Every body stored in both polarities, as a set.

as-stored-opposed-in clj

(as-stored-opposed-in index contexts)

The handles of the facts of every body stored in both polarities that are stated in a context of contexts, belief unread: |contexts| leaf reads.

as-stored-opposed-members clj

(as-stored-opposed-members index body)

The handles of body's facts of both polarities while it is stored in both, in every context, belief unread; empty when it is not.

as-stored-predicates-at-arg clj

(as-stored-predicates-at-arg index pos term)

The predicates holding a stored fact, either polarity, with term at argument pos — the slot roster's entry, no handle read and no belief consulted — or nil for an index store that keeps no roster this can reach (kv/slot-predicates).

A roster read rather than a posting read, so it names predicates where the other entry points here name handles. A predicate enters with its first stored fact at the slot and leaves with its last, so a defeated claim keeps it listed: the answer is for a caller that must over-approximate which predicates a term could be claimed under.

as-stored-rule-keys clj

(as-stored-rule-keys index)

The antecedent keys some stored rule takes (rules/antecedent-key), as a set: the root level of the :rule-antecedent trie (kv/rule-keys).

as-stored-rules-by-antecedent clj

(as-stored-rules-by-antecedent index pred)

Handles of rules with an antecedent on pred — every rule, whatever its direction, belief unread.

Belief for a rule is resolution/rule-believed? and not jtms/in?, which is why there is no believed entry point beside this one: a rule the TMS holds no node for is available rather than disbelieved, and a chainer asks that question of each handle it means to fire.

as-stored-rules-by-consequent clj

(as-stored-rules-by-consequent index pred)

Handles of rules concluding pred — every rule, whatever its direction, belief unread.

resolution/rule-believed? is the belief question, as for the antecedent entry point above. A rule whose consequent functor is a variable files under protocols/var-consequent-key rather than under a canonical ?var0, so a concrete goal's answer is this bucket unioned with that catch-all (resolution/concluding-rule-handles).

as-stored-rules-in clj

(as-stored-rules-in index kind contexts)

Handles of the stored rules of kind stated in one of contexts (every context when nil): :rule for every rule, :solve for the rules a solve reads (rules/solve-sentex?). The rule extent ends in the context, so this costs min(|contexts stating one|, |contexts|) probes plus a leaf read per context kept.

as-stored-self-tuples clj

(as-stored-self-tuples index f contexts)

The handles of the stored ground positive binary self tuples (f a a) of functor f stated in a context of contexts (every context when nil), belief unread (kv/self-tuples).

as-stored-shape-lengths clj

(as-stored-shape-lengths index f)

The lengths the positive facts of functor f are stored at, as a set, belief unread: one roster read (kv/shape-lengths). A length leaves with its last fact.

as-stored-supporter-map clj

(as-stored-supporter-map index)

Every taxonomy key with a stored supporter, as {k {handle ctx}}, by a walk of the whole store (kv/all-supporters): a raw taxonomy's reads, whose private store holds the supporter families and nothing else.

as-stored-supporters clj

(as-stored-supporters index k)

The stored supporters of taxonomy key k ([:genl a b], [:genlCx a b] or a flat-cache key) as {handle ctx}, belief unread (kv/supporters): the taxonomy decides an entry's belief from them, and a disbelieved supporter stays listed so that its revival can bring the entry back. {} for an index store this finds no roots store in.

as-stored-unary-multi-terms clj

(as-stored-unary-multi-terms index)

The terms the unary roster lists two or more predicates of, as a set, belief unread (kv/unary-multi-terms): a superset of the terms holding two stored memberships.

as-stored-with-arg clj

(as-stored-with-arg index pos term)

Handles of fact sentexes holding term at 1-based argument pos — belief unread.

The argument root is scoped by predicate, so this is the narrow read a pattern pinning an argument after a variable wants. Same shape as as-stored-with-functor: a candidate set whose consumer decides per record.

as-stored-with-args clj

(as-stored-with-args index pred pos-terms)

Handles with functor pred AND each [pos term] of pos-terms, belief unread: the intersection of pred's argument-root nodes at the named positions, or the predicate extent when pos-terms is empty. pred may be nil, for a variable-functor pattern.

as-stored-with-functor clj

(as-stored-with-functor index pred)

Handles of fact sentexes whose functor is pred, any arity, either polarity — belief unread.

The candidate-set read: a caller narrowing by predicate almost always fetches each record and decides on its polarity, its context and its belief together, and doing so one handle at a time is cheaper than two passes over the same set. A caller whose filter is belief alone takes believed-with-functor instead.

as-stored-with-functor-in clj

(as-stored-with-functor-in index pred contexts)

as-stored-with-functor restricted to the facts stated in one of contexts — a reader's ancestor set, or nil for every context. The predicate extent ends in the context, so this costs min(|contexts stating one|, |contexts|) membership probes plus one leaf read per context kept (docs/indexing.md, "By-context reads").

as-stored-with-term clj

(as-stored-with-term index term)

Handles the inverted term index keys by term — belief unread.

Exact for a symbol; for a compound outside the indexed depth bounds it holds only the sentexes that nest it deep enough, so kb/find-sentexes is the exact read for one. The postings are a candidate set in both cases: a term appears in a sentence the reader then has to look at.

as-stored-with-terms clj

(as-stored-with-terms index terms)

Handles the inverted term index keys by every one of terms, one intersection — belief unread. A candidate set, as as-stored-with-term's is.

believed-with-args clj

(believed-with-args kb pred pos-terms)

Handles with functor pred AND each [pos term] of pos-terms that the KB believes — as-stored-with-args filtered by jtms/in?, lazily.

The narrowing read's believed entry point: a caller that knows several of a sentence's terms and wants only what holds asks here rather than intersecting and then filtering by hand.

believed-with-functor clj

(believed-with-functor kb pred)

Handles of fact sentexes with functor pred that the KB believes — the extent above, filtered by jtms/in?.

Lazy, as the posting read is: the filter is applied as the seq is walked, so a consumer taking a prefix pays a TMS probe per handle it takes and not per handle in the root. A superseded spelling drops out with a defeated one, since that is what in? answers.

stored-census-with-arg clj

(stored-census-with-arg index pred pos term)

[n k]: how many facts with functor pred and term at argument pos are stored, in every context, and in how many contexts, or nil where as-stored-contexts-with-functor is nil. Two count reads.

stored-count-at clj

(stored-count-at index prefix)

How many sentexes are stored under trie prefix prefix — the count-aware trie's own tally, no walk. [] is the whole KB.

stored-count-children clj

(stored-count-children index prefix)

How many child tokens sit under interior prefix prefix — the trie's distinct-value count at a position, answered without building the child set.

What the planner's cost model divides by, so it must not scale with the KB: (count (stored-children …)) would, and this does not.

stored-count-in-context clj

(stored-count-in-context index context)

How many sentexes are stored in context — one set-size read, O(1), nothing fetched and no belief consulted. A defeated default still occupies its context.

stored-count-with-arg clj

(stored-count-with-arg index pos term)

How many fact sentexes store term at argument position pos — one O(1) set-size read per predicate declaring an argument at that slot, since the argument roots are scoped by predicate.

stored-count-with-arg-in clj

(stored-count-with-arg-in index pred pos term contexts)

How many facts with functor pred and term at argument pos are stored in the contexts of contexts: one leaf count per context the argument node lists and contexts holds, or nil where as-stored-contexts-with-functor is nil.

stored-count-with-functor clj

(stored-count-with-functor index pred)

How many fact sentexes are stored with functor pred — one set-size read, O(1).

The gate in front of nearly every definitional check in the engine: a KB that declares none of a feature's predicates pays one integer read and stops, which is what keeps an unused feature off the assert path.

stored-count-with-functor-in clj

(stored-count-with-functor-in index pred contexts)

How many facts with functor pred are stored in the contexts of contexts: one leaf count per context stating one, or nil where as-stored-contexts-with-functor is nil.

stored-mint-context-count clj

(stored-mint-context-count index)

How many contexts some filed mint is stored in. One count read.

stored-mint-count clj

(stored-mint-count index)

How many records are filed as mints. One count read.

stored-mint-term-count clj

(stored-mint-term-count index)

How many terms some filed mint is about. One count read.

stored-mint-term? clj

(stored-mint-term? index term)

Is some filed mint about term? One membership test.

stored-mint? clj

(stored-mint? index term c h)

Is record h filed as a mint about term in context c? One membership test.

stored-naming? clj

(stored-naming? index functor h)

Is a positive (functor (sentexHandle h)) stored in any context? One count read.

stored-opposed? clj

(stored-opposed? index body)

Is body stored in both polarities? One membership read, belief unread.

stored-rule-key? clj

(stored-rule-key? index k)

Does a stored rule take the antecedent key k? One membership test.

stored-supporter-count clj

(stored-supporter-count index k)

How many stored handles support taxonomy key k: one count read.

stored-term-count clj

(stored-term-count index)

How many distinct symbol terms the index is keyed by — the roster's own count, no walk over it.

stored-terms clj

(stored-terms index)

Every symbol term the index is keyed by — the KB's vocabulary, unordered.

A name is in this roster while some stored sentex mentions it, so it answers what the KB talks about rather than what it currently holds: defeating the one fact about a term does not unname the term.

stores-any? clj

(stores-any? index functor)

Is a positive (functor …) fact stored in any context? One count read on the trie's [functor], belief unread.

stores-in? clj

(stores-in? index pred contexts)

Does a context of contexts store a fact of functor pred, either polarity? The predicate extent's children intersected with contexts, no leaf read (kv/extent-contexts), belief unread.

stores-opposed? clj

(stores-opposed? index)

Is any body stored in both polarities? One count read, belief unread.

stores-rule-in? clj

(stores-rule-in? index contexts)

Does a context of contexts store a rule? The rule extent's children intersected with contexts, no leaf read.

watched-rule? clj

(watched-rule? index handle)

Is handle in the exception/watched-rule roster — O(1) membership, the firing-path gate.

The roster stores no truth value, so there is no second entry point: it answers which rules carry an exceptWhen at all, never whether one holds. Whether the exception fires is provers/exceptions-block?, and whether the rule itself is believed is resolution/rule-believed?.

watched-rules clj

(watched-rules index)

Handles of every rule carrying a re-check condition — an exception, an (unknown S) antecedent, an aggregate, a closed-extent negative or a different antecedent (rules/rechecked?).

Read to queue re-checks, which is why belief is not filtered: over-queueing costs a query at the next settle and under-queueing leaves a conclusion standing on evidence that has moved. A trigger is conservative in the direction the answer is.

watched-rules-on clj

(watched-rules-on index pred)

Handles of rules whose re-check condition mentions pred — the predicate-scoped slice of watched-rules, and unfiltered for its reason.