Praxeophysics Protocol — Core Architecture & Reference Specification

Version: 4.1.0 (Derived from Baseline Specification v4.0.0)
Effective Baseline Date: Prior to 2026-09-01 (Baseline v4.0.0 Prior IP)
Author: Koki Sato / Praxeophysics Institute
Specification License: CC BY 4.0 International
Reference Code License: Apache License 2.0

Canonical Glossary: 04_Praxeophysics_Canonical_Glossary_EN
Japanese Bilingual Edition: 05_Praxeophysics_Protocol_and_Glossary_JA
Master Index: 00_Praxeophysics_Master_MOC

1. Architectural Overview & Core Principles

The Praxeophysics Protocol (prxs) defines a domain-neutral, self-sovereign computational architecture that shifts the locus of adaptation from rigid external standards to the individual’s internal priors. Grounded in the Free Energy Principle (Active Inference), Praxeology (Demonstrated Preference, Subjective Value, and Synallactics), and Buddhist/Critical Epistemology (Apoha Threshold Demarcation & Two-Tier Separation), the protocol minimizes variational friction across physical environments, multi-agent couplings, and polycentric institutions

flowchart LR
    subgraph Sources["External Data Sources"]
        S0["Diagnostics / Sensors / Preferences"]
    end
    subgraph Blanket["Individual's Markov Blanket (Self-Sovereign Boundary)"]
        P1["1. Ingestion Pipeline<br>Importer → Mapper → Extractor<br>Inverse Precision Inference"]
        P2["2. Storage Pipeline<br>Personal Data Store (Holder)<br>Epoch Revocation"]
        P3["3. Verification Pipeline<br>Selective Disclosure / ZKP<br>Plausible Deniability Pooling"]
        P4["4. Adapter & Personal Agent<br>4-Step A2A Handshake"]
        P1 --> P2 --> P3 --> P4
    end
    subgraph Domains["External Execution Domains"]
        D1["Domain I (N=1)<br>Environmental Alignment"]
        D2["Domain II (N≥2)<br>Complementary Reconciliation / Exit"]
        D3["Domain III (N≥2)<br>Strategy-Proof ZKP Settlement"]
    end
    S0 --> P1
    P4 --> D1 & D2 & D3
    D1 & D2 & D3 -->|Empirical Feedback ΔI & Load L(t)| P1

1-1. Taxonomy of Adaptive Operations

Operation	Coupling Topology	Formal Condition	Canonical Definition
Adaptation	Overarching Closed Loop	Continuous across epochs $t_{k}$	The overarching process wherein a bounded system preserves its Markov blanket while minimizing variational free energy via internal generative updating and active boundary intervention
Environmental Alignment	Micro ( $N = 1$ ) Individual $\leftrightarrow$ Non-autonomous Niche	Valid Predicate $x_{d} = 1$	Optimizing external physical, spatial, or informational parameters to match a single agent’s internal prior ( $μ_{d}$ ) within its allowable tolerance radius ( $r_{d}$ )
Complementary Reconciliation	Meso ( $N \geq 2$ , Cooperative) Agent A $\leftrightarrow$ Agent B / Group	SAT ( $U_{A} \cap U_{B} \neq = \emptyset$ )	Deriving mutually consistent interface or interaction parameters that simultaneously satisfy the protective boundaries of multiple coupled agents and minimize joint variational friction
Strategy-Proof Settlement	Macro ( $N \geq 2$ , Competitive) Multi-Party $\leftrightarrow$ Institutional Rules	SAT via Reference $p_{ref}$	Executing incentive-compatible agreements over scarce resources or contracts using Zero-Knowledge Proofs (ZKP) against an independent reference threshold ( $p_{ref}$ ), preventing reservation value exploitation
Frictionless Sorting (Clean Exit)	Meso / Macro Safety Valve Multi-Agent Deadlock	UNSAT ( $U_{A} \cap U_{B} = \emptyset$ )	Decoupling an interaction without penalty and sorting agents into compatible alternative niches when mutually required protective boundaries cannot be simultaneously satisfied

