MCP HubMCP Hub
Volver a habilidades

derive-theoretical-result

pjt222
Actualizado 2 days ago
2 vistas
17
2
17
Ver en GitHub
Otroai

Acerca de

Esta habilidad permite a Claude realizar derivaciones rigurosas y paso a paso de fórmulas o teoremas desde los primeros principios, justificando explícitamente cada paso. Está diseñada para casos de uso como demostrar enunciados matemáticos, verificar resultados de libros de texto o crear derivaciones autocontenidas para trabajos académicos. Las características clave incluyen verificar casos especiales y construir sobre axiomas o teoremas establecidos mediante deducción lógica.

Instalación rápida

Claude Code

Recomendado
Principal
npx skills add pjt222/agent-almanac -a claude-code
Comando PluginAlternativo
/plugin add https://github.com/pjt222/agent-almanac
Git CloneAlternativo
git clone https://github.com/pjt222/agent-almanac.git ~/.claude/skills/derive-theoretical-result

Copia y pega este comando en Claude Code para instalar esta habilidad

Documentación

Derive Theoretical Result

Rigorous step-by-step derivation from axioms/first principles/theorems. Every step justified. Limiting cases checked. Final result + notation glossary.

Use When

  • Formula/theorem from first principles (e.g., Euler-Lagrange from action)
  • Math proof by logic from axioms
  • Re-derive textbook → verify/adapt
  • Extend known → more general (flat → curved spacetime)
  • Self-contained → paper/thesis/report

In

  • Required: Target result (equation, inequality, theorem, relation)
  • Required: Starting point (axioms, postulates, prior results, Lagrangian/Hamiltonian)
  • Optional: Proof technique (direct, contradiction, induction, variational, constructive)
  • Optional: Notation conventions
  • Optional: Known intermediate results citable w/o re-deriving

Do

Step 1: State assumptions + target

Contract before calc:

  1. Axioms + postulates: Every assumption listed. Physics: symmetry group, action principle, QM postulates. Math: axiom sys + prior lemmas.
  2. Target: Precise notation. Equation → both sides. Inequality → direction + equality conds.
  3. Scope: Domain of validity (e.g., "non-relativistic, spinless, 3D"). State what not covered.
  4. Notation: Define every symbol. Self-contained.
## Derivation Contract
- **Starting from**: [axioms, postulates, or established results]
- **Target**: [precise mathematical statement]
- **Domain of validity**: [restrictions and assumptions]
- **Notation**:
  - [symbol]: [meaning and units]
  - ...

→ Complete unambiguous statement. Notation up front.

If err: Target ambiguous/assumptions incomplete → clarify before proceed. Hidden assumptions → unreliable.

Step 2: Math toolkit

Tools + applicability:

  1. Algebra: Tensor, commutator, matrix, series. Verify prereqs (convergence, invertibility).
  2. Calc/analysis: ODE/PDE, integration + domain, functional derivs, contour, distributions. Verify regularity (differentiability, integrability, analyticity).
  3. Symmetry/group theory: Irreps, Clebsch-Gordan, character orthogonality, Wigner-Eckart.
  4. Topology/geometry (if applicable): Manifolds, bundles, connections + topo constraints (boundary terms, winding, index).
  5. Identities/lemmas: Specific ones invoked (Jacobi, Bianchi, integration by parts, Stokes). State explicitly, cite by name.
## Mathematical Toolkit
- **Algebra**: [techniques and prerequisites]
- **Analysis**: [calculus tools and regularity conditions]
- **Symmetry**: [group theory tools]
- **Identities to invoke**: [list with precise statements]

→ Checklist w/ applicability verified.

If err: Unverified prereqs (e.g., term-by-term diff w/o uniform convergence) → flag gap. Prove or state as additional assumption.

Step 3: Execute w/ justification

Every step labeled + justified:

  1. One op per step: No combining.
  2. Justification labels:
    • [by assumption] — stated axiom/assumption
    • [by definition] — prior definition
    • [by {identity name}] — named identity (e.g., "by Jacobi identity")
    • [by Step N] — prior step
    • [by {theorem name}] — external theorem (Step 2)
  3. Checkpoints (every 5-10 steps):
    • Units/dimensions consistent
    • Symmetries preserved
    • Correct transformation props
  4. Branches: Case analysis → each branch labeled sub-derivation, merge.
## Derivation

**Step 1.** [Starting expression]
*Justification*: [by assumption / definition]

**Step 2.** [Result of operation on Step 1]
*Justification*: [specific reason]

...

**Checkpoint (after Step N).** Verify:
- Dimensions: [check]
- Symmetry: [check]

...

**Step M.** [Final expression = Target result]
*Justification*: [final operation]  QED

→ Linear sequence, no logic gaps. Every step verifiable.

If err: Step doesn't follow → gap. Insert intermediates or identify new assumption. No "it can be shown" unless well-known identity listed Step 2.

Step 4: Limiting cases + special values

