#Wholeness Language Unpacking (RPR-WHOLE)

Pattern A.6.H · Stable · Architectural (A) · Normative Part A - Kernel Architecture Cluster

Plain-name. Wholeness / integrity / part / boundary disambiguation One-liner. Treat “whole/part/complete/holistic” as trigger words that force an explicit choice among reference level (referent vs description vs work), boundary, parthood kind, aggregation (Γ), order/time, and completeness (capability/spec/evidence).

Type: Architectural (A) Status: Stable Normativity: Normative

Placement. A.6 precision-restoration cluster; a lexical front-end to mereology and Γ selection. Specialises. A.6.P Relational Precision Restoration Suite. Works alongside. A.14 (mereology extension), B.1.1 (edge selection), B.1.4 (Γ_ctx/Γ_time), A.15 (role–method–work). Template discipline. Canonical section order and headings follow E.8.

Teams routinely use compact natural-language tokens like whole, part, integrity, holistic, and complete to gesture at multiple different things at once: a boundary, a bill-of-materials, a collective, a workflow, a lifecycle, or “end-to-end” capability. The same sentence then gets interpreted as structure, procedure, history, or competence, and the disagreement is not resolvable because the referent is under-specified.

#Keywords

• wholeness
• integrity
• part-of
• boundary
• environment
• mereology
• completeness
• order/time
• artefact-referent level
• role-method-work.

#Relations

#Content

#Problem frame

Teams routinely use compact natural-language tokens like whole, part, integrity, holistic, and complete to gesture at multiple different things at once: a boundary, a bill-of-materials, a collective, a workflow, a lifecycle, or “end-to-end” capability. The same sentence then gets interpreted as structure, procedure, history, or competence, and the disagreement is not resolvable because the referent is under-specified.

This matters because FPF’s core moves are boundary-grounded wholes (holons) and explicit composition operators (Γ). A holon is individuated by a boundary that separates inside from environment, with interactions crossing that boundary. When language collapses “whole” into a rhetorical flourish, the modeler is tempted to smuggle order, time, membership, or capability into part–whole edges, causing the classic category errors that later break Γ composition and audits.

This pattern is a practical repair protocol: it does not fight natural language; it treats its vague words as triggers that force an explicit unpacking into the minimal, typed vocabulary for wholeness claims.

#Problem

Without an unpacking discipline, the following failure modes recur:

1. Boundary ambiguity. “The whole system” is asserted with no statement of what is inside vs outside, so “environment” and “interface” debates become circular.
2. Parthood overload. “Part of” is used for physical parts, logical subsections, group membership, fractions of a stock, and lifecycle stages—then encoded as one generic inclusion.
3. Order-as-part. Teams say “Step B is part of the process” and model it as a structural inclusion, reproducing the structure-as-sequence anti-pattern.
4. History-as-part. Versions or phases are treated as subcomponents instead of time-slices of the same carrier, erasing coverage/overlap constraints.
5. Completeness conflation. “Complete/turnkey/end-to-end” is treated as “has all parts,” when the intent was capability coverage, specification coverage, or evidence coverage (role–method–work confusion).
6. Discipline/context drift. “Chemistry as a whole” alternates between meaning a method family, a social community, and a bounded context—leading to incompatible nesting stories.
7. Integrity misrouting. “Integrity” is read as “wholeness/coherence” when the author meant security/data integrity (CIA-style integrity, constraint satisfaction, tamper-resistance), producing the wrong facet unpacking and the wrong remediation.
8. Artefact–referent collapse. “The whole system is documented” / “the whole model is deployed” slides between a system and its description artefact, so inclusion edges and completeness claims get attached to the wrong level (A.15: referent vs description vs work/evidence).

The result is not merely imprecise prose; it is non-auditable modeling, because different readers (or validators) infer different decomposition rules.

#Forces

#Solution

This pattern applies the A.6.P repair recipe to the wholeness polysemy cluster by introducing a stable lens, a trigger list, a facet vocabulary, and an always-unpack rewrite discipline.

#A.6.P crosswalk (what this pattern adds)

This is a wholeness-specific binding of the generic A.6.P repair sequence:

