Co-Activation Coupling Design

batch: Batch 12

canonical_family: Shared Awareness & Identity Alignment

slug: learning

slug: correlation

slug: coupling

slug: feedback

slug: habit

slug: livelock

slug: reinforcement

slug: metaplasticity

slug: network

slug: recurrence

slug: adaptation

slug: salience

slug: observability

essence_one_line: Strengthen useful links by arranging valid repeated co-activation, then bound the update so accidental pairings do not become durable shortcuts.

compression_statement: Co-Activation Coupling Design applies when connections, associations, weights, habits, cues, or routines change because two units are repeatedly active together. The archetype defines the units to be coupled, the intended association, a valid co-activation window, a local update rule, a correlation trace, a link-strength state, context gates, repetition cadence, inhibition or competition, pruning or decay, and spurious-coupling tests. It turns Hebbian-learning logic into a general design pattern: make the right things fire together often enough to wire together, while preventing invalid co-occurrence from wiring the wrong things together.

core_intuition: Not all learning depends on explicit instruction or reward. Some systems become different simply because elements repeatedly occur together. A name paired with a face, a cue paired with a response, a feature paired with a label, two teammates paired in practice, or two nodes paired in a graph can become mutually recruiting through repetition. That is powerful, but dangerous: the same local rule can also strengthen stereotypes, shortcut features, addictive loops, and irrelevant correlations. The solution is to design the co-activation conditions and guardrails, not merely hope the association forms correctly.

canonical_formula: For units i and j, strengthen link w_ij when valid activity_i and activity_j co-occur within window W under context gate G; cap, inhibit, decay, or audit w_ij when co-activation is invalid, saturated, harmful, or non-transferable.

structural_problem: A system needs certain units, signals, concepts, actions, memories, roles, or features to become linked through experience. The link is formed locally and cumulatively from repeated joint activation rather than from a centralized explanation, reward, or explicit mapping. Without design, the desired association may never consolidate; or worse, repeated incidental co-occurrence may strengthen an irrelevant, biased, addictive, brittle, or unsafe association.

trigger_conditions: Two or more units should reliably recruit, predict, prime, support, or stabilize one another after repeated exposure.

trigger_conditions: The update process is local or semi-local: co-occurrence itself is a major signal, rather than only externally supplied reward or supervision.

trigger_conditions: Timing, spacing, repetition, context, and intensity strongly affect whether the association forms.

trigger_conditions: Accidental or biased co-occurrence could create a harmful shortcut, stereotype, false dependency, or misleading relation.

trigger_conditions: The system has capacity limits, so unused or invalid links must decay, compete, or be pruned.

trigger_conditions: A designer can influence exposure order, pairing, context gates, feedback traces, update rules, or tests of transfer.

trigger_conditions: The target behavior is not simply to map an existing relation but to change the ease with which one unit activates another later.

symptoms: Learners can recall elements separately but fail when a cue should trigger a response or concept.

symptoms: A model, recommender, or search system strengthens edges merely because popular, biased, or contaminated items repeatedly co-occur.

symptoms: Training pairs the right skills inconsistently, so associations remain fragile despite repeated instruction.

symptoms: A system overgeneralizes from superficial co-occurrence and collapses when the context changes.

symptoms: Unwanted pairings become sticky: alarms with nonurgent events, identities with risk labels, brands with emotional cues, or features with target outcomes.

symptoms: Association strength saturates, creating lock-in, habit rigidity, or brittle defaults that resist later correction.

symptoms: Teams try to fix a learned association with explanation alone, even though the underlying link is maintained by repeated co-activation patterns.

root_tension: Useful associative learning needs repeated joint activation, but local cumulative update cannot by itself tell intended structure from accidental correlation.

anti_signatures: The main update signal is explicit reward or punishment; use reinforcement_loop_design instead.

anti_signatures: The task is only to make an existing dependency visible; use relation_mapping or dependency mapping instead.

anti_signatures: The problem is choosing how to aggregate many independent inputs into one output; use aggregation_function_design_and_weighting or population_code_readout_design instead.

anti_signatures: The issue is a present association that should be redesigned at the cue-response level without local cumulative link-strength dynamics; consider associative_cue_redesign.

anti_signatures: The goal is to infer a hidden state from a correlated proxy, not to change the association itself; use correlated_proxy_monitoring.

anti_signatures: The system cannot control exposure, timing, context, or update rules enough to influence association strength.

anti_signatures: The intended relation is normative, legal, or semantic and should not be made true merely by repetition.

structural_intervention: Design, monitor, and bound the repeated co-activation process that changes association strength: specify which units should link, when co-activation counts, how local updates accumulate, what contexts allow the update, how competing links are inhibited or pruned, and how spurious or saturated associations are detected and corrected.

action_logic: Define the units, association objective, and later behavior the strengthened link should support.

action_logic: Specify the co-activation window: timing, context, intensity, repetition, and valid pairing conditions.

action_logic: Choose or describe the local update rule: how joint activation increases accessibility, weight, trust, habit strength, or edge confidence.

action_logic: Instrument a correlation trace so strengthening is based on accumulated exposure rather than anecdote.

action_logic: Add context gates to prevent irrelevant or unsafe pairings from updating the link.

action_logic: Use repetition, spacing, replay, rehearsal, or co-use to consolidate valid associations.

action_logic: Apply inhibition, competition, counterbalancing, decay, or pruning so nearby or invalid links do not all strengthen indiscriminately.

action_logic: Probe for spurious associations, shortcut cues, saturation, and transfer failure before relying on the learned link.

action_logic: Update the co-activation design when outcomes show underbinding, overbinding, harmful coupling, or context leakage.

decision_rules: Treat co-activation as update evidence only inside a declared valid window and context gate.

decision_rules: Increase repetition or pairing salience when a desired association fails to consolidate under appropriate use.

decision_rules: Reduce, separate, randomize, or counterbalance co-activation when a harmful or irrelevant link begins to strengthen.

decision_rules: Add decay or pruning when accumulated links crowd attention, memory, model capacity, or operational flexibility.

decision_rules: Escalate to shortcut_reliance_mitigation when performance depends on a cheap incidental feature instead of the intended association.

decision_rules: Escalate to reinforcement_loop_design when consequence design, not co-activation, is the primary lever.

decision_rules: Do not use repeated pairing to manufacture belief, consent, preference, loyalty, or stigma without autonomy and safety safeguards.

target_invariants: The intended association remains explicit and reviewable.

target_invariants: Co-activation windows distinguish valid joint use from accidental co-occurrence.

target_invariants: Local strengthening remains bounded by saturation, context, and transfer checks.

target_invariants: Spurious or harmful associations are detectable and reversible enough to correct.

target_invariants: Competing or irrelevant associations are not allowed to strengthen merely because they were present nearby.

target_invariants: The learned link improves later retrieval, coordination, prediction, or action without erasing uncertainty or diversity.

target_invariants: Human autonomy, consent, and fairness are protected when association shaping affects people.

expected_outcomes: Desired cue-response, concept-example, feature-label, memory, role, or routine links become more reliable.

expected_outcomes: Training and design shift from vague repetition to valid, testable co-activation conditions.

expected_outcomes: Accidental correlations are caught before they harden into shortcuts or biased responses.

expected_outcomes: Stale or invalid associations decay or are pruned rather than accumulating indefinitely.

expected_outcomes: The system transfers the strengthened association to intended contexts while resisting inappropriate generalization.

expected_outcomes: Designers can explain why a link strengthened and what evidence would justify weakening or revising it.

