PyPI - rockycode - Versions diffs - 0.1.0__py3-none-any.whl - Mend

rockycode 0.1.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (83) hide show

rockycode/__init__.py +1 -0
rockycode/banner.py +37 -0
rockycode/cli.py +1386 -0
rockycode/config.py +178 -0
rockycode/dream/__init__.py +9 -0
rockycode/dream/core.py +523 -0
rockycode/dream/judge.py +134 -0
rockycode/dream/mining.py +152 -0
rockycode/dream/proposals.py +440 -0
rockycode/engine/__init__.py +10 -0
rockycode/engine/artifact.py +367 -0
rockycode/engine/budget.py +90 -0
rockycode/engine/checks.py +157 -0
rockycode/engine/compaction.py +181 -0
rockycode/engine/container.py +225 -0
rockycode/engine/effort.py +46 -0
rockycode/engine/events.py +101 -0
rockycode/engine/explore.py +592 -0
rockycode/engine/goal.py +541 -0
rockycode/engine/goal_review.py +161 -0
rockycode/engine/goal_session.py +259 -0
rockycode/engine/headless.py +481 -0
rockycode/engine/loop.py +711 -0
rockycode/engine/lsp.py +473 -0
rockycode/engine/mcp.py +364 -0
rockycode/engine/modes.py +123 -0
rockycode/engine/outcome.py +81 -0
rockycode/engine/permission.py +198 -0
rockycode/engine/planmode.py +249 -0
rockycode/engine/providers.py +196 -0
rockycode/engine/redact.py +83 -0
rockycode/engine/safety.py +139 -0
rockycode/engine/sandbox.py +219 -0
rockycode/engine/server.py +431 -0
rockycode/engine/skills.py +178 -0
rockycode/engine/titler.py +46 -0
rockycode/engine/tools.py +479 -0
rockycode/engine/trajectory.py +131 -0
rockycode/engine/web.py +431 -0
rockycode/engine/worktree.py +128 -0
rockycode/memory/__init__.py +7 -0
rockycode/memory/index.py +260 -0
rockycode/memory/store.py +331 -0
rockycode/modes/learn/learn.md +46 -0
rockycode/modes/research/deep-research.md +53 -0
rockycode/modes/research/paper-reading.md +49 -0
rockycode/modes/research/prove.md +60 -0
rockycode/modes/research/whiteboard.md +64 -0
rockycode/onboarding.py +332 -0
rockycode/palette.py +15 -0
rockycode/pricing.py +178 -0
rockycode/prompts/__init__.py +0 -0
rockycode/prompts/rocky.py +257 -0
rockycode/routines.py +287 -0
rockycode/runners/__init__.py +0 -0
rockycode/runners/agent.py +273 -0
rockycode/runners/data.py +61 -0
rockycode/runners/raw.py +176 -0
rockycode/score.py +114 -0
rockycode/session.py +298 -0
rockycode/skills/architecture-viz/SKILL.md +71 -0
rockycode/skills/architecture-viz/template.html +87 -0
rockycode/skills/lean-prover/SKILL.md +155 -0
rockycode/skills/lean-prover/torchlean-api.md +85 -0
rockycode/tui/__init__.py +1 -0
rockycode/tui/app.py +2450 -0
rockycode/tui/exitsheet.py +181 -0
rockycode/tui/goal_screen.py +315 -0
rockycode/tui/mdterm.py +232 -0
rockycode/tui/mdview.py +99 -0
rockycode/tui/modepicker.py +103 -0
rockycode/tui/permission.py +154 -0
rockycode/tui/plangate.py +110 -0
rockycode/tui/prompt_history.py +77 -0
rockycode/tui/proposalcard.py +126 -0
rockycode/tui/resume.py +142 -0
rockycode/tui/rocky_pet.py +96 -0
rockycode/tui/routinecard.py +123 -0
rockycode-0.1.0.dist-info/METADATA +488 -0
rockycode-0.1.0.dist-info/RECORD +83 -0
rockycode-0.1.0.dist-info/WHEEL +4 -0
rockycode-0.1.0.dist-info/entry_points.txt +2 -0
rockycode-0.1.0.dist-info/licenses/LICENSE +21 -0