1-2. Five Core Design Axioms

Individual-Origin Control (Prop_1.300, Prop_3.110):
The reference baseline for evaluation resides exclusively within the individual’s Markov blanket, never in a monolithic external standard
Orthogonal Atomic Predicates over Scalar Reduction (Prop_2.210, Prop_2.300, Prop_2.310):
Multi-dimensional states are never collapsed into a single scalar score; they are maintained as orthogonal vectors evaluated as binary guardrail predicates $x_{d} \in {0, 1}$
Structural Separation of Attributes and Contextual Rules (Prop_2.520):
Personal state representations stored in the Holder repository are strictly decoupled from contextual evaluation policies (Adapter rules), enabling zero-cost cross-domain portability
Minimization of Variational Friction (Prop_2.100, Prop_3.000):
The global objective function of the protocol is the minimization of precision-weighted prediction errors (variational free energy $\sum F_{i}$ ) across all coupled interfaces
Infrastructure and Domain Neutrality (Prop_2.510, Prop_4.410):
The protocol operates as an open upper-layer specification independent of any specific database, cryptographic primitive, user interface, or application domain

2. System Topology: 4 Pipelines, Personal Agent & 3 Execution Domains

Pipeline Stage	Module Components	Core Responsibility & Output
1. Ingestion Pipeline	`1-1. Importer` `1-2. Mapper` `1-3. Extractor`	Ingests raw external diagnostics, sensor streams, or preference inputs; maps them to shared ontology URIs (`ontologyRef`); extracts the Internal Generative State ( $μ, Π, L$ ) and derives protective boundaries via Inverse Precision Inference
2. Storage Pipeline	`2-1. Holder` (Personal Data Store)	Stores user-verified, cryptographically signed claims exclusively under self-sovereign control; enforces strict separation from contextual rules; manages Epoch Re-configuration & Credential Revocation when states change
3. Verification Pipeline	`3-1. Prover` `3-2. Verifier`	Evaluates binary Apoha predicates $x_{d} (t) \in {0, 1}$ against contextual rule circuits $R_{c}$ ; executes Selective Disclosure in cooperative contexts or Zero-Knowledge Proofs in asymmetric contexts; enforces Plausible Deniability by pooling protective constraints with everyday preferences
4. Reconciliation & Alignment Pipeline	`4-1. Adapter` Cross-Cutting: `[[Term_Personal_Agent_A2A\\|Personal Agent]]`	Executes the 4-step A2A handshake (`1. Schema Exchange` $\to$ `2. Request Policy` $\to$ `3. Submit Proof` $\to$ `4. Issue Settlement`); outputs domain-neutral Alignment Parameters or Reconciliation Directives to external execution systems

External Execution Domains

Domain I: Physical & Somatic Niche (Micro: $N = 1$ )
- Scope: Dietary and allergen filtering, spatial control (lighting, acoustics, thermal parameters, etc.), ergonomic hardware adjustment, adaptive information rendering, etc.
- Protocol Output: Alignment Parameter Vector (enforcing Plausible Deniability)
Domain II: Inter-Agent Coupling (Meso: $N \geq 2$ Cooperative)
- Scope: Dyadic or multi-agent pairing, complementary precision delegation, asynchronous communication protocols, non-penalized UNSAT sorting, etc.
- Protocol Output: Reconciliation Directive Token (COMPLEMENTARY_PRECISION_SYNC, INTERFACE_SCHEMA_MEDIATION, ALLOSTATIC_LOAD_RELIEF, or FRICTIONLESS_EXIT_SORTING)
Domain III: Institutional Governance & Resource Allocation (Macro: $N \geq 2$ Competitive)
- Scope: Strategy-proof bilateral contracting, scarce facility or budget allocation, Alternative Dispute Resolution (ADR), polycentric rule adoption, etc.
- Protocol Output: ZKP Settlement Attestation against independent reference $p_{ref}$

3. Mathematical Specification: Dynamic Boundary Generative Model & Inverse Precision Inference

