Skip to main content
skill CX Codex

vstack-s7-prove — Claude Code skill for TLAPS proofs

The vstack-s7-prove Claude Code skill guides deductive proofs of design-model properties in TLAPS. It starts after invariant discovery, model calibration, and trace alignment with code.

MIT ★ 89 updated 2026-11-16

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add hao-ai-lab/vstack
/plugin install vstack@hao-ai-lab-vstack
Open on GitHub

What vstack-s7-prove does

The skill lays out a workflow for proving pinned properties in a shared TLAPS module tree. First, the specification, full inductive invariant, parameter ranges, and configuration are fixed; then the proof covers initialization, invariant preservation for each action, and safety.

Work stays in one module tree. The workflow separates action effects from unchanged-field facts and connects auxiliary lemmas to pinned definitions. Module slices use tlapm --toolbox <start_line> <end_line> --threads 1; each module needs a complete check result or an independently reconciled slice certificate. A successful bounded model check cannot serve as a proof premise.

The theorem concerns the design model, not the implementation. An atomic model step does not establish that the corresponding code is atomic. Parallel checks require slice certificates, and the package does not include a general proof-integrity checker.

What it helps with

  • prove that each invariant conjunct survives every model action
  • split a safety proof into preservation cells and lemmas
  • connect auxiliary definitions to the pinned model
  • check a proof across the complete TLAPS module tree

Example prompts for the agent

  • Prove this model's safety from its pinned invariant in TLAPS.
  • Split the invariant-preservation proof across the model actions.
  • Check the proof in the shared module tree and produce slice certificates.

How to install vstack-s7-prove

1Plugin marketplace

/plugin marketplace add hao-ai-lab/vstack
/plugin install vstack@hao-ai-lab-vstack

This installs the whole vstack plugin with all its skills

2Skills CLI (Vercel)

npx skills add hao-ai-lab/vstack --skill vstack-s7-prove -a claude-code

3Manually: put the files in place

~/.claude/skills/vstack-s7-prove/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/vstack-s7-prove/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about vstack-s7-prove

How do I install vstack-s7-prove in Claude Code?

Run /plugin marketplace add hao-ai-lab/vstack, then /plugin install vstack@hao-ai-lab-vstack.

What does vstack-s7-prove do?

It provides a workflow for deductively proving design-model properties in TLAPS, from breaking invariant preservation into lemmas to checking the assembled module tree.

Does a proof establish that the implementation is correct?

No. The theorem is about the design model; implementation evidence is treated as validation against that model. An atomic model transition alone does not prove atomicity in code.

Source text

SKILL.md · MIT
---
name: vstack-s7-prove
description: "Prove pinned design-model properties in one shared TLAPS module tree after invariant discovery, calibration and trace alignment."
---

# S7 — Upgrade to a proof

Read [Layer 0: shared operating rules](../../docs/layer-0.md), this stage and the assigned input bundle.

## Role and write scope

Proof workers own assigned proof modules and auxiliary lemmas in one shared module tree. The coordinator owns theorem statements, invariant pins and accepted tool and settings manifests.

## 1. Input

The calibrated model selected in S1, after S4 and S5, with no unclassified mismatch between model and code. Complete [invariant discovery](../../docs/method-selection.md) first; pin the specification, full inductive invariant, parameter ranges and proved configuration before deductive proof starts.

## 2. Procedure

