#Contextual & Temporal Aggregation (Γctx & Γtime)

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

► decided‑by: A.14 Advanced Mereology A.14 compliance — Γ_ctx relies on SerialStepOf/ParallelFactorOf (order semantics); Γ_time composes PhaseOf slices of the same carrier with coverage/no‑overlap; PortionOf is orthogonal (quantities within steps), mappings are not parthood.

Plain‑English headline. Use Γ_ctx when the order of steps changes meaning. Use Γ_time when we are aggregating the same carrier across a timeline.

The universal algebra Γ (B.1) assumes local commutativity and locality for most structures. But many real‑world compositions are not order‑indifferent (recipes, proofs that unfold by steps, manufacturing routes), and many composites are nothing but a history (asset lifecycle, model revisions, experiment runs). For these cases FPF offers two universal flavours:

#Keywords

• temporal aggregation
• time-series
• order-sensitive
• composition.

#Relations

#Content

#Problem frame

The universal algebra Γ (B.1) assumes local commutativity and locality for most structures. But many real‑world compositions are not order‑indifferent (recipes, proofs that unfold by steps, manufacturing routes), and many composites are nothing but a history (asset lifecycle, model revisions, experiment runs). For these cases FPF offers two universal flavours:

• Γ_ctx — procedural composition (where SerialStepOf / ParallelFactorOf edges are present; see B.1.5 Γ_method for typing and joins; A.14 governs only mereological edges such as PortionOf/PhaseOf). Γ_time — temporal aggregation for phase composition of the same carrier (where PhaseOf edges from A.14 are present).

Both flavours inherit WLNK and MONO from the Quintet (B.1) and remain compatible with A.12 (Transformer Principle) and A.15 (Strict Distinction): they do order and time, not structure, mapping, or cost.

#Problem

Forcing sequential or temporal phenomena through the default, order‑indifferent Γ leads to recurring failures:

1. Semantic erasure: Treating SerialStepOf as if it were structural parthood flattens workflows; swapping steps silently changes meaning.
2. Causal paradoxes: Aggregating time slices as if they were unordered parts lets effects precede causes, or hides missing epochs.
3. Locality violations: Hidden shared state between “parallel” branches breaks reproducibility; independent branches were not actually independent.
4. Design/run conflation: Mixing design‑time plans and run‑time histories in one fold produces “chimeras” that neither simulate nor audit reality.

#Forces

#Solution — Part 1: What these flavours are, and when to use them

#Two flavours at a glance (edge discipline)

Strict Distinction (A.15) reminder. • Structural inclusion → Γ_sys (ComponentOf / ConstituentOf). • Order of actions → Γ_ctx (and its specialisation Γ_method). • History of the same thing → Γ_time (PhaseOf). • Resource spending → Γ_work. • Mappings / representations → value‑level links or U.Interaction, not parthood.

#Operator signatures (normative)

Γ_ctx — Contextual / Order‑Sensitive Aggregation

Γ\_ctx : (D_ctx : DependencyGraph, σ : OrderSpec, T : U.TransformerRole) → H′ : U.Holon

• D_ctx: a DAG whose edges are only SerialStepOf / ParallelFactorOf.
• σ (OrderSpec): an explicit partial order (or total order) compatible with D_ctx that disambiguates how branches compose and where joins occur.
• T: the transformer that performs the material act of sequencing/combining steps (A.12).
• Output H′: typically a U.Method holon, but may be any holon whose identity is defined by stepwise construction.

Γ_time — Temporal / Phase Aggregation

Γ\_time : (D_time : DependencyGraph, τ : TimeWindow, T : U.TransformerRole) → H′ : U.Holon

• D_time: a DAG whose edges are only PhaseOf, all phases referring to the same carrier identity.
• τ: the declared time window to be covered by the aggregation.
• T: the transformer that composes the timeline (A.12).
• Output H′: the holon reconstructed over τ (system lifecycle, theory revision history, dataset growth, etc.).

#Adapted invariants (what replaces COMM/LOC)

Both flavours keep IDEM, WLNK, MONO from B.1. They replace COMM/LOC by discipline specific to order and time.

For Γ_ctx (NC‑invariants):

• NC‑1 — Determinism under σ. Given the same D_ctx and σ, the fold yields the same result.
• NC‑2 — Context identifier. The result SHALL record an unambiguous identifier of σ (e.g., a canonical text or digest) as part of the aggregation record.
• NC‑3 — Partial‑Order Soundness. Any topological sort consistent with σ and with declared independence (below) yields the same result; independent branches may fold in parallel.

For Γ_time (T‑invariants):

• T‑1 — Temporal Idempotence. A single phase/slice folds to itself.
• T‑2 — Chronological Discipline. Phases must be composed in non‑decreasing time consistent with carrier identity; reversing adjacent slices is forbidden.
• T‑3 — Coverage. The union of phase intervals equals the declared τ, with no overlaps and no unexplained gaps. Gaps/overlaps require explicit justification (e.g., measurement resolution or MHT).

Why we keep WLNK and MONO. Even with order/time, the whole cannot be safer or more reliable than the bottleneck step/phase (WLNK), and improving a step/phase on declared monotone characteristics cannot make the whole worse (MONO).

