The visibility except set: 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` set: 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.
A volatile a pass that reads many handles binds (checks/refresh-argument-holds!), holding
reader-state by context for one value of observe/change-clock, or nil.
A volatile a pass that reads many handles binds (`checks/refresh-argument-holds!`), holding `reader-state` by context for one value of `observe/change-clock`, or nil.
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 stored excepts 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 stored `except`s 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-entries kb)supporter-entries over the stored excepts alone: what a firing's witness search
reads (tax/*network-belief*).
`supporter-entries` over the stored `except`s alone: what a firing's witness search reads (`tax/*network-belief*`).
(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 answers a storage presence check, not a belief one: excepts
that are all defeated still give a predicate, which answers false. The presence check
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.
The ancestor set is the unscoped one, for visible-exception-index's reason.
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 answers a storage presence check, not a belief one: excepts that are all defeated still give a predicate, which answers false. The presence check 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. The ancestor set is the unscoped one, for `visible-exception-index`'s reason.
(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
stored excepts 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 stored `except`s 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.(exemption-reads? kb)Can a placement be exempt at some reader (exempt-justifications): a (contradicts …)
is stored beside a siblingDisjointException or an equality edge. This is the
whole-KB presence check of exempting-at?.
Can a placement be exempt at some reader (`exempt-justifications`): a `(contradicts …)` is stored beside a `siblingDisjointException` or an equality edge. This is the whole-KB presence check of `exempting-at?`.
(forced-hidden-own-fn kb)A predicate (fn [h]) answering whether the forced-monotonic declarations alone hide
the handle h at its own context: a handle with no premise mark every justification of
which is a firing void there (forced-void);
or nil when no declaration outside the baseline set is stored. A justification the
network holds void (:void) counts for neither side. The answer reads the declarations
and h's justifications only, so the answer is the same before and after a write that moves no
declaration and removes none of h's justifications. The reader state of each context
is kept for the predicate's lifetime.
A predicate `(fn [h])` answering whether the forced-monotonic declarations alone hide the handle `h` at its own context: a handle with no premise mark every justification of which is a firing void there (`forced-void`); or nil when no declaration outside the baseline set is stored. A justification the network holds void (`:void`) counts for neither side. The answer reads the declarations and `h`'s justifications only, so the answer is the same before and after a write that moves no declaration and removes none of `h`'s justifications. The reader state of each context is kept for the predicate's lifetime.
(forced-reading kb ctx)The forced-monotonic reading (fn [kind pred]) of ctx (forced-state's :on?).
The forced-monotonic reading `(fn [kind pred])` of `ctx` (`forced-state`'s `:on?`).
(genlCx-except-contexts kb sups)The contexts stating an except that reaches the support of a genlCx supporter in
the supporter summary sups (genlCx-excepts), with the contexts stating an except
of one of those, transitively, as a sorted set: what splits the readers under a moved edge into classes
(tax/context-move).
The contexts stating an `except` that reaches the support of a `genlCx` supporter in the supporter summary `sups` (`genlCx-excepts`), with the contexts stating an `except` of one of those, transitively, as a sorted set: what splits the readers under a moved edge into classes (`tax/context-move`).
(genlCx-excepted? kb sups)Does a stored except reach the support of a genlCx supporter in sups
(genlCx-excepts)? kb/supporter-reaches? reads this as the genlCx filter's presence
check.
Does a stored `except` reach the support of a `genlCx` supporter in `sups` (`genlCx-excepts`)? `kb/supporter-reaches?` reads this as the `genlCx` filter's presence check.
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.
(guard-owners recs g js)The ids of the justifications among js the guard justification g belongs to: of
those whose rule and antecedents g's antecedents hold and whose bindings g carries
(read off recs; a g with no bindings matches on its antecedents alone), each that
no other one of the same rule holds a proper superset of the antecedents of. A guard
justification rests on its firing's antecedents, so a second firing of the rule with
equal bindings over a subset of them is not taken for its owner.
The ids of the justifications among `js` the `guard` justification `g` belongs to: of those whose rule and antecedents `g`'s antecedents hold and whose bindings `g` carries (read off `recs`; a `g` with no bindings matches on its antecedents alone), each that no other one of the same rule holds a proper superset of the antecedents of. A guard justification rests on its firing's antecedents, so a second firing of the rule with equal bindings over a subset of them is not taken for its owner.
(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 is the O(1) presence check 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 is the O(1) presence check 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 an index answer 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 an index answer its caller already read.
(justification-verdicts kb h ctx){jid reason}: the verdict ctx reads on each justification of h
(verdict-reader).
`{jid reason}`: the verdict `ctx` reads on each justification of `h`
(`verdict-reader`).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?)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.
`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.
(supporter-entries kb)What the taxonomy's whole-KB presence-check callback answers for a reader's belief
(tax/install-supporter-visibility!): nil when no except and no defeat is stored,
else the entries [defeat targets] and [except targets], each a delay of the set of
handles the stored facts of that functor name. Two counts on the index.
What the taxonomy's whole-KB presence-check callback answers for a reader's belief (`tax/install-supporter-visibility!`): nil when no `except` and no `defeat` is stored, else the entries `[defeat targets]` and `[except targets]`, each a delay of the set of handles the stored facts of that functor name. Two counts 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), under ctx's forced-monotonic reading
(forced-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`), under `ctx`'s forced-monotonic reading (`forced-state`).
(verdict-reader kb)(fn [h ctx]): {:believed? b :verdicts {jid reason}}, whether ctx believes the
handle h (res/believed-at?'s reading: the excepts are not applied) and the verdict
ctx reads on each justification of h, one of:
:supports valid there: every handle it rests on is believed there
:antecedent-out a handle it rests on is not believed there
:blocked its rule's exceptWhen holds in the network (jtms/blocked)
:void the network, or ctx's forced-monotonic reading, holds it void
:guard a guard defeat in force at ctx covers it (docs/naf.md)
:exempt a nogood justification of a placement ctx exempts
h is believed at ctx exactly when it is IN, no defeat or conflict in force there
names it (defeats-of), and it is a premise or a justification of it reads
:supports. Both answers are read off one walk
(support-read), and every answer of one reader shares one reader state per context,
so a defeat cycle is broken alike whichever handle is asked first.
`(fn [h ctx])`: `{:believed? b :verdicts {jid reason}}`, whether `ctx` believes the
handle `h` (`res/believed-at?`'s reading: the excepts are not applied) and the verdict
`ctx` reads on each justification of `h`, one of:
:supports valid there: every handle it rests on is believed there
:antecedent-out a handle it rests on is not believed there
:blocked its rule's `exceptWhen` holds in the network (`jtms/blocked`)
:void the network, or `ctx`'s forced-monotonic reading, holds it void
:guard a guard defeat in force at `ctx` covers it (docs/naf.md)
:exempt a `nogood` justification of a placement `ctx` exempts
`h` is believed at `ctx` exactly when it is IN, no defeat or conflict in force there
names it (`defeats-of`), and it is a premise or a justification of it reads
`:supports`. Both answers are read off one walk
(`support-read`), and every answer of one reader shares one reader state per context,
so a defeat cycle is broken alike whichever handle is asked first.(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 ancestor set is the unscoped one (tax/context-up-global): the except filter
cannot be scoped by the filter it derives.
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 ancestor set is the unscoped one (`tax/context-up-global`): the except filter
cannot be scoped by the filter it derives.(walk-reads? kb)Does a belief-filtered read owe the walk (defeat-hidden-fn): placed-reads?, a
placement some reader can exempt (exemption-reads?), or a forced-monotonic declaration
that can hide a handle at some reader (forced-reads?).
Does a belief-filtered read owe the walk (`defeat-hidden-fn`): `placed-reads?`, a placement some reader can exempt (`exemption-reads?`), or a forced-monotonic declaration that can hide a handle at some reader (`forced-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 is empty or hides nothing, which is almost
every read of almost every KB. hidden-fn is read only for a non-empty answer, so a
probe that matches nothing builds no reader state.
Drop the `[handle …]` matches whose handle `view-context` does not see (`hidden-fn`), and answer the **identical seq** when it is empty or hides nothing, which is almost every read of almost every KB. `hidden-fn` is read only for a non-empty answer, so a probe that matches nothing builds no reader state.
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 |