Record 20 verified HPC batch manifests

manifests/batches/mathlib/000869.json

@@ -0,0 +1,166 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "mathlib/000869",
+  "batch_fingerprint": "5518d60d143780526d3b6de6d1f4e5da447e11d3bdd8e15a11a8709900f8cf1e",
+  "evidence": {
+    "batch_fingerprint": "5518d60d143780526d3b6de6d1f4e5da447e11d3bdd8e15a11a8709900f8cf1e",
+    "contamination_matches": [],
+    "failures": [
+      {
+        "error": "final tactic does not close all goals",
+        "full_name": "ContT.monadLift_bind",
+        "id": "ContT.monadLift_bind",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            105,
+            21
+          ],
+          "file_path": "Mathlib/Control/Monad/Cont.lean",
+          "full_name": "ContT.monadLift_bind",
+          "start": [
+            101,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"ext\"",
+                "[]"
+              ],
+              "state_after": "case h\nr : Type u\nm : Type u \u2192 Type v\n\u03b1\u271d \u03b2\u271d \u03b3 \u03c9 : Type w\ninst\u271d\u00b9 : Monad m\ninst\u271d : LawfulMonad m\n\u03b1 \u03b2 : Type u\nx : m \u03b1\nf : \u03b1 \u2192 m \u03b2\nf\u271d : \u03b2 \u2192 m r\n\u22a2 (monadLift (x >>= f)).run f\u271d = (monadLift x >>= monadLift \u2218 f).run f\u271d",
+              "state_before": "r : Type u\nm : Type u \u2192 Type v\n\u03b1\u271d \u03b2\u271d \u03b3 \u03c9 : Type w\ninst\u271d\u00b9 : Monad m\ninst\u271d : LawfulMonad m\n\u03b1 \u03b2 : Type u\nx : m \u03b1\nf : \u03b1 \u2192 m \u03b2\n\u22a2 monadLift (x >>= f) = monadLift x >>= monadLift \u2218 f",
+              "tactic": "ext"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/Monad/Cont.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "ContT.run_contT_map_contT",
+        "id": "ContT.run_contT_map_contT",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            70,
+            6
+          ],
+          "file_path": "Mathlib/Control/Monad/Cont.lean",
+          "full_name": "ContT.run_contT_map_contT",
+          "start": [
+            69,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/Monad/Cont.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "ContT.run_withContT",
+        "id": "ContT.run_withContT",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            78,
+            6
+          ],
+          "file_path": "Mathlib/Control/Monad/Cont.lean",
+          "full_name": "ContT.run_withContT",
+          "start": [
+            76,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/Monad/Cont.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "OptionT.goto_mkLabel",
+        "id": "OptionT.goto_mkLabel",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            159,
+            6
+          ],
+          "file_path": "Mathlib/Control/Monad/Cont.lean",
+          "full_name": "OptionT.goto_mkLabel",
+          "start": [
+            157,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/Monad/Cont.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "WriterT.ext",
+        "id": "WriterT.ext",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            60,
+            93
+          ],
+          "file_path": "Mathlib/Control/Monad/Writer.lean",
+          "full_name": "WriterT.ext",
+          "start": [
+            60,
+            11
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/Monad/Writer.lean"
+      }
+    ],
+    "input_proofs": 11,
+    "input_units": 2,
+    "proofs": 6,
+    "published_proofs": 6,
+    "published_transitions": 12,
+    "replay_failures": [],
+    "transitions": 12,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/mathlib-000869-0000-124e96c6e69c7dfd.parquet",
+      "sha256": "124e96c6e69c7dfd0afc60cd27a1e354b291fc28ec90983c5ab7d31e353e4d6d",
+      "bytes": 52884,
+      "rows": 12,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    }
+  ],
+  "proof_ids": [
+    "mathlib:ContT.ext",
+    "mathlib:ExceptT.goto_mkLabel",
+    "mathlib:ReaderT.goto_mkLabel",
+    "mathlib:StateT.goto_mkLabel",
+    "mathlib:WriterT.goto_mkLabel",
+    "mathlib:WriterT.goto_mkLabel'"
+  ],
+  "proof_keys": [
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Monad/Cont.lean\",null,null,\"ContT.ext\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Monad/Cont.lean\",null,null,\"ExceptT.goto_mkLabel\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Monad/Cont.lean\",null,null,\"ReaderT.goto_mkLabel\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Monad/Cont.lean\",null,null,\"StateT.goto_mkLabel\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Monad/Cont.lean\",null,null,\"WriterT.goto_mkLabel\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Monad/Cont.lean\",null,null,\"WriterT.goto_mkLabel'\"]"
+  ]
+}

manifests/batches/mathlib/000870.json

