#C.13 — Constructional Mereology (Compose‑CAL)

Preface node heading:c-13-constructional-mereology-compose-cal:35228

#Content

#Intent

Provide a single, generative calculus for part–whole structure so that all structural relations in FPF are constructed (not merely declared) from three primitives and thereby inherit extensional identity by design. The calculus is hidden from day‑to‑day users behind relation aliases; its artefacts are traces that witness how a whole arises from its parts.

Also known as “Γₘ mereology”, “constructor‑based composition”.

Layer. calculus. Depends on. Kernel only (no upward imports). Consumed by. CT2R‑LOG (B.3.5) Working‑Model alias logic and any FPF pattern that needs part–whole semantics. Compose‑CAL does not import alias definitions; it merely emits traces that others may reference.

Compose‑CAL introduces a single construction operator Γₘ with exactly three constructors—sum, set, slice—sufficient to build structural wholes, collections‑as‑wholes, and aspects without extending the Kernel’s type set. No “parallel” or “temporal slice” constructor is added. Every construction yields a trace that serves as the witness for structure. Human‑facing relations such as ComponentOf, MemberOf, AspectOf are defined elsewhere as Working‑Model aliases and are grounded in these traces; Compose‑CAL itself remains purely generative and extensional.

#Problem frame & Problem

FPF presents a unified structural backbone used across disciplines. Historically, sub‑relations like ComponentOf or MemberOf were declared directly. This maximised usability but provided no generative guarantee that a new subtype was extensionally well‑behaved or reducible to common mereology.

Declared lists of part‑of sub‑relations scale poorly and lack identity guarantees. Engineers ask for a single dial (“is x part of y?”), while ontologists need a principled foundation that (a) avoids Kernel bloat and (b) proves that wholes are nothing over and above their parts. Adding yet another bespoke relation (e.g., PortionOf) should not entail schema surgery or ad‑hoc rules.

#Forces

• Parsimony (C‑5). Add no core types if composition suffices; keep the constructor set minimal.
• Minimal Kernel (P‑1). Generativity must live in a calculus pattern, not in Kernel axioms and postulates.
• Cognitive asymmetry. Everyday users want “one part‑of query”; specialists accept complexity backstage.
• Trans‑disciplinary unification. Every pattern that needs mereology should reuse one generative basis.
• Green‑field strictness. With no legacy to break, we can require grounding for new structural edges.

#Solution

#Solution sketch

Compose‑CAL SHALL provide Γₘ with three and only three constructors:

1. Γₘ.sum(parts:Set[U.Entity]) — returns a whole W such that each p in parts stands in KernelPartOf(p, W).
2. Γₘ.set(elems:Set[U.Entity]) — returns a collection C; each e in elems stands in a calculus‑internal mero:KernelPartOf(e, C) under member‑as‑part semantics (publication alias: typically ut:MemberOf). Counts/order (e.g., parallel/serial factors) are not carried here; they live in method/time families adjacent to structure. Note: although mero:KernelPartOf is transitive in the calculus, the published MemberOf alias remains non‑transitive by design (see A.14 guards).
3. Γₘ.slice(entity:U.Entity, facet:U.Facet) — returns an aspect S such that mero:KernelPartOf(S, entity) and S carries the declared facet. Temporal facets are excluded here.

Note. The calculus names an internal backbone mero:KernelPartOf; the Kernel’s public ut:PartOf/A.14 catalogue remain unchanged. Publish only via Working‑Model aliases (CT2R‑LOG).

The calculus emits a trace for every construction; Structural aliases MUST be grounded by exactly one such trace.

Non‑goals (clarifications).

• No extra constructors for “parallelism” or “time slices”; parallelism is modelled via set (with order handled in Γ_method), and temporal parts live in the appropriate temporal/system calculus. This preserves parsimony.
• Compose‑CAL does not define user‑visible relation names; those belong to the alias layer.

#Normative Standard (high‑level)

• C13‑N1. Extensional identity. Two Γₘ results are identical iff they have the same parts under the same constructor and facet conditions.
• C13-N2. Structural grounding stance. Every structural edge MUST reference exactly one Γₘ trace as its grounding witness and SHALL declare validationMode = axiomatic (see B.3.5 / E.14). Structural edges MUST NOT be published in postulate or inferential stances.
• C13‑N3. Algebraic laws. Γₘ.sum and Γₘ.set are commutative and idempotent over their inputs; Γₘ.slice composes only by facet‑compatible refinement.
• C13‑N4. Acyclicity & antisymmetry. Structural part‑of induced by Γₘ is transitive, antisymmetric, and acyclic at the level of entities. (Formal axioms appear later in this pattern.)
• C13‑N5. Separation of concerns. Γₘ provides constructions and traces; naming, aliasing and human‑level relation taxonomies are defined outside Compose‑CAL (see B.3.5 for the CT2R‑LOG handshake).
• C13‑N6. Member vs component. Γₘ.set yields collections whose Working‑Model alias is MemberOf; authors SHALL NOT infer ComponentOf from MemberOf without a separate Γₘ.sum narrative.
• C13‑N7. Domain guard. Do not apply Compose‑CAL to roles, methods, or works (see A.12/A.15): these are outside mereology.

