#Dependency Graph & Proofs

Pattern B.1.1 · Stable Part B - Trans-disciplinary Reasoning Cluster

In FPF, every aggregation is a material act:

#Keywords

• dependency graph
• proofs
• structural aggregators
• sum
• set
• slice.

#Relations

#Content

#Problem frame

In FPF, every aggregation is a material act:

Γ : (D : DependencyGraph, T : U.TransformerRole) → H′ : U.Holon

D is the only admissible input shape for Γ. It must capture part–whole structure faithfully (A.1, A.14) while staying neutral to order (handled by Γ_ctx / Γ_method), time (Γ_time), and accounting (Γ_work). If D is sloppy—mixing kinds of relations or scopes—Γ becomes unpredictable and the Quintet invariants (IDEM, COMM, LOC, WLNK, MONO) fail in subtle ways.

This pattern normatively defines DependencyGraph, the mereological vocabulary allowed on its edges, and the guards that make Γ provable and comparable across domains.

#Problem

Without a disciplined DependencyGraph, four pathologies recur:

1. Relation drift: Edges blur composition with mapping (e.g., “represents”), or confuse collections with parts. Aggregations then mix algebraic regimes (sums where mins are required, etc.).
2. Boundary blindness: Cross‑holon influences are drawn as parts, bypassing explicit U.Boundary and U.Interaction. This corrupts locality (LOC) and defeats reproducible folding.
3. Temporal conflation: design‑time and run‑time holons appear in one graph; simulations then “prove” facts about a blueprint using live telemetry.
4. Hidden cycles: Self‑dependence enters through aliasing (e.g., a team is a member of itself via “units of units”). Γ cannot topologically fold such graphs.

#Forces

#Solution

#The shape: a typed, scoped, acyclic graph

Definition.

DependencyGraph D = (V, E, scope, notes)

• V (nodes): each v ∈ V is a U.Holon with:

  • holonKind ∈ {U.System, U.Episteme}
  • DesignRunTag ∈ {design, run} (A.4) — single, uniform per D
  • a declared U.Boundary (A.14)
  • optional characteristics (e.g., F–G–R, CL, Agency metrics) for use by downstream patterns (B.1.2/3; B.3; A.13)

• E (edges): each e ∈ E is a mereological relation from the normative vocabulary V_rel (below).

• scope: the uniform temporal scope of the entire graph (design or run).

• acyclicity: D MUST be a DAG. Any cycle requires refactoring or elevation to a Meta‑Holon (B.2).

Strict distinction (A.15). DependencyGraph encodes part–whole only. Order goes to Γ_ctx/Γ_method. Time evolution goes to Γ_time. Resource spending goes to Γ_work. Cross‑boundary influence goes to U.Interaction (not parthood).

#Normative edge vocabulary V_rel (A.14 compliant)

Only the following four mereological relations are allowed in E (A.14):

Not in V_rel (by design):

• SerialStepOf, ParallelFactorOf — order/concurrency edges of Γ_method/Γ_ctx; not parthood; keep them out of E (see § 4.1 A.15 and Part B.1.5).
• MemberOf — non‑mereological collective membership; model in Γ_collective (B.1.7), not in E (see § 9).
• RepresentationOf, MapsTo, Implements — these are mappings, not parthood; model them at the value level (A.15) or as U.Interaction between holons.
• RoleBearerOf — links a U.System to a U.Role; not parthood (see A.12, A.15).
• Any “is‑a” (subClassOf) taxonomic relation — orthogonal to parthood.

#Minimal axioms & type guards per relation

Carrier identity for PhaseOf. The “same thing across phases” must be explicit (e.g., this frame across heat/dwell/quench; this theory across revisions). If identity changes, you are modelling a Transformer creating a new holon (A.12) — not a phase.

#Selection guide (didactic, normative in spirit)

Use this one‑page decision to pick the edge correctly:

1. Is it a part–whole relation at all? If it is mapping, influence, or reference → not parthood. Use U.Interaction or value‑level links (A.15).

2. Is it physical vs. conceptual composition? Physical assembly → ComponentOf. Conceptual/content inclusion → ConstituentOf.

3. Is it a collection? If the “whole” is a collection/collective → MemberOf (outside E, route to Γ_collective (B.1.7)). Note: a team’s members are MemberOf (outside E); the team’s tools are likely ComponentOf.

4. Is it order‑sensitive execution? If step order changes semantics → route to A.15 (ordered relations) and aggregate with Γ_ctx / Γ_method. Do not encode order as parthood in this section.

5. Is it a quantitative fraction of a homogeneous stock? If yes → PortionOf (requires an extensive attribute; use in Γ_sys / Γ_work).