@@ -0,0 +1,538 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "mathlib/000870",
+  "batch_fingerprint": "c23a0100b62ad076b59ddb6d3d391837bd2537278f2f85534a979586c131da00",
+  "evidence": {
+    "batch_fingerprint": "c23a0100b62ad076b59ddb6d3d391837bd2537278f2f85534a979586c131da00",
+    "contamination_matches": [],
+    "failures": [
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "ApplicativeTransformation.app_eq_coe",
+        "id": "ApplicativeTransformation.app_eq_coe",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            94,
+            6
+          ],
+          "file_path": "Mathlib/Control/Traversable/Basic.lean",
+          "full_name": "ApplicativeTransformation.app_eq_coe",
+          "start": [
+            93,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/Traversable/Basic.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "ApplicativeTransformation.coe_mk",
+        "id": "ApplicativeTransformation.coe_mk",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            100,
+            6
+          ],
+          "file_path": "Mathlib/Control/Traversable/Basic.lean",
+          "full_name": "ApplicativeTransformation.coe_mk",
+          "start": [
+            98,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/Traversable/Basic.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "ApplicativeTransformation.comp_apply",
+        "id": "ApplicativeTransformation.comp_apply",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            186,
+            6
+          ],
+          "file_path": "Mathlib/Control/Traversable/Basic.lean",
+          "full_name": "ApplicativeTransformation.comp_apply",
+          "start": [
+            184,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/Traversable/Basic.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "ApplicativeTransformation.comp_assoc",
+        "id": "ApplicativeTransformation.comp_assoc",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            194,
+            6
+          ],
+          "file_path": "Mathlib/Control/Traversable/Basic.lean",
+          "full_name": "ApplicativeTransformation.comp_assoc",
+          "start": [
+            191,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/Traversable/Basic.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "ApplicativeTransformation.comp_id",
+        "id": "ApplicativeTransformation.comp_id",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            199,
+            21
+          ],
+          "file_path": "Mathlib/Control/Traversable/Basic.lean",
+          "full_name": "ApplicativeTransformation.comp_id",
+          "start": [
+            198,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/Traversable/Basic.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "ApplicativeTransformation.congr_arg",
+        "id": "ApplicativeTransformation.congr_arg",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            110,
+            34
+          ],
+          "file_path": "Mathlib/Control/Traversable/Basic.lean",
+          "full_name": "ApplicativeTransformation.congr_arg",
+          "start": [
+            108,
+            11
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/Traversable/Basic.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "ApplicativeTransformation.congr_fun",
+        "id": "ApplicativeTransformation.congr_fun",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            105,
+            64
+          ],
+          "file_path": "Mathlib/Control/Traversable/Basic.lean",
+          "full_name": "ApplicativeTransformation.congr_fun",
+          "start": [
+            103,
+            11
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/Traversable/Basic.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "ApplicativeTransformation.ext_iff",
+        "id": "ApplicativeTransformation.ext_iff",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            130,
+            41
+          ],
+          "file_path": "Mathlib/Control/Traversable/Basic.lean",
+          "full_name": "ApplicativeTransformation.ext_iff",
+          "start": [
+            128,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/Traversable/Basic.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "ApplicativeTransformation.id_comp",
+        "id": "ApplicativeTransformation.id_comp",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            204,
+            21
+          ],
+          "file_path": "Mathlib/Control/Traversable/Basic.lean",
+          "full_name": "ApplicativeTransformation.id_comp",
+          "start": [
+            203,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/Traversable/Basic.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "ApplicativeTransformation.preserves_pure",
+        "id": "ApplicativeTransformation.preserves_pure",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            139,
+            20
+          ],
+          "file_path": "Mathlib/Control/Traversable/Basic.lean",
+          "full_name": "ApplicativeTransformation.preserves_pure",
+          "start": [
+            138,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/Traversable/Basic.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "ApplicativeTransformation.preserves_seq",
+        "id": "ApplicativeTransformation.preserves_seq",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            144,
+            19
+          ],
+          "file_path": "Mathlib/Control/Traversable/Basic.lean",
+          "full_name": "ApplicativeTransformation.preserves_seq",
+          "start": [
+            143,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/Traversable/Basic.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Equiv.isLawfulTraversable",
+        "id": "Equiv.isLawfulTraversable",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            160,
+            41
+          ],
+          "file_path": "Mathlib/Control/Traversable/Equiv.lean",
+          "full_name": "Equiv.isLawfulTraversable",
+          "start": [
+            153,
+            11
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/Traversable/Equiv.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Equiv.lawfulFunctor",
+        "id": "Equiv.lawfulFunctor",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            70,
+            37
+          ],
+          "file_path": "Mathlib/Control/Traversable/Equiv.lean",
+          "full_name": "Equiv.lawfulFunctor",
+          "start": [
+            65,
+            11
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/Traversable/Equiv.lean"
+      },
+      {
+        "error": "no internal trace for tactic 'cases F'",
+        "full_name": "Equiv.lawfulFunctor'",
+        "id": "Equiv.lawfulFunctor'",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            82,
+            32
+          ],
+          "file_path": "Mathlib/Control/Traversable/Equiv.lean",
+          "full_name": "Equiv.lawfulFunctor'",
+          "start": [
+            73,
+            11
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"have : F = <a>Equiv.functor<\\/a> eqv := by\\n    cases F\\n    dsimp [<a>Equiv.functor<\\/a>]\\n    congr <;> ext <;> dsimp only <;> [rw [\\u2190 h\\u2080]; rw [\\u2190 h\\u2081]] <;> rfl\"",
+                "[{\"full_name\":\"Equiv.functor\",\"def_path\":\"Mathlib\\/Control\\/Traversable\\/Equiv.lean\",\"def_pos\":[50,15],\"def_end_pos\":[50,22]},{\"full_name\":\"Equiv.functor\",\"def_path\":\"Mathlib\\/Control\\/Traversable\\/Equiv.lean\",\"def_pos\":[50,15],\"def_end_pos\":[50,22]}]"
+              ],
+              "state_after": "t t' : Type u \u2192 Type u\neqv : (\u03b1 : Type u) \u2192 t \u03b1 \u2243 t' \u03b1\ninst\u271d\u00b9 : Functor t\ninst\u271d : LawfulFunctor t\nF : Functor t'\nh\u2080 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 \u03b2), map f = Equiv.map eqv f\nh\u2081 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b2), mapConst f = (Equiv.map eqv \u2218 Function.const \u03b1) f\nthis : F = Equiv.functor eqv\n\u22a2 LawfulFunctor t'",
+              "state_before": "t t' : Type u \u2192 Type u\neqv : (\u03b1 : Type u) \u2192 t \u03b1 \u2243 t' \u03b1\ninst\u271d\u00b9 : Functor t\ninst\u271d : LawfulFunctor t\nF : Functor t'\nh\u2080 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 \u03b2), map f = Equiv.map eqv f\nh\u2081 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b2), mapConst f = (Equiv.map eqv \u2218 Function.const \u03b1) f\n\u22a2 LawfulFunctor t'",
+              "tactic": "have : F = Equiv.functor eqv := by\n  cases F\n  dsimp [Equiv.functor]\n  congr <;> ext <;> dsimp only <;> [rw [\u2190 h\u2080]; rw [\u2190 h\u2081]] <;> rfl"
+            },
+            {
+              "annotated_tactic": [
+                "\"subst this\"",
+                "[]"
+              ],
+              "state_after": "t t' : Type u \u2192 Type u\neqv : (\u03b1 : Type u) \u2192 t \u03b1 \u2243 t' \u03b1\ninst\u271d\u00b9 : Functor t\ninst\u271d : LawfulFunctor t\nh\u2080 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 \u03b2), map f = Equiv.map eqv f\nh\u2081 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b2), mapConst f = (Equiv.map eqv \u2218 Function.const \u03b1) f\n\u22a2 LawfulFunctor t'",
+              "state_before": "t t' : Type u \u2192 Type u\neqv : (\u03b1 : Type u) \u2192 t \u03b1 \u2243 t' \u03b1\ninst\u271d\u00b9 : Functor t\ninst\u271d : LawfulFunctor t\nF : Functor t'\nh\u2080 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 \u03b2), map f = Equiv.map eqv f\nh\u2081 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b2), mapConst f = (Equiv.map eqv \u2218 Function.const \u03b1) f\nthis : F = Equiv.functor eqv\n\u22a2 LawfulFunctor t'",
+              "tactic": "subst this"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact <a>Equiv.lawfulFunctor<\\/a> eqv\"",
+                "[{\"full_name\":\"Equiv.lawfulFunctor\",\"def_path\":\"Mathlib\\/Control\\/Traversable\\/Equiv.lean\",\"def_pos\":[65,19],\"def_end_pos\":[65,32]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "t t' : Type u \u2192 Type u\neqv : (\u03b1 : Type u) \u2192 t \u03b1 \u2243 t' \u03b1\ninst\u271d\u00b9 : Functor t\ninst\u271d : LawfulFunctor t\nh\u2080 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 \u03b2), map f = Equiv.map eqv f\nh\u2081 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b2), mapConst f = (Equiv.map eqv \u2218 Function.const \u03b1) f\n\u22a2 LawfulFunctor t'",
+              "tactic": "exact Equiv.lawfulFunctor eqv"
+            },
+            {
+              "annotated_tactic": [
+                "\"cases F\"",
+                "[]"
+              ],
+              "state_after": "case mk\nt t' : Type u \u2192 Type u\neqv : (\u03b1 : Type u) \u2192 t \u03b1 \u2243 t' \u03b1\ninst\u271d\u00b9 : Functor t\ninst\u271d : LawfulFunctor t\nmap\u271d : {\u03b1 \u03b2 : Type u} \u2192 (\u03b1 \u2192 \u03b2) \u2192 t' \u03b1 \u2192 t' \u03b2\nmapConst\u271d : {\u03b1 \u03b2 : Type u} \u2192 \u03b1 \u2192 t' \u03b2 \u2192 t' \u03b1\nh\u2080 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 \u03b2), map f = Equiv.map eqv f\nh\u2081 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b2), mapConst f = (Equiv.map eqv \u2218 Function.const \u03b1) f\n\u22a2 { map := map\u271d, mapConst := mapConst\u271d } = Equiv.functor eqv",
+              "state_before": "t t' : Type u \u2192 Type u\neqv : (\u03b1 : Type u) \u2192 t \u03b1 \u2243 t' \u03b1\ninst\u271d\u00b9 : Functor t\ninst\u271d : LawfulFunctor t\nF : Functor t'\nh\u2080 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 \u03b2), map f = Equiv.map eqv f\nh\u2081 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b2), mapConst f = (Equiv.map eqv \u2218 Function.const \u03b1) f\n\u22a2 F = Equiv.functor eqv",
+              "tactic": "cases F"
+            },
+            {
+              "annotated_tactic": [
+                "\"dsimp [<a>Equiv.functor<\\/a>]\"",
+                "[{\"full_name\":\"Equiv.functor\",\"def_path\":\"Mathlib\\/Control\\/Traversable\\/Equiv.lean\",\"def_pos\":[50,15],\"def_end_pos\":[50,22]}]"
+              ],
+              "state_after": "case mk\nt t' : Type u \u2192 Type u\neqv : (\u03b1 : Type u) \u2192 t \u03b1 \u2243 t' \u03b1\ninst\u271d\u00b9 : Functor t\ninst\u271d : LawfulFunctor t\nmap\u271d : {\u03b1 \u03b2 : Type u} \u2192 (\u03b1 \u2192 \u03b2) \u2192 t' \u03b1 \u2192 t' \u03b2\nmapConst\u271d : {\u03b1 \u03b2 : Type u} \u2192 \u03b1 \u2192 t' \u03b2 \u2192 t' \u03b1\nh\u2080 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 \u03b2), map f = Equiv.map eqv f\nh\u2081 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b2), mapConst f = (Equiv.map eqv \u2218 Function.const \u03b1) f\n\u22a2 { map := map\u271d, mapConst := mapConst\u271d } =\n    { map := fun {\u03b1 \u03b2} => Equiv.map eqv, mapConst := fun {\u03b1 \u03b2} => Equiv.map eqv \u2218 Function.const \u03b2 }",
+              "state_before": "case mk\nt t' : Type u \u2192 Type u\neqv : (\u03b1 : Type u) \u2192 t \u03b1 \u2243 t' \u03b1\ninst\u271d\u00b9 : Functor t\ninst\u271d : LawfulFunctor t\nmap\u271d : {\u03b1 \u03b2 : Type u} \u2192 (\u03b1 \u2192 \u03b2) \u2192 t' \u03b1 \u2192 t' \u03b2\nmapConst\u271d : {\u03b1 \u03b2 : Type u} \u2192 \u03b1 \u2192 t' \u03b2 \u2192 t' \u03b1\nh\u2080 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 \u03b2), map f = Equiv.map eqv f\nh\u2081 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b2), mapConst f = (Equiv.map eqv \u2218 Function.const \u03b1) f\n\u22a2 { map := map\u271d, mapConst := mapConst\u271d } = Equiv.functor eqv",
+              "tactic": "dsimp [Equiv.functor]"
+            },
+            {
+              "annotated_tactic": [
+                "\"congr <;> ext <;> dsimp only <;> [rw [\\u2190 h\\u2080]; rw [\\u2190 h\\u2081]] <;> rfl\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case mk\nt t' : Type u \u2192 Type u\neqv : (\u03b1 : Type u) \u2192 t \u03b1 \u2243 t' \u03b1\ninst\u271d\u00b9 : Functor t\ninst\u271d : LawfulFunctor t\nmap\u271d : {\u03b1 \u03b2 : Type u} \u2192 (\u03b1 \u2192 \u03b2) \u2192 t' \u03b1 \u2192 t' \u03b2\nmapConst\u271d : {\u03b1 \u03b2 : Type u} \u2192 \u03b1 \u2192 t' \u03b2 \u2192 t' \u03b1\nh\u2080 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 \u03b2), map f = Equiv.map eqv f\nh\u2081 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b2), mapConst f = (Equiv.map eqv \u2218 Function.const \u03b1) f\n\u22a2 { map := map\u271d, mapConst := mapConst\u271d } =\n    { map := fun {\u03b1 \u03b2} => Equiv.map eqv, mapConst := fun {\u03b1 \u03b2} => Equiv.map eqv \u2218 Function.const \u03b2 }",
+              "tactic": "congr <;> ext <;> dsimp only <;> [rw [\u2190 h\u2080]; rw [\u2190 h\u2081]] <;> rfl"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/Traversable/Equiv.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Equiv.traverse_def",
+        "id": "Equiv.traverse_def",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            103,
+            6
+          ],
+          "file_path": "Mathlib/Control/Traversable/Equiv.lean",
+          "full_name": "Equiv.traverse_def",
+          "start": [
+            101,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/Traversable/Equiv.lean"
+      }
+    ],
+    "input_proofs": 26,
+    "input_units": 2,
+    "proofs": 11,
+    "published_proofs": 10,
+    "published_transitions": 17,
+    "replay_failures": [],
+    "transitions": 24,
+    "validation_failures": [
+      {
+        "errors": [
+          "internal transition boundary mismatch",
+          "internal transition boundary mismatch",
+          "internal transition boundary mismatch"
+        ],
+        "file_path": "Mathlib/Control/Traversable/Equiv.lean",
+        "proof_id": "mathlib:Equiv.isLawfulTraversable'",
+        "provenance": {
+          "selection": {
+            "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+            "end": [
+              180,
+              59
+            ],
+            "file_path": "Mathlib/Control/Traversable/Equiv.lean",
+            "full_name": "Equiv.isLawfulTraversable'",
+            "start": [
+              168,
+              11
+            ],
+            "traced_tactics": [
+              {
+                "annotated_tactic": [
+                  "\"rw [h\\u2082, <a>Equiv.id_traverse<\\/a>]\"",
+                  "[{\"full_name\":\"Equiv.id_traverse\",\"def_path\":\"Mathlib\\/Control\\/Traversable\\/Equiv.lean\",\"def_pos\":[129,19],\"def_end_pos\":[129,30]}]"
+                ],
+                "state_after": "no goals",
+                "state_before": "t t' : Type u \u2192 Type u\neqv : (\u03b1 : Type u) \u2192 t \u03b1 \u2243 t' \u03b1\ninst\u271d\u2076 : Traversable t\ninst\u271d\u2075 : LawfulTraversable t\nF G : Type u \u2192 Type u\ninst\u271d\u2074 : Applicative F\ninst\u271d\u00b3 : Applicative G\ninst\u271d\u00b2 : LawfulApplicative F\ninst\u271d\u00b9 : LawfulApplicative G\n\u03b7 : ApplicativeTransformation F G\n\u03b1 \u03b2 \u03b3 : Type u\ninst\u271d : Traversable t'\nh\u2080 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 \u03b2), map f = Equiv.map eqv f\nh\u2081 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b2), mapConst f = (Equiv.map eqv \u2218 Function.const \u03b1) f\nh\u2082 :\n  \u2200 {F : Type u \u2192 Type u} [inst : Applicative F] [inst_1 : LawfulApplicative F] {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 F \u03b2),\n    traverse f = Equiv.traverse eqv f\n\u03b1\u271d : Type u\nx\u271d : t' \u03b1\u271d\n\u22a2 traverse pure x\u271d = x\u271d",
+                "tactic": "rw [h\u2082, Equiv.id_traverse]"
+              },
+              {
+                "annotated_tactic": [
+                  "\"rw [h\\u2082, <a>Equiv.comp_traverse<\\/a>, h\\u2082]\"",
+                  "[{\"full_name\":\"Equiv.comp_traverse\",\"def_path\":\"Mathlib\\/Control\\/Traversable\\/Equiv.lean\",\"def_pos\":[138,19],\"def_end_pos\":[138,32]}]"
+                ],
+                "state_after": "t t' : Type u \u2192 Type u\neqv : (\u03b1 : Type u) \u2192 t \u03b1 \u2243 t' \u03b1\ninst\u271d\u00b9\u2070 : Traversable t\ninst\u271d\u2079 : LawfulTraversable t\nF G : Type u \u2192 Type u\ninst\u271d\u2078 : Applicative F\ninst\u271d\u2077 : Applicative G\ninst\u271d\u2076 : LawfulApplicative F\ninst\u271d\u2075 : LawfulApplicative G\n\u03b7 : ApplicativeTransformation F G\n\u03b1 \u03b2 \u03b3 : Type u\ninst\u271d\u2074 : Traversable t'\nh\u2080 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 \u03b2), map f = Equiv.map eqv f\nh\u2081 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b2), mapConst f = (Equiv.map eqv \u2218 Function.const \u03b1) f\nh\u2082 :\n  \u2200 {F : Type u \u2192 Type u} [inst : Applicative F] [inst_1 : LawfulApplicative F] {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 F \u03b2),\n    traverse f = Equiv.traverse eqv f\nF\u271d G\u271d : Type u \u2192 Type u\ninst\u271d\u00b3 : Applicative F\u271d\ninst\u271d\u00b2 : Applicative G\u271d\ninst\u271d\u00b9 : LawfulApplicative F\u271d\ninst\u271d : LawfulApplicative G\u271d\n\u03b1\u271d \u03b2\u271d \u03b3\u271d : Type u\nx\u271d\u00b2 : \u03b2\u271d \u2192 F\u271d \u03b3\u271d\nx\u271d\u00b9 : \u03b1\u271d \u2192 G\u271d \u03b2\u271d\nx\u271d : t' \u03b1\u271d\n\u22a2 Comp.mk (Equiv.traverse eqv x\u271d\u00b2 <$> Equiv.traverse eqv x\u271d\u00b9 x\u271d) = Comp.mk (Equiv.traverse eqv x\u271d\u00b2 <$> traverse x\u271d\u00b9 x\u271d)",
+                "state_before": "t t' : Type u \u2192 Type u\neqv : (\u03b1 : Type u) \u2192 t \u03b1 \u2243 t' \u03b1\ninst\u271d\u00b9\u2070 : Traversable t\ninst\u271d\u2079 : LawfulTraversable t\nF G : Type u \u2192 Type u\ninst\u271d\u2078 : Applicative F\ninst\u271d\u2077 : Applicative G\ninst\u271d\u2076 : LawfulApplicative F\ninst\u271d\u2075 : LawfulApplicative G\n\u03b7 : ApplicativeTransformation F G\n\u03b1 \u03b2 \u03b3 : Type u\ninst\u271d\u2074 : Traversable t'\nh\u2080 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 \u03b2), map f = Equiv.map eqv f\nh\u2081 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b2), mapConst f = (Equiv.map eqv \u2218 Function.const \u03b1) f\nh\u2082 :\n  \u2200 {F : Type u \u2192 Type u} [inst : Applicative F] [inst_1 : LawfulApplicative F] {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 F \u03b2),\n    traverse f = Equiv.traverse eqv f\nF\u271d G\u271d : Type u \u2192 Type u\ninst\u271d\u00b3 : Applicative F\u271d\ninst\u271d\u00b2 : Applicative G\u271d\ninst\u271d\u00b9 : LawfulApplicative F\u271d\ninst\u271d : LawfulApplicative G\u271d\n\u03b1\u271d \u03b2\u271d \u03b3\u271d : Type u\nx\u271d\u00b2 : \u03b2\u271d \u2192 F\u271d \u03b3\u271d\nx\u271d\u00b9 : \u03b1\u271d \u2192 G\u271d \u03b2\u271d\nx\u271d : t' \u03b1\u271d\n\u22a2 traverse (Comp.mk \u2218 map x\u271d\u00b2 \u2218 x\u271d\u00b9) x\u271d = Comp.mk (traverse x\u271d\u00b2 <$> traverse x\u271d\u00b9 x\u271d)",
+                "tactic": "rw [h\u2082, Equiv.comp_traverse, h\u2082]"
+              },
+              {
+                "annotated_tactic": [
+                  "\"congr\"",
+                  "[]"
+                ],
+                "state_after": "case e_x.e_a\nt t' : Type u \u2192 Type u\neqv : (\u03b1 : Type u) \u2192 t \u03b1 \u2243 t' \u03b1\ninst\u271d\u00b9\u2070 : Traversable t\ninst\u271d\u2079 : LawfulTraversable t\nF G : Type u \u2192 Type u\ninst\u271d\u2078 : Applicative F\ninst\u271d\u2077 : Applicative G\ninst\u271d\u2076 : LawfulApplicative F\ninst\u271d\u2075 : LawfulApplicative G\n\u03b7 : ApplicativeTransformation F G\n\u03b1 \u03b2 \u03b3 : Type u\ninst\u271d\u2074 : Traversable t'\nh\u2080 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 \u03b2), map f = Equiv.map eqv f\nh\u2081 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b2), mapConst f = (Equiv.map eqv \u2218 Function.const \u03b1) f\nh\u2082 :\n  \u2200 {F : Type u \u2192 Type u} [inst : Applicative F] [inst_1 : LawfulApplicative F] {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 F \u03b2),\n    traverse f = Equiv.traverse eqv f\nF\u271d G\u271d : Type u \u2192 Type u\ninst\u271d\u00b3 : Applicative F\u271d\ninst\u271d\u00b2 : Applicative G\u271d\ninst\u271d\u00b9 : LawfulApplicative F\u271d\ninst\u271d : LawfulApplicative G\u271d\n\u03b1\u271d \u03b2\u271d \u03b3\u271d : Type u\nx\u271d\u00b2 : \u03b2\u271d \u2192 F\u271d \u03b3\u271d\nx\u271d\u00b9 : \u03b1\u271d \u2192 G\u271d \u03b2\u271d\nx\u271d : t' \u03b1\u271d\n\u22a2 Equiv.traverse eqv x\u271d\u00b9 x\u271d = traverse x\u271d\u00b9 x\u271d",
+                "state_before": "t t' : Type u \u2192 Type u\neqv : (\u03b1 : Type u) \u2192 t \u03b1 \u2243 t' \u03b1\ninst\u271d\u00b9\u2070 : Traversable t\ninst\u271d\u2079 : LawfulTraversable t\nF G : Type u \u2192 Type u\ninst\u271d\u2078 : Applicative F\ninst\u271d\u2077 : Applicative G\ninst\u271d\u2076 : LawfulApplicative F\ninst\u271d\u2075 : LawfulApplicative G\n\u03b7 : ApplicativeTransformation F G\n\u03b1 \u03b2 \u03b3 : Type u\ninst\u271d\u2074 : Traversable t'\nh\u2080 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 \u03b2), map f = Equiv.map eqv f\nh\u2081 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b2), mapConst f = (Equiv.map eqv \u2218 Function.const \u03b1) f\nh\u2082 :\n  \u2200 {F : Type u \u2192 Type u} [inst : Applicative F] [inst_1 : LawfulApplicative F] {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 F \u03b2),\n    traverse f = Equiv.traverse eqv f\nF\u271d G\u271d : Type u \u2192 Type u\ninst\u271d\u00b3 : Applicative F\u271d\ninst\u271d\u00b2 : Applicative G\u271d\ninst\u271d\u00b9 : LawfulApplicative F\u271d\ninst\u271d : LawfulApplicative G\u271d\n\u03b1\u271d \u03b2\u271d \u03b3\u271d : Type u\nx\u271d\u00b2 : \u03b2\u271d \u2192 F\u271d \u03b3\u271d\nx\u271d\u00b9 : \u03b1\u271d \u2192 G\u271d \u03b2\u271d\nx\u271d : t' \u03b1\u271d\n\u22a2 Comp.mk (Equiv.traverse eqv x\u271d\u00b2 <$> Equiv.traverse eqv x\u271d\u00b9 x\u271d) = Comp.mk (Equiv.traverse eqv x\u271d\u00b2 <$> traverse x\u271d\u00b9 x\u271d)",
+                "tactic": "congr"
+              },
+              {
+                "annotated_tactic": [
+                  "\"rw [h\\u2082]\"",
+                  "[]"
+                ],
+                "state_after": "no goals",
+                "state_before": "case e_x.e_a\nt t' : Type u \u2192 Type u\neqv : (\u03b1 : Type u) \u2192 t \u03b1 \u2243 t' \u03b1\ninst\u271d\u00b9\u2070 : Traversable t\ninst\u271d\u2079 : LawfulTraversable t\nF G : Type u \u2192 Type u\ninst\u271d\u2078 : Applicative F\ninst\u271d\u2077 : Applicative G\ninst\u271d\u2076 : LawfulApplicative F\ninst\u271d\u2075 : LawfulApplicative G\n\u03b7 : ApplicativeTransformation F G\n\u03b1 \u03b2 \u03b3 : Type u\ninst\u271d\u2074 : Traversable t'\nh\u2080 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 \u03b2), map f = Equiv.map eqv f\nh\u2081 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b2), mapConst f = (Equiv.map eqv \u2218 Function.const \u03b1) f\nh\u2082 :\n  \u2200 {F : Type u \u2192 Type u} [inst : Applicative F] [inst_1 : LawfulApplicative F] {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 F \u03b2),\n    traverse f = Equiv.traverse eqv f\nF\u271d G\u271d : Type u \u2192 Type u\ninst\u271d\u00b3 : Applicative F\u271d\ninst\u271d\u00b2 : Applicative G\u271d\ninst\u271d\u00b9 : LawfulApplicative F\u271d\ninst\u271d : LawfulApplicative G\u271d\n\u03b1\u271d \u03b2\u271d \u03b3\u271d : Type u\nx\u271d\u00b2 : \u03b2\u271d \u2192 F\u271d \u03b3\u271d\nx\u271d\u00b9 : \u03b1\u271d \u2192 G\u271d \u03b2\u271d\nx\u271d : t' \u03b1\u271d\n\u22a2 Equiv.traverse eqv x\u271d\u00b9 x\u271d = traverse x\u271d\u00b9 x\u271d",
+                "tactic": "rw [h\u2082]"
+              },
+              {
+                "annotated_tactic": [
+                  "\"rw [h\\u2082, <a>Equiv.traverse_eq_map_id<\\/a>, h\\u2080]\"",
+                  "[{\"full_name\":\"Equiv.traverse_eq_map_id\",\"def_path\":\"Mathlib\\/Control\\/Traversable\\/Equiv.lean\",\"def_pos\":[133,19],\"def_end_pos\":[133,37]}]"
+                ],
+                "state_after": "t t' : Type u \u2192 Type u\neqv : (\u03b1 : Type u) \u2192 t \u03b1 \u2243 t' \u03b1\ninst\u271d\u2076 : Traversable t\ninst\u271d\u2075 : LawfulTraversable t\nF G : Type u \u2192 Type u\ninst\u271d\u2074 : Applicative F\ninst\u271d\u00b3 : Applicative G\ninst\u271d\u00b2 : LawfulApplicative F\ninst\u271d\u00b9 : LawfulApplicative G\n\u03b7 : ApplicativeTransformation F G\n\u03b1 \u03b2 \u03b3 : Type u\ninst\u271d : Traversable t'\nh\u2080 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 \u03b2), map f = Equiv.map eqv f\nh\u2081 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b2), mapConst f = (Equiv.map eqv \u2218 Function.const \u03b1) f\nh\u2082 :\n  \u2200 {F : Type u \u2192 Type u} [inst : Applicative F] [inst_1 : LawfulApplicative F] {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 F \u03b2),\n    traverse f = Equiv.traverse eqv f\n\u03b1\u271d \u03b2\u271d : Type u\nx\u271d\u00b9 : \u03b1\u271d \u2192 \u03b2\u271d\nx\u271d : t' \u03b1\u271d\n\u22a2 pure (Equiv.map eqv x\u271d\u00b9 x\u271d) = id.mk (Equiv.map eqv x\u271d\u00b9 x\u271d)",
+                "state_before": "t t' : Type u \u2192 Type u\neqv : (\u03b1 : Type u) \u2192 t \u03b1 \u2243 t' \u03b1\ninst\u271d\u2076 : Traversable t\ninst\u271d\u2075 : LawfulTraversable t\nF G : Type u \u2192 Type u\ninst\u271d\u2074 : Applicative F\ninst\u271d\u00b3 : Applicative G\ninst\u271d\u00b2 : LawfulApplicative F\ninst\u271d\u00b9 : LawfulApplicative G\n\u03b7 : ApplicativeTransformation F G\n\u03b1 \u03b2 \u03b3 : Type u\ninst\u271d : Traversable t'\nh\u2080 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 \u03b2), map f = Equiv.map eqv f\nh\u2081 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b2), mapConst f = (Equiv.map eqv \u2218 Function.const \u03b1) f\nh\u2082 :\n  \u2200 {F : Type u \u2192 Type u} [inst : Applicative F] [inst_1 : LawfulApplicative F] {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 F \u03b2),\n    traverse f = Equiv.traverse eqv f\n\u03b1\u271d \u03b2\u271d : Type u\nx\u271d\u00b9 : \u03b1\u271d \u2192 \u03b2\u271d\nx\u271d : t' \u03b1\u271d\n\u22a2 traverse (pure \u2218 x\u271d\u00b9) x\u271d = id.mk (x\u271d\u00b9 <$> x\u271d)",
+                "tactic": "rw [h\u2082, Equiv.traverse_eq_map_id, h\u2080]"
+              },
+              {
+                "annotated_tactic": [
+                  "\"rfl\"",
+                  "[]"
+                ],
+                "state_after": "no goals",
+                "state_before": "t t' : Type u \u2192 Type u\neqv : (\u03b1 : Type u) \u2192 t \u03b1 \u2243 t' \u03b1\ninst\u271d\u2076 : Traversable t\ninst\u271d\u2075 : LawfulTraversable t\nF G : Type u \u2192 Type u\ninst\u271d\u2074 : Applicative F\ninst\u271d\u00b3 : Applicative G\ninst\u271d\u00b2 : LawfulApplicative F\ninst\u271d\u00b9 : LawfulApplicative G\n\u03b7 : ApplicativeTransformation F G\n\u03b1 \u03b2 \u03b3 : Type u\ninst\u271d : Traversable t'\nh\u2080 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 \u03b2), map f = Equiv.map eqv f\nh\u2081 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b2), mapConst f = (Equiv.map eqv \u2218 Function.const \u03b1) f\nh\u2082 :\n  \u2200 {F : Type u \u2192 Type u} [inst : Applicative F] [inst_1 : LawfulApplicative F] {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 F \u03b2),\n    traverse f = Equiv.traverse eqv f\n\u03b1\u271d \u03b2\u271d : Type u\nx\u271d\u00b9 : \u03b1\u271d \u2192 \u03b2\u271d\nx\u271d : t' \u03b1\u271d\n\u22a2 pure (Equiv.map eqv x\u271d\u00b9 x\u271d) = id.mk (Equiv.map eqv x\u271d\u00b9 x\u271d)",
+                "tactic": "rfl"
+              },
+              {
+                "annotated_tactic": [
+                  "\"rw [h\\u2082, <a>Equiv.naturality<\\/a>, h\\u2082]\"",
+                  "[{\"full_name\":\"Equiv.naturality\",\"def_path\":\"Mathlib\\/Control\\/Traversable\\/Equiv.lean\",\"def_pos\":[145,19],\"def_end_pos\":[145,29]}]"
+                ],
+                "state_after": "no goals",
+                "state_before": "t t' : Type u \u2192 Type u\neqv : (\u03b1 : Type u) \u2192 t \u03b1 \u2243 t' \u03b1\ninst\u271d\u00b9\u2070 : Traversable t\ninst\u271d\u2079 : LawfulTraversable t\nF G : Type u \u2192 Type u\ninst\u271d\u2078 : Applicative F\ninst\u271d\u2077 : Applicative G\ninst\u271d\u2076 : LawfulApplicative F\ninst\u271d\u2075 : LawfulApplicative G\n\u03b7 : ApplicativeTransformation F G\n\u03b1 \u03b2 \u03b3 : Type u\ninst\u271d\u2074 : Traversable t'\nh\u2080 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 \u03b2), map f = Equiv.map eqv f\nh\u2081 : \u2200 {\u03b1 \u03b2 : Type u} (f : \u03b2), mapConst f = (Equiv.map eqv \u2218 Function.const \u03b1) f\nh\u2082 :\n  \u2200 {F : Type u \u2192 Type u} [inst : Applicative F] [inst_1 : LawfulApplicative F] {\u03b1 \u03b2 : Type u} (f : \u03b1 \u2192 F \u03b2),\n    traverse f = Equiv.traverse eqv f\nF\u271d G\u271d : Type u \u2192 Type u\ninst\u271d\u00b3 : Applicative F\u271d\ninst\u271d\u00b2 : Applicative G\u271d\ninst\u271d\u00b9 : LawfulApplicative F\u271d\ninst\u271d : LawfulApplicative G\u271d\nx\u271d\u2074 : ApplicativeTransformation F\u271d G\u271d\nx\u271d\u00b3 x\u271d\u00b2 : Type u\nx\u271d\u00b9 : x\u271d\u00b3 \u2192 F\u271d x\u271d\u00b2\nx\u271d : t' x\u271d\u00b3\n\u22a2 (fun {\u03b1} => x\u271d\u2074.app \u03b1) (traverse x\u271d\u00b9 x\u271d) = traverse ((fun {\u03b1} => x\u271d\u2074.app \u03b1) \u2218 x\u271d\u00b9) x\u271d",
+                "tactic": "rw [h\u2082, Equiv.naturality, h\u2082]"
+              }
+            ],
+            "url": "https://github.com/leanprover-community/mathlib4"
+          }
+        },
+        "theorem_name": "Equiv.isLawfulTraversable'"
+      }
+    ],
+    "validation_rejected_proofs": 1,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/mathlib-000870-0000-5b67fb70f25af816.parquet",
+      "sha256": "5b67fb70f25af816364ba4751ed5e62f042dd36b1ef443ce43372b61efc820a1",
+      "bytes": 72480,
+      "rows": 14,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    },
+    {
+      "path": "data/internal_test/mathlib-000870-0000-4553cbf7af452dce.parquet",
+      "sha256": "4553cbf7af452dce627e15c88617cf3bc96a7dbbd8a6d8a942717c9ab83ef0ce",
+      "bytes": 53571,
+      "rows": 3,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    }
+  ],
+  "proof_ids": [
+    "mathlib:ApplicativeTransformation.coe_inj",
+    "mathlib:ApplicativeTransformation.ext",
+    "mathlib:ApplicativeTransformation.preserves_map",
+    "mathlib:ApplicativeTransformation.preserves_map'",
+    "mathlib:Equiv.comp_map",
+    "mathlib:Equiv.comp_traverse",
+    "mathlib:Equiv.id_map",
+    "mathlib:Equiv.id_traverse",
+    "mathlib:Equiv.naturality",
+    "mathlib:Equiv.traverse_eq_map_id"
+  ],
+  "proof_keys": [
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Basic.lean\",null,null,\"ApplicativeTransformation.coe_inj\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Basic.lean\",null,null,\"ApplicativeTransformation.ext\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Basic.lean\",null,null,\"ApplicativeTransformation.preserves_map\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Basic.lean\",null,null,\"ApplicativeTransformation.preserves_map'\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Equiv.lean\",null,null,\"Equiv.comp_map\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Equiv.lean\",null,null,\"Equiv.comp_traverse\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Equiv.lean\",null,null,\"Equiv.id_map\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Equiv.lean\",null,null,\"Equiv.id_traverse\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Equiv.lean\",null,null,\"Equiv.naturality\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Equiv.lean\",null,null,\"Equiv.traverse_eq_map_id\"]"
+  ]
+}

manifests/batches/mathlib/000871.json

