PLN Primer

New to PLN? You're in the right place — this is the plain-language on-ramp. For the topic overview see the PLN index card; for the expert-level technical treatment, the PLN Deep Dive.

PLN in one idea

PLN is uncertain reasoning. Real minds — and real AGI — almost never deal in certainties. You rarely know something is true; you have evidence that makes it more or less likely, from sources you trust more or less. PLN (Probabilistic Logic Networks) is Hyperon's machinery for reasoning when nothing is certain — drawing conclusions, step by careful step, from evidence that is partial, noisy, and sometimes contradictory. A belief in PLN isn't simply true or false: it records how strongly the evidence points and how much evidence stands behind it. “Probably true, but I've barely looked” and “almost certainly true, and I've checked exhaustively” are different states of mind — and PLN keeps them apart.

What is paraconsistency?

One idea you need before the machinery: a thinking system has to survive contradiction. Classical logic doesn't — give it a single contradiction and it will formally prove anything at all (the principle called ex falso quodlibet). That's fatal for a real mind, which is fed conflicting evidence constantly: one study says yes, another no; a trusted friend disagrees with a trusted book. A paraconsistent stance refuses to explode — it holds conflicting evidence side by side, weighs it, and keeps reasoning. PLN earns this robustness from graded beliefs: a contradiction lowers a belief's strength and is reconciled by combining evidence rather than detonating the knowledge base. (This is a deliberate design foundation — see Goertzel, Paraconsistent Foundations for Probabilistic Reasoning, Programming and Concept Formation (2020), arXiv:2012.14474.) It is the same property you see when PLN degrades gracefully: when evidence is sparse or conflicting, it produces tentative conclusions rather than brittle failures.

The elements of uncertainty: strength and confidence

PLN attaches a truth value to every statement — in its simplest form, two numbers: strength (0–1, how true) and confidence (0–1, how much evidence backs that estimate). This is how PLN holds evidence consistently. When two pieces of evidence about the same statement arrive, PLN revises — merging them into one truth value, the strength pulled toward whichever side has more evidence, the confidence rising as evidence accumulates. Conflicting evidence pulls strength toward the middle and is recorded honestly, never forced into a brittle true/false.

A concrete picture. Imagine drawing marbles from a bag, unseen. Draw one red marble: your best guess is “mostly red,” but you’ve seen almost nothing — strength near 1, confidence still low. Now draw a hundred red and a hundred blue: strength settles near ½, and now you genuinely know something, because a hundred trials is meaningful — confidence is high. Strength and confidence move independently, and PLN tracks both. (Adapted from Goertzel et al., Probabilistic Logic Networks, Springer 2009, Ch. 1 §1.4 — free PDF: goertzel.org/PLN_BOOK_6_27_08.pdf.)

Grounding it into the machinery

