#+TITLE: Whitehead's Logic & Process Philosophy → Passepartout
#+FILETAGS: :notes:whitehead:logic:philosophy:architecture:passepartout:

* 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:

#+BEGIN_EXAMPLE
(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 φ)
#+END_EXAMPLE

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:

#+BEGIN_SRC lisp
(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
#+END_SRC

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:

#+BEGIN_EXAMPLE
ιx(φx) = "the unique x such that φ holds"
#+END_EXAMPLE

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:

#+BEGIN_SRC lisp
(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)))))
#+END_SRC

~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.