Encyclopedia/All topics/Delta

Delta

Articles 1–57 of 57. Alphabetical by title.

• Delta Kernel Check

  A machine-checked library that audits every derivation in Recognition Science, returning the proved formula and the exact assumptions it consumed.

• Delta Kernel Check Check

  A machine-checked library of formal theorems audits every proof it accepts, and records exactly which assumptions each one needed.

• Delta Kernel Check Conditional

  A machine-checked proof can carry a receipt: the exact assumptions it consumed, named one by one.

• Delta Kernel Check Ctx

  In the framework's proof-checking kernel, a context is simply a list of assumptions, and the declaration Ctx defines it as such.

• Delta Kernel Check Deriv

  A derivation is a fully written-out proof tree that a machine can audit line by line, and it records exactly which assumptions each step leans on.

• Delta Kernel Check Forced

  A proof that uses no special assumptions is marked as forced, and the machine-checked library records exactly which assumptions it used.

• Delta Kernel Examples

  A small set of hand-checked proofs shows what a recognition ledger accepts and rejects, and why the rules are not a matter of convention.

• Delta Kernel Examples Forced Route Forced

  A machine-checked example shows how a simple logical truth can be built without relying on a classical axiom, and what that demonstration does not prove.

• Delta Kernel Examples Full Ind Demo Tier

  The declaration fullIndDemo_tier shows a machine checker accepting a proof that uses the full power of induction, and it records the exact strength of that proof.

• Delta Kernel Examples Mp Rejects Quantified

  A small checker rule decides which logical principles a derivation may invoke, and it refuses to let a quantified statement pass as a quantifier-free one.

• Delta Kernel Examples One Plus One Certified

  A machine-checked proof of 1 + 1 = 2 that records exactly which logical assumptions it needed, and shows how arithmetic can be certified without hidden axioms.

• Delta Kernel Examples One Plus One Forced

  A machine-checked proof that 1 + 1 = 2, built from the bare recursion rules of arithmetic and nothing else.

• Delta Kernel Examples Zero Add Certified

  A machine-checked proof that zero plus any natural number equals that number, built from first principles without hidden assumptions.

• Delta Kernel Godel Test

  A pre-registered experiment asks whether the framework's ledger records the strength of a proof, not just its truth.

• Delta Kernel Godel Test Add Comm Full Certified

  A machine-checked proof that addition commutes, with a twist: it records the kind of induction the proof used.

• Delta Kernel Godel Test Add Comm Full Syntactic Audit

  A machine-checked ledger records not just what is proved, but how hard the proof was, and this audit shows it can tell two routes apart.

• Delta Kernel Godel Test Add Comm Full Tier

  A machine-checked experiment shows that the same theorem, commutativity of addition, can be derived in two ways that leave different traces in a formal ledger.

• Delta Kernel Godel Test Add Comm Syntactic Audit

  A machine-checked proof that a careful proof of commutativity of addition avoids a hidden logical convenience, and what that convenience costs.

• Delta Kernel Godel Test Pricing Discriminates

  A machine-checked experiment shows that the same arithmetic theorem can be derived with different proof routes, and the framework's ledger records that difference.

• Delta Kernel Godel Test Succ Add Forced

  A machine-checked proof that the simplest addition fact can be derived without paying a hidden logical toll, and what that pricing does not measure.

• Delta Kernel Ledger

  A small record of which classical assumptions a proof used, and the machine-checked guarantee that an empty record means a forced derivation.

• Delta Kernel Ledger Em Right

  A small formal lemma about combining records of logical assumptions, and the sharp line it draws between what is forced and what is merely conditional.

• Delta Kernel Ledger Lpo Left

  A small theorem about bookkeeping for mathematical assumptions shows how a machine-checked library records which principles a proof actually used.

• Delta Kernel Ledger Of Em Ne Empty

  A machine-checked theorem confirms that using the law of excluded middle marks a derivation as relying on a classical posit, not as forced.

• Delta Kernel Ledger Of Lpo Ne Empty

  A machine-checked proof that using one classical principle leaves a trace, and the trace is never the empty record.

• Delta Kernel Ledger Of Mp Ne Empty

  A tiny formal theorem about a bookkeeping record shows how the framework tracks which classical principles a derivation consumes.

• Delta Kernel Ledger Union Eq Empty

  A tiny theorem about combining records of logical assumptions says exactly when the combined record is empty, and it never claims to know which assumptions are true.

• Delta Kernel Ledger Union Is Forced

  A machine-checked proof shows that combining two proof ledgers stays assumption-free exactly when each half was assumption-free.