Skill-Pairing Co-Activation

short_definition: A training variant where two skills, cues, or responses are practiced together so one reliably recruits the other.

distinctive_feature: The intervention is organized around valid repeated co-use of two skills or representations.

distinct_from_parent: The parent is cross-domain; this variant specializes the pattern to education, training, habit shaping, and skill integration.

still_same_parent_because: It still uses co-activation windows, local accumulation, context gates, and spurious-coupling checks.

use_when: A learner must bind a cue to a response, a concept to an example, or a routine to a trigger.

use_when: The intended association is strengthened primarily by repeated joint activation rather than external reward.

use_when: Transfer and overgeneralization must be checked after the pairing becomes fluent.

example_domains:
education
professional training
rehabilitation support
habit design

example: Students repeatedly pair a concept with contrasting worked examples until the cue evokes the right distinction.

domain: operations training

example: A checklist cue is practiced with the safety action it should automatically recruit.

failure_modes:
rote association without understanding
cue dependence
overgeneralization to the wrong context

Representation Weight Update

short_definition: A computational variant where repeated co-occurrence updates weights among features, nodes, embeddings, or memory traces.

distinctive_feature: The association being strengthened is represented explicitly as a weight or edge in a model, graph, recommender, or memory system.

distinct_from_parent: The parent includes human, organizational, and biological analogues; this variant focuses on computational representation updates.

still_same_parent_because: It still depends on valid co-activation windows, cumulative local updates, saturation boundaries, and spurious-coupling probes.

use_when: Representations are encoded as weighted links, edges, or feature associations.

use_when: Co-occurrence data can update those links locally or semi-locally.

use_when: Spurious correlations, popularity loops, or proxy features could be reinforced by the same update rule.

example_domains:
machine learning
recommendation systems
knowledge graphs
search ranking

domain: recommender systems

example: Co-viewed items strengthen an edge only after bot traffic, popularity effects, and context leakage are filtered.

domain: knowledge graph

example: Repeated co-mentions increase a relation-confidence score but require periodic bias and source-diversity checks.

failure_modes: bias amplification through co-occurrence

Harmful Co-Activation Decoupling

short_definition: A corrective variant that detects and breaks associations that strengthened only because harmful or irrelevant units repeatedly co-occurred.

distinctive_feature: The intervention operates on accumulated co-activation damage rather than only preventing future pairing.

distinct_from_parent: The parent covers both constructive association-building and guardrails; this variant focuses on unlearning or weakening harmful learned links.

still_same_parent_because: It uses the same link-strength state, correlation trace, context gate, decay/pruning rule, and transfer check.

use_when: A system repeatedly links a protected attribute, stigma, shortcut cue, or irrelevant context with a response.

use_when: The association is local and cumulative, so simply removing a reward or instruction will not erase it.

use_when: Corrective exposure, counterbalancing, pruning, or context gating is needed to weaken the link.

example_domains:
bias mitigation
safety training
machine learning robustness
media literacy

domain: AI robustness

example: A model is tested and retrained after learning a background cue that co-occurred with a class label.

domain: organizational safety

example: A team separates alarm tones that were accidentally paired with nonurgent events until alertness recovers.

failure_modes: association hidden in downstream features

failure_modes: valid signal removed along with harmful shortcut

near_names:
Hebbian Design
Co-Activation Coupling
Use-Dependent Link Strengthening
“Cells That Fire Together” Design
Co-Occurrence Weighting Design


Coarse-Graining

type: archetype

source: generated

batch: First Iteration/Batch 28

source_primes: renormalization abstraction scale

related_primes: representation compression set_and_membership equivalence_relation hierarchy complexity invariance variability

Renormalization

slug: renormalization

role: Motivates scale-changing simplification and behavior preservation across levels.

Abstraction

slug: abstraction

role: Supports selective omission of lower-level detail once the grouping rule is justified.

Scale

slug: scale

role: Defines the movement from fine-grained elements to macro units.

Representation

slug: representation

role: The archetype changes the representational units used to model the system.

Compression

slug: compression

role: Many fine-grained states are compressed into fewer summary units.

Set and Membership

role: Grouping depends on membership rules that determine which elements belong together.

Equivalence Relation

role: The grouping rule asserts that elements are equivalent for the current purpose.

Hierarchy

slug: hierarchy

role: Coarse units often form a higher level above fine-grained elements.

Complexity

slug: complexity

role: The intervention reduces the number of elements and interactions that must be tracked directly.

Invariance

slug: invariance

role: Validation checks which behaviors remain stable after grouping.

Variability

slug: variability

role: The draft must decide which within-group variation is tolerable and which must remain visible.

essence_one_line: Group fine-grained elements into larger units so macro behavior becomes tractable while relevant structure is preserved.

compression_statement: When micro-level detail overwhelms analysis, simulation, governance, or communication, coarse-grain the system by choosing meaningful aggregation units, defining within-group equivalence, preserving important inter-unit interactions, and checking what information is lost from the grouping.

core_intuition: Some behaviors are not understandable one element at a time. Coarse-graining deliberately changes the unit of attention: it replaces many detailed elements with fewer higher-level units, but does so under explicit rules about what can be treated as equivalent and what behavior must survive the scale change.

canonical_formula: fine_elements + aggregation_unit + equivalence_rule + interaction_preservation + loss_check -> tractable_macro_representation

structural_problem: A system contains too many fine-grained elements, states, events, agents, variables, or local differences for direct reasoning, yet a simple aggregate would erase structure that matters. The actor needs a macro representation that is simpler than the raw system but not blind to the behavior of interest.

condition: The number of micro elements makes direct analysis, simulation, governance, or communication infeasible.

condition: A macro pattern is suspected but remains hidden by local variation and detail noise.

condition: Existing summaries are too broad and hide important interactions or subgroup differences.

condition: The system must be modeled at a higher level while preserving contact, flow, dependency, or feedback structure.

condition: Stakeholders need a tractable representation but cannot safely discard all low-level detail.

symptom: Element overload

interpretation: The number of units is too large for direct inspection or computation.

symptom: Local noise hides macro behavior

interpretation: Fine-grained variation distracts from the pattern the decision actually depends on.

symptom: Ungovernable detail

interpretation: Policies, plans, or controls cannot be written for every micro case.

symptom: Misleading averages

interpretation: Simple averaging hides structure because the grouping rule is implicit or invalid.

symptom: Boundary argument

interpretation: Participants disagree about which elements belong together and what differences matter.

root_tension: The representation must reduce detail enough to make macro reasoning possible while preserving enough structure to keep the resulting decisions valid.

condition: The main task is to choose the right scale of model, but no grouping transformation is needed.

condition: The fine-grained differences are all safety-critical, rights-critical, legally required, or causally decisive.

condition: The issue is missing data quality rather than too many units or excessive resolution.

condition: A single aggregate value is sufficient and no interaction, equivalence, or loss-check logic is needed.

condition: The task is search refinement, where coarse units are temporary filters rather than a stable macro representation.

structural_intervention: Replace many fine-grained elements with fewer higher-level units by defining grouping boundaries, within-group equivalence, representative state variables, preserved interactions, and loss checks that protect the behavior required for the decision.

logic: Name the macro behavior, decision, explanation, or control action that the representation must support.

logic: Inventory the fine-grained elements and identify candidate grouping levels such as bins, regions, cohorts, roles, states, modules, or sectors.

logic: Choose aggregation units and define explicit boundaries for what belongs together.