@@ -0,0 +1,287 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "mathlib/000871",
+  "batch_fingerprint": "1e992fd5cd16861e09bfebb8270f2131bf148552e66a9ecf76bd52a8dbab11d9",
+  "evidence": {
+    "batch_fingerprint": "1e992fd5cd16861e09bfebb8270f2131bf148552e66a9ecf76bd52a8dbab11d9",
+    "contamination_matches": [],
+    "failures": [
+      {
+        "error": "no internal trace for tactic 'simp'",
+        "full_name": "List.mem_traverse",
+        "id": "List.mem_traverse",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            136,
+            53
+          ],
+          "file_path": "Mathlib/Control/Traversable/Instances.lean",
+          "full_name": "List.mem_traverse",
+          "start": [
+            131,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"simp\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "F G : Type u \u2192 Type u\ninst\u271d\u00b2 : Applicative F\ninst\u271d\u00b9 : Applicative G\n\u03b1' \u03b2' : Type u\nf\u271d : \u03b1' \u2192 F \u03b2'\ninst\u271d : LawfulApplicative F\nf : \u03b1' \u2192 Set \u03b2'\n\u22a2 [] \u2208 traverse f [] \u2194 Forall\u2082 (fun b a => b \u2208 f a) [] []",
+              "tactic": "simp"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "F G : Type u \u2192 Type u\ninst\u271d\u00b2 : Applicative F\ninst\u271d\u00b9 : Applicative G\n\u03b1' \u03b2' : Type u\nf\u271d : \u03b1' \u2192 F \u03b2'\ninst\u271d : LawfulApplicative F\nf : \u03b1' \u2192 Set \u03b2'\na : \u03b1'\nas : List \u03b1'\n\u22a2 [] \u2208 traverse f (a :: as) \u2194 Forall\u2082 (fun b a => b \u2208 f a) [] (a :: as)",
+              "tactic": "simp"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "F G : Type u \u2192 Type u\ninst\u271d\u00b2 : Applicative F\ninst\u271d\u00b9 : Applicative G\n\u03b1' \u03b2' : Type u\nf\u271d : \u03b1' \u2192 F \u03b2'\ninst\u271d : LawfulApplicative F\nf : \u03b1' \u2192 Set \u03b2'\nb : \u03b2'\nbs : List \u03b2'\n\u22a2 b :: bs \u2208 traverse f [] \u2194 Forall\u2082 (fun b a => b \u2208 f a) (b :: bs) []",
+              "tactic": "simp"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp [mem_traverse as bs]\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "F G : Type u \u2192 Type u\ninst\u271d\u00b2 : Applicative F\ninst\u271d\u00b9 : Applicative G\n\u03b1' \u03b2' : Type u\nf\u271d : \u03b1' \u2192 F \u03b2'\ninst\u271d : LawfulApplicative F\nf : \u03b1' \u2192 Set \u03b2'\na : \u03b1'\nas : List \u03b1'\nb : \u03b2'\nbs : List \u03b2'\n\u22a2 b :: bs \u2208 traverse f (a :: as) \u2194 Forall\u2082 (fun b a => b \u2208 f a) (b :: bs) (a :: as)",
+              "tactic": "simp [mem_traverse as bs]"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/Traversable/Instances.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "List.traverse_cons",
+        "id": "List.traverse_cons",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            119,
+            6
+          ],
+          "file_path": "Mathlib/Control/Traversable/Instances.lean",
+          "full_name": "List.traverse_cons",
+          "start": [
+            117,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/Traversable/Instances.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "List.traverse_nil",
+        "id": "List.traverse_nil",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            113,
+            6
+          ],
+          "file_path": "Mathlib/Control/Traversable/Instances.lean",
+          "full_name": "List.traverse_nil",
+          "start": [
+            112,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/Traversable/Instances.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Traversable.map_eq_traverse_id",
+        "id": "Traversable.map_eq_traverse_id",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            67,
+            48
+          ],
+          "file_path": "Mathlib/Control/Traversable/Lemmas.lean",
+          "full_name": "Traversable.map_eq_traverse_id",
+          "start": [
+            66,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/Traversable/Lemmas.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Traversable.pureTransformation_apply",
+        "id": "Traversable.pureTransformation_apply",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            60,
+            6
+          ],
+          "file_path": "Mathlib/Control/Traversable/Lemmas.lean",
+          "full_name": "Traversable.pureTransformation_apply",
+          "start": [
+            59,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/Traversable/Lemmas.lean"
+      }
+    ],
+    "input_proofs": 32,
+    "input_units": 2,
+    "proofs": 27,
+    "published_proofs": 26,
+    "published_transitions": 43,
+    "replay_failures": [],
+    "transitions": 46,
+    "validation_failures": [
+      {
+        "errors": [
+          "internal transition boundary mismatch"
+        ],
+        "file_path": "Mathlib/Control/Traversable/Instances.lean",
+        "proof_id": "mathlib:List.traverse_append",
+        "provenance": {
+          "selection": {
+            "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+            "end": [
+              128,
+              72
+            ],
+            "file_path": "Mathlib/Control/Traversable/Instances.lean",
+            "full_name": "List.traverse_append",
+            "start": [
+              125,
+              1
+            ],
+            "traced_tactics": [
+              {
+                "annotated_tactic": [
+                  "\"simp [functor_norm]\"",
+                  "[]"
+                ],
+                "state_after": "no goals",
+                "state_before": "F G : Type u \u2192 Type u\ninst\u271d\u00b2 : Applicative F\ninst\u271d\u00b9 : Applicative G\n\u03b1' \u03b2' : Type u\nf : \u03b1' \u2192 F \u03b2'\ninst\u271d : LawfulApplicative F\nbs : List \u03b1'\n\u22a2 traverse f ([] ++ bs) = Seq.seq ((fun x x_1 => x ++ x_1) <$> traverse f []) fun x => traverse f bs",
+                "tactic": "simp [functor_norm]"
+              },
+              {
+                "annotated_tactic": [
+                  "\"simp [traverse_append as bs, functor_norm]\"",
+                  "[]"
+                ],
+                "state_after": "F G : Type u \u2192 Type u\ninst\u271d\u00b2 : Applicative F\ninst\u271d\u00b9 : Applicative G\n\u03b1' \u03b2' : Type u\nf : \u03b1' \u2192 F \u03b2'\ninst\u271d : LawfulApplicative F\na : \u03b1'\nas bs : List \u03b1'\n\u22a2 (Seq.seq\n      (Seq.seq (((fun x => x \u2218 fun x x_1 => x ++ x_1) \u2218 Function.comp \u2218 fun x x_1 => x :: x_1) <$> f a) fun x =>\n        traverse f as)\n      fun x => traverse f bs) =\n    Seq.seq (Seq.seq (((fun x => (fun x x_1 => x ++ x_1) \u2218 x) \u2218 fun x x_1 => x :: x_1) <$> f a) fun x => traverse f as)\n      fun x => traverse f bs",
+                "state_before": "F G : Type u \u2192 Type u\ninst\u271d\u00b2 : Applicative F\ninst\u271d\u00b9 : Applicative G\n\u03b1' \u03b2' : Type u\nf : \u03b1' \u2192 F \u03b2'\ninst\u271d : LawfulApplicative F\na : \u03b1'\nas bs : List \u03b1'\n\u22a2 traverse f (a :: as ++ bs) = Seq.seq ((fun x x_1 => x ++ x_1) <$> traverse f (a :: as)) fun x => traverse f bs",
+                "tactic": "simp [traverse_append as bs, functor_norm]"
+              },
+              {
+                "annotated_tactic": [
+                  "\"congr\"",
+                  "[]"
+                ],
+                "state_after": "no goals",
+                "state_before": "F G : Type u \u2192 Type u\ninst\u271d\u00b2 : Applicative F\ninst\u271d\u00b9 : Applicative G\n\u03b1' \u03b2' : Type u\nf : \u03b1' \u2192 F \u03b2'\ninst\u271d : LawfulApplicative F\na : \u03b1'\nas bs : List \u03b1'\n\u22a2 (Seq.seq\n      (Seq.seq (((fun x => x \u2218 fun x x_1 => x ++ x_1) \u2218 Function.comp \u2218 fun x x_1 => x :: x_1) <$> f a) fun x =>\n        traverse f as)\n      fun x => traverse f bs) =\n    Seq.seq (Seq.seq (((fun x => (fun x x_1 => x ++ x_1) \u2218 x) \u2218 fun x x_1 => x :: x_1) <$> f a) fun x => traverse f as)\n      fun x => traverse f bs",
+                "tactic": "congr"
+              }
+            ],
+            "url": "https://github.com/leanprover-community/mathlib4"
+          }
+        },
+        "theorem_name": "List.traverse_append"
+      }
+    ],
+    "validation_rejected_proofs": 1,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/mathlib-000871-0000-dece65e10cd016cf.parquet",
+      "sha256": "dece65e10cd016cf4d49ef27dd63cfc633999780d23736efb15790f9518d3a4c",
+      "bytes": 179869,
+      "rows": 43,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    }
+  ],
+  "proof_ids": [
+    "mathlib:List.comp_traverse",
+    "mathlib:List.id_traverse",
+    "mathlib:List.naturality",
+    "mathlib:List.traverse_eq_map_id",
+    "mathlib:Option.comp_traverse",
+    "mathlib:Option.id_traverse",
+    "mathlib:Option.naturality",
+    "mathlib:Option.traverse_eq_map_id",
+    "mathlib:Sum.comp_traverse",
+    "mathlib:Sum.id_traverse",
+    "mathlib:Sum.map_traverse",
+    "mathlib:Sum.naturality",
+    "mathlib:Sum.traverse_eq_map_id",
+    "mathlib:Sum.traverse_map",
+    "mathlib:Traversable.comp_sequence",
+    "mathlib:Traversable.id_sequence",
+    "mathlib:Traversable.map_traverse",
+    "mathlib:Traversable.map_traverse'",
+    "mathlib:Traversable.naturality'",
+    "mathlib:Traversable.naturality_pf",
+    "mathlib:Traversable.pure_traverse",
+    "mathlib:Traversable.traverse_comp",
+    "mathlib:Traversable.traverse_eq_map_id'",
+    "mathlib:Traversable.traverse_id",
+    "mathlib:Traversable.traverse_map",
+    "mathlib:Traversable.traverse_map'"
+  ],
+  "proof_keys": [
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Instances.lean\",null,null,\"List.comp_traverse\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Instances.lean\",null,null,\"List.id_traverse\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Instances.lean\",null,null,\"List.naturality\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Instances.lean\",null,null,\"List.traverse_eq_map_id\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Instances.lean\",null,null,\"Option.comp_traverse\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Instances.lean\",null,null,\"Option.id_traverse\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Instances.lean\",null,null,\"Option.naturality\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Instances.lean\",null,null,\"Option.traverse_eq_map_id\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Instances.lean\",null,null,\"Sum.comp_traverse\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Instances.lean\",null,null,\"Sum.id_traverse\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Instances.lean\",null,null,\"Sum.map_traverse\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Instances.lean\",null,null,\"Sum.naturality\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Instances.lean\",null,null,\"Sum.traverse_eq_map_id\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Instances.lean\",null,null,\"Sum.traverse_map\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Lemmas.lean\",null,null,\"Traversable.comp_sequence\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Lemmas.lean\",null,null,\"Traversable.id_sequence\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Lemmas.lean\",null,null,\"Traversable.map_traverse\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Lemmas.lean\",null,null,\"Traversable.map_traverse'\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Lemmas.lean\",null,null,\"Traversable.naturality'\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Lemmas.lean\",null,null,\"Traversable.naturality_pf\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Lemmas.lean\",null,null,\"Traversable.pure_traverse\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Lemmas.lean\",null,null,\"Traversable.traverse_comp\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Lemmas.lean\",null,null,\"Traversable.traverse_eq_map_id'\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Lemmas.lean\",null,null,\"Traversable.traverse_id\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Lemmas.lean\",null,null,\"Traversable.traverse_map\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Control/Traversable/Lemmas.lean\",null,null,\"Traversable.traverse_map'\"]"
+  ]
+}

manifests/batches/mathlib/000872.json

@@ -0,0 +1,223 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "mathlib/000872",
+  "batch_fingerprint": "ac0e34a98d4118d8199a13b31550fa4f1ef8de46039e2cae6c5a12de0532877d",
+  "evidence": {
+    "batch_fingerprint": "ac0e34a98d4118d8199a13b31550fa4f1ef8de46039e2cae6c5a12de0532877d",
+    "batch_outcome": "all_inputs_failed_with_evidence",
+    "contamination_matches": [],
+    "failures": [
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "PLift.bind_up",
+        "id": "PLift.bind_up",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            54,
+            6
+          ],
+          "file_path": "Mathlib/Control/ULift.lean",
+          "full_name": "PLift.bind_up",
+          "start": [
+            53,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/ULift.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "PLift.map_up",
+        "id": "PLift.map_up",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            28,
+            6
+          ],
+          "file_path": "Mathlib/Control/ULift.lean",
+          "full_name": "PLift.map_up",
+          "start": [
+            27,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/ULift.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "PLift.rec.constant",
+        "id": "PLift.rec.constant",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            84,
+            63
+          ],
+          "file_path": "Mathlib/Control/ULift.lean",
+          "full_name": "PLift.rec.constant",
+          "start": [
+            83,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/ULift.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "PLift.seq_up",
+        "id": "PLift.seq_up",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            44,
+            6
+          ],
+          "file_path": "Mathlib/Control/ULift.lean",
+          "full_name": "PLift.seq_up",
+          "start": [
+            43,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/ULift.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "ULift.map_up",
+        "id": "ULift.map_up",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            98,
+            90
+          ],
+          "file_path": "Mathlib/Control/ULift.lean",
+          "full_name": "ULift.map_up",
+          "start": [
+            98,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/ULift.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "ULift.rec.constant",
+        "id": "ULift.rec.constant",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            154,
+            63
+          ],
+          "file_path": "Mathlib/Control/ULift.lean",
+          "full_name": "ULift.rec.constant",
+          "start": [
+            153,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/ULift.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "ULift.seq_up",
+        "id": "ULift.seq_up",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            114,
+            6
+          ],
+          "file_path": "Mathlib/Control/ULift.lean",
+          "full_name": "ULift.seq_up",
+          "start": [
+            113,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/ULift.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "ULiftable.down_up",
+        "id": "ULiftable.down_up",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            114,
+            48
+          ],
+          "file_path": "Mathlib/Control/ULiftable.lean",
+          "full_name": "ULiftable.down_up",
+          "start": [
+            112,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/ULiftable.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "ULiftable.up_down",
+        "id": "ULiftable.up_down",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            108,
+            49
+          ],
+          "file_path": "Mathlib/Control/ULiftable.lean",
+          "full_name": "ULiftable.up_down",
+          "start": [
+            106,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Control/ULiftable.lean"
+      }
+    ],
+    "input_proofs": 9,
+    "input_units": 2,
+    "proofs": 0,
+    "published_proofs": 0,
+    "published_transitions": 0,
+    "replay_failures": [],
+    "transitions": 0,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [],
+  "proof_ids": [],
+  "proof_keys": []
+}

manifests/batches/mathlib/000873.json

@@ -0,0 +1,596 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "mathlib/000873",
+  "batch_fingerprint": "457612b7522dde210ab5e941ea1222cd212510cc8ad4beb84d2d4bbc0f150478",
+  "evidence": {
+    "batch_fingerprint": "457612b7522dde210ab5e941ea1222cd212510cc8ad4beb84d2d4bbc0f150478",
+    "contamination_matches": [],
+    "failures": [
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CFilter.coe_mk",
+        "id": "CFilter.coe_mk",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            60,
+            6
+          ],
+          "file_path": "Mathlib/Data/Analysis/Filter.lean",
+          "full_name": "CFilter.coe_mk",
+          "start": [
+            59,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Analysis/Filter.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CFilter.mem_toFilter_sets",
+        "id": "CFilter.mem_toFilter_sets",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            92,
+            10
+          ],
+          "file_path": "Mathlib/Data/Analysis/Filter.lean",
+          "full_name": "CFilter.mem_toFilter_sets",
+          "start": [
+            91,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Analysis/Filter.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Filter.Realizer.bot_F",
+        "id": "Filter.Realizer.bot_F",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            205,
+            6
+          ],
+          "file_path": "Mathlib/Data/Analysis/Filter.lean",
+          "full_name": "Filter.Realizer.bot_F",
+          "start": [
+            204,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Analysis/Filter.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Filter.Realizer.bot_\u03c3",
+        "id": "Filter.Realizer.bot_\u03c3",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            200,
+            6
+          ],
+          "file_path": "Mathlib/Data/Analysis/Filter.lean",
+          "full_name": "Filter.Realizer.bot_\u03c3",
+          "start": [
+            199,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Analysis/Filter.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Filter.Realizer.le_iff",
+        "id": "Filter.Realizer.le_iff",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            339,
+            31
+          ],
+          "file_path": "Mathlib/Data/Analysis/Filter.lean",
+          "full_name": "Filter.Realizer.le_iff",
+          "start": [
+            333,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Analysis/Filter.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Filter.Realizer.map_F",
+        "id": "Filter.Realizer.map_F",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            229,
+            6
+          ],
+          "file_path": "Mathlib/Data/Analysis/Filter.lean",
+          "full_name": "Filter.Realizer.map_F",
+          "start": [
+            228,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Analysis/Filter.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Filter.Realizer.map_\u03c3",
+        "id": "Filter.Realizer.map_\u03c3",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            224,
+            6
+          ],
+          "file_path": "Mathlib/Data/Analysis/Filter.lean",
+          "full_name": "Filter.Realizer.map_\u03c3",
+          "start": [
+            223,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Analysis/Filter.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Filter.Realizer.ofEquiv_F",
+        "id": "Filter.Realizer.ofEquiv_F",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            148,
+            46
+          ],
+          "file_path": "Mathlib/Data/Analysis/Filter.lean",
+          "full_name": "Filter.Realizer.ofEquiv_F",
+          "start": [
+            147,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Analysis/Filter.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Filter.Realizer.ofEquiv_\u03c3",
+        "id": "Filter.Realizer.ofEquiv_\u03c3",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            143,
+            6
+          ],
+          "file_path": "Mathlib/Data/Analysis/Filter.lean",
+          "full_name": "Filter.Realizer.ofEquiv_\u03c3",
+          "start": [
+            142,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Analysis/Filter.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Filter.Realizer.principal_F",
+        "id": "Filter.Realizer.principal_F",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            170,
+            6
+          ],
+          "file_path": "Mathlib/Data/Analysis/Filter.lean",
+          "full_name": "Filter.Realizer.principal_F",
+          "start": [
+            169,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Analysis/Filter.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Filter.Realizer.principal_\u03c3",
+        "id": "Filter.Realizer.principal_\u03c3",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            165,
+            6
+          ],
+          "file_path": "Mathlib/Data/Analysis/Filter.lean",
+          "full_name": "Filter.Realizer.principal_\u03c3",
+          "start": [
+            164,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Analysis/Filter.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Filter.Realizer.tendsto_iff",
+        "id": "Filter.Realizer.tendsto_iff",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            344,
+            94
+          ],
+          "file_path": "Mathlib/Data/Analysis/Filter.lean",
+          "full_name": "Filter.Realizer.tendsto_iff",
+          "start": [
+            342,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Analysis/Filter.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Filter.Realizer.top_F",
+        "id": "Filter.Realizer.top_F",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            189,
+            6
+          ],
+          "file_path": "Mathlib/Data/Analysis/Filter.lean",
+          "full_name": "Filter.Realizer.top_F",
+          "start": [
+            188,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Analysis/Filter.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Filter.Realizer.top_\u03c3",
+        "id": "Filter.Realizer.top_\u03c3",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            184,
+            6
+          ],
+          "file_path": "Mathlib/Data/Analysis/Filter.lean",
+          "full_name": "Filter.Realizer.top_\u03c3",
+          "start": [
+            183,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Analysis/Filter.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Ctop.Realizer.ext",
+        "id": "Ctop.Realizer.ext",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            170,
+            79
+          ],
+          "file_path": "Mathlib/Data/Analysis/Topology.lean",
+          "full_name": "Ctop.Realizer.ext",
+          "start": [
+            168,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Analysis/Topology.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Ctop.Realizer.isOpen_iff",
+        "id": "Ctop.Realizer.isOpen_iff",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            139,
+            68
+          ],
+          "file_path": "Mathlib/Data/Analysis/Topology.lean",
+          "full_name": "Ctop.Realizer.isOpen_iff",
+          "start": [
+            137,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Analysis/Topology.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Ctop.Realizer.mem_interior_iff",
+        "id": "Ctop.Realizer.mem_interior_iff",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            154,
+            45
+          ],
+          "file_path": "Mathlib/Data/Analysis/Topology.lean",
+          "full_name": "Ctop.Realizer.mem_interior_iff",
+          "start": [
+            152,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Analysis/Topology.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Ctop.Realizer.nhds_F",
+        "id": "Ctop.Realizer.nhds_F",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            229,
+            78
+          ],
+          "file_path": "Mathlib/Data/Analysis/Topology.lean",
+          "full_name": "Ctop.Realizer.nhds_F",
+          "start": [
+            229,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Analysis/Topology.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Ctop.Realizer.nhds_\u03c3",
+        "id": "Ctop.Realizer.nhds_\u03c3",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            225,
+            89
+          ],
+          "file_path": "Mathlib/Data/Analysis/Topology.lean",
+          "full_name": "Ctop.Realizer.nhds_\u03c3",
+          "start": [
+            225,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Analysis/Topology.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Ctop.Realizer.ofEquiv_\u03c3",
+        "id": "Ctop.Realizer.ofEquiv_\u03c3",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            200,
+            78
+          ],
+          "file_path": "Mathlib/Data/Analysis/Topology.lean",
+          "full_name": "Ctop.Realizer.ofEquiv_\u03c3",
+          "start": [
+            200,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Analysis/Topology.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Ctop.Realizer.tendsto_nhds_iff",
+        "id": "Ctop.Realizer.tendsto_nhds_iff",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            235,
+            52
+          ],
+          "file_path": "Mathlib/Data/Analysis/Topology.lean",
+          "full_name": "Ctop.Realizer.tendsto_nhds_iff",
+          "start": [
+            233,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Analysis/Topology.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Ctop.coe_mk",
+        "id": "Ctop.coe_mk",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            64,
+            81
+          ],
+          "file_path": "Mathlib/Data/Analysis/Topology.lean",
+          "full_name": "Ctop.coe_mk",
+          "start": [
+            64,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Analysis/Topology.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Ctop.toTopsp_isTopologicalBasis",
+        "id": "Ctop.toTopsp_isTopologicalBasis",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            94,
+            66
+          ],
+          "file_path": "Mathlib/Data/Analysis/Topology.lean",
+          "full_name": "Ctop.toTopsp_isTopologicalBasis",
+          "start": [
+            89,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Analysis/Topology.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "locallyFinite_iff_exists_realizer",
+        "id": "locallyFinite_iff_exists_realizer",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            266,
+            34
+          ],
+          "file_path": "Mathlib/Data/Analysis/Topology.lean",
+          "full_name": "locallyFinite_iff_exists_realizer",
+          "start": [
+            253,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Analysis/Topology.lean"
+      }
+    ],
+    "input_proofs": 34,
+    "input_units": 2,
+    "proofs": 10,
+    "published_proofs": 10,
+    "published_transitions": 23,
+    "replay_failures": [],
+    "transitions": 23,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/mathlib-000873-0000-571700e852bc01c2.parquet",
+      "sha256": "571700e852bc01c246c0206e3db95016d6a4f58e47928983574ef2728d1822d5",
+      "bytes": 72892,
+      "rows": 18,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    },
+    {
+      "path": "data/dev/mathlib-000873-0000-32508f8568b23827.parquet",
+      "sha256": "32508f8568b238275d3cf398fd922be04c43434b2a5f522311d9c6d4e66cf6f0",
+      "bytes": 57124,
+      "rows": 4,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    },
+    {
+      "path": "data/internal_test/mathlib-000873-0000-96a78a5f570da68f.parquet",
+      "sha256": "96a78a5f570da68f27b90bb46e45e64f75c7aa0e35af613fb208371bddf8db08",
+      "bytes": 40951,
+      "rows": 1,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    }
+  ],
+  "proof_ids": [
+    "mathlib:CFilter.ofEquiv_val",
+    "mathlib:Ctop.Realizer.ext'",
+    "mathlib:Ctop.Realizer.isClosed_iff",
+    "mathlib:Ctop.Realizer.isOpen",
+    "mathlib:Ctop.Realizer.is_basis",
+    "mathlib:Ctop.Realizer.mem_nhds",
+    "mathlib:Ctop.Realizer.ofEquiv_F",
+    "mathlib:Ctop.ofEquiv_val",
+    "mathlib:Filter.Realizer.mem_sets",
+    "mathlib:Filter.Realizer.ne_bot_iff"
+  ],
+  "proof_keys": [
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Analysis/Filter.lean\",null,null,\"CFilter.ofEquiv_val\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Analysis/Filter.lean\",null,null,\"Filter.Realizer.mem_sets\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Analysis/Filter.lean\",null,null,\"Filter.Realizer.ne_bot_iff\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Analysis/Topology.lean\",null,null,\"Ctop.Realizer.ext'\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Analysis/Topology.lean\",null,null,\"Ctop.Realizer.isClosed_iff\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Analysis/Topology.lean\",null,null,\"Ctop.Realizer.isOpen\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Analysis/Topology.lean\",null,null,\"Ctop.Realizer.is_basis\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Analysis/Topology.lean\",null,null,\"Ctop.Realizer.mem_nhds\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Analysis/Topology.lean\",null,null,\"Ctop.Realizer.ofEquiv_F\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Analysis/Topology.lean\",null,null,\"Ctop.ofEquiv_val\"]"
+  ]
+}

manifests/batches/mathlib/000874.json

