Skip to content

Lucasuiii/modeling-workbench / .agents/skills/cumcm-workflow

cumcm-workflow

Verified

Build or resume mathematical-modeling competition work, including CUMCM, MCM/ICM, graduate and regional contests, data challenges, and open-topic statistical modeling. Guide problem framing, modeling, computation, validation, Chinese or English LaTeX writing, and reviewed PDF/source delivery using current official requirements. Not for ordinary paper polishing.

FileKindSize
SKILL.mdskill md9.0 KB
agents/openai.yamlconfig427 B
assets/latex-template/generic-ctex/macros.texother859 B
assets/latex-template/generic-ctex/main.tex.tmplother2.5 KB
assets/latex-template/generic-ctex/metadata.tex.tmplother272 B
assets/latex-template/generic-ctex/planned-section.tex.tmplother1.0 KB
assets/latex-template/generic-ctex/references.bibother155 B
assets/latex-template/generic-ctex/sections/00_abstract.texother935 B
assets/latex-template/generic-ctex/sections/98_references.texother221 B
assets/latex-template/generic-ctex/sections/99_appendix.texother264 B
assets/latex-template/generic-ctex/template.jsonconfig304 B
assets/latex-template/generic-en/macros.texother868 B
assets/latex-template/generic-en/main.tex.tmplother2.2 KB
assets/latex-template/generic-en/metadata.tex.tmplother278 B
assets/latex-template/generic-en/planned-section.tex.tmplother1013 B
assets/latex-template/generic-en/references.bibother155 B
assets/latex-template/generic-en/sections/00_abstract.texother454 B
assets/latex-template/generic-en/sections/98_references.texother201 B
assets/latex-template/generic-en/sections/99_appendix.texother240 B
assets/latex-template/generic-en/template.jsonconfig249 B
assets/latex-template/huawei-ctex/main.tex.tmplother3.3 KB
assets/latex-template/huawei-ctex/template.jsonconfig276 B
assets/plot-style/cumcm.mplstyleother953 B
references/01-intake.mdmarkdown3.9 KB
references/02-problem-analysis.mdmarkdown2.8 KB
references/03-model-design.mdmarkdown7.6 KB
references/04-computation.mdmarkdown13.4 KB
references/05-validation.mdmarkdown5.9 KB
references/06-paper-writing.mdmarkdown14.3 KB
references/07-compile-delivery.mdmarkdown6.1 KB
references/artifact-contracts.mdmarkdown3.1 KB
references/competition-adaptation.mdmarkdown6.8 KB
references/competition-writing.mdmarkdown5.6 KB
references/diagnostics.mdmarkdown4.5 KB
references/evidence-rules.mdmarkdown1.6 KB
references/handoffs.mdmarkdown3.5 KB
references/huawei-delivery.mdmarkdown10.1 KB
references/latex-template.mdmarkdown6.2 KB
references/mechanism-validation.mdmarkdown11.6 KB
references/open-topic-research.mdmarkdown4.9 KB
references/task-driven-modeling.mdmarkdown7.2 KB
schemas/claim-ledger.schema.jsonconfig5.5 KB
schemas/common.schema.jsonconfig2.5 KB
schemas/compile-receipt.schema.jsonconfig3.7 KB
schemas/cross-question-ledger.schema.jsonconfig1.3 KB
schemas/delivery-manifest.schema.jsonconfig7.9 KB
schemas/figure-manifest.schema.jsonconfig1.9 KB
schemas/handoff.schema.jsonconfig2.1 KB
schemas/independent-review-package.schema.jsonconfig3.4 KB
schemas/independent-review-result.schema.jsonconfig4.0 KB
schemas/latex-template-manifest.schema.jsonconfig2.4 KB
schemas/model-contract.schema.jsonconfig5.0 KB
schemas/paper-plan.schema.jsonconfig3.3 KB
schemas/paper-quality-report.schema.jsonconfig5.7 KB
schemas/paper-revision-log.schema.jsonconfig2.2 KB
schemas/paper-visible-text-report.schema.jsonconfig1.6 KB
schemas/problem-facts.schema.jsonconfig1.7 KB
schemas/results-index.schema.jsonconfig1.4 KB
schemas/run-manifest.schema.jsonconfig7.1 KB
schemas/source-manifest.schema.jsonconfig1.9 KB
schemas/task-capabilities.schema.jsonconfig3.9 KB
schemas/workflow-state.schema.jsonconfig2.4 KB
scripts/backend_selection.pyscript6.3 KB
scripts/build_handoff.pyscript20.4 KB
scripts/build_independent_review_package.pyscript14.9 KB
scripts/canonical_evidence.pyscript8.4 KB
scripts/compile_sources.pyscript2.4 KB
scripts/cumcm_check.pyscript2.9 KB
scripts/delivery_archives.pyscript7.0 KB
scripts/doctor.pyscript7.5 KB
scripts/index_result.pyscript10.9 KB
scripts/init_latex_paper.pyscript17.2 KB
scripts/init_project.pyscript11.1 KB
scripts/inventory_artifacts.pyscript4.1 KB
scripts/json_pointer.pyscript1.0 KB
scripts/official_materials.pyscript3.0 KB
scripts/paper_visible_text_check.pyscript5.4 KB
scripts/plan_redo.pyscript18.8 KB
scripts/project_status.pyscript5.8 KB
scripts/provenance.pyscript2.2 KB
scripts/record_compile.pyscript13.2 KB
scripts/record_decision.pyscript12.0 KB
scripts/record_run.pyscript28.1 KB
scripts/refresh_evidence.pyscript4.7 KB
scripts/set_mode.pyscript2.0 KB
scripts/submission_check.pyscript10.6 KB
scripts/workflow_checks.pyscript146.0 KB

