import { type TCoreQuadrivalentValue } from "../../types/evaluation.js";
/** `true` iff the value carries the "told true" component. */
export declare function hasTrueComponent(value: TCoreQuadrivalentValue): boolean;
/** `true` iff the value carries the "told false" component. */
export declare function hasFalseComponent(value: TCoreQuadrivalentValue): boolean;
/**
 * Merge what two sources say about the same proposition: the join of the
 * knowledge order `null ≤ true ≤ contested`, `null ≤ false ≤ contested`.
 * `true` merged with `false` is `CONTESTED`.
 */
export declare function joinKnowledge(a: TCoreQuadrivalentValue, b: TCoreQuadrivalentValue): TCoreQuadrivalentValue;
/** Belnap NOT: swaps the components, so `null` and `contested` are fixed points. */
export declare function belnapNot(a: TCoreQuadrivalentValue): TCoreQuadrivalentValue;
/** Belnap AND: told true iff both are, told false iff either is. */
export declare function belnapAnd(a: TCoreQuadrivalentValue, b: TCoreQuadrivalentValue): TCoreQuadrivalentValue;
/** Belnap OR: told true iff either is, told false iff both are. */
export declare function belnapOr(a: TCoreQuadrivalentValue, b: TCoreQuadrivalentValue): TCoreQuadrivalentValue;
/**
 * Belnap exclusive disjunction (parity): told true iff some reading of the
 * operands makes an odd number of them true, told false iff some reading makes
 * an even number.
 *
 * This is written from the components rather than composed out of
 * `and`/`or`/`not`, and the difference is load-bearing. The composed reading
 * `(a ∧ ¬b) ∨ (¬a ∧ b)` agrees with this everywhere except `xor(null,
 * contested)`, where it answers `false`; that single cell costs associativity,
 * and 8 of the 64 triples then disagree depending on how they are bracketed.
 * A variadic operator cannot afford that — flattening a nested xor is an
 * auto-normalization rule, and the parser already collapses `a ⊻ b ⊻ c` into
 * one node, so a fold-order-dependent answer would make normalization change
 * what a formula means.
 *
 * Restricted to `{null, true, false}` this is exactly strong Kleene XOR, and
 * `null` absorbs throughout: a parity depends on every operand, so knowing
 * nothing about one is knowing nothing about the result. `iff` is composed and
 * keeps its own answer, which is why `xor(a, b)` and `not(iff(a, b))` part
 * company at that one cell — `iff` is binary and never has to associate.
 */
export declare function belnapXor(a: TCoreQuadrivalentValue, b: TCoreQuadrivalentValue): TCoreQuadrivalentValue;
/** Belnap material implication: NOT a OR b. */
export declare function belnapImplies(a: TCoreQuadrivalentValue, b: TCoreQuadrivalentValue): TCoreQuadrivalentValue;
/** Belnap biconditional: (a -> b) AND (b -> a). */
export declare function belnapIff(a: TCoreQuadrivalentValue, b: TCoreQuadrivalentValue): TCoreQuadrivalentValue;
//# sourceMappingURL=belnap.d.ts.map