rockycode/skills/architecture-viz/template.html ADDED Viewed

@@ -0,0 +1,87 @@
+<!-- architecture-viz reference scaffold — COPY AND ADAPT.
+     This is create_artifact BODY content: NO <html>/<head>/<style> (rocky strips
+     <style> and applies its light theme). Style with INLINE style= only; the
+     <script> at the end survives and drives the cross-highlight. Self-contained,
+     no CDN. Example block = scaled dot-product attention; swap the diagram,
+     ribbon, and torch for the architecture you're visualizing. Keep the shared
+     data-step ids matched across all three panels — that IS the link. -->
+<p style="color:#5a5e7a;max-width:70ch">The diagram you know from the papers, the
+shape at every step, and the PyTorch that makes it — the same block three ways.
+<b style="color:#7c5cba">Hover any box, shape, or line of code</b> and the matching
+two light up.</p>
+<!-- shape ribbon: how the tensor shape changes, the through-line -->
+<div class="card" style="display:flex;align-items:center;gap:6px;flex-wrap:wrap;justify-content:center">
+  <div data-step="in" style="display:flex;flex-direction:column;align-items:center;padding:7px 12px;border:1px solid #ddd4ef;border-radius:9px;background:#fff"><span style="font-family:ui-monospace,Menlo,monospace;font-weight:700;color:#6a4ca3">(n, d)</span><span style="font-size:.72rem;color:#5a5e7a">tokens in</span></div>
+  <span style="color:#5a5e7a">→</span>
+  <div data-step="qkv" style="display:flex;flex-direction:column;align-items:center;padding:7px 12px;border:1px solid #ddd4ef;border-radius:9px;background:#fff"><span style="font-family:ui-monospace,Menlo,monospace;font-weight:700;color:#6a4ca3">(n, dₖ)×3</span><span style="font-size:.72rem;color:#5a5e7a">Q K V</span></div>
+  <span style="color:#5a5e7a">→</span>
+  <div data-step="scores" style="display:flex;flex-direction:column;align-items:center;padding:7px 12px;border:1px solid #ddd4ef;border-radius:9px;background:#fff"><span style="font-family:ui-monospace,Menlo,monospace;font-weight:700;color:#6a4ca3">(n, n)</span><span style="font-size:.72rem;color:#5a5e7a">scores</span></div>
+  <span style="color:#5a5e7a">→</span>
+  <div data-step="softmax" style="display:flex;flex-direction:column;align-items:center;padding:7px 12px;border:1px solid #ddd4ef;border-radius:9px;background:#fff"><span style="font-family:ui-monospace,Menlo,monospace;font-weight:700;color:#6a4ca3">(n, n)</span><span style="font-size:.72rem;color:#5a5e7a">weights A</span></div>
+  <span style="color:#5a5e7a">→</span>
+  <div data-step="out" style="display:flex;flex-direction:column;align-items:center;padding:7px 12px;border:1px solid #ddd4ef;border-radius:9px;background:#fff"><span style="font-family:ui-monospace,Menlo,monospace;font-weight:700;color:#6a4ca3">(n, dₖ)</span><span style="font-size:.72rem;color:#5a5e7a">output</span></div>
+</div>
+<div style="display:flex;gap:22px;flex-wrap:wrap;align-items:flex-start">
+  <!-- LEFT: the paper diagram (inline-styled SVG) -->
+  <div class="card" style="flex:1 1 240px">
+    <h2>the block (as the paper draws it)</h2>
+    <svg viewBox="0 0 240 430" width="240" style="max-width:100%;height:auto" role="img" aria-label="scaled dot-product attention">
+      <defs><marker id="af" markerWidth="8" markerHeight="8" refX="6" refY="3" orient="auto"><path d="M0,0 L6,3 L0,6 Z" fill="#7c5cba"/></marker></defs>
+      <path stroke="#7c5cba" stroke-width="1.6" fill="none" marker-end="url(#af)" d="M120,372 L120,346"/>
+      <path stroke="#7c5cba" stroke-width="1.6" fill="none" marker-end="url(#af)" d="M120,320 L120,286"/>
+      <path stroke="#7c5cba" stroke-width="1.6" fill="none" marker-end="url(#af)" d="M120,260 L120,226"/>
+      <path stroke="#7c5cba" stroke-width="1.6" fill="none" marker-end="url(#af)" d="M120,200 L120,150"/>
+      <path stroke="#7c5cba" stroke-width="1.6" fill="none" marker-end="url(#af)" d="M120,124 L120,78"/>
+      <text x="88" y="418" fill="#6a4ca3" font-family="ui-monospace,Menlo,monospace" font-size="13" font-weight="700" text-anchor="middle">Q</text>
+      <text x="120" y="418" fill="#6a4ca3" font-family="ui-monospace,Menlo,monospace" font-size="13" font-weight="700" text-anchor="middle">K</text>
+      <text x="208" y="418" fill="#6a4ca3" font-family="ui-monospace,Menlo,monospace" font-size="13" font-weight="700" text-anchor="middle">V</text>
+      <path stroke="#7c5cba" stroke-width="1.6" fill="none" marker-end="url(#af)" d="M88,408 L88,398 Q88,388 102,388 L110,388"/>
+      <path stroke="#7c5cba" stroke-width="1.6" fill="none" marker-end="url(#af)" d="M120,408 L120,398"/>
+      <path stroke="#8a6fc0" stroke-width="1.6" stroke-dasharray="4 3" fill="none" marker-end="url(#af)" d="M208,408 L208,105 Q208,93 182,93 L158,93"/>
+      <g data-step="scores"><rect x="70" y="372" width="100" height="26" rx="6" style="fill:#efeafa;stroke:#9d7cd8;stroke-width:1.5"/><text x="120" y="389" fill="#2a2a38" font-size="12.5" font-weight="600" text-anchor="middle" style="pointer-events:none">MatMul QKᵀ</text></g>
+      <g data-step="scores"><rect x="70" y="320" width="100" height="26" rx="6" style="fill:#efeafa;stroke:#9d7cd8;stroke-width:1.5"/><text x="120" y="337" fill="#2a2a38" font-size="12.5" font-weight="600" text-anchor="middle" style="pointer-events:none">Scale ÷√dₖ</text></g>
+      <g data-step="mask"><rect x="70" y="260" width="100" height="26" rx="6" style="fill:#efeafa;stroke:#9d7cd8;stroke-width:1.5;stroke-dasharray:5 4"/><text x="120" y="277" fill="#2a2a38" font-size="12.5" font-weight="600" text-anchor="middle" style="pointer-events:none">Mask (opt.)</text></g>
+      <g data-step="softmax"><rect x="70" y="200" width="100" height="26" rx="6" style="fill:#efeafa;stroke:#9d7cd8;stroke-width:1.5"/><text x="120" y="217" fill="#2a2a38" font-size="12.5" font-weight="600" text-anchor="middle" style="pointer-events:none">SoftMax</text></g>
+      <g data-step="out"><rect x="70" y="124" width="100" height="26" rx="6" style="fill:#efeafa;stroke:#9d7cd8;stroke-width:1.5"/><text x="120" y="141" fill="#2a2a38" font-size="12.5" font-weight="600" text-anchor="middle" style="pointer-events:none">MatMul ·V</text></g>
+      <text x="120" y="64" fill="#6a4ca3" font-family="ui-monospace,Menlo,monospace" font-size="13" font-weight="700" text-anchor="middle">Output</text>
+    </svg>
+  </div>
+  <!-- RIGHT: the same block, in the language she writes -->
+  <div class="card" style="flex:1 1 300px">
+    <h2>the same block, in PyTorch</h2>
+    <pre style="white-space:pre;overflow-x:auto"><span data-step="in" style="display:block;padding:1px 8px;border-radius:6px;border-left:3px solid transparent"># x: your tokens                (n, d)
+x</span><span data-step="qkv" style="display:block;padding:1px 8px;border-radius:6px;border-left:3px solid transparent">Q, K, V = x@Wq, x@Wk, x@Wv     # (n, dₖ) each</span><span data-step="scores" style="display:block;padding:1px 8px;border-radius:6px;border-left:3px solid transparent">scores = Q @ K.transpose(-2,-1) / dₖ**0.5   # (n, n)</span><span data-step="mask" style="display:block;padding:1px 8px;border-radius:6px;border-left:3px solid transparent">scores = scores.masked_fill(mask, -inf)     # (n, n)</span><span data-step="softmax" style="display:block;padding:1px 8px;border-radius:6px;border-left:3px solid transparent">A = scores.softmax(dim=-1)     # (n, n) rows→1</span><span data-step="out" style="display:block;padding:1px 8px;border-radius:6px;border-left:3px solid transparent">out = A @ V                    # (n, dₖ)</span></pre>
+  </div>
+</div>
+<p style="color:#5a5e7a;font-size:.9rem">
+<span class="tag tag-purple">◆ derived</span> shapes &amp; dataflow from the standard
+attention definition &nbsp;·&nbsp; <span class="tag tag-amber">◇ illustrative</span> n·dₖ are
+example sizes. Want a shape proven for every n? <code>/research prove</code>.</p>
+<script>
+(function(){
+  var els = Array.prototype.slice.call(document.querySelectorAll("[data-step]"));
+  function paint(step, on){
+    els.forEach(function(el){
+      if(el.getAttribute("data-step")!==step) return;
+      var rect = el.tagName.toLowerCase()==="g" ? el.querySelector("rect") : null;
+      if(rect){ rect.style.fill = on ? "#ede6fb" : "#efeafa"; rect.style.stroke = on ? "#7c5cba" : "#9d7cd8"; rect.style.strokeWidth = on ? "2.4" : "1.5"; }
+      else { el.style.background = on ? "#ede6fb" : ""; el.style.borderLeftColor = on ? "#7c5cba" : (el.tagName.toLowerCase()==="span" && el.style.borderLeft ? "transparent" : ""); if(el.style.border && el.tagName.toLowerCase()!=="span") el.style.borderColor = on ? "#7c5cba" : "#ddd4ef"; }
+    });
+  }
+  els.forEach(function(el){
+    var step = el.getAttribute("data-step");
+    el.style.cursor = "pointer";
+    el.addEventListener("mouseenter", function(){ paint(step, true); });
+    el.addEventListener("mouseleave", function(){ paint(step, false); });
+    el.setAttribute("tabindex","0");
+    el.addEventListener("focus", function(){ paint(step, true); });
+    el.addEventListener("blur", function(){ paint(step, false); });
+  });
+})();
+</script>