Under the Laplace approximation (Gaussian generative density $N (μ, Π^{- 1})$ ), an agent’s internal continuous state across $D$ orthogonal dimensions is parameterized by the Internal Generative State ( $μ, Π, L (t)$ ):

Prior Mean Vector ( $μ \in R^{D}$ ) (Prop_1.300, Prop_3.110):
The baseline expectation value in each dimension $d \in {1, \dots, D}$ where prediction error is zero
Precision Weighting Vector ( $Π \in R_{+}^{D}$ ) (Prop_2.400, Prop_3.300):
The inverse variance ( $Π_{d} = σ_{d}^{- 2}$ ) representing sensitivity or attentional commitment to dimension $d$ , governed by the finite resource conservation law:
$d = 1 \sum D Π_{d} = Π_{budget} < \infty$
Normalized Allostatic Load ( $L (t) \in [0, 1)$ ) (Prop_1.100, Prop_2.410):
Cumulative unresolved variational free energy integrated over recent epochs, reducing the agent’s remaining homeostatic capacity $C (t) = 1 - L (t)$

Precision-Tolerance Reciprocity & Binary Predicate Projection

Given an external stimulus or coupling state $s_{d}$ in dimension $d$ , the instantaneous variational free energy (friction) is:
$F_{d} (s_{d}) = \frac{1}{2} Π_{d} (s_{d} - μ_{d})^{2}$

Applying the Threshold Demarcation (Apoha) Function (Prop_2.210) against the remaining homeostatic capacity $1 - L (t)$ directly yields the binary Atomic Predicate $x_{d} (t) \in {0, 1}$ and the Allowable Tolerance Radius $r_{d} (t)$ :

Binary Guardrail Predicate:
$x_{d} (t) = I (\frac{1}{2} Π_{d} (s_{d} - μ_{d})^{2} \leq 1 - L (t)) \in {0, 1}$
Allowable Tolerance Radius (Inverse Precision Formula):
$r_{d} (t) = \frac{2 ( 1 - L ( t ))}{Π _{d}} (such that x_{d} (t) = 1 ⟺ ∣ s_{d} - μ_{d} ∣ \leq r_{d} (t))$

This formulation establishes three structural properties:

Inverse Precision Inference (Prop_5.220): Because $Π_{d}$ resides in the denominator, dimensions where an agent exhibits high positive commitment (high $Π_{d}$ ) possess a narrow tolerance radius $r_{d} (t)$ (high sensitivity to mismatch), whereas low-commitment dimensions (low $Π_{d}$ ) possess a wide tolerance radius. Candidate protective guardrails can thus be inferred from positive commitment inputs without requiring direct self-reporting of vulnerabilities
Allostatic Contraction (Prop_2.410): As cumulative load $L (t) \to 1$ , the numerator $1 - L (t)$ approaches zero, contracting $r_{d} (t)$ across all dimensions and triggering early guardrail breaches in high-precision dimensions
Multi-Blanket SAT / UNSAT Criterion (Prop_4.400): For two coupled agents $A$ and $B$ , a mutually viable shared state $u_{d}$ exists in dimension $d$ (SAT) if and only if their tolerance radii intersect:
$∣ μ_{A, d} - μ_{B, d} ∣ \leq r_{A, d} (t) + r_{B, d} (t)$

4. Wire Format Schema & Reference Implementation (v4.1.0)

4-1. W3C VC v2.0 Compatible Credential Schema (JSON-LD)

{
  "@context": [
    "https://www.w3.org/ns/credentials/v2",
    "https://praxeophysics.org/ns/protocol/v4.1"
  ],
  "type": ["VerifiableCredential", "PraxeophysicsBoundaryClaim"],
  "issuer": "did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK",
  "validFrom": "2026-08-31T00:00:00Z",
  "credentialStatus": {
    "id": "urn:praxeophysics:revocation:epoch-2026-08",
    "type": "EpochRevocationList2026"
  },
  "credentialSubject": {
    "id": "did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK",
    "ontologyRef": "urn:praxeophysics:ontology:core:v4.1",
    "predicateCommitment": "0x9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08",
    "reconciliationProfile": {
      "verificationMode": ["SelectiveDisclosure", "ZeroKnowledgeProof"],
      "plausibleDeniabilityPooling": true
    }
  }
}

