Repository navigation
Architecture Loop Engineering Friction
This log records concrete documentation, checkout, discovery, and proof-probing failures encountered while progressing repository loop-engineering work. It is separate from the mathematical generalization backlog: an API being hard to discover is not evidence that a mathematical generalization is valid. Each entry records a prevention step for later runs.
| Date | Friction and effect | Prevention for later runs |
|---|---|---|
| 2026-09-24 | Controller review found that ignored .loop-runs folders are worktree-local, so a linked sibling checkout could initialize a second ledger after cap exhaustion. It also found ordinary push/PR creation could publish changed content after a pass without exact-failure admission, and a final-path symlink could leave the canonical ledger tree. |
Preserve old ledger bytes with read-only compatibility defaults; scan linked worktrees for duplicate issue/slug/chunk ledgers; bind post-pass shipping, resolved ledger paths, and base_ref to the frozen review contract. |
| 2026-09-21 | A search centered on KProjective initially suggested that affine bounded-above projective preservation/coherence was missing. The merged base already had it under BoundedAboveProjective.lean and AffineKProjective* files. |
Search filename inventories and mathematical synonyms (bounded above, affine, preserves projectives, coherence) before proposing a chunk; verify declarations and audits on the exact base. |
| 2026-09-21 | The root checkout and the isolated SF8 worktree exposed different generalization-backlog.md contents. An initial read from the wrong checkout hid the existing UNVERIFIED Tor-comparison row. |
Before reading or editing a task artifact, print the active worktree root and git rev-parse HEAD; use absolute paths from that worktree and re-check git status. |
| 2026-09-21 | A prototype of IsLeftDerivedFunctor along the isomorphisms on a category already equivalent to its derived image compiled, but expressed only equivalence transport and added no non-flat/K-projective content. Adversarial review caught the tautology before code was accepted. |
Require a concrete non-isomorphism weak equivalence or a proved non-flat derived effect in the theorem's data; reviewers should challenge whether the conclusion follows solely by equivalence transport. |
| 2026-09-22 | A reviewer in a different, stale SF8 worktree recommended replaying the H⁻¹-only chunk even though PR #1457 had merged and the active origin/main was exactly b8306d6b. |
Give every adversary the absolute active worktree and full base SHA; require them to verify git rev-parse HEAD, origin/main, and live PR state before recommending a chunk. Treat summaries from another checkout as untrusted until reconciled. |
| 2026-09-22 | Mathlib's Tor definition, its chosen-projective-resolution computation, and the chain/cochain indexing bridge are in separate files. Tor derives the second tensor factor; using Tor' or silently swapping arguments would be wrong. Also, extendScalars did not synthesize Additive in the probe; fixed-left tensor followed by restriction of scalars did. |
Inspect pinned declarations and instantiated types, not filenames alone. State the Tor orientation and target module category explicitly, and test typeclass obligations before writing the public statement. |
| 2026-09-22 | The candidate restriction from CochainComplex ℤ to ChainComplex ℕ compiled through its terms, augmentation, and projectivity, but QuasiIso did not. restrictionHomologyIso cannot handle degree zero here because embeddingDownNat does not contain the cochain successor 1; an edge-specific proof is required. |
Add a boundary-index case to proof plans before freezing any chain/cochain comparison; do not treat a generic interior-degree lemma as covering degree zero. |
| 2026-09-22 | A query to the issue tracker used a guessed repository owner and failed; resolving the configured remote gave chris-dare-dev/derived-alg-geo-lean. |
Use the repository slug in the validated loop manifest or inspect the configured remote; never infer a provider owner from a shortened repository name. |
| 2026-09-22 | The worktree-cache helper was not executable by direct invocation, though running it with bash worked. |
Preserve and report the exact failed invocation; inspect the script mode/shebang and use its documented shell entry point rather than inferring the script itself is broken. |
| 2026-09-22 | A fresh tracked OpenSpec/manifest draft cannot itself pass preflight: the controller requires a clean checkout exactly at base_ref, but the draft exists only on the implementation branch. The attempted local-tag base workaround was rejected because action push does not publish tags and the ledger does not bind the resolved base OID. |
Superseded 2026-09-22: the plan now travels in the work PR. Preflight accepts an uncommitted or branch-committed manifest and OpenSpec change on a head that contains base_ref; no planning PR merges first (see .claude/loop-specs/README.md). Formerly: a one-time planning-only bootstrap PR, as in SF8 PR #1447. |
| 2026-09-22 | A reviewer tried python3 scripts/loop_engine.py validate <manifest>; the CLI accepts the spec only as validate --spec <manifest>. This was a usage error, not a manifest failure. |
Follow --help and the exact command shown in the manifest README; report parser/usage failures separately from validation verdicts. |
| 2026-09-22 | The controller hashes every required OpenSpec artifact, including tasks.md, and refuses PR creation or merge if any changes after ledger initialization. Marking task 1.7 complete in its implementation PR would invalidate the evidence needed to create or merge that PR. |
Superseded 2026-09-22 for v2, then refined by v3 on 2026-09-23: v2 uses its original regex to normalize checkbox-shaped task lines and excludes agent-observations.md; the regex also matches examples. V1 ledgers retain their earlier read_text digest behavior, so task-box changes remain digest-visible there. Current v3 behavior is recorded in the newer parser entries below. |
| 2026-09-22 | The altitude review found that the live #554 issue checklist and roadmap summary still list a nonidentity, nonflat supported example as outstanding, although merged PR #1404 supplies the affine witness and #1457 adds its explicit H⁻¹ effect. The roadmap gate passes without reconciling this stale prose. | Before eventual issue closure, reconcile the issue checklist and roadmap summary against merged PR evidence in a separately scoped tracker update. Do not reopen an already supplied example as implementation work, and do not infer that the remaining K-flat, preservation, and coherence obligations are complete. |
| 2026-09-22 | Porting the scratch Tor bridge into the source file exposed several API/syntax assumptions: tensoringLeft needs CategoryTheory.MonoidalCategory opened; the public comparison is an Iso, so it must be a noncomputable def rather than a Lean theorem; and the Tor degree reindexing only elaborated with the literal negative indices passed to restrictionHomologyIso. |
Preserve the exact scratch imports/open declarations and compiled index expressions when moving a proof into a module. Treat these as API-discovery/transcription failures, not mathematical counterexamples, and build the named source target before review. |
| 2026-09-22 |
python3 scripts/check_audit.py --help treats --help as its required output-file path and fails with FileNotFoundError; unlike the adjacent completeness checker, it has no CLI help parser. |
Read the audit script's usage/docstring or source signature before probing legacy scripts with conventional help flags; pipe audit output to /dev/stdin when checking a single audit leaf. |
| 2026-09-22 |
loop_engine.py validate accepts an unquoted #554 inside a YAML acceptance scalar, but YAML treats it and the rest of that scalar as a comment. The initialized ledger therefore ended its last acceptance item at “references,” despite the source line also specifying the no-close and review/CI conditions. The configured progress closure, four reviewers, required ci, and disabled issue-close mutation remain separate and intact. |
Quote or block-scalar any manifest value containing issue references; inspect ledger show after init, and add schema validation that detects comment-truncated acceptance strings rather than relying on a successful YAML parse. |
| 2026-09-22 | The abstraction review found a public nonzero-Tor theorem whose proposition mentioned private module abbreviations. Lean exposed generated inaccessible names in the imported theorem type, although the adjacent comparison theorem already spelled out the concrete modules. | Keep private abbreviations inside proof terms; spell public specialization data in the declaration type and inspect imported #print output when reviewing API accessibility. |
| 2026-09-22 | OpenSpec's generated apply guidance and the generic run-loop guidance allow up to five review rounds, while this SF8/SF9 change's design and enabled manifest cap a frozen chunk at three and make the third unsuccessful round terminal. | Treat the task-specific frozen manifest and its three-round budget as the controlling ceiling; generated or generic guidance cannot widen it. Reconcile these sources when the guidance is next maintained. |
| 2026-09-22 | The review ledger becomes terminal immediately after a passing adjudication. A later process-only commit in an allowed file could not receive another recorded review, even though three rounds were configured; the extra note therefore had to stay out of the code PR. |
Superseded 2026-09-22: a passed review now covers a later head (an empty commit, a clean rebase, or a merge of main) when three conditions hold. The head carries the same change against the base tip GitHub reports. Only task checkboxes and the top-level observation log changed. The base left the reviewed files, their direct imports and the pins alone. Otherwise one revalidation round with the full panel reopens the pass without spending the improvement cap; a ledger allows at most two. |
| 2026-09-22 | The desktop worktree initially used its generic codex/ branch prefix, but loop_engine.py allows only the manifest-planned agent/<issue-slug> branch for provider actions. Detecting this after code review required preserving the reviewed commit on a new planned branch. |
Select the manifest's exact issue branch when opening the implementation worktree; validate branch naming before the first commit, not at publication time. |
| 2026-09-22 |
gh pr checks --required returned “no required checks reported” while the PR workflow jobs were running, even though branch protection requires the aggregate ci context. The workflow exposes build and roadmap first, then runs the ci aggregate after both finish. |
Inspect the base branch's required contexts and the workflow's aggregate job; monitor the full PR status rollup rather than treating an empty --required filter as a CI failure or as proof that no gate is configured. |
| 2026-09-22 | Several read-only probes guessed paths instead of consulting the active tree: docs/architecture/loop-friction-log.md, DerivedAlgGeo/AlgebraicGeometry/Families, and scripts/AlgebraicGeometryAudit/Modules.lean do not exist; the actual locations are loop-engineering-friction.md, AlgebraicGeometry/DerivedCategory/Families/, and scripts/AlgebraicGeometryAudit/ModulePullback.lean. |
Resolve filenames with rg --files (and use the paths frozen in the manifest) before opening them; do not reconstruct this repository's hierarchy from remembered Mathlib paths. |
| 2026-09-22 | An API probe guessed Adjunction.leftAdjointUniqIso; the pinned API uses Adjunction.leftAdjointUniq. The wrong identifier interrupted exploration of the affine pullback/tilde comparison, but was not a mathematical obstruction. |
Search the pinned source or run a focused #check before encoding remembered theorem names; preserve the exact compiled spelling in the probe notes. |
| 2026-09-22 | A broad web search for issue #554 surfaced unrelated GitHub issues with the same number in other repositories. The configured repository's direct issue URL identified the intended SF8.5 contract. |
Resolve issue URLs from the validated owner/repository in the active manifest or configured remote; issue numbers alone are not globally identifying. |
| 2026-09-22 | The affine derived pullback API transports extension of scalars through the quasi-coherent equivalence, but that alone does not identify it with full Scheme.Modules.pullback on module sheaves. Treating these as interchangeable would silently upgrade an underived representative comparison into a scheme-level derived claim. |
Prove and audit the explicit affine pullback/tilde comparison before using the transported affine operation as a geometric pullback; keep derivedPullback's exactness gate and the general K-flat gap visible. |
| 2026-09-22 | Two exploratory shell calls failed before reading or changing files: an unescaped backtick terminated a quoted Bash command, and rg -E was mistaken for an extended-regex flag (-E means encoding in ripgrep). |
Use single-quoted shell patterns or avoid shell quoting around Markdown syntax; use ripgrep's -e for an explicit pattern and consult rg --help when option spelling is uncertain. |
| 2026-09-22 | At the initial scratch stage, the generic affine pullback/tilde comparison and its lift to arbitrary cochain complexes compiled, but the concrete nonzero H⁻¹ had not yet been transported into the target scheme-derived category. |
Keep the full derived transport as a frozen acceptance condition until one theorem composes the actual pullback comparison with the module-side calculation; do not infer the endpoint from separate scratch lemmas. |
| 2026-09-22 | A follow-up scratch proof compiled the affine realization's target scheme-module H⁻¹ nonvanishing using mapDerivedCategoryHomologyIso, affineTildeDerivedHomologyIso, and the affine QCoh inclusion, but at that point it still had not composed the result with the actual-pullback/tilde complex comparison. The source theorem now completes that composition and builds. |
Preserve the exact endpoint in the single source theorem and rerun its named target after edits; separate compiled lemmas are not a substitute for the end-to-end check. |
| 2026-09-22 | After the planning bootstrap merged, controller preflight rejected a clean detached checkout at the exact base SHA because git branch --show-current is empty. Its diagnostic says “from a detached or dedicated agent branch,” but the current implementation rejects both the protected branch and a detached checkout. Creating the manifest's dedicated local agent/sf8-5-affine-resolution-pullback branch at that same commit made preflight pass. |
Run from a dedicated local issue branch at the exact base SHA and match the manifest slug. Treat the current diagnostic as stale/misleading; a future controller maintenance change should align the predicate and error text. |
| 2026-09-22 | The end-to-end scratch transport hit two Lean elaboration mistakes: the target homology functor was first inferred on Scheme.Modules rather than DerivedCategory (Scheme.Modules), and writing the factorization RHS with a separately inferred HasDerivedCategory.standard caused a Q universe mismatch. The pieces compile when the target Q object is named through (F.mapHomologicalComplex up ⋙ DerivedCategory.Q).obj baseChangedResolution and F.mapDerivedCategoryFactors.app supplies the comparison. Explicit scheme-module abelianity and affine-tilde exactness imports/instances were also missing in the probe. |
Name the target derived-category functor and Q object explicitly before applying naturality/isomorphisms, import the module AB and quasicoherent extension leaves, then compile the single source theorem as recorded in the next row. |
| 2026-09-22 | Moving the final transport into the source exposed concrete elaboration edges hidden by generic scratch variables: the generic private additive instance did not synthesize for the two concrete tilde functors, Functor.map_id resolved to the natural-transformation theorem rather than the objectwise field, and the named zmodTwoSchemeMap needed unfolding to match Spec.map zmodTwoRingMap. The combined target theorem now compiles after using two explicit private concrete additive instances, F.map_id, and unfolding that alias. |
Recheck typeclass synthesis at the final concrete specialization; distinguish the functor field F.map_id X from the natural-transformation lemma, and unfold named map abbreviations only at the comparison boundary. |
| 2026-09-22 | An early scalar-extension probe used change-of-rings tensor notation without opening the ChangeOfRings scope and without the tensor-product tower API import, so parsing/elaboration failed before reaching the intended distributivity proof. |
Copy the exact scope and focused tensor-product import from the compiling leaf, and separate parser/import failures from proof failures in the run notes. |
| 2026-09-22 | The first focused check_audit.py call supplied only the output path, so the script silently used its default StabilityConditionAudit.lean command count and correctly rejected a 29-record ModulePullback audit. The optional source-audit argument is documented in the script docstring but not in the short CONTRIBUTING.md example. |
For a non-default audit leaf, pass both the captured output and its exact .lean source path; verify the audit-specific command count before treating a mismatch as truncation. |
| 2026-09-22 | The ledger show subcommand uses --state, unlike validate and provider actions which use --spec; the first inspection command guessed the latter and stopped at argparse. |
Read each subcommand's --help independently instead of assuming a shared option vocabulary across loop_engine.py commands. |
| 2026-09-23 |
scripts/precheck.sh ran the changed-module build and every other local gate successfully, but loop-spec failed on the unrelated .claude/loop-specs/issue-1394-audit-record-cleanup.yaml: the manifest has a base ref that the current validator no longer accepts (spec.base_ref must be 'origin/main'). |
Preserve this as a separate stale-manifest/tooling issue; do not widen the SF8.5 chunk or edit another frozen manifest during its CI repair. Report the local gates individually and rely on hosted PR CI for the required verdict. |
| 2026-09-23 | The saved workspace checkout was 21 commits behind origin/main (verified with git rev-list --count 503817d7..4739a0f8) and showed an obsolete OpenSpec completion count. On the refreshed base, task 1.8 and its scheme-module H⁻¹ endpoint were already implemented by merged PR #1471, though the checklist was unchecked. |
Resolve progress from the exact origin/main tree, live merged-PR state, and source declarations before choosing a chunk; never treat the desktop root's cached plan as current. |
| 2026-09-23 | An enabled-looking Tor manifest still passed validation and preflight after its chunk had merged as PR #1464. A fresh worktree collided with an existing local branch and stale origin tracking ref. A later live check found no matching GitHub branch (git ls-remote --heads returned none), so the earlier remote-existence claim is not independently corroborated after merge. |
Before initializing a ledger, reconcile manifest scope with live PR head/state and OpenSpec tasks; verify a new slug against local and remote branches before switching or creating it. Consider a controller preflight check for already-merged matching PRs. |
| 2026-09-23 | The next #554 construction task says “supported” but does not identify its input class. Existing APIs distinguish all scheme-module complexes, the affine K-projective derived locus, and the Dqc locus; the interface for K-flat resolutions has no general scheme-module producer, and nonflat acyclicity remains morphism-specific. | Record this as an explicit unresolved contract boundary. Before attempting the all-scheme theorem, name the input category, boundedness, scheme scope, and whether the deliverable is a resolution producer, acyclicity, or both; do not fill the gap with a parallel carrier. |
| 2026-09-23 | The merged #1471 controller manifest rejected an explicit --keep-branch option even though its configured default already retained the branch; the option was treated as an unauthorized override. |
Omit merge-policy override flags when the manifest's defaults express the requested behavior; use the controller policy verbatim. |
| 2026-09-23 | The cache-seeding instructions showed scripts/seed_worktree_cache.sh as a direct executable, but Git records mode 100644; direct invocation failed while bash scripts/seed_worktree_cache.sh worked. |
Check tracked mode when a documented script invocation fails; run it through its declared shell rather than treating this as a script logic failure. |
| 2026-09-23 | A namespace-level API probe initially missed Spec.map because AlgebraicGeometry was not opened, and then lacked local additive instances for affine tilde and the scalar-extension/tilde composite. |
Copy the exact namespace openings and additive-instance setup from the compiling affine comparison module; distinguish a missing scope/instance from a failed mathematical comparison. |
| 2026-09-23 | Adversarial review found that checking only effective grants left legacy-only exemptions (protected-path/link checks, force-push, admin merge, and non-PR closure) consulting the local digest. A follow-up review also claimed prior hash 41d884… was on origin/main, but the exact fetched base 4739a0f8 contained neither that hash nor the manifest; it was present only in planning commit 487e766f. |
Use the provider's default-branch controller as the authority for every legacy privilege, including ledger-bound exemptions; test the local-only digest against grants and each exceptional path. Give reviewers the full active worktree and base SHA, and verify claimed history with git show <base>:<path> before acting on it. |
| 2026-09-23 | Controller tests initially failed after default-branch review became part of manifest loading and ledger publication checks: old fixtures assumed local digest membership was sufficient and did not model the provider-side source. | Stub provider-confirmed review explicitly in branch-manifest fixtures; separately test default-reviewed/local-absent manifests and branch-local-only digests across grants, validation, and publication guards. |
| 2026-09-23 | Before SF8.5 task 1.9 was frozen, the altitude scout first proposed three backlog rows for Functor.mapHomotopyCategoryCompIso, Functor.mapDerivedCategoryFactorsh, and Localization.liftNatIso, although these are existing proof tools and the planned comparison can consume them directly. An independent source check caught this; the scout withdrew the rows. Its first report also grouped repository-defined kProjectiveLocusDerivedFunctor with a pinned Mathlib declaration. Writing the proposed rows would have misrepresented reused APIs as deferred lifts. |
Distinguish an existing API consumed by the current chunk from an unacted generalization that belongs in the backlog. Confirm each declaration's owner with a pinned-source or repository-path search. Resolve the wording mismatch between .claude/agents/altitude-scout.md (“one row per candidate”) and the backlog's narrower “could not be acted on inside the chunk” definition before changing the scout instructions. |
| 2026-09-23 | A pre-ledger friction-log edit touched a frozen chunk file, so preflight rejected the dirty worktree even though its documentation allows uncommitted plan artifacts. Stashing that note let the clean exact-base check and ledger initialization proceed; the note was restored immediately afterward. | Keep advisor dispositions in temporary notes until ledger initialization, then write them to the manifest-authorized friction log; distinguish uncommitted plan files from uncommitted chunk files in the preflight guidance. |
| 2026-09-23 |
scripts/precheck.sh found that loop-spec rejects the unrelated issue-1394 manifest's stale base ref, while 13 recovery/controller unit cases try to fetch the controller from the fake example/repository and receive GitHub 404s. The SF8 modules, audit, style and targeted-build gates passed; changing protected controller/test files is outside this chunk. |
Keep provider reads behind injectable test doubles for fixture repositories, run the isolated loop-engine suite separately from authenticated integration checks, and fix stale manifests in their own reviewed change. |
| 2026-09-23 | GitHub interpreted the negated PR-body phrase “does not close #554” as a closing reference, causing the roadmap job to fail despite the manifest's progress-only closure. Removing the negated keyword made closingIssuesReferences empty and the rerun passed. |
For progress PRs, avoid close/reopen keywords next to issue numbers even in negated prose; verify GitHub's parsed closing references and the hosted roadmap result before merge. |
| 2026-09-23 | A boundary reviewer recommended a trust-reviewed label based on stale CI assumptions. The fetched origin/main has no trust-review workflow or such requirement; the trust-guard surface had intentionally been removed, as the owner confirmed. |
Verify review gates against the exact base workflow and required-check configuration; do not restore retired trust labels based on historical instructions or reviewer memory. |
| 2026-09-23 | The OpenSpec apply guidance suggested appending agent-observations.md, but the active frozen manifest does not authorize that path; the only in-scope process record is the friction log. Editing the observation file would have widened the chunk. |
Treat manifest file scope as controlling over generic apply guidance; reconcile optional observation-log advice with the frozen manifest before implementation. |
| 2026-09-23 | At initial base 8351baf8, the SF8 plan used a legacy-reviewed manifest digest because the exact digest cannot self-authorize and the controller has no planning-only publication action. While PR #1491 was open, main advanced through #1490 and gained standing grants for push/create/merge, but not ready_pr or create_issue; the exact digest remains needed for these deliberately selected manifest-level grants. |
Recompute effective mutations against live default-branch authority after every base change. Register a digest only for deliberate per-manifest grants not covered by standing authority, and use an explicitly owner-authorized bootstrap when no controller action can publish it. |
| 2026-09-23 | I initially treated the missing .claude/loop-authority.yaml at base 8351baf8 as denying every provider action. That missed the controller's separate legacy-reviewed path; later main commit #1490 supplied standing grants for push/create/merge, while a digest-reviewed manifest can retain its additional explicit grants unless the standing file explicitly revokes them. |
Read effective_mutations and test both branch-authored and legacy-reviewed paths against the live default branch before declaring an authority blocker or choosing a bootstrap. |
| 2026-09-23 | The task-1.2 altitude scouts ran before a task-specific manifest existed and before its required preflight, so their outputs were useful reconnaissance but not ledger-bound review evidence. | Complete the publication step first; then run live preflight, dispatch both advisors again on the frozen scope, and record only post-preflight findings in the backlog. |
| 2026-09-23 | The supplied AGENTS snapshot still describes trust-guard.yml and a trust-reviewed label after the owner-confirmed CI removal in PRs #1449/#1455; following that stale passage would add a nonexistent prerequisite. |
Verify the exact base workflow and required contexts before acting on copied instructions; keep the removed trust surface retired and record any remaining documentation drift separately. |
| 2026-09-23 | At exact base 8351baf8, loop-spec failed only because existing #1394 had base_ref: agent/issue-1394-plan; loop-engine-tests ran 194 tests with 12 failures and one error. Base and branch had identical failure identities. Main later merged #1485, which updated the recovery fixtures and controller tests; the stale #1394 manifest remains a separate known failure. |
Compare baseline gates against the exact reviewed base and keep their evidence time-bounded. Do not call a local gate green when it failed; refresh this record after the base moves and repair unrelated fixtures/manifests in scoped controller-maintenance work. |
| 2026-09-23 | After merging current main ce58cc9e (including #1485), scripts/precheck.sh --no-build on the refreshed SF8 branch passed loop-engine-tests and every other gate, but loop-spec still failed only on the unrelated #1394 base_ref: agent/issue-1394-plan. This supersedes the earlier test-failure list as the current baseline; the full hosted ci remains the required verdict. |
Refresh local-gate evidence after a base merge. Waive only the exact still-reproduced unrelated failure; all other gates must pass, and never report the precheck as green while any gate fails. |
| 2026-09-23 | Adversarial review noticed that the parser dependency was documented for contributor setup and CI, but the canonical run-loop skill and manifest guide still invoked python3 scripts/loop_engine.py in fresh worktrees. Those commands would abort at import time when system Python lacks the pinned parser package, before validation or recovery could run. |
Install scripts/requirements-loop.txt into .loop-tools in each fresh worktree and use .loop-tools/bin/python for controller calls; keep setup and invocation guidance synchronized whenever controller dependencies change. |
| 2026-09-23 | A round-two handoff included a guessed full commit SHA instead of reading the branch's exact HEAD; a reviewer correctly stopped because the requested SHA did not match its checkout. |
Run git rev-parse HEAD immediately before dispatch, copy that verified 40-character SHA into every review prompt, and require the same exact SHA in each verdict trailer. |
| 2026-09-23 | Adversarial review found that raw HTML attributes can hide heading text and an image token can accompany Why while text-only extraction still equals Why; a task checkbox followed by a soft break also has a newline after its marker. |
Reject raw HTML and images in a qualifying heading, and test task-state normalization across space, end-of-item, and soft-break delimiters while keeping links and adjacent literal text contract-bound. |
| 2026-09-23 | After the digest default advanced to v3, the run-loop skill, manifest guide, and historical friction note still described v2 as current. This could lead a later run to assume examples or malformed checkbox labels are excluded from the v2 digest. | Keep versioned digest semantics explicit in user-facing guidance: v3 is current and CommonMark-aware, v2 retains its historical regex behavior, and v1 retains its own legacy behavior; search all active docs whenever the default digest version changes. |
| 2026-09-23 | A follow-up review found that updating direct controller examples was insufficient: scripts/precheck.sh invokes python3 internally, and recovery/formalization/landing plus root AGENTS.md/CLAUDE.md guidance still reached it without selecting the pinned environment. |
Trace dependency use through wrapper scripts as well as direct commands; set the venv on PATH for precheck wrappers and use the explicit venv interpreter in recovery examples. Search all operational guides and root instructions when adding a controller dependency. |
| 2026-09-23 | During PR #1485 maintenance, the unattended loop's manifest and standing-grant rules were applied to the owner's explicit request to push a conflict-resolution commit. The branch stayed conflicting until the request was handled directly. | State the boundary in the root instructions, run-loop skill, manifest guide, and contributor guide: controller grants govern unattended issue runs; a direct owner request authorizes the named PR maintenance action. |
| 2026-09-23 | Revalidation after merging main found that a CommonMark reference link beginning [x] was mistaken for a task box, reviewed-head comparison always used v3 rules even for v2 ledgers, and unknown digest versions inherited a known version's behavior. The new full-suite CI step also exposed recovery tests that queried the fake example/repository on GitHub. |
Inspect parsed inline children before normalizing a task box, select review comparison by ledger version, reject unsupported versions, and make provider-backed fixtures hermetic before adding the suite to CI. |
| 2026-09-24 | The run-loop guide and root CLAUDE.md said a missing OpenSpec CLI could never stop a run. The original controller design instead says cli-required is opt-in and fails closed. The first #1446 controller revision copied stale guidance into a passing regression test; independent adversaries caught the false green before publication, and round two found the remaining root-guide mismatch. |
Check the original behavioral contract when current operational prose and mode names disagree. Keep cli-required fatal on CLI absence or launch failure, cli-advisory warning-only, and all guides and tests aligned. |
| 2026-09-24 | Independent #1446 review found that malformed live protection entries were silently discarded, an older check's late completion could outrank a newer pending attempt, and approval ignored the checked PR head. Round two caught a residual race: gh pr review --approve has no commit pin, so a push after the comparison could still attach approval to an unreviewed head. The initial unit suite had passed throughout. |
Reject malformed protection entries and ambiguous duplicate attempts, order retries by start time, and use the provider's commit-bound review API for approval; keep focused race and malformed-payload regressions. |
| 2026-09-24 | A read-only CLI reviewer independently confirmed the malformed-protection finding but consumed 163,647 tokens, while its project AGENTS.md load was truncated by the runner's document budget. The collaboration adversaries found the same defect with smaller, bounded prompts. |
Prefer focused collaboration reviews on an exact commit for later rounds, and split oversized project guidance or route reviewers to relevant sections so truncation does not silently omit policy. |
| 2026-09-24 | The untracked #1446 OpenSpec/manifest draft was found in the terminal #1451 controller worktree at 868ed290, not on current main. It predates #1493's issue-first policy and incorrectly made two documentation corrections wait for a clean-bootstrap successor. The already-closed #927 and #570 task lists still have unchecked lifecycle boxes, which do not establish unfinished mathematics or a recoverable original review ledger. |
Start user-requested #1446 work from the live issue and a fresh current-main worktree; leave the old worktree and historical checkboxes untouched. Use the controller protocol only for a separately chosen standalone unattended run. |
| 2026-09-24 | PR #1419 merged at 2026-09-21 23:13:47 UTC. Its trust-surface check completed with FAILURE five seconds later; ci completed with SUCCESS at 23:27:10. The live main protection query on 2026-09-24 returned only ci as required. The available status does not establish the exact merge-time protection settings or that the failed check passed. |
Preserve the final check rollup and timestamps as a historical control-plane discrepancy. Re-query current required checks for each new PR, and never mark an old check green or infer a protection bypass from its later result. |
| 2026-09-24 | A direct read-only probe of current scripts/loop_engine.py's run_command with an unavailable executable raised uncaught FileNotFoundError; its subprocess.run wrapper does not turn launch failure into LoopError. The first probe used from scripts import loop_engine and instead failed on the script-local loop_recovery import; adding PYTHONPATH=scripts exposed the intended failure. |
Add a focused missing-executable regression in the controller-owned #1446 follow-up chunk. For source probes, select the script directory on PYTHONPATH before interpreting import failures as controller behavior. |
| 2026-09-24 | A fresh adversarial source-agent spawn returned agent thread limit reached despite another completed agent being reusable; a follow-up task to that existing agent succeeded. |
Reuse a completed independent agent or a read-only CLI reviewer when spawn capacity is unavailable, and retain the exact task/commit binding; do not silently skip a required review role. |
| 2026-09-24 | Historically, SF11.4 issue #1063 was labelled epic, while the branch-authored unattended loop controller disallowed epic opt-in and standing authority had create_issue: false; at that point there was no open non-epic child for the finite-cover obligation. This prevented ledger initialization for the parent through that controller. |
Resolved for user-started work: current AGENTS.md permits explicit user-authorized issue-first work without an OpenSpec plan, controller manifest, or preflight; the epic label is not a current start blocker. Controller eligibility applies only to separately chosen unattended runs. A child issue #1496 was also later owner-approved for the historical controller path. Do not revive this old controller obstacle as ceremony for a user-started chunk. |
| 2026-09-24 | The SF11.4 worktree cache helper copied repository oleans but its shared .lake/packages target lacked several Mathlib/Batteries oleans, so an ordinary lake env lean failed on TStructure.Induced and Batteries.Lean.HashMap. An alternate worktree had caches at the same Mathlib and dependency pins, except MathFormalContract, which was built at the current pin. |
Check dependency revs against lake-manifest.json, then seed the package build cache too or provide a pin-checked cache path; do not interpret a missing olean as a failed proof. |
| 2026-09-24 | A read-only SF11 search guessed CategoryTheory/Triangulated/TStructure/IndExtension.lean; the owner is actually under CategoryTheory/Triangulated/CompactlyGenerated/. |
Use rg --files for the actual owner path before concluding an interface is absent. |
| 2026-09-24 | The comment on the existing finite-family Noetherian-object detector says pinned Mathlib's JointlyReflectIsomorphisms requires a common target, but the pinned Functor/ReflectsIso/Jointly.lean accepts dependent target categories. The theorem itself remains useful; only that API explanation is stale. |
Check the pinned declaration's type before treating a repository comment as a current API limitation; correct the comment in a separately scoped edit. |
| 2026-09-24 | The owner approved child issue #1496, resolving the epic eligibility obstacle for this chunk. Preflight then failed the required global roadmap gate because another loop created #1495 on milestone 31 and added it as a live blocker of #554 without updating stability-families.yaml (RM-05 and RM-06). This SF11 branch cannot responsibly repair unrelated SF8 roadmap state inside its frozen math chunk. |
When a loop creates a follow-up issue on a roadmap-owned milestone, publish the issue/roadmap relation together or leave the follow-up off that milestone until its owning lane can update the roadmap; report cross-lane gate failures without weakening roadmap_gate. |
| 2026-09-24 | PR #1493 changed the active AGENTS.md and manifest guide after this SF11 plan was started: user-initiated issue work now takes the issue-first path and does not require a controller manifest, OpenSpec record, or preflight. Retaining the old manifest would add ceremony and leave an unrelated SF8 roadmap mismatch as a controller-only start gate. |
Refresh repository guidance on moving main; for user-started issues, use the issue's acceptance criteria, scoped commits, independent review, and hosted checks directly. Keep controller artifacts only for a run that actually opts into the bounded controller protocol. |
| 2026-09-24 | After PR #1498 synchronized the live child-issue relationships, PR #1497's hosted roadmap gate reported RM-08: its Closes #1496 reference requires that child's roadmap entry to be done in the same PR. The earlier unscoped local precheck passed while the issue was still open and the entry was in_progress; after advancing the entry, an unscoped local check may disagree until merge closes the issue. |
For a closing PR, advance only its deliverable entry in the PR diff and run the PR-scoped roadmap check (--scope-to-diff=origin/main --pr=<number>); distinguish the simulated post-merge closure from the issue's current live state. |
| 2026-09-24 | A passed ledger could treat a changed implementation as an ordinary protected-base revalidation, while stale CI evidence from another head could not justify a safe repair. This could publish new code without charging the original review cap or could tempt an operator to start a replacement ledger after exhaustion. | Require exact live failure evidence for a check on the current full PR head that is required by both manifest and branch protection; append the repair event and charged round to the same ledger. Re-read PR, refs and protection before writing, and scan all nested .loop-runs by issue, slug and chunk so renamed state cannot reset the cap. |
| 2026-09-24 | The first full precheck caught an ordering regression: action push rejected the current branch name before consulting a recovery-managed ledger, so its recovery-specific publication denial was hidden by an ordinary branch error. |
Resolve the selected ledger and its publication state before applying ordinary branch-name checks; keep all provider actions on the shared ledger guard so controller variants fail for their own state and never reach provider mutation. |
| 2026-09-24 | The existing SLocal.lean declaration lemma_4_16_3 describes an arbitrary lifted filtration, but its Filtration and Lemma416Part3Data types record only a chain of objects and successive monomorphisms, not subobjects of one fixed ambient heart object. Treating this adapter as a proof of the stabilization needed in Theorem 5.7(2) would silently assume the missing geometric lift. |
Compare paper statements with the actual Lean type before consuming a named adapter. Use ℕ →o Subobject F for the fixed-ambient categorical step, keep the bounded-heart and geometric lifting obligations explicit, and do not infer Noetherianity from an unanchored chain. |
| 2026-09-24 | In the SF11.4 bounded-heart follow-up, BaseChangeSequence.boundedSequence_hasTriangulatedComponents still assumed that the intrinsic bounded-coherent locus is triangulated. The already-proved triangulatedness of Dqc(X) and the existence of Dᵇ(Coh X) do not supply that instance for the separate bounded-coherent-cohomology property. A fresh worktree also had an incomplete repository olean cache; Lean reported a missing import until given one complete cache root at the matching manifest and toolchain pins. |
Prove the bounded-coherent property triangulated from coherent-sheaf kernel/cokernel closure (supplied by local Noetherianity) via weak-Serre cohomology intersected with standard boundedness; keep preservation by the base-changed t-structure's truncations as a separate obligation. For local checks, use one complete pin-matched olean root rather than placing a partial root first in LEAN_PATH. |
| 2026-09-24 | Resuming #1495 initially ran OpenSpec status in the desktop's main checkout, while the active code was in sf8-flat-generators; this reported a different task count. The branch's old manifest preflight then rejected the dirty implementation files and its pre-merge HEAD because origin/main had advanced. Current main's #1493 issue-first policy makes that manifest/preflight optional for user-started issue work. |
Before acting on carried context, verify the active repository root, branch, HEAD, and live issue. For a user-started issue, use the issue body as scope and don't turn an optional preflight or missing authority file into a blocker; retain the requested adversarial review and round cap. |
| 2026-09-24 | The SF8/SF9 apply status was again read from the desktop's stale checkout instead of the active worktree: it reported 1/13 tasks, while the current branch records 6/16 after merged affine slices and task syncs. This repeated the already-documented worktree-selection failure because the carried context named the repository root, not the active branch path. | Run OpenSpec status and read its context files from the same verified worktree used for implementation; before reporting progress, compare the active branch's task list and origin/main, not the desktop checkout's stale task copy. |
| 2026-09-24 | The free-Yoneda stalk calculation had several API false starts: a hand-built freeObjDesc path hit a scheme namespace alias, the module unit needed an explicit coercion rather than OfNat, and remembered freeDesc_apply rewriting did not match the pinned freeYonedaEquiv goal. The working route uses the canonical freeYonedaEquiv, its composition/naturality lemmas, and the sheafification/stalk comparison. |
Probe the pinned equivalence and its naturality before reconstructing an adjunction map by hand; spell the ModuleCat unit carrier explicitly and keep the scheme stalk comparison as a downstream geometric proof. |
| 2026-09-24 | In the identity-base flatness proof, rewriting the point equality (𝟙 X) x = x caused a dependent-motive/typeclass mismatch. |
Rewrite Scheme.Hom.stalkMap_id first, then expose the identity restriction-of-scalars module with change and transport flatness using ModuleCat.restrictScalarsId'App; avoid rewriting the indexed point equality. |
| 2026-09-24 | The altitude scout found Stacks Project Lemma 6.31.8 (tag 00A7), which gives the stalk formula for extension by zero along an open immersion. It does not establish that the repository's SheafOfModules.freeYonedaSheaf is that extension-by-zero object; treating the analogy as a Lean comparison would overstate the evidence. |
Use the direct proved stalk calculation for free-Yoneda sheaves. Claim an identification with j_! only after proving an explicit comparison using the pinned local API. |
| 2026-09-24 | The new generic SheafOfModules declarations live under Algebra/Category/ModuleCat/Sheaf/, but their axiom records were initially placed in AlgebraicGeometryAudit. The audit registry routes that module subtree to StabilityConditionAudit, so geometry-lane checks alone could not satisfy declaration completeness. |
Before adding audit records, consult the declaration-to-lane routing in scripts/EnumDecls.lean; split records by owning audit lane and run audit completeness after cross-lane additions. |
| 2026-09-24 | The heart's Abelian structure is available via heartFullSubcategoryAbelian, not as an automatically inferred instance in the TStructure.Restriction theorem signature. An initial pointwise-lift specialization failed to elaborate p ⊔ q and synthesize HasImages even though the generic subobject lemma compiled. |
For the final triangulated-heart theorem, register heartFullSubcategoryAbelian as a local instance and derive finite-colimit preservation from short-exact preservation. Do not mistake missing local instance synthesis for a mathematical obstruction or impose redundant public hypotheses. |
| 2026-09-24 | A pinned Mathlib image-preservation import guessed from its source path had no local olean, and no ready-made mapFunctor join theorem existed. A scratch proof using image.isoStrongEpiMono and the image-of-coproduct definition compiled, giving the required binary join comparison under mono, epi, and binary-coproduct preservation. |
Search pinned declarations and available oleans before asserting an API exists; prove the generic Subobject.mapFunctor_sup in its owner module and consume it from heart exactness, rather than retaining an unexplained hjoin premise. |
| 2026-09-24 | The paper's Lemma 4.16(2) lifts a morphism into a fixed source ambient object before taking its image. Repository SLocal.lemma_4_16_3 stores a chosen quasicoherent filtration lift, and AffineLocalizationPullback supplies object essential surjectivity for derived modules, but neither supplies this bounded-component morphism extension. Calling either a pointwise subobject-lifting proof would overstate the source. |
Add a bounded-component localization-specific morphism-extension theorem before claiming geometric pointwise subobject lifts; use ImageFactorisation only after that arrow exists. Heart exactness discharges finite joins but not this geometric lift. |
| 2026-09-24 | Pinned Mathlib's Module.FinitePresentation.exists_lift_of_isLocalizedModule and localized-Hom API clear denominators for maps out of a finitely presented module; a scratch module theorem compiled. This does not automatically lift a morphism of derived bounded coherent components: the needed derived Hom localization, perfectness or pseudo-coherence/boundedness hypotheses, and component comparison are not supplied by AffineLocalizationPullback's object-surjectivity result. The fresh SF11 worktree also lacked package oleans, so its direct lake env lean failure was cache state, not a proof counterexample. |
Treat the module theorem as a verified lower-level input only. Prove and audit the derived Hom and component bridges before consuming it in Lemma 4.16(2); run scratch checks against a manifest-matched complete package cache. |
| 2026-09-24 | The #1495 adversarial pass found origin/main had advanced from 2e180203 to 28047178 while the four-lens review was running; the boundary reviewer correctly withheld a pass against the stale base. The update touched the shared friction log, causing a one-file merge conflict, but was disjoint from the Lean implementation. |
Fetch and compare origin/main immediately before freezing reviews and again before opening the PR. If it moves, merge the new base, preserve both documentation histories, rerun focused verification, and obtain a same-commit review against the refreshed base. |
| 2026-09-24 | The first hosted CI run found two failures that the local precheck did not cover: audit completeness found the generated declaration SheafOfModules.ι_fromFreeYonedaSheafCoproduct_assoc missing from the routed StabilityCondition slice, and Lean's defsWithUnderscore linter rejected a public _of_mem theorem name. |
Keep generated public declarations in audit inventory as well as explicitly written declarations. For new public names, run the pinned Lean declaration linter (not just the repository mathlib-style text gate); local precheck is not CI-equivalent. |
| 2026-09-24 | An initial fixed-target criterion quantified over every target arrow and separately assumed essential surjectivity of the heart functor. Adversarial review found the object-lift premise redundant (zero arrows force it), while the subobject proof itself only uses extension of monos. In the correction, the heart's zero object also needed an explicit local Zero instance despite the abelian and HasZeroObject instances being present; a bare 0 failed elaboration. |
Expose the weaker paired object/mono-extension criterion and retain all-arrow extension as a derived convenience theorem. In this file's proof context, install HasZeroObject.zero' _ explicitly before using the zero object; distinguish elaboration friction from the geometric gap. |
| 2026-09-24 | A read-only derived-Hom scout found pinned Module.FinitePresentation.isLocalizedModule_map and linearEquivMapExtendScalars for ordinary module Hom, and CochainComplex.IsKProjective.Qh_map_bijective for K-projective source models, but no theorem composing them into derived Hom localization for bounded coherent components. AffineLocalizationPullback lifts cohomologically bounded objects, not necessarily coherently (restriction of scalars along R → Rₓ need not preserve finite generation), and no checked comparison identifies it with Families K-flat base change or transports lifts into an arbitrary t-heart. |
Keep ordinary Hom localization as a lower-level input. Research finite/pseudo-coherent resolutions, derived Hom localization, pullback comparison, and heart membership separately before claiming the affine fixed-target mono-extension hypothesis. |
| 2026-09-24 | While PR #1507's 27-minute CI run was active, origin/main advanced again from 28047178 to 8018746. GitHub then reported the PR as conflicting; after the CI-fix push, the run list still showed only the previous head's checks. |
Re-check origin/main after long hosted runs, not only before PR creation. When it advances, merge the new base, preserve shared-log entries, and push the refreshed head before expecting a check run for that exact SHA. |
| 2026-09-24 | After the corrected PR #1507 run passed, origin/main had advanced again from 8018746 to 767a3639 while that 26m50 CI run was in flight. The PR was marked BEHIND despite its green checks; main's required ci status is strict, so the checked head could not merge unchanged. |
Re-fetch main immediately before merge as well as before CI. A green check on a head that is behind a strict-status base is not merge-ready; merge the latest base and wait for checks on the refreshed head. |
| 2026-09-24 | PR #1514's first refreshed full CI passed on base 701f004d, but main advanced to f25d69fb (#1522) during that ~24-minute run. Syncing and rerunning then cost another full CI cycle; strict required checks correctly rejected the stale green head. Re-fetching before CI and immediately before merge detects this, but cannot prevent concurrent main updates during a long run. |
Keep strict protection intact. On repositories without a merge queue, sync the latest base and validate the resulting exact head; if main advances during the run, repeat without source edits and reuse the unchanged source review. Consider a merge queue as a future workflow improvement rather than treating a stale-base green run as mergeable. |
| 2026-09-24 | An optional controller preflight for user-started #554 reported a live blocked dependency because GitHub returned #1495 in blockedBy with state=CLOSED, while the preflight rejects every nonempty node list. The issue-first workflow explicitly makes this preflight optional, so the stale controller result was not a mathematical or authorization blocker; it nevertheless consumed investigation time. |
For user-started issue work, follow the issue-first path without making an optional manifest preflight a start gate. If the controller is used, classify closed blockers as satisfied and fail closed only on active or incomplete blocker data; add regression tests before relying on that path. |
| 2026-09-24 | The module-stalk coproduct proof did not elaborate by instance search even though the component preservation proofs were available. Passing hF and hG explicitly to composition and using (preservesColimitsOfShape_iff_of_natIso ...).mp fixed the transfer. The stalked composite diagram also required Discrete.compNatIsoDiscrete, and Module.Flat.directSum_iff.mpr was needed to expose summand obligations. |
When transporting shape preservation through the module-stalk comparison, name and pass each preservation proof explicitly, then normalize the discrete diagram by its natural isomorphism before identifying its colimit with the module direct sum. Treat these as elaboration/API-discovery issues, not mathematical evidence for or against the general K-flat resolution. |
| 2026-09-24 | Initial K-flat reconnaissance mistook the optional LeftResolution.chainComplexMap_zero lemma's [F.PreservesZeroMorphisms] hypothesis for a prerequisite to constructing a LeftResolution or its chainComplexFunctor. The pinned Basic.lean shows the structure only needs a functor and natural epi; the stalk-flat full-subcategory instance and its induced resolution functor both elaborate without zero-map preservation. |
Inspect the fields and prerequisites of the exact pinned structure and distinguish optional helper lemmas from the construction path before declaring a blocker. Keep the genuine boundary explicit: this objectwise resolution does not construct a replacement functor for arbitrary unbounded complexes or establish K-flatness. |
| 2026-09-24 | The first LeftResolution.reduced scratch import failed because the seeded dependency cache lacked its pinned Reduced.olean; a targeted build of the named Mathlib module restored it. An alias-shaped flat ObjectProperty instance did not match Mathlib's inline predicate during typeclass search, and chainComplexMap_zero left metavariables stuck without its owner and endpoints. |
Build the exact missing pinned module as a named target, use the same ObjectProperty expression in the instance and consumer, and pass the resolution plus both endpoint objects explicitly to dependent zero-map lemmas. |
| 2026-09-24 | Mathlib documents that LeftResolution.reduced.F preserves zero, but extending its induced chainComplexFunctor to an outer homological complex also needs an explicit PreservesZeroMorphisms instance. mapHomologicalComplex gives the resolution bicomplex; exactAt_map_chainComplex_succ proves its rows exact only in positive resolution degrees. The theorem proves the natural termwise augmentation is epi; it does not establish that this map is a quasi-isomorphism, and no totalization/K-flat conclusion follows. |
Derive the functor-level zero-map instance from the pinned chainComplexMap_zero, use exactAt_map_chainComplex_succ and HomologicalComplex.epi_of_epi_f, and keep the full-bicomplex augmentation, totalization, and arbitrary K-flat replacement as separate proof obligations. |
| 2026-09-24 | In the #1514 style review, an adversary reported that the LeftResolution.chainComplexFunctor reference lacked Markdown code quoting, but the exact frozen source already had backticks. Adopting the unverified finding would have caused an unnecessary edit and another CI/review cycle. |
Adjudicate every finding against the named commit and line before revising. Quote the actual source text in findings; when a claim conflicts with the visible file, ask the reviewer to re-open the exact SHA and correct the verdict rather than editing to match a false positive. |
| 2026-09-24 | A fresh #1514 style review found an unqualified declaration link in a new docstring even though the changed-line style check passed. The repository guide explicitly requires fully qualified links, but the checker does not enforce that prose rule. | Keep adversarial docstring review focused on link qualification; report the changed-line style check as a formatting verdict, not as validation of prose links. |
| 2026-09-24 | Despite the #1514 friction note, the #1527 style review found two more new docstring references that were backticked but not fully qualified: Functor.mapHomologicalComplex and LeftResolution. The changed-line checker still passed because it checks formatting rather than declaration-link qualification. |
The #1514 prevention was insufficient. Fully qualify links from the declaration's actual namespace (CategoryTheory.Functor and CategoryTheory.Abelian.LeftResolution) and require a dedicated adversarial docstring-link pass until an automated checker covers this convention. |
| 2026-09-24 | The #1527 style review also caught the phrase “epi, not a quasi-isomorphism” in the friction note and source docstring. The proved theorem gives epimorphicity; it does not prove the map fails to be a quasi-isomorphism, so that negative phrasing overstated the evidence. | Say “the map is epi; no quasi-isomorphism is established” unless non-quasi-isomorphism itself has been proved. Keep the result and the missing theorem distinct. |
| 2026-09-24 | The repository already had Tilting.originalHeartCohFunctor and an objectwise heart-recovery iso for arbitrary t-structures, but both live under the stability/tilting import path. The SF11 categorical restriction owner cannot import that path without reversing the subject layering. Its existing Functor.mapTruncLEIso and mapTruncGEIso are objectwise; no natural comparison was available to turn an ambient arrow lift into a heart arrow. A direct mapTruncGEIso proof probe also exposed an index-transport cast from (n - 1) + 1 = n in the chosen triangle comparison. |
Put a minimal degree-zero heart functor and natural heart-recovery iso under TStructure/HeartBridge; establish natural truncation comparisons under TStructure/Exactness before claiming an ambient-to-heart lift. Prefer a two-index truncation-triangle comparison or explicit transport lemma when the mapTruncGEIso cast blocks naturality; keep the bounded-component geometric premise separate. |
| 2026-09-24 | The repository's Tilting.originalHeartCohFunctor was the generic degree-n cohomology root for arbitrary t-structures, despite living below stability/tilting. Adding a separate degree-zero owner would have duplicated it, as adversarial architecture review caught. The existing Functor.mapTruncLEIso and mapTruncGEIso were objectwise; the GE comparison's (n - 1) + 1 = n transport hid its morphism equation behind a dependent cast. A second review found that the specialized H⁰ normal form did not inherit the generic cohomology functor's additive instance through their natural isomorphism. |
Move the generic cohomology construction and additivity to TStructure/HeartBridge; retain the historical tilting name only as a downstream abbreviation. Give the specialized H⁰ functor its own audited additive instance and an objectwise degree-zero comparison. For the GE transport, use an explicit heterogeneous equality of the casted homs before eq_of_heq; GE naturality, natural H⁰ comparison, and the bounded-component geometric lift remain separate obligations. |
| 2026-09-24 | The first GE naturality proof probe appeared stuck after the dependent index cast was resolved: Mathlib's from_truncGE_obj_ext compares maps from the target connective truncation, while the chosen comparison iso points to it. A read-only research recovery found the missing orientation step in the pinned API, and the exact scratch proof compiled. |
Derive π' ≫ comparison.inv = F.map π from the proved GE morphism equation, apply from_truncGE_obj_ext after precomposing with that inverse, then use both truncation-projection naturality laws. Compose this with LE naturality to obtain the natural H⁰ comparison. The bounded-coherent derived-Hom and heart-lift geometry remain separate. |
| 2026-09-24 | In a fresh isolated worktree, direct Lean compiled the edited Exactness module but failed to import sibling ImageFactorisation while building Local, even though a later LEAN_PATH entry contained its olean. The diagnostic named the new worktree's incomplete first cache root. An adversarial reviewer also stopped a fresh Lake check when it tried to fetch a missing Mathlib checkout. These were cache-layout failures, not theorem counterexamples. |
Populate the new worktree's ignored olean tree with a no-clobber symlink farm from the pin-matched parent cache, then unlink only the edited module's symlink before emitting its local olean. Check the destination is a regular file so a build never writes through into the parent worktree. Use the pin-matched cache for read-only review checks; hosted CI remains the full-build verdict. |
| 2026-09-24 | The prior subobject criterion needs only extension of monomorphisms inside the heart, which tempts a direct use of ambient mono extension. That inference is invalid: a heart mono need not be an ambient triangulated mono, and ambient mono extension does not cover arbitrary heart-domain arrows. A scratch H⁰ proof instead established the valid transfer from ambient all-arrow fixed-target extension. | Use natural H⁰ comparison and H⁰-on-heart recovery to transport an ambient arrow factorization into the heart, with no ambient mono assumption. Keep the all-arrow ambient extension as an explicit geometric premise; do not report the Noetherianity corollary as proving it. |
| 2026-09-24 | A geometric recovery scout could compile the ambient exact affine-sheafification and supplied-K-flat pullback comparison, but not derived Hom localization or bounded-coherent arrow descent. The pinned module-Hom localization theorem requires finite presentation of the domain of a lifted arrow, not its fixed target. Restricting scalars from ℤ[1/2] does not itself preserve finite generation over ℤ; without finite presentation, the map from localized ∏ₙ ℤ to ∏ₙ ℤ[1/2] misses sequences with unbounded denominators. |
Land the exact ambient comparison separately and state flatness and supplied resolution hypotheses. For the later arrow theorem, identify a coherent descended domain model and prove the needed derived-Hom localization under boundedness or perfectness hypotheses before invoking the categorical heart transfer. |
| 2026-09-24 | The new affine comparison first reported pullbackSpecMapTildeIso unknown despite its current source declaration: the isolated olean cache lacked Modules/Pullback/AffineSpec. An explicit direct import and compilation against the matching pin resolved that false API failure. The full local geometry audit still reports unrelated older declarations missing from cached umbrella oleans, even though focused prints for all new declarations show only standard axioms. |
Name direct source dependencies instead of relying on a stale transitive olean; distinguish focused source/audit checks from a clean full build. Let hosted CI rebuild the umbrella and audit before claiming the complete lane passes. |
| 2026-09-24 | Both first-round reviewers found that the purported localization specialization still required callers to install flatness and pullback finite-limit instances, even though IsLocalization M A proves them. Architecture review also caught a duplicated spectrum-to-identity constructor already present in the S-linearity owner. |
Move the shared terminal base-change constructor to the lightweight base-change category owner, reuse it, and construct the K-flat acyclicity and exactness instances internally. Check a client invocation with only the localization and supplied resolution; review the revised chunk afresh. |
| 2026-09-24 | A pinned-Mathlib research probe proves localization commutes with a finite product of Hom modules from finitely presented sources and verifies bounded-above projective complexes are K-projective, but does not prove the derived-Hom comparison. Hom-complex degrees involve integer-indexed products; two complexes merely bounded above can leave infinitely many nonzero factors, and localizing ∏ₙ ℤ at 2 misses the unbounded-denominator sequence (2⁻ⁿ)ₙ. |
Require a strictly bounded finite-projective source, or a bounded-above such source with a bounded-below target, before attempting degreewise Hom-complex localization. Next prove compatibility with differentials, degree-zero cohomology, Qh, and affine derived pullback; do not infer the bounded-coherent arrow theorem from the finite-product lemma. |
| 2026-09-24 | After three capped adversarial rounds passed the heart cohomology slice, hosted CI exposed two gate-only omissions that the local precheck does not exercise: three public _assoc declarations generated by @[reassoc] were absent from the StabilityCondition audit, and the public triangle comparison definition lacked a docstring. Source compilation and axiom audits had already passed. | Treat this as research recovery after the critique cap: inspect the exact CI gate output and declaration owner, add the generated audit names and the missing documentation, then rerun hosted CI on the repaired head. Do not broaden the reviewed mathematical theorem or extend the critique cycle. |
| 2026-09-24 | The first full CI for the natural H⁰ comparison inherited three missing @[reassoc] audit entries from its parent and exposed a fourth generated companion, mapTruncGEIso_hom_naturality_assoc, in this slice. The parent gate repair covered the first three but not the new companion. | Inspect hosted audit-completeness output for each stacked head, add every generated public companion in its owner audit, and revalidate the stack; local source compilation and axiom prints alone do not enumerate generated declarations. |
| 2026-09-24 | A pin-matched Hom-complex recovery probe compiled a degreewise localization theorem under strictly finite support of the source and finite presentation of its terms, plus compatibility with the differential. HomComplex.Cochain is an integer-indexed product, so merely bounded-above source and target can still leave infinitely many factors; the product-localization argument needs an actual finite support condition. Its scalar instances also differ between mapHomologicalComplex and ModuleCat.localizedModule, requiring an explicit linear equivalence in the proof. | Land the cochain-level theorem with its exact hypotheses and a finite-projective corollary, but do not call it derived-Hom localization. Next transport through Hom-complex cohomology and K-projective Qh, then compare with geometric affine pullback; keep all three claims separate and audited. |
| 2026-09-24 | The bounded quasi-coherent affine localization lift uses restriction of scalars, which does not preserve coherence (for example ℤ[1/2] is not finite over ℤ). Moreover, Spec(M⁻¹R) → Spec R for an arbitrary multiplicative set need not be an open immersion (Spec ℚ → Spec ℤ is a counterexample), so the principal-open extension argument cannot be silently applied to full localization. The existing bounded-component pullback API does not prove essential surjectivity. | Establish coherent object descent at finite principal stages under Noetherian hypotheses and then pass to arbitrary localizations by finite-stage presentation. Project a coherent ambient lift into the chosen component only with an explicit base-change/projector comparison. Do not infer the fixed-target arrow lift from object descent alone. |
| 2026-09-24 | A pinned Lean probe proves finite module descent through arbitrary ring localization by spanning chosen localized generators inside the restriction-of-scalars module; over a Noetherian base the finite submodule is finitely presented. This avoids the false inference that restriction of scalars itself preserves finite generation. | Use the finite submodule and its scalar-extension isomorphism as the degree-zero object-lift ingredient only. To descend a bounded coherent complex, choose compatible finite submodules in finitely many degrees and ensure the differentials close; component/projector compatibility and arrow extension remain separate geometric obligations. |
| 2026-09-24 | An adversarial-review spawn temporarily hit the tool's agent-thread limit despite the SF11 process imposing no logical subagent cap. A completed research agent still occupied a live slot; closing that finished agent freed one immediately. | Close completed subagents before starting new review tasks. Distinguish the tool's concurrency slot limit from the task's three-round per-chunk critique cap; do not turn the former into a mathematical blocker. |
| 2026-09-24 | The first finite-module descent statement exposed only Nonempty (A ⊗[R] L ≃ₗ[A] N). Adversarial review caught that an abstract equivalence does not say the inclusion L ↪ N induces it; downstream differentials need the canonical comparison. | Export IsLocalizedModule S L.subtype as part of both descent witnesses and retain the equivalence as a convenience. Test a caller constructing the canonical base-change equivalence from that witness before using it for complex descent. |
| 2026-09-24 | A standalone finite object-lift theorem does not by itself descend a differential: independently chosen finite submodules need not be closed under the map. The next stage needs to preserve a previously prescribed finite submodule in each target degree. | Enlarge a prescribed finite R-submodule by joining it to a canonical localization witness; the join stays finite and its inclusion still localizes to the whole A-module. Audit this as a separate step, then build complex-level closure along finite support rather than claiming it from object descent. |
| 2026-09-24 | During adversarial review of the prescribed-submodule/one-arrow slice, a reviewer's isolated worktree lacked .olean files for the umbrella and kernel imports, so its full audit entrypoint could not run even though the focused source and new axiom prints compiled. This is an incomplete local cache, not a Lean proof failure. | Distinguish missing worktree cache artifacts from source errors; report which focused files and axiom declarations actually compiled, and let the hosted full CI decide the complete audit gate. |
| 2026-09-24 | A pin-matched research probe compiled exactness of localization on the concrete kernel/image cohomology quotient of a three-term complex. Pinned Mathlib's HomComplex.CohomologyClass is instead an additive quotient; its supplied homologyAddEquiv is additive, not an R-linear equivalence. Treating the concrete quotient result as a named CohomologyClass or derived-Hom statement would silently skip a map-natural, scalar-linear adapter. | Land and audit the generic module-level quotient theorem first. Build and review an explicit linear adapter to CohomologyClass separately, then identify with homotopy/derived Homs under the required K-projective hypotheses. |
| 2026-09-24 | A second Hom-complex probe found that a bounded-above source and bounded-below target still give finite effective support in each fixed degree n, namely Finset.Icc (c - n) b. The earlier finite-source-only theorem does not cover this useful case. The mapped-bound iff API would require a faithful functor, but localization need not be faithful; the probe instead uses map_isZero directly. | Generalize the finite-cochain equivalence degree by degree, then prove the full IsLocalizedModule theorem under finite presentation on that interval. Do not assert a uniform finite support over all degrees or derived-Hom localization from the probe alone. |
| 2026-09-24 | A pin-matched scratch now compiles an R-linear equivalence from the concrete kernel/range quotient to Mathlib's HomComplex.CohomologyClass, a map-natural square, and localization of the induced class map. The scratch gives CohomologyClass its module structure locally by transport; Mathlib exposes only an additive quotient, so treating this local instance as a stable global API would be premature. It also has not identified its class map with a geometric or derived-category comparison. | Integrate the linear adapter with an explicit/scoped module structure and independent review, then connect the induced map to K-projective homotopy/derived Homs under their actual hypotheses. Keep the compiled scratch result separate from merged theorem status until that integration lands. |
| 2026-09-24 | In the linear adapter, a generic @[simp] scalar-compatibility lemma compiled and could be applied directly at R = ℤ, but simp did not use it on an ordinary integer-scaling goal: Lean selected the canonical integer action rather than matching the transported scoped module action. Likewise, a downstream ≃ₗ[ℤ] annotation rejected the generic equivalence's captured module instances. These were API mismatches, not failed mathematical equalities. | Add an integer-scaling simp lemma through the additive quotient constructor (mkAddMonoidHom.map_zsmul) and an explicit ModuleCat ℤ equivalence using uniqueness of integer-module instances. Compile both ordinary downstream clients. Keep the general R-module structure scoped. |
| 2026-09-24 | The integer-specialized linear equivalence compiles under an ordinary ≃ₗ[ℤ] annotation, but does not yet have a representative _mk simp theorem; the generic equivalence does. No current localization proof consumes the integer specialization, so this is an API-convenience gap, not a blocker for the generic adapter. | Add and audit an integer-specific representative theorem in a separate reviewed chunk only when a downstream client needs simplification through that equivalence. Do not extend the completed three-round critique cycle for this optional case. |
| 2026-09-24 | A downstream naturality client exposed the deferred integer adapter gap immediately: the generic linear naturality square could not compose with a canonical ≃ₗ[ℤ] annotation, and the initial integer equivalence's convert-based instance transport did not reduce on representatives. This was an instance-coherence/API obstacle, not a failure of the naturality equation. | Define the integer equivalence from the underlying additive quotient equivalence via AddEquiv.toIntLinearEquiv, prove its representative formula, and expose a pointwise integer naturality corollary. Audit and compile an ordinary ModuleCat ℤ caller; do not claim the generic square is directly an equality of canonical integer linear maps. |
| 2026-09-24 | The concrete Hom-cohomology localization theorem compiled, but a downstream representative calculation was not definitional: its map transports the generic three-term quotient through proved equalities of differentials. Unfolding the transport in a caller stopped at a private equivalence, and an initial direct rewrite failed because Lean retained local instance and proof transports. An independent client also could not restate the theorem with ordinary canonical Module ℤ instances on the quotient, although the generic R statement compiles. | Expose and audit a representative _mk theorem through explicit equivalence-on-generators lemmas; use it to identify the map with the class adapter. Treat the canonical-integer IsLocalizedModule client as a separate bridge requiring a canonical integer-linear map and instance transport, or explicitly keep it out of the generic theorem's API; never present the generic result as that canonical specialization without a compiled client. |
| 2026-09-24 | In SF11.4s, 4q's adjacent cochain maps elaborate at the syntactic indices 0 - 1 and 0 + 1, whereas 4r's degree-zero representative theorem uses -1 and 1. Direct rewriting of the 4r _mk theorem in quotient induction did not match the dependent cycle subtype, despite the two quotient presentations being definitionally equal. | Instantiate the generic map at the syntactic adjacent indices, transport the cycle along an explicit (0 : ℤ) + 1 = 1, then apply concreteCohomologyLocalizedMap_mk. Keep this index transport inside the map-comparison lemma; it is an elaboration issue, not missing localization exactness. |
| 2026-09-24 | During SF11.4 aggregate review, the umbrella coverage checker scanned raw lines with a declaration regex. A docstring line beginning class map made HomotopyCategory.lean appear declaration-bearing, so the green gate silently checked 215 rather than 216 umbrellas. | Reword the docstring to restore 216 checked umbrellas in this PR. Harden the checker separately to parse/ignore comments and add a regression for declaration-looking doc text; a green gate alone did not establish this umbrella was checked. |
| 2026-09-24 | SF11.4v's ordinary ModuleCat ℤ client could not apply 4s's generic IsLocalizedModule theorem directly: 4s captured the scoped cohomologyClassModule, while the client inferred AddCommGroup.toIntModule. A first generic bridge attempt also missed the ModuleCat.Algebra linear instance on the localized target ModuleCat (Localization S), so its map type did not match. The concrete quotient route adds a separate additive-instance mismatch. | Relinearize the already-identified class map via toAddMonoidHom.toIntLinearMap; transport the localization proof using uniqueness of integer-module structures, with both source and localized-target ModuleCat.Algebra linear instances explicit. Compile a downstream client without opening the scoped Hom-complex module instance. This does not establish derived-Hom localization. |
| 2026-09-24 | For a fixed terminal R-module T, two applications of fixed-target arrow descent make the composite of the descended maps zero only after localization. It need not be zero over R: a nonzero map ℤ → ℤ/2 vanishes after tensoring with ℤ[1/2]. Thus the zero-composite hypothesis on M₀ → M₁ → A ⊗[R] T cannot be transferred by faithfulness, and no finiteness of T is available. | Use finite presentation of the descended first domain to localize its Hom module into T; IsLocalizedModule.exists_of_eq yields one denominator annihilating the composite. Scale the first descended arrow by that denominator and its source equivalence by the inverse localization unit, preserving both comparison equations and obtaining a literal zero composite. Keep this a module-level three-term witness, not a ShortComplex or derived/geometric/heart extension claim. |
| 2026-09-24 | The degree-zero Hom-complex class-to-homotopy comparison needs the canonical shiftFunctorZero map: Cocycle.equivHomShift.symm z followed by it is mathematically Cocycle.homOf z, but not definitionally so. Componentwise simplification leaves an inverse/forward XIsoOfEq composite containing dependent casts; ordinary rw fails at instances transparency, while erw [Category.assoc, Iso.inv_hom_id, Category.comp_id] closes it. The merged derivedCategoryHomAddEquiv independently repeats this pre-Qh factor; a downstream factorization through the new equivalence compiles by rfl. An architecture review caught that the generic factor originally lived in a localization-specific leaf. | Prove the chain-map identity before applying the homotopy quotient, and own the resulting equivalence in a neutral HomotopyCategory leaf importing only Mathlib. The localization square then reduces on representatives to Functor.mapHomotopyCategory_map and componentwise rfl. A later derived-seam refactor can import the neutral leaf without importing localization. This additive naturality alone does not imply derived-Hom localization. |
| 2026-09-24 | In SF11.4ac, the pinned ModuleCat.localizedModuleFunctor has no inferred generic Functor.Linear R instance, although its map respects the original R-action through algebraMap R (Localization S). Source K-projectivity alone does not provide the localized-source instance needed for the second class-to-derived equivalence. The first compiled public signatures also printed inaccessible private abbreviations F✝ and loc✝, although a full-type downstream client elaborated. | Prove R-linearity as a private abbreviation installed only inside the map proof, and spell out functor/complex types in exported signatures. State both K-projectivity assumptions on the square and localization transfer; discharge both only in the separate bounded-above termwise-projective corollary. No arbitrary K-projectivity preservation or internal derived-Hom claim follows. |
| 2026-09-24 | SF11.4ac's first review found two downstream API errors: an ordinary ModuleCat ℤ annotation inferred AddCommGroup.toIntModule, not the scoped class action or Linear.homModule; and a private instance Functor.Linear still participated in importer typeclass search despite its private name. A #synth at ℤ was an invalid isolation test because Mathlib independently supplies Functor.intLinear; the generic-ring test is the relevant one. | Add a neutral canonical-integer class-to-derived equivalence from the additive equivalence and a separately named canonical-integer localization map/square/theorems. Keep generic-R results unchanged. Replace the private instance with a private non-instance abbreviation and a proof-local letI; compile an ordinary integer client and an import-isolation probe quantified over an arbitrary commutative ring. |
| 2026-09-24 | A bounded-component arrow lift cannot be inferred from boundedPullbackCompInclusion or component membership alone: projecting an ambient lifted domain needs a natural pullback/projector isomorphism compatible with both projection counits. The generic transfer proof also exposes a Lean full-subcategory elaboration seam: rewriting through the nested projector functors needs explicit component IsIso evidence and backward.isDefEq.respectTransparency false; a direct full Families client with two DecompositionData parameters exhausted the default and then 2,000,000 heartbeat budgets, while a client with the exact component RightProjectionData inputs compiled. | Keep the inclusion iso canonical, pass the projector iso and counit mate equation explicitly, and test the conditional Families theorem with chosen component projectors. Prove geometric bounded-coherent ambient arrow descent and actual projector commutation separately; this formal transfer alone does not prove Theorem 5.7(2). |
| 2026-09-24 | Hosted single-instantiation CI found that the generic RightProjectionData.CompatibleFunctor structure had zero counted inhabitants: Families assembled its sole use as a local let, so the public carrier was not an adopted interface. Its three fields were only premises of one transfer theorem, not a reusable object. | Remove the one-off structure and pass the inclusion iso, projector iso, and counit mate equation as explicit hypotheses to RightProjectionData.fixedTargetArrowExtension_of_ambient. Families supplies its canonical inclusion comparison directly and still assumes projector compatibility and ambient arrow extension; the refactor does not strengthen the geometry. |
| 2026-09-24 | The 4ae coherent fixed-target arrow proof needed a coherent-restricted affine tilde/pullback comparison, while the existing pullbackSpecMapTildeIso compares only sheaves of modules. Its coherent restriction compiles by postcomposing with Coh.ι and cancelling the fully faithful inclusion. The module fixed-target theorem also uses RingHom.toAlgebra in ModuleCat.extendScalars, requiring explicit transport of IsLocalization from the ambient Algebra R A and a pure-tensor check that mapExtendScalars agrees with ModuleCat.extendScalars.map. Older scout prose describing #1062 as an open dependency is stale: #1062 is now CLOSED. | Keep the comparison private until a second consumer needs a public square; test the exported underived coherent-arrow theorem from a direct leaf import. Do not infer derived pullback, component/heart extension, or Theorem 5.7(2) from this underived bridge, and verify issue status before repeating dependency notes. |
| 2026-09-24 | The coherent three-term consumer needed both arrow equations from 4aa, not two independent fixed-target arrow lifts: only the module theorem's uniform denominator step makes the descended composite literally zero. In the geometric transfer, FGModuleCat.affineTilde had no inferred PreservesZeroMorphisms instance, though zero preservation follows after the fully faithful coherent inclusion from Mathlib's tilde.map_zero. The affine comparison and RingHom.toAlgebra transport remain private to the existing localization leaf, so reusing them there avoids a second public square or an extra packaging layer. | Audit the full zero-composite diagram and both comparison equations through a direct owner-leaf client. The result is an ordinary coherent-sheaf statement for affine noetherian localization with arbitrary fixed coherent terminal E; it supplies no derived, component, heart, or Theorem 5.7(2) conclusion. |
| 2026-09-24 | The old umbrella gate's raw declaration/import regexes yielded a false-green count of 216 on this checkout; five genuine umbrellas were skipped because docstrings looked like declarations. Three rounds of hand-written masking still missed valid Lean character literals and nested raw-string interpolation. | This recovery uses pinned Lean 4.32.1 --deps-json --stdin for batched header imports and treats all 232 same-named sibling candidates as umbrellas except 11 explicitly reviewed, SHA-256-pinned declaration owners: 221 checked. The historical 215→216 entry above records an earlier local doc fix, not the current count. Fixture compilation and strict JSON/error/count checks guard the parser seam. Owner-file changes require re-review of the witness and digest; no source regex chooses exceptions. |
| 2026-09-24 | Pinned Lean's header parser answers direct imports only; it does not classify declarations, prove elaboration, or establish public-root reachability. The separate check_root_reachability.py still scans raw import-looking lines, and check_explicit_numerical_data.py still masks Lean source incompletely (notably nested raw-string interpolation). | Keep those gates separate from this umbrella slice and do not describe them as parser-complete. A future focused recovery should replace raw-import reachability with the same checked Lean header data and independently settle numerical-token coverage; a passing umbrella gate alone is not either verdict. |
| 2026-09-24 | Adversarial review found the new Lean-header gate still treated every parsed module name as a re-export. Under a module header, pinned Lean marks a plain import Child with isExported: false; only public import Child has isExported: true. The earlier loop discarded that flag, allowing a private-import false green. | Require a boolean isExported on every import record and count only true records. Compile both module-header forms against a module-format child and assert the private/public coverage outcomes; missing or non-boolean flags fail closed. This does not change the 221 current umbrellas or the exact owner/child exceptions. |
| 2026-09-24 | The exact DerivedCategory/Stability omission was still only permission to skip a missing child. The gate did not forbid the neutral DerivedCategory umbrella from importing Stability or require the outer AlgebraicGeometry umbrella to export it; the layering gate exempts this neutral umbrella, so either header mutation could pass. | Retain both all-import and exported-import sets from the same Lean header batch. Require the neutral umbrella to have no Stability import at all, the outer umbrella to publicly export it, and the explicit exception map to contain exactly this one child. Regressions cover the valid route, neutral exported/private imports, outer missing/private imports, and a broadened exception map. |
| 2026-09-24 | The prior exact-name umbrella check still accepted DerivedCategory importing DerivedCategory.Stability.Leaf (and the real Stability.SLocal) without importing exact Stability; the subject-layering gate exempts this neutral umbrella. Pinned Lean's --deps-json gives direct headers only, but a batch of every tracked library header is fast enough to construct the full graph. The umbrella check's old comment saying the layering gate checks this direction is historical; that file is deliberately untouched in this slice. | Keep the umbrella check's direct child exception unchanged. A separate architecture gate parses every tracked header, validates per-file errors and import flags, rejects unknown internal targets and cycles, and follows all private/meta internal edges from the neutral umbrella. Reject paths into either the component-prefix geometric Stability or triangulated StabilityCondition tree; require a direct exported outer edge. The gate checks this named boundary, not all geometry layering, root reachability, or numerical source masking. |
| 2026-09-24 | First review of the new graph gate showed that pinned Lean marks public meta import Stability as isExported: true, and a compiled downstream meta client can use a public declaration through it; meta import Stability is not exported. An interim revision accepted any exported edge. | This established the meaning of isExported for meta code, but not the ordinary export/build route; the next review and row supersede that interim gate criterion. |
| 2026-09-24 | The stronger umbrella contract in AGENTS.md requires a stable ordinary export/build route for an omitted child. A compiled downstream ordinary def cannot use a declaration reached only via public meta import Stability, although a downstream meta def can; the interim exported-only graph gate was therefore false green. | Require one direct outer import record with isExported: true and isMeta: false, keeping every private/meta edge in the neutral transitive closure. Compile ordinary and meta clients for public ordinary, public meta, and private meta routes; do not infer ordinary visibility from exported meta visibility. |
| 2026-09-24 | Hosted CI for the reviewed header gates failed in the roadmap job because that job runs the full Python test suite before installing Lean. The new parser fixtures compile tiny Lean clients; local precheck had lean on PATH, masking the job-order assumption. The failure was FileNotFoundError: lean, not a parser counterexample. | Install the repository-pinned Lean toolchain in the roadmap job before the full Python suite, with build/test/cache disabled. Keep the fixture compilation in that suite and use the fresh hosted result as the verdict; local precheck alone cannot validate CI job environments. |
| 2026-09-24 | A proposed finite-window complex signature type-checked but supplied no proof or dependable construction API. In the pinned ModuleCat.extendScalars, the tensor's left factor is a restriction-of-scalars ModuleCat carrier, so an ordinary rewrite on naive A ⊗[R] L failed at instances transparency; the canonical IsBaseChange.equiv_tmul and an explicit pure-tensor check resolved the comparison. The new worktree also initially lacked FiniteDescent.olean despite byte-identical source and matching pins in another checkout; a targeted Lake build supplied it. | Check actual pinned constructor and object definitions before treating a scout's signature or remembered API as a proof. Use B_i ⊔ d(B_{i-1}), CochainComplex.of, and HomologicalComplex.Hom.isoOfComponents; verify the literal zero square by subtype injectivity and the comparison on pure tensors. Diagnose a missing .olean as cache state, not mathematical failure. |
| 2026-09-24 | SF11.4al's coherent-complex target type-checked before the comparison proof existed. In the pinned imports, the affine tilde, finite scalar-extension and affine-equivalence functors did not synthesize the Additive instances required by mapHomologicalComplexCompIso; even the concrete tilde.functor instance visible in source was not found by typeclass search at this application. The fresh stacked worktree also lacked 4ak's .olean. | Target-build the exact 4ak dependency, derive additivity proof-locally through the affine tilde adjunction and faithful full-subcategory inclusions, then use NatIso.mapHomologicalComplex and HomologicalComplex.liftObjectProperty. Audit and compile an ordinary coherent-complex client. An ordinary complex isomorphism under Coh.pullback is not a derived pullback, descended arrow, component, heart, or Theorem 5.7(2) result. |
| 2026-09-24 | The combined 4ak+4al integration reviewer compiled the coherent owner, umbrella, and direct client, but could not run the broader categorical-cohomology audit in its isolated worktree because an unrelated SpectralSequence.olean was absent. The reviewer's focused axiom prints used only standard axioms; this missing cache artifact is not a proof failure or a full-audit verdict. | Distinguish focused review evidence from the complete hosted audit. Build the missing dependency only when a local full audit is needed, and wait for exact-head CI before merging the combined PR. |
| 2026-09-24 | The first SF11.4am sketch proposed iterating finite-presentation kernels to assemble a projective resolution, but pinned Mathlib already has ProjectiveResolution.of in the abelian category FGModuleCat R. The finite-free epi/projectivity lemmas provide proof-local enough projectives. The inclusion into ModuleCat preserves homology, but its projective-object preservation requires a finite-free epi splitting/retract proof; using (ModuleCat.isFG R).ι in that proof blocked typeclass synthesis of PreservesHomology, while the definitionally related forget₂ spelling synthesized it. A fresh worktree also lacked cached oleans, which was resolved by a pin-matched Lake cache build. | Use the finite-category resolution and forget₂.mapProjectiveResolution, then prove finiteness degreewise, including the integer cochain extension. Do not describe the resulting resolution as finite length or as an arbitrary bounded-complex resolution; the negative tail may be infinite, and constructing compatible resolutions for a complex is separate work. |
| 2026-09-24 | In SF11.4an, Module.FinitePresentation R X is deliberately not inferred merely from [IsNoetherianRing R] [Module.Finite R X]; the pinned Module.finitePresentation_of_finite lemma must be installed on the exact Icc (c - 1) 0 window required by the bounded-projective Hom theorem. The new worktree had no .lake cache, and Lean resolved imports against the first LEAN_PATH library root rather than falling through to a later root when an olean was absent. | Use the 4am resolution's cochain finiteness and a proof-local finite-presentation instance, not a new global instance. For local validation, link the pin-matched 4am oleans into this worktree's untracked build root and put that root first. The result localizes the degree-zero Hom map of the chosen resolution against a bounded-below target; transporting it to the original module's degree-zero complex still needs a separate quasi-isomorphism-conjugation theorem. |
| 2026-09-24 | SF11.4ap's first source-change square did not rewrite after simp only [Category.assoc]: the target associated away the subexpression matching inverse naturality of Mathlib's mapDerivedCategoryFactorsh. Also, Linear.homCongr R e.symm (Iso.refl _) does not reduce its source precomposition to e.hom ≫ f by change alone; the Iso.symm_inv and identity-comp simplifications are needed. | Use the inverse naturality square directly, associate left before rewriting, and simplify the two homCongr applications explicitly. QuasiIso P.π' and preservation of quasi-isomorphisms by degreewise module localization then provide the two source isomorphisms. This yields localization from M[0] into a bounded-below complex, with the target still displayed as degreewise localization of M[0]; a single-complex comparison and internal derived-Hom base change are separate claims. |
| 2026-09-24 | For SF11.4ao, pinned Mathlib's exists_quasiIso_injective was available only for strictly bounded-below cochain complexes. CochainComplex.opEquivalence negates degrees, but no ready QuasiIso transport for its index-restriction half was found. A direct QuasiIsoAt cast failed because the default neighboring indices were not definitionally equal after negation; choosing n+1,n,n-1 and their negatives in quasiIsoAt_iff' made the short-complex maps definitionally equal. In the FG-to-ModuleCat transfer, inference of the mapped quasi-isomorphism also needed an explicit proof-local F.Additive and HomologicalComplex.quasiIso_map_of_preservesHomology, despite homology preservation already being inferred. | For a future complex-shape equivalence, inspect both degree and adjacent-index maps; prove a focused quasi-isomorphism transport instead of assuming an equivalence of complex categories transports QuasiIso automatically. Keep finite-term projectivity, K-projectivity, and strict upper bounds distinct from a finite lower bound, functorial replacement, or any derived/geometric arrow comparison. |
| 2026-09-24 | SF11.4aq's bounded-projective derived-Hom localization corollary needs Module.FinitePresentation R (P.X i) only for i in the exact Finset.Icc (c - 1) b window. The replacement supplies termwise finiteness as a quantified witness, not a typeclass instance, so Lean does not infer this presentation condition without proof-local finite and interval-indexed finite-presentation instances. The standard source and localized derived-category instances also remain local to the new leaf. | Build the presentation instances from Noetherianity and termwise finiteness inside the witness proof, then retain P and p : P ⟶ K in the exported result. QuasiIso p and K-projectivity alone are not a proved conjugation of localization from P to K; the theorem states localization only for the map out of P, with no internal derived-Hom or geometric consequence. |
| 2026-09-24 | The SF11.4ar handoff described a final bounded-complex IsLocalizedModule transfer as compiled, but the scout later corrected that it could not retain or verify any final proof. Only the generic source-naturality square was retained as a compiled stdin probe; the bounded-complex transport remained unverified at handoff. This was a proof-evidence overclaim, not a mathematical counterexample. | Reuse the independently compiled generic naturality lemma from 4ap and separate its neutral leaf from both specializations. The 4ar source, direct client, and axiom audit were subsequently compiled in this worktree; that evidence, not the scout's unretained final proof, supports the new transfer. |
| 2026-09-24 | In SF11.4as, a first draft placed mapDerivedCategory in the underived coherent-affine localization leaf, crossing the subject layering boundary. Pinned Lean also has the category as root DerivedCategory, not CategoryTheory.DerivedCategory; and mapDerivedCategory in a public result type demands exactness/additivity before the proof body, so proof-local instances cannot repair that signature. The fresh worktree lacked a complete olean cache; a single combined pin-matched cache root was needed. | Keep only the ordinary affine functor and natural isomorphism in the underived owner, and package exact derived functors plus their natural comparison in DerivedCategory/Families/AffineCoherentLocalizationComparison. Supply localization-derived Noetherianity and flatness explicitly, reflect finite-limit/colimit preservation through FGModuleCat → ModuleCat, and test naturality on an arbitrary derived arrow. |
| 2026-09-24 | The SF11.4as comparison is a natural isomorphism for Spec A → Spec R and derived coherent/finite-module functors on noetherian affines. The paper's Lemma 4.16 instead works over X ×_S T with possibly non-affine X, while Theorem 5.7(2) further needs relative fixed-target arrow extension, component-projector isomorphisms with counit mate compatibility, and t-exact bounded restriction. | Use the affine comparison only as an exact affine input. Do not infer relative geometric Hom localization, bounded-component compatibility, heart Noetherianity, or Theorem 5.7(2) from this square. |
| 2026-09-24 | In SF11.4at, pinned ModuleCat.extendScalars (algebraMap R (Localization S)) tensors a restriction-of-scalars carrier, while localizedModuleFunctor uses Shrink; their objects and scalar-action instances are not definitionally identical. IsLocalizedModule.isBaseChange supplies the component equivalence only after proof-local transport to the RingHom.toAlgebra action, and the naturality proof needs the explicit mapExtendScalars generator equation. A separate worktree had byte-identical Mathlib pins but its available library .olean for the umbrella predated several current children, making an initial owner-audit run report unknown constants. | Use the canonical base-change equivalence and verify the tensor-generator formula before assembling NatIso.ofComponents; inspect the pinned ModuleCat.isIso_of_isLocalizedModule_comp as an alternative, not a definitional shortcut. Rebuild only the current localization import chain in a temporary pin-matched cache before treating owner-audit results as proof evidence. This comparison is not arrow descent or derived-Hom localization. |
| 2026-09-24 | SF11.4at's first implementation put a public ModuleCat functor comparison in Algebra/Module/Localization/ because its construction uses localization. Architecture review applied AGENTS.md Tier 1: both extended Mathlib functors are defined under Algebra/Category/ModuleCat/, so the proof's subject and first consumer cannot determine its owner. The original audit sat in the Algebra lane, but EnumDecls routes the ModuleCat subtree to the StabilityCondition audit lane. | Move the unchanged comparison declarations to Algebra/Category/ModuleCat/Localization.lean, export from the ModuleCat umbrella only, and move the direct clients and axiom records to StabilityConditionAudit/ModuleCatLocalization.lean. Check definition sites and audit routing before choosing a new leaf. |
| 2026-09-24 | SF11.4au found no pinned direct bounded-derived full-faithfulness theorem for FGModuleCat R → ModuleCat R. The inclusion's finite-limit preservation is registered for forget₂, not inferred from (ModuleCat.isFG R).ι; mapDerivedCategory also needs exactness and additivity before elaborating its result type. A fresh worktree had incomplete repository oleans although the pin-matched source and package caches were available. | Package the canonical derived inclusion as a named functor with proof-local exactness, then use finite-free epimorphic generators and projectivity on both sides in bijective_mapExtAddHom_of_generators; apply bounded dévissage only to bounded source objects. Avoid global instance leakage, an unbounded full-faithfulness claim, or any geometric localization inference. |
| 2026-09-24 | SF11.4av's categorical denominator proof needs two separate facts: IsLocalizedModule.surj gives s • γ = F.map f for a fixed-target Hom map, while absorption on the source requires IsIso ((s : R) • 𝟙 (F.obj Y)). The localized-module witness displays F.mapLinearMap rather than F.map, so a direct rewrite of its equation did not elaborate until F.coe_mapLinearMap R was used explicitly. A bare localization-of-Homs hypothesis supplies neither object lifts nor these scalar isomorphisms. | State all three hypotheses explicitly in the neutral theorem and form the new source iso by composing the chosen lift with the inverse scalar iso. This is an arrow-factorization mechanism, not a geometric instance, heart result, or proof of Theorem 5.7(2). A fresh worktree's missing .olean is cache state; validate imported source hashes before using a pin-matched checkout cache. |
| 2026-09-24 | In SF11.4aw, the pinned Submodule.localized'gi and IsLocalizedModule.surj suffice to lift finitely many localized-module generators to a finitely generated base-ring submodule with exactly the requested localization. This holds for an arbitrary multiplicative set, but the pin has no sheaf-level Stacks 28.23.2 finite-type quasi-coherent submodule extension or 28.23.4 finite-presentation fixed-target arrow extension across a quasi-compact open. QuasicoherentData.bind only glues presentation data for a sheaf already constructed. | Own the algebraic lemma beside Mathlib's Submodule.localized' definition. Build quasi-compact-open pushforward/coherence and finite-type subsheaf extension with affine-chart overlap gluing in separate geometric leaves. An arbitrary localization of rings need not induce an open immersion; this lemma does not prove coherent-sheaf, derived-arrow, heart, or Theorem 5.7(2) descent. |
| 2026-09-24 | SF11.4ax lifted the canonical ModuleCat scalar-extension/localization natural isomorphism to derived categories using localization flatness for exactness and NatIso.mapDerivedCategory. Pinned mapDerivedCategory needs additivity and exactness before a public result type can elaborate, so the instances were kept proof-local behind named functors. A bounded optional comparison on displayed complexes reached the expected inverse-factorization cancellation, but Lean's hidden Functor.comp_obj/instance transports prevented a clean rw or simp proof in this slice; no Qh comparison or FG-to-all-module mate was retained. | Use the compiled arbitrary-derived-arrow natural isomorphism as the neutral prerequisite. In a separate slice, prove its Qh mate against mapDerivedCategoryFactorsh and CochainComplex.HomComplex.derivedLocalizationComparison, then connect the finite-module and all-module derived functors. Do not infer geometric Hom localization, arrow descent, or Theorem 5.7(2) from the neutral iso. |
| 2026-09-24 | SF11.4ay resolved 4ax's optional Q/Qh mate on displayed complexes. NatIso.mapDerivedCategory is constructed through Q, while mapDerivedCategoryFactorsh_hom_app passes through quotientCompQhIso and mapHomotopyCategoryFactors. Those latter components reduce to identities at a complex, but a broad simp failed under hidden Functor.comp_obj transports; an explicit change to the typed factorization, an applied component iso for the inverse cancellation, and a separate Qh.map_id step made the proof elaborate. | Reuse the private Q square and component-reduction lemma to state the public Qh square. Its direct client unfolds derivedLocalizationComparison definitionally. This remains an objectwise displayed-complex mate, not FG-to-all-module derived functor compatibility, derived-Hom localization, geometric pullback, or Theorem 5.7(2). |
| 2026-09-24 | SF11.4az starts from integration 468d3031 with pinned Mathlib 520045ab: Mathlib has Scheme.Modules.pullbackComp, pullbackId, and basicOpenIsoSpecAway, but the repository's Coh.pullback had only pullbackCompι, not coherent composition/identity or transport across a scheme isomorphism. The prior 4aw friction entry concerns global qc-open gluing and remains open; it should not be read as saying the affine D(r) functor comparison is unavailable. In a direct client, an over-expanded arrow-level naturality expression hit Lean's default heartbeat, whereas the component of the public NatIso compiled without extra options. Fresh-worktree .olean state was seeded from the pin-matched 4aw checkout and the changed owners were rebuilt. | Lift the pinned module-sheaf composition/identity isomorphisms through the fully faithful Coh.ι, then specialize with basicOpenIsoSpecAway_hom_SpecMap. Keep this chart-level ordinary-pullback comparison separate from finite-type subsheaf gluing, arbitrary localizations, derived arrows, and Theorem 5.7(2); do not add global instances merely for the equivalence. |
| 2026-09-24 | While arranging independent reviews of SF11.4ay in parallel with SF11.4az, an additional agent spawn returned collab spawn failed: agent thread limit reached. The user had not imposed an agent-count cap; this was a service concurrency limit, not missing OpenSpec authority or a mathematical blocker. | Reuse the existing independent adversarial reviewers after their current review completes; keep the three-cycle critique limit per code chunk, not a cap on the total number of agents. Do not waive review or pause the issue-first workflow because a fresh agent could not be spawned. |
| 2026-09-24 | SF11.4bc's canonical projection comparison is the inverse of Mathlib's mateEquiv image of the inclusion iso. Its invertibility is not automatic: the counit triangle only gives it after triangulated pullback carries the source right orthogonal into the target right orthogonal. The first Families proof attempt put Lean's include pU pT in between a docstring and its lemma, which the parser rejected; runLinter also rejected an underscore in the public def name. | Prove the mapped counit is invertible from the mutation triangle and target projection, then use mateEquiv_counit for the compatibility equation. Put include before the docstring and use camelCase for the def. Keep orthogonal preservation and ambient arrow extension as explicit geometric inputs, not as inferred consequences of bounded pullback. |
| 2026-09-24 | SF11.4bg reduces 4bc's bounded right-orthogonal premise to vanishing of maps from target perfect-envelope objects into pulled-back bounded right-orthogonal objects. The target quasicoherent component is a coprodClosure; coprodClosure_le needs the separately owned ObjectProperty.leftOrthogonal colimit-closure instance, so importing only the Families pullback leaf did not synthesize it. The reduction does not construct the perfect-envelope vanishing. | Import the neutral orthogonal-closure leaf explicitly, extend vanishing through coproducts and extensions, and reflect zero maps through the fully faithful bounded-coherent inclusion. Prove the geometric vanishing separately using relative Hom base change or compatible full decomposition data; neither component-image preservation nor the formal reduction proves it, arrow extension, or Theorem 5.7(2). |
| 2026-09-24 | SF11.4bi's formal shifted-generator probe initially treated the left orthogonal to a singleton pulled-back target as automatically triangulated. The pinned instance requires the target property to be shift-stable; a singleton is not. Also, the named equality between the shifted-generators' triangulated envelope and the perfect envelope requires [P.ContainsZero], which 4bg did not assume. | Close the target singleton under all integer shifts before applying ObjectProperty.triangEnvelope_le_iff, and use the one-way inclusion from perfectGenerators ≤ shiftedPerfectGenerators to retain 4bg's arbitrary P. The compiled result still requires geometric vanishing for every integer shift of each external product; unshifted vanishing and component-image preservation do not suffice. |
| 2026-09-24 | SF11.4ba transports the affine-localization fixed-target arrow witness through 4az's Coh.pullbackBasicOpenIsoSpecAway and the coherent-pullback equivalence of the basic-open/spectrum isomorphism. Directly expanding the geometric functors in the arrow equation exceeded Lean's default heartbeat; a private categorical transport helper with a named intermediate arrow p compiled without raising limits. The result remains only for the actual affine basic-open immersion D(r) ↪ Spec R; the pinned APIs do not supply the sheaf-level finite-type submodule extension or gluing needed for a general quasi-compact open. | Keep the categorical equivalence proof private to the downstream geometric leaf, with only a proof-local IsEquivalence instance. Audit an arbitrary arrow against the public theorem and retain the fixed target. This does not produce a monic lift, a global quasi-compact-open theorem, a derived/heart arrow, or Theorem 5.7(2). |
| 2026-09-24 | For relative SF11.4bb, pinned Linear on intrinsic bounded-coherent Dqc is over Γ(Y, 𝒪_Y), not automatically over the chosen affine base ring R; multiple R-actions could exist. Composing R → A ≅ Γ(Spec A) → Γ(Y) gives a proof-local action, and localization units yield denominator isomorphisms even when Y is non-affine. The pinned derived-pullback API does not thereby supply Functor.Linear R or localized Hom maps. The concrete projective-line client needed ULift.{u} (Fin 2) so its coordinate type and base field inhabit the same scheme universe. An initial import-graph precheck saw the new umbrella edge before the new leaf was staged and therefore reported an unknown internal import. | Export the canonical action as an explicit value and require callers to install it locally. Keep the denominator-unit result separate from the still-needed functor-linearity, Hom-localization, object-descent, and fixed-target arrow-extension proofs. Stage new Lean leaves before graph-gate checks, and match universe levels in projective-space clients. |
| 2026-09-24 | SF11.4bd required matching the source action on X ×_S S, not directly on X; the Over-category identity product is not definitionally the latter. Mathlib's derived-functor Linear instance did not synthesize for the repository's derivedPullback abbreviation until the goal was changed to modulePullback.mapDerivedCategory. Linearity through Dqc and bounded-coherent full subcategories needed explicit ObjectProperty.hom_ext; the resulting inherited bounded actions are definitionally equal to the explicit 4bb affine-base actions. The direct client's generic Functor.map_smul elaborated only via the receiver syntax (pull.boundedFunctor h).map_smul r g. The first no-build precheck failed solely because the new leaf was untracked and the import-graph gate treated its umbrella edge as unknown. | Match scalar-action objects to the exact base-change carrier, prove the module-sheaf scalar identity from the cartesian square and adjunction, expose the Mathlib derived-lift shape with change, and use full-subcategory hom extensionality. Keep all intermediate linear instances local and check the final statement with an ordinary imported pointwise client. Stage new leaves before the graph gate. This proves functor linearity, not localized Hom sets or object/arrow descent. |
| 2026-09-24 | SF11.4bh research recovery: the perfect-source fixed-target IsLocalizedModule M ((pull.boundedFunctor h).mapLinearMap R ...) proposition elaborates for Perf(Y) → Dqcᵇ_coh(Y) under the explicit affine-base actions, but Functor.mapLinearMap also requires Functor.Additive, which 4bd's separate Functor.Linear R does not supply. Additivity follows from localization flatness, exact derived pullback, and the existing DqcLeftDerivedPullback exact comparison; the resulting additive theorem and ordinary mapLinearMap client compile. Even for the source 𝒪_Y[0], the current geometric APIs do not expose the natural flat-base-change comparison between derived global sections of a bounded-coherent target on Y and its pullback to Y_A. Cohomology/Derived/UnitExt compares unit Ext with sheaf cohomology but does not furnish that relative localization comparison; Families/DqcFlatBaseChangeTheorem is supplied structure, not a proved instance. Finite affine cover and Čech APIs do not yet assemble the derived-Hom comparison. | Keep additivity as an independently proved prerequisite for the actual linear Hom map. The next mathematical bridge is flat localization of derived global sections with its natural pullback map, first for the degree-zero unit source and a bounded target; it must prove denominator clearing and torsion-kernel control, then generalize by finite locally free resolutions/finite effective Hom windows. Do not infer perfect-source Hom localization, all bounded-coherent Hom localization, object descent, or Lemma 4.16 from additivity and denominator units. |
| 2026-09-24 | SF11.4be needs an actual coherent monomorphism upstairs, whereas FixedTargetMonoExtension only limits its input to monomorphisms and permits a nonmonic witness. Pinned Scheme.Modules.restrictFunctor_preservesFiniteLimits and restrictFunctorIsoPullback make the module-sheaf pullback along the basic-open immersion left exact; Coh.pullback_preservesFiniteLimits and its right-exact counterpart then let the categorical image theorem turn 4ba's arrow witness into a coherent mono. The Submodule.exists_fg_localized_submodule result from 4aw is not consumed by this shortest proof: it supplies a separate concrete module witness, whose identification with the categorical sheaf subobject still needs a comparison. | Keep exactness as a proof-local instance in the downstream basic-open subobject leaf and export only the literal Mono m witness. Do not add a global instance or infer finite-type subsheaf gluing on a general quasi-compact open, a derived/heart statement, or Theorem 5.7(2). |
| 2026-09-24 | SF11.4bf compares two localized submodules at the common localization away from r * s by first taking their inverse images in finite M. The pinned Submodule.localized'gi, IsLocalizedModule.mk'_eq_iff/exists_of_eq, and Submodule.smul_mem_iff_of_isUnit give exact recovery for their intersection: an overlap denominator (r*s)^n is reduced to the required cross-chart r^n or s^n because the other factor is a unit in that chart. Submodule.FG.of_le makes the intersection finite only because M is finite over Noetherian R. | Own this direct extension of Submodule.localized' in the algebraic localized-module subtree, with the geometric basic-open/coherent comparison downstream. Do not treat equality of localized inverse images as a proved sheaf-subobject gluing API or infer finite-union/global qc-open descent, derived arrows, or Theorem 5.7(2). The 4aw finite-generation descent theorem is not consumed in this finite-target route. |
| 2026-09-24 | SF11.4bj uses pinned tilde.toOpen_map_app and LinearMap.localized'_range_eq_range_localizedMap to identify the range of a tilde map on one basic open with localization of its module-map range. The modulesSpecToSheaf section carrier is exposed as an R-module; a Localization.Away r action and scalar tower must be installed locally using IsLocalizedModule.module/isScalarTower_module. That action is not definitionally the structure-sheaf section action, and ModuleCat.extendScalarsLocalizationNatIso is not definitional either. | Place this direct extension of Mathlib's tilde beside its definition site, importing only pinned Mathlib. A later geometric leaf must transport the action and the resulting range through the coherent affine equivalence and basic-open pullback isomorphisms before asserting an equality of coherent subobjects. This cut proves no coherent subobject comparison, union gluing, derived/heart arrow, or Theorem 5.7(2). |
| 2026-09-24 | SF11.4bk: TargetBoundedTStructure supplies a target Dqc t-structure and an ambient-boundedness comparison but is not the paper's base-changed construction. Local Noetherianity makes finite-presentation cohomology triangulated; it does not make arbitrary truncations preserve it. A pin-matched Lean probe showed that an explicit finite-presentation hypothesis for truncLE on bounded-coherent objects suffices: the truncation triangle supplies the truncGE half, and bounded_iff supplies boundedness. rfl did not expose the named induced structure's halves until the proof-local HasInducedTStructure instance was restored and Mathlib's comparison lemmas were applied. | Export only the conditional induced t-structure and its boundedness and half-membership formulas in the Families owner; keep the supplied t-structure, target local-Noetherian hypothesis, and truncLE coherence premise visible. Construct the geometric base-changed t-structure, its bounded-locus comparison, and truncation coherence in later chunks before claiming any paper identification or bounded-heart theorem. |
| 2026-09-24 | SF11.4bl assembles Coh.affineTildePullbackIso, the localized affine-equivalence counit, and ModuleCat.extendScalarsLocalizationNatIso into an explicit global-sections comparison on Spec (Localization.Away r). The module action on the localized-module carrier is not definitionally the action on coherent global sections; in the M = Γ(E) specialization, unfolding the global-sections carrier also makes implicit module-instance inference fragile. A categorical iso is surjective on underlying modules, but LinearEquiv.range_comp does not rewrite across the two definitionally equal localization types with different captured instances. | Keep M : FGModuleCat R and cR : E ≅ ~M explicit in the core API, with the affine-equivalence unit providing the canonical global-sections specialization. Use naturality of the composite comparison and elementwise surjectivity to identify ranges, then LinearMap.localized'_range_eq_range_localizedMap. This proves only the localized-spectrum coherent subobject comparison; the actual D(r) corollary, union gluing, Hom localization, and Theorem 5.7(2) remain separate. |
| 2026-09-24 | SF11.4bn: the paper's base-changed t-structure belongs to the quasicoherent base-change component, while 4bk's TargetBoundedTStructure is supplied on all target Dqc and its hfpLE ranges over every ambient bounded-coherent object. The existing generic Functor.mapTruncLEIso compares truncations only after a t-exact functor and both t-structures are supplied. | The neutral Functor.truncLE_mem_of_component_lift transfers finiteness only on an explicit target component, using an object lift up to isomorphism, source truncation finiteness, and preservation of finiteness. A later geometric chunk must construct the component t-structure and prove t-exactness, bounded-coherent object descent, and finite-presentation preservation before specializing this lemma. It does not establish 4bk's ambient hfpLE, the paper's t-structure, or Theorem 5.7(2). |
| 2026-09-24 | SF11.4bm transports 4bl's coherent tilde subobject to the actual D(r) using pullbackBasicOpenIsoSpecAway and the inverse coherent-pullback equivalence. Although the two paths have isomorphic sources, Lean does not identify their sheaf objects, global-section actions, or Subobject representatives definitionally. Rewriting the individual α-square maps also encountered a Spec R versus PrimeSpectrum R open-coercion elaboration mismatch. | Assemble χ by whiskering α with the inverse equivalence and its unit, transport the target through κD, and use naturality of the fully whiskered χ at the tilde inclusion. That square yields an isomorphism between the two source arrows and hence equality of Subobjects before applying 4bl's localized-spectrum theorem. This remains a one-chart underived comparison; finite-union subobject gluing, relative geometry, derived/heart arrows, and Theorem 5.7(2) are not claimed. |
| 2026-09-24 | SF11.4bq: Coh.restrict_jointlyReflectsIsomorphisms detects when a given global arrow is invertible; local inclusions of two subobjects do not supply a global arrow between them. Subobject.mapFunctor needs mono preservation, and a global order-reflection proof additionally needs the restrictions to preserve the pullback of the two representing monos. Pinned Coh.restrict has no named finite-limit instance, although its definition through Coh.ι and Scheme.Modules.restrictFunctor_preservesFiniteLimits yields one proof-locally. The existing isomorphism-reflection theorem tied the cover-index universe to the scheme universe, so a Bool-indexed open-cover client required generalizing that theorem's universe parameter without changing its proof. | Export generic order/equality reflection beside Subobject.mapFunctor, then specialize to any open cover in the coherent owner using a proof-local finite-limit witness. The Bool two-basic-open cover is Scheme.Opens.iSupOpenCover; no finiteness of the cover is needed for reflection. This compares only subobjects already defined over the union; it neither constructs nor glues a coherent subobject from two local ones, and it proves no derived/heart arrow extension or Theorem 5.7(2). |
| 2026-09-24 | SF11.4bo identifies localization at r * s of the inverse image of P ≤ M[1/r] with the R[1/(r*s)]-span of its image under the canonical module-localization map. The pinned localized'gi recovers P from its inverse image, and localized'_eq_span handles the forward inclusion. To construct the module map by the universal property, invertibility of powers of r in M[1/(r*s)] must be expressed through Algebra.lsmul into Module.End; it is not a definitional consequence of the ring-level away map. | Keep the result algebraic and valid for zero divisors, with no Noetherian or finite-module assumptions. Its target is a span, not a raw image; it does not identify coherent-subobject restriction on D(rs), establish the opposite chart comparison or union gluing, or prove a derived/heart statement. |
| 2026-09-24 | SF11.4bp needs the converse for an arbitrary mono on actual D(r). The 4be categorical lift supplies a mono upstairs, but its global-sections map is not itself the chosen inclusion of its range. LinearEquiv.ofInjective identifies its source with the finite range submodule, while affine-equivalence unit naturality and unit_inverse_comp identify the resulting tilde arrow. The canonical Γ(E) carrier cannot safely elaborate a freshly written FGModuleCat.ofHom N.subtype after unfolding its sheaf action; the proof uses an explicit M : FGModuleCat R and cR : E ≅ ~M, then specializes to the unit. 4bm's target transport κD was private, so it is now exported as basicOpenGlobalSectionsIso without changing the 4bm comparison theorem. | Keep the range argument and equivalence transport in the downstream affine coherent leaf; publish both the explicit-presentation and canonical-global-sections one-chart classifiers. The source iso witnesses prescribed-mono subobject equality; 4bm computes its chart module as N.localized' through κD. No non-zero-divisor hypothesis, two-chart/union gluing, relative-X, derived/heart arrow, or Theorem 5.7(2) follows. |
| 2026-09-24 | SF11.4bs: transporting the 4bo right-chart map from target M[1/(s*r)] to M[1/(r*s)] by rw [mul_comm] works at the map type but produces a dependent equality transport in its application and span theorem. A direct universal-property lift instead inverts powers of s in the literal r*s target via dvd_mul_left s r and Algebra.lsmul; localized'gi then recovers the source submodule without injectivity. For a chosen N ≤ M, its inverse image after localization at s is a saturation, not definitionally N, so the chosen-N span identity needs its own denominator argument. | Keep both opposite-chart identities in a neutral LocalizedModule leaf importing 4bo, with the two chart maps sharing the literal target. They concern spans of canonical images, including r*s = 0, not raw-image equalities. They supply no coherent restriction comparison, two-chart gluing, derived/heart arrow, or Theorem 5.7(2). |
| 2026-09-24 | SF11.4br: Coh.pullbackComp gives an isomorphism of pullback functors, whereas restricting a Subobject requires its component and mono preservation for both pullbacks. The apparently equivalent componentwise eqToIso and functor-level eqToIso were not definitionally interchangeable in Lean; constructing the restriction from the functor-level iso made naturality available. The chart global-sections subobject lives on a Shrink carrier, not the raw LocalizedModule.Away carrier used by the nested localization map. | Use proof-local finite-limit witnesses for coherent pullback, then map the chosen tilde subobject through pullbackComp. Convert the chart submodule by the explicit Shrink.linearEquiv and localized'_eq_span/Submodule.map_span; a separate algebraic span identity handles M[1/r] → M[1/(r*s)] even with zero divisors. The theorem concerns a chosen finite N on one nested pair of basic opens; it does not prove arbitrary-subobject restriction, union gluing, a derived/heart arrow, or Theorem 5.7(2), and is not the heart-level critical path. |
| 2026-09-25 | Adversarial SF11.4 strategy review compared the actual 4bf/4bo/4bp/4bq and 4bk/4bn theorem types with arXiv:1902.08184v4, Lemma 4.16(3) and Theorem 5.7 Step 4. Ordinary coherent-subobject gluing across two basic opens is a side path: the paper instead lifts an arbitrary increasing filtration of subobjects of one fixed object in the base-changed heart after t-exact localization. The current SLocal.lemma_4_16_3 accepts supplied Lemma416Part3Data and is not that geometric lift. Pinned Mathlib already has PreservesFiniteLimits (ModuleCat.localizedModuleFunctor S) and the two-open sheaf pullback cone; neither identifies the natural relative global-sections pullback map with its localized counterpart. Stacks tags 02KH and 071M describe the mathematical flat-base-change/Čech route, not pinned Lean proofs. | Finish and independently review only the bounded algebraic/one-chart chunks already underway, then pivot to constructing the actual base-ring-linear global-sections pullback map and its natural two-affine localization comparison. Keep derived-Hom localization, component-projector compatibility, anchored heart-filtration lifting, and Theorem 5.7(2) as separate unproved obligations. Do not infer the paper theorem from an abstract sheaf equalizer or a non-natural cohomology-group isomorphism. |
| 2026-09-24 | SF11 relative-global-sections research recovery (this worktree): at pinned Mathlib 520045ab14e26149ee970e2e617ca04b09bde5d6, baseRingHom p := (ΓSpecIso R).inv ≫ p.appTop, Module.compHom, and baseRingHom (f ≫ p) r = f.appTop.hom (baseRingHom p r) elaborate. The actual unit ((Scheme.Modules.pullbackPushforwardAdjunction f).unit.app F).app ⊤ is available; its pointwise naturality reduces by change from unit.naturality. The R-linearity proof did not compile in three bounded revisions: after ModuleCat.ofHom and local globalSectionsModule instances, elaborating baseRingHom (f ≫ p) r • ηTop x produces failed to synthesize HSMul Γ(Z,⊤) Γ((pullback f ⋙ pushforward f).obj F,⊤). Pinned PresheafOfModules.pushforward = pushforward₀ ⋙ restrictScalars φ, so this target is presented as a pushforward section with a Γ(Y,⊤)-action, while the Γ(Z,⊤)-action belongs to the identified pullback section; neither pushforward_obj_obj nor pushforward_map_app states the scalar-action equality. The temporary uncompiled geometric leaf was removed; no theorem or client is claimed. | First prove a focused top-section scalar bridge from restrictScalarsObj, identifying the pushforward action of a : Γ(Y,⊤) with the pullback action of f.appTop.hom a on the same section. Keep the pullback section carrier explicit before constructing the ModuleCat arrow, then prove the map is the unit top component and its naturality, and audit a client with no affine hypothesis. Do not infer localization, derived Hom, a heart result, or Theorem 5.7(2). |
| 2026-09-24 | SF11 affine unit mate: pullbackSpecMapTildeIso is constructed by Adjunction.leftAdjointUniq, but that definition alone does not visibly identify its action on the actual pullbackPushforwardAdjunction unit. Pinned Adjunction.unit_leftAdjointUniq_hom_app supplies the equality after composing the tilde/Γ and affine-pushforward adjunctions. The proof must expose the ofNatIsoRight and composite units; category composition associativity and the restriction-of-scalars carrier are not definitionally interchangeable in the elementwise statement. | Export the categorical unit square and its 1 ⊗ m generator equation beside the affine pullback iso, with no localization assumption. This is affine and underived; a relative two-chart Γ comparison still needs chart restriction naturality and the fixed-base module packaging, and no derived-Hom, heart-filtration, or Theorem 5.7(2) claim follows. |
| 2026-09-24 | SF11 pushforward-action recovery: pinned PresheafOfModules.pushforward is pushforward₀ ⋙ restrictScalars, so at top sections the action is definitionally scalar restriction along f.appTop. The Γ(M,U) notation denotes the underlying abelian-group object: pushforward_obj_obj_top records f ⁻¹ᵁ ⊤ = ⊤, but its object equality cannot directly be used as an element-type Eq.mp. An ordinary client with an explicit ¬ IsAffineHom f hypothesis compiles; a concrete polynomial Proj client exceeded Lean's heartbeat budget while elaborating its large section type, without reaching a contrary mathematical obligation. Adversarial review found that the earlier research-recovery note overlooked the existing private all-open pushforward_scalar and pullback_scalar proofs in Families/RelativeLocalizationLinearity.lean; the new top-section identity is a convenient public pointwise API, not the missing mathematical prerequisite. | Export the exact pointwise scalar identity and top-carrier equality in the scheme-module pushforward owner, with no global instance, affineness, quasi-coherence, or derived hypothesis. The existing private all-open comparison is an alternative route to linearity; this public identity packages the top-section map. Neither proves Hom localization or Theorem 5.7(2). |
| 2026-09-25 | SF11 fixed-base-sheaf recovery: Mathlib already has the modulesSpecToSheaf fixed-ring presentation on Spec R and SheafOfModules.forgetToSheafModuleCat for an arbitrary scheme, but the former does not give an arbitrary Y → Spec R wrapper. The new wrapper takes the explicit ring map R → Γ(Y, 𝒪_Y) and exposes the two-open sheaf pullback cone in ModuleCat R; it does not compare that cone with the base-changed scheme. Compilation initially ballooned into more than 2,500 Mathlib jobs despite seeding 1,416 project oleans: seed_worktree_cache.sh reports project-cache size but does not rank/check the Mathlib package cache behind its packages link. The chosen donor had only 692 Mathlib oleans; a pin-identical donor had 8,276, after which the focused build completed. | Keep the fixed-ring sheaf wrapper separate from the still-unproved natural base-change comparison. When selecting a worktree cache donor, check both the project and package cache, not only the project olean count; record the exact Mathlib pin before reusing a dependency directory. Do not treat a sheaf pullback cone plus localization preserving finite limits as the missing unit-compatible geometric comparison. |
| 2026-09-25 | SF11 fixed-base pullback on top sections: the actual adjunction unit maps Γ(M,⊤) to Γ(f^*M,⊤), but fixedBaseSectionsFunctor Y φ presents its codomain as sections of f_*f^*M, with a separately captured R-module structure. ModuleCat.ofHom could not synthesize both source and target module instances from their definitionally shared carrier. Providing the two ModuleCat.isModule instances explicitly, proving the identity-on-carriers comparison via X.smul/T.smul, and using pushforward_smul_appTop solved that typing seam. At ⊤, the two Opens.leTop maps are propositionally, not definitionally, identities, so the last scalar equation needed Subsingleton.elim and simp. | Export the actual unit map as a natural transformation of R-module-valued top-section functors and audit its element equation. This is an underived linearity statement for arbitrary f and M, not a localization theorem. For p : Y → Spec R, take φ = (ΓSpecIso R).inv ≫ p.appTop; a subsequent comparison needs cartesian base change by a localization R → A, a quasi-compact quasi-separated p, and a quasi-coherent M. Prove that this natural R-linear map induces an isomorphism A ⊗[R] Γ(Y,M) ≅ Γ(Y_A,f^*M) after scalar extension. Derived global-sections base change is a further, separate obligation. Finite-limit preservation and affine unit compatibility alone do not prove either comparison, Hom localization, or Theorem 5.7(2). |
| 2026-09-25 | SF11 scalar-extended section map: the compatibility φ ≫ f.appTop = a ≫ ψ makes the two fixed-base presentations of target sections equal as module objects, but using eqToHom concealed the pointwise identity needed for the generator equation. An explicit identity-on-sections linear map, with both ModuleCat.isModule actions installed locally and the compatibility rewritten only after the top-open scalar actions are exposed, compiled. The tensor generator notation required open scoped ChangeOfRings; the adjunction proof required local Module.compHom instances for both A and its section module. An attempted natural-transformation wrapper exceeded Lean's heartbeat budget even at one million heartbeats and was deferred, rather than recorded as proved. | Export the actual A-linear scalar-extension transpose and its 1 ⊗ x equation, with no claim of invertibility or naturality. The required relative base-change isomorphism remains a separate geometric theorem; affine naturality does not imply it. Avoid object-equality casts for element equations when an explicit carrier-identity map gives a direct proof. |
| 2026-09-24 | SF11 open-section pullback unit: at an arbitrary U, the fixed-base wrapper presents Γ(f_*f⁺M,U) and Γ(f⁺M,f⁻¹ᵁU) on the same carrier with different scalar actions. The pushforward action evaluates f.app U after restricting a global scalar on Y; the native action restricts f.appTop on Z. f.naturality U.leTop.op identifies those scalars, so an identity-on-carriers ModuleCat comparison composes with the actual adjunction unit. Naturality in M is the unit's naturality, and restriction compatibility is naturality of its underlying presheaf morphism. | Keep the all-open unit map in the scheme-module pullback leaf and audit it through a direct client. It is underived and needs no affine or quasi-coherent hypothesis. The remaining relative base-change step must compare this specific map after scalar extension with sections on the base-changed scheme; neither the all-open linearity nor restriction compatibility supplies that isomorphism, derived base change, Hom localization, or a heart-level result. |
| 2026-09-25 | SF11 affine localization unit: on Spec R, fixed-base top sections at (ΓSpecIso R).inv are definitionally Mathlib's affine global-sections functor. The pinned affine pullback mate and the scalar-extension/localization natural isomorphism identify the actual pullback unit with the localization generator. A cache donor selected by project olean count alone had sparse Mathlib package cache; checking the pin-identical package cache found a larger donor. | Publish the natural affine tilde localization isomorphism together with its generator equation, and separately audit the all-section equation. This is only the affine underived comparison, not a relative nonaffine or derived global-sections theorem. Select cache donors using both project and Mathlib package cache sizes at the exact pinned revision. |
| 2026-09-25 | SF11 open-restriction mate adversarial review: a proposed pullbackOpenBaseChangeRightMate was defined from the chosen pullback iso by conjugateEquiv. Its unit square is consequently the general unit_conjugateEquiv identity, and its section equation only evaluates that identity. Neither identifies the mate with the independently defined pushforward/restriction comparison for the geometric open square. The useful open-immersion unit formula compiles, but the proposed package was left on the research branch rather than presented as the missing chart bridge. | Prove the independent pushforward comparison and show that the canonical mate equals it (including transport through the slice-site pullbackOverIso); then derive an equation in ordinary restricted sections. Until that is compiled and independently reviewed, use the already proved arbitrary-open unit/restriction compatibility without claiming geometric chart base change. No relative, derived, heart, or Theorem 5.7(2) claim follows. |
| 2026-09-25 | SF11 scalar-extended open-section restriction: three bounded attempts to prove the restriction square by expanding pure tensors did not close. Research recovery found pinned Adjunction.homEquiv_naturality_right_square; prove the square first over R by composing the actual open pullback-unit restriction theorem with an identity-on-sections change-of-scalars comparison, then transpose the entire square. The ModuleCat.extendRestrictScalarsAdj hom-equivalence is not definitionally the named fromExtendScalars map in the target: pinned Adjunction.mk'_homEquiv bridges them, and a final convert ... using 1 <;> rfl aligns the fixed-base functor wrappers. This was an API-elaboration obstacle, not a counterexample. | Keep the compiled result scoped to an underived arbitrary-open restriction square and audit the very same map on the tensor generator. Do not infer that any independently defined chart pushforward comparison equals this map, or that it is invertible after relative localization. The geometric two-chart base-change isomorphism, derived Hom localization, heart filtration lift, and Theorem 5.7(2) remain open. |
| 2026-09-25 | SF11 #1063 open-square cutover: the generic comparison still sat below Modules/Coherent/Pushforward/, while its module docstring and Projective audit said no functor natural isomorphism existed. A historical path in Restriction/Sections.lean and a cross-reference in Topology/Sheaves/CohomologyPushforward.lean used the retired CoherentSheaf spelling. The direct audit client initially failed because its example used the noncomputable comparison outside a noncomputable section. | Keep the independent comparison under Modules/Pushforward/BaseChange.lean, route its axiom records through a direct generic client, and check actual component and section equations after each move. Update stale path and capability prose with the source cutover; mark examples using noncomputable comparisons accordingly. This does not identify the independent comparison with an adjunction mate or prove a relative, derived, or heart-level result. |
| 2026-09-25 | SF11 #1063 open-square mate research: the direct pullback iso and the independent pushforward comparison both compile. A direct pointwise attempt left the pullback unit and counit exposed; broad simp hit the pinned instances transparency type mismatch. Recovery pasted five pullback-iso factors through conjugateEquiv_comp: the restriction factors use leftAdjointUniq, the composition factors use conjugateEquiv_pullbackComp_inv, and the equality-transport factor uses pushforwardCongr_hom_app_app plus M.presheaf.map_id. Iso.symm_hom closed the final comparison. | The conjugate equality and, via iterated_mateEquiv_conjugateEquiv and injectivity, the horizontal mate equality are now compiled and audited. Retain explicit change at the iterated-mate transparency seam. Next transport the result through the slice-site pullbackOverIso; do not infer relative or derived base change, Hom localization, or Theorem 5.7(2). |
| 2026-09-25 | SF11 #1063 actual-unit square: pinned unit_mateEquiv_symm turns the reviewed horizontal mate equality into the component equation for the actual pullbackPushforwardAdjunction units. The inverse-mate alignment needed Equiv.symm_apply_eq; a functor-level simpa did not eliminate unitor/associator coherence, but NatTrans.ext, convert ... using 1, and focused simp only did. On ordinary sections, simpa only [Hom.comp_app] failed at the ConcreteCategory.hom/AddCommGrpCat.Hom.hom elaboration seam; an explicit change on the component equality closed the direct equation evaluating β as restrictSquareSections. | Keep the three compiled unit theorems and direct audit client in the generic module-pushforward leaf. This is the direct open-square unit, not slice-site pullbackOverIso transport or relative localization/base-change IsIso; audit those later as separate obligations. |
| 2026-09-25 | SF11 two-open gluing: an unqualified ModuleCat.extendScalars a.hom in a PreservesFiniteLimits hypothesis elaborated with a fresh module universe, so Lean could not synthesize preservation of the source cospan despite the finite-limit instance. Pinning extendScalars.{u,u,u} in the hypothesis and proof resolved the mismatch. Inline asIso qU arguments in cospanIsoMk failed to find their local IsIso instances under expected-type elaboration; naming the component isos first resolved it. The cone's center compatibility is determined by its two legs, so constructing the universal cone morphism and using PullbackCone.IsLimit.hom_ext avoided a redundant center calculation. | Audit both the generic finite-limit-preserving gluing lemma and its canonical-localization client. The client supplies preservation by extendScalarsLocalizationNatIso, but still explicitly assumes the three actual open-section map isomorphisms. For a qcqs cover, an affine overlap cannot be assumed merely from two affine opens; cover the quasi-compact overlap separately. This proves no relative chart comparison, derived Hom localization, heart filtration lift, or Theorem 5.7(2). |
| 2026-09-25 | The first local precheck of the new two-open leaf failed neutral-stability-imports with “unknown internal import” even though the leaf built and the umbrella import was correct: the leaf was still untracked, and the graph gate reads the Git file set. | Stage the new leaf and its direct audit before running graph-based precheck. Treat this fail-closed result as an untracked-file workflow signal, not evidence of an import-cycle or mathematical defect; rerun the gate on the staged snapshot and keep hosted CI as the final verdict. |
| 2026-09-25 | In an independent API review of the two-open chunk, a broader pre-existing audit failed to see new ModuleCat.Localization declarations through its cached umbrella; the direct localization import and both new direct clients compiled. This is a stale local .olean/umbrella-cache observation, not a proof counterexample or a hosted-CI verdict. | Rebuild the exact umbrella and its dependencies before interpreting a broader audit failure; distinguish cache state from the audited source and still require hosted exact-head CI. |
| 2026-09-24 | The first scratch proof of augmented LeftResolution exactness compiled its objectwise kernel sequence but not the actual chainComplex segment: opaque ShortComplex projections and (𝟭 A).obj _ blocked a direct comparison. Keeping the short complex as a local S, proving exactness via ShortComplex.exact_iff_epi_kernel_lift, and factoring the kernel lift through kernel.map compiled the actual degree-1-to-degree-0 segment. | When proving exactness of a mapped resolution's augmented segment, use map_chainComplex_d_1_0 and the kernel-lift factorization directly; do not infer an H₀ or total-complex theorem from the objectwise short exact sequence. Preserve and compile the exact probe before moving it into a module. |
| 2026-09-24 | Porting that probe into a source module exposed syntax/API transcription traps: a scoped set_option ... in placed between a docstring and its declaration caused a parser error; instance synthesis did not infer the augmentation epi from an underspecified epi_comp call; and the concrete ObjectProperty.ι predicate and explicit LeftResolution argument needed their module argument and named Λ parameter. | Put scoped options before declaration docstrings, use epi_comp' with the recorded epi_π_app proof when instance composition does not elaborate, and compile the generic leaf plus its concrete client immediately. These were Lean elaboration mismatches, not mathematical counterexamples. |
| 2026-09-24 | A fresh worktree's documented scripts/seed_worktree_cache.sh --dry-run invocation failed because the tracked file mode is 100644. Running it through bash then selected the largest cache donor, whose .lake/packages was absent; the real seed correctly refused, while an explicit pin-matched donor with a valid package link succeeded. | Invoke the helper via bash on this checkout and inspect .lake/packages on a proposed donor; pass --from <verified-worktree> when automatic selection reports no dependency set. Consider repairing executable mode and donor selection separately from the mathematical PR. |
| 2026-09-24 | A generic LeftResolution extension under DerivedAlgGeo/Algebra/Homology/ is counted by the legacy EnumDecls.libraryOf route in the StabilityCondition audit lane, not the geometry audit; relying on namespace or subject intuition would omit it from the audit and trip the new-declaration ratchet. | Check scripts/EnumDecls.lean before choosing the audit leaf. Add the generic records under scripts/StabilityConditionAudit/ and any scheme-specific specialization under scripts/AlgebraicGeometryAudit/; the audit library globs the area leaves. |
| 2026-09-24 | PR #1527's first complete CI passed on head f5e74756, but main advanced through unrelated PR #1526 before merge. The PR therefore became behind and its green checks no longer satisfied strict branch freshness. | Fetch main immediately before merging. If it moved, merge the new base into the branch, confirm the SF8 diff is unchanged, revalidate the exact new head, and wait for its own required CI run; never treat stale green checks as merge-ready. |
| 2026-09-25 | The local agent/loop-preflight-closed-blockers controller attempt stopped after its third critique/revise round. Its final adversaries found that a bare blockedBy list of closed nodes lacks completeness evidence, and that a connection node marked CLOSED with no valid issue number can be accepted as resolved. The candidate remains local at f2026ca with no PR. | Preserve the terminal review and both findings as a documented handoff. Do not revise or rename that frozen fix to reset its round count; a later controller effort needs a separately authorized objective and its own review history. The general SF8 proof work may continue through the issue-first path. |
| 2026-09-25 | PR #1527 was merged at 04138c26 while its refreshed head d1d8bd0d still showed a failing roadmap job and a running build job. The roadmap log identifies two test_loop_engine.CIFailureRepairTests failures, both from a run-manifest digest mismatch in approval tests. The live PR record showed no GitHub reviews. | Treat the merged stalk-flat bicomplex as mathematical progress, not as evidence that the refreshed PR head passed all checks. Keep #554 open and make a separate, fully checked CI recovery if those controller tests still fail on current main; require exact-head review and CI for the next SF8 PR. |
| 2026-09-25 | The next SF8 probe initially inferred the mapped resolution as HomologicalComplex A (ComplexShape.down ℕ), so Lean did not resolve the chain-specific isoHomologyι₀. An explicit local K : ChainComplex A ℕ exposed Mathlib's ChainComplex.isIso_descOpcycles_iff, which turns the already proved augmented exactness and epi into an H₀ isomorphism. Repeating the elaborated index proof inline in the final exact triggered a spurious “No goals to be solved”; naming the descended map as ψ compiled. | State the mapped complex at its chain-complex alias and reuse one named descended augmentation. This proves objectwise H₀ only; naturality, bicomplex totalization/quasi-isomorphism, K-flatness, and arbitrary derived pullback remain separate obligations. |
| 2026-09-25 | The first H₀ precheck's neutral-Stability import gate failed closed on the new LeftResolution/HomologyZero.lean because the file was still untracked: that gate builds its module map from Git's index and interpreted the umbrella import as an unknown internal module. The targeted Lean build had already compiled the module. | Stage new source files before running repository import gates, then rerun the gate on the staged tree. Treat an unknown-import result on an untracked module as an inventory/precheck issue, not as a geometric import leak. |
| 2026-09-25 | The H₀ naturality proof initially stalled on reassociation of pOpcycles, isoHomologyι₀.inv, and homologyMap, plus cancellation of the mapped degree-zero isomorphism. The pinned library already exposes the reassociated isoHomologyι₀_inv_naturality_assoc, p_opcyclesMap_assoc, and Iso.map_inv_hom_id_assoc lemmas. | Use those named lemmas to prove naturality against the augmentation, then package the objectwise H₀ isomorphisms as a natural isomorphism. This still does not totalize the resolution bicomplex or construct arbitrary derived pullback. |
| 2026-09-25 | Mathlib's HomologicalComplex₂.totalFunctor expects two integer-up directions, while the free-Yoneda resolution has an integer-up complex of nonnegative-down chain resolutions. The pinned ComplexShape.embeddingDownNat.extendFunctor reindexes one resolution degree as a nonpositive integer; X.Modules supplies the required coproducts for direct-sum totalization. Searching the pinned total-complex API found no theorem that turns the objectwise exact rows and H₀ identification into a quasi-isomorphism of this unbounded total complex. | Place the geometric totalization in AlgebraicGeometry/Modules/FlatResolutionTotalization.lean, downstream of the existing FlatGenerators root. Export only the constructed functor; prove its augmentation comparison, quasi-isomorphism, flat-term preservation, and K-flatness separately before using it to inhabit derived pullback. |
| 2026-09-25 | The general proof that moduleStalkFunctor preserves indexed coproducts was private inside FlatGenerators.lean, where it served one free-Yoneda calculation. Total-complex termwise flatness needs the same general preservation statement. A first generalized flat-coproduct proof also failed to elaborate ModuleCat.coprodIsoDirectSum until the index type had an explicit classical DecidableEq instance. Extending the index from Type u to an independent Type v failed because the pinned sheafification and forgetful-colimit instances do not synthesize at that universe. The first abstraction review also found the free-Yoneda caller still repeated the new general proof. | Move the stalk theorem to its functor's definition site, Modules/Pullback/Stalk.lean, and move the identity-flatness/stalk equivalence to Modules/Flat.lean; preserve the Type u scope, and use a universe lift if a later totalization fiber needs it. Prove IsFlatOver (𝟙 X) for these indexed coproducts using stalk preservation and Mathlib's Module.Flat.directSum_iff, then derive the free-Yoneda result from that theorem. Keep the total-complex termwise consequence and any K-flatness claim for later chunks. |
| 2026-09-25 | PR #1560 passed its Lean build, audit completeness, contract gates, and roadmap job, but the environment linter rejected the new public def freeYonedaSheafCoproductReducedLeftResolution_homologyZeroIso under defsWithUnderscore. The targeted build and local precheck did not run that declaration linter. | Rename the isomorphism definition to lowerCamelCase, update its audit record, rerun the focused declaration linter, and require fresh exact-head CI before merge. Keep the failed run as evidence that local precheck is not CI-equivalent. |
| 2026-09-25 | The free-Yoneda total complex is a coproduct over Mathlib's diagonal fiber, whose index lives in Type while the general module-sheaf coproduct flatness theorem uses Type u. The integer extension also has zero terms outside the image of embeddingDownNat, so the flatness proof must cover those terms. | Reindex the small coproduct through ULift.{u} and Sigma.reindex; derive flatness of zero terms stalkwise from a zero-object stalk and Module.Flat.of_retract. This proves each total term flat over the identity, without a K-flatness or total quasi-isomorphism assertion. |
| 2026-09-25 | The generic left-resolution initial segment already supplies an augmentation map that kills the differential, and Mathlib's ChainComplex.toSingle₀Equiv packages exactly that datum as a chain map. During the naturality probe, a local backward.defeqAttrib.useBackward setting prevented the same reduction that compiled without it, making change fail on the augmentation component. | Construct the augmentation in Algebra/Homology/LeftResolution/Augmented.lean through the pinned equivalence, prove naturality at degree zero, and expose one natural transformation. Remove the unnecessary local reduction setting. This produces a chain-level map, while totalization comparison and quasi-isomorphism remain open. |
| 2026-09-25 | The first adversarial review of the chain augmentation caught a public naturality lemma without a docstring and a missing audit record for the public @[reassoc] companion generated by Lean. The focused style checker flags the docstring, while a direct #print axioms on authored names alone overlooks generated companions. | Document the naturality square and audit chainComplexAugmentation_naturality_assoc beside its source lemma. Include generated declaration inspection in future new-public-lemma reviews, then rerun the focused style and audit checks. |
| 2026-09-25 | #1560's second CI run was still running when unrelated SF11 #1561 moved main from 8e44470b to b2c37fa2; the PR had to be rebased and submitted for a third exact-head run. Both commit patch IDs stayed identical, and the four independent reviewers revalidated the new head without a critique/revise round. A separate new-worktree cache seed was initially run from the donor checkout; the script refused to overwrite its warm cache, and a rerun from the intended cold checkout succeeded. | Recheck origin/main before merge, verify stable patch IDs after rebases, and use the new head's CI verdict. Run cache seeding from the returned target worktree directory; its refusal protected the donor. |
| 2026-09-25 | For the generic chain augmentation, Mathlib's ChainComplex.quasiIsoAt₀_iff and ShortComplex.quasiIso_iff_of_zeros' reduce degree-zero quasi-isomorphism to exactly the proved augmented exactness and epi; quasiIsoAt_iff_exactAt' handles positive degrees. The proof required an explicit SingleHomology import, and the local backward-definitional-equality options used by the pinned projective-resolution proof made the ShortComplex.isoMk comparison elaborate. These options had caused trouble in the preceding naturality proof, so their usefulness is proof-specific. | Prove the objectwise chain augmentation is a quasi-isomorphism in the generic LeftResolution owner, with the exact imports and scoped options; do not infer that direct-sum totalization of unbounded rows is a quasi-isomorphism. |
| 2026-09-25 | On the cold quasi-isomorphism worktree, lake exe runLinter DerivedAlgGeo stopped because an unrelated all-library .olean was absent; a targeted build of the changed generic umbrella had succeeded. The module-scoped runLinter DerivedAlgGeo.Algebra.Homology.LeftResolution.Augmented then passed. | Use the module-scoped linter as local feedback on the changed declaration; require the PR's full environment-linter job for the complete library, without running a prohibited full local build just to warm its cache. |
| 2026-09-25 | A fresh worktree's tracked scripts/seed_worktree_cache.sh lacked an executable bit, so the documented direct invocation failed with permission denied; bash scripts/seed_worktree_cache.sh seeded the cache. In the H₀ agreement proof, rw failed to match maps through let-bound complexes and the short-complex source even when their types were definitionally equal; explicit complex objects, composition association, and change at the owner lemma made the comparison compile. | Invoke the non-executable seed script through bash and record the documentation mismatch. In later generic comparisons, state the source and target complex types explicitly before rewriting canonical homology and augmentation maps; do not infer totalization or K-flatness from this degree-zero agreement. |
| 2026-09-26 | main added the run-loop policy after a nine-commit SF8 stack was reviewed locally. Its two generic zero-column cutover commits edit AGENTS.md and CLAUDE.md, which the new policy forbids during an issue run; the older controller fix also remains terminal after three rounds. | Preserve the reviewed nine-commit stack locally, publish only its seven patch-equivalent, policy-compliant foundation commits as a progress PR, and keep the terminal controller findings documented for a separate authorized effort. Do not restart a frozen chunk to reset its review budget. |
| 2026-09-26 | The first review of the seven-commit foundations PR found five explanatory docstrings that repeated statement shapes; the #554 roadmap summary also still listed the already merged nonflat example as outstanding. | Revise the comments to explain the proof mechanism, correct the roadmap to five completed deliverables while explicitly retaining the totalized quasi-isomorphism and K-flatness gaps, then submit the new frozen commit to all four independent reviewers. |
| 2026-09-26 | A new SF8 worktree request collided with an older clean sf8-total-augmentation checkout; git worktree add -b created the branch name before refusing the occupied path. The pinned API exposes Functor.whiskerRight, not NatTrans.whiskerRight, and mapping the augmentation through homological complexes needs explicit zero-preservation instances for the composite functors. | Keep the older checkout intact, use a distinct worktree path for the newly created branch, and expose the instances locally before applying NatTrans.mapHomologicalComplex. Mathlib's Embedding.ExtendHomology then transports the objectwise quasi-isomorphism to each integer-indexed row; this still supplies no totalized quasi-isomorphism. |
| 2026-09-26 | The Stacks Project's flat-resolution construction obtains unbounded K-flat resolutions from a compatible filtered tower of bounded-above flat resolutions (Lemmas 21.17.10–11). This highlights the missing step between rowwise quasi-isomorphisms for the free-Yoneda bicomplex and a quasi-isomorphism or K-flatness claim for its unbounded direct-sum total. | Keep the rowwise augmentation and total map as limited progress. Investigate a compatible truncation tower and exact filtered colimits, or prove a separate theorem with hypotheses sufficient for this totalization; do not infer the unbounded conclusion from flat terms or rowwise quasi-isomorphisms alone. |
| 2026-09-26 | A live recheck found progress PR #1527 already merged, contrary to the older handoff state. Its previous head e441b51 had a successful PR CI run, but the final merge-from-main head d1d8bd0 was merged seconds after its own PR CI began; that run later failed the roadmap job. The same timing pattern occurred on #1565, whose later run succeeded. | Treat a merged state and an earlier green head as insufficient evidence for the last pushed head. For each active PR, verify the exact current head and completed required checks immediately before merging, and recheck main after another PR moves it. Preserve the #1527 failure as stale-state and CI-ordering evidence, not as a failure of its Lean build. |
| 2026-09-27 | While #1568's first PR run was active, #1569 advanced main to e83b6140. Merging that base into #1568 was conflict-free, and the four-path contribution diff stayed byte-for-byte identical, but the previous successful run no longer checked its pushed head. The run on merge head 5364d5bc completed before #1568 merged as 20abe06c; #554 remained open. | Recheck the live base before merging. Preserve exact contribution-diff evidence for a conflict-free base merge and wait for all required checks on the final pushed head. |
| 2026-09-27 | The tracked cache seed script still lacks an executable bit; its default donor had a build directory modified within 90 seconds and correctly refused a torn read. Invoking it with bash and an explicit idle SF8 donor seeded 1494 modules. A first generic colimit proof placed under an existing HasZeroMorphisms section failed to synthesize homology for the abelian category; reopening the namespace with a clean [Category] [Abelian] context compiled. preservesColimitNatIso also needed the explicit diagram shape and a named composite-isomorphism proof through its let-bound natural isomorphism. | Use bash scripts/seed_worktree_cache.sh --from <idle donor> after the dry-run refusal. Keep abelian homology proofs in a context whose inherited zero-morphism instance does not obscure the canonical homology instances; state the colimit shape and composite isomorphism explicitly when elaboration cannot infer them. |
| 2026-09-27 | Round-one abstraction review of the filtered-colimit foundation found that its [Abelian C] and exact-colimit assumptions were stronger than the proof required. The reviewer compiled the same argument with only category-with-homology, colimits, and preservation of those colimits by each homology functor. | State the core quasi-isomorphism result under the preservation hypotheses and derive the exact-colimit/AB5 case as a corollary. Audit both public declarations and submit the revised frozen commit to all four independent reviewers in round two. |
| 2026-09-27 | Round-two Mathlib-style review found that the new generic theorem's docstring only paraphrased its statement. The focused style script reported DOCECHO but still exited successfully, so the warning needed an adversarial reading to become actionable. | Replace the comment with the homology-colimit comparison mechanism, then run the named build, focused audit, and local precheck again before the final four-role review round. A third failed round parks the chunk. |
| 2026-09-27 | The next K-flat colimit step needed naturality of Mathlib’s preservesColimitIso in the preserving functor, while the pinned preservesColimitNatIso only gives naturality in the diagram. Its declaration is in CategoryTheory, not CategoryTheory.Limits; Lean rewrites through colimit and colim.obj needed backward.isDefEq.respectTransparency false. The cache seed script again required bash, since its documented direct invocation is not executable in this worktree. The first no-build precheck passed its other gates but neutral-stability-imports failed closed on the new module while it was still untracked; that gate inventories internal modules through Git, so staging the source before rerunning resolves this workflow-state failure. | Put the new naturality theorem beside the Mathlib limits API, prove homology-preserving-colimit transfer for natural transformations at the homological-complex owner, and use that theorem for generic K-flat closure. Keep scheme tensor-colimit preservation and a compatible resolution tower explicit prerequisites before claiming #554. |
| 2026-09-27 | Round-one review of the K-flat colimit chunk found three excess-premise sites: naturality and quasi-isomorphism transfer asked for shape-wide preservation despite using one diagram, and K-flat closure asked for exact colimits despite using only degreewise homology preservation. The Mathlib-style reviewer found a naturality docstring that repeated the equation. Mathematics and boundary reviewers passed the same frozen commit. | Narrow the two comparisons to PreservesColimit F and HasColimit F, state K-flat closure under diagram-specific tensor continuity and homology-colimit preservation, retain the exact-colimit result as a corollary, and explain the proof through colimit injections. Resubmit all four roles on the round-two commit. |
| 2026-09-27 | The scheme-module colimit proof reused the arbitrary-sheaf tensor/sheafification comparisons already proved in Modules/Tensor/Basic.lean; the older finite-colimit proof and tensorLeftFunctor lived under Invertible even though neither needs invertibility. Scheme.Modules is opaque enough that Lean did not synthesize its monoidal instance for an unannotated tensorLeft; the explicit canonical category (C := X.Modules) compiled, and a scratch rfl check confirmed agreement with the historical functor. The pinned presheaf tensor instance supplies shape categories only in the scheme site universe, so future smaller-index filtered towers may need ULift reindexing. | Move the historical functor to a canonical tensorLeft abbreviation in Monoidal, move its finite-colimit instance to the new scheme tensor Colimits leaf, and prove both slotwise colimit theorems at the supported universe. Keep complex totalTensor continuity, the resolution tower, and #554 open as separate obligations. |
| 2026-09-27 | The first required PR CI for the sheaf-tensor colimit chunk passed its Lean build, audits, contract gates, and emitter reproducibility, but runLinter DerivedAlgGeo found two now-unused invertibility arguments in tensorLeftFunctor_additive and tensorLeftFreeIso. The earlier no-build precheck had no environment linter stage. A broad local linter attempt could not import the cold worktree's missing Cohomology/Cech/ProjectiveSpace.olean, while focused lints on the two changed leaves passed after revision. | Generalize and relocate those two consequences from Invertible to Colimits, preserving their names and auditing the newly widened additive instance. Freeze a new commit, rerun all four reviews, and require CI on that exact head. Treat focused local lints as evidence for the changed declarations, not the repository-wide CI verdict. |
| 2026-09-27 | Round-two abstraction and Mathlib-style reviewers independently compiled a stronger tensorLeftFreeIso: after moving it to the generic colimit owner, its inherited [Finite I] premise was unnecessary. Mathematics and boundary reviews passed the same frozen commit. The local named build command first used invalid scripts.* Lake targets, and a style probe used the unsupported --diff option; using lake env lean for audit files and --diff-only REF FILE for style resolved those tool-invocation errors. | Remove the finite premise and Fintype.ofFinite, install the Discrete I preservation instance from tensorLeft_preservesColimitsOfShape, and update the proof description. Submit the final allowed round to all four reviewers on one frozen commit; any third-round failure stops this chunk under the loop policy. |
| 2026-09-27 | ROU1 #920 stopped after all four reviewers passed the frozen implementation because the issue still carried its research triage label. The required reconnaissance verdict was already recorded in comments, but preflight treated the label as ineligible; this also delayed dependent #921. The owner then explicitly authorized removing the stale label. | Compare triage labels with the issue's stated conditions and recorded evidence before treating them as blockers. When research is complete and the active authorization permits reconciliation, remove or reclassify only the stale label, record the evidence, and rerun preflight. Keep unresolved research findings blocking; a stale label alone must not stop the autonomous queue. |
| 2026-09-27 | The active issue-first loop parked terminal three-round attempts without launching R&D. PR #1574's third reviewed head passed four reviewers but failed the repository-wide linter on an unused invertibility premise; the older local controller-preflight attempt ended with two fail-open provider-shape findings. The initial R&D report for #1574 also repeated the terminal PR's overly narrow repair, and independent review rejected it as a disguised fourth edit. Main advanced during review, and the full raw review messages were not in the located worktree records. | Reserve every future review round in issue-level comments before dispatch, preserve raw outcomes and exact SHAs, then automatically launch read-only research and independent plan review at exhaustion. Prefer a changed architecture only when a falsifiable probe supports it; keep missing transcripts an admission blocker. Recheck main and the live PR, and do not turn research approval into source or publication approval. |
| 2026-09-27 | First formal review of the R&D handoff protocol found that CONTRIBUTING still said “three rounds per PR,” AGENTS/CLAUDE still said only park, the skill exempted changed non-Lean PR content from re-review, and its third-head rule accidentally covered transient CI failures. It also tried to freeze a nonexistent source attempt when initial research found a false definition of done or withdrawn authority. | Synchronize all active guidance; charge any PR-content repair to the same attempt, exempt only a documented content-identical base refresh, and verify live head/checks before merge. Limit the automatic exhausted-attempt handoff to an actual terminal review panel or an attributable third-head PR-content failure; record pre-implementation blockers using only evidence that exists. |
| 2026-09-27 | Second formal review found the terminal CI wording still excluded deterministic documentation/configuration failures even though those repairs consumed review rounds; one reviewer also caught an imprecise R&D claim that the historical tensorLeftFunctor itself was invertible-only. On the PR base it is defined for every module sheaf; only its existing preservation/additivity instances and free comparison carry invertibility. | Trigger R&D whenever an attributable required-check failure on the third reviewed PR head needs a content-changing repair, regardless of file type. Keep transient/unrelated reruns separate. Correct the research report's API distinction and get independent review of its new exact digest; do not narrow the old public functor. |
These entries are process evidence, not proof evidence. The concrete affine
Tor comparison is proved, audited, and reviewed in merged PR #1464. The broader
abstract Tor generalization remains unverified in
generalization-backlog.md; each remaining mathematical claim still needs its
own compiled evidence and independent review.
Exported from docs/architecture/loop-engineering-friction.md at the commit that removed it from the tree.
Architecture
- Canonical roots and specialization trees
- Structural cutover ledger
- Generalization backlog
- Dependency direction
- Loop-engineering friction log
- Mathematical ownership and abstraction boundarie
- Declaration placement
- When a proposition-valued class is justified
- Enhanced spherical twists: conventions and remai
- Verification history
CI and runners
- Bounded audit batching probe, 2026-09-27
- CI1.10: audit and exception record contention, 2
- Proposed hosted-only CI cutover for CI1.07
- Mac VM runners
- Owner CI lane: self-hosted runners in a private
- CI performance baseline, 2026-09-27
- CI1.07 exact-tree Ubuntu routing sample, 2026-09
- Ubuntu workstation runners (historical topology)
Decision records
- ADR-0001 — The seam is cold: files, not runtime (superseded)
- ADR-0002 — Identity is minted in the topic repo, (superseded)
- ADR-0003 — Elaboration and axiom evidence is pro (superseded)
- ADR-0004 — The statement registry lives in the t (superseded)
- ADR-0005 — Seven axes, four values, no aggregate (superseded)
- ADR-0006 — All contract issues are filed on `bri (superseded)
- ADR-0007 — Where the contract package lives (superseded)
-
ADR-0008 —
@[cites]ships as a shared Lake dep (superseded) - ADR-0009 — The contract package lives with the e (superseded)
- ADR-0010 — How a dg category is encoded, and whe
- ADR-0011 — Hom-complexes are complexes of abelia
- ADR-0012 — One Mathlib-style source root
- ADR-0013 — Own reusable moduli infrastructure in
- ADR-0014 — Stacks, algebraic spaces and moduli:
Roadmaps