1. Detect. WHOL triggers mark a sentence as semantically overloaded.
2. Expand. Enumerate candidate meanings along the facets (boundary, parthood, fold/Γ, order/time, completeness).
3. Discriminate. Apply the table tests (level-of-reference, transitivity, swap-test, carrier-identity test, coverage test) to eliminate candidates.
4. Rewrite. Replace the trigger token with facet headphrases + typed relations.
5. Lock-in. Record the choice (optionally via a wholenessSituation record) so the document stops re-litigating the same ambiguity.

#Lens: Boundary–Parthood–Fold–Order/Time–Completeness

When any of the trigger words below appear on a load-bearing surface, interpret the sentence through this ordered checklist and rewrite until the claim is decidable for the current purpose (i.e., the remaining ambiguity would not change the model edge(s), Γ choice, or review decision). Multiple facets may legitimately apply; “stop” only when the residual facets are irrelevant to the claim being made.

Definition WHOL-LBS-1 (load-bearing surface).
A sentence is on a load-bearing surface if it functions as a requirement ("SHALL"/"MUST"),
an invariant, an interface/boundary claim, a model edge/label, a decision record, a test oracle,
or any statement that downstream reasoning or audits depend on.

0. Term-of-art override. Is the trigger part of a defined term-of-art (glossary entry, standard term, contract term)? If yes, cite that definition and do not force WHOL facet unpacking unless the definition itself contains unresolved WHOL triggers. Clarification: this override applies to the term itself. Still unpack any separate wholeness claim the sentence makes about the term (e.g., boundary, composition, or coverage). 0.5 Reference level. Is the sentence about (i) a holon-level referent, (ii) a description artefact (spec/model/document), or (iii) an executed run/work/evidence? State the level explicitly when it affects relation choice (e.g., ConstituentOf for document structure vs StepOf/SerialStepOf for the procedure itself).
1. Boundary. If the claim is holon-level: what is the inside and what is the environment (boundary-based individuation)? Name at least one cross-boundary interaction, interface, dependency, or external constraint relevant to the claim. If there are multiple plausible boundaries (levels/resolutions), list candidates and state which boundary this claim is about.
2. Parthood kind. If “part-of” is intended, which kind is meant: ComponentOf, ConstituentOf, PortionOf, or MemberOf (collection membership)? If the claim is about a description artefact, default to ConstituentOf and keep the referent explicit (model-of vs modeled).
3. Fold. If the sentence asserts a whole-level property that depends on how parts are “glued” (not merely listed), what composition operator (Γ flavour) is implied: structure, episteme, context, time/history, method, or work/cost?
4. Order/time routing. Is the claim about a procedure graph (StepOf + order/concurrency constraints such as SerialStepOf / ParallelFactorOf), or about temporal continuity/coverage (PhaseOf aggregated via Γ_time), rather than structural containment? If the claim is about observed concurrency in a specific run, route it to work/evidence (A.15) rather than treating it as ParallelFactorOf.
5. Completeness. Is “whole/complete/end-to-end” actually about completeness in a scope: capability coverage, specification coverage, and/or evidence coverage (A.15 layer), rather than “has all parts”?

A “wholeness” statement is considered precise only after the sentence has been rewritten to answer the subset of these questions that actually matters.

#Trigger words and phrases

Treat the following as WHOL triggers on normative surfaces and in Working-Model claims.

Hard triggers (always unpack on load-bearing surfaces):

• Whole / entire / as a whole / integrated / unified / coherent
• Part / piece / component / module / element / subsystem
• Includes / consists of / composed of / contains / comprises
• Complete / end-to-end / turnkey / fully specified / self-contained
• Integrity (always classify first; see CC-A6H-10)

Conditional triggers (unpack when coupled to a wholeness frame such as “as a whole”, “part of”, “composed of”, “end-to-end”, “integrated”, or “complete”):

• Pipeline / workflow / process / step / stage
• Phase / version / revision / lifecycle
• Collection / group / team / set of

Soft triggers (unpack only when used as a wholeness predicate, not as a term-of-art):

• Holistic / holonic
• Context / environment (when asserted “as a whole” or treated as a bounded entity)

Term-of-art override. If a trigger occurs inside a defined term-of-art (e.g., “data integrity”, “integrity constraint”, “referential integrity”), cite the glossary definition and do not force WHOL unpacking unless that definition itself contains unresolved WHOL triggers.

In running prose you can still say “whole” informally, but on load-bearing surfaces these words are treated as a lintable signal: “this sentence needs a facet rewrite.”