6. Is it the same carrier across time? If yes → PhaseOf (then aggregate with Γ_time / Γ_work).

Common anti‑patterns and the fix • Using MemberOf for material stocks → replace with PortionOf. • Drawing cross‑boundary “parts” → replace edge with U.Interaction plus ComponentOf inside each holon. • Using ConstituentOf for a module cage or bracket → that is ComponentOf. • Treating representation (file ↔ thing) as parthood → keep as value‑level mapping (A.15), not in D.

#Γ_m (Compose‑CAL) — structural aggregators & trace shape

Purpose. Provide a minimal constructional generator for structural mereology that keeps the kernel small (C-5), aligns with A.14 (Portions/Phases/Components discipline), and feeds Working-Model layer publication in LOG without importing tooling or notations.

Operators (aggregators).

Γ_m.sum(parts : Set[U.Entity]) → W : U.Holon // for each p ∈ parts assert internal U.KernelPartOf(p, W)

Γ_m.set(elems : Multiset[U.Entity]) → C : U.Holon // for each e ∈ elems assert internal U.KernelPartOf(e, C) // outward MemberOf remains a non‑mereological signal per A.14 (does not build holarchies)

Γ_m.slice(ent : U.Entity, facet : U.Facet) → S : U.Holon // assert internal U.KernelPartOf(S, ent) and record facet label

Trace (conceptual, notation‑independent).
Trace = ⟨ op ∈ {sum, set, slice}, inputs, output, notes ⟩
Notes capture boundary tags (A.14), scope (design|run), and any independence declarations used by the Quintet proofs (below).

Invariant footprint on Γ_m traces (inherits B.1 Quintet).

• IDEM — singleton fold returns the part unchanged.
• COMM/LOC — results are invariant under re‑order and local factorisation given an independence declaration (IND‑LOC).
• WLNK — aggregate cannot exceed the weakest limiting attribute among parts; synergy escalates via B.2 Meta‑Holon Transition.
• MONO — improving a part on a monotone characteristic cannot worsen the whole, ceteris paribus.

Exclusions and routing (A.15/A.14).
No parallel or temporalSlice constructor is introduced here; sequence/parallelism live in Γ_ctx/Γ_method, and temporal parts in Γ_time. This preserves the firewall between structure, order and time mandated by A.15/A.14.

Internal proof relation.
U.KernelPartOf names the constructional edges inside traces; it is not part of the public V_rel and appears only in the trace/proof narrative (definitional didactic status).

#Scope and boundary rules (make graphs foldable)

1. Single temporal scope: all nodes in D share design or run. No mixing (“chimera” graphs are invalid).
2. Declared boundary: every holon in D has a U.Boundary; any cross‑holon influence must be an explicit U.Interaction, not parthood.
3. Acyclicity: if a cycle is detected, either (a) refactor (e.g., split a collective from an assembly), or (b) escalate to Meta‑Holon Transition (B.2) if a new “whole” with novel properties is intended.
4. Order & time routing: do not encode sequence or history with structural edges; route to Γ_ctx / Γ_method / Γ_time explicitly.
5. Resource routing: do not encode costs with structural edges; route to Γ_work (B.1.6) across declared boundaries.

#What “Proofs” mean here (preview of Part 2)

Each Γ flavour (Γ_sys / Γ_epist / Γ_method / Γ_time / Γ_work) must attach a small, reusable Proof Kit showing the Quintet on the given D:

• IDEM: singleton fold = identity.
• COMM/LOC: independence conditions + invariance under local reorder/factorisation.
• WLNK: weakest‑link bound (e.g., critical input caps, weakest claim).
• MONO: explicit monotone characteristics (what “cannot get worse” means here).

#Didactic mini‑examples

• System (assembly): a motor ComponentOf a chassis; wiring harness ComponentOf the motor; a crew MemberOf a team holon (the crew is not a component of the chassis).
• Episteme (paper): a lemma ConstituentOf a proof; appendices ConstituentOf the paper; three datasets MemberOf a curated collection; version v2 PhaseOf the same model.

#The Proof Kit (ready‑made templates for Γ on D)

This section provides small, reusable proof obligations you attach to a DependencyGraph D when invoking any Γ‑flavour. Each obligation is minimal—just enough to guarantee the Invariant Quintet for the stated scope and edge set.

#Independence declaration (for COMM/LOC)

Obligation IND‑LOC. Provide a partition of D into subgraphs {Dᵢ} such that:

1. Their node sets are disjoint (no shared holon instances).
2. Their boundaries are disjoint (no shared ports) or any shared internal stock is lifted to the parent boundary in notes.
3. No edge in E crosses partitions except via explicit U.Interaction (not parthood).

Claim: Under IND‑LOC, Γ’s fold result is invariant to local fold order within and across {Dᵢ}.

#Weakest‑link cutset (WLNK)

Obligation WLNK‑CUT. Enumerate a critical set C ⊆ V ∪ E (nodes/edges) such that failure (or insufficiency) of any element of C makes the aggregation invalid or unsafe in the chosen Γ‑flavour.

Claim: For the target property, the result for the whole is bounded by the minimum (or tightest cap) across C. Examples: • Γ_sys → tensile strength cutset along a load path; • Γ_epist → weakest supported premise in a proof spine; • Γ_work → availability caps for required inputs across the boundary.

#Monotone coordinates (MONO)

Obligation MONO‑AX. Declare the monotone characteristics (attributes whose improvement cannot worsen the whole) for this call. Specify how “improvement” is recognized.

Claim: If only monotone characteristics change in the direction of improvement while all else is fixed, the aggregate’s target value cannot degrade.

Examples: • Γ_sys → increased component reliability, tighter tolerance; • Γ_epist → stronger evidence, higher formality; • Γ_method → reduced step duration, stronger step assurance; • Γ_time → added non‑overlapping coverage; • Γ_work → higher yield η, reduced dissipation.

#Idempotence witness (IDEM)

Obligation IDEM‑WIT. Provide the singleton case: a subgraph D₁ with one node and no admissible composition edges.

Claim: Γ(D₁) returns that node’s property unchanged.

#Scope & boundary attestations

Obligation SCOPE‑1. Affirm DesignRunTag(D) ∈ {design, run} and that all nodes share it. Obligation BOUND‑1. List the U.Boundary for each top‑level holon in V and record any U.Interaction edges that are relevant but not part of E (to show cross‑boundary influences were not mis‑typed as parthood).

#Flavour‑specific summary table

Attach the row(s) you use as the Proof Kit to the Γ call record.

#Archetypal grounding (worked micro‑examples)

Each row is self‑contained and can be used as a template.

#U.System (assembly & production)

#U.Episteme (paper & dataset)

#Conformance Checklist (normative checklist)

#Anti‑pattern diagnostics (before → after)

#Consequences

Benefits

• Predictable composition: Γ‑folds are reproducible and auditable across domains.
• Cross‑scale clarity: Resource and time additivity are preserved by routing to Γ_work and Γ_time.
• Safer modelling: WLNK cutsets surface true constraints; emergence is not “smuggled in”.
• Didactic simplicity: A small, fixed edge vocabulary makes reviews and onboarding faster.

Trade‑offs / mitigations

• Up‑front discipline: Declaring boundaries and independence requires effort. Mitigation: reuse the Proof Kit templates; keep small, local graphs and compose.
• Refactoring legacy edges: Replacing “generic part‑of” with precise relations can be noisy. Mitigation: use the decision guide (4.4) and anti‑pattern table (9) as a script.

#Rationale (informative)

This pattern operationalizes A.14 (Mereology Extension) and A.15 (Strict Distinction) for the universal algebra of B.1. +… By limiting E to four well‑formed mereological relations, we prevent the three recurrent category errors: mapping≠parthood, order/time≠structure, collection≠stock. The Proof Kit converts the Quintet from abstract slogans into concrete obligations that engineers can check in everyday models. Γ‑flavours then remain simple and domain‑appropriate, while proofs remain small and reusable.

#Relations

• Builds on: A.1 Holonic Foundation; A.14 Mereology Extension; A.15 Strict Distinction; A.12 Transformer Principle.
• Constrained by: B.1 Universal Γ and the Invariant Quintet.
• Used by: B.1.2 Γ_sys, B.1.3 Γ_epist, B.1.4 Γ_ctx/Γ_time, B.1.5 Γ_method, B.1.6 Γ_work.
• Triggers: B.2 Meta‑Holon Transition (MHT): Recognizing Emergence and Re‑identifying Wholes when cycles or WLNK violations indicate a new emergent whole.
• Feeds: B.3 Trust & Assurance Calculus (F–G–R with Congruence) via explicit declaration of monotone characteristics and provenance.

One‑page takeaway. Keep D a DAG, pick edges from four mereological relations, route order/time/cost to their Γ‑flavours, and attach the four Proof Kit obligations (IND‑LOC, WLNK‑CUT, MONO‑AX, IDEM‑WIT) with scope/boundary notes. Do this, and the Quintet holds with minimal fuss.

#B.1.1:End