Gpd Limiting Cases

Interpretation:

• If a number (e.g., "3"): check limits for all results in phase 3
• If a file path: check limits for results in that file
• If empty: prompt for target

Load known framework:

cat .gpd/research-map/FORMALISM.md 2>/dev/null | grep -A 20 "Known Limiting Cases"
cat .gpd/research-map/VALIDATION.md 2>/dev/null | grep -A 30 "Limiting Cases"

<execution_context>

Called from $gpd-limiting-cases command. Produces LIMITING-CASES.md report.

Every new result must reduce to known results in appropriate limits. If it doesn't, the new result is wrong (or the known result is wrong, which is rare but possible). There are no exceptions to this principle. </purpose>

0. Load Project Context

Load project state and conventions to identify applicable limits:

• Run:

INIT=$(/home/qol/.gpd/venv/bin/python -m gpd.runtime_cli --runtime codex --config-dir ./.codex --install-scope local init phase-op --include state,config)
if [ $? -ne 0 ]; then
  echo "ERROR: gpd initialization failed: $INIT"
  # STOP — display the error to the user and do not proceed.
fi

• If init succeeds (non-empty JSON with state_exists: true): Extract convention_lock for unit system and sign conventions. Extract intermediate_results from state for previously verified expressions. Extract active approximations and their validity ranges — these define the limits to check.
• If init fails or state_exists is false (standalone usage): Proceed with explicit convention declarations required from user via ask_user.

Active approximations from the project state directly inform which limits are most important to verify (e.g., if a perturbative approximation is active, the free-theory limit g→0 is mandatory).

Convention verification (if project exists):

CONV_CHECK=$(/home/qol/.gpd/venv/bin/python -m gpd.runtime_cli --runtime codex --config-dir ./.codex --install-scope local --raw convention check 2>/dev/null)
if [ $? -ne 0 ]; then
  echo "WARNING: Convention verification failed — review before checking limits"
  echo "$CONV_CHECK"
fi

Limiting case checks depend on conventions — e.g., the sign of k^2 = m^2 vs k^2 = -m^2 in the non-relativistic limit depends on metric signature.

1. Identify the Result(s) to Check

Scan the target for the main physics results:

# Final expressions, key results
grep -n "result\|final\|=.*\\\\frac\|=.*\\\\sqrt\|=.*\\\\sum\|=.*\\\\int\|E\s*=\|Z\s*=\|sigma\s*=\|Gamma\s*=" "$TARGET_FILE" 2>/dev/null

# Named equations
grep -n "\\\\label\|\\\\tag\|# Eq\." "$TARGET_FILE" 2>/dev/null

For each result, identify:

• What physical quantity it represents
• What parameters it depends on
• What the physical system is

2. Identify All Relevant Limits

For each result, systematically enumerate limits organized by physics domain:

Universal Limits (check for every result)

Thermodynamic Limits

Quantum Mechanical Limits

Field Theory Limits

Condensed Matter Limits

Gravitational / Relativistic Limits

Spatial / Geometric Limits

3. Select Applicable Limits

Not all limits apply to every result. Select based on:

1. What parameters does the result depend on? Only limits involving those parameters are relevant.
2. What is the physical system? Domain-specific limits apply.
3. What is known? Only check limits where the answer is independently established.

Present the selected limits:

## Limiting Cases for {Result Name}

Selected {N} applicable limits:

| # | Limit | Parameter | Known Result | Source |
|---|-------|-----------|--------------|--------|
| 1 | {limit} | {param -> value} | {known expression} | {textbook/paper} |
| 2 | ... | ... | ... | ... |

Ask the user once using a single compact prompt block if:

• Unsure which limits are known for this system
• Multiple conventions for the known result exist
• Need user to provide the expected limiting expression

4. Verify Each Limit

For each selected limit:

4a. Analytical verification (preferred)

1. Write out the full expression
2. Take the limit analytically (Taylor expand, set parameter to limiting value)
3. Simplify
4. Compare with known result
5. Check: Do they match exactly? If not, what is the discrepancy?

4b. Numerical verification (when analytical is intractable)

# Template for numerical limit check
import numpy as np

def result_function(params):
    """The result being checked."""
    ...

def known_limit(params):
    """The known limiting expression."""
    ...

# Approach the limit systematically
param_values = [1.0, 0.1, 0.01, 0.001, 0.0001]
for val in param_values:
    computed = result_function({..., limit_param: val})
    expected = known_limit({..., limit_param: val})
    ratio = computed / expected
    rel_error = abs(computed - expected) / abs(expected)
    print(f"param={val:.0e}  computed={computed:.10f}  expected={expected:.10f}  ratio={ratio:.10f}  rel_err={rel_error:.2e}")

# Expected: ratio -> 1 and rel_error -> 0 as param -> limiting value
# Red flags: ratio not approaching 1, oscillating, or diverging

4c. Classify the result

5. Diagnose Failures

For any limit that fails:

1. Characterize the discrepancy:

   • Wrong by a constant factor? (Suggests normalization or combinatorial error)
   • Wrong sign? (Suggests convention mismatch or parity error)
   • Wrong functional form? (Suggests wrong starting point or missed contribution)
   • Divergent where finite expected? (Suggests regularization issue)

2. Localize the error:

   • At which step in the derivation does the limit first fail?
   • Binary search: check intermediate expressions in the same limit

3. Suggest cause:

   • Common: missing factor of 2 from spin, wrong Fourier convention, missing Jacobian
   • Domain-specific: missing symmetry factor, wrong boundary condition, missed diagram

6. Generate Report

Write LIMITING-CASES.md:

---