#Scope, applicability, terms & notation

Use Compose-CAL whenever a claim concerns structural containment of entities (assemblies, collections, aspects). Compose-CAL is not used for epistemic relations between knowledge artefacts; those are epistemic relations and may be justified by Logical/Mapping and/or Empirical Validation with an explicit validationMode ∈ {inferential, postulate}. Compose-CAL is neutral with respect to domain (mechanical, biological, software, etc.).

• Γₘ — the mereological construction operator of this calculus.
• trace — a minimal, inspectable witness that a constructor was applied to given inputs to yield a whole (or aspect).
• structural part‑of — the structural relation induced by Γₘ; user‑facing aliases (e.g., ComponentOf, MemberOf) are separate patterns that must point back to traces.

Alias readiness. Typical CT2R mappings:

• ComponentOf ⇢ sum narrative;
• MemberOf ⇢ set narrative;
• AspectOf ⇢ slice narrative;
• PortionOf ⇢ slice(entity, facet="material/spatial‑region") plus metrical semantics (A.14);
• ConstituentOf (logical/content) ⇢ sum narrative over conceptual parts. (Material mixtures are not ConstituentOf; use PortionOf or ComponentOf per A.14.)

#Archetypal Grounding (System / Episteme duo)

Tell–Show–Show. Compose‑CAL is a thinking‑level calculus for building structural wholes from parts. We show it twice—first on a System (structural) and then on an Episteme case (where constructive grounding is not the primary mode).

#System (structural; constructive grounding)

Story. A Skid is assembled from its Pump, Motor, Baseframe, and Manifold.

Constructive grounding (Γ_m). Narrate a sum of parts: “Skid = sum{Pump, Motor, Baseframe, Manifold}.” This uses Γ_m.sum to obtain a whole whose parts stand in KernelPartOf; the resulting Working‑Model relation engineers publish is ut:ComponentOf on each edge from part to whole. The mapping “sum → ComponentOf” reflects the intended aliasing between constructive traces and human‑facing mereology.

Facets and collections. Need the inspection surface? Narrate Γₘ.slice(Skid, "spatial") and publish ut:AspectOf. Need a group of Transfer interactions? Narrate Γₘ.set{…} and publish ut:MemberOf—this is a collection-as-whole, not a sub‑assembly; no component identity is implied without a separate Γₘ.sum narrative.

Plane separation. Assembly order and time are not encoded here: parallel lines and schedules live in method/time families and are described adjacent to, not inside, the part‑tree.

#Episteme (knowledge‑bearing; non‑constructive first)

Story. A Mass‑Flow Representation is used to stand for a measured flow in a plant dataset.

Grounding choice. Here the Working‑Model relation (e.g., RepresentationOf) is epistemic. Authors typically justify it by inferential or postulate stances (argument or calibration cues), not by a mereological construction; constructive traces remain optional. This preserves the firewall between structure and knowledge claims while keeping a clear path to stronger assurance if the team later reframes part of the representation structurally (e.g., sets of interactions as a Γ_m.set for a flow bundle).

#Scope justification

• Universality. The trio sum / set / slice appears across mechanical assemblies, biological complexes, and organizational artifacts; aliasing to ComponentOf / MemberOf / AspectOf provides a stable Working‑Model surface for those domains.
• Parsimony. No “parallel” or “temporal slice” constructor is added; time slices belong in the temporal calculus, and parallelism is modelled as a set plus method metadata.

#Bias‑Annotation (cognitive anti‑patterns and counter‑moves)

#Conformance Checklist (normative, calculus‑level)

The following regulate how to think and write when invoking Compose‑CAL. They are notation‑agnostic and conceptual.

Author’s note. Compose‑CAL is a calculus for constructive reasoning about structure. Publishing remains in the Working‑Model layer (see B.3.5); constructive narratives are attached when the team seeks stronger assurance, never as a substitute for clear human‑facing relations.

#Consequences

Benefits

• Extensional clarity. Every structural claim is reconstructed from Γ_m.sum | Γ_m.set | Γ_m.slice: sum establishes component‑assembly identity; set establishes collection identity; slice yields aspects as parts—without expanding the Kernel.
• Human–first publication, formal–on‑demand. Teams keep publishing Working‑Model relations (e.g., ut:ComponentOf), while assurance is attached as needed via a constructive grounding narrative and tv:groundedBy (see B.3.5).
• Separation of planes preserved. Order/parallelism and temporal coverage remain in Γ_method / Γ_time; structure is never overloaded to carry them, avoiding recurrent category errors.
• Uniformity across domains. The same triad models mechanical assemblies, socio‑technical memberships, and informational wholes without domain‑specific constructors or ad‑hoc exceptions.
• Didactic economy. Authors learn one compact calculus; reviewers gain a predictable place to look for constructive justification when validationMode = axiomatic (B.3.5 alignment).
• Compositional reuse. Traces are reusable fragments of reasoning; complex wholes are narratable as sums of sub‑traces, with sets for concurrency and slices for aspect selection.