With beliefs represented as (strength, confidence), PLN can reason. Its core moves are the three classical inference forms, each a rule taking truth-valued premises to a truth-valued conclusion: deduction (from A→B and B→C, conclude A→C), induction (generalize from instances), and abduction (reason to the best explanation). Each carries a truth-value formula that computes the conclusion's (strength, confidence) from the premises' — so uncertainty propagates through a whole chain of inference instead of being discarded at the first step. This makes PLN, in effect, a logic-based analogue of statistical learning — but with explicit semantics and inference steps you can trace. (The full rule set, the formulas, and how PLN runs over Hyperon's AtomSpace / MORK substrate are the subject of the Deep Dive.)

Seeing it run: Sam the Raven

The public FlyingRaven.metta gives PLN six graded beliefs — Sam is a raven (strength 0.99), Pingu is a penguin (0.99), penguins don’t fly (exception rule, strength 1.0), ravens are birds (0.99), penguins are birds (0.99), birds fly (general rule, 0.99) — and then asks two questions. The queries and PLN’s computed answers, in MeTTa:

!(PLN.Query (kb) (Inheritance Sam   (IntSet flies)))
;; -> (stv 0.97  0.69)   Sam probably flies

!(PLN.Query (kb) (Inheritance Pingu (IntSet flies)))
;; -> (stv 0.0098 0.80)  Pingu almost certainly does not

Reading the numbers: Sam’s strength 0.97 traces to a three-step deduction chain — Sam is a raven, ravens are birds, birds fly. Three high-strength premises (all 0.99) compose to stay near that range; confidence falls to 0.69 as three steps accumulate uncertainty. Pingu’s result takes a different path: PLN needs only two facts — Pingu is a penguin (evidence 2) and penguins don’t fly (evidence 3, the exception rule, strength 1.0). Those two facts alone yield strength 0.0098 and confidence 0.80; the bird-flight chain plays no role in this result.

Full source: FlyingRaven.metta. The values above are the example’s checked-in expected results.

More examples in the PLN repository

• Toothbrush — physical reasoning chain: plastic properties lead through reshaping and hardening to object removal.
• Smokes — social network probabilistic reasoning: friends, smoking, and cancer (Tuffy Smokes benchmark).
• Robot — task planning: PLN infers which objects to bring based on observed properties and derived classifications.
• RavenInduction — inductive reasoning: two raven observations drive inference about color frequency.
• DeductionRevision — evidence combination: two parallel deduction paths reach the same conclusion, then merge via Revision.

Running PLN yourself

PLN runs on the PeTTa runtime. To try the examples locally, clone PeTTa, drop the PLN repo into its repos/ folder, and run an example script:

git clone https://github.com/trueagi-io/PeTTa
cd PeTTa && mkdir -p repos && cd repos
git clone https://github.com/trueagi-io/PLN
cd ..
sh ./run.sh ./repos/PLN/examples/FlyingRaven.metta

Inside a MeTTa program you import PLN via PeTTa's git-import mechanism:

!(import! &self (library lib_import))
!(git-import! "https://github.com/trueagi-io/PLN.git")
!(import! &self (library PLN lib_pln))

Setup note: PLN examples are authored for PeTTa and do not run as-is in the current wiki playground — the import prologue returns an argument-form error when attempted. To run them locally: install PeTTa (SWI-Prolog ≥ 9.3.x required), clone PLN into PeTTa’s repos/ directory, then from the PeTTa root:

sh ./run.sh ./repos/PLN/examples/<ExampleFile>.metta
cd ./repos/PLN && sh test.sh  # full test suite

PLN side-by-side with NARS

You'll often see PLN paired with NARS (the Non-Axiomatic Reasoning System). Both reason under uncertainty with a two-number truth value; the difference is where the numbers come from. PLN is grounded in probability theory — its truth values track probabilities and update like Bayesian evidence. NARS is grounded in experience — its values measure how an idea has held up against the system's history, assuming nothing about the world being probabilistically well-behaved. Different philosophies — yet on highly uncertain evidence they often land on very similar strength×confidence numbers. PLN is the more probabilistically principled of the two; NARS the more assumption-free.

Where PLN fits: the precision half of a neural-symbolic mind

Hyperon pairs neural, stochastic learning (fast, fuzzy pattern-finding) with symbolic, precise reasoning. PLN is the symbolic, precision side. Where a neural model gives a quick hunch, PLN gives a traceable chain of evidence-weighted inference — crisper, auditable, grounded in explicit truth values, yet still probabilistic, never claiming a certainty it doesn't have. Stochastic intuition paired with symbolic, evidence-based precision is much of how Hyperon reasons.

Go deeper

PLN Deep Dive — the truth-value formulas, the full rule set, forward / backward chaining, and execution on MORK.

Related

NARS, ECAN (which steers PLN's attention).

Intro presentation

Nil Geisweiller, AITP-25 (2025), slides 12–16 — public PDF; a concise presentation source for PLN truth values, inference forms, and the Beta-distribution interpretation.