4-2. TypeScript Core Engine (Domains I, II, and III)

/**
 * Praxeophysics Protocol (prxs) v4.1.0 — Canonical Reference Implementation
 * Copyright (c) Koki Sato / Praxeophysics Institute
 * Licensed under the Apache License, Version 2.0
 */
 
export interface BlanketGenerativeState {
  mu: number[];   // 1. Prior Mean Vector (Prop 1.300, 3.110)
  Pi: number[];   // 2. Precision Weighting Vector (Prop 2.400, 3.300: sum(Pi) = const)
  L_load: number; // 3. Normalized Allostatic Load in [0, 1) (Prop 1.100, 2.410)
}
 
export type AdaptationMode = 'perceptual_update' | 'active_alignment';
 
export interface SingleBlanketEvaluation {
  dimension_vfe: number[];
  instant_total_vfe: number;
  allowable_radii: number[];      // Derived via Inverse Precision Inference: r_d(t) = sqrt(2(1-L)/Pi_d)
  atomic_predicates: boolean[];   // Binary Guardrail Predicates x_d in {0, 1} (Prop 2.210)
  pooled_output_flags: boolean[]; // Plausible Deniability Pooled Flags z_d (Prop 5.310)
  recommended_modes: AdaptationMode[];
}
 
export class PraxeophysicsBlanketEngine {
  /**
   * Domain I (N = 1): Evaluates single-agent alignment and applies Plausible Deniability pooling
   */
  public static evaluateAlignment(
    state: BlanketGenerativeState,
    stimulusVector: number[],
    ordinaryPreferenceFlags: boolean[] = [],
    envPrecisionBaseline = 1.0
  ): SingleBlanketEvaluation {
    const { mu, Pi, L_load } = state;
    const remainingCapacity = Math.max(0, 1.0 - L_load);
    const D = mu.length;
 
    const dimVFE: number[] = [];
    const radii: number[] = [];
    const predicates: boolean[] = [];
    const pooledFlags: boolean[] = [];
    const modes: AdaptationMode[] = [];
    let totalVFE = 0;
 
    for (let d = 0; d < D; d++) {
      const safePi = Math.max(Pi[d], 1e-6);
      const epsilon = stimulusVector[d] - mu[d];
      const f_d = 0.5 * safePi * Math.pow(epsilon, 2);
      const r_d = Math.sqrt((2.0 * remainingCapacity) / safePi);
      const isSatisfied = f_d <= remainingCapacity;
 
      dimVFE.push(f_d);
      radii.push(r_d);
      predicates.push(isSatisfied);
      totalVFE += f_d;
 
      const prefFlag = ordinaryPreferenceFlags[d] ?? false;
      pooledFlags.push(!isSatisfied || prefFlag);
 
      modes.push(safePi >= envPrecisionBaseline ? 'active_alignment' : 'perceptual_update');
    }
 
    return {
      dimension_vfe: dimVFE,
      instant_total_vfe: totalVFE,
      allowable_radii: radii,
      atomic_predicates: predicates,
      pooled_output_flags: pooledFlags,
      recommended_modes: modes
    };
  }
}
 
export type ReconciliationDirective =
  | 'COMPLEMENTARY_PRECISION_SYNC'
  | 'INTERFACE_SCHEMA_MEDIATION'
  | 'ALLOSTATIC_LOAD_RELIEF'
  | 'FRICTIONLESS_EXIT_SORTING';
 
export interface MultiBlanketReconciliationResult {
  prior_divergence_score: number;
  precision_asymmetry_score: number;
  joint_vfe_load: number;
  unsat_dimensions: number[];
  is_satisfiable: boolean;
  directive: ReconciliationDirective;
  focus_dimension_indices: number[];
}
 
