NABLA Axioms

Overview

NABLA Infinity defines seven axioms that govern how the Prismatic Platform reasons about uncertainty, forms beliefs, and synthesizes intelligence. These axioms are non-negotiable -- every agent, every decision, every belief must comply. They represent the epistemic constitution of the platform: the fundamental rules that no process, no matter how urgent or authoritative, can bypass.

The axioms emerged from a practical observation: intelligence analysis systems fail not because they lack data, but because they reason poorly about uncertainty. Systems that force premature conclusions produce false confidence. Systems that discard contradictions produce blind spots. Systems that accept single-source claims without corroboration produce vulnerabilities. NABLA addresses each of these failure modes with a specific, enforceable axiom.

The name NABLA (the mathematical gradient operator) reflects the framework's purpose: to map the gradient of uncertainty across the platform's knowledge landscape. Just as the gradient operator reveals the direction of steepest change in a mathematical field, NABLA reveals where the platform's knowledge is strongest, weakest, and most contested. The infinity symbol denotes the framework's commitment to continuous, never-finished epistemic refinement.

The Seven Axioms

Axiom 1: Signal Plurality

No belief without at least two independent signals.

Signal Plurality is the foundational axiom. It mandates that no claim can achieve "believed" status without corroboration from at least two independent sources. This prevents the single-source vulnerability that plagues traditional intelligence analysis systems.

defmodule PrismaticNabla.SignalPlurality do
  @moduledoc """
  Enforces Signal Plurality axiom: no belief without at least
  two independent signals from verified sources.
  """

  @minimum_signals 2

  @spec validate(list(signal())) :: {:ok, :plurality_met} | {:error, :insufficient_signals}
  def validate(signals) when length(signals) >= @minimum_signals do
    independent_count =
      signals
      |> group_by_source_family()
      |> Map.keys()
      |> length()

    if independent_count >= @minimum_signals do
      {:ok, :plurality_met}
    else
      {:error, :insufficient_independent_signals}
    end
  end

  def validate(_signals), do: {:error, :insufficient_signals}

  defp group_by_source_family(signals) do
    Enum.group_by(signals, & &1.source_family)
  end
end

Axiom 2: Contradiction Preservation

Never discard contradicting evidence.

Both sides of a contradiction must be preserved and tracked. Resolution requires explicit reconciliation, not deletion. This axiom prevents the natural human tendency to resolve cognitive dissonance by discarding inconvenient evidence.

Contradictions are not failures of the system -- they are features. A contradiction between two reliable sources indicates that the situation is genuinely complex, that one source may be outdated, or that there is a dimension of the problem not yet understood. Discarding either side destroys information that may be critical for correct analysis.

Axiom 3: Absence Is Informative

Missing signals carry meaning.

The absence of expected data is itself data. If a company claims to be registered in a jurisdiction but the jurisdiction's registry has no record, that absence is a signal. The platform tracks what it expected to find but did not, treating absence as informative rather than ignorable.

Axiom 4: Time Decay

All beliefs have mandatory timestamps. Confidence decays over time.

Intelligence has a shelf life. A sanctions list match from yesterday carries more weight than a clean record from three years ago. Time decay is implemented as an exponential decay function applied to all confidence scores.

defmodule PrismaticNabla.TimeDecay do
  @moduledoc """
  Implements mandatory time decay for all belief confidence scores.
  Uses exponential decay with configurable half-life.
  """

  @default_half_life_hours 720  # 30 days

  @spec apply_decay(float(), DateTime.t(), keyword()) :: float()
  def apply_decay(base_confidence, evidence_timestamp, opts \\ []) do
    half_life = Keyword.get(opts, :half_life_hours, @default_half_life_hours)
    age_hours = DateTime.diff(DateTime.utc_now(), evidence_timestamp, :hour)

    decay_factor = :math.exp(-age_hours * :math.log(2) / half_life)
    adjusted = base_confidence * decay_factor

    # Floor at 0.01 -- never reaches absolute zero
    max(adjusted, 0.01)
  end

  @spec needs_refresh?(float(), DateTime.t()) :: boolean()
  def needs_refresh?(base_confidence, timestamp) do
    apply_decay(base_confidence, timestamp) < base_confidence * 0.5
  end
end

Axiom 5: Unknown Is Valid

"I don't know" is a legitimate answer.

Never fabricate certainty. When the evidence is insufficient to support a conclusion, the correct response is explicit uncertainty, not a forced answer. This axiom prevents the platform from producing false confidence that could lead to incorrect decisions.