#Canonical facet headphrases

Use these headphrases to replace the ambiguous word with the intended semantics:

A) Boundary & environment

• “the holon boundary of X is …”
• “the environment of X includes …”
• “interaction across X’s boundary is …” (not parthood)

B) Parthood kinds

• “A is ComponentOf B” for physical assembly
• “A is ConstituentOf B” for conceptual/content inclusion
• “A is PortionOf B with μ=…” for a quantitative fraction
• “A is MemberOf C” for membership in a collective (not a part–whole chain)

C) Order/time

• “A is PhaseOf carrier B over window τ” for a lifecycle slice of the same carrier (temporal continuity/coverage; not inside/outside containment)
• “Step s is StepOf procedure P” for step membership in a procedure graph (not a part–whole claim)
• “Step i is SerialStepOf Step j” for precedence constraints in order-sensitive procedures (directed; read as “i precedes j”, not as containment; use an adjacency variant if you need “immediately before”)
• “Step u is ParallelFactorOf Step v” for parallelizability/concurrency potential (often symmetric; state synchronization/independence/resource constraints)
• “In run r, Step u ExecutedConcurrentlyWith Step v” for observed concurrency in a specific work/evidence instance (A.15); do not infer this from ParallelFactorOf alone

Semantics cues (review-time, minimal invariants).

• ComponentOf: typically transitive within a bill-of-materials; removing A changes the assembled carrier; do not use for sequences or memberships.
• ConstituentOf: transitive within an information/conceptual artefact; supports “section/chapter/lemma is part of paper/proof” without implying physical assembly.
• PortionOf: requires an explicit extensive measure μ and an additivity story (non-overlap + sum); avoid if you cannot state μ.
• MemberOf: not transitive; does not imply the collective is an assembly; membership can change without “recomposition”.
• PhaseOf: same carrier across time; requires an explicit window τ and a coverage/overlap story; aggregate with Γ_time when composing the history narrative.
• StepOf: membership of a step node in a procedure graph; does not imply physical assembly or conceptual containment. Pair with precedence/concurrency constraints rather than “part-of”.
• SerialStepOf: directed precedence constraint on step nodes (read as “i precedes j”). For a single execution trace/iteration, the precedence constraint set should be acyclic (strict partial order). If the procedure includes iteration/loops, model the loop explicitly (e.g., as a loop/control-flow construct or by time-indexing step instances) rather than introducing cycles into SerialStepOf. If you mean “adjacent in sequence”, use an explicit adjacency form.
• ParallelFactorOf: parallelizability constraint between step nodes under stated assumptions (resources, independence, synchronization). Treat it as potential parallelism (a property of the procedure design), not as evidence that two steps were executed concurrently. If you need to record observed concurrency, use a run-anchored work/evidence relation (e.g., ExecutedConcurrentlyWith in run r). ParallelFactorOf is typically symmetric and not transitive; say so if you rely on those properties.

D) Fold / aggregation

• “Γ_sys / Γ_epist / Γ_ctx / Γ_time / Γ_method / Γ_work” as the explicit “gluing rule” (the operator that produces the composite)

E) Completeness

• “capability coverage is …”
• “specification coverage is …”
• “evidence coverage is …” with explicit scope (G) if relevant.

#Optional bundling record: wholenessSituation

This is a didactic bundling device for prose and review; it adds no new kernel semantics (the semantics remain in boundary + relation kinds + Γ choices).

Definition WHOL-REC-1 (wholenessSituation record).
wholenessSituation ::= ⟨
  wholeRef,
  referenceLevel ∈ {referent, description, work},
  boundaryRefs (0..*),
  environmentRefs (0..*),
  carrierRef (0..1),       // required if PhaseOf is asserted
  parthoodKinds ⊆ {ComponentOf, ConstituentOf, PortionOf, MemberOf},
  measureRef (0..1),       // μ if PortionOf is asserted
  foldRef (0..1),          // Γ_* if a fold is asserted
  orderTimeKinds ⊆ {StepOf, SerialStepOf, ParallelFactorOf, PhaseOf},
  orderTimeRef (0..1),     // the step graph / timeline segment being referenced
  completenessKinds ⊆ {capability, spec, evidence},
  scopeRef (0..1)          // ClaimScope (G) if relevant
⟩