#Guards that make the folds provable

For Γ_ctx

1. Edge discipline: only SerialStepOf / ParallelFactorOf.
2. OrderSpec σ: explicit partial order; joins must have well‑typed inputs/outputs (see B.1.5 for join soundness).
3. Independence declaration: if you claim parallel folds commute locally, declare which branches are independent (no hidden shared state or side‑effects).
4. Scope: single DesignRunTag (design or run) for all nodes; do not mix plans with histories.
5. Boundary note: if steps cross holon boundaries, record the relevant U.Interaction—do not recast it as parthood.

For Γ_time

1. Same carrier: all phases are PhaseOf the same holon identity; identity change implies a Transformer producing a new holon.
2. Non‑overlap / coverage: phase intervals are disjoint and cover τ; if not, specify how resolution limits or business rules justify the pattern.
3. Scope: single DesignRunTag; design‑time hypothetical timelines and run‑time actual logs are kept separate.
4. Boundary note: if Work across boundaries is reported for phases, route resource statements to Γ_work; Γ_time itself does not invent costs.

#Selection checklist (didactic quick guide)

• Does swapping two steps change meaning or safety? → Γ_ctx.
• Is this the same entity evolving over time? → Γ_time.
• Is it a physical assembly or conceptual inclusion? → Γ_sys.
• Is it a “who belongs to this collective” question? → MemberOf + (future) Γ_collective.
• Do you need durations, critical paths, and joins? → Γ_method (specialisation of Γ_ctx).
• Do you need resource spending across a boundary? → Γ_work (orthogonal; can be used together with Γ_ctx/Γ_time).

#Didactic contrasts (one‑liners)

• Γ_sys vs Γ_ctx: Γ_sys composes what the whole is; Γ_ctx composes how it is done.
• Γ_ctx vs Γ_method: Γ_method is Γ_ctx plus step‑specific rules (durations, joins, capability typing).
• Γ_time vs Γ_ctx: Γ_time composes phases of the same carrier; Γ_ctx composes different steps that realise a procedure.
• Γ_time vs Γ_work: Γ_time composes history; Γ_work accounts costs across a boundary for each phase.

#Proof Kit (ready‑to‑reuse obligations for Γ\ctx / Γ\time)

This Proof Kit instantiates the generic obligations from B.1.1 §6 for the order/time flavours. Attach these items whenever you call Γ_ctx or Γ_time on a DependencyGraph D.

#Γ_ctx obligations

• CTX‑IND (Independence & Joins). Declare which branches are independent (no hidden shared state, no side‑effects that leak across branches). For every join, state a join‑soundness condition (compatible input/output types and pre/postconditions). Claim: Under CTX‑IND, parallel folds of independent branches commute locally; any topological sort consistent with σ yields the same result (NC‑3).

• CTX‑ORD (OrderSpec). Provide the OrderSpec σ as a partial order (or total order) text, including where joins occur. Claim: Given D_ctx and σ, the fold is deterministic (NC‑1) and carries a stable context identifier (NC‑2).

• CTX‑WLNK (Critical Path). Identify the critical path (or a cutset) whose weakest step caps the property of the whole: throughput, safety, assurance, etc. Claim: The whole is bounded by the weakest element along the critical path (WLNK).

• CTX‑MONO (Monotone characteristics). List the characteristics that cannot degrade the whole when improved: e.g., ↓ step duration, ↓ error rate, ↑ step reliability, ↑ join soundness. Claim: Improving only monotone characteristics cannot make the aggregated process worse (MONO).

• CTX‑IDEM (Singleton). Provide the one‑step singleton witness: Γ_ctx of a single SerialStepOf‑free node returns that step unchanged (IDEM).

• CTX‑SCOPE/BOUND. Affirm a single DesignRunTag (design or run) and list any U.Interaction that crosses a holon boundary (do not recast it as parthood).

#Γ_time obligations

• TIME‑CARR (Carrier Identity). State explicitly the carrier holon whose history is being reconstructed. Claim: All PhaseOf arcs refer to the same carrier; if identity changes, model a Transformer producing a new holon (A.12), not another phase.

• TIME‑COV (Coverage & Non‑overlap). Provide the target TimeWindow τ and the list of phases with intervals; justify any gaps or overlaps (resolution limits, business rules). Claim: Phases cover τ without overlap; otherwise the fold is not admissible (T‑3).

• TIME‑ORD (Chronological Discipline). Assert that fold order is non‑decreasing in time; reversing adjacent slices is forbidden. Claim: Temporal idempotence holds on a single slice, and chronological composition preserves consistency (T‑1, T‑2).

• TIME‑WLNK (Temporal Weakest‑Link). Identify time‑critical constraints: missing essential phases, minimal sampling resolution, minimal integrity of a crucial epoch. Claim: The property of the whole (over τ) is capped by the weakest phase/epoch.

• TIME‑MONO (Monotone characteristics). List monotone improvements: ↑ coverage, ↑ timestamp precision, ↑ measurement accuracy, ↑ calibration quality. Claim: Such improvements cannot degrade the aggregate.