rockycode/skills/lean-prover/SKILL.md ADDED Viewed

@@ -0,0 +1,155 @@
+---
+name: lean-prover
+description: Formalize and machine-verify mathematics AND neural networks in Lean 4 — Mathlib proofs for the math, TorchLean for typed models and robustness certificates, honest green/amber/red verdicts, rendered as an artifact
+---
+# lean-prover — machine-verified mathematics
+The Lean compiler is ground truth. A theorem that compiles with zero `sorry`
+is true — no judge, no vibes, no trust required. The corollary binds you:
+**never say "proved" without a green compile you actually ran.** This is the
+one domain where your output is machine-checkable; act like it.
+## Two layers — say which one every claim lives in
+- **Math layer (Mathlib)** — properties of the mathematics itself, exact reals,
+  all sizes at once: "softmax lands in the probability simplex, for every n."
+  Default layer; the pipeline below.
+- **Model layer (TorchLean)** — properties of a concrete network in Lean's
+  typed tensor framework: shape guarantees by compilation, semantics lemmas,
+  robustness certificates over float32. Use when the user brings actual model
+  code or asks about a specific network. See "Model layer" below.
+A claim proved about real-number math is not a claim about a float32 kernel,
+and vice versa. Never let the two blur in a report.
+## Verdicts — use exactly this vocabulary
+- **green** — compiles; zero `sorry`/`admit`; no new `axiom`. Machine-verified.
+- **amber** — the statement typechecks but some goals remain as explicit
+  `sorry`. Honest partial credit: a correctly formalized statement is real
+  value on its own. Always say how many `sorry` and which goals.
+- **red** — does not compile. Say so plainly, with the first error.
+Before claiming green, grep your own file: no `sorry`, no `admit`, no `axiom`
+declarations. An axiom "proof" proves nothing — that is cheating, not amber.
+## Preflight — is Lean installed? Never assume it is
+Before formalizing anything, confirm Lean itself is present. In bash:
+`command -v lake elan || ls ~/.elan/bin/lake 2>/dev/null` (elan/lake usually
+live in `~/.elan/bin`; prepend it to PATH in your bash calls if needed).
+If Lean is **not found**, STOP and hand the user the choice — never silently
+install a toolchain, and never fabricate a verdict for code you couldn't run:
+- **Install it** — `curl https://elan.lean-lang.org/elan-init.sh -sSf | sh`
+  installs elan + the Lean toolchain; then set up a workspace (below). Guided
+  path: https://leanprover-community.github.io/get_started.html . Best if they
+  want to keep proving locally.
+- **Verify in the browser (no install)** — rocky writes the formalization; the
+  user pastes it into https://live.lean-lang.org and reads the goal state /
+  green there. rocky reports the source as **unverified** and asks them for the
+  compile result before ever calling it green.
+- **Formalize only** — rocky produces the Lean statement + proof sketch as an
+  artifact, badged **unverified — Lean not installed, not compiled**. Useful to
+  review the formalization; it is NOT machine-checked, so it can never be green
+  or amber (both mean a compile ran) — it is its own "unverified" verdict.
+Only once Lean is confirmed present do you enter the workspace + pipeline below.
+## Workspace
+Proving needs a Lake project with Mathlib **cache-built**. Find one, in order:
+1. a `lakefile.toml` / `lakefile.lean` in the current folder (or one level down)
+   whose `lake-manifest.json` lists mathlib
+2. `$ROCKYCODE_LEAN_WS`
+3. a `lean_probe/` Lake project in the current directory
+If none exists, stop and offer setup — do not silently install:
+`lake new <name> math && cd <name> && lake exe cache get`
+(warn: the Mathlib cache is a ~5 GB download, but without it the build takes
+hours, not minutes).
+## Pipeline
+1. **Formalize.** Write ONE self-contained file at `<workspace>/Rocky/<Slug>.lean`
+   (create the folder if needed). Restate the user's informal claim as a comment
+   at the top, then the formal statement. Name theorems descriptively. If the
+   informal statement is ambiguous, ask before formalizing — a proof of the
+   wrong statement is worse than no proof.
+2. **Compile.** `lake env lean Rocky/<Slug>.lean` with bash, cwd = workspace.
+   Compiles run ~10s on a warm cache; a `sorry` produces a *warning*, so check
+   the text, not just the exit code.
+3. **Repair, up to 3 rounds.** Read the errors, fix, recompile. Fix the first
+   error first — later ones are often cascade.
+4. **Escalate, up to 3 more rounds.** If unknown-identifier errors persist,
+   STOP guessing names and switch to searching (see name-grounding below).
+5. **Amber fallback.** Past ~6 compile rounds without green: keep every goal
+   you closed, replace the stuck ones with `sorry`, and get *that* file to
+   compile — the statement itself is then certified well-formed. Report amber.
+   Do not grind past the budget; do not delete the file to hide the attempt.
+6. **Report.** Verdict first, then the exact compile command you ran, the
+   theorem names, and (if amber) what remains. Render the artifact.
+## Name-grounding — the known failure mode is hallucinated identifiers
+Measured on this exact pipeline: proof *architecture* is nearly always right;
+what fails is invented Mathlib names. Rules:
+- `import Mathlib` — bare, nothing else. NEVER `import Mathlib.Some.Module`:
+  guessed module names kill the whole file at the header (the module split
+  changes between versions; the bare import always works on a cached build).
+- On `unknown identifier`/`unknown constant`: do NOT retry a similar guess.
+  Search instead —
+  - put `exact?` (or `apply?`, `rw?`) at the stuck goal and compile: the
+    output's "Try this:" line is a *verified* lemma name;
+  - batch-check candidates cheaply in a scratch file: `#check @Filter.Tendsto`
+    lines, one compile validates them all;
+  - `open` the relevant namespace and retry `exact?` — suggestions improve.
+- Prefer big hammer tactics you know exist (`simp`, `norm_num`, `nlinarith`,
+  `positivity`, `field_simp`, `ring`, `omega`, `fun_prop`, `measurability`)
+  before hunting for the perfectly named lemma.
+## Model layer (TorchLean)
+TorchLean (github.com/lean-dojo/TorchLean) formalizes neural networks in
+Lean 4 — PyTorch-shaped API, shape-indexed tensors, IBP/CROWN certificates.
+It is **newer than your pretraining: you have ZERO latent knowledge of it.**
+Working rules, validated by probe (3/3 machine-verified this way):
+- FIRST read `torchlean-api.md` in this skill's directory — it is the only
+  TorchLean API you may use. Do not invent names beyond it; when stuck, read
+  the repo's own `NN/Examples/` files instead of guessing.
+- `import NN.API` then `open TorchLean` — the missing `open` is the #1 error.
+- Workspace: a built TorchLean checkout. Look for `$ROCKYCODE_TORCHLEAN_WS`,
+  then a `torchlean_probe/` checkout in the current directory. If none exists, offer setup
+  (clone + `lake exe cache get && lake build`; warn: multi-GB, ~30 min) —
+  never silently install.
+- Same compile loop, budgets, and verdicts as the math layer. For pure
+  shape/wiring claims, the file compiling IS the theorem — say so in the
+  report rather than inventing a redundant proposition.
+- Translating user PyTorch code: restate the model in TorchLean's API
+  (layer list ↔ `nn.Sequential!`, input shape ↔ `Tensor.T … (shape![…])`),
+  and show the correspondence side by side. Semantic claims about training
+  or CUDA runtime behavior are runtime evidence, not Lean proof evidence —
+  TorchLean's own trust boundaries say so; repeat that honestly.
+## Artifact
+Render the result with `create_artifact`: the informal statement, the Lean
+source in a code block, and the verdict up top (green/amber/red — amber lists
+the remaining goals). One artifact per statement, updated in place on re-runs.
+When the work spans both layers (user code + math + model), render the
+**triptych**: the user's original code, the math-layer theorem(s), and the
+model-layer result, each with its own verdict badge — three panels, one story,
+every claim labeled with the layer it lives in.
+## Honesty rules
+- The report's verdict comes from the last compile you ran, nothing else.
+- Quote compiler output when it disagrees with your expectation.
+- If the user's claim is false, say so — a disproof or a counterexample
+  (`decide`, `norm_num`, or an explicit witness) is a fully valid green result.

