Technical Archive · Reference Specification

Deep Research: 7 Logics Framework

A layered reasoning architecture that routes every question through deterministic validation, a state and workflow engine, seven logic modalities, and a jury-and-judge review loop - so answers are auditable, bounded, and verifiable.

7 logic modalities4-layer architectureTrust & reliability pipelineDeterministic + probabilistic

00 · Orientation

How to use this archive

Five short steps. Read them in order for the full picture, or jump straight to the section you need.

01
Start with the architecture
Read the four layers to see how an input becomes a verified output. The flow diagram shows the order and the audit loop.
02
Study the seven modalities
Each logic has its own card: definition, when to use it, mechanics, strengths, risks, and an applied example. Use the filter to find one by name.
03
Pick a logic with the matrix
Compare all seven side by side by determinism, latency, token cost, and trade-offs, or jump straight to the choose-this-when guide.
04
Trust the pipeline
See how scaffolding, just-in-time context, and the jury-and-judge workflow keep every output grounded and auditable.
05
Grab the artifacts
Copy the reference pipeline, look up a term in the glossary, and check the invariants before you ship anything.

01 · Layered System

Architecture & Layered System

Four layers, one direction of travel. Each layer is a hard boundary with its own guarantees, and the review layer feeds back into the pipeline so failures become lessons, not repeats.

Input Validation Layer

Deterministic gate that rejects malformed or out-of-policy input before any reasoning runs.

Schema checksType boundsPolicy guardrails

State & Workflow Engine

Tracks where each request is in its lifecycle and orchestrates execution as a directed graph.

State machinesDAG executionTransaction logs

Reasoning Engine

The multi-logic kernel that combines deterministic rules with probabilistic LLM inference.

Logic selectionDeterministic rulesProbabilistic inference

Review & Verification Layer

Jury-and-judge verification, auditability, and invariant checks that certify the output.

Jury / JudgeAudit trailInvariant checks

The audit loop

The review layer writes every verdict to the transaction log. When a verdict fails an invariant or the jury disagrees, that event feeds back to the state and workflow engine, which can re-route the request through a different logic path or back to validation. The loop is what turns a one-shot pipeline into a learning one.

02 · The Seven

Seven Logic Modalities

Each modality is a distinct way of reasoning. The framework picks one or more per request, depending on what the question demands. Filter to find one, or read them in order.

Deductive Logic

Guaranteed conclusions from true premises

Top-down reasoning that moves from general premises to specific conclusions. If the premises are true and the inference rules are valid, the conclusion necessarily follows. There is no room for guesswork.

When to use it

Use it wherever a wrong answer is unacceptable and the domain can be specified precisely: enforcing invariants, type checking, proving constraints, verifying formal properties, and any step that must be auditable and reproducible.

Strengths

Sound and complete within the formal system
Zero hallucination bound - the answer is entailed or it is not
Fully deterministic and reproducible
Every step is auditable as a chain of inferences

Failure modes & risks

Garbage in, garbage out - a false premise yields a false conclusion
Brittle in underspecified or messy domains
Cannot generate new knowledge, only make implicit facts explicit
Proof search can be computationally expensive

Mechanics & applied example

Mechanics

Start from axioms and known-true premises, then apply sound inference rules (modus ponens, modus tollens, universal instantiation) to derive conclusions. In practice this maps to symbolic derivation, SAT/SMT solving for constraint proofs, and theorem proving over a formal model of the system.

Applied example

Given the invariant 'every input that passes validation conforms to schema S' and the fact 'this input passed validation', the engine deduces 'this input conforms to schema S'. That is a hard guarantee the pipeline can assert, not a probabilistic guess.

Inductive Logic

Patterns and probabilities learned from data

Bottom-up reasoning that generalizes from empirical observations to probabilistic patterns, statistical models, and predictions. Conclusions are probable, not certain, and come with uncertainty.

When to use it

Use it for anomaly detection, forecasting, classification, and discovering structure when no formal model exists - anywhere the signal lives in real, messy data rather than in axioms.

Strengths

Learns from real data without hand-written rules
Handles high-dimensional and noisy domains
Quantifies uncertainty explicitly
Improves as more data accumulates

Failure modes & risks

Overfitting or underfitting the training signal
Spurious correlations mistaken for causes
Sampling bias distorts the model
Confidence can be miscalibrated; degrades silently on distribution shift

Mechanics & applied example

Mechanics

Fit statistical models to observed samples: frequentist or Bayesian estimation, regression, clustering, and density estimation. Generalize from finite samples, quantify uncertainty with confidence intervals or credible regions, and update as new data arrives.

Applied example

From a corpus of past queries and their verified outcomes, estimate the prior probability that a given query class needs human review, then flag statistically unusual outliers as anomalies for the review layer.

Abductive Logic

Inference to the best explanation

Reasoning that generates hypotheses to explain observed evidence and ranks them by how well they account for it. It is the logic of diagnosis: given the effect, find the most plausible cause.

When to use it

Use it for root-cause diagnosis, debugging, hypothesis generation, incident analysis, and any situation where you must explain an observation and decide what to test next.