logic: State the equivalence rule that makes within-group differences irrelevant or tolerable for the current purpose.

logic: Select representative state variables or summaries that stand in for the grouped elements.

logic: Preserve or approximate the interactions among coarse units that generate the target behavior.

logic: Run loss checks and sensitivity tests to see what information, heterogeneity, or edge behavior disappeared.

logic: Document when to disaggregate or reintroduce detail if the coarse representation stops being valid.

rule: Group only elements that are equivalent for the purpose at hand, not merely elements that share a convenient label.

rule: Do not average across heterogeneity that changes the decision, risk profile, causal pathway, or intervention effect.

rule: Preserve interactions that mediate the macro behavior; if those interactions cannot be preserved, the grouping is suspect.

rule: Use the coarsest representation that passes the behavior-preservation and loss checks.

rule: Maintain traceability or disaggregation routes when the coarse model will be used for high-stakes decisions.

invariant: Target macro behavior

description: The behavior that motivated the coarse model remains visible and reasonably accurate.

invariant: Decision-critical heterogeneity

description: Differences that change the decision are retained, flagged, or made recoverable.

invariant: Inter-unit interaction structure

description: Flows, dependencies, feedback, contact patterns, or constraints between coarse units remain represented.

invariant: Interpretability of units

description: Users can understand what each coarse unit means and what fine detail it suppresses.

invariant: Validation link to fine scale

description: The coarse representation remains checkable against fine-grained samples, cases, or simulations.

outcome: Tractable macro representation

description: The system becomes possible to analyze, simulate, govern, or communicate.

outcome: Visible macro patterns

description: Higher-level behavior becomes easier to see because distracting microvariation is suppressed.

outcome: Reduced computational and cognitive load

description: Fewer units and interactions need to be tracked directly.

outcome: Controlled information loss

description: Lost detail is named, tested, and bounded rather than ignored accidentally.

outcome: Better scale-aware decisions

description: Decisions are made at a level that fits the behavior and avoids false precision.

prose_essence:
Coarse-Graining is the intervention pattern of turning many fine-grained elements into fewer higher-level units so the system becomes tractable without losing the behavior that matters. It is not merely making a summary shorter. It is a disciplined scale shift: choose what will count as a coarse unit, justify why members of that unit can be treated together, preserve the interactions that still matter between units, and test what the grouping hides.

The archetype is useful when the raw system is too detailed to reason about directly, but an undisciplined aggregate would be misleading. A good coarse-grained representation is deliberately incomplete and deliberately validated.

prose_when_to_use:
Use Coarse-Graining when the problem has too many elements, states, agents, events, or local variations for direct analysis. It is especially relevant when macro behavior is real but hard to see through micro-level detail: demand patterns, disease spread, organizational bottlenecks, ecological dynamics, system dependencies, and policy-level effects.

The archetype is strongest when the grouping level can be defended behaviorally. Elements should be grouped because they act alike for the current purpose, share a relevant role, belong to a meaningful spatial or temporal unit, participate in a similar interaction pattern, or can be represented by the same state variable. Convenience alone is not enough.

Do not use this archetype when the decision legally, ethically, or technically requires individual-level detail. In those cases, grouping may still support preliminary orientation, but it must not replace the required detailed judgment.

prose_structural_problem:
The structural problem is micro-detail overload. The system contains more elements than the actor can inspect, simulate, govern, or communicate. Yet the answer is not simply to average everything together, because some differences and interactions remain consequential.

Coarse-Graining responds to a tension between two bad extremes. At one extreme, the representation carries so much detail that macro behavior is invisible or computationally impossible. At the other, the representation becomes so broad that it erases heterogeneity, flow, risk, and causality. The archetype creates a middle level where macro reasoning becomes possible while important structure remains visible.

prose_intervention_logic:
The intervention starts by naming the macro behavior or decision the representation must support. Then the drafter chooses candidate aggregation units: bins, regions, cohorts, roles, compartments, modules, zones, sectors, or states. The crucial move is the equivalence rule. The model must say why the fine-grained elements inside a coarse unit are similar enough for the current purpose.

After grouping, the drafter selects representative state variables: totals, rates, averages, proportions, dominant modes, contact classes, responsibility categories, or other summaries. Then the drafter preserves the interactions among coarse units. A coarse model that forgets flows, dependencies, contact patterns, or feedback may look simpler while becoming behaviorally false.

The last step is validation. A loss check asks what disappeared. A sensitivity test asks whether conclusions change under alternative groupings. A disaggregation path says when and how to reopen the coarse unit if suppressed detail becomes important.

prose_key_components:
### Aggregation Unit

Defines the larger unit that will stand in for multiple fine-grained elements at the coarse scale. The unit may be a spatial region, time bucket, role group, category, model cell, organizational unit, or state cluster. It must be chosen because it preserves the target macro behavior, not merely because it is convenient.

### Equivalence Rule

Specifies why elements may be grouped together for the current purpose. Coarse-graining only works when within-group differences are irrelevant or tolerable for the behavior being modeled. The equivalence rule should name the properties that matter and the differences that may be ignored.

### Group Boundary Definition

Marks where one coarse unit ends and another begins. Boundaries create the macro entities that the model can reason about. Bad boundaries create artificial discontinuities, hide flows across groups, or merge elements that behave differently.

### Representative State Variable

Replaces many lower-level states with a smaller set of summary variables at the coarse scale. Examples include totals, averages, proportions, rates, occupancy states, representative profiles, or dominant modes. The selected summary must remain interpretable and decision-relevant.

### Interaction Preservation

Keeps the interactions between coarse units that generate the macro behavior of interest. Grouping elements is not enough. The draft must preserve or deliberately approximate the flows, dependencies, constraints, feedback, or contact patterns that connect the resulting coarse units.

### Loss Check

Tests what information, variation, and edge behavior is lost when elements are grouped. A loss check prevents coarse-graining from becoming blind averaging. It should compare the coarse representation against fine-grained samples, known edge cases, or behavior-preservation tests.

### Scale Validation

Confirms that the coarse scale still supports the intended analysis, decision, communication, or control action. Scale validation asks whether the new representation is valid for the target purpose, not whether it is universally accurate. It is especially important when the grouping level changes incentives, interactions, or risk visibility.

### Optional Components

### Disaggregation Path

Provides a way to reopen a coarse unit into its underlying elements when risk, anomaly, or decision stakes require detail. A disaggregation path preserves reversibility and auditability. It is optional for low-stakes summaries but important for safety, fairness, legal review, and high-impact decisions.

### Sensitivity Test

Checks whether conclusions change when grouping thresholds, boundaries, or equivalence assumptions are varied. Sensitivity testing helps detect whether the coarse representation is robust or merely an artifact of a convenient grouping choice.

### Traceability Map

Links each coarse unit back to the fine-grained elements, assumptions, and transformations that produced it. Traceability helps reviewers understand what was combined, what was suppressed, and where to investigate when the coarse model fails.

### Residual Monitor

Tracks unexplained variation left outside the coarse representation. Residual monitoring is useful when ignored microdetail may become important over time, such as emerging hotspots, minority subgroups, localized failures, or changing interaction patterns.

### Detail Reintroduction Trigger

Defines when suppressed detail must be brought back into the analysis. This is treated as a component here rather than a standalone Batch 028 draft candidate. It prevents coarse-graining from persisting beyond its validity range.

Together, these components make coarse-graining more than aggregation. The unit, boundary, and equivalence rule create the grouped representation. The representative state variable makes it usable. Interaction preservation keeps it behaviorally connected. Loss checks and scale validation keep it honest.