@@ -0,0 +1,395 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "mathlib/000874",
+  "batch_fingerprint": "f9d90137f7bf52a4b3d56cc6462d7cd4d2c7a88fad0c451e491c793a6a0853c7",
+  "evidence": {
+    "batch_fingerprint": "f9d90137f7bf52a4b3d56cc6462d7cd4d2c7a88fad0c451e491c793a6a0853c7",
+    "contamination_matches": [],
+    "failures": [
+      {
+        "error": "no internal trace for tactic 'intro k hi h2'",
+        "full_name": "Array.extract_append_right",
+        "id": "Array.extract_append_right",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            38,
+            10
+          ],
+          "file_path": "Mathlib/Data/Array/ExtractLemmas.lean",
+          "full_name": "Array.extract_append_right",
+          "start": [
+            29,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"apply <a>ext<\\/a>\"",
+                "[{\"full_name\":\"Array.ext\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Array\\/Basic.lean\",\"def_pos\":[614,9],\"def_end_pos\":[614,12]}]"
+              ],
+              "state_after": "case h\u2081\n\u03b1 : Type u_1\na b : Array \u03b1\ni j : Nat\nh : a.size \u2264 i\n\u22a2 ((a ++ b).extract i j).size = (b.extract (i - a.size) (j - a.size)).size\n\ncase h\u2082\n\u03b1 : Type u_1\na b : Array \u03b1\ni j : Nat\nh : a.size \u2264 i\n\u22a2 \u2200 (i_1 : Nat) (hi\u2081 : i_1 < ((a ++ b).extract i j).size) (hi\u2082 : i_1 < (b.extract (i - a.size) (j - a.size)).size),\n    ((a ++ b).extract i j)[i_1] = (b.extract (i - a.size) (j - a.size))[i_1]",
+              "state_before": "\u03b1 : Type u_1\na b : Array \u03b1\ni j : Nat\nh : a.size \u2264 i\n\u22a2 (a ++ b).extract i j = b.extract (i - a.size) (j - a.size)",
+              "tactic": "apply ext"
+            },
+            {
+              "annotated_tactic": [
+                "\"rw [<a>size_extract<\\/a>, <a>size_extract<\\/a>, <a>size_append<\\/a>]\"",
+                "[{\"full_name\":\"Array.size_extract\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Array\\/Lemmas.lean\",\"def_pos\":[843,17],\"def_end_pos\":[843,29]},{\"full_name\":\"Array.size_extract\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Array\\/Lemmas.lean\",\"def_pos\":[843,17],\"def_end_pos\":[843,29]},{\"full_name\":\"Array.size_append\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Array\\/Lemmas.lean\",\"def_pos\":[773,9],\"def_end_pos\":[773,20]}]"
+              ],
+              "state_after": "case h\u2081\n\u03b1 : Type u_1\na b : Array \u03b1\ni j : Nat\nh : a.size \u2264 i\n\u22a2 min j (a.size + b.size) - i = min (j - a.size) b.size - (i - a.size)",
+              "state_before": "case h\u2081\n\u03b1 : Type u_1\na b : Array \u03b1\ni j : Nat\nh : a.size \u2264 i\n\u22a2 ((a ++ b).extract i j).size = (b.extract (i - a.size) (j - a.size)).size",
+              "tactic": "rw [size_extract, size_extract, size_append]"
+            },
+            {
+              "annotated_tactic": [
+                "\"omega\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case h\u2081\n\u03b1 : Type u_1\na b : Array \u03b1\ni j : Nat\nh : a.size \u2264 i\n\u22a2 min j (a.size + b.size) - i = min (j - a.size) b.size - (i - a.size)",
+              "tactic": "omega"
+            },
+            {
+              "annotated_tactic": [
+                "\"intro k hi h2\"",
+                "[]"
+              ],
+              "state_after": "case h\u2082\n\u03b1 : Type u_1\na b : Array \u03b1\ni j : Nat\nh : a.size \u2264 i\nk : Nat\nhi : k < ((a ++ b).extract i j).size\nh2 : k < (b.extract (i - a.size) (j - a.size)).size\n\u22a2 ((a ++ b).extract i j)[k] = (b.extract (i - a.size) (j - a.size))[k]",
+              "state_before": "case h\u2082\n\u03b1 : Type u_1\na b : Array \u03b1\ni j : Nat\nh : a.size \u2264 i\n\u22a2 \u2200 (i_1 : Nat) (hi\u2081 : i_1 < ((a ++ b).extract i j).size) (hi\u2082 : i_1 < (b.extract (i - a.size) (j - a.size)).size),\n    ((a ++ b).extract i j)[i_1] = (b.extract (i - a.size) (j - a.size))[i_1]",
+              "tactic": "intro k hi h2"
+            },
+            {
+              "annotated_tactic": [
+                "\"rw [<a>get_extract<\\/a>, <a>get_extract<\\/a>,\\n      <a>get_append_right<\\/a> (show <a>size<\\/a> a \\u2264 i + k by omega)]\"",
+                "[{\"full_name\":\"Array.get_extract\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Array\\/Lemmas.lean\",\"def_pos\":[908,17],\"def_end_pos\":[908,28]},{\"full_name\":\"Array.get_extract\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Array\\/Lemmas.lean\",\"def_pos\":[908,17],\"def_end_pos\":[908,28]},{\"full_name\":\"Array.get_append_right\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Array\\/Lemmas.lean\",\"def_pos\":[783,9],\"def_end_pos\":[783,25]},{\"full_name\":\"Array.size\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[2586,5],\"def_end_pos\":[2586,15]}]"
+              ],
+              "state_after": "case h\u2082\n\u03b1 : Type u_1\na b : Array \u03b1\ni j : Nat\nh : a.size \u2264 i\nk : Nat\nhi : k < ((a ++ b).extract i j).size\nh2 : k < (b.extract (i - a.size) (j - a.size)).size\n\u22a2 b[i + k - a.size] = b[i - a.size + k]",
+              "state_before": "case h\u2082\n\u03b1 : Type u_1\na b : Array \u03b1\ni j : Nat\nh : a.size \u2264 i\nk : Nat\nhi : k < ((a ++ b).extract i j).size\nh2 : k < (b.extract (i - a.size) (j - a.size)).size\n\u22a2 ((a ++ b).extract i j)[k] = (b.extract (i - a.size) (j - a.size))[k]",
+              "tactic": "rw [get_extract, get_extract,\n  get_append_right (show size a \u2264 i + k by omega)]"
+            },
+            {
+              "annotated_tactic": [
+                "\"congr\"",
+                "[]"
+              ],
+              "state_after": "case h\u2082.e_i\n\u03b1 : Type u_1\na b : Array \u03b1\ni j : Nat\nh : a.size \u2264 i\nk : Nat\nhi : k < ((a ++ b).extract i j).size\nh2 : k < (b.extract (i - a.size) (j - a.size)).size\n\u22a2 i + k - a.size = i - a.size + k",
+              "state_before": "case h\u2082\n\u03b1 : Type u_1\na b : Array \u03b1\ni j : Nat\nh : a.size \u2264 i\nk : Nat\nhi : k < ((a ++ b).extract i j).size\nh2 : k < (b.extract (i - a.size) (j - a.size)).size\n\u22a2 b[i + k - a.size] = b[i - a.size + k]",
+              "tactic": "congr"
+            },
+            {
+              "annotated_tactic": [
+                "\"omega\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case h\u2082.e_i\n\u03b1 : Type u_1\na b : Array \u03b1\ni j : Nat\nh : a.size \u2264 i\nk : Nat\nhi : k < ((a ++ b).extract i j).size\nh2 : k < (b.extract (i - a.size) (j - a.size)).size\n\u22a2 i + k - a.size = i - a.size + k",
+              "tactic": "omega"
+            },
+            {
+              "annotated_tactic": [
+                "\"omega\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "\u03b1 : Type u_1\na b : Array \u03b1\ni j : Nat\nh : a.size \u2264 i\nk : Nat\nhi : k < ((a ++ b).extract i j).size\nh2 : k < (b.extract (i - a.size) (j - a.size)).size\n\u22a2 a.size \u2264 i + k",
+              "tactic": "omega"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Array/ExtractLemmas.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "BitVec.toFin_injective",
+        "id": "BitVec.toFin_injective",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            31,
+            31
+          ],
+          "file_path": "Mathlib/Data/BitVec.lean",
+          "full_name": "BitVec.toFin_injective",
+          "start": [
+            30,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/BitVec.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "BitVec.toFin_nsmul",
+        "id": "BitVec.toFin_nsmul",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            42,
+            79
+          ],
+          "file_path": "Mathlib/Data/BitVec.lean",
+          "full_name": "BitVec.toFin_nsmul",
+          "start": [
+            42,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/BitVec.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "BitVec.toFin_pow",
+        "id": "BitVec.toFin_pow",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            44,
+            79
+          ],
+          "file_path": "Mathlib/Data/BitVec.lean",
+          "full_name": "BitVec.toFin_pow",
+          "start": [
+            44,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/BitVec.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "BitVec.toFin_zsmul",
+        "id": "BitVec.toFin_zsmul",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            43,
+            79
+          ],
+          "file_path": "Mathlib/Data/BitVec.lean",
+          "full_name": "BitVec.toFin_zsmul",
+          "start": [
+            43,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/BitVec.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "BitVec.toNat_injective",
+        "id": "BitVec.toNat_injective",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            28,
+            31
+          ],
+          "file_path": "Mathlib/Data/BitVec.lean",
+          "full_name": "BitVec.toNat_injective",
+          "start": [
+            27,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/BitVec.lean"
+      }
+    ],
+    "input_proofs": 10,
+    "input_units": 2,
+    "proofs": 4,
+    "published_proofs": 2,
+    "published_transitions": 3,
+    "replay_failures": [],
+    "transitions": 13,
+    "validation_failures": [
+      {
+        "errors": [
+          "internal transition boundary mismatch",
+          "internal transition boundary mismatch"
+        ],
+        "file_path": "Mathlib/Data/Array/ExtractLemmas.lean",
+        "proof_id": "mathlib:Array.extract_append_left",
+        "provenance": {
+          "selection": {
+            "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+            "end": [
+              27,
+              51
+            ],
+            "file_path": "Mathlib/Data/Array/ExtractLemmas.lean",
+            "full_name": "Array.extract_append_left",
+            "start": [
+              21,
+              1
+            ],
+            "traced_tactics": [
+              {
+                "annotated_tactic": [
+                  "\"apply <a>ext<\\/a>\"",
+                  "[{\"full_name\":\"Array.ext\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Array\\/Basic.lean\",\"def_pos\":[614,9],\"def_end_pos\":[614,12]}]"
+                ],
+                "state_after": "case h\u2081\n\u03b1 : Type u_1\na b : Array \u03b1\ni j : Nat\nh : j \u2264 a.size\n\u22a2 ((a ++ b).extract i j).size = (a.extract i j).size\n\ncase h\u2082\n\u03b1 : Type u_1\na b : Array \u03b1\ni j : Nat\nh : j \u2264 a.size\n\u22a2 \u2200 (i_1 : Nat) (hi\u2081 : i_1 < ((a ++ b).extract i j).size) (hi\u2082 : i_1 < (a.extract i j).size),\n    ((a ++ b).extract i j)[i_1] = (a.extract i j)[i_1]",
+                "state_before": "\u03b1 : Type u_1\na b : Array \u03b1\ni j : Nat\nh : j \u2264 a.size\n\u22a2 (a ++ b).extract i j = a.extract i j",
+                "tactic": "apply ext"
+              },
+              {
+                "annotated_tactic": [
+                  "\"simp only [<a>size_extract<\\/a>, <a>size_append<\\/a>]\"",
+                  "[{\"full_name\":\"Array.size_extract\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Array\\/Lemmas.lean\",\"def_pos\":[843,17],\"def_end_pos\":[843,29]},{\"full_name\":\"Array.size_append\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Array\\/Lemmas.lean\",\"def_pos\":[773,9],\"def_end_pos\":[773,20]}]"
+                ],
+                "state_after": "case h\u2081\n\u03b1 : Type u_1\na b : Array \u03b1\ni j : Nat\nh : j \u2264 a.size\n\u22a2 min j (a.size + b.size) - i = min j a.size - i",
+                "state_before": "case h\u2081\n\u03b1 : Type u_1\na b : Array \u03b1\ni j : Nat\nh : j \u2264 a.size\n\u22a2 ((a ++ b).extract i j).size = (a.extract i j).size",
+                "tactic": "simp only [size_extract, size_append]"
+              },
+              {
+                "annotated_tactic": [
+                  "\"omega\"",
+                  "[]"
+                ],
+                "state_after": "no goals",
+                "state_before": "case h\u2081\n\u03b1 : Type u_1\na b : Array \u03b1\ni j : Nat\nh : j \u2264 a.size\n\u22a2 min j (a.size + b.size) - i = min j a.size - i",
+                "tactic": "omega"
+              },
+              {
+                "annotated_tactic": [
+                  "\"intro h1 h2 h3\"",
+                  "[]"
+                ],
+                "state_after": "case h\u2082\n\u03b1 : Type u_1\na b : Array \u03b1\ni j : Nat\nh : j \u2264 a.size\nh1 : Nat\nh2 : h1 < ((a ++ b).extract i j).size\nh3 : h1 < (a.extract i j).size\n\u22a2 ((a ++ b).extract i j)[h1] = (a.extract i j)[h1]",
+                "state_before": "case h\u2082\n\u03b1 : Type u_1\na b : Array \u03b1\ni j : Nat\nh : j \u2264 a.size\n\u22a2 \u2200 (i_1 : Nat) (hi\u2081 : i_1 < ((a ++ b).extract i j).size) (hi\u2082 : i_1 < (a.extract i j).size),\n    ((a ++ b).extract i j)[i_1] = (a.extract i j)[i_1]",
+                "tactic": "intro h1 h2 h3"
+              },
+              {
+                "annotated_tactic": [
+                  "\"rw [<a>get_extract<\\/a>, <a>get_append_left<\\/a>, <a>get_extract<\\/a>]\"",
+                  "[{\"full_name\":\"Array.get_extract\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Array\\/Lemmas.lean\",\"def_pos\":[908,17],\"def_end_pos\":[908,28]},{\"full_name\":\"Array.get_append_left\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Array\\/Lemmas.lean\",\"def_pos\":[776,9],\"def_end_pos\":[776,24]},{\"full_name\":\"Array.get_extract\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Array\\/Lemmas.lean\",\"def_pos\":[908,17],\"def_end_pos\":[908,28]}]"
+                ],
+                "state_after": "no goals",
+                "state_before": "case h\u2082\n\u03b1 : Type u_1\na b : Array \u03b1\ni j : Nat\nh : j \u2264 a.size\nh1 : Nat\nh2 : h1 < ((a ++ b).extract i j).size\nh3 : h1 < (a.extract i j).size\n\u22a2 ((a ++ b).extract i j)[h1] = (a.extract i j)[h1]",
+                "tactic": "rw [get_extract, get_append_left, get_extract]"
+              }
+            ],
+            "url": "https://github.com/leanprover-community/mathlib4"
+          }
+        },
+        "theorem_name": "Array.extract_append_left"
+      },
+      {
+        "errors": [
+          "internal transition boundary mismatch",
+          "internal transition boundary mismatch"
+        ],
+        "file_path": "Mathlib/Data/Array/ExtractLemmas.lean",
+        "proof_id": "mathlib:Array.extract_extract",
+        "provenance": {
+          "selection": {
+            "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+            "end": [
+              50,
+              43
+            ],
+            "file_path": "Mathlib/Data/Array/ExtractLemmas.lean",
+            "full_name": "Array.extract_extract",
+            "start": [
+              44,
+              1
+            ],
+            "traced_tactics": [
+              {
+                "annotated_tactic": [
+                  "\"apply <a>ext<\\/a>\"",
+                  "[{\"full_name\":\"Array.ext\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Array\\/Basic.lean\",\"def_pos\":[614,9],\"def_end_pos\":[614,12]}]"
+                ],
+                "state_after": "case h\u2081\n\u03b1 : Type u_1\ns1 e2 e1 s2 : Nat\na : Array \u03b1\nh : s1 + e2 \u2264 e1\n\u22a2 ((a.extract s1 e1).extract s2 e2).size = (a.extract (s1 + s2) (s1 + e2)).size\n\ncase h\u2082\n\u03b1 : Type u_1\ns1 e2 e1 s2 : Nat\na : Array \u03b1\nh : s1 + e2 \u2264 e1\n\u22a2 \u2200 (i : Nat) (hi\u2081 : i < ((a.extract s1 e1).extract s2 e2).size) (hi\u2082 : i < (a.extract (s1 + s2) (s1 + e2)).size),\n    ((a.extract s1 e1).extract s2 e2)[i] = (a.extract (s1 + s2) (s1 + e2))[i]",
+                "state_before": "\u03b1 : Type u_1\ns1 e2 e1 s2 : Nat\na : Array \u03b1\nh : s1 + e2 \u2264 e1\n\u22a2 (a.extract s1 e1).extract s2 e2 = a.extract (s1 + s2) (s1 + e2)",
+                "tactic": "apply ext"
+              },
+              {
+                "annotated_tactic": [
+                  "\"simp only [<a>size_extract<\\/a>]\"",
+                  "[{\"full_name\":\"Array.size_extract\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Array\\/Lemmas.lean\",\"def_pos\":[843,17],\"def_end_pos\":[843,29]}]"
+                ],
+                "state_after": "case h\u2081\n\u03b1 : Type u_1\ns1 e2 e1 s2 : Nat\na : Array \u03b1\nh : s1 + e2 \u2264 e1\n\u22a2 min e2 (min e1 a.size - s1) - s2 = min (s1 + e2) a.size - (s1 + s2)",
+                "state_before": "case h\u2081\n\u03b1 : Type u_1\ns1 e2 e1 s2 : Nat\na : Array \u03b1\nh : s1 + e2 \u2264 e1\n\u22a2 ((a.extract s1 e1).extract s2 e2).size = (a.extract (s1 + s2) (s1 + e2)).size",
+                "tactic": "simp only [size_extract]"
+              },
+              {
+                "annotated_tactic": [
+                  "\"omega\"",
+                  "[]"
+                ],
+                "state_after": "no goals",
+                "state_before": "case h\u2081\n\u03b1 : Type u_1\ns1 e2 e1 s2 : Nat\na : Array \u03b1\nh : s1 + e2 \u2264 e1\n\u22a2 min e2 (min e1 a.size - s1) - s2 = min (s1 + e2) a.size - (s1 + s2)",
+                "tactic": "omega"
+              },
+              {
+                "annotated_tactic": [
+                  "\"intro i h1 h2\"",
+                  "[]"
+                ],
+                "state_after": "case h\u2082\n\u03b1 : Type u_1\ns1 e2 e1 s2 : Nat\na : Array \u03b1\nh : s1 + e2 \u2264 e1\ni : Nat\nh1 : i < ((a.extract s1 e1).extract s2 e2).size\nh2 : i < (a.extract (s1 + s2) (s1 + e2)).size\n\u22a2 ((a.extract s1 e1).extract s2 e2)[i] = (a.extract (s1 + s2) (s1 + e2))[i]",
+                "state_before": "case h\u2082\n\u03b1 : Type u_1\ns1 e2 e1 s2 : Nat\na : Array \u03b1\nh : s1 + e2 \u2264 e1\n\u22a2 \u2200 (i : Nat) (hi\u2081 : i < ((a.extract s1 e1).extract s2 e2).size) (hi\u2082 : i < (a.extract (s1 + s2) (s1 + e2)).size),\n    ((a.extract s1 e1).extract s2 e2)[i] = (a.extract (s1 + s2) (s1 + e2))[i]",
+                "tactic": "intro i h1 h2"
+              },
+              {
+                "annotated_tactic": [
+                  "\"simp only [<a>get_extract<\\/a>, <a>Nat.add_assoc<\\/a>]\"",
+                  "[{\"full_name\":\"Array.get_extract\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Array\\/Lemmas.lean\",\"def_pos\":[908,17],\"def_end_pos\":[908,28]},{\"full_name\":\"Nat.add_assoc\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/Basic.lean\",\"def_pos\":[168,19],\"def_end_pos\":[168,28]}]"
+                ],
+                "state_after": "no goals",
+                "state_before": "case h\u2082\n\u03b1 : Type u_1\ns1 e2 e1 s2 : Nat\na : Array \u03b1\nh : s1 + e2 \u2264 e1\ni : Nat\nh1 : i < ((a.extract s1 e1).extract s2 e2).size\nh2 : i < (a.extract (s1 + s2) (s1 + e2)).size\n\u22a2 ((a.extract s1 e1).extract s2 e2)[i] = (a.extract (s1 + s2) (s1 + e2))[i]",
+                "tactic": "simp only [get_extract, Nat.add_assoc]"
+              }
+            ],
+            "url": "https://github.com/leanprover-community/mathlib4"
+          }
+        },
+        "theorem_name": "Array.extract_extract"
+      }
+    ],
+    "validation_rejected_proofs": 2,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/mathlib-000874-0000-e1305c53ec3c8614.parquet",
+      "sha256": "e1305c53ec3c8614e29ccd3c895a2229aa7db3a1dfbab30962d22561ff8053c7",
+      "bytes": 44676,
+      "rows": 1,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    },
+    {
+      "path": "data/internal_test/mathlib-000874-0000-1e8d383aa56f4f77.parquet",
+      "sha256": "1e8d383aa56f4f776c9cec9895df7b4aa9b785ffd3991c3efdc9b053a00887d5",
+      "bytes": 56571,
+      "rows": 2,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    }
+  ],
+  "proof_ids": [
+    "mathlib:Array.extract_eq_nil_of_start_eq_end",
+    "mathlib:Array.extract_eq_of_size_le_end"
+  ],
+  "proof_keys": [
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Array/ExtractLemmas.lean\",null,null,\"Array.extract_eq_nil_of_start_eq_end\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Array/ExtractLemmas.lean\",null,null,\"Array.extract_eq_of_size_le_end\"]"
+  ]
+}

manifests/batches/mathlib/000875.json

