The visibility except roster: which handles a believed except hides from a
reading context, with the meta-except cascade; and the read walk that applies the
placed defeats at a reader. See docs/exceptions.md and docs/nmtms.md.
The visibility `except` roster: which handles a believed `except` hides from a reading context, with the meta-except cascade; and the read walk that applies the placed `defeat`s at a reader. See docs/exceptions.md and docs/nmtms.md.
The second-route answers of the read that opened the search, a volatile map, while a
search runs, and nil outside one. A read nested in the search answers its own second
routes into the same map, so a route met again on one path reads as not reaching
(route-answer).
The second-route answers of the read that opened the search, a volatile map, while a search runs, and nil outside one. A read nested in the search answers its own second routes into the same map, so a route met again on one path reads as not reaching (`route-answer`).
True while a read that names no reader is answered unscoped (vantage/answers with
nothing to witness, or no reader to fan over): hidden-fn of a variable context then
answers own-hidden-fn, so the read believes a handle as its own context does. False
for the engine's own unscoped joins, which read the network.
True while a read that names no reader is answered unscoped (`vantage/answers` with nothing to witness, or no reader to fan over): `hidden-fn` of a variable context then answers `own-hidden-fn`, so the read believes a handle as its own context does. False for the engine's own unscoped joins, which read the network.
(belief-hidden-fn kb view-context)A predicate (fn [handle]) answering whether view-context does not believe handle,
IN in the network, by the placed defeats it sees (defeat-hidden-fn, belief only), or
nil when the walk reads nothing there. An except is visibility and is not applied.
A predicate `(fn [handle])` answering whether `view-context` does not believe `handle`, IN in the network, by the placed defeats it sees (`defeat-hidden-fn`, belief only), or nil when the walk reads nothing there. An `except` is visibility and is not applied.
(belief-only-antecedent j)The antecedent justification j rests on for belief and not for visibility, or nil.
A reader's copy has one: [original equality except] under informant except
(special/migrate-sentex) is stored in a context that reads the except, so the equality
is hidden wherever the copy is read, and that hiding is the copy's reason rather than a
withdrawal of it. The read walk adds the placed nogood's own loser
(placed-belief-only).
The antecedent justification `j` rests on for belief and not for visibility, or nil. A reader's copy has one: `[original equality except]` under informant `except` (`special/migrate-sentex`) is stored in a context that reads the except, so the equality is hidden wherever the copy is read, and that hiding is the copy's reason rather than a withdrawal of it. The read walk adds the placed nogood's own loser (`placed-belief-only`).
(believed-own? kb handle)Is handle believed as the context it is stored in reads it: IN in the network and
not removed there (own-hidden-fn)? The answer of every read that names no reader.
Is `handle` believed as the context it is stored in reads it: IN in the network and not removed there (`own-hidden-fn`)? The answer of every read that names no reader.
(closure-excepted-anywhere? kb handle)Is handle hidden from at least one context by the excepts alone
(except-closure-hidden-fn)? Reads the excepts naming a handle of its support and the
contexts stating them, so it costs the support and not the standing excepts on other
targets.
Is `handle` hidden from at least one context by the excepts alone (`except-closure-hidden-fn`)? Reads the excepts naming a handle of its support and the contexts stating them, so it costs the support and not the standing excepts on other targets.
(defeat-hidden-fn kb ctx with-excepts?)A predicate (fn [handle]) answering whether ctx reads handle, IN in the network, as
removed by the placed defeats it sees, or nil when no defeat is stored. With
with-excepts? false this is belief: handle is not believed at ctx. With it true
it is visibility as well: the excepts in force at ctx are forced OUT beside the
defeats, so a handle resting on an excepted handle and a defeated one is hidden.
A defeat is in force at ctx while it is IN, stated in a context ctx sees, not hidden
by an except in force, its nogood's verdict at ctx names its target
(decide/verdict), and it is believed and seen at ctx with its own target exempt.
The predicate holds a memo for its own lifetime and nothing past it.
A predicate `(fn [handle])` answering whether `ctx` reads `handle`, IN in the network, as removed by the placed defeats it sees, or **nil** when no defeat is stored. With `with-excepts?` false this is belief: `handle` is not believed at `ctx`. With it true it is visibility as well: the excepts in force at `ctx` are forced OUT beside the defeats, so a handle resting on an excepted handle and a defeated one is hidden. A defeat is in force at `ctx` while it is IN, stated in a context `ctx` sees, not hidden by an except in force, its nogood's verdict at `ctx` names its target (`decide/verdict`), and it is believed and seen at `ctx` with its own target exempt. The predicate holds a memo for its own lifetime and nothing past it.
(defeat-member-sets kb d)The member sets of the placed nogoods whose defeat is the handle d, one per nogood
in content order of their (contradicts …), or nil.
The member sets of the placed nogoods whose `defeat` is the handle `d`, one per nogood in content order of their `(contradicts …)`, or nil.
(defeated-anywhere? kb handle)Can a placed defeat remove handle from some context's belief: a stored defeat names
a handle of its support? One count read per handle of the support, and none on the
standing defeats on other targets.
Can a placed defeat remove `handle` from some context's belief: a stored `defeat` names a handle of its support? One count read per handle of the support, and none on the standing defeats on other targets.
(defeats-hiding kb handle ctx)The defeats in force at ctx whose targets lie in handle's support, and the placed
conflicts ctx decides against a handle there (conflicts-naming), in content order:
what defeat-hidden-fn forced OUT to read handle as not believed there.
The defeats in force at `ctx` whose targets lie in `handle`'s support, and the placed conflicts `ctx` decides against a handle there (`conflicts-naming`), in content order: what `defeat-hidden-fn` forced OUT to read `handle` as not believed there.
(defeats-of kb handle ctx)The defeats naming handle that are in force at ctx, and the placed conflicts ctx
decides against it (conflicts-naming), in content order.
The defeats naming `handle` that are in force at `ctx`, and the placed conflicts `ctx` decides against it (`conflicts-naming`), in content order.
(except-closure-hidden-fn kb ctx)(except-closure-hidden-fn kb ctx read?)A predicate (fn [handle]) answering whether ctx reads handle, IN in the network, as
hidden by the excepts alone: an except in force there names it, or names a handle every
justification route of it rests on. nil when no context of ctx's ancestor set
states an except (except-hidden-fn). What a placement reads, a firing's and a
nogood's alike: the except roster and the network, and no defeat. With read?, the
visibility a read asks, a firing that rests on an excepted witness edge stands where
ctx reaches the path's ends another way (rerouted). The predicate holds a memo for
its own lifetime.
A predicate `(fn [handle])` answering whether `ctx` reads `handle`, IN in the network, as hidden by the excepts alone: an except in force there names it, or names a handle every justification route of it rests on. **nil** when no context of `ctx`'s ancestor set states an except (`except-hidden-fn`). What a placement reads, a firing's and a nogood's alike: the `except` roster and the network, and no `defeat`. With `read?`, the visibility a read asks, a firing that rests on an excepted witness edge stands where `ctx` reaches the path's ends another way (`rerouted`). The predicate holds a memo for its own lifetime.
(except-hidden-fn kb view-context)A predicate (fn [handle]) -> boolean answering, for one view-context, what
excepted-handles answers as a set, or nil when no context of its ancestor set
states an except. The nil is a storage gate, not a belief one: excepts that are all
defeated still give a predicate, which answers false. The gate reads the except
extent, which holds both polarities, so a stored (not (except …)) in a context of the
set gives a predicate too. This is the excepts alone, which a derivation asks
(chain/antecedent-hidden?); a read asks exc/hidden-fn. The predicate reads the
excepts naming the asked handle, and the cascade over the excepts naming those.
A predicate `(fn [handle]) -> boolean` answering, for one `view-context`, what `excepted-handles` answers as a set, or **nil** when no context of its ancestor set states an except. The nil is a storage gate, not a belief one: excepts that are all defeated still give a predicate, which answers false. The gate reads the `except` extent, which holds both polarities, so a stored `(not (except …))` in a context of the set gives a predicate too. This is the excepts alone, which a derivation asks (`chain/antecedent-hidden?`); a read asks `exc/hidden-fn`. The predicate reads the excepts naming the asked handle, and the cascade over the excepts naming those.
(except-roster kb)supporter-roster over the stored excepts alone: what a firing's witness search
reads (tax/*network-belief*).
`supporter-roster` over the stored `except`s alone: what a firing's witness search reads (`tax/*network-belief*`).
(excepted-handles kb view-context)The handles a believed except in force hides from view-context, read off the
except extent over its ancestor set (docs/contexts.md, "except"). Empty when
nothing is excepted, and for a variable view-context, since an except hides its
target below its own context and not above it. A caller asking about particular
handles asks except-hidden-fn or excepted? instead.
The handles a believed `except` in force hides from `view-context`, read off the `except` extent over its ancestor set (docs/contexts.md, "except"). Empty when nothing is excepted, and for a variable `view-context`, since an except hides its target below its own context and not above it. A caller asking about particular handles asks `except-hidden-fn` or `excepted?` instead.
(excepted-in-network? kb handle view-context)Is handle hidden from view-context by the excepts alone
(except-closure-hidden-fn)? What a placement reads, a firing's and a nogood's: the
except roster and the network, and no defeat.
Is `handle` hidden from `view-context` by the excepts alone (`except-closure-hidden-fn`)? What a placement reads, a firing's and a nogood's: the `except` roster and the network, and no `defeat`.
(excepted? kb handle view-context)Is the sentex at handle hidden from view-context (hidden-fn)? The one-shot form,
for a caller with a single handle to ask about.
Is the sentex at `handle` hidden from `view-context` (`hidden-fn`)? The one-shot form, for a caller with a single handle to ask about.
(exception-status kb handle view-context)Diagnostic exception forest for handle from view-context.
Returns {:exceptions [...] :excepted? bool}. Roots are every visible exception
directly targeting handle, ordered by assertion context and content; nested
meta-exceptions live under :excepted-by. Reads the excepts naming handle and,
through the cascade, those naming them, and no others.
Diagnostic exception forest for `handle` from `view-context`.
Returns `{:exceptions [...] :excepted? bool}`. Roots are every visible exception
directly targeting `handle`, ordered by assertion context and content; nested
meta-exceptions live under `:excepted-by`. Reads the excepts naming `handle` and,
through the cascade, those naming them, and no others.The informant of every justification a guard defeat stores
(chain/place-guard-defeats!): a firing's exceptWhen or unknown that holds below its
placement.
The informant of every justification a guard defeat stores (`chain/place-guard-defeats!`): a firing's `exceptWhen` or `unknown` that holds below its placement.
(hidden-fn kb view-context)A predicate (fn [handle]) -> boolean answering whether view-context does not see
handle, or nil when it hides nothing. Every belief-filtered read with a concrete
context asks this. An except in force naming handle hides it
(except-hidden-fn); for a handle IN in the network, so does resting only on an
excepted handle (except-closure-hidden-fn), or not being believed there by the placed
defeats (defeat-hidden-fn with the excepts). Nil stays the O(1) gate for the KB that
excepts nothing and holds no placed nogood. A variable context under *unscoped-own*
answers own-hidden-fn. Inside a second-route search for a belief read (tax/*search*
:belief) this answers belief-hidden-fn. Under the network reading
(tax/*network-belief*), the one a placement in chain reads, no defeat is read and
the excepts alone hide.
A predicate `(fn [handle]) -> boolean` answering whether `view-context` does not see `handle`, or **nil** when it hides nothing. Every belief-filtered read with a concrete context asks this. An except in force naming `handle` hides it (`except-hidden-fn`); for a handle IN in the network, so does resting only on an excepted handle (`except-closure-hidden-fn`), or not being believed there by the placed defeats (`defeat-hidden-fn` with the excepts). Nil stays the O(1) gate for the KB that excepts nothing and holds no placed nogood. A variable context under `*unscoped-own*` answers `own-hidden-fn`. Inside a second-route search for a belief read (`tax/*search*` `:belief`) this answers `belief-hidden-fn`. Under the network reading (`tax/*network-belief*`), the one a placement in `chain` reads, no defeat is read and the excepts alone hide.
(in-force-targets kb target->ehs)The targets of target->ehs (visible-exception-index's answer) that an except in
force hides, as a set: excepted-handles over a roster its caller already read.
The targets of `target->ehs` (`visible-exception-index`'s answer) that an except in force hides, as a set: `excepted-handles` over a roster its caller already read.
(install-route-reach! reach goals goal-reach)Register the walks a second route is read through: reach, which route-reaches? asks
for a path over a fact relation, and goals and goal-reach, a rule firing's goals and
the backward search for one (firing-reach). vaelii.impl.inherit's, once, when it
loads. Global, as the walks dispatch on the kb they are handed.
Register the walks a second route is read through: `reach`, which `route-reaches?` asks for a path over a fact relation, and `goals` and `goal-reach`, a rule firing's goals and the backward search for one (`firing-reach`). `vaelii.impl.inherit`'s, once, when it loads. Global, as the walks dispatch on the `kb` they are handed.
The informant of every justification a placed nogood stores (chain/place-nogood!).
The informant of every justification a placed nogood stores (`chain/place-nogood!`).
(own-hidden-fn kb)A predicate (fn [handle]) answering whether handle, IN in the network, is not
believed at the context it is stored in (defeat-hidden-fn there, belief only), or nil
when the walk reads nothing (walk-reads?). The belief filter of every read that names
no reader (docs/nmtms.md, "A read with no reader").
A predicate `(fn [handle])` answering whether `handle`, IN in the network, is not believed at the context it is stored in (`defeat-hidden-fn` there, belief only), or nil when the walk reads nothing (`walk-reads?`). The belief filter of every read that names no reader (docs/nmtms.md, "A read with no reader").
(own-seq s)s, realized under *unscoped-own* one element at a time: a read that names no
context answers as each handle's own context believes it.
`s`, realized under `*unscoped-own*` one element at a time: a read that names no context answers as each handle's own context believes it.
(placed-reads? kb)Does a read owe the walk over the placed nogoods (defeat-hidden-fn): a defeat is
stored, or a placed (contradicts …) beside a stored except, which can lower a
member's class at the reader that sees it (conflict-loser?).
Does a read owe the walk over the placed nogoods (`defeat-hidden-fn`): a `defeat` is stored, or a placed `(contradicts …)` beside a stored `except`, which can lower a member's class at the reader that sees it (`conflict-loser?`).
(support tms h stop?)(support tms h stop? past-premises?)(support tms h stop? past-premises? limit)h and its justification ancestors: every handle a justification of one of them rests
on, transitively, not descending past a premise unless past-premises?, and leaving
out each handle stop? names, which the read takes at its label. A premise's other
justifications decide its class, not its belief, so only a class read descends past
it. With limit, nil once the support holds more than limit handles.
`h` and its justification ancestors: every handle a justification of one of them rests on, transitively, not descending past a premise unless `past-premises?`, and leaving out each handle `stop?` names, which the read takes at its label. A premise's other justifications decide its class, not its belief, so only a class read descends past it. With `limit`, nil once the support holds more than `limit` handles.
(supporter-roster kb)What the taxonomy's whole-KB gate callback answers for a reader's belief
(tax/install-supporter-visibility!): nil when no except and no defeat is stored,
else the entries [::defeated targets] and [::excepted targets], each the set of
handles the stored facts of that functor name. Two reads on the index.
What the taxonomy's whole-KB gate callback answers for a reader's belief (`tax/install-supporter-visibility!`): nil when no `except` and no `defeat` is stored, else the entries `[::defeated targets]` and `[::excepted targets]`, each the set of handles the stored facts of that functor name. Two reads on the index.
(verdict-at-reader kb members ctx)decide/verdict over the placed nogood members as ctx reads it (verdict-at): the
network's classes, or those ctx's excepts leave; the network's verdict when the walk
reads nothing at ctx (reader-state).
`decide/verdict` over the placed nogood `members` as `ctx` reads it (`verdict-at`): the network's classes, or those `ctx`'s excepts leave; the network's verdict when the walk reads nothing at `ctx` (`reader-state`).
(visible-exception-index kb view-context)The excepts stated in a context of view-context's ancestor set, as {target-handle -> #{except-handle ...}}, or nil when none is stated there or view-context is a
variable: the except extent in that set, one record read per except. Both the hot
boolean reads and diagnostic exception forest use this one index so they cannot
disagree about scope.
The excepts stated in a context of `view-context`'s ancestor set, as `{target-handle ->
#{except-handle ...}}`, or nil when none is stated there or `view-context` is a
variable: the `except` extent in that set, one record read per except. Both the hot
boolean reads and diagnostic exception forest use this one index so they cannot
disagree about scope.(walk-reads? kb)Does a belief-filtered read owe the walk (defeat-hidden-fn): placed-reads?, or a
placement the reader can exempt (exemption-reads?).
Does a belief-filtered read owe the walk (`defeat-hidden-fn`): `placed-reads?`, or a placement the reader can exempt (`exemption-reads?`).
(without-excepted kb view-context matches)Drop the [handle …] matches whose handle view-context does not see (hidden-fn),
and answer the identical seq when it hides nothing, which is almost every read of
almost every KB.
Drop the `[handle …]` matches whose handle `view-context` does not see (`hidden-fn`), and answer the **identical seq** when it hides nothing, which is almost every read of almost every KB.
cljdoc builds & hosts documentation for Clojure/Script libraries
| Ctrl+k | Jump to recent docs |
| ← | Move to previous article |
| → | Move to next article |
| Ctrl+/ | Jump to the search field |