Trade‑offs / Mitigations

• Discipline cost at higher assurance. Writing a concise grounding narrative for axiomatic claims takes effort. Mitigation: reuse the micro‑templates in this pattern’s Grounding section and keep narratives notation‑free.
• Over‑use risk. Temptation to treat collections as integrated assemblies. Mitigation: keep MemberOf distinct from ComponentOf; both set and sum yield wholes, but only sum establishes component structure and assembly identity.
• Temporal leakage risk. Authors may try to smuggle time into structure via “temporal slices.” Mitigation: use Γ_time for temporal statements and slice only for intensional aspects, not for time windows.

One‑line takeaway. Compose‑CAL gives a minimal, universal how‑it‑was‑built story for any structural edge, without disturbing the human‑first publication surface defined in B.3.5.

#Rationale (informative)

Why exactly three moves? sum, set, and slice are jointly sufficient and minimally overlapping:

• sum creates an integrated whole from parts and thereby establishes component structure (assembly identity).
• set creates a collection‑as‑whole; members are parts of the collection under member‑as‑part semantics, but no component integration is implied.
• slice returns an aspect as part of its bearer (facet‑constrained, e.g., spatial/material); temporal facets are excluded here.

All three moves create new entities; sum is the only move that establishes component identity. Neither set nor slice changes the identity of their inputs, and set never upgrades membership to component status. Temporal coverage and workflow order are handled in their own planes.

This separation mirrors long‑standing distinctions between composition, collection, and aspect, while enforcing parsimony: no additional constructors are introduced into the Kernel (C‑5). The calculus remains notation‑agnostic: its meanings are given in prose and mathematics; any diagrams are illustrative only, in line with the Notational‑Independence guard‑rail (E.5).

Why constructive grounding lives outside the publication surface. FPF privileges Working‑Model relations as the canonical form for communication and design. Compose‑CAL supplies the constructive shoulder of the Assurance Layer: when authors choose validationMode = axiomatic, they narrate the whole as a sum of parts (with optional set and slice scaffolding) and point to that narrative via tv:groundedBy. This keeps the text readable while preserving a path to stronger assurance (B.3 family, Authoring Template).

Why order/time are out of scope. Correctness‑by‑sequence and temporal coverage are orthogonal to parthood. Encoding them as parts breeds contradictions (e.g., “phase‑as‑component”). Compose‑CAL deliberately refuses any “serial/parallel/temporal constructor,” delegating such concerns to Γ_method and Γ_time and aligning with B.1’s flavour separation.

#Relations

Builds on

• A.14 Advanced Mereology. Uses its structural catalogue (Component/Portion/Aspect vs Member) as the target of constructive narratives; never collapses Member into Part.
• E.5 Guard‑Rails (Notational Independence). Meanings are given in prose; diagrams are illustrative only.
• E.5 Guard‑Rails (Unidirectional Dependency). Compose‑CAL depends downward only; it never imports alias layers or higher planes.
• E.8 Authoring Conventions. Conforms to the canonical pattern template (Grounding section for architectural patterns; CC placement).

Coordinates with

• B.3.5 CT2R‑LOG. tv:groundedBy refers (conceptually) to Compose‑CAL traces when validationMode = axiomatic; Working‑Model relations remain the publication interface.
• B.1 flavours. Keeps order (Γ_method) and time (Γ_time) outside structure; may co‑appear in narratives when relevant but never as constructors.
• Kind-CAL / Lang‑CHR. Provide the Mapping shoulder of assurance (labels, type alignment) that complements constructive narratives in this pattern.
• KD‑CAL. Provides the Logical shoulder when authors justify relations inferentially instead of constructively.
• C.16 (Measurement substrate). Supplies quantitative hooks when a constructive narrative benefits from explicit counts/ratios (e.g., cardinalities, coverage), while keeping metrics distinct from mereology.

Constrains

• Any pattern that creates or reasons about structural wholes SHOULD narrate them using only sum | set | slice.
• Structural publication MUST NOT encode order/time; such claims belong to their dedicated flavours.
• Introducing new structural constructors requires a separate parsimony argument and is discouraged unless the triad cannot narrate the case without ambiguity.

Provides

• A minimal generative basis (Γ_m.sum | Γ_m.set | Γ_m.slice) and the corresponding reading discipline for constructive narratives.
• A stable interface with CT2R‑LOG for tv:groundedBy links under validationMode = axiomatic.

#C.13:End