@@ -0,0 +1,522 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "mathlib/000875",
+  "batch_fingerprint": "620275a7e5710d4000b61f042ade75d30cf34d755dc45df88877a9aef49bc0ca",
+  "evidence": {
+    "batch_fingerprint": "620275a7e5710d4000b61f042ade75d30cf34d755dc45df88877a9aef49bc0ca",
+    "contamination_matches": [],
+    "failures": [
+      {
+        "error": "no internal trace for tactic 'exact iff_of_true rfl (forall_mem_nil _)'",
+        "full_name": "List.all_iff_forall",
+        "id": "List.all_iff_forall",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            30,
+            66
+          ],
+          "file_path": "Mathlib/Data/Bool/AllAny.lean",
+          "full_name": "List.all_iff_forall",
+          "start": [
+            27,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"induction' l with a l ih\"",
+                "[]"
+              ],
+              "state_after": "case nil\n\u03b1 : Type u_1\np\u271d : \u03b1 \u2192 Prop\ninst\u271d : DecidablePred p\u271d\nl : List \u03b1\na : \u03b1\np : \u03b1 \u2192 Bool\n\u22a2 [].all p = true \u2194 \u2200 (a : \u03b1), a \u2208 [] \u2192 p a = true\n\ncase cons\n\u03b1 : Type u_1\np\u271d : \u03b1 \u2192 Prop\ninst\u271d : DecidablePred p\u271d\nl\u271d : List \u03b1\na\u271d : \u03b1\np : \u03b1 \u2192 Bool\na : \u03b1\nl : List \u03b1\nih : l.all p = true \u2194 \u2200 (a : \u03b1), a \u2208 l \u2192 p a = true\n\u22a2 (a :: l).all p = true \u2194 \u2200 (a_1 : \u03b1), a_1 \u2208 a :: l \u2192 p a_1 = true",
+              "state_before": "\u03b1 : Type u_1\np\u271d : \u03b1 \u2192 Prop\ninst\u271d : DecidablePred p\u271d\nl : List \u03b1\na : \u03b1\np : \u03b1 \u2192 Bool\n\u22a2 l.all p = true \u2194 \u2200 (a : \u03b1), a \u2208 l \u2192 p a = true",
+              "tactic": "induction' l with a l ih"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp only [<a>all_cons<\\/a>, <a>Bool.and_eq_true_iff<\\/a>, ih, <a>forall_mem_cons<\\/a>]\"",
+                "[{\"full_name\":\"List.all_cons\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/List\\/Basic.lean\",\"def_pos\":[1058,17],\"def_end_pos\":[1058,25]},{\"full_name\":\"Bool.and_eq_true_iff\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Bool.lean\",\"def_pos\":[146,9],\"def_end_pos\":[146,24]},{\"full_name\":\"List.forall_mem_cons\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/List\\/Lemmas.lean\",\"def_pos\":[305,9],\"def_end_pos\":[305,24]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case cons\n\u03b1 : Type u_1\np\u271d : \u03b1 \u2192 Prop\ninst\u271d : DecidablePred p\u271d\nl\u271d : List \u03b1\na\u271d : \u03b1\np : \u03b1 \u2192 Bool\na : \u03b1\nl : List \u03b1\nih : l.all p = true \u2194 \u2200 (a : \u03b1), a \u2208 l \u2192 p a = true\n\u22a2 (a :: l).all p = true \u2194 \u2200 (a_1 : \u03b1), a_1 \u2208 a :: l \u2192 p a_1 = true",
+              "tactic": "simp only [all_cons, Bool.and_eq_true_iff, ih, forall_mem_cons]"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact <a>iff_of_true<\\/a> <a>rfl<\\/a> (<a>forall_mem_nil<\\/a> _)\"",
+                "[{\"full_name\":\"iff_of_true\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Core.lean\",\"def_pos\":[1353,9],\"def_end_pos\":[1353,20]},{\"full_name\":\"rfl\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[294,22],\"def_end_pos\":[294,25]},{\"full_name\":\"List.forall_mem_nil\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/List\\/Lemmas.lean\",\"def_pos\":[312,9],\"def_end_pos\":[312,23]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case nil\n\u03b1 : Type u_1\np\u271d : \u03b1 \u2192 Prop\ninst\u271d : DecidablePred p\u271d\nl : List \u03b1\na : \u03b1\np : \u03b1 \u2192 Bool\n\u22a2 [].all p = true \u2194 \u2200 (a : \u03b1), a \u2208 [] \u2192 p a = true",
+              "tactic": "exact iff_of_true rfl (forall_mem_nil _)"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Bool/AllAny.lean"
+      },
+      {
+        "error": "no internal trace for tactic 'exact iff_of_false Bool.false_ne_true (not_exists_mem_nil _)'",
+        "full_name": "List.any_iff_exists",
+        "id": "List.any_iff_exists",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            45,
+            69
+          ],
+          "file_path": "Mathlib/Data/Bool/AllAny.lean",
+          "full_name": "List.any_iff_exists",
+          "start": [
+            42,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"induction' l with a l ih\"",
+                "[]"
+              ],
+              "state_after": "case nil\n\u03b1 : Type u_1\np\u271d : \u03b1 \u2192 Prop\ninst\u271d : DecidablePred p\u271d\nl : List \u03b1\na : \u03b1\np : \u03b1 \u2192 Bool\n\u22a2 [].any p = true \u2194 \u2203 a, a \u2208 [] \u2227 p a = true\n\ncase cons\n\u03b1 : Type u_1\np\u271d : \u03b1 \u2192 Prop\ninst\u271d : DecidablePred p\u271d\nl\u271d : List \u03b1\na\u271d : \u03b1\np : \u03b1 \u2192 Bool\na : \u03b1\nl : List \u03b1\nih : l.any p = true \u2194 \u2203 a, a \u2208 l \u2227 p a = true\n\u22a2 (a :: l).any p = true \u2194 \u2203 a_1, a_1 \u2208 a :: l \u2227 p a_1 = true",
+              "state_before": "\u03b1 : Type u_1\np\u271d : \u03b1 \u2192 Prop\ninst\u271d : DecidablePred p\u271d\nl : List \u03b1\na : \u03b1\np : \u03b1 \u2192 Bool\n\u22a2 l.any p = true \u2194 \u2203 a, a \u2208 l \u2227 p a = true",
+              "tactic": "induction' l with a l ih"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp only [<a>any_cons<\\/a>, <a>Bool.or_eq_true_iff<\\/a>, ih, <a>exists_mem_cons_iff<\\/a>]\"",
+                "[{\"full_name\":\"List.any_cons\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/List\\/Basic.lean\",\"def_pos\":[1043,17],\"def_end_pos\":[1043,25]},{\"full_name\":\"Bool.or_eq_true_iff\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Bool.lean\",\"def_pos\":[166,17],\"def_end_pos\":[166,31]},{\"full_name\":\"List.exists_mem_cons_iff\",\"def_path\":\"Mathlib\\/Data\\/List\\/Basic.lean\",\"def_pos\":[291,9],\"def_end_pos\":[291,28]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case cons\n\u03b1 : Type u_1\np\u271d : \u03b1 \u2192 Prop\ninst\u271d : DecidablePred p\u271d\nl\u271d : List \u03b1\na\u271d : \u03b1\np : \u03b1 \u2192 Bool\na : \u03b1\nl : List \u03b1\nih : l.any p = true \u2194 \u2203 a, a \u2208 l \u2227 p a = true\n\u22a2 (a :: l).any p = true \u2194 \u2203 a_1, a_1 \u2208 a :: l \u2227 p a_1 = true",
+              "tactic": "simp only [any_cons, Bool.or_eq_true_iff, ih, exists_mem_cons_iff]"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact <a>iff_of_false<\\/a> <a>Bool.false_ne_true<\\/a> (<a>not_exists_mem_nil<\\/a> _)\"",
+                "[{\"full_name\":\"iff_of_false\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Core.lean\",\"def_pos\":[1354,9],\"def_end_pos\":[1354,21]},{\"full_name\":\"Bool.false_ne_true\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Bool.lean\",\"def_pos\":[43,9],\"def_end_pos\":[43,22]},{\"full_name\":\"List.not_exists_mem_nil\",\"def_path\":\"Mathlib\\/Init\\/Data\\/List\\/Lemmas.lean\",\"def_pos\":[75,9],\"def_end_pos\":[75,27]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case nil\n\u03b1 : Type u_1\np\u271d : \u03b1 \u2192 Prop\ninst\u271d : DecidablePred p\u271d\nl : List \u03b1\na : \u03b1\np : \u03b1 \u2192 Bool\n\u22a2 [].any p = true \u2194 \u2203 a, a \u2208 [] \u2227 p a = true",
+              "tactic": "exact iff_of_false Bool.false_ne_true (not_exists_mem_nil _)"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Bool/AllAny.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "List.any_of_mem",
+        "id": "List.any_of_mem",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            52,
+            31
+          ],
+          "file_path": "Mathlib/Data/Bool/AllAny.lean",
+          "full_name": "List.any_of_mem",
+          "start": [
+            51,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Bool/AllAny.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Bool.exists_bool",
+        "id": "Bool.exists_bool",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            74,
+            21
+          ],
+          "file_path": "Mathlib/Data/Bool/Basic.lean",
+          "full_name": "Bool.exists_bool",
+          "start": [
+            73,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Bool/Basic.lean"
+      },
+      {
+        "error": "no internal trace for tactic 'exact .inl \u2039_\u203a'",
+        "full_name": "Bool.exists_bool'",
+        "id": "Bool.exists_bool'",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            70,
+            43
+          ],
+          "file_path": "Mathlib/Data/Bool/Basic.lean",
+          "full_name": "Bool.exists_bool'",
+          "start": [
+            68,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"cases x <;> cases b <;> first | exact .inl \\u2039_\\u203a | exact .inr \\u2039_\\u203a\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "p : Bool \u2192 Prop\nb : Bool\nx\u271d : \u2203 x, p x\nx : Bool\nhx : p x\n\u22a2 p b \u2228 p !b",
+              "tactic": "cases x <;> cases b <;> first | exact .inl \u2039_\u203a | exact .inr \u2039_\u203a"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact .inl \\u2039_\\u203a\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case true.true\np : Bool \u2192 Prop\nx\u271d : \u2203 x, p x\nhx : p true\n\u22a2 p true \u2228 p !true",
+              "tactic": "exact .inl \u2039_\u203a"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact .inr \\u2039_\\u203a\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case true.false\np : Bool \u2192 Prop\nx\u271d : \u2203 x, p x\nhx : p true\n\u22a2 p false \u2228 p !false",
+              "tactic": "exact .inr \u2039_\u203a"
+            },
+            {
+              "annotated_tactic": [
+                "\"cases h <;> exact \\u27e8_, \\u2039_\\u203a\\u27e9\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "p : Bool \u2192 Prop\nb : Bool\nh : p b \u2228 p !b\n\u22a2 \u2203 x, p x",
+              "tactic": "cases h <;> exact \u27e8_, \u2039_\u203a\u27e9"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Bool/Basic.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Bool.false_lt_true",
+        "id": "Bool.false_lt_true",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            215,
+            22
+          ],
+          "file_path": "Mathlib/Data/Bool/Basic.lean",
+          "full_name": "Bool.false_lt_true",
+          "start": [
+            214,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Bool/Basic.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Bool.forall_bool",
+        "id": "Bool.forall_bool",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            65,
+            21
+          ],
+          "file_path": "Mathlib/Data/Bool/Basic.lean",
+          "full_name": "Bool.forall_bool",
+          "start": [
+            64,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Bool/Basic.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Bool.ne_not",
+        "id": "Bool.ne_not",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            135,
+            13
+          ],
+          "file_path": "Mathlib/Data/Bool/Basic.lean",
+          "full_name": "Bool.ne_not",
+          "start": [
+            134,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Bool/Basic.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Bool.not_ne_id",
+        "id": "Bool.not_ne_id",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            84,
+            73
+          ],
+          "file_path": "Mathlib/Data/Bool/Basic.lean",
+          "full_name": "Bool.not_ne_id",
+          "start": [
+            84,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Bool/Basic.lean"
+      },
+      {
+        "error": "no internal trace for tactic 'rw [_root_.decide_eq_true hn]'",
+        "full_name": "Bool.ofNat_le_ofNat",
+        "id": "Bool.ofNat_le_ofNat",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            258,
+            88
+          ],
+          "file_path": "Mathlib/Data/Bool/Basic.lean",
+          "full_name": "Bool.ofNat_le_ofNat",
+          "start": [
+            251,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"simp only [<a>ofNat<\\/a>, <a>ne_eq<\\/a>, <a>_root_.decide_not<\\/a>]\"",
+                "[{\"full_name\":\"Bool.ofNat\",\"def_path\":\"Mathlib\\/Data\\/Bool\\/Basic.lean\",\"def_pos\":[242,5],\"def_end_pos\":[242,10]},{\"full_name\":\"ne_eq\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/SimpLemmas.lean\",\"def_pos\":[89,17],\"def_end_pos\":[89,22]},{\"full_name\":\"decide_not\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/SimpLemmas.lean\",\"def_pos\":[246,17],\"def_end_pos\":[246,27]}]"
+              ],
+              "state_after": "n m : Nat\nh : n \u2264 m\n\u22a2 (!decide (n = 0)) \u2264 !decide (m = 0)",
+              "state_before": "n m : Nat\nh : n \u2264 m\n\u22a2 ofNat n \u2264 ofNat m",
+              "tactic": "simp only [ofNat, ne_eq, _root_.decide_not]"
+            },
+            {
+              "annotated_tactic": [
+                "\"cases <a>Nat.decEq<\\/a> n 0 with\\n  | <a>isTrue<\\/a> hn => rw [<a>_root_.decide_eq_true<\\/a> hn]; exact <a>Bool.false_le<\\/a> _\\n  | <a>isFalse<\\/a> hn =>\\n    cases <a>Nat.decEq<\\/a> m 0 with\\n    | <a>isFalse<\\/a> hm => rw [<a>_root_.decide_eq_false<\\/a> hm]; exact <a>Bool.le_true<\\/a> _\\n    | <a>isTrue<\\/a> hm => subst hm; have h := <a>Nat.le_antisymm<\\/a> h (<a>Nat.zero_le<\\/a> n); contradiction\"",
+                "[{\"full_name\":\"Nat.decEq\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[1614,15],\"def_end_pos\":[1614,24]},{\"full_name\":\"Decidable.isTrue\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[843,5],\"def_end_pos\":[843,11]},{\"full_name\":\"decide_eq_true\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[876,9],\"def_end_pos\":[876,23]},{\"full_name\":\"Bool.false_le\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Bool.lean\",\"def_pos\":[293,27],\"def_end_pos\":[293,35]},{\"full_name\":\"Decidable.isFalse\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[841,5],\"def_end_pos\":[841,12]},{\"full_name\":\"Nat.decEq\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[1614,15],\"def_end_pos\":[1614,24]},{\"full_name\":\"Decidable.isFalse\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[841,5],\"def_end_pos\":[841,12]},{\"full_name\":\"decide_eq_false\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[880,9],\"def_end_pos\":[880,24]},{\"full_name\":\"Bool.le_true\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Bool.lean\",\"def_pos\":[291,27],\"def_end_pos\":[291,34]},{\"full_name\":\"Decidable.isTrue\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[843,5],\"def_end_pos\":[843,11]},{\"full_name\":\"Nat.le_antisymm\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[1750,19],\"def_end_pos\":[1750,34]},{\"full_name\":\"Nat.zero_le\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[1663,9],\"def_end_pos\":[1663,20]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "n m : Nat\nh : n \u2264 m\n\u22a2 (!decide (n = 0)) \u2264 !decide (m = 0)",
+              "tactic": "cases Nat.decEq n 0 with\n| isTrue hn => rw [_root_.decide_eq_true hn]; exact Bool.false_le _\n| isFalse hn =>\n  cases Nat.decEq m 0 with\n  | isFalse hm => rw [_root_.decide_eq_false hm]; exact Bool.le_true _\n  | isTrue hm => subst hm; have h := Nat.le_antisymm h (Nat.zero_le n); contradiction"
+            },
+            {
+              "annotated_tactic": [
+                "\"rw [<a>_root_.decide_eq_true<\\/a> hn]\"",
+                "[{\"full_name\":\"decide_eq_true\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[876,9],\"def_end_pos\":[876,23]}]"
+              ],
+              "state_after": "case isTrue\nn m : Nat\nh : n \u2264 m\nhn : n = 0\n\u22a2 (!true) \u2264 !decide (m = 0)",
+              "state_before": "case isTrue\nn m : Nat\nh : n \u2264 m\nhn : n = 0\n\u22a2 (!decide (n = 0)) \u2264 !decide (m = 0)",
+              "tactic": "rw [_root_.decide_eq_true hn]"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact <a>Bool.false_le<\\/a> _\"",
+                "[{\"full_name\":\"Bool.false_le\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Bool.lean\",\"def_pos\":[293,27],\"def_end_pos\":[293,35]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case isTrue\nn m : Nat\nh : n \u2264 m\nhn : n = 0\n\u22a2 (!true) \u2264 !decide (m = 0)",
+              "tactic": "exact Bool.false_le _"
+            },
+            {
+              "annotated_tactic": [
+                "\"cases <a>Nat.decEq<\\/a> m 0 with\\n    | <a>isFalse<\\/a> hm => rw [<a>_root_.decide_eq_false<\\/a> hm]; exact <a>Bool.le_true<\\/a> _\\n    | <a>isTrue<\\/a> hm => subst hm; have h := <a>Nat.le_antisymm<\\/a> h (<a>Nat.zero_le<\\/a> n); contradiction\"",
+                "[{\"full_name\":\"Nat.decEq\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[1614,15],\"def_end_pos\":[1614,24]},{\"full_name\":\"Decidable.isFalse\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[841,5],\"def_end_pos\":[841,12]},{\"full_name\":\"decide_eq_false\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[880,9],\"def_end_pos\":[880,24]},{\"full_name\":\"Bool.le_true\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Bool.lean\",\"def_pos\":[291,27],\"def_end_pos\":[291,34]},{\"full_name\":\"Decidable.isTrue\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[843,5],\"def_end_pos\":[843,11]},{\"full_name\":\"Nat.le_antisymm\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[1750,19],\"def_end_pos\":[1750,34]},{\"full_name\":\"Nat.zero_le\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[1663,9],\"def_end_pos\":[1663,20]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case isFalse\nn m : Nat\nh : n \u2264 m\nhn : \u00acn = 0\n\u22a2 (!decide (n = 0)) \u2264 !decide (m = 0)",
+              "tactic": "cases Nat.decEq m 0 with\n| isFalse hm => rw [_root_.decide_eq_false hm]; exact Bool.le_true _\n| isTrue hm => subst hm; have h := Nat.le_antisymm h (Nat.zero_le n); contradiction"
+            },
+            {
+              "annotated_tactic": [
+                "\"rw [<a>_root_.decide_eq_false<\\/a> hm]\"",
+                "[{\"full_name\":\"decide_eq_false\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[880,9],\"def_end_pos\":[880,24]}]"
+              ],
+              "state_after": "case isFalse.isFalse\nn m : Nat\nh : n \u2264 m\nhn : \u00acn = 0\nhm : \u00acm = 0\n\u22a2 (!decide (n = 0)) \u2264 !false",
+              "state_before": "case isFalse.isFalse\nn m : Nat\nh : n \u2264 m\nhn : \u00acn = 0\nhm : \u00acm = 0\n\u22a2 (!decide (n = 0)) \u2264 !decide (m = 0)",
+              "tactic": "rw [_root_.decide_eq_false hm]"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact <a>Bool.le_true<\\/a> _\"",
+                "[{\"full_name\":\"Bool.le_true\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Bool.lean\",\"def_pos\":[291,27],\"def_end_pos\":[291,34]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case isFalse.isFalse\nn m : Nat\nh : n \u2264 m\nhn : \u00acn = 0\nhm : \u00acm = 0\n\u22a2 (!decide (n = 0)) \u2264 !false",
+              "tactic": "exact Bool.le_true _"
+            },
+            {
+              "annotated_tactic": [
+                "\"subst hm\"",
+                "[]"
+              ],
+              "state_after": "case isFalse.isTrue\nn : Nat\nhn : \u00acn = 0\nh : n \u2264 0\n\u22a2 (!decide (n = 0)) \u2264 !decide (0 = 0)",
+              "state_before": "case isFalse.isTrue\nn m : Nat\nh : n \u2264 m\nhn : \u00acn = 0\nhm : m = 0\n\u22a2 (!decide (n = 0)) \u2264 !decide (m = 0)",
+              "tactic": "subst hm"
+            },
+            {
+              "annotated_tactic": [
+                "\"have h := <a>Nat.le_antisymm<\\/a> h (<a>Nat.zero_le<\\/a> n)\"",
+                "[{\"full_name\":\"Nat.le_antisymm\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[1750,19],\"def_end_pos\":[1750,34]},{\"full_name\":\"Nat.zero_le\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[1663,9],\"def_end_pos\":[1663,20]}]"
+              ],
+              "state_after": "case isFalse.isTrue\nn : Nat\nhn : \u00acn = 0\nh\u271d : n \u2264 0\nh : n = 0\n\u22a2 (!decide (n = 0)) \u2264 !decide (0 = 0)",
+              "state_before": "case isFalse.isTrue\nn : Nat\nhn : \u00acn = 0\nh : n \u2264 0\n\u22a2 (!decide (n = 0)) \u2264 !decide (0 = 0)",
+              "tactic": "have h := Nat.le_antisymm h (Nat.zero_le n)"
+            },
+            {
+              "annotated_tactic": [
+                "\"contradiction\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case isFalse.isTrue\nn : Nat\nhn : \u00acn = 0\nh\u271d : n \u2264 0\nh : n = 0\n\u22a2 (!decide (n = 0)) \u2264 !decide (0 = 0)",
+              "tactic": "contradiction"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Bool/Basic.lean"
+      }
+    ],
+    "input_proofs": 45,
+    "input_units": 2,
+    "proofs": 35,
+    "published_proofs": 35,
+    "published_transitions": 38,
+    "replay_failures": [],
+    "transitions": 38,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/mathlib-000875-0000-08c3a557d84c3177.parquet",
+      "sha256": "08c3a557d84c31778d9e94175b70841d3bc34c9fa5f51f5a80f58249bda9b870",
+      "bytes": 100518,
+      "rows": 34,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    },
+    {
+      "path": "data/dev/mathlib-000875-0000-dc5c7a47b8f3669e.parquet",
+      "sha256": "dc5c7a47b8f3669e406a32b0ab359b551fd0b4aed41a55399ea24cd01c7edc4d",
+      "bytes": 32302,
+      "rows": 1,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    },
+    {
+      "path": "data/internal_test/mathlib-000875-0000-556cb8c1518c24d6.parquet",
+      "sha256": "556cb8c1518c24d6bbcb976e3d22f60dcc4201765cbcd8a4461a8f5c60200ffc",
+      "bytes": 32992,
+      "rows": 3,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    }
+  ],
+  "proof_ids": [
+    "mathlib:Bool.and_elim_left",
+    "mathlib:Bool.and_elim_right",
+    "mathlib:Bool.and_intro",
+    "mathlib:Bool.and_le_left",
+    "mathlib:Bool.and_le_right",
+    "mathlib:Bool.apply_apply_apply",
+    "mathlib:Bool.bne_eq_xor",
+    "mathlib:Bool.dichotomy",
+    "mathlib:Bool.eq_false_of_not_eq_true'",
+    "mathlib:Bool.eq_not_iff",
+    "mathlib:Bool.eq_or_eq_not",
+    "mathlib:Bool.eq_true_of_not_eq_false'",
+    "mathlib:Bool.forall_bool'",
+    "mathlib:Bool.injective_iff",
+    "mathlib:Bool.le_and",
+    "mathlib:Bool.le_iff_imp",
+    "mathlib:Bool.left_le_or",
+    "mathlib:Bool.lt_iff",
+    "mathlib:Bool.not_eq_iff",
+    "mathlib:Bool.not_iff_not",
+    "mathlib:Bool.not_ne_self",
+    "mathlib:Bool.ofNat_toNat",
+    "mathlib:Bool.or_inl",
+    "mathlib:Bool.or_inr",
+    "mathlib:Bool.or_le",
+    "mathlib:Bool.right_le_or",
+    "mathlib:Bool.self_ne_not",
+    "mathlib:Bool.toNat_beq_one",
+    "mathlib:Bool.toNat_beq_zero",
+    "mathlib:Bool.toNat_bne_one",
+    "mathlib:Bool.toNat_bne_zero",
+    "mathlib:Bool.toNat_le_toNat",
+    "mathlib:Bool.xor_iff_ne",
+    "mathlib:List.all_iff_forall_prop",
+    "mathlib:List.any_iff_exists_prop"
+  ],
+  "proof_keys": [
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/AllAny.lean\",null,null,\"List.all_iff_forall_prop\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/AllAny.lean\",null,null,\"List.any_iff_exists_prop\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.and_elim_left\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.and_elim_right\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.and_intro\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.and_le_left\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.and_le_right\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.apply_apply_apply\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.bne_eq_xor\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.dichotomy\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.eq_false_of_not_eq_true'\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.eq_not_iff\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.eq_or_eq_not\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.eq_true_of_not_eq_false'\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.forall_bool'\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.injective_iff\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.le_and\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.le_iff_imp\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.left_le_or\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.lt_iff\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.not_eq_iff\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.not_iff_not\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.not_ne_self\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.ofNat_toNat\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.or_inl\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.or_inr\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.or_le\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.right_le_or\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.self_ne_not\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.toNat_beq_one\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.toNat_beq_zero\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.toNat_bne_one\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.toNat_bne_zero\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.toNat_le_toNat\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Basic.lean\",null,null,\"Bool.xor_iff_ne\"]"
+  ]
+}