prose_common_mechanisms:
### Binning

As a **method**, this implements coarse-graining by groups continuous or highly varied values into intervals so patterns can be seen at a manageable resolution. Binning implements coarse-graining when bins are chosen to preserve the decision-relevant distribution rather than simply round away inconvenient variation.

### Clustering

As a **method**, this implements coarse-graining by forms coarse units by grouping elements with similar features, behavior, or relationships. Clustering is a mechanism, not the archetype itself. It only fits coarse-graining when the clusters become useful macro units and are validated against the target behavior.

### Regional Aggregation

As a **method**, this implements coarse-graining by combines location-level observations into neighborhoods, watersheds, corridors, districts, zones, or regions. Regional aggregation can reveal spatial patterns, but it can also create boundary artifacts or hide local inequities if the aggregation units are poorly chosen.

### Role Grouping

As a **method**, this implements coarse-graining by combines individuals, tasks, or responsibilities into role-level units for analysis, staffing, communication, or governance. Role grouping is useful when fine-grained individual differences are less important than the macro pattern of responsibilities and interactions.

### Model Reduction by Aggregation

As a **method**, this implements coarse-graining by reduces the number of modeled elements or equations by combining similar states, compartments, variables, or agents. This is a common scientific and engineering implementation of coarse-graining. It must include a behavior-preservation or error-checking procedure.

### Grouped Reporting

As a **document**, this implements coarse-graining by presents detailed events, metrics, or observations as grouped categories so decision-makers can see macro patterns. Grouped reporting is an artifact-level implementation; it should not be confused with the full archetype unless the grouping logic and loss checks are explicit.

### Sector-Level Analysis

As a **method**, this implements coarse-graining by analyzes industries, policy domains, ecological classes, or operational sectors as coarse units rather than isolated cases. Sector-level analysis fits when the sector is a meaningful interaction or behavior unit, not merely a convenient label.

### Summarized State Variables

As a **method**, this implements coarse-graining by represents many fine-grained states using totals, averages, proportions, rates, representative states, or dominant modes. Summaries implement coarse-graining only when the chosen summary variables preserve the relationships needed for the target inference or action.

### Mesh or Grid Coarsening

As a **method**, this implements coarse-graining by combines spatial, computational, or search cells into larger cells to reduce computational burden while retaining macro structure. This mechanism is common in simulation and planning. It should be distinguished from coarse-to-fine search, where the main logic is search refinement rather than stable macro representation.

Each mechanism is an implementation choice, not the archetype itself. Binning, clustering, regional aggregation, and grouped reporting can all instantiate Coarse-Graining, but only when they include explicit grouping logic and validation of lost information.

prose_failure_modes:
Overaggregation occurs when groups are too broad and hide meaningful differences. Invalid equivalence occurs when elements are grouped because they share a label rather than because they behave similarly for the current purpose.

Lost interaction structure is especially dangerous. If flows, contact patterns, dependencies, or feedback loops disappear, the model may preserve the appearance of the system while losing the mechanism of its behavior.

Boundary artifacts arise when the grouping scheme creates patterns that are not actually present in the underlying system. Hidden tails and hotspots arise when rare but important cases are averaged into larger units. Irreversible detail loss occurs when the coarse model cannot be traced back to the original elements.

The most common misuse is applying a coarse representation outside its validated scope, especially using group-level conclusions to make individual-level judgments.

prose_neighbor_distinctions:
**Scale-Appropriate Modeling** chooses the right level of representation. Coarse-Graining is one way to build that representation by grouping elements into larger units.

**Aggregation to Manage Complexity** is broader and more merge-sensitive. Coarse-Graining should remain distinct when scale-shift grouping, equivalence rules, interaction preservation, and loss checks are central.

**Task-Relevant Compression** can compress any kind of information. Coarse-Graining specifically compresses by grouping elements into macro units.

**Equivalence Class Consolidation** treats items as equivalent for handling or reference. Coarse-Graining uses equivalence as a component but also creates higher-level units and validates macro behavior.

**Dimensionality Reduction** reduces variables or features. Coarse-Graining reduces elements, states, agents, cells, or cases into larger units.

**Coarse-to-Fine Search** uses coarse representations to filter a search space and then refine selected regions. Coarse-Graining creates a stable macro representation for analysis, communication, governance, or simulation.

prose_cross_domain_examples:
### Public health

Age-specific case data are grouped into risk bands for vaccination planning. This fits because The bands preserve intervention-relevant risk while reducing individual-level detail.

### Ecology

Species observations are grouped into habitat zones to guide conservation action. This fits because The habitat zones act as macro units with preserved ecological interactions.

### Software architecture

A dependency map groups classes into modules so architects can reason about subsystem coupling. This fits because The module-level view reduces node count while preserving interaction structure.

### Urban planning

Parcel-level travel demand is grouped into transportation analysis zones. This fits because The zones make flow modeling tractable while retaining origin-destination behavior.

### Operations

Individual support tickets are grouped by issue family and workflow stage. This fits because The grouping reveals volume, bottlenecks, and staffing needs at a manageable level.

### Extended Example: Transit Planning

A city planning team cannot evaluate every household trip individually when designing a transit service plan. It groups parcels and trip records into transportation zones, defines the equivalence assumptions that make trips within a zone similar enough for planning, preserves major origin-destination flows between zones, and checks whether the zone boundaries hide underserved neighborhoods or peak-demand corridors. The resulting coarse model is not a substitute for every street-level detail, but it supports network-level decisions while keeping disaggregation available for equity and safety review.

prose_non_examples:
### A raw average reported without a grouping rule

It is an aggregate statistic, not a coarse-grained representation with equivalence and loss checks.

### A one-time executive summary that omits detail for readability

It is summarization unless it forms validated macro units that preserve target behavior.

### A low-resolution prototype built before refinement

That belongs under Progressive Fidelity Increase if fidelity staging is the core logic.

### A legal or medical case review requiring individual-level facts

The decision depends on details that cannot be legitimately grouped away.

prose_tradeoffs:
The central tradeoff is tractability versus fidelity. Fewer units make reasoning easier, but every grouping suppresses variation. A good coarse-grained model accepts some loss and controls it.

There is also a communication tradeoff. A grouped representation can be clear and compelling, but clarity can create false confidence. Users may forget that the groups are constructed. This is why scope notes, residuals, and disaggregation routes matter.

Finally, boundaries create their own effects. Stable group boundaries support comparison over time, but fixed boundaries can become invalid when the system changes. Adaptive boundaries may fit better but make comparison harder.

prose_invariants_to_preserve:
Coarse-graining should preserve the target macro behavior, decision-critical heterogeneity, and the interaction structure that produces the phenomenon of interest. It should also preserve interpretability: users need to understand what each coarse unit means and what has been suppressed.

The representation should remain checkable against fine-grained samples. Without a validation link back to the fine scale, the coarse model becomes an unsupported fiction. The point is not to preserve everything; it is to preserve what the decision, explanation, or control action requires.

prose_target_outcomes:
A successful coarse-graining intervention produces a tractable macro representation. It lowers cognitive and computational burden, reveals patterns hidden by local variation, and supports decisions at a useful scale.

It should also improve communication. Stakeholders can discuss regions, cohorts, modules, roles, or categories instead of thousands of isolated details. The best versions make information loss explicit, so simplicity does not masquerade as completeness.

prose_parameter_dimensions:
The most important tuning dimension is **grain size**: how many fine elements are combined into each coarse unit. A smaller grain preserves more detail but may remain too complex; a larger grain is easier to reason about but risks hiding consequential variation.