Axiom 6: Source Independence

Independent sources weight higher than derivative sources.

Signals from the same source family get diminishing returns. If three news articles all cite the same original report, they count as one signal with slightly increased confidence, not three independent signals. True source independence increases confidence significantly.

Axiom 7: Provenance Required

All beliefs must be traceable to their originating signals.

Every belief in the platform traces back to its originating signals through an unbroken provenance chain. No orphan beliefs are permitted. This axiom enables full auditability and supports regulatory compliance requirements.

Confidence Thresholds

Different operational contexts require different confidence thresholds before action can be taken. These thresholds work in conjunction with the Trinity Gate verification requirements.

The threshold system ensures that confidence requirements scale with decision impact. A critical decision (blocking a financial transaction, issuing a compliance alert) requires 0.95 confidence with mandatory Trinity Gate passage. An exploratory analysis can proceed with 0.60 confidence to enable hypothesis generation without premature filtering.

Enforcement Protocol

Axiom violations trigger a four-level enforcement response proportional to the severity and scope of the violation.

Anti-Patterns (Forbidden)

These patterns represent common intelligence analysis failures that NABLA axioms are specifically designed to prevent.

Platform Implementation

The NABLA axiom enforcement is implemented as an Elixir module that wraps all epistemic operations with axiom validation.

defmodule PrismaticNabla.AxiomEnforcer do
  @moduledoc """
  Central enforcement point for all seven NABLA axioms.
  Wraps epistemic operations with mandatory axiom validation.
  """

  alias PrismaticNabla.{
    SignalPlurality,
    ContradictionPreserver,
    AbsenceTracker,
    TimeDecay,
    UnknownValidator,
    SourceIndependence,
    ProvenanceChecker
  }

  @spec validate_belief(belief()) :: {:ok, validated_belief()} | {:error, [violation()]}
  def validate_belief(belief) do
    violations =
      []
      |> check_signal_plurality(belief)
      |> check_contradiction_preservation(belief)
      |> check_absence_tracking(belief)
      |> check_time_decay(belief)
      |> check_unknown_validity(belief)
      |> check_source_independence(belief)
      |> check_provenance(belief)

    case classify_violations(violations) do
      :clean ->
        {:ok, %{belief | validated: true, validation_timestamp: DateTime.utc_now()}}

      {:soft_violations, warnings} ->
        {:ok, %{belief | validated: true, warnings: warnings}}

      {:hard_violations, errors} ->
        {:error, errors}
    end
  end

  defp check_signal_plurality(violations, belief) do
    case SignalPlurality.validate(belief.signals) do
      {:ok, _} -> violations
      {:error, reason} -> [{:signal_plurality, :hard, reason} | violations]
    end
  end

  defp check_provenance(violations, belief) do
    case ProvenanceChecker.trace(belief) do
      {:ok, _chain} -> violations
      {:error, :broken_chain} -> [{:provenance, :hard, :broken_chain} | violations]
      {:error, :orphan} -> [{:provenance, :hard, :orphan_belief} | violations]
    end
  end
end

NABLA and Trinity Gate Integration

The NABLA axioms serve as prerequisites for Trinity Gate passage. A belief that violates any hard axiom cannot enter the Trinity Gate verification pipeline, regardless of how well it might score on structural, logical, or formal checks.

Commands

Performance and Metrics

Integration

• Prerequisite for Trinity Gate verification passage
• Governs all Intelligence Synthesis operations
• Applied through Multi-Paradigm Solving epistemic paradigm
• Enforced by NO DOUBTS evidence standards
• Quality assured by NO MERCY zero-tolerance enforcement
• Color Teams operate under full NABLA compliance
• AIAD Standard encodes NABLA requirements in agent specifications
• AIAD Compliance validates NABLA enforcement blocks
• Monitored by Real-Time Monitoring for axiom compliance metrics
• Tracked by Telemetry Integration for enforcement performance
• Autonomous Self-Healing uses evidence-based healing per NABLA requirements
• Quality Gates include NABLA compliance as a gate criterion
• Supports Cross-Domain Flexibility epistemic operations across domains
• Feeds EASM and Compliance with calibrated intelligence

Connect & Contribute

Created by Tomáš Korcak (korczis) | Open Source under GHL

• GitHub | GitLab | LinkedIn | Contact
• Developer Portal | Architecture | Meet the Creator