Note: if the trigger token is “integrity” and the intent is security/data integrity (CIA integrity, constraint satisfaction), do not treat it as a WHOL situation; route it as an integrity-as-quality statement instead of forcing boundary/parthood semantics.

Use it when a document keeps repeating “the whole X”; a single record makes the intended wholeness facets stable across pages.

#Always-unpack rule for normative surfaces

D-WHOL-UNPACK. In any normative or Working-Model sentence, if a WHOL trigger appears, the author SHALL rewrite the sentence using facet headphrases and typed relations, or attach a Candidate-Set Note while the choice remains open.

This keeps “whole/part” as natural-language scaffolding while preventing it from becoming semantic authority.

Definition WHOL-CSN-1 (Candidate-Set Note).
CandidateSetNote ::= ⟨
  triggerToken,
  excerptRef,
  candidates,              // explicit candidate meanings (facet combinations)
  discriminatorsPending,   // questions/tests to run before committing
  noSmugglingConstraints   // what must NOT be asserted while open (e.g., “do not encode as generic PartOf”)
⟩

A Candidate-Set Note is conformant only if it explicitly blocks semantic smuggling (e.g., forbids encoding an unresolved “part-of” as a generic inclusion edge).

#Disambiguation guide

Use the following format when reviewing or rewriting: trigger → candidates → discriminating questions/tests → canonical rewrite → routing hooks.

Minimal discriminator kit (lintable tests).

• Level-of-reference test: Is the sentence about the referent holon, a description artefact (spec/model/document), or a work/evidence instance? If the level changes the edge type, make it explicit before choosing relations.
• Boundary test: Can you point to an inside/outside cut and name at least one cross-boundary interaction, interface, dependency, or external constraint that matters for this claim? If not, either “whole” is rhetorical, or the boundary is intentionally out of scope (say so), or you are not making a holon-level claim (see level-of-reference).
• Transitivity test (parthood): Would “A part-of B” and “B part-of C” normally license “A part-of C” under the intended meaning? If yes, you likely mean a typed parthood (ComponentOf/ConstituentOf). If no, suspect MemberOf, PortionOf, or an order/time relation.
• Swap test (order): If you swap A and B, does the meaning change? If yes, encode precedence/concurrency, not containment.
• Carrier-identity test (history): Is it the same carrier across time with windows/coverage constraints? If yes, PhaseOf + Γ_time. If not, model a transformation that yields a new holon identity.
• Coverage test (completeness): “Complete” with respect to what scope (G), and is it capability/spec/evidence coverage (A.15) rather than “has all parts”?

Candidate-Set Note. If you cannot yet decide which candidate meaning is intended, record a Candidate-Set Note and proceed without silently collapsing meanings.

#Change lexicon for wholeness narratives

When “the whole” evolves, narrate the change as an explicit change-class, not as “it’s still the same whole” rhetoric:

• reboundary: boundary/interface changed (inside/outside changed)
• recompose: a parthood edge was added/removed or its kind changed (ComponentOf ↔ ConstituentOf, etc.)
• repartition: PortionOf distribution changed (with explicit μ)
• rephase: PhaseOf windows changed (coverage/overlap story)
• reorder / reparallelize: SerialStepOf / ParallelFactorOf graph changed
• redescribe: the claim’s reference level shifted (system ↔ description ↔ work/evidence) while retaining the same noun phrase (“the whole X”)
• recomplete: capability/spec/evidence coverage changed (scope pin updated)

If the identity criterion fails (it is no longer “the same carrier”), escalate: do not hide it behind “whole/integrity” language.

#Guardrails

1. No “part-of” as a universal relation. “Part of” is a prompt to choose a typed relation, not a final answer.
2. No order/time smuggling. Steps and histories must not be encoded as structural inclusion.
3. No membership upgrade. A set of members is not automatically a composed artefact; keep MemberOf distinct from ComponentOf.
4. No role-as-part. Role boundaries are scope and authorization boundaries, not BoM structure.
5. Cross-boundary influence is interaction. If something crosses a boundary, it is an interaction/interface story, not a parthood story.
6. No integrity-as-wholeness by default. If “integrity” appears, first classify it as (a) wholeness/coherence, or (b) security/data integrity quality (CIA/constraints). Route accordingly before invoking parthood or Γ.
7. No artefact–referent drift. Do not slide between a system, its description artefacts, and observed runs under the same “whole X” phrase; state the reference level and use the appropriate relations (ConstituentOf vs ComponentOf vs work/evidence predicates).