1. Import the pinned model directly. The root concludes exactly its `Spec ⇒ □Safety`, with parameter ranges and configuration in explicit `ASSUME … PROVE` premises. Add no module-level `ASSUME` or `AXIOM`. Keep auxiliary definitions in the proof layer and machine-check their bridges to pinned definitions. Never rewrite the model to ease proof.
2. Use one module tree and shared definitions from the start. Assign preservation cells for every invariant conjunct under every action, including all strengthening. Do not prove independent model copies and merge or rename them later.
3. Prove projection lemmas `IndInv ⇒ Conjunct`; unfold the full invariant only at this interface. Each preservation cell receives just the old-state conjuncts it needs, including necessary type and domain facts.
4. Expand each action once to prove effect equations and frame facts for unchanged fields. Reuse those facts in subsequent cells. Prove shared effects as family lemmas, retain every action-to-family bridge, and hide large local definitions after proving their interfaces.
5. Split remaining goals by quantified object, updated or unchanged object, or old or new set member. Close Init, every preservation cell, stuttering and `IndInv ⇒ Safety`. Compose only proved results at the root; never use bounded model-checking success as a proof premise.
6. Control facts and definitions separately: `BY ONLY` retains already usable definitions. Pair it with `HIDE DEF` and keep `USE DEF` inside the smallest subproof scope. A renamed large expression still expands unless hidden.
7. Follow the [proof-run protocol](../../docs/run-review.md#proof-runs): keep persistent fingerprints, diagnose timeouts in the full module context with a capped step budget, and parallelize large modules at top-level theorem boundaries. Use `tlapm --toolbox <start_line> <end_line> --threads 1` for each slice; start with one or two backend threads per slice. Accept slices only with the complete certificate defined in the proof gates. For lasting reductions in frontend work, split large modules and narrow `DEF` expansion.
8. Keep at most one active check run per module, across all snapshots and execution hosts. That run may comprise several parallel slice processes; do not run a second whole-module or sliced copy alongside it. Overlap rounds for different modules. Refresh each downstream module unchanged once its own changed dependencies have final passing sources; do not wait for unrelated modules. Preserve exported definitions and theorem statements when repairing proof bodies. Route interface or invariant changes through review and new acceptance; invariant changes also require new pins.

For certified parallel checks, follow the [slice-certificate procedure](../../docs/gates.md#slice-certificates), including native inventory generation, fresh per-slice caches and independent reconciliation of obligation-location multisets.

For proof structure and tool mechanics, consult the [TLAPS guide](https://lamport.azurewebsites.net/tla/tla2-guide.pdf), [practical hints](https://proofs.tlapl.us/doc/web/content/Documentation/Tutorial/Practical_hints.html), [tactics](https://proofs.tlapl.us/doc/web/content/Documentation/Tutorial/Tactics.html), [MongoRaftReconfig proof organization](https://arxiv.org/html/2109.11987v2) and [TLAPS-Bench theorem-range slicing](https://arxiv.org/abs/2611.02849). These references provide no measured performance guarantee for this workflow.

## 3. Exit checks

- Pass all [proof acceptance gates](../../docs/gates.md#deductive-proof-acceptance) on the assembled tree, including bridges and strengthening. Retain one complete strict result per module, from a whole-module run or an independently checked slice certificate. Bind each result to its source, full import closure and toolchain; cached leaves or a green root alone are insufficient.
- Report the root statement and its premises verbatim. Finite-domain induction retains its bounds; an arbitrary-scale claim requires the corresponding quantification.
- The proved object is the design model. Describe implementation evidence as validation against that model, with its alignment limits.
- Treat final unproved, timeout, unknown, omitted, interrupted or inconclusive work as incomplete. Record runtime, memory and repeat runs without making them proof gates. No generic proof-integrity/closure checker is bundled.

## 4. Rollback

Send a reachable induction counterexample to S6. Return a missing premise or invariant change to S2 for review and new pins; do not inherit the old acceptance result. If strengthening fails, revisit S3. Use [a rollback ticket](../../templates/rollback.md).

## Concrete Examples

For PD KV slot release, prove the design-model promise only after checking real interleavings and trace conformance. A theorem about an atomic model step does not establish atomicity in the implementation.

© Hao AI Lab · MIT · hao-ai-lab/vstack

Similar skills

SKILL.md skills catalog →
principle-prove-it-works backnotprop principle-prove-it-works is a Claude Code skill that enforces verification against real artifacts before declaring work done. Applies at the completion stage. CX Codex +1 10,300installs prove-patch trailofbits prove-patch — a skill for Claude Code validates a local security patch with scoped cases and a three-arm comparison. It runs when a patch commit needs independent proof. CX Codex +1 676installs create-prove aeonfun create-prove runs a modified Aeon skill inside GitHub Actions and attaches SHA-bound behavioral proof directly to the pull request. CX Codex +1 ★ 797repo stars find-skills vercel-labs find-skills is a Claude Code skill that locates agent skills for a task and helps assess the results. It activates when someone asks for a capability that may already be installable. CX Codex +1 4,400,000installs frontend-design official anthropics The frontend-design skill guides intentional visual design for new interfaces and redesigns. Use it when a generic generated UI is not enough. CX Codex +1 1,025,790installs agent-browser vercel-labs This Claude Code skill automates browser interaction for tasks like navigating sites, filling forms, and testing web apps. It also supports exploratory QA and Electron app automation. CX Codex +1 1,600,000installs design-taste-frontend Leonxlnx The design-taste-frontend Claude Code skill sets design rules and checks for websites. It activates for new pages, redesigns, and requests to fix a generic-looking site. CX Codex +1 802,600installs grill-me Matt Pocock grill-me interviews you about a plan or design to expose gaps and sharpen decisions. Use it before implementation starts. CX Codex +1 1,424,476installs

From the same set13

The whole set →
vstack-s6-hunt-fix The vstack-s6-hunt-fix Claude Code skill searches for bugs within a trace-validated model and checks proposed fixes. It classifies counterexamples and tests changes against real code. CX Codex +1 ★ 89repo stars vstack-s0-decompose vstack-s0-decompose is a Claude Code skill that maps system control, data flow, and boundaries, then builds evidence-backed historical anchors. It runs during analysis of a pinned source revision before verification. CX Codex +1 ★ 89repo stars vstack-s4-calibrate-tv The vstack-s4-calibrate-tv Claude Code skill calibrates behavior models and checks them against real traces. It runs stage S4 checks for bugs, fixes, repair components, and reachability witnesses. CX Codex +1 ★ 89repo stars vstack-mode The vstack-mode Claude Code skill runs staged verification for concurrent, distributed, and systems software. It takes a property from source investigation through proof and regression. CX Codex +1 ★ 89repo stars vstack-s2-spec The vstack-s2-spec Claude Code skill turns a design into testable specifications and pinned checks. It runs during specification work based on an approved S1 design and obligation matrix. CX Codex +1 ★ 89repo stars vstack-s5-redteam The vstack-s5-redteam Claude Code skill probes a model and its gates with independent attacks. It runs at stage S5 to expose weak checks and verify findings against real code. CX Codex +1 ★ 89repo stars vstack-s8-package-maintain The vstack-s8-package-maintain Claude Code skill turns verified project scope into a five-step regression workflow. It handles regression setup and upkeep as code changes. CX Codex +1 ★ 89repo stars vstack-s3-model The vstack-s3-model Claude Code skill builds transition models from pinned source code. It captures environment actions, engine responses, and visible interleavings. CX Codex +1 ★ 89repo stars

Project sponsors

Companies that keep this analytics open