references/03-model-design.md

View on GitHub
# Stage 3: Model design

## Required output

- `model/MODEL_CONTRACT.json`

`MODEL_CANDIDATES.md`, `OPTIMALITY_SCOPE.md`, `VALIDATION_PLAN.md` and `CROSS_QUESTION_LEDGER.json` are working notes, not contracts. Write them when they help; the review package picks them up if they exist.

## The shape of this stage

```text
problem analysis
      |
model design            candidate A / candidate B
      |                 + why each is worth considering
      |                 + what evidence would tell them apart
      v
computation             cheap exploratory runs, one per candidate
      |                 record_run.py --candidate <id>
      v
selection               exactly one candidate becomes `selected`,
      |                 with a rationale that cites those runs
      |                 --- the person confirms the choice here ---
      v
official computation    only the selected model earns record_run.py --official
      |
      v
validation
```

Model design does not choose the model. It sets up the comparison so that computation can settle it.

## The checkpoint at selection

Before a candidate becomes `selected`, put the choice in front of the person and record the answer in `MODEL_CONTRACT.selection_check`. This is the earliest of the three checkpoints and the cheapest: only exploratory comparisons have been run, so a rejection precedes official computation. It is also the one with the most leverage, because everything downstream inherits the judgement criterion settled here.

Show three things:

1. **What is being optimized, and under what constraints.** State the criterion in one line. A criterion that controls only one kind of error, or optimizes only one side of a tradeoff, is visible here and nowhere else — by validation it has already shaped every result.
2. **Each candidate's `discriminating_evidence`, and whether it can actually discriminate.** If both candidates would produce the same value of the named evidence, the comparison is decorative.
3. **The `scope` the selected model will claim.** Whatever is written here is what validation must later cover; a scope wider than the evidence is a P0 finding at that point, so it is worth narrowing now.

`presented_candidate_ids` records what was shown. `MODEL-E018` rejects an acceptance that did not present every declared candidate — showing only the winner is not a comparison — and `MODEL-E016` keeps the choice unconfirmed until someone answers. Use `preflight` for drafts; `enforce` and official execution require human acceptance in both modes. After showing all candidates and receiving the reply, use the single `record_decision.py --confirm-human` command in SKILL.md; it fills this checkpoint automatically.

## Candidates

Each entry in `components[].candidates` records:

| field | meaning |
|---|---|
| `candidate_id` | stable ID that runs can point at |
| `method` | what this candidate actually is |
| `why_considered` | why it is on the table at all |
| `discriminating_evidence` | the observation that would separate it from the others |
| `status` | `under_evaluation` / `selected` / `rejected` |
| `evaluation_run_ids` | the runs that actually evaluated it |
| `decision_rationale` | why it won or lost, in terms of what those runs showed |

`discriminating_evidence` is the field that makes the comparison real. "Candidate A is more accurate" is not a discriminator; "whether the residual on the held-out window exceeds 5%" is, because a run can answer it.

Evaluate candidates with cheap exploratory runs — they cost no declarations and never block:

```bash
python3 "$S/record_run.py" --project <p> --candidate CAND-A -- python3 code/try_a.py
python3 "$S/record_run.py" --project <p> --candidate CAND-B -- python3 code/try_b.py
```

Then set exactly one candidate to `selected`, write a `decision_rationale` that refers to what those runs showed, and list them in `evaluation_run_ids`. `cumcm_check.py` reports the comparison under `model_candidates`, and flags a selection with no evaluation run (`MODEL-W014`), a decision with no reason (`MODEL-E014`), a candidate with no discriminator (`MODEL-W012`), and a comparison that never resolved to one winner (`MODEL-E013`). Warnings in `working`; errors once frozen.

One candidate is allowed when one model is clearly right — that only raises `MODEL-W007`. What is not allowed is claiming a comparison you did not make.