A second dimension is **equivalence strictness**. Strict equivalence creates many smaller groups; loose equivalence creates fewer groups but increases the risk that unlike elements are treated as the same.

A third dimension is **interaction fidelity**. Some coarse models retain detailed inter-unit links; others keep only dominant flows or average relationships. The right fidelity depends on whether interactions are central to the macro behavior.

Other tuning dimensions include boundary stability, residual monitoring intensity, disaggregation cost, update cadence, and the acceptable level of information loss. High-stakes uses should tune toward more traceability, tighter equivalence, and stronger loss checks.

prose_variants_and_near_names:
### Statistical Binning

A coarse-graining variant that groups fine-grained numeric values into intervals or categories. Its distinctive feature is: The grouping unit is an interval, bucket, quantile, threshold band, or category boundary. It remains within Coarse-Graining because It still groups many fine-grained elements into fewer macro units and requires loss checks for hidden variation.

### Spatial or Regional Coarse-Graining

A variant that groups point, parcel, cell, or local observations into larger spatial units. Its distinctive feature is: The grouping boundary is spatial, geographic, ecological, or jurisdictional. It remains within Coarse-Graining because It still uses coarse units, equivalence assumptions, interaction preservation, and loss checks.

### Role-Group Coarse-Graining

A variant that groups people, tasks, or responsibilities into role-level units for coordination or governance. Its distinctive feature is: The coarse units are roles, teams, functions, or responsibility groups rather than numeric or spatial buckets. It remains within Coarse-Graining because It still forms macro units from fine-grained elements and must preserve decision-relevant interactions.

### Interaction Graph Coarsening

A variant that groups nodes, states, or agents while preserving the interaction structure that drives macro behavior. Its distinctive feature is: The main preservation target is the topology or weighted interaction structure between grouped units. It remains within Coarse-Graining because It remains a grouping intervention with equivalence assumptions and loss validation.

Near names include coarse-grain simplification, macro grouping, aggregate modeling, bucketed representation, grouped reporting, and coarse-grained model. Some are aliases; some are mechanisms or artifacts. The draft collapses coarse-grained model into this archetype as an artifact, while keeping Aggregation to Manage Complexity visible as a neighbor requiring review.

Statistical Binning

distinctive_feature: The grouping unit is an interval, bucket, quantile, threshold band, or category boundary.

distinct_from_parent: The parent archetype is any element-to-unit grouping; this variant specifically handles numeric or ordered value spaces.

source_primes: renormalization abstraction

use_when: The raw value space is too detailed for pattern detection or communication.

use_when: The decision depends on distributional structure at a chosen resolution rather than exact values.

use_when: The bin boundaries can be justified by behavior, risk, policy, or statistical stability.

Aggregation Unit

role: Defines the bin or interval.

Equivalence Rule

role: Specifies why values in the same bin may be treated together.

Loss Check

role: Checks whether binning hides important tails or thresholds.

Binning

slug: binning

mechanism_type: method

Grouped Reporting

mechanism_type: document

example_domains:
statistics
analytics
risk reporting
public health

domain: Public health

example: Ages are grouped into bands for population-level vaccination planning.

domain: Product analytics

example: Session durations are grouped into intervals to reveal user behavior patterns.

failure_modes: Bins hide threshold effects, tails, or within-bin inequality.

Spatial or Regional Coarse-Graining

short_definition: A variant that groups point, parcel, cell, or local observations into larger spatial units.

distinctive_feature: The grouping boundary is spatial, geographic, ecological, or jurisdictional.

distinct_from_parent: The parent can group any kind of element; this variant adds spatial boundary and adjacency risks.

source_primes: renormalization scale

use_when: Local data are too detailed for planning, governance, simulation, or communication.

use_when: Spatial adjacency, flow, or regional interaction matters at the macro level.

use_when: The chosen region can be validated against behavior such as movement, ecology, risk, or service demand.

Group Boundary Definition

role: Draws the spatial region.

Interaction Preservation

role: Preserves flows across regions.

Scale Validation

role: Checks that the spatial level fits the decision.

example_domains:
urban planning
ecology
logistics
public policy

domain: Ecology

example: Individual habitat observations are grouped into watershed-level management units.

domain: Urban planning

example: Street-level demand is grouped into service zones for transit planning.

failure_modes: Boundary artifacts hide local hotspots or cross-boundary dependencies.

Role-Group Coarse-Graining

distinct_from_parent: The parent is domain-general grouping; this variant emphasizes accountability, authority, and coordination semantics.

source_primes: abstraction hierarchy

use_when: Individual-level detail obscures responsibility patterns or coordination bottlenecks.

use_when: The target decision concerns roles, teams, units, or governance structure.

use_when: Within-role differences can be safely ignored or represented by exception rules.

Aggregation Unit

role: Defines the role or team unit.

Interaction Preservation

role: Preserves handoffs and dependencies.

Disaggregation Path

role: Allows escalation to individual detail when needed.

example_domains:
organizational design
operations
education
healthcare administration

domain: Operations

example: Individual tasks are grouped into shift roles to reason about coverage.

domain: Education

example: Student support needs are grouped into service tiers for resource planning.

failure_modes: Role labels hide important capability differences, workload inequities, or informal responsibilities.

Interaction Graph Coarsening

distinct_from_parent: The parent can preserve any relevant structure; this variant specifically prioritizes relations among elements.

still_same_parent_because: It remains a grouping intervention with equivalence assumptions and loss validation.

source_primes: relation scale abstraction

use_when: The macro behavior depends more on interaction patterns than on attributes of individual elements.

use_when: A graph, dependency network, flow network, or contact structure is too detailed to reason about directly.

use_when: Edges between coarse units can be represented without losing crucial pathways or feedback.

Interaction Preservation

role: Preserves the coarse interaction graph.

Loss Check

role: Checks lost pathways, bridges, and feedback.

Scale Validation

role: Confirms graph-level behavior remains valid.

example_domains:
network analysis
systems engineering
epidemiology
software architecture

domain: Software architecture

example: Service-level dependencies are grouped into subsystem-level dependency maps.

domain: Epidemiology

example: Individual contacts are grouped into household, workplace, and community interaction classes.

failure_modes: Critical bridges, bottlenecks, or feedback loops disappear when nodes are merged.

near_names:
Coarse-Grain Simplification
Macro Grouping
Aggregate Modeling
Coarse-Grained Model
Bucketed Representation
Grouped Reporting


Coarse-to-Fine Search

aliases:
Coarse-to-Detailed Search
Broad-then-Deep Search
Resolution-Progressive Search
Search by Refinement

alias_records:
Coarse-to-Detailed Search
Broad-then-Deep Search
Resolution-Progressive Search
Search by Refinement

related_primes: scale optimization constraint convergence branch_and_bound feedback uncertainty

Progressive Refinement from Core Model

role: Motivates moving from a broad, low-resolution scan to higher-resolution inspection only where the earlier pass indicates that more detail is justified.

Search and Retrieval

role: Defines the core problem as finding promising options, regions, diagnoses, designs, or explanations within a large possibility space.

Approximation

slug: approximation

role: The coarse pass is an approximation that is useful because it is cheaper than full evaluation, while its errors must remain visible and auditable.

Scale

role: The archetype changes representational scale or resolution during search, rather than merely repeating the same evaluation at the same level of detail.

Optimization

slug: optimization