Validate vs known:

  1. Limits (≥3): Simpler prior formula (non-rel limit), trivial case (coupling=0), extreme regime (high/low T).

  2. Special values: Known independent (n=1 hydrogen, d=3).

  3. Symmetry: Correct under group. Scalar → invariant. Vector → transforms right.

  4. Consistency: Ward identities, sum rules, reciprocity.

## Limiting Case Verification
| Case | Condition | Expected Result | Derived Result | Match |
|------|-----------|----------------|----------------|-------|
| [name] | [parameter limit] | [known result] | [substitution] | [Yes/No] |
| ... | ... | ... | ... | ... |

→ All limits + special values match. Internally consistent.

If err: Failed limit → err in derivation. Trace to first step producing fail. Common: sign, missing 2/π, wrong combinatorial coeff, wrong order of limits.

Step 5: Final w/ notation glossary

Polished:

  1. Narrative: Intro para → motivation, approach, main result.
  2. Body: Steps from Step 3 cleaned. Group → logical blocks w/ headings.
  3. Result box: Highlighted, separated.
  4. Glossary: Every symbol + meaning + units + first occurrence.
  5. Assumptions summary: All in one place, postulates vs technical (smoothness, convergence).
## Final Result

> **Theorem/Result**: [precise statement with equation number]

## Notation Glossary
| Symbol | Meaning | Units | First appears |
|--------|---------|-------|---------------|
| [sym] | [meaning] | [units or dimensionless] | [Step N] |
| ... | ... | ... | ... |

## Assumptions
1. [Fundamental postulate 1]
2. [Technical assumption 1]
3. ...

→ Self-contained doc, followable start to finish w/o external refs (except cited identities + theorems).

If err: Too long (>~50 steps) → break into lemmas. Derive each, assemble main result citing lemmas.

Check

  • All starting assumptions stated before first calc
  • Every step labeled justification (no unjustified leaps)
  • Units/dimensions consistent at every checkpoint
  • ≥3 limiting cases checked + match
  • Special values match known
  • Result transforms correctly under stated symmetry
  • Glossary defines every symbol
  • No deferred "it can be shown"
  • Domain of validity stated w/ result

Traps

  • Hidden assumptions: Analyticity, convergence, integral existence w/o stating. Every regularity cond = assumption, declare.
  • Sign errs: Most common mech err. Track at every step. Cross-check dim analysis (sign err → dim inconsistent).
  • Dropped boundary terms: Integration by parts / Stokes → boundary terms vanish only under conds. State why (e.g., "field decays > 1/r at infinity").
  • Order of limits: Wrong order → diff results (thermodynamic before zero-T). State order explicit + justify.
  • Circular reasoning: Using result as intermediate. Subtle for "obvious" formulas. Every step from stated start, not answer familiarity.
  • Notation collisions: Same symbol for diff quantities (E = energy + E-field). Glossary prevents — IF written before derivation.

  • formulate-quantum-problem — formulate QM framework before deriving
  • survey-theoretical-literature — find prior derivations for comparison

Repositorio GitHub

pjt222/agent-almanac
Ruta: i18n/caveman-ultra/skills/derive-theoretical-result
0
agentsagentskillsai-assisted-developmentclaude-codeskillsteams

Habilidades relacionadas

llamaguard

Otro

LlamaGuard es el modelo de Meta de 7-8B parámetros para moderar las entradas y salidas de LLM en seis categorías de seguridad como violencia y discurso de odio. Ofrece una precisión del 94-95% y puede implementarse usando vLLM, Hugging Face o Amazon SageMaker. Utiliza esta skill para integrar fácilmente filtrado de contenido y barreras de seguridad en tus aplicaciones de IA.

Ver habilidad

cost-optimization

Otro

Esta Skill de Claude ayuda a los desarrolladores a optimizar los costes en la nube mediante el ajuste de tamaño de recursos, estrategias de etiquetado y análisis de gastos. Proporciona un marco para reducir los gastos en la nube e implementar una gobernanza de costes en AWS, Azure y GCP. Úsala cuando necesites analizar los costes de infraestructura, ajustar el tamaño de los recursos o cumplir con restricciones presupuestarias.

Ver habilidad

quantizing-models-bitsandbytes

Otro

Esta habilidad cuantiza LLMs a precisión de 8 o 4 bits utilizando bitsandbytes, logrando una reducción de memoria del 50-75% con pérdida mínima de precisión. Es ideal para ejecutar modelos más grandes en memoria GPU limitada o para acelerar la inferencia, admitiendo formatos como INT8, NF4 y FP4. La habilidad se integra con HuggingFace Transformers y permite entrenamiento QLoRA y optimizadores de 8 bits.

Ver habilidad

dispatching-parallel-agents

Otro

Esta Skill de Claude despliega múltiples agentes para investigar y solucionar 3 o más problemas independientes de forma concurrente. Está diseñada para escenarios que involucran fallos no relacionados que pueden resolverse sin estado compartido o dependencias. Su capacidad principal es la resolución paralela de problemas, asignando un agente por cada dominio problemático independiente para maximizar la eficiencia.

Ver habilidad