Strengths

Explains novel observations other logics cannot
Generates hypotheses, not just conclusions
Supports iterative, evidence-driven diagnosis
Works well with incomplete information

Failure modes & risks

The best explanation can still be wrong
Confirmation bias toward familiar hypotheses
Hypothesis space may be incomplete
Explains the past without predicting the future

Mechanics & applied example

Mechanics

Generate a set of candidate explanations, score each by likelihood and prior plausibility, then apply Bayesian updates as new evidence arrives. Keep the best explanation while retaining plausible alternatives that further evidence could promote.

Applied example

A workflow fails a postcondition. Abduction proposes candidate causes - schema drift, a race condition, a stale cache - ranks them by prior likelihood and the evidence at hand, and drives the next diagnostic probe to disambiguate.

Fuzzy Logic

Graded truth and continuous confidence

Reasoning with truth values between 0 and 1, capturing partial membership and continuous degrees of confidence instead of crisp true or false.

When to use it

Use it for continuous risk scoring, control decisions, ambiguity, thresholds where a hard pass/fail is wrong, and ranking or prioritization over graded signals.

Strengths

Handles ambiguity gracefully with no cliff edges
Produces smooth, continuous outputs
Rule bases are human-readable and tunable
Robust to noise in the input signal

Failure modes & risks

Membership functions are hand-designed and subjective
Can mask underlying uncertainty
Defuzzification choices change results
Hard to verify formally

Mechanics & applied example

Mechanics

Define membership functions for linguistic variables (low, medium, high), combine them with fuzzy operators, and defuzzify to a crisp output. Confidence thresholds route graded scores into decision bands.

Applied example

Instead of a pass/fail on a risk check, compute a graded risk score in [0, 1] with membership functions for low, medium, and high, then route the item into review bands by threshold rather than a single brittle cut.

Dialectical Logic

Thesis, antithesis, synthesis

Reasoning that resolves contradictions by surfacing and integrating opposing positions. A thesis is built, its strongest antithesis is constructed, and a synthesis preserves the valid parts of both.

When to use it

Use it for red teaming versus blue teaming, resolving contradictory constraints, adversarial review, and stress-testing conclusions before they are trusted.

Strengths

Surfaces blind spots and hidden assumptions
Hardens conclusions against adversarial challenge
Resolves genuine conflicts between constraints
Produces more defensible, tested outputs

Failure modes & risks

Can collapse into a false compromise
Synthesis may be vacuous or vague
Risk of infinite regress without a stopping rule
Running both sides costs time and tokens

Mechanics & applied example

Mechanics

Generate a thesis, construct the strongest possible antithesis, then synthesize a resolution that keeps what survives scrutiny on both sides. Iterate until the synthesis withstands a new round of attack.

Applied example

The blue team proposes a permissive input policy for usability; the red team shows the injection risk it introduces. The synthesis is an allow-list plus strict escaping policy that preserves usability and safety.

Informal Logic & Pragmatics

Critical thinking over natural language

Critical thinking applied to natural language: evaluating arguments, detecting fallacies, and reasoning about context and intent. It is the logic of claims made in human language.

When to use it

Use it for evaluating LLM outputs, argument analysis, rhetoric and fallacy detection, context-aware reasoning, and judging claims embedded in unstructured text.

Strengths

Handles natural language and real-world ambiguity
Catches rhetorical manipulation and fallacies
Context-aware where formal logics are blind
Complements formal logics on unstructured input

Failure modes & risks

Judgment is subjective and context-dependent
Hard to formalize into deterministic rules
Can be gamed by skilled rhetoric
Lower determinism than formal logics

Mechanics & applied example

Mechanics

Reconstruct arguments into premises and conclusions, map each premise to its support, apply a fallacy taxonomy, and use pragmatic inference (implicature) plus context and source credibility to judge whether the conclusion is warranted.

Applied example

Given an LLM answer, reconstruct its argument, check each premise for support, flag an appeal to authority or a straw man, and judge whether the conclusion is actually warranted in context.

03 · Comparison

Engineering Decision Matrix

All seven logics side by side. The table scrolls horizontally on small screens; the first column stays pinned so you always know which row you are reading.

Choose this when…

You need a guarantee, not a guess→ DeductiveYou have data and want patterns→ InductiveYou must explain an observation→ AbductiveYou must prove safety over time→ ModalTruth is a matter of degree→ FuzzyConstraints conflict→ DialecticalThe input is human language→ Informal