manifests/batches/mathlib/000876.json

@@ -0,0 +1,560 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "mathlib/000876",
+  "batch_fingerprint": "18a4beea2521680b89292c9998555d5f960f5fe755823ed1593e5617dbbb394e",
+  "evidence": {
+    "batch_fingerprint": "18a4beea2521680b89292c9998555d5f960f5fe755823ed1593e5617dbbb394e",
+    "contamination_matches": [],
+    "failures": [
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "List.Chain'.count_false_eq_count_true",
+        "id": "List.Chain'.count_false_eq_count_true",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            76,
+            32
+          ],
+          "file_path": "Mathlib/Data/Bool/Count.lean",
+          "full_name": "List.Chain'.count_false_eq_count_true",
+          "start": [
+            74,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Bool/Count.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "List.Chain'.count_false_le_count_true_add_one",
+        "id": "List.Chain'.count_false_le_count_true_add_one",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            92,
+            37
+          ],
+          "file_path": "Mathlib/Data/Bool/Count.lean",
+          "full_name": "List.Chain'.count_false_le_count_true_add_one",
+          "start": [
+            90,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Bool/Count.lean"
+      },
+      {
+        "error": "no internal trace for tactic 'suffices count (!x) (x :: l) = count x (x :: l) by\\n  cases b <;> cases x <;>\\n  revert this <;> simp only [Bool.not_false, Bool.not_true] <;> intro this <;>\\n  (try exact this) <;> exact this.symm'",
+        "full_name": "List.Chain'.count_not_eq_count",
+        "id": "List.Chain'.count_not_eq_count",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            71,
+            73
+          ],
+          "file_path": "Mathlib/Data/Bool/Count.lean",
+          "full_name": "List.Chain'.count_not_eq_count",
+          "start": [
+            60,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"cases' l with x l\"",
+                "[]"
+              ],
+              "state_after": "case nil\nb : Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) []\nh2 : Even [].length\n\u22a2 count (!b) [] = count b []\n\ncase cons\nb x : Bool\nl : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) (x :: l)\nh2 : Even (x :: l).length\n\u22a2 count (!b) (x :: l) = count b (x :: l)",
+              "state_before": "l : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) l\nh2 : Even l.length\nb : Bool\n\u22a2 count (!b) l = count b l",
+              "tactic": "cases' l with x l"
+            },
+            {
+              "annotated_tactic": [
+                "\"rw [<a>length_cons<\\/a>, <a>Nat.even_add_one<\\/a>, <a>Nat.not_even_iff<\\/a>] at h2\"",
+                "[{\"full_name\":\"List.length_cons\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/List\\/Basic.lean\",\"def_pos\":[70,17],\"def_end_pos\":[70,28]},{\"full_name\":\"Nat.even_add_one\",\"def_path\":\"Mathlib\\/Algebra\\/Group\\/Nat.lean\",\"def_pos\":[113,23],\"def_end_pos\":[113,35]},{\"full_name\":\"Nat.not_even_iff\",\"def_path\":\"Mathlib\\/Algebra\\/Group\\/Nat.lean\",\"def_pos\":[98,7],\"def_end_pos\":[98,19]}]"
+              ],
+              "state_after": "case cons\nb x : Bool\nl : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) (x :: l)\nh2 : l.length % 2 = 1\n\u22a2 count (!b) (x :: l) = count b (x :: l)",
+              "state_before": "case cons\nb x : Bool\nl : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) (x :: l)\nh2 : Even (x :: l).length\n\u22a2 count (!b) (x :: l) = count b (x :: l)",
+              "tactic": "rw [length_cons, Nat.even_add_one, Nat.not_even_iff] at h2"
+            },
+            {
+              "annotated_tactic": [
+                "\"suffices <a>count<\\/a> (!x) (x :: l) = <a>count<\\/a> x (x :: l) by\\n    -- Porting note: old proof is\\n    -- cases b <;> cases x <;> try exact this;\\n    cases b <;> cases x <;>\\n    revert this <;> simp only [<a>Bool.not_false<\\/a>, <a>Bool.not_true<\\/a>] <;> intro this <;>\\n    (try exact this) <;> exact this.symm\"",
+                "[{\"full_name\":\"List.count\",\"def_path\":\".lake\\/packages\\/batteries\\/Batteries\\/Data\\/List\\/Basic.lean\",\"def_pos\":[448,15],\"def_end_pos\":[448,20]},{\"full_name\":\"List.count\",\"def_path\":\".lake\\/packages\\/batteries\\/Batteries\\/Data\\/List\\/Basic.lean\",\"def_pos\":[448,15],\"def_end_pos\":[448,20]},{\"full_name\":\"Bool.not_false\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/SimpLemmas.lean\",\"def_pos\":[230,17],\"def_end_pos\":[230,31]},{\"full_name\":\"Bool.not_true\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/SimpLemmas.lean\",\"def_pos\":[229,17],\"def_end_pos\":[229,30]}]"
+              ],
+              "state_after": "case cons\nb x : Bool\nl : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) (x :: l)\nh2 : l.length % 2 = 1\n\u22a2 count (!x) (x :: l) = count x (x :: l)",
+              "state_before": "case cons\nb x : Bool\nl : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) (x :: l)\nh2 : l.length % 2 = 1\n\u22a2 count (!b) (x :: l) = count b (x :: l)",
+              "tactic": "suffices count (!x) (x :: l) = count x (x :: l) by\n  cases b <;> cases x <;>\n  revert this <;> simp only [Bool.not_false, Bool.not_true] <;> intro this <;>\n  (try exact this) <;> exact this.symm"
+            },
+            {
+              "annotated_tactic": [
+                "\"rw [<a>count_cons_of_ne<\\/a> x.not_ne_self, hl.count_not, h2, <a>count_cons_self<\\/a>]\"",
+                "[{\"full_name\":\"List.count_cons_of_ne\",\"def_path\":\".lake\\/packages\\/batteries\\/Batteries\\/Data\\/List\\/Count.lean\",\"def_pos\":[143,17],\"def_end_pos\":[143,33]},{\"full_name\":\"List.count_cons_self\",\"def_path\":\".lake\\/packages\\/batteries\\/Batteries\\/Data\\/List\\/Count.lean\",\"def_pos\":[140,17],\"def_end_pos\":[140,32]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case cons\nb x : Bool\nl : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) (x :: l)\nh2 : l.length % 2 = 1\n\u22a2 count (!x) (x :: l) = count x (x :: l)",
+              "tactic": "rw [count_cons_of_ne x.not_ne_self, hl.count_not, h2, count_cons_self]"
+            },
+            {
+              "annotated_tactic": [
+                "\"rfl\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case nil\nb : Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) []\nh2 : Even [].length\n\u22a2 count (!b) [] = count b []",
+              "tactic": "rfl"
+            },
+            {
+              "annotated_tactic": [
+                "\"cases b <;> cases x <;>\\n    revert this <;> simp only [<a>Bool.not_false<\\/a>, <a>Bool.not_true<\\/a>] <;> intro this <;>\\n    (try exact this) <;> exact this.symm\"",
+                "[{\"full_name\":\"Bool.not_false\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/SimpLemmas.lean\",\"def_pos\":[230,17],\"def_end_pos\":[230,31]},{\"full_name\":\"Bool.not_true\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/SimpLemmas.lean\",\"def_pos\":[229,17],\"def_end_pos\":[229,30]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "b x : Bool\nl : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) (x :: l)\nh2 : l.length % 2 = 1\nthis : count (!x) (x :: l) = count x (x :: l)\n\u22a2 count (!b) (x :: l) = count b (x :: l)",
+              "tactic": "cases b <;> cases x <;>\nrevert this <;> simp only [Bool.not_false, Bool.not_true] <;> intro this <;>\n(try exact this) <;> exact this.symm"
+            },
+            {
+              "annotated_tactic": [
+                "\"try exact this\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case true.true\nl : List Bool\nh2 : l.length % 2 = 1\nhl : Chain' (fun x x_1 => x \u2260 x_1) (true :: l)\nthis : count false (true :: l) = count true (true :: l)\n\u22a2 count false (true :: l) = count true (true :: l)",
+              "tactic": "try exact this"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact this\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case true.true\nl : List Bool\nh2 : l.length % 2 = 1\nhl : Chain' (fun x x_1 => x \u2260 x_1) (true :: l)\nthis : count false (true :: l) = count true (true :: l)\n\u22a2 count false (true :: l) = count true (true :: l)",
+              "tactic": "exact this"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Bool/Count.lean"
+      },
+      {
+        "error": "no internal trace for tactic 'exact zero_le _'",
+        "full_name": "List.Chain'.count_not_le_count_add_one",
+        "id": "List.Chain'.count_not_le_count_add_one",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            87,
+            51
+          ],
+          "file_path": "Mathlib/Data/Bool/Count.lean",
+          "full_name": "List.Chain'.count_not_le_count_add_one",
+          "start": [
+            79,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"cases' l with x l\"",
+                "[]"
+              ],
+              "state_after": "case nil\nb : Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) []\n\u22a2 count (!b) [] \u2264 count b [] + 1\n\ncase cons\nb x : Bool\nl : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) (x :: l)\n\u22a2 count (!b) (x :: l) \u2264 count b (x :: l) + 1",
+              "state_before": "l : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) l\nb : Bool\n\u22a2 count (!b) l \u2264 count b l + 1",
+              "tactic": "cases' l with x l"
+            },
+            {
+              "annotated_tactic": [
+                "\"obtain rfl | rfl : b = x \\u2228 b = !x := by simp only [<a>Bool.eq_not_iff<\\/a>, <a>em<\\/a>]\"",
+                "[{\"full_name\":\"Bool.eq_not_iff\",\"def_path\":\"Mathlib\\/Data\\/Bool\\/Basic.lean\",\"def_pos\":[125,7],\"def_end_pos\":[125,17]},{\"full_name\":\"em\",\"def_path\":\"Mathlib\\/Logic\\/Basic.lean\",\"def_pos\":[195,7],\"def_end_pos\":[195,9]}]"
+              ],
+              "state_after": "case cons.inl\nb : Bool\nl : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) (b :: l)\n\u22a2 count (!b) (b :: l) \u2264 count b (b :: l) + 1\n\ncase cons.inr\nx : Bool\nl : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) (x :: l)\n\u22a2 count (!!x) (x :: l) \u2264 count (!x) (x :: l) + 1",
+              "state_before": "case cons\nb x : Bool\nl : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) (x :: l)\n\u22a2 count (!b) (x :: l) \u2264 count b (x :: l) + 1",
+              "tactic": "obtain rfl | rfl : b = x \u2228 b = !x := by simp only [Bool.eq_not_iff, em]"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact <a>zero_le<\\/a> _\"",
+                "[{\"full_name\":\"zero_le\",\"def_path\":\"Mathlib\\/Algebra\\/Order\\/Monoid\\/Canonical\\/Defs.lean\",\"def_pos\":[204,30],\"def_end_pos\":[204,37]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case nil\nb : Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) []\n\u22a2 count (!b) [] \u2264 count b [] + 1",
+              "tactic": "exact zero_le _"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp only [<a>Bool.eq_not_iff<\\/a>, <a>em<\\/a>]\"",
+                "[{\"full_name\":\"Bool.eq_not_iff\",\"def_path\":\"Mathlib\\/Data\\/Bool\\/Basic.lean\",\"def_pos\":[125,7],\"def_end_pos\":[125,17]},{\"full_name\":\"em\",\"def_path\":\"Mathlib\\/Logic\\/Basic.lean\",\"def_pos\":[195,7],\"def_end_pos\":[195,9]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "b x : Bool\nl : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) (x :: l)\n\u22a2 b = x \u2228 b = !x",
+              "tactic": "simp only [Bool.eq_not_iff, em]"
+            },
+            {
+              "annotated_tactic": [
+                "\"rw [<a>count_cons_of_ne<\\/a> b.not_ne_self, <a>count_cons_self<\\/a>, hl.count_not, <a>add_assoc<\\/a>]\"",
+                "[{\"full_name\":\"List.count_cons_of_ne\",\"def_path\":\".lake\\/packages\\/batteries\\/Batteries\\/Data\\/List\\/Count.lean\",\"def_pos\":[143,17],\"def_end_pos\":[143,33]},{\"full_name\":\"List.count_cons_self\",\"def_path\":\".lake\\/packages\\/batteries\\/Batteries\\/Data\\/List\\/Count.lean\",\"def_pos\":[140,17],\"def_end_pos\":[140,32]},{\"full_name\":\"add_assoc\",\"def_path\":\"Mathlib\\/Algebra\\/Group\\/Defs.lean\",\"def_pos\":[288,3],\"def_end_pos\":[288,14]}]"
+              ],
+              "state_after": "case cons.inl\nb : Bool\nl : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) (b :: l)\n\u22a2 count b l + l.length % 2 \u2264 count b l + (1 + 1)",
+              "state_before": "case cons.inl\nb : Bool\nl : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) (b :: l)\n\u22a2 count (!b) (b :: l) \u2264 count b (b :: l) + 1",
+              "tactic": "rw [count_cons_of_ne b.not_ne_self, count_cons_self, hl.count_not, add_assoc]"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact <a>add_le_add_left<\\/a> (<a>Nat.mod_lt<\\/a> _ <a>two_pos<\\/a>).<a>le<\\/a> _\"",
+                "[{\"full_name\":\"add_le_add_left\",\"def_path\":\"Mathlib\\/Algebra\\/Order\\/Monoid\\/Unbundled\\/Basic.lean\",\"def_pos\":[49,32],\"def_end_pos\":[49,47]},{\"full_name\":\"Nat.mod_lt\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/Div.lean\",\"def_pos\":[142,9],\"def_end_pos\":[142,15]},{\"full_name\":\"two_pos\",\"def_path\":\"Mathlib\\/Algebra\\/Order\\/Monoid\\/NatCast.lean\",\"def_pos\":[113,7],\"def_end_pos\":[113,14]},{\"full_name\":\"LT.lt.le\",\"def_path\":\"Mathlib\\/Order\\/Basic.lean\",\"def_pos\":[137,7],\"def_end_pos\":[137,15]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case cons.inl\nb : Bool\nl : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) (b :: l)\n\u22a2 count b l + l.length % 2 \u2264 count b l + (1 + 1)",
+              "tactic": "exact add_le_add_left (Nat.mod_lt _ two_pos).le _"
+            },
+            {
+              "annotated_tactic": [
+                "\"rw [<a>Bool.not_not<\\/a>, <a>count_cons_self<\\/a>, <a>count_cons_of_ne<\\/a> x.not_ne_self, hl.count_not]\"",
+                "[{\"full_name\":\"Bool.not_not\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/SimpLemmas.lean\",\"def_pos\":[228,17],\"def_end_pos\":[228,29]},{\"full_name\":\"List.count_cons_self\",\"def_path\":\".lake\\/packages\\/batteries\\/Batteries\\/Data\\/List\\/Count.lean\",\"def_pos\":[140,17],\"def_end_pos\":[140,32]},{\"full_name\":\"List.count_cons_of_ne\",\"def_path\":\".lake\\/packages\\/batteries\\/Batteries\\/Data\\/List\\/Count.lean\",\"def_pos\":[143,17],\"def_end_pos\":[143,33]}]"
+              ],
+              "state_after": "case cons.inr\nx : Bool\nl : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) (x :: l)\n\u22a2 count x l + 1 \u2264 count x l + l.length % 2 + 1",
+              "state_before": "case cons.inr\nx : Bool\nl : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) (x :: l)\n\u22a2 count (!!x) (x :: l) \u2264 count (!x) (x :: l) + 1",
+              "tactic": "rw [Bool.not_not, count_cons_self, count_cons_of_ne x.not_ne_self, hl.count_not]"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact <a>add_le_add_right<\\/a> (<a>le_add_right<\\/a> <a>le_rfl<\\/a>) _\"",
+                "[{\"full_name\":\"add_le_add_right\",\"def_path\":\"Mathlib\\/Algebra\\/Order\\/Monoid\\/Unbundled\\/Basic.lean\",\"def_pos\":[66,32],\"def_end_pos\":[66,48]},{\"full_name\":\"le_add_right\",\"def_path\":\"Mathlib\\/Algebra\\/Order\\/Monoid\\/Canonical\\/Defs.lean\",\"def_pos\":[264,3],\"def_end_pos\":[264,14]},{\"full_name\":\"le_rfl\",\"def_path\":\"Mathlib\\/Init\\/Order\\/Defs.lean\",\"def_pos\":[50,9],\"def_end_pos\":[50,15]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case cons.inr\nx : Bool\nl : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) (x :: l)\n\u22a2 count x l + 1 \u2264 count x l + l.length % 2 + 1",
+              "tactic": "exact add_le_add_right (le_add_right le_rfl) _"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Bool/Count.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "List.Chain'.count_true_le_count_false_add_one",
+        "id": "List.Chain'.count_true_le_count_false_add_one",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            97,
+            38
+          ],
+          "file_path": "Mathlib/Data/Bool/Count.lean",
+          "full_name": "List.Chain'.count_true_le_count_false_add_one",
+          "start": [
+            95,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Bool/Count.lean"
+      },
+      {
+        "error": "no internal trace for tactic 'exact (h2 even_zero).elim'",
+        "full_name": "List.Chain'.two_mul_count_bool_eq_ite",
+        "id": "List.Chain'.two_mul_count_bool_eq_ite",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            117,
+            65
+          ],
+          "file_path": "Mathlib/Data/Bool/Count.lean",
+          "full_name": "List.Chain'.two_mul_count_bool_eq_ite",
+          "start": [
+            105,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"by_cases h2 : <a>Even<\\/a> (<a>length<\\/a> l)\"",
+                "[{\"full_name\":\"Even\",\"def_path\":\"Mathlib\\/Algebra\\/Group\\/Even.lean\",\"def_pos\":[46,3],\"def_end_pos\":[46,14]},{\"full_name\":\"List.length\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[2316,5],\"def_end_pos\":[2316,16]}]"
+              ],
+              "state_after": "case pos\nl : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) l\nb : Bool\nh2 : Even l.length\n\u22a2 2 * count b l = if Even l.length then l.length else if (some b == l.head?) = true then l.length + 1 else l.length - 1\n\ncase neg\nl : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) l\nb : Bool\nh2 : \u00acEven l.length\n\u22a2 2 * count b l = if Even l.length then l.length else if (some b == l.head?) = true then l.length + 1 else l.length - 1",
+              "state_before": "l : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) l\nb : Bool\n\u22a2 2 * count b l = if Even l.length then l.length else if (some b == l.head?) = true then l.length + 1 else l.length - 1",
+              "tactic": "by_cases h2 : Even (length l)"
+            },
+            {
+              "annotated_tactic": [
+                "\"rw [<a>if_pos<\\/a> h2, hl.two_mul_count_bool_of_even h2]\"",
+                "[{\"full_name\":\"if_pos\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Core.lean\",\"def_pos\":[932,9],\"def_end_pos\":[932,15]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case pos\nl : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) l\nb : Bool\nh2 : Even l.length\n\u22a2 2 * count b l = if Even l.length then l.length else if (some b == l.head?) = true then l.length + 1 else l.length - 1",
+              "tactic": "rw [if_pos h2, hl.two_mul_count_bool_of_even h2]"
+            },
+            {
+              "annotated_tactic": [
+                "\"cases' l with x l\"",
+                "[]"
+              ],
+              "state_after": "case neg.nil\nb : Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) []\nh2 : \u00acEven [].length\n\u22a2 2 * count b [] =\n    if Even [].length then [].length else if (some b == [].head?) = true then [].length + 1 else [].length - 1\n\ncase neg.cons\nb x : Bool\nl : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) (x :: l)\nh2 : \u00acEven (x :: l).length\n\u22a2 2 * count b (x :: l) =\n    if Even (x :: l).length then (x :: l).length\n    else if (some b == (x :: l).head?) = true then (x :: l).length + 1 else (x :: l).length - 1",
+              "state_before": "case neg\nl : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) l\nb : Bool\nh2 : \u00acEven l.length\n\u22a2 2 * count b l = if Even l.length then l.length else if (some b == l.head?) = true then l.length + 1 else l.length - 1",
+              "tactic": "cases' l with x l"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp only [<a>if_neg<\\/a> h2, <a>count_cons<\\/a>, <a>mul_add<\\/a>, <a>head?<\\/a>, <a>Option.mem_some_iff<\\/a>, @<a>eq_comm<\\/a> _ x]\"",
+                "[{\"full_name\":\"if_neg\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Core.lean\",\"def_pos\":[937,9],\"def_end_pos\":[937,15]},{\"full_name\":\"List.count_cons\",\"def_path\":\".lake\\/packages\\/batteries\\/Batteries\\/Data\\/List\\/Count.lean\",\"def_pos\":[136,9],\"def_end_pos\":[136,19]},{\"full_name\":\"mul_add\",\"def_path\":\"Mathlib\\/Algebra\\/Ring\\/Defs.lean\",\"def_pos\":[83,7],\"def_end_pos\":[83,14]},{\"full_name\":\"List.head?\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/List\\/Basic.lean\",\"def_pos\":[296,5],\"def_end_pos\":[296,10]},{\"full_name\":\"Option.mem_some_iff\",\"def_path\":\"Mathlib\\/Data\\/Option\\/Defs.lean\",\"def_pos\":[61,9],\"def_end_pos\":[61,21]},{\"full_name\":\"eq_comm\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Core.lean\",\"def_pos\":[811,9],\"def_end_pos\":[811,16]}]"
+              ],
+              "state_after": "case neg.cons\nb x : Bool\nl : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) (x :: l)\nh2 : \u00acEven (x :: l).length\n\u22a2 (2 * count b l + 2 * if b = x then 1 else 0) =\n    if (some b == some x) = true then (x :: l).length + 1 else (x :: l).length - 1",
+              "state_before": "case neg.cons\nb x : Bool\nl : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) (x :: l)\nh2 : \u00acEven (x :: l).length\n\u22a2 2 * count b (x :: l) =\n    if Even (x :: l).length then (x :: l).length\n    else if (some b == (x :: l).head?) = true then (x :: l).length + 1 else (x :: l).length - 1",
+              "tactic": "simp only [if_neg h2, count_cons, mul_add, head?, Option.mem_some_iff, @eq_comm _ x]"
+            },
+            {
+              "annotated_tactic": [
+                "\"rw [<a>length_cons<\\/a>, <a>Nat.even_add_one<\\/a>, <a>not_not<\\/a>] at h2\"",
+                "[{\"full_name\":\"List.length_cons\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/List\\/Basic.lean\",\"def_pos\":[70,17],\"def_end_pos\":[70,28]},{\"full_name\":\"Nat.even_add_one\",\"def_path\":\"Mathlib\\/Algebra\\/Group\\/Nat.lean\",\"def_pos\":[113,23],\"def_end_pos\":[113,35]},{\"full_name\":\"Classical.not_not\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Classical.lean\",\"def_pos\":[135,17],\"def_end_pos\":[135,24]}]"
+              ],
+              "state_after": "case neg.cons\nb x : Bool\nl : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) (x :: l)\nh2 : Even l.length\n\u22a2 (2 * count b l + 2 * if b = x then 1 else 0) =\n    if (some b == some x) = true then (x :: l).length + 1 else (x :: l).length - 1",
+              "state_before": "case neg.cons\nb x : Bool\nl : List Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) (x :: l)\nh2 : \u00acEven (x :: l).length\n\u22a2 (2 * count b l + 2 * if b = x then 1 else 0) =\n    if (some b == some x) = true then (x :: l).length + 1 else (x :: l).length - 1",
+              "tactic": "rw [length_cons, Nat.even_add_one, not_not] at h2"
+            },
+            {
+              "annotated_tactic": [
+                "\"rw [hl.two_mul_count_bool_of_even h2]\"",
+                "[]"
+              ],
+              "state_after": "case neg.cons\nb x : Bool\nl : List Bool\nh2 : Even l.length\nhl : Chain' (fun x x_1 => x \u2260 x_1) l\n\u22a2 (l.length + 2 * if b = x then 1 else 0) =\n    if (some b == some x) = true then (x :: l).length + 1 else (x :: l).length - 1",
+              "state_before": "case neg.cons\nb x : Bool\nl : List Bool\nh2 : Even l.length\nhl : Chain' (fun x x_1 => x \u2260 x_1) l\n\u22a2 (2 * count b l + 2 * if b = x then 1 else 0) =\n    if (some b == some x) = true then (x :: l).length + 1 else (x :: l).length - 1",
+              "tactic": "rw [hl.two_mul_count_bool_of_even h2]"
+            },
+            {
+              "annotated_tactic": [
+                "\"cases b <;> cases x <;> split_ifs <;> simp <;> contradiction\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case neg.cons\nb x : Bool\nl : List Bool\nh2 : Even l.length\nhl : Chain' (fun x x_1 => x \u2260 x_1) l\n\u22a2 (l.length + 2 * if b = x then 1 else 0) =\n    if (some b == some x) = true then (x :: l).length + 1 else (x :: l).length - 1",
+              "tactic": "cases b <;> cases x <;> split_ifs <;> simp <;> contradiction"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact (h2 <a>even_zero<\\/a>).<a>elim<\\/a>\"",
+                "[{\"full_name\":\"even_zero\",\"def_path\":\"Mathlib\\/Algebra\\/Group\\/Even.lean\",\"def_pos\":[95,3],\"def_end_pos\":[95,14]},{\"full_name\":\"False.elim\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[236,21],\"def_end_pos\":[236,31]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case neg.nil\nb : Bool\nhl : Chain' (fun x x_1 => x \u2260 x_1) []\nh2 : \u00acEven [].length\n\u22a2 2 * count b [] =\n    if Even [].length then [].length else if (some b == [].head?) = true then [].length + 1 else [].length - 1",
+              "tactic": "exact (h2 even_zero).elim"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Bool/Count.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "List.count_false_add_count_true",
+        "id": "List.count_false_add_count_true",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            39,
+            29
+          ],
+          "file_path": "Mathlib/Data/Bool/Count.lean",
+          "full_name": "List.count_false_add_count_true",
+          "start": [
+            38,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Bool/Count.lean"
+      },
+      {
+        "error": "no internal trace for tactic 'rw [this]'",
+        "full_name": "List.count_not_add_count",
+        "id": "List.count_not_add_count",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            29,
+            37
+          ],
+          "file_path": "Mathlib/Data/Bool/Count.lean",
+          "full_name": "List.count_not_add_count",
+          "start": [
+            24,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"suffices (fun x => x == b) = (fun a => <a>decide<\\/a> \\u00ac(a == !b) = <a>true<\\/a>) by rw [this]\"",
+                "[{\"full_name\":\"Decidable.decide\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[851,39],\"def_end_pos\":[851,55]},{\"full_name\":\"Bool.true\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[571,5],\"def_end_pos\":[571,9]}]"
+              ],
+              "state_after": "l : List Bool\nb : Bool\n\u22a2 (fun x => x == b) = fun a => decide \u00ac(a == !b) = true",
+              "state_before": "l : List Bool\nb : Bool\n\u22a2 countP (fun x => x == b) l = countP (fun a => decide \u00ac(a == !b) = true) l",
+              "tactic": "suffices (fun x => x == b) = (fun a => decide \u00ac(a == !b) = true) by rw [this]"
+            },
+            {
+              "annotated_tactic": [
+                "\"ext x\"",
+                "[]"
+              ],
+              "state_after": "case h\nl : List Bool\nb x : Bool\n\u22a2 (x == b) = decide \u00ac(x == !b) = true",
+              "state_before": "l : List Bool\nb : Bool\n\u22a2 (fun x => x == b) = fun a => decide \u00ac(a == !b) = true",
+              "tactic": "ext x"
+            },
+            {
+              "annotated_tactic": [
+                "\"cases x <;> cases b <;> rfl\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case h\nl : List Bool\nb x : Bool\n\u22a2 (x == b) = decide \u00ac(x == !b) = true",
+              "tactic": "cases x <;> cases b <;> rfl"
+            },
+            {
+              "annotated_tactic": [
+                "\"rw [this]\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "l : List Bool\nb : Bool\nthis : (fun x => x == b) = fun a => decide \u00ac(a == !b) = true\n\u22a2 countP (fun x => x == b) l = countP (fun a => decide \u00ac(a == !b) = true) l",
+              "tactic": "rw [this]"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Bool/Count.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "List.count_true_add_count_false",
+        "id": "List.count_true_add_count_false",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            44,
+            30
+          ],
+          "file_path": "Mathlib/Data/Bool/Count.lean",
+          "full_name": "List.count_true_add_count_false",
+          "start": [
+            43,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Bool/Count.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Bool.compl_singleton",
+        "id": "Bool.compl_singleton",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            32,
+            35
+          ],
+          "file_path": "Mathlib/Data/Bool/Set.lean",
+          "full_name": "Bool.compl_singleton",
+          "start": [
+            31,
+            9
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Bool/Set.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Bool.univ_eq",
+        "id": "Bool.univ_eq",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            23,
+            42
+          ],
+          "file_path": "Mathlib/Data/Bool/Set.lean",
+          "full_name": "Bool.univ_eq",
+          "start": [
+            22,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Bool/Set.lean"
+      }
+    ],
+    "input_proofs": 18,
+    "input_units": 2,
+    "proofs": 7,
+    "published_proofs": 7,
+    "published_transitions": 11,
+    "replay_failures": [],
+    "transitions": 11,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/mathlib-000876-0000-acaff619cbf3982b.parquet",
+      "sha256": "acaff619cbf3982b8a07180aa0d054fa0d181b6a9be84ed41bbb13e015587244",
+      "bytes": 40865,
+      "rows": 5,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    },
+    {
+      "path": "data/dev/mathlib-000876-0000-8183d045bbd69f8e.parquet",
+      "sha256": "8183d045bbd69f8ea06b7b4e6934228d47ab710b0b572c58ccdfe156fd646ec7",
+      "bytes": 49658,
+      "rows": 2,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    },
+    {
+      "path": "data/internal_test/mathlib-000876-0000-8b5b5419fb0eb37a.parquet",
+      "sha256": "8b5b5419fb0eb37a89ff882a4a207fdabaeebeca795e9193fa22dda3ee937355",
+      "bytes": 43125,
+      "rows": 4,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    }
+  ],
+  "proof_ids": [
+    "mathlib:Bool.range_eq",
+    "mathlib:List.Chain'.length_div_two_le_count_bool",
+    "mathlib:List.Chain'.length_sub_one_le_two_mul_count_bool",
+    "mathlib:List.Chain'.two_mul_count_bool_le_length_add_one",
+    "mathlib:List.Chain'.two_mul_count_bool_of_even",
+    "mathlib:List.Chain.count_not",
+    "mathlib:List.count_add_count_not"
+  ],
+  "proof_keys": [
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Count.lean\",null,null,\"List.Chain'.length_div_two_le_count_bool\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Count.lean\",null,null,\"List.Chain'.length_sub_one_le_two_mul_count_bool\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Count.lean\",null,null,\"List.Chain'.two_mul_count_bool_le_length_add_one\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Count.lean\",null,null,\"List.Chain'.two_mul_count_bool_of_even\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Count.lean\",null,null,\"List.Chain.count_not\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Count.lean\",null,null,\"List.count_add_count_not\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bool/Set.lean\",null,null,\"Bool.range_eq\"]"
+  ]
+}

