derive-theoretical-result
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
Recomendadonpx skills add pjt222/agent-almanac -a claude-code/plugin add https://github.com/pjt222/agent-almanacgit clone https://github.com/pjt222/agent-almanac.git ~/.claude/skills/derive-theoretical-resultCopia 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:
- Axioms + postulates: Every assumption listed. Physics: symmetry group, action principle, QM postulates. Math: axiom sys + prior lemmas.
- Target: Precise notation. Equation → both sides. Inequality → direction + equality conds.
- Scope: Domain of validity (e.g., "non-relativistic, spinless, 3D"). State what not covered.
- 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:
- Algebra: Tensor, commutator, matrix, series. Verify prereqs (convergence, invertibility).
- Calc/analysis: ODE/PDE, integration + domain, functional derivs, contour, distributions. Verify regularity (differentiability, integrability, analyticity).
- Symmetry/group theory: Irreps, Clebsch-Gordan, character orthogonality, Wigner-Eckart.
- Topology/geometry (if applicable): Manifolds, bundles, connections + topo constraints (boundary terms, winding, index).
- 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:
- One op per step: No combining.
- 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)
- Checkpoints (every 5-10 steps):
- Units/dimensions consistent
- Symmetries preserved
- Correct transformation props
- 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:
-
Limits (≥3): Simpler prior formula (non-rel limit), trivial case (coupling=0), extreme regime (high/low T).
-
Special values: Known independent (n=1 hydrogen, d=3).
-
Symmetry: Correct under group. Scalar → invariant. Vector → transforms right.
-
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:
- Narrative: Intro para → motivation, approach, main result.
- Body: Steps from Step 3 cleaned. Group → logical blocks w/ headings.
- Result box: Highlighted, separated.
- Glossary: Every symbol + meaning + units + first occurrence.
- 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 derivingsurvey-theoretical-literature— find prior derivations for comparison
Repositorio GitHub
Preguntas frecuentes
¿Qué es el Skill derive-theoretical-result?
derive-theoretical-result es un Skill de Claude creado por pjt222. Los Skills agrupan instrucciones y recursos que Claude carga cuando los necesita para realizar tareas relacionadas con derive-theoretical-result sin indicaciones adicionales.
¿Cómo instalo derive-theoretical-result?
Usa los comandos de instalación de esta página: añade derive-theoretical-result a Claude Code como plugin o clona su repositorio en tu directorio de skills y reinicia Claude para cargarlo.
¿A qué categoría pertenece derive-theoretical-result?
derive-theoretical-result pertenece a la categoría Otro.
¿Se puede usar derive-theoretical-result gratis?
Sí. derive-theoretical-result aparece en AIMCP y se puede instalar gratis.
Habilidades relacionadas
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.
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.
Esta habilidad de Claude analiza los mercados de apuestas deportivas, incluyendo spreads, over/unders y apuestas de propuestas, mediante el examen de tendencias históricas y estadísticas situacionales para identificar apuestas de valor. Proporciona una salida en markdown estructurado con recomendaciones accionables con fines educativos. Los desarrolladores deben utilizar esto para herramientas de análisis de apuestas deportivas, teniendo en cuenta que está diseñado únicamente para entretenimiento/educación.
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.