role: Many uses involve concentrating effort near high-performing regions, though the archetype also applies to diagnosis, discovery, and review workflows where optimization is not formal.

Constraint

slug: constraint

role: Coarse screens often use constraints to exclude impossible, unsafe, or low-fit regions before expensive detailed evaluation.

Convergence

slug: convergence

role: Search should converge toward sufficiently detailed candidates without collapsing too early into a narrow region that was chosen by a fragile proxy.

Branch and Bound

role: Provides a neighboring formal mechanism for pruning search branches, but coarse-to-fine search is broader and centers resolution escalation rather than proof-based bounds.

Feedback

slug: feedback

role: Feedback from fine-stage results and false-negative audits updates the coarse representation, screening criteria, and escalation thresholds.

Uncertainty

slug: uncertainty

role: Uncertainty determines how conservative the coarse filter should be and when a region should be refined despite weak early evidence.

components:
Search Space Boundary
Coarse Representation
Promising Region Filter
Resolution Transition Rule
Refinement Step
False-Negative Check
Coverage Record
Stop Rule
Uncertainty Margin
Backtracking Path
Evaluation Budget
Diversity Quota

mechanisms:
Multi-Resolution Search
Coarse Grid Search
Funnel Process
Diagnostic Narrowing
Portfolio Screening
Progressive Candidate Review
Design Downselection
Search Tree Pruning with Refinement

essence_one_line: Search broadly at a coarse level first, then refine only the most promising regions in more detail.

compression_statement: When exhaustive fine-grained search is too costly, search coarsely first and progressively refine promising regions to concentrate effort without losing sight of the wider space.

core_intuition: A detailed search of everything is often impossible, but a purely coarse search is too blunt to decide well. Coarse-to-Fine Search uses a cheap broad pass to find where attention is likely to matter, then spends expensive precision only in those areas. Its discipline is not just filtering; it must also protect against false negatives by checking whether the coarse representation is hiding important possibilities.

canonical_formula: search_space + coarse_representation + promising_region_filter + resolution_transition_rule + refinement_step + false_negative_check -> focused high-resolution search

structural_problem: The solution, diagnosis, design, or search space is too large for detailed evaluation of every possibility, but crude screening alone risks missing important options.

trigger_conditions: The number of possible options, regions, hypotheses, designs, or parameter settings is too large for full fine-grained evaluation.

trigger_conditions: Detailed evaluation is expensive, slow, scarce, risky, or attention-intensive.

trigger_conditions: There is a lower-resolution representation that can cheaply preserve at least some signal about where detail is worth adding.

trigger_conditions: The search space has structure: neighborhoods, categories, scales, branches, stages, or candidate families that can be refined selectively.

trigger_conditions: Early precise analysis would create false precision, sunk-cost bias, or premature commitment to a few cases.

trigger_conditions: Missing a promising region is possible, so the coarse filter needs an audit, exception, or backtracking mechanism.

symptoms: Teams spend high-resolution effort on too many low-potential options before doing broad screening.

symptoms: The search becomes stuck in local detail while large parts of the possibility space remain unseen.

symptoms: People cannot explain why some candidates received detailed attention and others were ignored.

symptoms: Coarse dashboards, maps, or scores are used as final judgments even though they were only meant to guide deeper search.

symptoms: High-value outliers are missed because the early screen was too aggressive, biased, or poorly calibrated.

symptoms: Detailed review capacity is exhausted before the most promising regions are reached.

root_tension: The intervention must balance breadth against depth. Broad search protects coverage but lacks precision; fine search improves precision but cannot be applied everywhere. The challenge is to choose the lowest useful resolution for the first pass, refine only where justified, and keep enough auditability to recover from coarse-stage mistakes.

anti_signatures: The candidate space is small enough that every option can be evaluated in detail without material cost or delay.

anti_signatures: There is no trustworthy coarse representation; any coarse signal would be arbitrary, misleading, or systematically biased.

anti_signatures: Safety, law, ethics, or irreversible harm requires full detailed evaluation before exclusion.

anti_signatures: The main issue is proving that branches cannot dominate, rather than changing evaluation resolution; Bounded Search Pruning or Search Space Pruning may fit better.

anti_signatures: The main issue is stakeholder convergence from many options to one, rather than resolution change; Progressive Narrowing may fit better.

anti_signatures: The main issue is increasing the fidelity of a single prototype or model, rather than searching a space; Progressive Fidelity Increase may fit better.

structural_intervention: Define a coarse representation of the full search space, use it to identify promising regions, refine selected regions at higher resolution, and audit whether the coarse filter excluded important options.

action_logic: Define the search objective and the boundary of the possibility space that must receive at least coarse coverage.

action_logic: Choose a coarse representation that is cheap enough to scan broadly while preserving the signals needed for first-pass prioritization.

action_logic: Specify the filter or scoring rule that marks regions as promising, uncertain, high-risk, or safe to defer.

action_logic: Run the coarse pass across the full bounded space and document what each region received: rejection, hold, escalation, or exception review.

action_logic: Refine selected regions with higher-resolution analysis, tests, simulations, evidence, or human review.

action_logic: Use results from the refined stage to recalibrate the coarse representation, especially when fine results contradict coarse expectations.

action_logic: Audit excluded or low-scored regions through sampling, known-positive tests, challenge review, or backtracking to detect false negatives.

action_logic: Stop when further refinement no longer changes the decision enough to justify the cost, or when the remaining uncertainty is acceptable for the stakes.

decision_rules: Use the coarsest representation that preserves enough decision-relevant signal for the first pass.

decision_rules: Escalate a region when potential value, risk, uncertainty, novelty, diversity, or boundary status exceeds the transition rule.

decision_rules: Do not treat a coarse score as a final judgment unless the domain explicitly permits coarse final decisions.

decision_rules: If false-negative checks reveal missed high-value or high-risk regions, widen the filter, revise the representation, or reopen excluded areas.

decision_rules: Keep borderline regions visible until enough evidence exists to exclude them safely.

decision_rules: Make the refinement depth proportional to stakes, evidence quality, available budget, and the cost of being wrong.

target_invariants: The original search-space boundary remains visible even after attention narrows to selected regions.

target_invariants: Coarse and fine representations correspond closely enough that escalation decisions are interpretable.

target_invariants: The filter criteria, thresholds, assumptions, and exceptions are documented.

target_invariants: The process retains a way to detect and recover from false negatives.

target_invariants: Detailed evaluation is concentrated without becoming unfair, opaque, or prematurely narrow.

target_invariants: Final choices are based on high-resolution evidence where stakes require it, not only on the coarse screen.

expected_outcomes: Lower search cost by avoiding detailed evaluation of every option.

expected_outcomes: Faster discovery of promising regions, diagnoses, designs, or opportunities.

expected_outcomes: Better allocation of scarce expert attention, simulation time, testing capacity, or review resources.

expected_outcomes: Reduced premature commitment because the whole space receives an initial pass before detail is concentrated.

expected_outcomes: Improved traceability of why certain regions were refined and others were deferred.

expected_outcomes: More robust search when false-negative checks are used to update coarse filters.

prose_essence:
Coarse-to-Fine Search is a way to search a large possibility space without pretending that every possibility can receive full-detail evaluation immediately. It begins with a low-resolution pass over the whole bounded space, uses that pass to locate promising, uncertain, or high-risk regions, and then adds detail only where the added precision can change the outcome.

The archetype is not merely “narrow the list.” Its distinctive move is a **change in search resolution**: broad low-cost coverage first, selective high-resolution refinement second, and false-negative checks throughout.

