memex/notes/passepartout-whitehead.org

Whitehead's Logic & Process Philosophy → Passepartout

• Purpose
• Historical Connection: PM → Lisp
• Contribution 1: Ramified Theory of Types → Gate Stack
  • The Problem PM Solved
  • The Problem Passepartout Faces
  • The PM-Type Solution
  • Concrete Implementation
• Contribution 2: Theory of Descriptions → Reference Resolution
  • The Problem PM Solved
  • The Problem Passepartout Faces
  • The PM-Description Solution
• Contribution 3: Process and Reality → Architectural Vocabulary
  • Mapping Whiteheadian Concepts to Passepartout
  • The Foveal-Peripheral Model in Whiteheadian Terms
  • Why This Matters for Self-Documentation
• Contribution 4: VivaceGraph + PM Types (v3.0.0)
• What Would NOT Be Useful
  • Implementing PM's Full Formalism
  • Process Theology
  • Full Whiteheadian Metaphysics
• Summary: What to Ship and When
• Relation to Passepartout's Neuro-Symbolic Architecture

Purpose

Alfred North Whitehead's two major bodies of work — Principia Mathematica (1910–1913, with Bertrand Russell) and Process and Reality (1929) — are assessed for their applicability to Passepartout's architecture, gate stack, knowledge graph, and self-descriptive vocabulary.

Historical Connection: PM → Lisp

Principia Mathematica is a direct ancestor of Lisp. Alonzo Church's lambda calculus (1930s), from which John McCarthy built Lisp (1958), was a response to PM's foundational program. PM's notation:

(x).φx        ≡ (for all x, φ holds of x)
(∃x).φx       ≡ (there exists x such that φ holds)
* x̂(φx)        ≡ (the class of x satisfying φ)
ιx(φx)         ≡ (the unique x satisfying φ)

These map directly to Lisp: (lambda (x) (φ x)), (class (x) (φ x)), (the (x) (φ x)). McCarthy cited PM as an influence. The connection is genetic, not metaphorical.

Contribution 1: Ramified Theory of Types → Gate Stack

The Problem PM Solved

Russell's paradox ("the set of all sets that do not contain themselves") proved that unrestricted comprehension produces contradictions. PM's solution: a ramified theory of types that assigns every propositional function a type level. A function can only apply to arguments of a lower type — self-application is syntactically invalid.

The Problem Passepartout Faces

Passepartout's dispatcher gate stack (vectors 0–8b active, 9–18 planned) currently enforces safety through runtime predicates. But there is no structural guarantee preventing a request from modifying the rules that validate it. Gate vector 2 (self-build-core) catches this empirically — a request modifies core → rejected. But this is a heuristic, not a theorem.

The PM-Type Solution

Assign every cognitive tool a :type-level integer. Assign every gate vector a :type-level integer. The dispatcher framework, before running any gate predicate, checks:

(defun gate-type-check (signal gate-vector)
  (let ((signal-type-level (getf (signal-meta signal) :type-level))
        (gate-type-level (gate-vector-type-level gate-vector)))
    (if (>= signal-type-level gate-type-level)
        :reject-type-violation  ; self-referential — reject
        :pass)))                ; safe — proceed to predicate

A request to modify dispatcher rules (type-level 5) cannot pass a gate of type-level 4 or lower. No predicate needed — it's a structural prohibition, just as PM's theory of types makes self-membership syntactically invalid.

Concrete Implementation

• defgate gains a :type-level keyword argument (default 0)
• Each cognitive tool registered via def-cognitive-tool inherits a :type-level
• The dispatcher's run-gates function checks type-level before predicate evaluation
• Gate vector 2b (self-build-core) at type-level 5; write-file at type-level 3; read-file at type-level 1
• 30 lines in ~core-dispatcher.lisp~; no new dependencies; v0.7.2 viable

Contribution 2: Theory of Descriptions → Reference Resolution

The Problem PM Solved

PM's theory of descriptions addresses: "the current king of France is bald" — a sentence that seems to refer to something that doesn't exist. PM formalizes:

ιx(φx) = "the unique x such that φ holds"

A statement about ιx(φx) is false (not meaningless) when there is no unique x satisfying φ. This is the origin of definite description semantics in modern linguistics and programming.

The Problem Passepartout Faces

When the user says "the function that validates secrets," the agent must resolve this to a specific code entity. Natural language is ambiguous — there might be multiple functions matching the description. Resolving to the wrong one causes incorrect actions.

The PM-Description Solution

A cognitive tool that checks descriptional uniqueness before resolution:

(def-cognitive-tool :resolve-reference
    (query-string &key (max-candidates 10)
                   (context-path *current-context*))
  "Resolve a definite description to a unique referent."
  (let ((candidates (search-knowledge-graph query-string
                                               :source-path context-path
                                               :limit max-candidates)))
    (cond
      ((null candidates)
       (values nil :no-referent query-string))
      ((> (length candidates) 1)
       (values nil :ambiguous candidates))
      (t
       (values (first candidates) :unique nil)))))

~40 lines as a skill in v0.7.2. When VivaceGraph ships (v3.0.0), descriptions become native Prolog queries with uniqueness constraints.