## Deferred model selection

In `working` mode a component needs only `model_id`, `capability_ids`, `method` and `scope`. That is deliberate: real modeling runs `sketch -> exploratory computation -> compare -> revise -> freeze`, and a contract frozen before the first run is a guess.

What does **not** defer is capability ownership. Every official subproblem needs a capability with an acceptance check that could fail (`CAP-E008`, `CAP-E009`), because "answered the wrong question" is the failure this workflow exists to prevent, and that invariant does not change when the model does.

Entering `finalizing` requires the complete contract: `variables`, `inputs`, `outputs`, `verification_plan`, and a resolved candidate comparison. Each `verification_plan` entry should match an assertion name that an official run actually recorded — a plan with no executed assertion behind it fails (`MODEL-E009`), and entries with no matching assertion warn (`MODEL-W010`).

A frozen contract must read as a design commitment, not as a transcript of whatever the code ended up doing. That distinction is not machine-checkable; it is a named failure class for the independent reviewer.

Compare candidates using fit to the task contract, identifiability, data requirements, computation cost, interpretability, and validation opportunities. Do not force multiple models when one is clearly sufficient.

Use the applicable family in [task-driven modeling](task-driven-modeling.md) when selecting the formulation, baseline and evidence. It also covers data audit and experiment priorities under a time budget. Reuse the fields and optional working notes above; no extra experiment contract or model quota is required.

For the selected model, define state, decisions, parameters, objective, constraints, observation mechanism, stochastic assumptions, and numerical method. Declare whether an optimum is exact, local, heuristic, relaxed, sampled, or restricted to a stated policy class.

Map every capability to a model component; `CAP-E013` reports any that no component takes on (a warning while working, an error once frozen), because a capability nobody claims is how a task quietly loses a requirement. Record each shared quantity's producer, consumers, definition, unit, time basis, transformation, uncertainty propagation, and authoritative artifact in the cross-question ledger. Resolve incompatible reuse before computation.

Plan meaningful checks appropriate to the actual claims: hand-solvable instance, extreme case, conservation law, out-of-sample test, residual analysis, or perturbation analysis. An independent second implementation is optional and must not be created merely for MATLAB/Python parity.

When choosing discriminating evidence and the `verification_plan`, consult the applicable sections of [mechanism-validation.md](mechanism-validation.md). Select checks that could expose a plausible wrong answer, including their scope and tolerance basis; reuse existing coverage and preserve the current question’s simplifications.

Before freezing, obtain approval of the selected model and scope, then build the `modeling-computation` handoff. A computation task reads that handoff rather than the full modeling conversation.

To revisit a frozen model, record a `revision_requested` decision for `model-design`; it reopens the stage and everything downstream in one step.
canvas-designanthropics/skillsCreate beautiful visual art in .png and .pdf documents using design philosophy. You should use this skill when the user asks to create a poster, piece of art, design, or other static piece. Create original visual designs, never copying existing artists' work to avoid copyright violations.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
docxanthropics/skillsUse this skill whenever the user wants to create, read, edit, or manipulate Word documents (.docx files) or Word templates (.dotx files). Triggers include: any mention of 'Word doc', 'word document', '.docx', '.dotx', or requests to produce professional documents with formatting like tables of contents, headings, page numbers, or letterheads. Also use when extracting or reorganizing content from .docx or .dotx files, inserting or replacing images in documents, performing find-and-replace in Word files, working with tracked changes or comments, or converting content into a polished Word document. If the user asks for a 'report', 'memo', 'letter', 'template', or similar deliverable as a Word or .docx file, use this skill. Do NOT use for PDFs, spreadsheets, Google Docs, or general coding tasks unrelated to document generation.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
pdfanthropics/skillsUse this skill whenever the user wants to do anything with PDF files. This includes reading or extracting text/tables from PDFs, combining or merging multiple PDFs into one, splitting PDFs apart, rotating pages, adding watermarks, creating new PDFs, filling PDF forms, encrypting/decrypting PDFs, extracting images, and OCR on scanned PDFs to make them searchable. If the user mentions a .pdf file or asks to produce one, use this skill.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
pptxanthropics/skillsUse this skill any time a .pptx or .potx file is involved in any way — as input, output, or both. This includes: creating slide decks, pitch decks, or presentations; reading, parsing, or extracting text from any .pptx or .potx file (even if the extracted content will be used elsewhere, like in an email or summary); editing, modifying, or updating existing presentations; combining or splitting slide files; working with templates (.potx), layouts, speaker notes, or comments. Trigger whenever the user mentions "deck," "slides," "presentation," or references a .pptx or .potx filename, regardless of what they plan to do with the content afterward. If a .pptx or .potx file needs to be opened, created, or touched, use this skill.Stars: 198kUpdated Claude CodeCodexVerifiedInstall