Prismatic Logic Prolog

Overview

Prismatic Logic Prolog embeds a Prolog logic programming engine within the Elixir platform, enabling declarative rule-based reasoning, expert system construction, and constraint satisfaction for complex intelligence analysis problems. Prolog's pattern matching and backtracking naturally complement Elixir's functional approach -- where Elixir excels at data transformation and concurrency, Prolog excels at exploring search spaces defined by logical rules. Together, they form one pillar of the platform's multi-paradigm solving strategy, alongside formal verification in Lean4 and probabilistic analysis via Monte Carlo verification.

The module provides a bidirectional bridge between Elixir data structures and Prolog terms. Elixir maps, keyword lists, and structs are automatically translated into Prolog facts, and query results are marshalled back into native Elixir types. This means analysts can define complex classification rules in Prolog's declarative syntax while the rest of the platform continues operating in standard Elixir/OTP patterns. The bridge uses NIF bindings for performance-critical term conversion while maintaining fault tolerance through supervised worker isolation.

A primary use case is compliance rule evaluation. Regulatory requirements such as NIS2 and ZKB can be expressed as Prolog rules that are easier to audit and maintain than equivalent imperative code. When regulations change, analysts update rule definitions without modifying application code. The engine supports rule provenance tracking so every deduced conclusion can be traced back to the specific rules and facts that produced it -- a requirement of the NABLA framework's provenance mandatory axiom and the Trinity Gate logical consistency check.

Architecture

PrismaticLogicProlog.Application
└── PrismaticLogicProlog.Supervisor (:one_for_one)
    ├── PrismaticLogicProlog.KnowledgeBaseManager (GenServer)
    │   ├── Domain: :compliance (NIS2, ZKB, GDPR rules)
    │   ├── Domain: :risk (entity risk classification)
    │   ├── Domain: :entity (entity resolution rules)
    │   └── Domain: :custom (user-defined rule sets)
    ├── PrismaticLogicProlog.PoolSupervisor (DynamicSupervisor)
    │   ├── Prolog.Worker (NIF-backed SWI-Prolog)
    │   ├── Prolog.Worker ...
    │   └── Prolog.Worker ...
    ├── PrismaticLogicProlog.QueryDispatcher (GenServer)
    │   └── Term translation, timeout, result limits
    └── PrismaticLogicProlog.RuleVersioner (GenServer)
        └── Provenance tracking: rule → conclusion audit trail

Rule Files (.pl) → Knowledge Base Manager → Prolog Engine Pool → Query Results
       ↓                    ↓                       ↓                  ↓
  Version Control     Domain Databases          SWI-Prolog NIF     Elixir Terms
  Migration Support   (Compliance, Risk,        Concurrent Workers  Explanation Chain
  Provenance Tags      Entity, Custom)          Timeout Protection  Confidence Score
  Audit Trail         Hot-Reload Support        Depth Limits        Provenance Link

Multiple Prolog worker processes run concurrently under a PoolSupervisor, preventing a single long-running query from blocking other reasoning tasks. Each worker runs in process isolation so that a runaway unification or infinite backtracking loop is contained and terminated without affecting the platform.

Key Modules

Configuration

config :prismatic_logic_prolog,
  # Engine settings
  pool_size: 4,
  query_timeout_ms: 10_000,
  max_result_count: 1000,
  max_depth: 100,

  # Knowledge base
  rule_directory: "priv/rules/",
  hot_reload: true,

  # Memory limits per worker
  max_worker_memory_mb: 256,

  # Telemetry
  telemetry_prefix: [:prismatic_logic_prolog, :query]

API Reference

# Define compliance rules in Prolog syntax
PrismaticLogicProlog.assert_rules(:compliance, """
  high_risk(Entity) :-
    sanctions_match(Entity, _),
    jurisdiction(Entity, Jurisdiction),
    high_risk_jurisdiction(Jurisdiction).

  requires_enhanced_due_diligence(Entity) :-
    high_risk(Entity);
    pep(Entity);
    complex_ownership(Entity).
""")

# Query for all high-risk entities
{:ok, results} = PrismaticLogicProlog.query(:compliance, "high_risk(X)")
# => [%{x: "entity_123"}, %{x: "entity_456"}]

# Check a specific entity with explanation chain
{:ok, %{result: true, explanation: chain}} =
  PrismaticLogicProlog.query_with_explanation(:compliance,
    "requires_enhanced_due_diligence(entity_789)")

# Load rules from versioned file
PrismaticLogicProlog.load_rules(:risk, "priv/rules/risk_v2.3.pl")

# Hot-reload rules without engine restart
PrismaticLogicProlog.reload_rules(:compliance)

Testing

# Run all Prolog engine tests
cd apps/prismatic_logic_prolog && mix test

# Run with coverage
mix test --cover

# Run knowledge base management tests
mix test test/prismatic_logic_prolog/knowledge_base_test.exs

# Run term translation property tests
mix test test/prismatic_logic_prolog/term_translator_test.exs

Testing includes property-based tests (via PropCheck and StreamData) for bidirectional term translation, integration tests for Prolog query execution with timeout enforcement, and unit tests for knowledge base versioning and provenance tracking. Worker isolation tests verify that runaway queries are contained without affecting other workers.

Integration Points

NABLA Compliance

Rule provenance tracking ensures that every deduced conclusion links back through the specific rules and facts that produced it. This satisfies the NABLA provenance mandatory axiom and enables auditing of all reasoning chains. Conclusions from Prolog pass through Trinity Gate Gate 2 (logical consistency) validation.

Performance

Related Resources

• Prismatic Deduction -- Orchestrates inference workflows using Prolog as a reasoning backend
• Prismatic CER -- Stores rule evaluation results as compliance evidence
• Prismatic Narrative -- Renders Prolog explanation chains as human-readable reports
• Prismatic Labs -- Experimental rule sets prototyped before production deployment
• Multi-Paradigm Problem Solving -- Prolog as the logic programming paradigm
• Trinity Gate -- Prolog conclusions validated through Gate 2 logical consistency
• NABLA Axioms -- Rule provenance tracking enforces provenance mandatory axiom

Connect & Contribute

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

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