manifests/batches/mathlib/000877.json

@@ -0,0 +1,243 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "mathlib/000877",
+  "batch_fingerprint": "b58413bd6bf6cb817ae2f648480934e98e518e63b97345bdd45724fbf33b1886",
+  "evidence": {
+    "batch_fingerprint": "b58413bd6bf6cb817ae2f648480934e98e518e63b97345bdd45724fbf33b1886",
+    "contamination_matches": [],
+    "failures": [
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Bundle.Pullback.lift_mk",
+        "id": "Bundle.Pullback.lift_mk",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            153,
+            6
+          ],
+          "file_path": "Mathlib/Data/Bundle.lean",
+          "full_name": "Bundle.Pullback.lift_mk",
+          "start": [
+            151,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Bundle.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Bundle.TotalSpace.eta",
+        "id": "Bundle.TotalSpace.eta",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            87,
+            82
+          ],
+          "file_path": "Mathlib/Data/Bundle.lean",
+          "full_name": "Bundle.TotalSpace.eta",
+          "start": [
+            87,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Bundle.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Bundle.TotalSpace.exists",
+        "id": "Bundle.TotalSpace.exists",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            92,
+            62
+          ],
+          "file_path": "Mathlib/Data/Bundle.lean",
+          "full_name": "Bundle.TotalSpace.exists",
+          "start": [
+            91,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Bundle.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Bundle.TotalSpace.mk_injective",
+        "id": "Bundle.TotalSpace.mk_injective",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            78,
+            11
+          ],
+          "file_path": "Mathlib/Data/Bundle.lean",
+          "full_name": "Bundle.TotalSpace.mk_injective",
+          "start": [
+            77,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Bundle.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Nat.Up.WF",
+        "id": "Nat.Up.WF",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            19,
+            88
+          ],
+          "file_path": "Mathlib/Data/ByteArray.lean",
+          "full_name": "Nat.Up.WF",
+          "start": [
+            18,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/ByteArray.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Nat.Up.next",
+        "id": "Nat.Up.next",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            16,
+            79
+          ],
+          "file_path": "Mathlib/Data/ByteArray.lean",
+          "full_name": "Nat.Up.next",
+          "start": [
+            16,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/ByteArray.lean"
+      }
+    ],
+    "input_proofs": 9,
+    "input_units": 2,
+    "proofs": 3,
+    "published_proofs": 2,
+    "published_transitions": 3,
+    "replay_failures": [],
+    "transitions": 8,
+    "validation_failures": [
+      {
+        "errors": [
+          "internal transition boundary mismatch",
+          "internal transition boundary mismatch"
+        ],
+        "file_path": "Mathlib/Data/Bundle.lean",
+        "proof_id": "mathlib:Bundle.TotalSpace.range_mk",
+        "provenance": {
+          "selection": {
+            "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+            "end": [
+              100,
+              19
+            ],
+            "file_path": "Mathlib/Data/Bundle.lean",
+            "full_name": "Bundle.TotalSpace.range_mk",
+            "start": [
+              95,
+              1
+            ],
+            "traced_tactics": [
+              {
+                "annotated_tactic": [
+                  "\"apply <a>Subset.antisymm<\\/a>\"",
+                  "[{\"full_name\":\"Set.Subset.antisymm\",\"def_path\":\"Mathlib\\/Data\\/Set\\/Basic.lean\",\"def_pos\":[347,9],\"def_end_pos\":[347,24]}]"
+                ],
+                "state_after": "case h\u2081\nB : Type u_1\nF : Type u_2\nE : B \u2192 Type u_3\nb : B\n\u22a2 range (mk b) \u2286 proj \u207b\u00b9' {b}\n\ncase h\u2082\nB : Type u_1\nF : Type u_2\nE : B \u2192 Type u_3\nb : B\n\u22a2 proj \u207b\u00b9' {b} \u2286 range (mk b)",
+                "state_before": "B : Type u_1\nF : Type u_2\nE : B \u2192 Type u_3\nb : B\n\u22a2 range (mk b) = proj \u207b\u00b9' {b}",
+                "tactic": "apply Subset.antisymm"
+              },
+              {
+                "annotated_tactic": [
+                  "\"rintro _ \\u27e8x, rfl\\u27e9\"",
+                  "[]"
+                ],
+                "state_after": "case h\u2081.intro\nB : Type u_1\nF : Type u_2\nE : B \u2192 Type u_3\nb : B\nx : E b\n\u22a2 { proj := b, snd := x } \u2208 proj \u207b\u00b9' {b}",
+                "state_before": "case h\u2081\nB : Type u_1\nF : Type u_2\nE : B \u2192 Type u_3\nb : B\n\u22a2 range (mk b) \u2286 proj \u207b\u00b9' {b}",
+                "tactic": "rintro _ \u27e8x, rfl\u27e9"
+              },
+              {
+                "annotated_tactic": [
+                  "\"rfl\"",
+                  "[]"
+                ],
+                "state_after": "no goals",
+                "state_before": "case h\u2081.intro\nB : Type u_1\nF : Type u_2\nE : B \u2192 Type u_3\nb : B\nx : E b\n\u22a2 { proj := b, snd := x } \u2208 proj \u207b\u00b9' {b}",
+                "tactic": "rfl"
+              },
+              {
+                "annotated_tactic": [
+                  "\"rintro \\u27e8_, x\\u27e9 rfl\"",
+                  "[]"
+                ],
+                "state_after": "case h\u2082.mk\nB : Type u_1\nF : Type u_2\nE : B \u2192 Type u_3\nproj\u271d : B\nx : E proj\u271d\n\u22a2 { proj := proj\u271d, snd := x } \u2208 range (mk { proj := proj\u271d, snd := x }.proj)",
+                "state_before": "case h\u2082\nB : Type u_1\nF : Type u_2\nE : B \u2192 Type u_3\nb : B\n\u22a2 proj \u207b\u00b9' {b} \u2286 range (mk b)",
+                "tactic": "rintro \u27e8_, x\u27e9 rfl"
+              },
+              {
+                "annotated_tactic": [
+                  "\"exact \\u27e8x, <a>rfl<\\/a>\\u27e9\"",
+                  "[{\"full_name\":\"rfl\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[294,22],\"def_end_pos\":[294,25]}]"
+                ],
+                "state_after": "no goals",
+                "state_before": "case h\u2082.mk\nB : Type u_1\nF : Type u_2\nE : B \u2192 Type u_3\nproj\u271d : B\nx : E proj\u271d\n\u22a2 { proj := proj\u271d, snd := x } \u2208 range (mk { proj := proj\u271d, snd := x }.proj)",
+                "tactic": "exact \u27e8x, rfl\u27e9"
+              }
+            ],
+            "url": "https://github.com/leanprover-community/mathlib4"
+          }
+        },
+        "theorem_name": "Bundle.TotalSpace.range_mk"
+      }
+    ],
+    "validation_rejected_proofs": 1,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/mathlib-000877-0000-ecac367b5e72dd77.parquet",
+      "sha256": "ecac367b5e72dd775353dabf17db341c7469fa7e9d3b1aad6f91d94d63a32a2f",
+      "bytes": 31760,
+      "rows": 3,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    }
+  ],
+  "proof_ids": [
+    "mathlib:Bundle.TotalSpace.mk_cast",
+    "mathlib:Bundle.TotalSpace.mk_inj"
+  ],
+  "proof_keys": [
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bundle.lean\",null,null,\"Bundle.TotalSpace.mk_cast\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Bundle.lean\",null,null,\"Bundle.TotalSpace.mk_inj\"]"
+  ]
+}

manifests/batches/mathlib/000879.json

@@ -0,0 +1,128 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "mathlib/000879",
+  "batch_fingerprint": "d56f4ba3d9971c51b9424d0402d854b357a113cbce1d9ec4ce29522de4e5faa8",
+  "evidence": {
+    "batch_fingerprint": "d56f4ba3d9971c51b9424d0402d854b357a113cbce1d9ec4ce29522de4e5faa8",
+    "contamination_matches": [],
+    "failures": [
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Complex.im_sum",
+        "id": "Complex.im_sum",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            37,
+            28
+          ],
+          "file_path": "Mathlib/Data/Complex/BigOperators.lean",
+          "full_name": "Complex.im_sum",
+          "start": [
+            36,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Complex/BigOperators.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Complex.ofReal_prod",
+        "id": "Complex.ofReal_prod",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            22,
+            22
+          ],
+          "file_path": "Mathlib/Data/Complex/BigOperators.lean",
+          "full_name": "Complex.ofReal_prod",
+          "start": [
+            21,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Complex/BigOperators.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Complex.ofReal_sum",
+        "id": "Complex.ofReal_sum",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            27,
+            21
+          ],
+          "file_path": "Mathlib/Data/Complex/BigOperators.lean",
+          "full_name": "Complex.ofReal_sum",
+          "start": [
+            26,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Complex/BigOperators.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "Complex.re_sum",
+        "id": "Complex.re_sum",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            32,
+            28
+          ],
+          "file_path": "Mathlib/Data/Complex/BigOperators.lean",
+          "full_name": "Complex.re_sum",
+          "start": [
+            31,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/Data/Complex/BigOperators.lean"
+      }
+    ],
+    "input_proofs": 7,
+    "input_units": 2,
+    "proofs": 3,
+    "published_proofs": 3,
+    "published_transitions": 4,
+    "replay_failures": [],
+    "transitions": 4,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/mathlib-000879-0000-f9fa4549df41225c.parquet",
+      "sha256": "f9fa4549df41225c80a5de200b6332c8ef164736737b835fc4890ff4c00a350f",
+      "bytes": 43939,
+      "rows": 4,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    }
+  ],
+  "proof_ids": [
+    "mathlib:mk_complex",
+    "mathlib:mk_univ_complex",
+    "mathlib:not_countable_complex"
+  ],
+  "proof_keys": [
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Complex/Cardinality.lean\",null,null,\"mk_complex\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Complex/Cardinality.lean\",null,null,\"mk_univ_complex\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/Data/Complex/Cardinality.lean\",null,null,\"not_countable_complex\"]"
+  ]
+}

manifests/batches/numina/001630.json

@@ -0,0 +1,58 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "numina/001630",
+  "batch_fingerprint": "52389ba4bc40e0f9e1f685ba7ce7b3a82d24f2a9e50ab10178ea8aa85794e65b",
+  "evidence": {
+    "batch_fingerprint": "52389ba4bc40e0f9e1f685ba7ce7b3a82d24f2a9e50ab10178ea8aa85794e65b",
+    "contamination_matches": [],
+    "failures": [],
+    "input_proofs": 5,
+    "input_units": 5,
+    "proofs": 5,
+    "published_proofs": 5,
+    "published_transitions": 25,
+    "replay_failures": [],
+    "trace_mode": "bundle",
+    "transitions": 25,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/numina-001630-0000-a746a2cdaf457218.parquet",
+      "sha256": "a746a2cdaf4572182f9f1942b7f9c8617ab623d410a54fb8dd7c99e85325a1e7",
+      "bytes": 56399,
+      "rows": 7,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    },
+    {
+      "path": "data/dev/numina-001630-0000-a1327dd0a27a1a6c.parquet",
+      "sha256": "a1327dd0a27a1a6c56bec44ebc7e738f3d32017bd28d653a4f449fc76e66adb5",
+      "bytes": 138087,
+      "rows": 4,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    },
+    {
+      "path": "data/internal_test/numina-001630-0000-da8259f85ef08836.parquet",
+      "sha256": "da8259f85ef088362c43253641ff5005bf8fd2d4fa36d0e9c8cceec4dc3ba204",
+      "bytes": 357580,
+      "rows": 14,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    }
+  ],
+  "proof_ids": [
+    "numina:4605a5d8-2075-5498-83ea-ec40974b1b72",
+    "numina:5d1e3d23-8bb6-580d-8acc-995defc49d6e",
+    "numina:6e2dc401-e159-594a-bd2f-dd52de27bedb",
+    "numina:926b6029-7a9d-56f1-9d99-850851b2b42f",
+    "numina:a9cebebd-a9b6-5bbc-b8fb-2ce483a86692"
+  ],
+  "proof_keys": [
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008150.lean\",\"231b89b9770ce6b251f8fe3afeedd7c5700a7089875e58da138af0635e34a348\",0,\"algebra_611017\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008151.lean\",\"795d11c484a45ab4db4c9e1b0191843cb27820ad4e09f36f502bd999ae9eb37a\",0,\"calculus_23401\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008152.lean\",\"c739abe8a72a4d397395489d317bdc4cfc71d01556ff11d0f6a97b27e752c841\",0,\"algebra_251758\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008153.lean\",\"449e14af4dc8dae3b469cff267e79a5cb6cbc56899e8abc089fa54cfeeb0fd78\",0,\"number_theory_98368\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008154.lean\",\"8f9b6f7e07cf5dff9d026e5ded54ac45f6428dd28ed19ed6936d6b603f3751f0\",0,\"number_theory_605529\"]"
+  ]
+}