rockycode/skills/lean-prover/torchlean-api.md ADDED Viewed

@@ -0,0 +1,85 @@
+# TorchLean API excerpt — the ONLY TorchLean names you may use
+TorchLean (github.com/lean-dojo/TorchLean, arXiv 2602.22631) formalizes neural
+networks in Lean 4. It is NEWER than your pretraining data: you have zero latent
+knowledge of it. Everything below is verbatim from the repo and was validated by
+compile on 2026-07-15 (probe: 3/3 machine-verified). Treat this file as the whole
+API surface — if a name is not here and not suggested by a compiler error, do not
+use it. Read the repo's own files (NN/Examples/) when you need more.
+## Imports and namespace
+```lean
+import NN.API        -- the public API (works from a plain, non-module file)
+import NN.Proofs     -- optional: proof helpers
+import Mathlib       -- optional: Mathlib is a TorchLean dependency, fully available
+open TorchLean       -- REQUIRED before nn./tensor!/shape! names resolve
+```
+Missing `open TorchLean` is the #1 observed error (unknown identifier `nn.Linear`).
+## Tensors (validated by compile)
+```lean
+-- element type = dtype (Float, ℚ, Int, ℝ)
+def v := Tensor.vector (α := Float) [0.1, 0.2, 0.3, 0.4]
+-- typed vector, shape in the type
+def twoVector : Tensor.T Float (shape![2]) := tensor! [1.0, 2.0]
+-- N-D from nested lists (row-major); explicit: Tensor.ofList [2,2,2] [1,...,8]
+def x3 : Tensor.T Float (Shape.ofDims [2, 2, 2]) :=
+  tensor! [ [ [1, 2], [3, 4] ], [ [5, 6], [7, 8] ] ]
+-- flat constructor with dims
+def xs : Tensor.T Float (shape![4, 2]) :=
+  tensorOfList! [4, 2] [0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0]
+```
+ℝ-valued tensors are fine for proofs but are noncomputable — do not `Tensor.print` them.
+## Models (validated by compile)
+```lean
+def model :=
+  nn.Sequential![
+    nn.Linear 2 8,
+    nn.ReLU,
+    nn.Linear 8 1
+  ]
+```
+Shape-indexed types mean a shape-mismatched literal or layer stack fails to
+compile — for pure wiring claims, the file compiling IS the theorem.
+## Semantics lemmas (validated by compile)
+```lean
+theorem shape_roundtrip :
+    Shape.ofDims (Shape.toList (shape![2, 3])) = shape![2, 3] := by simp
+-- TorchLean.Semantics.relu is real-valued; unfolds to max-style form
+theorem relu_eq_self_of_nonnegative (x : ℝ) (hx : 0 ≤ x) :
+    TorchLean.Semantics.relu x = x := by
+  unfold TorchLean.Semantics.relu
+  exact max_eq_left hx
+```
+Deeper proof libraries: `NN.Proofs.*`, `NN.Verification.*`, `NN.MLTheory.*`.
+## From the README — NOT compile-validated here, verify before relying on it
+```lean
+def data : Trainer.Dataset (.dim 2 .scalar) (.dim 1 .scalar) := Data.tensorDataset xs ys
+-- Trainer.new model { task := .regression, optimizer := optim.sgd { lr := 0.05 }, ... }
+```
+CLI verification workflows: `lake exe verify --help`, `lake exe verify -- torchlean-ibp`
+(IBP/CROWN robustness certificates). Examples live in NN/Examples/Verification/.
+## Trust boundaries (from the repo's TRUST_BOUNDARIES.md)
+TorchLean's executable float32 path and its ℝ semantics are different layers —
+say which one a claim is about. CUDA/native-runtime results are runtime evidence,
+not Lean proof evidence; the repo itself makes this distinction. So must you.

rockycode/tui/__init__.py ADDED Viewed

	@@ -0,0 +1 @@
1	+ """rockycode TUI: a Textual front-end subscribing to engine events."""