Comparison of the seven logic modalities
Logic	Best use	Input shape	Determinism	Flexibility	Latency	Token cost	Strengths	Trade-offs
Deductive	Proving invariants, type checks, formal guarantees	Structured, formally specified	High	Low	Low	Low	Sound, auditable, zero hallucination	Brittle outside formal domains
Inductive	Anomaly detection, forecasting, classification	Empirical data, samples	Medium	High	Medium	Medium	Learns from data, quantifies uncertainty	Spurious correlations, calibration risk
Abductive	Root-cause diagnosis, hypothesis generation	Observations, evidence	Medium	High	Medium	Medium	Explains novel observations	Best guess can be wrong
Modal	Safety invariants, concurrency, temporal checks	State model, reachable states	High	Low	Medium-High	Low	Verifies safety and liveness	State-space explosion
Fuzzy	Risk scoring, graded thresholds, control	Continuous, graded signals	Medium	Medium	Low	Low	Graceful ambiguity, smooth outputs	Subjective membership design
Dialectical	Red teaming, resolving conflicting constraints	Positions, arguments	Low	High	High	High	Hardens conclusions, surfaces blind spots	Costly, risk of false compromise
Informal	Evaluating LLM output, fallacy detection	Natural language, context	Low	High	Medium	Medium	Context-aware critical judgment	Subjective, hard to formalize

04 · Reliability

Integration with the Trust Reliability Architecture

Three systems work together to keep every output grounded, contextual, and independently verified.

Scaffolding & Anchor Assets

A fixed set of trusted reference material - ground truth, invariants, schemas, and policy - that anchors reasoning and prevents drift. Every claim is checked against these anchors before it is trusted.

Radiant Librarian JIT Context Injection

Just-in-time retrieval that injects the right anchor assets into the reasoning step at the moment they are needed, instead of flooding the model with everything up front.

Jury & Judge Workflow

A panel of independent reviewers (the jury) evaluates the draft from different angles. A judge reconciles their verdicts and issues the final, certified output.

Trust pipeline

1Anchor assets loaded

2JIT context injected

3Reasoning runs

4Jury reviews

5Judge certifies

Reliability principles

Ground every claim in an anchor asset or a logged inference
Never trust a single reviewer; require independent verdicts
Inject context just in time, only what the step needs
Log every decision for a complete, replayable audit trail
Fail closed: if verification cannot certify, do not ship the answer

Pre-flight checklist

Anchor assets are versioned and immutable for the run
JIT injector has a retrieval budget and a fallback
Jury is diverse in logic modality and perspective
Judge has a documented tie-break rule
Every output carries an audit reference you can follow

05 · Engineering Artifacts

Reference Pipeline, Glossary & Invariants

The working pieces: a copyable reference pipeline, a searchable glossary, and the invariants every implementation should hold.

Reference pipeline

Pseudocode for routing a problem through validation, logic selection, reasoning, and jury-and-judge review. Copy it as the skeleton for an implementation.

pipeline.pseudo

function route_problem(input):
  # 1. Input Validation Layer
  if not validate_schema(input):   return reject("schema mismatch")
  if not within_type_bounds(input): return reject("type bounds")
  if not passes_policy(input):      return reject("policy guardrail")

  # 2. State & Workflow Engine
  state = workflow.begin(input)
  plan  = build_dag(state)          # ordered reasoning steps

  # 3. Reasoning Engine - pick logic per step
  for step in plan:
    logic = select_logic(step)      # deductive | inductive | ... | informal
    anchors = librarian.inject(step)   # Radiant Librarian JIT context
    draft[step] = reason(logic, step, anchors)

  # 4. Review & Verification Layer
  verdicts = jury.review(draft)     # independent reviewers
  if not judge.certify(verdicts):
    state.log_failure(draft)        # audit loop -> re-route or re-validate
    return route_problem(input)     # retry with updated plan
  output = judge.issue(verdicts)
  state.log_success(output)         # transaction log for auditability
  return output

Glossary

Core terms used across the framework, defined in plain language.

Entailment: The relation where a conclusion necessarily follows from premises, as in deductive logic.
Soundness: A system is sound if every conclusion it derives from true premises is actually true.
Completeness: A system is complete if every true statement within its scope can be derived.
Determinism: The property that the same input always produces the same output with no randomness.
Hallucination bound: A guarantee that a reasoning step cannot fabricate facts, as in deductive entailment.
Invariant: A property that must hold at all times or in all reachable states of a system.
State machine: A model of a system as a finite set of states and the transitions between them.
DAG: A directed acyclic graph used to order reasoning steps that have dependencies but no cycles.
Transaction log: An append-only record of every step and decision, enabling replay and audit.
JIT context injection: Just-in-time retrieval of the specific context needed for a step, right when it runs.
Jury & Judge: A review pattern where independent reviewers evaluate, then a judge reconciles and certifies.
Membership function: In fuzzy logic, a function mapping a value to its degree of membership in a set, from 0 to 1.
Kripke model: A formal structure of possible worlds and accessibility relations used in modal logic.
Synthesis: In dialectical logic, the resolution that integrates the valid parts of a thesis and antithesis.
Fallacy: A flaw in reasoning that makes an argument unsound, such as appeal to authority or straw man.

Invariants & acceptance criteria

The guarantees the framework is built to hold. Treat each as an acceptance criterion for any implementation.

No unvalidated input reaches reasoning

Every input passes schema, type, and policy checks before step 3.

Every output is certified

No output is emitted without a passing jury verdict and judge sign-off.

The audit trail is complete

Every decision maps to a transaction-log entry that can be replayed.

Claims are grounded

Every claim traces to an anchor asset or a logged inference.

Failure is visible

A failed invariant or disagreement is logged and re-routed, never silently dropped.