manifests/batches/numina/001631.json

@@ -0,0 +1,44 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "numina/001631",
+  "batch_fingerprint": "671e2e2c2775117fe616a65e399307fbcd855f9b2a407eab4741901e5404506e",
+  "evidence": {
+    "batch_fingerprint": "671e2e2c2775117fe616a65e399307fbcd855f9b2a407eab4741901e5404506e",
+    "contamination_matches": [],
+    "failures": [],
+    "input_proofs": 5,
+    "input_units": 5,
+    "proofs": 5,
+    "published_proofs": 5,
+    "published_transitions": 42,
+    "replay_failures": [],
+    "trace_mode": "bundle",
+    "transitions": 42,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/numina-001631-0000-4c13227068866f04.parquet",
+      "sha256": "4c13227068866f044fd0de7a6edfa93b9531377227f0b68a092b768cac5d09f0",
+      "bytes": 643798,
+      "rows": 42,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    }
+  ],
+  "proof_ids": [
+    "numina:38784c8a-b826-5b1b-8ee6-140904c676b6",
+    "numina:5bc51951-a1b7-5aed-88b2-1e37b5e5dde5",
+    "numina:7403e3c1-4633-58d7-bb66-dfb4c263e8cc",
+    "numina:b175bebe-b3e3-5273-83a1-1b03f8917d6c",
+    "numina:eb2eac58-4526-5c8d-9a1e-0c86b6e11373"
+  ],
+  "proof_keys": [
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008155.lean\",\"096d9a36f1a1baadc48fa4593c25596b874543f2fd33589974b3d728ed15d1a2\",0,\"Algebra_9432\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008156.lean\",\"3fdfb04662617c41e3ab8294cf2dcac23bf93d22f3e88a3c90c98d429c370479\",0,\"algebra_20530\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008157.lean\",\"37bf7c858acd189aebf63c706c39adad70955600a7b42397a1d4dd757c6113f8\",0,\"number_theory_19241\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008158.lean\",\"0c3d50a51981dcccfd6704f29cb7daec351568ca89e612fb25b45b1e5cbd4f17\",0,\"algebra_24341\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008159.lean\",\"103cb5dcede1bbabff95f37eb080e5ceb60c65f90ddfab7df96f8c31832ab8ee\",0,\"algebra_609070\"]"
+  ]
+}

manifests/batches/numina/001632.json

@@ -0,0 +1,44 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "numina/001632",
+  "batch_fingerprint": "89ae3e26c79ef8bae213e7ee08705104cf96b4efbeb1bb3c55d08e82ba1337a1",
+  "evidence": {
+    "batch_fingerprint": "89ae3e26c79ef8bae213e7ee08705104cf96b4efbeb1bb3c55d08e82ba1337a1",
+    "contamination_matches": [],
+    "failures": [],
+    "input_proofs": 5,
+    "input_units": 5,
+    "proofs": 5,
+    "published_proofs": 5,
+    "published_transitions": 44,
+    "replay_failures": [],
+    "trace_mode": "bundle",
+    "transitions": 44,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/numina-001632-0000-a4d17d44ee4e72d8.parquet",
+      "sha256": "a4d17d44ee4e72d891aa821c7d73ee742d758ff4e5b7333fb9c8f39bc43587b5",
+      "bytes": 480719,
+      "rows": 44,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    }
+  ],
+  "proof_ids": [
+    "numina:03542350-82cc-55e1-80ae-8ac07bd2d7d8",
+    "numina:5b7914b9-62b1-5a76-a750-6b77e590fbe2",
+    "numina:91c30962-c0bc-5ed0-90d2-0bf1c8745afd",
+    "numina:ca2874ed-6b10-565c-a82e-ffed45231803",
+    "numina:cdf521c8-e786-5f00-bacf-4886391548d8"
+  ],
+  "proof_keys": [
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008160.lean\",\"b44bb6a6020234010345b2ac1954b8069003d5f5c59911dd5013e5da33205ce5\",0,\"algebra_173356\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008161.lean\",\"0e828d97d62fe1eb993a70f1afeb769a4a28798cb0e9f64d05ffe86b071488a4\",0,\"algebra_313892\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008162.lean\",\"963f0019d97172248c2dcaf60e5154bb57851e6aed9d76b864dad611948a0e0e\",0,\"number_theory_605636\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008163.lean\",\"cfcade8796d22c3c03e694fafbbc23ba4d1cfd623ded084f5b9423d34b2ef0ab\",0,\"algebra_131612\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008164.lean\",\"3d93e9084bad51083edaab43766e653543fc0f44e0f1710e8b8ab360959a13e5\",0,\"algebra_9320\"]"
+  ]
+}

manifests/batches/numina/001634.json

@@ -0,0 +1,51 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "numina/001634",
+  "batch_fingerprint": "f8098728d5579e37f06daa53a8db81b2145e353963b67474f3f0b7a966b35194",
+  "evidence": {
+    "batch_fingerprint": "f8098728d5579e37f06daa53a8db81b2145e353963b67474f3f0b7a966b35194",
+    "contamination_matches": [],
+    "failures": [],
+    "input_proofs": 5,
+    "input_units": 5,
+    "proofs": 5,
+    "published_proofs": 5,
+    "published_transitions": 39,
+    "replay_failures": [],
+    "trace_mode": "bundle",
+    "transitions": 39,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/numina-001634-0000-0353f6521d60283c.parquet",
+      "sha256": "0353f6521d60283c66e30db7296ea50577c6255db971a0e0d6ee9393b1b99e58",
+      "bytes": 270776,
+      "rows": 23,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    },
+    {
+      "path": "data/internal_test/numina-001634-0000-41fdc09d7e6fecd4.parquet",
+      "sha256": "41fdc09d7e6fecd46308b8aa323c169f77d5c53d104874a739adab76be6fc5db",
+      "bytes": 124682,
+      "rows": 16,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    }
+  ],
+  "proof_ids": [
+    "numina:0afd1fb7-998a-5c06-92b0-828b600962fe",
+    "numina:1f76092e-ebc5-5f7e-b74f-704670f7d98e",
+    "numina:37334f86-c8dc-5d14-8f29-e634e7378475",
+    "numina:b2b6ffb1-3b33-53c3-8d3c-a161b4067b51",
+    "numina:c5e2a229-5681-56fe-aef5-f99371527a7f"
+  ],
+  "proof_keys": [
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008170.lean\",\"a424012af73dea2c02337ec86029c5130171bc0d56c859d472450034baa30ba5\",0,\"intermediate_algebra_4101\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008171.lean\",\"06db6f930223ce8571e5e34ad4e7caf867c1fc9d570eb4a38da153764d1abda4\",0,\"inequalities_131615\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008172.lean\",\"5336dd88eb0acf3a0ec14b49eb429bf9aa6afe0ff01966051b5b35ec03b22596\",0,\"number_theory_206892\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008173.lean\",\"148dbb0313bc81a75007e5a8839429afafb080811bc2b4395bd92e977138da2c\",0,\"algebra_10261\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008174.lean\",\"0255427c6eb2b7d56b89d99941af90fd02cc21176650a6f2982bc549ab19457f\",0,\"algebra_14362\"]"
+  ]
+}

manifests/batches/numina/001635.json

@@ -0,0 +1,70 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "numina/001635",
+  "batch_fingerprint": "32780c9e6cf38275860ed3bb628caae946b8931129aa05520898dded0c43d833",
+  "evidence": {
+    "batch_fingerprint": "32780c9e6cf38275860ed3bb628caae946b8931129aa05520898dded0c43d833",
+    "bundle_error": "helper declarations require isolated extraction",
+    "contamination_matches": [],
+    "failures": [],
+    "input_proofs": 5,
+    "input_units": 5,
+    "proofs": 5,
+    "published_proofs": 4,
+    "published_transitions": 41,
+    "replay_failures": [],
+    "trace_mode": "individual",
+    "transitions": 44,
+    "validation_failures": [
+      {
+        "errors": [
+          "internal transition boundary mismatch",
+          "internal transition boundary mismatch"
+        ],
+        "file_path": "Full/Proof_008178.lean",
+        "proof_id": "numina:5a6cc050-ab23-5a5e-9272-6135966f3371",
+        "provenance": {
+          "atomic_transition_count": 3,
+          "compound_transition_count": 0,
+          "declaration_kind": "theorem",
+          "metadata": {
+            "declaration_kind": "theorem",
+            "source_dataset": "numina",
+            "theorem_name": "number_theory_4632_c",
+            "theorem_ordinal": 2
+          },
+          "selection_index": 8178,
+          "source_dataset": "numina",
+          "source_id": "5a6cc050-ab23-5a5e-9272-6135966f3371",
+          "source_sha256": "fe73f7d338c2b14b9f1cd47626c6bbe021088f10ef8229023296cb2054495617",
+          "theorem_name": "number_theory_4632_c",
+          "theorem_ordinal": 2
+        },
+        "theorem_name": "number_theory_4632_c"
+      }
+    ],
+    "validation_rejected_proofs": 1,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/numina-001635-0000-911c170a6ef828ea.parquet",
+      "sha256": "911c170a6ef828ea9141b6540faecf1091248279f4af89c854ff82aee69c428a",
+      "bytes": 816221,
+      "rows": 41,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    }
+  ],
+  "proof_ids": [
+    "numina:5c84e4c0-1400-5ca9-8e6e-18816102c237",
+    "numina:64cde559-14ca-5926-b4e6-7a3050268856",
+    "numina:8b7649ad-b004-55f8-bce9-d0a381dae0f2",
+    "numina:ec57f7cf-845a-54fb-9006-cbe1d5ad8a54"
+  ],
+  "proof_keys": [
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008175.lean\",\"b0f38cbccd3e41154de085d7555ace92b060d63490b1d9f475b0165563b7f1e1\",0,\"algebra_18771\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008176.lean\",\"738cb6195c7eb7175df4f7afe6c0e30ba7b4053207ac172db67186670efd6a88\",0,\"algebra_159395\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008177.lean\",\"534f3c04b535400bf2fa4a65ffeffa772c3496666f38afb300f572b07f9dea7c\",0,\"inequalities_605656\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008179.lean\",\"3a1d31672fe65b545b9ab38335ebb225189ca7edf603121466ffcfba2beac850\",0,\"algebra_94934\"]"
+  ]
+}

manifests/batches/numina/001636.json

@@ -0,0 +1,73 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "numina/001636",
+  "batch_fingerprint": "6d7f950ee08788d6ff88fd7195854ab920337328de3194e795ff9c2188e9e992",
+  "evidence": {
+    "batch_fingerprint": "6d7f950ee08788d6ff88fd7195854ab920337328de3194e795ff9c2188e9e992",
+    "contamination_matches": [],
+    "failures": [],
+    "input_proofs": 5,
+    "input_units": 5,
+    "proofs": 5,
+    "published_proofs": 4,
+    "published_transitions": 35,
+    "replay_failures": [],
+    "trace_mode": "bundle",
+    "transitions": 40,
+    "validation_failures": [
+      {
+        "errors": [
+          "internal transition boundary mismatch",
+          "internal transition boundary mismatch"
+        ],
+        "file_path": "Full/Proof_008181.lean",
+        "proof_id": "numina:372c0ff5-3981-58db-8cf7-4335b780a1c1",
+        "provenance": {
+          "atomic_transition_count": 12,
+          "bundle_ordinal": 1,
+          "compound_transition_count": 1,
+          "declaration_kind": "theorem",
+          "metadata": {
+            "bundle_ordinal": 1,
+            "declaration_kind": "theorem",
+            "original_file_path": "Full/Proof_008181.lean",
+            "source_dataset": "numina",
+            "theorem_name": "number_theory_230706",
+            "theorem_ordinal": 0
+          },
+          "original_file_path": "Full/Proof_008181.lean",
+          "selection_index": 8181,
+          "source_dataset": "numina",
+          "source_id": "372c0ff5-3981-58db-8cf7-4335b780a1c1",
+          "source_sha256": "641a4b4d2a062c25e8ee4ba4dd453ff72e36f73dd619556a763d3dbf91f8359d",
+          "theorem_name": "number_theory_230706",
+          "theorem_ordinal": 0
+        },
+        "theorem_name": "number_theory_230706"
+      }
+    ],
+    "validation_rejected_proofs": 1,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/numina-001636-0000-a05dd977961d5899.parquet",
+      "sha256": "a05dd977961d589910c0849ce0a73b1c4b8a2077a6505866915e2a0dc1d70503",
+      "bytes": 293011,
+      "rows": 35,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    }
+  ],
+  "proof_ids": [
+    "numina:1887e0f0-368b-53e5-94d7-2dbdb9552a2a",
+    "numina:8a1fa5e8-0c2f-5eff-a218-547348d2c5a4",
+    "numina:fde9df8e-a136-5e7f-b693-871a954548bd",
+    "numina:ff24e8c1-5511-5159-8ba0-388dcb19641a"
+  ],
+  "proof_keys": [
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008180.lean\",\"51daab7b6261e671965a2160b39fca4f65996d0b2b62802f3b74db92fcfeec13\",0,\"algebra_131847\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008182.lean\",\"19b91ea1d93f518ae37296671979f6b21291585de353fb83d4041bff5667e7fe\",0,\"algebra_610682\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008183.lean\",\"b418aa73d20ac31b5883bd79f984e0361c7cb370711af635b952961f4e6cffa6\",0,\"algebra_18775\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008184.lean\",\"21b3b3f566327736c8a70c0b08b1cb1313f8439711781592676fa81962a9bae9\",0,\"inequalities_159432\"]"
+  ]
+}

manifests/batches/numina/001637.json

@@ -0,0 +1,51 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "numina/001637",
+  "batch_fingerprint": "5fbde294e9b49b64823b3a59277e0a9e065cd7719f90fbb993756d0f0fafae00",
+  "evidence": {
+    "batch_fingerprint": "5fbde294e9b49b64823b3a59277e0a9e065cd7719f90fbb993756d0f0fafae00",
+    "contamination_matches": [],
+    "failures": [],
+    "input_proofs": 5,
+    "input_units": 5,
+    "proofs": 5,
+    "published_proofs": 5,
+    "published_transitions": 24,
+    "replay_failures": [],
+    "trace_mode": "bundle",
+    "transitions": 24,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/numina-001637-0000-a8b23ece4a4a660a.parquet",
+      "sha256": "a8b23ece4a4a660a31184ac2336183841c4e0b54db698af1f4a9fc254595f385",
+      "bytes": 169126,
+      "rows": 19,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    },
+    {
+      "path": "data/internal_test/numina-001637-0000-e138833035b68d1b.parquet",
+      "sha256": "e138833035b68d1bea353a2b55b71254952ba898e4ad403ebf40b7022af31b28",
+      "bytes": 119132,
+      "rows": 5,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    }
+  ],
+  "proof_ids": [
+    "numina:5328b332-a67b-5cc1-b00d-513a3d792e7e",
+    "numina:606263d6-1eb6-52bb-b391-136444693c17",
+    "numina:aa1b58ca-1850-5004-a691-261b26b5af9c",
+    "numina:d38b78e6-f3a4-500c-8fa2-e70963a6a423",
+    "numina:d65c7cb3-0bfc-5159-b102-e69609dc0da9"
+  ],
+  "proof_keys": [
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008185.lean\",\"525c16499fc4d2a50f7a5a29619dc2a3cb81ac10df5f28a175a77e8eac798cc4\",0,\"number_theory_600015\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008186.lean\",\"db6da59e9094bf46181dda983e17cc40b892a2b8dc5bdb0812b4f8feda631f7d\",0,\"calculus_22878'\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008187.lean\",\"abfa786fe7b590ae820513050eca728fe2c5de210bcfca555a51add977960592\",0,\"number_theory_4637\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008188.lean\",\"82a051fbaea11fec704f4e77bcfbf4cdabbf7cc2bbe450278588dd03374cd95a\",0,\"algebra_10264\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008189.lean\",\"e93c531c2c9ddb0134ea6d9298a9fef54d2302531848067e4f540059daf82134\",0,\"Inequalities_288589\"]"
+  ]
+}

manifests/batches/numina/001638.json

@@ -0,0 +1,52 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "numina/001638",
+  "batch_fingerprint": "f83c668e7054aae01cb913c37ce6a2f2491b8a677481d9736d620806cfee1ea6",
+  "evidence": {
+    "batch_fingerprint": "f83c668e7054aae01cb913c37ce6a2f2491b8a677481d9736d620806cfee1ea6",
+    "bundle_error": "helper declarations require isolated extraction",
+    "contamination_matches": [],
+    "failures": [],
+    "input_proofs": 5,
+    "input_units": 5,
+    "proofs": 5,
+    "published_proofs": 5,
+    "published_transitions": 22,
+    "replay_failures": [],
+    "trace_mode": "individual",
+    "transitions": 22,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/numina-001638-0000-0dabd8c4ada6d1b5.parquet",
+      "sha256": "0dabd8c4ada6d1b515c38b35c5b2b1f1412dd6d257d988609c57aa82bee3bc26",
+      "bytes": 119987,
+      "rows": 15,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    },
+    {
+      "path": "data/internal_test/numina-001638-0000-2082dc95b5018a37.parquet",
+      "sha256": "2082dc95b5018a379d6a5ddd1eb9e808fa2da2c6bbe6b1b65646675dbc73d82b",
+      "bytes": 44027,
+      "rows": 7,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    }
+  ],
+  "proof_ids": [
+    "numina:873d18a3-79f2-5942-be59-bf0cc35e1643",
+    "numina:993b7ef0-e80c-58ef-a348-a5cf0216b8bd",
+    "numina:b6cf8943-34c6-583d-bbfc-b0ecf8062b0e",
+    "numina:bb053727-eb86-50ea-ae41-94bd6c8fcfd6",
+    "numina:dab64865-2b2d-5282-8f73-00bbb12c6b67"
+  ],
+  "proof_keys": [
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008190.lean\",\"4fb678d6ab4b19bb518ecf722630d24668b5ec45d06060e05e01a4981efc22f2\",0,\"number_theory_22879\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008191.lean\",\"78e9198d8c4ecd157f446d5f32b8ba41b381c93dac0a794773751cd4d356ab3f\",0,\"algebra_291411\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008192.lean\",\"fb151e454113ddcbe2a9c1c9beff4aa2c36b9c5ee10de1c475d81e4ecdcf7132\",1,\"algebra_104872'\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008193.lean\",\"cc9dad5b4930fbfdd61f6f6782031348a7ab10821c3c2c5a43ab3f9654e6db6b\",0,\"number_theory_4703\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008194.lean\",\"b1189a940e8ac87977700c77e4440ff6003c6125d3ee04f485a0a3b0a3a0e651\",0,\"algebra_132072\"]"
+  ]
+}

manifests/batches/numina/001639.json

@@ -0,0 +1,52 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "numina/001639",
+  "batch_fingerprint": "1b8de6f6ecf9c8e42348ce7eab8e3598a6b9b75f516f30d024d8ec3bc6134dc7",
+  "evidence": {
+    "batch_fingerprint": "1b8de6f6ecf9c8e42348ce7eab8e3598a6b9b75f516f30d024d8ec3bc6134dc7",
+    "bundle_error": "helper declarations require isolated extraction",
+    "contamination_matches": [],
+    "failures": [],
+    "input_proofs": 5,
+    "input_units": 5,
+    "proofs": 5,
+    "published_proofs": 5,
+    "published_transitions": 33,
+    "replay_failures": [],
+    "trace_mode": "individual",
+    "transitions": 33,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/numina-001639-0000-37e29292542ba100.parquet",
+      "sha256": "37e29292542ba100994ac7d36b6573d58144a5ae013207ac330175935ff9a078",
+      "bytes": 191072,
+      "rows": 19,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    },
+    {
+      "path": "data/internal_test/numina-001639-0000-5c10de00bfeb9dc4.parquet",
+      "sha256": "5c10de00bfeb9dc46cd117554edbe8e6eb9b8408c7ff071107c037467acc72f1",
+      "bytes": 77906,
+      "rows": 14,
+      "revision": "fc49ae0e4fe5737bf4bdb6aa58d2518b6704b5f3"
+    }
+  ],
+  "proof_ids": [
+    "numina:41087634-473a-5eb4-9b81-40b82e64467d",
+    "numina:589e666d-f937-59d6-bcf1-60cc3869514d",
+    "numina:6713064f-bc63-5946-bad9-f334eaf381ba",
+    "numina:bb5a8572-d1f3-5ca8-81f8-c3b2379667f5",
+    "numina:f56e7f55-76c4-5aff-aab5-da4d8bd69fbd"
+  ],
+  "proof_keys": [
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008195.lean\",\"6fbdb526170b36588236ac5b03b159cf3d545f99ea3242b56b7091efd5206ab0\",0,\"number_theory_288596\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008196.lean\",\"81b588861fd958dcafb06e6cedf99547a37298b6d47bf7dcb4b53336cceb71af\",0,\"algebra_284148\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008197.lean\",\"7978dcf9139e9ea02fb154debc9bde63935811e6d44b1e76aaf25d9b3df79ac7\",0,\"number_theory_600011\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008198.lean\",\"712faf418e392fda559c9d8593f53a94adaf1828703b45f549a8023f500c5033\",0,\"algebra_108556\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_008199.lean\",\"eb9190b881781b2a74003b06b9ff078979d526efc31a3bfc9139523c36a08f17\",3,\"number_theory_4709\"]"
+  ]
+}