Contribution 3: Process and Reality → Architectural Vocabulary

Whitehead's process philosophy is a metaphysics of becoming rather than being. The fundamental entities are not substances (atoms, objects) but processes (actual entities, occasions of experience. This maps precisely to Passepartout's pipeline architecture.

Mapping Whiteheadian Concepts to Passepartout

Whiteheadian Concept	Passepartout Mapping	Significance
Actual entity (actual occasion)	An event/signal in the pipeline	The fundamental unit — everything else is abstraction
Prehension	A gate's grasping of a signal	How one entity "takes account of" another
Positive prehension	A gate passing a signal	The signal is included in the concrescence
Negative prehension	A gate rejecting a signal	The signal is excluded from the concrescence
Concrescence	The pipeline process from input to output	Many prehensions → one satisfaction
Subjective aim	The agent's active goal / plan	The telos directing which prehensions matter
Eternal objects	Pure concepts in the knowledge graph	Universals — types, functions, categories
Nexus	A cluster of related memory objects	A Merkle subtree
Satisfaction	The final agent response	The "completed" entity — determinate output
Transition	From one signal to the next	The pipeline's forward motion
Causal efficacy	The agent's past context (memory)	What is prehended from the settled past
Presentational immediacy	The current signal (user input)	What is prehended from the immediate present

The Foveal-Peripheral Model in Whiteheadian Terms

Passepartout's foveal-peripheral model (near focus = current signal, far periphery = context window + memory) maps to Whitehead's distinction:

• Presentational immediacy (perception of the contemporary world, vivid but superficial) = foveal focus on the current signal
• Causal efficacy (prehension of the past, dim but causally powerful) = peripheral context from memory

This is not merely poetic. Whitehead argues that all perception is in the "mixed mode" of symbolic reference — the synthesis of presentational immediacy and causal efficacy. Passepartout's think() function does exactly this: it synthesizes the current signal (presentational immediacy) with context from memory (causal efficacy) into a response.

Why This Matters for Self-Documentation

Passepartout already has the pipeline. Whitehead gives it a descriptive vocabulary:

• "I am concrescing signal 47 through gates 0-8" ≠ poetry — it's a precise description of dispatcher operation.
• "Gate 3 has negatively prehended signal 136" = "the secret-content gate rejected signal 136."
• "The satisfaction includes a file-write prehension with Merkle commit abc123" = "the response contains a file write with the given merkle hash."

The agent can use this vocabulary in its /why output (gate trace in human-readable form) and in the ARCHITECTURE.org documentation. The terms are precise, standard (Whitehead's Process and Reality is a recognized philosophical text), and already map perfectly to Passepartout's design.

Contribution 4: VivaceGraph + PM Types (v3.0.0)

When the knowledge graph ships in v3.0.0, every entity inherits PM's type hierarchy:

• Entities have :pm-type-level metadata
• Queries cannot return entities of the same level as the querying function
• Self-referential knowledge becomes structurally impossible — no "this entity defines its own type level"
• The KG query layer enforces this at the Prolog level, not through runtime checks

This is the same contribution as Contribution 1, but applied to the knowledge base rather than the execution layer. The dispatcher prevents self-referential actions; the KG prevents self-referential facts.

What Would NOT Be Useful

Implementing PM's Full Formalism

PM takes 300+ pages to prove 1+1=2. The notation (*54·43) is notoriously unreadable. Using it as a reasoning engine would be a catastrophic waste of effort — the ideas (type theory, descriptions, propositional functions) are what matter, not the notation. Implement the ideas, not the pages.

Process Theology

Whitehead's later work includes a concept of God (the "principle of concretion," the "Eros of the Universe") that has no useful mapping to an agent architecture. Skip it.

Full Whiteheadian Metaphysics

The 25 categories of existence, the eight categories of explanation, the nine categoreal obligations — these are philosophical commitments, not engineering requirements. Select the concepts that map to the architecture; don't build a process-philosophy engine.

Summary: What to Ship and When

Contribution	Lines	Depends On	Earliest Release	Impact
Type-level gates	~30	dispatcher	v0.7.2	Provable safety against self-modification
Description tool	~40	search	v0.7.2	Better reference resolution
Whiteheadian doc vocabulary	prose	docs/	anytime	Sharper architectural self-description
KG type hierarchy	built-in	VivaceGraph	v3.0.0	Structural anti-self-reference in facts

Whitehead is the rare case where philosophy is directly engineerable. PM's type theory is the solution to a real Passepartout problem; the process ontology describes the pipeline more precisely than any existing vocabulary.

Relation to Passepartout's Neuro-Symbolic Architecture

Passepartout is level 4 neuro-symbolic (symbolic gates + neural LLM, deterministic components coordinate heterogeneous systems). PM's type theory adds level-5 properties: structural safety guarantees rather than empirical ones. The dispatcher becomes not just a runtime gate stack but a type-theoretic framework where category errors are impossible by construction — just as PM made Russell's paradox impossible by construction.

The Whiteheadian vocabulary reinforces the architectural identity: Passepartout is not a chatbot with safety checks. It is a process — a continuous concrescence of prehensions producing satisfactions — whose safety is guaranteed by the type structure of the prehending entities.