• TIME‑SCOPE/BOUND. Keep design‑time hypothetical timelines and run‑time actual logs separate; route resource statements for phases to Γ_work (not Γ_time).

#Archetypal grounding (worked micro‑examples)

Use these as templates; each fits on a page and references the obligations above.

#Γ_ctx — U.System (manufacturing route)

• Graph: Prep SerialStepOf Weld SerialStepOf Paint; QC ParallelFactorOf Paint with a join; scope=run.
• CTX‑IND: QC is independent of Prep/Weld state; join requires “painted & inspected” flags aligned.
• CTX‑ORD: σ is total: Prep → Weld → Paint; QC runs in parallel with Paint, joins at Finish.
• CTX‑WLNK: Slowest/least reliable step on the critical path caps throughput and assurance.
• CTX‑MONO: ↓ duration of Weld; ↑ join condition coverage → cannot reduce overall safety.
• Routing: Costs/energy are handled per step with Γ_work; structure of subassemblies remains in Γ_sys.

#Γ_ctx — U.Episteme (order‑bound argument)

• Graph: PremiseA SerialStepOf LemmaB SerialStepOf Conclusion; Background ParallelFactorOf PremiseA.
• CTX‑IND: Background does not alter LemmaB assumptions; join checks entailment preconditions.
• CTX‑WLNK: Weakest premise on the entailment spine caps the argument’s reliability.
• SCR: Γ_epist on the final Conclusion produces a SCR linking every source; Γ_ctx assures the order.

#Γ_time — U.System (asset lifecycle)

• Carrier: This turbine T‑17.
• Phases: Install [t0,t1), Operate v1 [t1,t2), Overhaul [t2,t3), Operate v2 [t3,t4).
• TIME‑COV: Intervals cover [t0,t4) with no overlap; a gap between t2 and t2+ε is justified as clock resolution.
• TIME‑WLNK: The weakest reliability epoch caps lifetime MTTF claimed for [t0,t4).
• Routing: Work/energy footprints per phase via Γ_work; structural upgrades (new rotor) are Transformers (A.12), not phases, if identity changes.

#Γ_time — U.Episteme (paper revisions)

• Carrier: This paper P.
• Phases: Draft v1, Review v2, Camera‑ready v3.
• TIME‑ORD/COV: Non‑overlapping versions covering the documented interval; v3 supersedes v2, not a parallel branch.
• TIME‑WLNK: If v2 violated a key citation, overall reliability over [v1,v3] is capped by that epoch unless the violation is explicitly retracted and corrected in v3 (documented change).
• Routing: Γ_epist aggregates the conceptual whole at each version; Γ_time composes the revision history.

#Conformance Checklist (normative checklist)

#Anti‑patterns and their fixes

#Consequences

Benefits

• Semantic fidelity: Order and history are first‑class; no more flattening sequential logic or erasing temporal causality.
• Auditable determinism: An explicit σ/τ and independence/coverage declarations make folds reproducible and reviewable.
• Safe parallelism: Partial‑order soundness preserves determinism while exploiting concurrency where it is actually safe.
• Clean separation of concerns: Structure (Γ_sys/Γ_epist), order (Γ_ctx/Γ_method), time (Γ_time), and cost (Γ_work) no longer interfere.

Trade‑offs / mitigations

• Extra declarations: Independence, joins, and coverage require up‑front articulation. Mitigation: reuse the Proof Kit forms; adopt the decision checklist from Part 1 §4.5.
• Limited parallelism: Where branches are not independent, concurrency must be curtailed. Mitigation: regroup steps; elevate shared state to explicit interfaces.

#Rationale (informative)

This pattern implements A.15’s ordered relations (SerialStepOf, ParallelFactorOf) and leverages A.14’s PhaseOf for timeline; consistent with Strict Distinction: order and time are not structure, and costs are not history. The adapted invariants (NC‑1..3 and T‑1..3) give precise replacements for COMM/LOC where these do not hold, while retaining WLNK and MONO. The result is a small, stable interface that matches how engineers and researchers already argue about procedures and histories, without importing domain‑specific notations into the kernel.

#Relations

• Builds on: B.1 (Universal Γ), B.1.1 (Dependency Graph & Proofs), A.12 (Transformer), A.14 (Mereology Extension), A.15 (Strict Distinction).
• Specialises into: B.1.5 Γ_method (adds duration, capability typing, join soundness rules).
• Works alongside: B.1.6 Γ_work (resource accounting per step/phase).
• Triggers: B.2 Meta‑Holon Transition (MHT): Recognizing Emergence and Re‑identifying Wholes when re‑ordering or re‑phasing produces genuinely new properties.
• Feeds: B.4 Canonical Evolution Loop (time‑aware cycles that carry explicit costs and order).

One‑page takeaway. If order changes meaning, use Γ_ctx with an explicit OrderSpec and independence/joins. If you are composing the same carrier across time, use Γ_time with a TimeWindow, coverage, and identity. Keep structure, mapping, and cost in their places, and the invariants will do the rest.

#B.1.4:End