prose_when_to_use:
Use this archetype when the search space is too large for detailed review of everything, but a cheaper representation can still reveal where deeper investigation should go. It is especially useful when candidate options cluster into regions, categories, neighborhoods, stages, branches, hypotheses, sites, or parameter ranges.

It is weak when the early representation is arbitrary, when the cost of missing an option is unacceptable, or when rules require full detailed review before any exclusion. In high-stakes human, safety, medical, or legal contexts, the coarse stage should guide deeper attention rather than act as an unappealable final gate.

prose_structural_problem:
The structural problem is the tension between **coverage** and **depth**. A broad search protects against tunnel vision but is too shallow to decide well. A fine-grained search gives richer evidence but cannot be applied to every possibility. Without a staged resolution strategy, teams either waste detailed effort on low-value options or use coarse screens as if they were final judgments.

The common failure is not just inefficiency. It is also invisibility: once a region is filtered out, nobody can tell whether it was genuinely low value, merely poorly represented by the coarse model, or never considered seriously.

prose_intervention_logic:
The intervention starts by defining the search space boundary. The team then chooses a coarse representation that can cover the whole space cheaply while preserving enough signal to guide attention. A filter identifies promising, uncertain, risky, or strategically diverse regions. Those regions receive a refinement step: more evidence, more detailed modeling, deeper review, local testing, or higher-fidelity simulation.

The key guardrail is the false-negative check. The process should sample rejected regions, test known positives, preserve exception paths, or allow backtracking when fine-stage evidence shows that the coarse pass was wrong. Coarse-to-fine search works only when the early pass is treated as guidance, not infallible truth.

prose_key_components:
### Search Space Boundary (`search_space_boundary`)

Defines the option, region, case, diagnosis, design, parameter, or explanation space that the coarse pass must cover. Without a boundary, a coarse screen can look efficient while silently ignoring areas that were never searched. The boundary should state what is in scope, what is excluded, and why the exclusion is legitimate.

### Coarse Representation (`coarse_representation`)

Represents the whole search space at a lower resolution so broad comparison is cheap enough to perform. This may be a rough grid, sketch, summary metric, symptom group, prototype class, portfolio category, map layer, or simplified feature set. It must preserve signals that are relevant to deciding where detail is worth adding.

### Promising Region Filter (`promising_region_filter`)

Identifies which coarse regions, options, or candidate groups should receive more detailed evaluation. The filter can be a score, threshold, constraint, risk flag, expert triage rule, feasibility test, or comparative ranking. It should be explicit enough that rejected regions can later be audited.

### Resolution Transition Rule (`resolution_transition_rule`)

Specifies when and how the search shifts from coarse evaluation to finer evaluation. The transition rule prevents arbitrary escalation. It may depend on potential value, uncertainty, risk, representativeness, diversity, or the cost of missing an option.

### Refinement Step (`refinement_step`)

Adds detail to selected regions so they can be tested, compared, or optimized at a higher resolution. Refinement should focus only on the variables, tests, views, or evidence that can change the decision. It is not generic improvement; it is targeted detail added after a broad pass.

### False-Negative Check (`false_negative_check`)

Tests whether the coarse pass wrongly discarded important regions or candidates. This is the main safety guardrail. It can include sample audits of rejected regions, challenge reviews, holdout testing, backtracking, exception channels, or comparison against known positive cases.

### Coverage Record (`coverage_record`)

Documents what was scanned, what was excluded, what was refined, and which assumptions justified each transition. A coverage record makes the search inspectable and reversible. It supports later audits, re-opening of excluded regions, and learning about which coarse indicators were reliable.

### Stop Rule (`stop_rule`)

Determines when additional refinement is no longer worth the cost or no longer changes the decision. The stop rule keeps coarse-to-fine search from becoming endless detail escalation. It should relate to decision impact, uncertainty reduction, risk, and remaining evaluation budget.

prose_common_mechanisms:
Mechanisms implement the archetype, but they are not the archetype itself. The archetype is the transferable pattern of coarse coverage, selective refinement, and false-negative protection; the mechanisms below are ways to operationalize that pattern.

### Multi-Resolution Search (`multi_resolution_search`)

Implements the archetype by scanning at multiple levels of resolution and escalating detail only where the lower-resolution pass indicates value, uncertainty, or risk. This mechanism should be used only when it preserves the broader coarse-to-fine logic rather than becoming a rote screen or a standalone artifact.

### Coarse Grid Search (`coarse_grid_search`)

Implements the archetype in parameter or design spaces by testing a rough grid first, then searching more finely near promising grid regions. This mechanism should be used only when it preserves the broader coarse-to-fine logic rather than becoming a rote screen or a standalone artifact.

### Funnel Process (`funnel_process`)

Implements the archetype in review or product workflows by moving many candidates through cheap early screens before detailed evaluation of a smaller set. This mechanism should be used only when it preserves the broader coarse-to-fine logic rather than becoming a rote screen or a standalone artifact.

### Diagnostic Narrowing (`diagnostic_narrowing`)

Implements the archetype by starting with broad symptom, signal, or evidence groups and then applying more specific tests to likely diagnostic regions. This mechanism should be used only when it preserves the broader coarse-to-fine logic rather than becoming a rote screen or a standalone artifact.

### Portfolio Screening (`portfolio_screening`)

Implements the archetype by using coarse financial, strategic, risk, or feasibility filters before intensive due diligence on selected opportunities. This mechanism should be used only when it preserves the broader coarse-to-fine logic rather than becoming a rote screen or a standalone artifact.

### Progressive Candidate Review (`progressive_candidate_review`)

Implements the archetype by reviewing applications, proposals, designs, or options in stages, with deeper review reserved for candidates that pass earlier screens or uncertainty checks. This mechanism should be used only when it preserves the broader coarse-to-fine logic rather than becoming a rote screen or a standalone artifact.

### Design Downselection (`design_downselection`)

Implements the archetype in design work by comparing rough concepts first and investing detailed engineering, prototyping, or testing in the most promising concepts. This mechanism should be used only when it preserves the broader coarse-to-fine logic rather than becoming a rote screen or a standalone artifact.

### Search Tree Pruning with Refinement (`search_tree_pruning_with_refinement`)

Implements the archetype when a tree or hierarchy is explored shallowly first, then expanded more deeply along selected branches while keeping audit checks for pruned branches. This mechanism should be used only when it preserves the broader coarse-to-fine logic rather than becoming a rote screen or a standalone artifact.

prose_failure_modes:
The most common failure mode is overaggressive filtering: a candidate is discarded because it does not look promising in the coarse representation even though it would perform well under detailed review. Another failure mode is proxy drift, where the early screen measures convenience rather than value. A third is unreviewable exclusion, where there is no record of what was rejected or why. In organizational settings, a fourth failure is fairness harm: early screens can favor candidates whose value is visible in standardized coarse measures and penalize those whose value requires context.

Mitigation requires uncertainty margins, audit samples, backtracking paths, subgroup checks where people are affected, and stop rules that tie refinement to decision value rather than curiosity alone.

prose_neighbor_distinctions:
Coarse-to-Fine Search is distinct from **Search Space Pruning** because pruning centers removal of regions that are impossible, dominated, or low value, while this archetype centers the resolution shift from coarse evaluation to fine evaluation. It is distinct from **Progressive Narrowing** because narrowing stages convergence toward fewer options, while coarse-to-fine search changes the level of detail applied to regions of the search space. It is distinct from **Progressive Fidelity Increase** because that archetype raises the fidelity of a model, prototype, or process; coarse-to-fine search applies detail selectively across alternatives.