export class MultiBlanketReconciliationAdapter {
  /**
   * Domain II (N >= 2 Cooperative): Computes coupling friction and issues a Reconciliation Directive
   */
  public static reconcileCoupling(
    agentA: BlanketGenerativeState,
    agentB: BlanketGenerativeState,
    loadAlertThreshold = 0.75
  ): MultiBlanketReconciliationResult {
    const D = agentA.mu.length;
    const capA = Math.max(0, 1.0 - agentA.L_load);
    const capB = Math.max(0, 1.0 - agentB.L_load);
 
    let priorDivergence = 0;
    let precisionAsymmetry = 0;
    const dimFriction: number[] = [];
    const unsatDims: number[] = [];
 
    for (let d = 0; d < D; d++) {
      const piA = Math.max(agentA.Pi[d], 1e-6);
      const piB = Math.max(agentB.Pi[d], 1e-6);
      const deltaMu = Math.abs(agentA.mu[d] - agentB.mu[d]);
 
      const harmonicPi = (piA * piB) / (piA + piB);
      const minJointVFE = 0.5 * harmonicPi * Math.pow(deltaMu, 2);
      const asymScore = Math.abs(piA - piB) * deltaMu;
 
      dimFriction.push(minJointVFE + 0.3 * asymScore);
      priorDivergence += minJointVFE;
      precisionAsymmetry += asymScore;
 
      const radiusA = Math.sqrt((2.0 * capA) / piA);
      const radiusB = Math.sqrt((2.0 * capB) / piB);
      if (deltaMu > radiusA + radiusB) {
        unsatDims.push(d);
      }
    }
 
    const focusDims = dimFriction
      .map((val, idx) => ({ val, idx }))
      .sort((a, b) => b.val - a.val)
      .slice(0, 2)
      .map(x => x.idx);
 
    const isSAT = unsatDims.length === 0;
    let directive: ReconciliationDirective = 'INTERFACE_SCHEMA_MEDIATION';
 
    if (agentA.L_load >= loadAlertThreshold || agentB.L_load >= loadAlertThreshold) {
      directive = 'ALLOSTATIC_LOAD_RELIEF';
    } else if (!isSAT) {
      directive = 'FRICTIONLESS_EXIT_SORTING';
    } else if (precisionAsymmetry > priorDivergence) {
      directive = 'COMPLEMENTARY_PRECISION_SYNC';
    }
 
    return {
      prior_divergence_score: priorDivergence,
      precision_asymmetry_score: precisionAsymmetry,
      joint_vfe_load: priorDivergence + 0.3 * precisionAsymmetry,
      unsat_dimensions: unsatDims,
      is_satisfiable: isSAT,
      directive,
      focus_dimension_indices: focusDims
    };
  }
 
  /**
   * Domain III (N >= 2 Competitive): Strategy-Proof Reference Settlement (Prop 4.300, 5.330)
   */
  public static evaluateStrategyProofSettlement(
    sellerMinReservation: number,
    buyerMaxReservation: number,
    independentReferenceValue: number
  ): { is_settled: boolean; settlement_value: number | null } {
    const isViable =
      sellerMinReservation <= independentReferenceValue &&
      independentReferenceValue <= buyerMaxReservation;
    return {
      is_settled: isViable,
      settlement_value: isViable ? independentReferenceValue : null
    };
  }
}

5. Attribution & Prior IP Continuity Statement

Continuity with Baseline Prior IP (v4.0.0):
This specification (v4.1.0) is a direct mathematical formalization and reference implementation of the Praxeophysics Protocol Baseline Specification (v4.0.0, finalized prior to September 1, 2026), conceived and developed independently by Koki Sato as pre-existing intellectual property (Prior IP) without the use of any third-party proprietary assets, confidential information, or organizational resources
Boundary of Open Standard vs. External Adapters:
The open standard defined herein covers the domain-neutral data schemas, the Dynamic Boundary Generative Model state representation, Inverse Precision Inference, Verification logic, and the abstract Reconciliation Directive tokens. Any domain-specific mapping weights, proprietary datasets, or application-layer execution interfaces connected via external Adapters remain independent of this core protocol specification

Quartz 5

Explorer

03_Praxeophysics_Protocol_Specification_EN