• Delta Kernel Semantics

  A machine-checked semantics that gives every expression of a minimal logic a concrete meaning as a computation on natural numbers, with no classical assumptions.

• Delta Kernel Semantics Cons Lift Var

  A small lemma about bookkeeping in a formal language shows how the framework's kernel keeps its own accounts straight.

• Delta Kernel Semantics Eval Subst

  A machine-checked lemma about swapping variables into formulas, and why the framework treats it as a load-bearing proof.

• Delta Kernel Semantics Sat Step Succ

  A small theorem about shifting variable assignments shows how the framework's kernel handles the simplest induction step, and why it matters for the whole system.

• Delta Kernel Semantics Sat Subst0

  A small lemma about swapping a term into a formula shows exactly when a formal language's substitution matches its meaning.

• Delta Kernel Semantics Subst At Cons

  A small formal lemma about bookkeeping with variable names, and why it matters for a machine-checked proof of soundness.

• Delta Kernel Semantics Subst At Zero

  A small formal lemma about variable substitution turns out to be the hinge that lets a whole logical system prove its own soundness without classical assumptions.

• Delta Kernel Sigma Conditional Ledger Syntactic

  A machine-checked theorem shows a proof's record of assumptions can be read directly from its syntax, like checking for a banned word.

• Delta Kernel Sigma Forced Iff Posit Free

  A proof's honesty can be checked by a simple tree-walk, without trusting the checker that produced it.

• Delta Kernel Sigma Forced Syntactic Audit

  A theorem in the Recognition Science library shows that a certain kind of proof certificate can be checked by simply scanning its symbols, with no need to run the checker itself.

• Delta Kernel Sigma Posit Free Eq Scan Is Forced

  A machine-checked theorem shows that a certain class of proof certificates can be verified by a simple tree-walk, with no knowledge of the checking algorithm.

• Delta Kernel Sigma Scan Ledger

  A machine-checked theorem shows that a proof's classification can be read directly from its syntax, like spotting a forbidden word in a text.

• Delta Kernel Sigma Uses Full Ind

  A machine-checked library shows that a proof's use of full induction is a simple syntactic property, readable directly from the proof's own structure.

• Delta Kernel Sigma Uses Full Ind Eq Scan Ind Full

  A machine-checked theorem lets anyone verify a proof's highest induction tier by a simple tree-walk, with no knowledge of the checking algorithm.

• Delta Kernel Sound

  A proof checker that accounts for the strength of its own assumptions, and certifies which conclusions need none.

• Delta Kernel Sound Mem Of Get Elem

  A tiny lemma about lists and indices, and what it reveals about the kernel that proves it.

• Delta Kernel Sound Meta Lpo

  A precise logical principle that says a search over natural numbers either finds an answer or proves none exists, and what it means for a proof checker to record its use.

• Delta Kernel Sound Sound Classical

  A proof checker that records its own logical assumptions, and the one theorem that lets every accepted derivation run on full classical logic.

• Delta Kernel Sound Sound Forced

  A machine-checked proof that certain logical derivations need no hidden assumptions, explained for a general reader.

• Delta Kernel Sound Sound Is Forced

  A machine-checked proof system certifies its own strongest guarantee: derivations that avoid omniscience principles are true without them.

• Delta Kernel Syntax

  A deliberately minimal formal language, the delta kernel syntax defines the basic symbols and rules for writing statements about the natural numbers in Recognition Science.

• Delta Kernel Syntax Dformula

  A machine-checked syntax for a minimal arithmetic where formulas are inert data, not executable propositions, and where the host logic's assumptions never leak in.

• Delta Kernel Syntax Dterm

  DTerm is the grammar of a deliberately small arithmetic, a language stripped to counting, adding, and multiplying, with nothing else allowed.

• Delta Kernel Syntax Is Qf

  A small Boolean function in a formal logic decides which formulas are simple enough for a key proof rule, and it does so without any hidden assumptions.

• Delta Kernel Syntax Neg

  In the δ-kernel, negation is not a primitive symbol but a defined operation: a formula is negated by saying it implies falsehood.

• Delta Kernel Syntax Of Nat

  A small function that turns ordinary counting numbers into the framework's formal language, and nothing more.

• Delta Kernel Syntax Step Succ

  In the δ-kernel's object logic, stepSucc is the one operation that advances a formula's bound variable by a single counting step, and it claims nothing about what that st

• Delta Kernel Syntax Subst

  A small function for replacing variables in logical formulas, and the careful limits that keep it honest.

• From Distinction to Loop Order

  An illustrated guide to distinction, arithmetic and the information carried by loop order.