It is also distinct from **Coarse-Graining**. Coarse-graining creates a higher-level representation; coarse-to-fine search may use such a representation, but its intervention is the search strategy that moves from that representation into selected details.

prose_cross_domain_examples:
In engineering design, a team can use rough simulations to screen many design regions, then run expensive high-fidelity tests only on selected configurations. In geospatial planning, a regional map can identify places for detailed local surveys. In incident response, responders can check broad classes of failure before inspecting service-specific logs. In research, cheap screening assays can identify candidate mechanisms for deeper experiments. In portfolio review, many opportunities can be screened by coarse criteria before selected cases receive due diligence.

In each example, the coarse stage should guide attention, not replace the evidence needed for final judgment.

prose_non_examples: A small three-option decision is not coarse-to-fine search if every option can be evaluated in detail. A legally required inspection is not this archetype if every item must receive the same full review before approval. A dashboard that reports aggregate metrics is not enough unless it triggers selective detailed analysis. Repeatedly improving a single prototype is not this archetype unless the process is also searching across alternative regions.

prose_tradeoffs: The central tradeoff is efficiency versus miss risk. Coarse screens make search possible, but they can hide rare, subtle, novel, or underrepresented possibilities. Strong audits reduce this risk but consume resources. Tight filters improve throughput but can encode bias or overfit to what is easy to measure. Loose filters preserve options but may overwhelm the fine-review stage.

prose_invariants_to_preserve: The original search-space boundary must remain visible after attention narrows. The coarse representation must correspond to the fine representation closely enough that escalation decisions can be understood. The process must preserve an audit trail of exclusions, assumptions, and exceptions. It must retain a way to recover from false negatives. In high-stakes settings, final decisions should be supported by appropriately detailed evidence rather than by coarse scores alone.

prose_target_outcomes: The intended outcomes are lower search cost, faster identification of promising regions, better allocation of expert attention or computational resources, reduced premature commitment, and improved traceability. A mature implementation also improves learning: results from detailed review update the coarse filter for future searches.

prose_parameter_dimensions:
Important tuning dimensions include the size of the coarse regions, the strictness of the promising-region filter, the amount of uncertainty margin around borderline cases, the cost budget for detailed review, the strength of false-negative auditing, the number of refinement levels, and the stop rule for ending further detail.

A conservative configuration uses broad inclusion thresholds, larger uncertainty margins, and stronger audits. This is appropriate when the cost of missing a candidate is high. An aggressive configuration uses tighter filters and fewer audits; it is appropriate only when coarse indicators are well validated and the stakes are low enough to tolerate misses.

prose_variants_and_near_names:
Common variants include **Multi-Resolution Search**, where explicit resolution levels are used; **Coarse Grid Search**, where parameter spaces are first evaluated on a rough grid; **Funnel Screening**, where organizational candidates pass through increasingly detailed review stages; and **Diagnostic Narrowing**, where broad hypothesis categories lead to specific tests.

Near names include broad-then-deep search, coarse-to-detailed search, search by refinement, pyramid search, design downselection, portfolio screening, and progressive candidate review. These names should usually remain aliases, variants, or mechanisms unless future evidence shows distinct cross-domain components and failure modes.

Multi-Resolution Search

short_definition: Search across explicit resolution levels, using each level to decide where the next level of detail should be applied.

distinctive_feature: The resolution ladder is explicit rather than merely a sequence of generic review stages.

distinct_from_parent: The parent archetype can be implemented without formal resolution levels; this variant names cases where resolution is a first-class design element.

still_same_parent_because: The logic is still broad coarse coverage followed by selective fine refinement with false-negative protection.

use_when: The domain naturally has multiple resolutions, such as maps, images, grids, simulations, organizational layers, or feature hierarchies.

use_when: A low-resolution pass can cheaply preserve enough structure to guide higher-resolution search.

example_domains:
geospatial analysis
computer vision
simulation
design search

domain: Geospatial planning

example: Scan a regional map before commissioning local surveys.

domain: Simulation

example: Run coarse simulations before detailed local models.

failure_modes: Resolution levels hide small but high-stakes features that are not visible in the coarse representation.

failure_modes: The search escalates mechanically through levels even when the coarse signal is unreliable.

Coarse Grid Search

short_definition: Evaluate a rough grid of possibilities first, then search finer neighborhoods around promising coarse cells.

distinctive_feature: It uses a grid or parameter lattice as the coarse representation.

distinct_from_parent: The parent archetype includes non-grid domains such as diagnosis, review funnels, planning, and qualitative design; this variant is parameter-space oriented.

still_same_parent_because: It still relies on coarse evaluation, selective refinement, and checks against missed promising regions.

use_when: The search space can be parameterized as a grid or set of tunable dimensions.

use_when: Fine evaluation is expensive but coarse grid results are informative enough to identify neighborhoods worth refining.

example_domains:
machine learning
engineering optimization
operations research

domain: Machine learning

example: Try a sparse hyperparameter grid, then refine around high-performing ranges.

domain: Engineering

example: Evaluate rough design parameter combinations before local detailed analysis.

failure_modes: The coarse grid is too sparse and misses narrow high-value regions.

failure_modes: Grid dimensions are chosen for convenience rather than decision relevance.

Funnel Screening

short_definition: Move many candidates through cheap early screens, then reserve deeper review for candidates that pass or remain uncertain.

distinctive_feature: It is organized as a stage funnel rather than an explicit geometric or spatial resolution ladder.

distinct_from_parent: The parent can include technical, spatial, diagnostic, or parameter search; this variant emphasizes human or organizational review workflows.

still_same_parent_because: The same broad-to-detailed allocation of attention governs the process.

use_when: There are many candidate options, proposals, leads, applicants, experiments, or opportunities.

use_when: Early screening criteria are informative but not sufficient for final decisions.

example_domains:
hiring
grant review
sales pipeline review
product discovery

domain: Grant review

example: Use eligibility and brief-scoring screens before full proposal review.

domain: Product discovery

example: Screen many ideas with quick tests before detailed prototypes.

failure_modes: Early screens encode bias or favor easy-to-measure attributes.

failure_modes: Candidates eliminated early have no appeal, audit, or second-look path.

Diagnostic Narrowing

short_definition: Start with broad diagnostic categories and selectively apply finer tests to the most plausible or highest-risk possibilities.

distinctive_feature: It treats hypotheses or fault classes as the regions of search.

distinct_from_parent: The parent is not limited to diagnosis; diagnostic narrowing is a domain expression with specific safety and false-negative concerns.

still_same_parent_because: It starts with broad coverage, then selectively refines likely or high-risk areas while guarding against missed cases.

use_when: The problem is to identify a cause, fault, diagnosis, or explanation within a large possibility space.

use_when: Detailed tests are costly, invasive, slow, or numerous, but coarse clues can guide sequencing.

example_domains:
medicine
technical support
incident response
root-cause analysis

domain: Incident response

example: Check broad failure classes before deep subsystem inspection.

domain: Medicine

example: Use noninvasive screening before specific tests while keeping red flags in view.

failure_modes: Anchoring on an early hypothesis prevents revisiting excluded diagnoses.

failure_modes: Rare but severe cases are filtered out by average-case coarse cues.

near_names:
Multi-Resolution Search
Coarse Grid Search
Coarse-to-Detailed Search
Broad-then-Deep Search
Funnel Process
Progressive Candidate Review
Design Downselection
Pyramid Search