#Archetypal Grounding

Tell. “Wholeness” is not one concept in practice; it is a shorthand for boundary, composition rule, and coverage. Precision comes from unpacking the shorthand into the smallest set of explicit claims that make disagreements decidable.

Show — System vignette (lab automation). A team says: “The whole chromatography pipeline is turnkey, and the chemist owns the whole thing.” This collapses three meanings: workflow order, capability completeness, and role boundary. A precise rewrite becomes:

• “Pipeline” is a MethodDescription with steps connected by SerialStepOf; the composite procedure is aggregated by Γ_method / Γ_ctx.
• “Turnkey” is capability/spec coverage: which required roles/capabilities cover which steps under which scope (G).
• “Chemist owns” is a role assignment boundary inside a bounded context (who is authorized/required), not a ComponentOf structure.

Now the discussion can separate: “Is the workflow correct?” vs “Do we have capability coverage?” vs “Who is responsible in this context?”

Show — Episteme vignette (paper + proof + revision). A reviewer writes: “Section 3 is part of the proof, and v2 is part of v1.” Both “part” usages differ.

• “Section 3” is typically ConstituentOf the paper (content inclusion), while “step 3 of the proof” is SerialStepOf in the proof’s reasoning order.
• “v2 part of v1” is usually PhaseOf the same carrier across time, aggregated by Γ_time—unless the identity changed, in which case it is a new artefact produced by an explicit transformation.

The author can now fix the prose and the model without guessing what “part” meant.

#Bias-Annotation

Lenses tested: Gov, Arch, Onto/Epist, Prag, Did. Scope: Universal.

• Gov bias. Prefers auditable, reviewable claims over rhetorically satisfying language; mitigated by allowing Candidate-Set Notes when decisions are intentionally deferred.
• Arch bias. Prefers small, typed vocabularies and explicit operator selection (Γ flavours), which can feel “heavy” in early drafts; mitigated by “always-unpack only on load-bearing surfaces.”
• Onto/Epist bias. Privileges clear category boundaries (structure vs order vs history vs capability); mitigated by permitting multiple facets when the situation genuinely requires them.
• Prag bias. Optimizes for fewer downstream refactors by forcing early disambiguation; mitigated by the change lexicon, which makes late changes explicit and safe.
• Did bias. Prefers teachability and lintable triggers; mitigated by keeping the facet set small and using domain-native examples.

#Conformance Checklist

#Common Anti-Patterns and How to Avoid Them

#Consequences

Quotable closer: If “whole” matters, say what makes it one.

#Rationale

Natural language compresses multiple modeling dimensions into a single word because that is efficient in conversation. In engineering and research, the same compression becomes a fault-line: boundary individuation, mereological inclusion, collection membership, procedural order, and lifecycle continuity behave differently under reasoning and composition.

FPF’s kernel already provides small, orthogonal “axes” to separate these dimensions: boundaries and interactions for inside/outside, typed parthood for different inclusion families, Γ flavours for different kinds of composition, and role–method–work for capability vs description vs occurrence. A.6.H simply supplies the linguistic steering wheel that keeps authors from driving those axes with one overloaded noun.

The result is not pedantry; it is a mechanism for preventing downstream refactors and for making disagreements reviewable.

#SoTA-Echoing

SoTA-Pack: Viewpoint discipline + relation typing + boundary-aware responsibility (lexically enforced).

This section follows the required craft: claim → practice → source → alignment → adoption status.

Scale legality note: whenever “fraction/percentage/share” appears in wholeness talk, treat it as PortionOf with an explicit extensive measure μ and an additive rule, not as “a component,” to avoid covert scalarization and category mistakes.

#Relations

• Specialises: A.6.P Relational Precision Restoration Suite.
• Front-ends: A.14 Advanced Mereology; B.1.1 edge selection guide — by turning prose triggers into typed edge choices.
• Coordinates with: B.1.4 Γ_ctx/Γ_time — to route order/time away from structure; A.15 Role–Method–Work Alignment — for “completeness/end-to-end” coverage language (capability/spec/evidence).
• Informs examples: F.18 vocabulary pitfalls (module/component, batch/lot) as recurring wholeness-word traps.

#A.6.H: End