Record 21 verified HPC batch manifests

manifests/batches/mathlib/000710.json

@@ -0,0 +1,1574 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "mathlib/000710",
+  "batch_fingerprint": "9740afea20c13ec16c97f381fa1d447e3c236a973d06206016410406ff84ac70",
+  "evidence": {
+    "batch_fingerprint": "9740afea20c13ec16c97f381fa1d447e3c236a973d06206016410406ff84ac70",
+    "contamination_matches": [],
+    "failures": [
+      {
+        "error": "no internal trace for tactic 'exact (hF _).eq_of_src _ _'",
+        "full_name": "CategoryTheory.Functor.isZero",
+        "id": "CategoryTheory.Functor.isZero",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            163,
+            31
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean",
+          "full_name": "CategoryTheory.Functor.isZero",
+          "start": [
+            146,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"constructor <;> intro G <;> refine \\u27e8\\u27e8\\u27e8?_\\u27e9, ?_\\u27e9\\u27e9\"",
+                "[]"
+              ],
+              "state_after": "case unique_to.refine_1\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nF : C \u2964 D\nhF : \u2200 (X : C), IsZero (F.obj X)\nG : C \u2964 D\n\u22a2 F \u27f6 G\n\ncase unique_to.refine_2\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nF : C \u2964 D\nhF : \u2200 (X : C), IsZero (F.obj X)\nG : C \u2964 D\n\u22a2 \u2200 (a : F \u27f6 G), a = default\n\ncase unique_from.refine_1\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nF : C \u2964 D\nhF : \u2200 (X : C), IsZero (F.obj X)\nG : C \u2964 D\n\u22a2 G \u27f6 F\n\ncase unique_from.refine_2\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nF : C \u2964 D\nhF : \u2200 (X : C), IsZero (F.obj X)\nG : C \u2964 D\n\u22a2 \u2200 (a : G \u27f6 F), a = default",
+              "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nF : C \u2964 D\nhF : \u2200 (X : C), IsZero (F.obj X)\n\u22a2 IsZero F",
+              "tactic": "constructor <;> intro G <;> refine \u27e8\u27e8\u27e8?_\u27e9, ?_\u27e9\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"refine\\n      { app := fun X => (hF _).<a>to_<\\/a> _\\n        naturality := ?_ }\"",
+                "[{\"full_name\":\"CategoryTheory.Limits.IsZero.to_\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/ZeroObjects.lean\",\"def_pos\":[55,15],\"def_end_pos\":[55,18]}]"
+              ],
+              "state_after": "case unique_to.refine_1\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nF : C \u2964 D\nhF : \u2200 (X : C), IsZero (F.obj X)\nG : C \u2964 D\n\u22a2 \u2200 \u2983X Y : C\u2984 (f : X \u27f6 Y), F.map f \u226b (fun X => \u22ef.to_ (G.obj X)) Y = (fun X => \u22ef.to_ (G.obj X)) X \u226b G.map f",
+              "state_before": "case unique_to.refine_1\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nF : C \u2964 D\nhF : \u2200 (X : C), IsZero (F.obj X)\nG : C \u2964 D\n\u22a2 F \u27f6 G",
+              "tactic": "refine\n  { app := fun X => (hF _).to_ _\n    naturality := ?_ }"
+            },
+            {
+              "annotated_tactic": [
+                "\"intros\"",
+                "[]"
+              ],
+              "state_after": "case unique_to.refine_1\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nF : C \u2964 D\nhF : \u2200 (X : C), IsZero (F.obj X)\nG : C \u2964 D\nX\u271d Y\u271d : C\nf\u271d : X\u271d \u27f6 Y\u271d\n\u22a2 F.map f\u271d \u226b (fun X => \u22ef.to_ (G.obj X)) Y\u271d = (fun X => \u22ef.to_ (G.obj X)) X\u271d \u226b G.map f\u271d",
+              "state_before": "case unique_to.refine_1\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nF : C \u2964 D\nhF : \u2200 (X : C), IsZero (F.obj X)\nG : C \u2964 D\n\u22a2 \u2200 \u2983X Y : C\u2984 (f : X \u27f6 Y), F.map f \u226b (fun X => \u22ef.to_ (G.obj X)) Y = (fun X => \u22ef.to_ (G.obj X)) X \u226b G.map f",
+              "tactic": "intros"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact (hF _).<a>eq_of_src<\\/a> _ _\"",
+                "[{\"full_name\":\"CategoryTheory.Limits.IsZero.eq_of_src\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/ZeroObjects.lean\",\"def_pos\":[81,9],\"def_end_pos\":[81,18]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case unique_to.refine_1\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nF : C \u2964 D\nhF : \u2200 (X : C), IsZero (F.obj X)\nG : C \u2964 D\nX\u271d Y\u271d : C\nf\u271d : X\u271d \u27f6 Y\u271d\n\u22a2 F.map f\u271d \u226b (fun X => \u22ef.to_ (G.obj X)) Y\u271d = (fun X => \u22ef.to_ (G.obj X)) X\u271d \u226b G.map f\u271d",
+              "tactic": "exact (hF _).eq_of_src _ _"
+            },
+            {
+              "annotated_tactic": [
+                "\"intro f\"",
+                "[]"
+              ],
+              "state_after": "case unique_to.refine_2\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nF : C \u2964 D\nhF : \u2200 (X : C), IsZero (F.obj X)\nG : C \u2964 D\nf : F \u27f6 G\n\u22a2 f = default",
+              "state_before": "case unique_to.refine_2\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nF : C \u2964 D\nhF : \u2200 (X : C), IsZero (F.obj X)\nG : C \u2964 D\n\u22a2 \u2200 (a : F \u27f6 G), a = default",
+              "tactic": "intro f"
+            },
+            {
+              "annotated_tactic": [
+                "\"ext\"",
+                "[]"
+              ],
+              "state_after": "case unique_to.refine_2.w.h\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nF : C \u2964 D\nhF : \u2200 (X : C), IsZero (F.obj X)\nG : C \u2964 D\nf : F \u27f6 G\nx\u271d : C\n\u22a2 f.app x\u271d = default.app x\u271d",
+              "state_before": "case unique_to.refine_2\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nF : C \u2964 D\nhF : \u2200 (X : C), IsZero (F.obj X)\nG : C \u2964 D\nf : F \u27f6 G\n\u22a2 f = default",
+              "tactic": "ext"
+            },
+            {
+              "annotated_tactic": [
+                "\"apply (hF _).<a>eq_of_src<\\/a> _ _\"",
+                "[{\"full_name\":\"CategoryTheory.Limits.IsZero.eq_of_src\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/ZeroObjects.lean\",\"def_pos\":[81,9],\"def_end_pos\":[81,18]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case unique_to.refine_2.w.h\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nF : C \u2964 D\nhF : \u2200 (X : C), IsZero (F.obj X)\nG : C \u2964 D\nf : F \u27f6 G\nx\u271d : C\n\u22a2 f.app x\u271d = default.app x\u271d",
+              "tactic": "apply (hF _).eq_of_src _ _"
+            },
+            {
+              "annotated_tactic": [
+                "\"refine\\n      { app := fun X => (hF _).<a>from_<\\/a> _\\n        naturality := ?_ }\"",
+                "[{\"full_name\":\"CategoryTheory.Limits.IsZero.from_\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/ZeroObjects.lean\",\"def_pos\":[69,15],\"def_end_pos\":[69,20]}]"
+              ],
+              "state_after": "case unique_from.refine_1\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nF : C \u2964 D\nhF : \u2200 (X : C), IsZero (F.obj X)\nG : C \u2964 D\n\u22a2 \u2200 \u2983X Y : C\u2984 (f : X \u27f6 Y), G.map f \u226b (fun X => \u22ef.from_ (G.obj X)) Y = (fun X => \u22ef.from_ (G.obj X)) X \u226b F.map f",
+              "state_before": "case unique_from.refine_1\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nF : C \u2964 D\nhF : \u2200 (X : C), IsZero (F.obj X)\nG : C \u2964 D\n\u22a2 G \u27f6 F",
+              "tactic": "refine\n  { app := fun X => (hF _).from_ _\n    naturality := ?_ }"
+            },
+            {
+              "annotated_tactic": [
+                "\"intros\"",
+                "[]"
+              ],
+              "state_after": "case unique_from.refine_1\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nF : C \u2964 D\nhF : \u2200 (X : C), IsZero (F.obj X)\nG : C \u2964 D\nX\u271d Y\u271d : C\nf\u271d : X\u271d \u27f6 Y\u271d\n\u22a2 G.map f\u271d \u226b (fun X => \u22ef.from_ (G.obj X)) Y\u271d = (fun X => \u22ef.from_ (G.obj X)) X\u271d \u226b F.map f\u271d",
+              "state_before": "case unique_from.refine_1\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nF : C \u2964 D\nhF : \u2200 (X : C), IsZero (F.obj X)\nG : C \u2964 D\n\u22a2 \u2200 \u2983X Y : C\u2984 (f : X \u27f6 Y), G.map f \u226b (fun X => \u22ef.from_ (G.obj X)) Y = (fun X => \u22ef.from_ (G.obj X)) X \u226b F.map f",
+              "tactic": "intros"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact (hF _).<a>eq_of_tgt<\\/a> _ _\"",
+                "[{\"full_name\":\"CategoryTheory.Limits.IsZero.eq_of_tgt\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/ZeroObjects.lean\",\"def_pos\":[85,9],\"def_end_pos\":[85,18]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case unique_from.refine_1\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nF : C \u2964 D\nhF : \u2200 (X : C), IsZero (F.obj X)\nG : C \u2964 D\nX\u271d Y\u271d : C\nf\u271d : X\u271d \u27f6 Y\u271d\n\u22a2 G.map f\u271d \u226b (fun X => \u22ef.from_ (G.obj X)) Y\u271d = (fun X => \u22ef.from_ (G.obj X)) X\u271d \u226b F.map f\u271d",
+              "tactic": "exact (hF _).eq_of_tgt _ _"
+            },
+            {
+              "annotated_tactic": [
+                "\"intro f\"",
+                "[]"
+              ],
+              "state_after": "case unique_from.refine_2\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nF : C \u2964 D\nhF : \u2200 (X : C), IsZero (F.obj X)\nG : C \u2964 D\nf : G \u27f6 F\n\u22a2 f = default",
+              "state_before": "case unique_from.refine_2\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nF : C \u2964 D\nhF : \u2200 (X : C), IsZero (F.obj X)\nG : C \u2964 D\n\u22a2 \u2200 (a : G \u27f6 F), a = default",
+              "tactic": "intro f"
+            },
+            {
+              "annotated_tactic": [
+                "\"ext\"",
+                "[]"
+              ],
+              "state_after": "case unique_from.refine_2.w.h\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nF : C \u2964 D\nhF : \u2200 (X : C), IsZero (F.obj X)\nG : C \u2964 D\nf : G \u27f6 F\nx\u271d : C\n\u22a2 f.app x\u271d = default.app x\u271d",
+              "state_before": "case unique_from.refine_2\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nF : C \u2964 D\nhF : \u2200 (X : C), IsZero (F.obj X)\nG : C \u2964 D\nf : G \u27f6 F\n\u22a2 f = default",
+              "tactic": "ext"
+            },
+            {
+              "annotated_tactic": [
+                "\"apply (hF _).<a>eq_of_tgt<\\/a> _ _\"",
+                "[{\"full_name\":\"CategoryTheory.Limits.IsZero.eq_of_tgt\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/ZeroObjects.lean\",\"def_pos\":[85,9],\"def_end_pos\":[85,18]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case unique_from.refine_2.w.h\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nF : C \u2964 D\nhF : \u2200 (X : C), IsZero (F.obj X)\nG : C \u2964 D\nf : G \u27f6 F\nx\u271d : C\n\u22a2 f.app x\u271d = default.app x\u271d",
+              "tactic": "apply (hF _).eq_of_tgt _ _"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Functor.isZero_iff",
+        "id": "CategoryTheory.Functor.isZero_iff",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            326,
+            43
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean",
+          "full_name": "CategoryTheory.Functor.isZero_iff",
+          "start": [
+            325,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Iso.isZero_iff",
+        "id": "CategoryTheory.Iso.isZero_iff",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            143,
+            50
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean",
+          "full_name": "CategoryTheory.Iso.isZero_iff",
+          "start": [
+            142,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.HasZeroObject.from_zero_ext",
+        "id": "CategoryTheory.Limits.HasZeroObject.from_zero_ext",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            259,
+            32
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean",
+          "full_name": "CategoryTheory.Limits.HasZeroObject.from_zero_ext",
+          "start": [
+            258,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.HasZeroObject.to_zero_ext",
+        "id": "CategoryTheory.Limits.HasZeroObject.to_zero_ext",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            254,
+            32
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean",
+          "full_name": "CategoryTheory.Limits.HasZeroObject.to_zero_ext",
+          "start": [
+            253,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.IsZero.eq_from",
+        "id": "CategoryTheory.Limits.IsZero.eq_from",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            74,
+            32
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean",
+          "full_name": "CategoryTheory.Limits.IsZero.eq_from",
+          "start": [
+            73,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.IsZero.eq_of_src",
+        "id": "CategoryTheory.Limits.IsZero.eq_of_src",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            82,
+            39
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean",
+          "full_name": "CategoryTheory.Limits.IsZero.eq_of_src",
+          "start": [
+            81,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.IsZero.eq_of_tgt",
+        "id": "CategoryTheory.Limits.IsZero.eq_of_tgt",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            86,
+            43
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean",
+          "full_name": "CategoryTheory.Limits.IsZero.eq_of_tgt",
+          "start": [
+            85,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.IsZero.eq_to",
+        "id": "CategoryTheory.Limits.IsZero.eq_to",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            60,
+            32
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean",
+          "full_name": "CategoryTheory.Limits.IsZero.eq_to",
+          "start": [
+            59,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.IsZero.from_eq",
+        "id": "CategoryTheory.Limits.IsZero.from_eq",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            78,
+            21
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean",
+          "full_name": "CategoryTheory.Limits.IsZero.from_eq",
+          "start": [
+            77,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.IsZero.hasZeroObject",
+        "id": "CategoryTheory.Limits.IsZero.hasZeroObject",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            219,
+            12
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean",
+          "full_name": "CategoryTheory.Limits.IsZero.hasZeroObject",
+          "start": [
+            218,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.IsZero.op",
+        "id": "CategoryTheory.Limits.IsZero.op",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            128,
+            97
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean",
+          "full_name": "CategoryTheory.Limits.IsZero.op",
+          "start": [
+            126,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.IsZero.to_eq",
+        "id": "CategoryTheory.Limits.IsZero.to_eq",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            64,
+            19
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean",
+          "full_name": "CategoryTheory.Limits.IsZero.to_eq",
+          "start": [
+            63,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.IsZero.unop",
+        "id": "CategoryTheory.Limits.IsZero.unop",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            133,
+            95
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean",
+          "full_name": "CategoryTheory.Limits.IsZero.unop",
+          "start": [
+            131,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.hasZeroObject_unop",
+        "id": "CategoryTheory.Limits.hasZeroObject_unop",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            213,
+            53
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean",
+          "full_name": "CategoryTheory.Limits.hasZeroObject_unop",
+          "start": [
+            212,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.isZero_zero",
+        "id": "CategoryTheory.Limits.isZero_zero",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            201,
+            33
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean",
+          "full_name": "CategoryTheory.Limits.isZero_zero",
+          "start": [
+            200,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.Types.Colimit.w_apply",
+        "id": "CategoryTheory.Limits.Types.Colimit.w_apply",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            545,
+            30
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+          "full_name": "CategoryTheory.Limits.Types.Colimit.w_apply",
+          "start": [
+            543,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Types.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.Types.Colimit.w_apply'",
+        "id": "CategoryTheory.Limits.Types.Colimit.w_apply'",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            563,
+            30
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+          "full_name": "CategoryTheory.Limits.Types.Colimit.w_apply'",
+          "start": [
+            561,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Types.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.Types.Colimit.\u03b9_map_apply",
+        "id": "CategoryTheory.Limits.Types.Colimit.\u03b9_map_apply",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            557,
+            34
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+          "full_name": "CategoryTheory.Limits.Types.Colimit.\u03b9_map_apply",
+          "start": [
+            555,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Types.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.Types.Colimit.\u03b9_map_apply'",
+        "id": "CategoryTheory.Limits.Types.Colimit.\u03b9_map_apply'",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            575,
+            34
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+          "full_name": "CategoryTheory.Limits.Types.Colimit.\u03b9_map_apply'",
+          "start": [
+            573,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Types.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.Types.Limit.lift_\u03c0_apply",
+        "id": "CategoryTheory.Limits.Types.Limit.lift_\u03c0_apply",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            302,
+            33
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+          "full_name": "CategoryTheory.Limits.Types.Limit.lift_\u03c0_apply",
+          "start": [
+            300,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Types.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.Types.Limit.lift_\u03c0_apply'",
+        "id": "CategoryTheory.Limits.Types.Limit.lift_\u03c0_apply'",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            320,
+            33
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+          "full_name": "CategoryTheory.Limits.Types.Limit.lift_\u03c0_apply'",
+          "start": [
+            318,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Types.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.Types.Limit.map_\u03c0_apply",
+        "id": "CategoryTheory.Limits.Types.Limit.map_\u03c0_apply",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            308,
+            29
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+          "full_name": "CategoryTheory.Limits.Types.Limit.map_\u03c0_apply",
+          "start": [
+            306,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Types.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.Types.Limit.map_\u03c0_apply'",
+        "id": "CategoryTheory.Limits.Types.Limit.map_\u03c0_apply'",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            326,
+            29
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+          "full_name": "CategoryTheory.Limits.Types.Limit.map_\u03c0_apply'",
+          "start": [
+            324,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Types.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.Types.Limit.w_apply",
+        "id": "CategoryTheory.Limits.Types.Limit.w_apply",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            296,
+            28
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+          "full_name": "CategoryTheory.Limits.Types.Limit.w_apply",
+          "start": [
+            294,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Types.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.Types.Limit.w_apply'",
+        "id": "CategoryTheory.Limits.Types.Limit.w_apply'",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            314,
+            28
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+          "full_name": "CategoryTheory.Limits.Types.Limit.w_apply'",
+          "start": [
+            312,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Types.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.Types.Quot.jointly_surjective",
+        "id": "CategoryTheory.Limits.Types.Quot.jointly_surjective",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            369,
+            81
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+          "full_name": "CategoryTheory.Limits.Types.Quot.jointly_surjective",
+          "start": [
+            368,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Types.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.Types.Quot.map_\u03b9",
+        "id": "CategoryTheory.Limits.Types.Quot.map_\u03b9",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            387,
+            29
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+          "full_name": "CategoryTheory.Limits.Types.Quot.map_\u03b9",
+          "start": [
+            385,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Types.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.Types.Quot.\u03b9_desc",
+        "id": "CategoryTheory.Limits.Types.Quot.\u03b9_desc",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            383,
+            90
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+          "full_name": "CategoryTheory.Limits.Types.Quot.\u03b9_desc",
+          "start": [
+            382,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Types.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.Types.colimitEquivQuot_symm_apply",
+        "id": "CategoryTheory.Limits.Types.colimitEquivQuot_symm_apply",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            530,
+            85
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+          "full_name": "CategoryTheory.Limits.Types.colimitEquivQuot_symm_apply",
+          "start": [
+            528,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Types.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.Types.hasColimit_iff_small_quot",
+        "id": "CategoryTheory.Limits.Types.hasColimit_iff_small_quot",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            457,
+            43
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+          "full_name": "CategoryTheory.Limits.Types.hasColimit_iff_small_quot",
+          "start": [
+            454,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Types.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.Types.hasLimit_iff_small_sections",
+        "id": "CategoryTheory.Limits.Types.hasLimit_iff_small_sections",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            150,
+            43
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+          "full_name": "CategoryTheory.Limits.Types.hasLimit_iff_small_sections",
+          "start": [
+            147,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Types.lean"
+      },
+      {
+        "error": "no internal trace for tactic 'simpa [f] using this'",
+        "full_name": "CategoryTheory.Limits.Types.isColimit_iff_bijective_desc",
+        "id": "CategoryTheory.Limits.Types.isColimit_iff_bijective_desc",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            427,
+            46
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+          "full_name": "CategoryTheory.Limits.Types.isColimit_iff_bijective_desc",
+          "start": [
+            401,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"refine \\u27e8?_, ?_\\u27e9\"",
+                "[]"
+              ],
+              "state_after": "case refine_1\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\n\u22a2 Nonempty (IsColimit c) \u2192 Function.Bijective (Quot.desc c)\n\ncase refine_2\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\n\u22a2 Function.Bijective (Quot.desc c) \u2192 Nonempty (IsColimit c)",
+              "state_before": "J : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\n\u22a2 Nonempty (IsColimit c) \u2194 Function.Bijective (Quot.desc c)",
+              "tactic": "refine \u27e8?_, ?_\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"refine fun \\u27e8hc\\u27e9 => \\u27e8fun x y h => ?_, fun x => ?_\\u27e9\"",
+                "[]"
+              ],
+              "state_after": "case refine_1.refine_1\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nx\u271d : Nonempty (IsColimit c)\nhc : IsColimit c\nx y : Quot F\nh : Quot.desc c x = Quot.desc c y\n\u22a2 x = y\n\ncase refine_1.refine_2\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nx\u271d : Nonempty (IsColimit c)\nhc : IsColimit c\nx : c.pt\n\u22a2 \u2203 a, Quot.desc c a = x",
+              "state_before": "case refine_1\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\n\u22a2 Nonempty (IsColimit c) \u2192 Function.Bijective (Quot.desc c)",
+              "tactic": "refine fun \u27e8hc\u27e9 => \u27e8fun x y h => ?_, fun x => ?_\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"let f : <a>Quot<\\/a> F \\u2192 <a>ULift<\\/a>.{u} <a>Bool<\\/a> := fun z => <a>ULift.up<\\/a> (x = z)\"",
+                "[{\"full_name\":\"CategoryTheory.Limits.Types.Quot\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Types.lean\",\"def_pos\":[358,5],\"def_end_pos\":[358,9]},{\"full_name\":\"ULift\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[809,11],\"def_end_pos\":[809,16]},{\"full_name\":\"Bool\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[567,11],\"def_end_pos\":[567,15]},{\"full_name\":\"ULift.up\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[810,41],\"def_end_pos\":[810,43]}]"
+              ],
+              "state_after": "case refine_1.refine_1\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nx\u271d : Nonempty (IsColimit c)\nhc : IsColimit c\nx y : Quot F\nh : Quot.desc c x = Quot.desc c y\nf : Quot F \u2192 ULift.{u, 0} Bool := fun z => { down := decide (x = z) }\n\u22a2 x = y",
+              "state_before": "case refine_1.refine_1\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nx\u271d : Nonempty (IsColimit c)\nhc : IsColimit c\nx y : Quot F\nh : Quot.desc c x = Quot.desc c y\n\u22a2 x = y",
+              "tactic": "let f : Quot F \u2192 ULift.{u} Bool := fun z => ULift.up (x = z)"
+            },
+            {
+              "annotated_tactic": [
+                "\"suffices f x = f y by simpa [f] using this\"",
+                "[]"
+              ],
+              "state_after": "case refine_1.refine_1\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nx\u271d : Nonempty (IsColimit c)\nhc : IsColimit c\nx y : Quot F\nh : Quot.desc c x = Quot.desc c y\nf : Quot F \u2192 ULift.{u, 0} Bool := fun z => { down := decide (x = z) }\n\u22a2 f x = f y",
+              "state_before": "case refine_1.refine_1\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nx\u271d : Nonempty (IsColimit c)\nhc : IsColimit c\nx y : Quot F\nh : Quot.desc c x = Quot.desc c y\nf : Quot F \u2192 ULift.{u, 0} Bool := fun z => { down := decide (x = z) }\n\u22a2 x = y",
+              "tactic": "suffices f x = f y by simpa [f] using this"
+            },
+            {
+              "annotated_tactic": [
+                "\"rw [\\u2190 <a>Quot.desc_toCocone_desc<\\/a> c f hc x, h, <a>Quot.desc_toCocone_desc<\\/a>]\"",
+                "[{\"full_name\":\"CategoryTheory.Limits.Types.Quot.desc_toCocone_desc\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Types.lean\",\"def_pos\":[396,7],\"def_end_pos\":[396,30]},{\"full_name\":\"CategoryTheory.Limits.Types.Quot.desc_toCocone_desc\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Types.lean\",\"def_pos\":[396,7],\"def_end_pos\":[396,30]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case refine_1.refine_1\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nx\u271d : Nonempty (IsColimit c)\nhc : IsColimit c\nx y : Quot F\nh : Quot.desc c x = Quot.desc c y\nf : Quot F \u2192 ULift.{u, 0} Bool := fun z => { down := decide (x = z) }\n\u22a2 f x = f y",
+              "tactic": "rw [\u2190 Quot.desc_toCocone_desc c f hc x, h, Quot.desc_toCocone_desc]"
+            },
+            {
+              "annotated_tactic": [
+                "\"simpa [f] using this\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "J : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nx\u271d : Nonempty (IsColimit c)\nhc : IsColimit c\nx y : Quot F\nh : Quot.desc c x = Quot.desc c y\nf : Quot F \u2192 ULift.{u, 0} Bool := fun z => { down := decide (x = z) }\nthis : f x = f y\n\u22a2 x = y",
+              "tactic": "simpa [f] using this"
+            },
+            {
+              "annotated_tactic": [
+                "\"let f\\u2081 : c.pt \\u27f6 <a>ULift<\\/a>.{u} <a>Bool<\\/a> := fun _ => <a>ULift.up<\\/a> <a>true<\\/a>\"",
+                "[{\"full_name\":\"ULift\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[809,11],\"def_end_pos\":[809,16]},{\"full_name\":\"Bool\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[567,11],\"def_end_pos\":[567,15]},{\"full_name\":\"ULift.up\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[810,41],\"def_end_pos\":[810,43]},{\"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": "case refine_1.refine_2\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nx\u271d : Nonempty (IsColimit c)\nhc : IsColimit c\nx : c.pt\nf\u2081 : c.pt \u27f6 ULift.{u, 0} Bool := fun x => { down := true }\n\u22a2 \u2203 a, Quot.desc c a = x",
+              "state_before": "case refine_1.refine_2\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nx\u271d : Nonempty (IsColimit c)\nhc : IsColimit c\nx : c.pt\n\u22a2 \u2203 a, Quot.desc c a = x",
+              "tactic": "let f\u2081 : c.pt \u27f6 ULift.{u} Bool := fun _ => ULift.up true"
+            },
+            {
+              "annotated_tactic": [
+                "\"let f\\u2082 : c.pt \\u27f6 <a>ULift<\\/a>.{u} <a>Bool<\\/a> := fun x => <a>ULift.up<\\/a> (\\u2203 a, <a>Quot.desc<\\/a> c a = x)\"",
+                "[{\"full_name\":\"ULift\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[809,11],\"def_end_pos\":[809,16]},{\"full_name\":\"Bool\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[567,11],\"def_end_pos\":[567,15]},{\"full_name\":\"ULift.up\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[810,41],\"def_end_pos\":[810,43]},{\"full_name\":\"CategoryTheory.Limits.Types.Quot.desc\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Types.lean\",\"def_pos\":[377,5],\"def_end_pos\":[377,14]}]"
+              ],
+              "state_after": "case refine_1.refine_2\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nx\u271d : Nonempty (IsColimit c)\nhc : IsColimit c\nx : c.pt\nf\u2081 : c.pt \u27f6 ULift.{u, 0} Bool := fun x => { down := true }\nf\u2082 : c.pt \u27f6 ULift.{u, 0} Bool := fun x => { down := decide (\u2203 a, Quot.desc c a = x) }\n\u22a2 \u2203 a, Quot.desc c a = x",
+              "state_before": "case refine_1.refine_2\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nx\u271d : Nonempty (IsColimit c)\nhc : IsColimit c\nx : c.pt\nf\u2081 : c.pt \u27f6 ULift.{u, 0} Bool := fun x => { down := true }\n\u22a2 \u2203 a, Quot.desc c a = x",
+              "tactic": "let f\u2082 : c.pt \u27f6 ULift.{u} Bool := fun x => ULift.up (\u2203 a, Quot.desc c a = x)"
+            },
+            {
+              "annotated_tactic": [
+                "\"suffices f\\u2081 = f\\u2082 by simpa [f\\u2081, f\\u2082] using <a>congrFun<\\/a> this x\"",
+                "[{\"full_name\":\"congrFun\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[376,9],\"def_end_pos\":[376,17]}]"
+              ],
+              "state_after": "case refine_1.refine_2\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nx\u271d : Nonempty (IsColimit c)\nhc : IsColimit c\nx : c.pt\nf\u2081 : c.pt \u27f6 ULift.{u, 0} Bool := fun x => { down := true }\nf\u2082 : c.pt \u27f6 ULift.{u, 0} Bool := fun x => { down := decide (\u2203 a, Quot.desc c a = x) }\n\u22a2 f\u2081 = f\u2082",
+              "state_before": "case refine_1.refine_2\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nx\u271d : Nonempty (IsColimit c)\nhc : IsColimit c\nx : c.pt\nf\u2081 : c.pt \u27f6 ULift.{u, 0} Bool := fun x => { down := true }\nf\u2082 : c.pt \u27f6 ULift.{u, 0} Bool := fun x => { down := decide (\u2203 a, Quot.desc c a = x) }\n\u22a2 \u2203 a, Quot.desc c a = x",
+              "tactic": "suffices f\u2081 = f\u2082 by simpa [f\u2081, f\u2082] using congrFun this x"
+            },
+            {
+              "annotated_tactic": [
+                "\"refine hc.hom_ext fun j => <a>funext<\\/a> fun x => ?_\"",
+                "[{\"full_name\":\"funext\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Core.lean\",\"def_pos\":[1817,9],\"def_end_pos\":[1817,15]}]"
+              ],
+              "state_after": "case refine_1.refine_2\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nx\u271d\u00b9 : Nonempty (IsColimit c)\nhc : IsColimit c\nx\u271d : c.pt\nf\u2081 : c.pt \u27f6 ULift.{u, 0} Bool := fun x => { down := true }\nf\u2082 : c.pt \u27f6 ULift.{u, 0} Bool := fun x => { down := decide (\u2203 a, Quot.desc c a = x) }\nj : J\nx : F.obj j\n\u22a2 (c.\u03b9.app j \u226b f\u2081) x = (c.\u03b9.app j \u226b f\u2082) x",
+              "state_before": "case refine_1.refine_2\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nx\u271d : Nonempty (IsColimit c)\nhc : IsColimit c\nx : c.pt\nf\u2081 : c.pt \u27f6 ULift.{u, 0} Bool := fun x => { down := true }\nf\u2082 : c.pt \u27f6 ULift.{u, 0} Bool := fun x => { down := decide (\u2203 a, Quot.desc c a = x) }\n\u22a2 f\u2081 = f\u2082",
+              "tactic": "refine hc.hom_ext fun j => funext fun x => ?_"
+            },
+            {
+              "annotated_tactic": [
+                "\"simpa [f\\u2081, f\\u2082] using \\u27e8<a>Quot.\\u03b9<\\/a> F j x, by simp\\u27e9\"",
+                "[{\"full_name\":\"CategoryTheory.Limits.Types.Quot.\\u03b9\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Types.lean\",\"def_pos\":[365,5],\"def_end_pos\":[365,11]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case refine_1.refine_2\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nx\u271d\u00b9 : Nonempty (IsColimit c)\nhc : IsColimit c\nx\u271d : c.pt\nf\u2081 : c.pt \u27f6 ULift.{u, 0} Bool := fun x => { down := true }\nf\u2082 : c.pt \u27f6 ULift.{u, 0} Bool := fun x => { down := decide (\u2203 a, Quot.desc c a = x) }\nj : J\nx : F.obj j\n\u22a2 (c.\u03b9.app j \u226b f\u2081) x = (c.\u03b9.app j \u226b f\u2082) x",
+              "tactic": "simpa [f\u2081, f\u2082] using \u27e8Quot.\u03b9 F j x, by simp\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"simpa [f\\u2081, f\\u2082] using <a>congrFun<\\/a> this x\"",
+                "[{\"full_name\":\"congrFun\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[376,9],\"def_end_pos\":[376,17]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "J : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nx\u271d : Nonempty (IsColimit c)\nhc : IsColimit c\nx : c.pt\nf\u2081 : c.pt \u27f6 ULift.{u, 0} Bool := fun x => { down := true }\nf\u2082 : c.pt \u27f6 ULift.{u, 0} Bool := fun x => { down := decide (\u2203 a, Quot.desc c a = x) }\nthis : f\u2081 = f\u2082\n\u22a2 \u2203 a, Quot.desc c a = x",
+              "tactic": "simpa [f\u2081, f\u2082] using congrFun this x"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "J : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nx\u271d\u00b9 : Nonempty (IsColimit c)\nhc : IsColimit c\nx\u271d : c.pt\nf\u2081 : c.pt \u27f6 ULift.{u, 0} Bool := fun x => { down := true }\nf\u2082 : c.pt \u27f6 ULift.{u, 0} Bool := fun x => { down := decide (\u2203 a, Quot.desc c a = x) }\nj : J\nx : F.obj j\n\u22a2 Quot.desc c (Quot.\u03b9 F j x) = c.\u03b9.app j x",
+              "tactic": "simp"
+            },
+            {
+              "annotated_tactic": [
+                "\"refine fun h => \\u27e8?_\\u27e9\"",
+                "[]"
+              ],
+              "state_after": "case refine_2\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nh : Function.Bijective (Quot.desc c)\n\u22a2 IsColimit c",
+              "state_before": "case refine_2\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\n\u22a2 Function.Bijective (Quot.desc c) \u2192 Nonempty (IsColimit c)",
+              "tactic": "refine fun h => \u27e8?_\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"let e := <a>Equiv.ofBijective<\\/a> _ h\"",
+                "[{\"full_name\":\"Equiv.ofBijective\",\"def_path\":\"Mathlib\\/Logic\\/Equiv\\/Defs.lean\",\"def_pos\":[957,19],\"def_end_pos\":[957,30]}]"
+              ],
+              "state_after": "case refine_2\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nh : Function.Bijective (Quot.desc c)\ne : Quot F \u2243 c.pt := Equiv.ofBijective (Quot.desc c) h\n\u22a2 IsColimit c",
+              "state_before": "case refine_2\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nh : Function.Bijective (Quot.desc c)\n\u22a2 IsColimit c",
+              "tactic": "let e := Equiv.ofBijective _ h"
+            },
+            {
+              "annotated_tactic": [
+                "\"have h : \\u2200 j x, e.symm (c.\\u03b9.app j x) = <a>Quot.\\u03b9<\\/a> F j x :=\\n      fun j x => e.injective (<a>Equiv.ofBijective_apply_symm_apply<\\/a> _ _ _)\"",
+                "[{\"full_name\":\"CategoryTheory.Limits.Types.Quot.\\u03b9\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Types.lean\",\"def_pos\":[365,5],\"def_end_pos\":[365,11]},{\"full_name\":\"Equiv.ofBijective_apply_symm_apply\",\"def_path\":\"Mathlib\\/Logic\\/Equiv\\/Defs.lean\",\"def_pos\":[965,7],\"def_end_pos\":[965,35]}]"
+              ],
+              "state_after": "case refine_2\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nh\u271d : Function.Bijective (Quot.desc c)\ne : Quot F \u2243 c.pt := Equiv.ofBijective (Quot.desc c) h\u271d\nh : \u2200 (j : J) (x : F.obj j), e.symm (c.\u03b9.app j x) = Quot.\u03b9 F j x\n\u22a2 IsColimit c",
+              "state_before": "case refine_2\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nh : Function.Bijective (Quot.desc c)\ne : Quot F \u2243 c.pt := Equiv.ofBijective (Quot.desc c) h\n\u22a2 IsColimit c",
+              "tactic": "have h : \u2200 j x, e.symm (c.\u03b9.app j x) = Quot.\u03b9 F j x :=\n  fun j x => e.injective (Equiv.ofBijective_apply_symm_apply _ _ _)"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact\\n      { desc := fun s => <a>Quot.desc<\\/a> s \\u2218 e.symm\\n        fac := fun s j => by\\n          ext x\\n          simp [h]\\n        uniq := fun s m hm => by\\n          ext x\\n          obtain \\u27e8x, rfl\\u27e9 := e.surjective x\\n          obtain \\u27e8j, x, rfl\\u27e9 := <a>Quot.jointly_surjective<\\/a> x\\n          rw [\\u2190 h, <a>Equiv.apply_symm_apply<\\/a>]\\n          simpa [h] using <a>congrFun<\\/a> (hm j) x }\"",
+                "[{\"full_name\":\"CategoryTheory.Limits.Types.Quot.desc\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Types.lean\",\"def_pos\":[377,5],\"def_end_pos\":[377,14]},{\"full_name\":\"CategoryTheory.Limits.Types.Quot.jointly_surjective\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Types.lean\",\"def_pos\":[368,7],\"def_end_pos\":[368,30]},{\"full_name\":\"Equiv.apply_symm_apply\",\"def_path\":\"Mathlib\\/Logic\\/Equiv\\/Defs.lean\",\"def_pos\":[279,17],\"def_end_pos\":[279,33]},{\"full_name\":\"congrFun\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[376,9],\"def_end_pos\":[376,17]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case refine_2\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nh\u271d : Function.Bijective (Quot.desc c)\ne : Quot F \u2243 c.pt := Equiv.ofBijective (Quot.desc c) h\u271d\nh : \u2200 (j : J) (x : F.obj j), e.symm (c.\u03b9.app j x) = Quot.\u03b9 F j x\n\u22a2 IsColimit c",
+              "tactic": "exact\n  { desc := fun s => Quot.desc s \u2218 e.symm\n    fac := fun s j => by\n      ext x\n      simp [h]\n    uniq := fun s m hm => by\n      ext x\n      obtain \u27e8x, rfl\u27e9 := e.surjective x\n      obtain \u27e8j, x, rfl\u27e9 := Quot.jointly_surjective x\n      rw [\u2190 h, Equiv.apply_symm_apply]\n      simpa [h] using congrFun (hm j) x }"
+            },
+            {
+              "annotated_tactic": [
+                "\"ext x\"",
+                "[]"
+              ],
+              "state_after": "case h\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nh\u271d : Function.Bijective (Quot.desc c)\ne : Quot F \u2243 c.pt := Equiv.ofBijective (Quot.desc c) h\u271d\nh : \u2200 (j : J) (x : F.obj j), e.symm (c.\u03b9.app j x) = Quot.\u03b9 F j x\ns : Cocone F\nj : J\nx : F.obj j\n\u22a2 (c.\u03b9.app j \u226b (fun s => Quot.desc s \u2218 \u21d1e.symm) s) x = s.\u03b9.app j x",
+              "state_before": "J : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nh\u271d : Function.Bijective (Quot.desc c)\ne : Quot F \u2243 c.pt := Equiv.ofBijective (Quot.desc c) h\u271d\nh : \u2200 (j : J) (x : F.obj j), e.symm (c.\u03b9.app j x) = Quot.\u03b9 F j x\ns : Cocone F\nj : J\n\u22a2 c.\u03b9.app j \u226b (fun s => Quot.desc s \u2218 \u21d1e.symm) s = s.\u03b9.app j",
+              "tactic": "ext x"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp [h]\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case h\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nh\u271d : Function.Bijective (Quot.desc c)\ne : Quot F \u2243 c.pt := Equiv.ofBijective (Quot.desc c) h\u271d\nh : \u2200 (j : J) (x : F.obj j), e.symm (c.\u03b9.app j x) = Quot.\u03b9 F j x\ns : Cocone F\nj : J\nx : F.obj j\n\u22a2 (c.\u03b9.app j \u226b (fun s => Quot.desc s \u2218 \u21d1e.symm) s) x = s.\u03b9.app j x",
+              "tactic": "simp [h]"
+            },
+            {
+              "annotated_tactic": [
+                "\"ext x\"",
+                "[]"
+              ],
+              "state_after": "case h\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nh\u271d : Function.Bijective (Quot.desc c)\ne : Quot F \u2243 c.pt := Equiv.ofBijective (Quot.desc c) h\u271d\nh : \u2200 (j : J) (x : F.obj j), e.symm (c.\u03b9.app j x) = Quot.\u03b9 F j x\ns : Cocone F\nm : c.pt \u27f6 s.pt\nhm : \u2200 (j : J), c.\u03b9.app j \u226b m = s.\u03b9.app j\nx : c.pt\n\u22a2 m x = (fun s => Quot.desc s \u2218 \u21d1e.symm) s x",
+              "state_before": "J : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nh\u271d : Function.Bijective (Quot.desc c)\ne : Quot F \u2243 c.pt := Equiv.ofBijective (Quot.desc c) h\u271d\nh : \u2200 (j : J) (x : F.obj j), e.symm (c.\u03b9.app j x) = Quot.\u03b9 F j x\ns : Cocone F\nm : c.pt \u27f6 s.pt\nhm : \u2200 (j : J), c.\u03b9.app j \u226b m = s.\u03b9.app j\n\u22a2 m = (fun s => Quot.desc s \u2218 \u21d1e.symm) s",
+              "tactic": "ext x"
+            },
+            {
+              "annotated_tactic": [
+                "\"obtain \\u27e8x, rfl\\u27e9 := e.surjective x\"",
+                "[]"
+              ],
+              "state_after": "case h.intro\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nh\u271d : Function.Bijective (Quot.desc c)\ne : Quot F \u2243 c.pt := Equiv.ofBijective (Quot.desc c) h\u271d\nh : \u2200 (j : J) (x : F.obj j), e.symm (c.\u03b9.app j x) = Quot.\u03b9 F j x\ns : Cocone F\nm : c.pt \u27f6 s.pt\nhm : \u2200 (j : J), c.\u03b9.app j \u226b m = s.\u03b9.app j\nx : Quot F\n\u22a2 m (e x) = (fun s => Quot.desc s \u2218 \u21d1e.symm) s (e x)",
+              "state_before": "case h\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nh\u271d : Function.Bijective (Quot.desc c)\ne : Quot F \u2243 c.pt := Equiv.ofBijective (Quot.desc c) h\u271d\nh : \u2200 (j : J) (x : F.obj j), e.symm (c.\u03b9.app j x) = Quot.\u03b9 F j x\ns : Cocone F\nm : c.pt \u27f6 s.pt\nhm : \u2200 (j : J), c.\u03b9.app j \u226b m = s.\u03b9.app j\nx : c.pt\n\u22a2 m x = (fun s => Quot.desc s \u2218 \u21d1e.symm) s x",
+              "tactic": "obtain \u27e8x, rfl\u27e9 := e.surjective x"
+            },
+            {
+              "annotated_tactic": [
+                "\"obtain \\u27e8j, x, rfl\\u27e9 := <a>Quot.jointly_surjective<\\/a> x\"",
+                "[{\"full_name\":\"CategoryTheory.Limits.Types.Quot.jointly_surjective\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Types.lean\",\"def_pos\":[368,7],\"def_end_pos\":[368,30]}]"
+              ],
+              "state_after": "case h.intro.intro.intro\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nh\u271d : Function.Bijective (Quot.desc c)\ne : Quot F \u2243 c.pt := Equiv.ofBijective (Quot.desc c) h\u271d\nh : \u2200 (j : J) (x : F.obj j), e.symm (c.\u03b9.app j x) = Quot.\u03b9 F j x\ns : Cocone F\nm : c.pt \u27f6 s.pt\nhm : \u2200 (j : J), c.\u03b9.app j \u226b m = s.\u03b9.app j\nj : J\nx : F.obj j\n\u22a2 m (e (Quot.\u03b9 F j x)) = (fun s => Quot.desc s \u2218 \u21d1e.symm) s (e (Quot.\u03b9 F j x))",
+              "state_before": "case h.intro\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nh\u271d : Function.Bijective (Quot.desc c)\ne : Quot F \u2243 c.pt := Equiv.ofBijective (Quot.desc c) h\u271d\nh : \u2200 (j : J) (x : F.obj j), e.symm (c.\u03b9.app j x) = Quot.\u03b9 F j x\ns : Cocone F\nm : c.pt \u27f6 s.pt\nhm : \u2200 (j : J), c.\u03b9.app j \u226b m = s.\u03b9.app j\nx : Quot F\n\u22a2 m (e x) = (fun s => Quot.desc s \u2218 \u21d1e.symm) s (e x)",
+              "tactic": "obtain \u27e8j, x, rfl\u27e9 := Quot.jointly_surjective x"
+            },
+            {
+              "annotated_tactic": [
+                "\"rw [\\u2190 h, <a>Equiv.apply_symm_apply<\\/a>]\"",
+                "[{\"full_name\":\"Equiv.apply_symm_apply\",\"def_path\":\"Mathlib\\/Logic\\/Equiv\\/Defs.lean\",\"def_pos\":[279,17],\"def_end_pos\":[279,33]}]"
+              ],
+              "state_after": "case h.intro.intro.intro\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nh\u271d : Function.Bijective (Quot.desc c)\ne : Quot F \u2243 c.pt := Equiv.ofBijective (Quot.desc c) h\u271d\nh : \u2200 (j : J) (x : F.obj j), e.symm (c.\u03b9.app j x) = Quot.\u03b9 F j x\ns : Cocone F\nm : c.pt \u27f6 s.pt\nhm : \u2200 (j : J), c.\u03b9.app j \u226b m = s.\u03b9.app j\nj : J\nx : F.obj j\n\u22a2 m (c.\u03b9.app j x) = (fun s => Quot.desc s \u2218 \u21d1e.symm) s (c.\u03b9.app j x)",
+              "state_before": "case h.intro.intro.intro\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nh\u271d : Function.Bijective (Quot.desc c)\ne : Quot F \u2243 c.pt := Equiv.ofBijective (Quot.desc c) h\u271d\nh : \u2200 (j : J) (x : F.obj j), e.symm (c.\u03b9.app j x) = Quot.\u03b9 F j x\ns : Cocone F\nm : c.pt \u27f6 s.pt\nhm : \u2200 (j : J), c.\u03b9.app j \u226b m = s.\u03b9.app j\nj : J\nx : F.obj j\n\u22a2 m (e (Quot.\u03b9 F j x)) = (fun s => Quot.desc s \u2218 \u21d1e.symm) s (e (Quot.\u03b9 F j x))",
+              "tactic": "rw [\u2190 h, Equiv.apply_symm_apply]"
+            },
+            {
+              "annotated_tactic": [
+                "\"simpa [h] using <a>congrFun<\\/a> (hm j) x\"",
+                "[{\"full_name\":\"congrFun\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[376,9],\"def_end_pos\":[376,17]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case h.intro.intro.intro\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cocone F\nh\u271d : Function.Bijective (Quot.desc c)\ne : Quot F \u2243 c.pt := Equiv.ofBijective (Quot.desc c) h\u271d\nh : \u2200 (j : J) (x : F.obj j), e.symm (c.\u03b9.app j x) = Quot.\u03b9 F j x\ns : Cocone F\nm : c.pt \u27f6 s.pt\nhm : \u2200 (j : J), c.\u03b9.app j \u226b m = s.\u03b9.app j\nj : J\nx : F.obj j\n\u22a2 m (c.\u03b9.app j x) = (fun s => Quot.desc s \u2218 \u21d1e.symm) s (c.\u03b9.app j x)",
+              "tactic": "simpa [h] using congrFun (hm j) x"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Types.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.Types.isLimitEquivSections_apply",
+        "id": "CategoryTheory.Limits.Types.isLimitEquivSections_apply",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            79,
+            82
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+          "full_name": "CategoryTheory.Limits.Types.isLimitEquivSections_apply",
+          "start": [
+            78,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Types.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.Types.jointly_surjective",
+        "id": "CategoryTheory.Limits.Types.jointly_surjective",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            611,
+            66
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+          "full_name": "CategoryTheory.Limits.Types.jointly_surjective",
+          "start": [
+            610,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Types.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.Types.jointly_surjective'",
+        "id": "CategoryTheory.Limits.Types.jointly_surjective'",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            618,
+            47
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+          "full_name": "CategoryTheory.Limits.Types.jointly_surjective'",
+          "start": [
+            616,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Types.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.Types.limitEquivSections_apply",
+        "id": "CategoryTheory.Limits.Types.limitEquivSections_apply",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            223,
+            35
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+          "full_name": "CategoryTheory.Limits.Types.limitEquivSections_apply",
+          "start": [
+            221,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Types.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.Types.limitEquivSections_symm_apply",
+        "id": "CategoryTheory.Limits.Types.limitEquivSections_symm_apply",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            229,
+            40
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+          "full_name": "CategoryTheory.Limits.Types.limitEquivSections_symm_apply",
+          "start": [
+            227,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Types.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.Types.limit_ext'",
+        "id": "CategoryTheory.Limits.Types.limit_ext'",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            276,
+            20
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+          "full_name": "CategoryTheory.Limits.Types.limit_ext'",
+          "start": [
+            274,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Types.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.Types.limit_ext_iff",
+        "id": "CategoryTheory.Limits.Types.limit_ext_iff",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            280,
+            40
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+          "full_name": "CategoryTheory.Limits.Types.limit_ext_iff",
+          "start": [
+            279,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Types.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.Types.limit_ext_iff'",
+        "id": "CategoryTheory.Limits.Types.limit_ext_iff'",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            285,
+            41
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+          "full_name": "CategoryTheory.Limits.Types.limit_ext_iff'",
+          "start": [
+            283,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Types.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.Types.nonempty_of_nonempty_colimit",
+        "id": "CategoryTheory.Limits.Types.nonempty_of_nonempty_colimit",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            624,
+            68
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+          "full_name": "CategoryTheory.Limits.Types.nonempty_of_nonempty_colimit",
+          "start": [
+            622,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Types.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Limits.Types.small_quot_of_hasColimit",
+        "id": "CategoryTheory.Limits.Types.small_quot_of_hasColimit",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            460,
+            49
+          ],
+          "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+          "full_name": "CategoryTheory.Limits.Types.small_quot_of_hasColimit",
+          "start": [
+            459,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Limits/Types.lean"
+      }
+    ],
+    "input_proofs": 59,
+    "input_units": 2,
+    "proofs": 16,
+    "published_proofs": 13,
+    "published_transitions": 28,
+    "replay_failures": [],
+    "transitions": 44,
+    "validation_failures": [
+      {
+        "errors": [
+          "internal transition boundary mismatch",
+          "internal transition boundary mismatch"
+        ],
+        "file_path": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean",
+        "proof_id": "mathlib:CategoryTheory.Limits.IsZero.of_iso",
+        "provenance": {
+          "selection": {
+            "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+            "end": [
+              123,
+              23
+            ],
+            "file_path": "Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean",
+            "full_name": "CategoryTheory.Limits.IsZero.of_iso",
+            "start": [
+              117,
+              1
+            ],
+            "traced_tactics": [
+              {
+                "annotated_tactic": [
+                  "\"refine \\u27e8fun Z => \\u27e8\\u27e8\\u27e8e.hom \\u226b hY.to_ Z\\u27e9, fun f => ?_\\u27e9\\u27e9,\\n    fun Z => \\u27e8\\u27e8\\u27e8hY.from_ Z \\u226b e.inv\\u27e9, fun f => ?_\\u27e9\\u27e9\\u27e9\"",
+                  "[]"
+                ],
+                "state_after": "case refine_1\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nX Y : C\nhY : IsZero Y\ne : X \u2245 Y\nZ : C\nf : X \u27f6 Z\n\u22a2 f = default\n\ncase refine_2\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nX Y : C\nhY : IsZero Y\ne : X \u2245 Y\nZ : C\nf : Z \u27f6 X\n\u22a2 f = default",
+                "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nX Y : C\nhY : IsZero Y\ne : X \u2245 Y\n\u22a2 IsZero X",
+                "tactic": "refine \u27e8fun Z => \u27e8\u27e8\u27e8e.hom \u226b hY.to_ Z\u27e9, fun f => ?_\u27e9\u27e9,\n  fun Z => \u27e8\u27e8\u27e8hY.from_ Z \u226b e.inv\u27e9, fun f => ?_\u27e9\u27e9\u27e9"
+              },
+              {
+                "annotated_tactic": [
+                  "\"rw [\\u2190 <a>cancel_epi<\\/a> e.inv]\"",
+                  "[{\"full_name\":\"CategoryTheory.cancel_epi\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[306,9],\"def_end_pos\":[306,19]}]"
+                ],
+                "state_after": "case refine_1\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nX Y : C\nhY : IsZero Y\ne : X \u2245 Y\nZ : C\nf : X \u27f6 Z\n\u22a2 e.inv \u226b f = e.inv \u226b default",
+                "state_before": "case refine_1\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nX Y : C\nhY : IsZero Y\ne : X \u2245 Y\nZ : C\nf : X \u27f6 Z\n\u22a2 f = default",
+                "tactic": "rw [\u2190 cancel_epi e.inv]"
+              },
+              {
+                "annotated_tactic": [
+                  "\"apply hY.eq_of_src\"",
+                  "[]"
+                ],
+                "state_after": "no goals",
+                "state_before": "case refine_1\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nX Y : C\nhY : IsZero Y\ne : X \u2245 Y\nZ : C\nf : X \u27f6 Z\n\u22a2 e.inv \u226b f = e.inv \u226b default",
+                "tactic": "apply hY.eq_of_src"
+              },
+              {
+                "annotated_tactic": [
+                  "\"rw [\\u2190 <a>cancel_mono<\\/a> e.hom]\"",
+                  "[{\"full_name\":\"CategoryTheory.cancel_mono\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[310,9],\"def_end_pos\":[310,20]}]"
+                ],
+                "state_after": "case refine_2\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nX Y : C\nhY : IsZero Y\ne : X \u2245 Y\nZ : C\nf : Z \u27f6 X\n\u22a2 f \u226b e.hom = default \u226b e.hom",
+                "state_before": "case refine_2\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nX Y : C\nhY : IsZero Y\ne : X \u2245 Y\nZ : C\nf : Z \u27f6 X\n\u22a2 f = default",
+                "tactic": "rw [\u2190 cancel_mono e.hom]"
+              },
+              {
+                "annotated_tactic": [
+                  "\"apply hY.eq_of_tgt\"",
+                  "[]"
+                ],
+                "state_after": "no goals",
+                "state_before": "case refine_2\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nD : Type u'\ninst\u271d : Category.{v', u'} D\nX Y : C\nhY : IsZero Y\ne : X \u2245 Y\nZ : C\nf : Z \u27f6 X\n\u22a2 f \u226b e.hom = default \u226b e.hom",
+                "tactic": "apply hY.eq_of_tgt"
+              }
+            ],
+            "url": "https://github.com/leanprover-community/mathlib4"
+          }
+        },
+        "theorem_name": "CategoryTheory.Limits.IsZero.of_iso"
+      },
+      {
+        "errors": [
+          "internal transition boundary mismatch",
+          "internal transition boundary mismatch"
+        ],
+        "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+        "proof_id": "mathlib:CategoryTheory.Limits.Types.isLimit_iff",
+        "provenance": {
+          "selection": {
+            "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+            "end": [
+              60,
+              81
+            ],
+            "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+            "full_name": "CategoryTheory.Limits.Types.isLimit_iff",
+            "start": [
+              52,
+              1
+            ],
+            "traced_tactics": [
+              {
+                "annotated_tactic": [
+                  "\"refine \\u27e8fun \\u27e8t\\u27e9 s hs \\u21a6 ?_, fun h \\u21a6 \\u27e8?_\\u27e9\\u27e9\"",
+                  "[]"
+                ],
+                "state_after": "case refine_1\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cone F\nx\u271d : Nonempty (IsLimit c)\ns : (j : J) \u2192 F.obj j\nhs : s \u2208 F.sections\nt : IsLimit c\n\u22a2 \u2203! x, \u2200 (j : J), c.\u03c0.app j x = s j\n\ncase refine_2\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cone F\nh : \u2200 s \u2208 F.sections, \u2203! x, \u2200 (j : J), c.\u03c0.app j x = s j\n\u22a2 IsLimit c",
+                "state_before": "J : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cone F\n\u22a2 Nonempty (IsLimit c) \u2194 \u2200 s \u2208 F.sections, \u2203! x, \u2200 (j : J), c.\u03c0.app j x = s j",
+                "tactic": "refine \u27e8fun \u27e8t\u27e9 s hs \u21a6 ?_, fun h \u21a6 \u27e8?_\u27e9\u27e9"
+              },
+              {
+                "annotated_tactic": [
+                  "\"let cs := <a>coneOfSection<\\/a> hs\"",
+                  "[{\"full_name\":\"CategoryTheory.Limits.Types.coneOfSection\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Types.lean\",\"def_pos\":[41,5],\"def_end_pos\":[41,18]}]"
+                ],
+                "state_after": "case refine_1\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cone F\nx\u271d : Nonempty (IsLimit c)\ns : (j : J) \u2192 F.obj j\nhs : s \u2208 F.sections\nt : IsLimit c\ncs : Cone F := coneOfSection \u22ef\n\u22a2 \u2203! x, \u2200 (j : J), c.\u03c0.app j x = s j",
+                "state_before": "case refine_1\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cone F\nx\u271d : Nonempty (IsLimit c)\ns : (j : J) \u2192 F.obj j\nhs : s \u2208 F.sections\nt : IsLimit c\n\u22a2 \u2203! x, \u2200 (j : J), c.\u03c0.app j x = s j",
+                "tactic": "let cs := coneOfSection hs"
+              },
+              {
+                "annotated_tactic": [
+                  "\"exact \\u27e8t.lift cs \\u27e8\\u27e9, fun j \\u21a6 <a>congr_fun<\\/a> (t.fac cs j) \\u27e8\\u27e9,\\n      fun x hx \\u21a6 <a>congr_fun<\\/a> (t.uniq cs (fun _ \\u21a6 x) fun j \\u21a6 <a>funext<\\/a> fun _ \\u21a6 hx j) \\u27e8\\u27e9\\u27e9\"",
+                  "[{\"full_name\":\"congr_fun\",\"def_path\":\".lake\\/packages\\/batteries\\/Batteries\\/Logic.lean\",\"def_pos\":[78,7],\"def_end_pos\":[78,16]},{\"full_name\":\"congr_fun\",\"def_path\":\".lake\\/packages\\/batteries\\/Batteries\\/Logic.lean\",\"def_pos\":[78,7],\"def_end_pos\":[78,16]},{\"full_name\":\"funext\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Core.lean\",\"def_pos\":[1817,9],\"def_end_pos\":[1817,15]}]"
+                ],
+                "state_after": "no goals",
+                "state_before": "case refine_1\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cone F\nx\u271d : Nonempty (IsLimit c)\ns : (j : J) \u2192 F.obj j\nhs : s \u2208 F.sections\nt : IsLimit c\ncs : Cone F := coneOfSection \u22ef\n\u22a2 \u2203! x, \u2200 (j : J), c.\u03c0.app j x = s j",
+                "tactic": "exact \u27e8t.lift cs \u27e8\u27e9, fun j \u21a6 congr_fun (t.fac cs j) \u27e8\u27e9,\n  fun x hx \u21a6 congr_fun (t.uniq cs (fun _ \u21a6 x) fun j \u21a6 funext fun _ \u21a6 hx j) \u27e8\u27e9\u27e9"
+              },
+              {
+                "annotated_tactic": [
+                  "\"choose x hx using fun c y \\u21a6 h _ (<a>sectionOfCone<\\/a> c y).2\"",
+                  "[{\"full_name\":\"CategoryTheory.Limits.Types.sectionOfCone\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Types.lean\",\"def_pos\":[49,5],\"def_end_pos\":[49,18]}]"
+                ],
+                "state_after": "case refine_2\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cone F\nh : \u2200 s \u2208 F.sections, \u2203! x, \u2200 (j : J), c.\u03c0.app j x = s j\nx : (c_1 : Cone F) \u2192 c_1.pt \u2192 c.pt\nhx :\n  \u2200 (c_1 : Cone F) (y : c_1.pt),\n    (fun x => \u2200 (j : J), c.\u03c0.app j x = \u2191(sectionOfCone c_1 y) j) (x c_1 y) \u2227\n      \u2200 (y_1 : c.pt), (fun x => \u2200 (j : J), c.\u03c0.app j x = \u2191(sectionOfCone c_1 y) j) y_1 \u2192 y_1 = x c_1 y\n\u22a2 IsLimit c",
+                "state_before": "case refine_2\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cone F\nh : \u2200 s \u2208 F.sections, \u2203! x, \u2200 (j : J), c.\u03c0.app j x = s j\n\u22a2 IsLimit c",
+                "tactic": "choose x hx using fun c y \u21a6 h _ (sectionOfCone c y).2"
+              },
+              {
+                "annotated_tactic": [
+                  "\"exact \\u27e8x, fun c j \\u21a6 <a>funext<\\/a> fun y \\u21a6 (hx c y).1 j,\\n      fun c f hf \\u21a6 <a>funext<\\/a> fun y \\u21a6 (hx c y).2 (f y) (fun j \\u21a6 <a>congr_fun<\\/a> (hf j) y)\\u27e9\"",
+                  "[{\"full_name\":\"funext\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Core.lean\",\"def_pos\":[1817,9],\"def_end_pos\":[1817,15]},{\"full_name\":\"funext\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Core.lean\",\"def_pos\":[1817,9],\"def_end_pos\":[1817,15]},{\"full_name\":\"congr_fun\",\"def_path\":\".lake\\/packages\\/batteries\\/Batteries\\/Logic.lean\",\"def_pos\":[78,7],\"def_end_pos\":[78,16]}]"
+                ],
+                "state_after": "no goals",
+                "state_before": "case refine_2\nJ : Type v\ninst\u271d : Category.{w, v} J\nF : J \u2964 Type u\nc : Cone F\nh : \u2200 s \u2208 F.sections, \u2203! x, \u2200 (j : J), c.\u03c0.app j x = s j\nx : (c_1 : Cone F) \u2192 c_1.pt \u2192 c.pt\nhx :\n  \u2200 (c_1 : Cone F) (y : c_1.pt),\n    (fun x => \u2200 (j : J), c.\u03c0.app j x = \u2191(sectionOfCone c_1 y) j) (x c_1 y) \u2227\n      \u2200 (y_1 : c.pt), (fun x => \u2200 (j : J), c.\u03c0.app j x = \u2191(sectionOfCone c_1 y) j) y_1 \u2192 y_1 = x c_1 y\n\u22a2 IsLimit c",
+                "tactic": "exact \u27e8x, fun c j \u21a6 funext fun y \u21a6 (hx c y).1 j,\n  fun c f hf \u21a6 funext fun y \u21a6 (hx c y).2 (f y) (fun j \u21a6 congr_fun (hf j) y)\u27e9"
+              }
+            ],
+            "url": "https://github.com/leanprover-community/mathlib4"
+          }
+        },
+        "theorem_name": "CategoryTheory.Limits.Types.isLimit_iff"
+      },
+      {
+        "errors": [
+          "internal transition boundary mismatch",
+          "internal transition boundary mismatch"
+        ],
+        "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+        "proof_id": "mathlib:CategoryTheory.Limits.Types.jointly_surjective_of_isColimit",
+        "provenance": {
+          "selection": {
+            "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+            "end": [
+              608,
+              80
+            ],
+            "file_path": "Mathlib/CategoryTheory/Limits/Types.lean",
+            "full_name": "CategoryTheory.Limits.Types.jointly_surjective_of_isColimit",
+            "start": [
+              600,
+              1
+            ],
+            "traced_tactics": [
+              {
+                "annotated_tactic": [
+                  "\"by_contra hx\"",
+                  "[]"
+                ],
+                "state_after": "J : Type v\ninst\u271d\u00b9 : Category.{w, v} J\nF\u271d : J \u2964 Type u\ninst\u271d : HasColimit F\u271d\nF : J \u2964 Type u\nt : Cocone F\nh : IsColimit t\nx : t.pt\nhx : \u00ac\u2203 j y, t.\u03b9.app j y = x\n\u22a2 False",
+                "state_before": "J : Type v\ninst\u271d\u00b9 : Category.{w, v} J\nF\u271d : J \u2964 Type u\ninst\u271d : HasColimit F\u271d\nF : J \u2964 Type u\nt : Cocone F\nh : IsColimit t\nx : t.pt\n\u22a2 \u2203 j y, t.\u03b9.app j y = x",
+                "tactic": "by_contra hx"
+              },
+              {
+                "annotated_tactic": [
+                  "\"simp_rw [<a>not_exists<\\/a>] at hx\"",
+                  "[{\"full_name\":\"not_exists\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/PropLemmas.lean\",\"def_pos\":[254,17],\"def_end_pos\":[254,27]}]"
+                ],
+                "state_after": "J : Type v\ninst\u271d\u00b9 : Category.{w, v} J\nF\u271d : J \u2964 Type u\ninst\u271d : HasColimit F\u271d\nF : J \u2964 Type u\nt : Cocone F\nh : IsColimit t\nx : t.pt\nhx : \u2200 (x_1 : J) (x_2 : F.obj x_1), \u00act.\u03b9.app x_1 x_2 = x\n\u22a2 False",
+                "state_before": "J : Type v\ninst\u271d\u00b9 : Category.{w, v} J\nF\u271d : J \u2964 Type u\ninst\u271d : HasColimit F\u271d\nF : J \u2964 Type u\nt : Cocone F\nh : IsColimit t\nx : t.pt\nhx : \u00ac\u2203 j y, t.\u03b9.app j y = x\n\u22a2 False",
+                "tactic": "simp_rw [not_exists] at hx"
+              },
+              {
+                "annotated_tactic": [
+                  "\"refine h.hom_ext fun j \\u21a6 ?_\"",
+                  "[]"
+                ],
+                "state_after": "J : Type v\ninst\u271d\u00b9 : Category.{w, v} J\nF\u271d : J \u2964 Type u\ninst\u271d : HasColimit F\u271d\nF : J \u2964 Type u\nt : Cocone F\nh : IsColimit t\nx : t.pt\nhx : \u2200 (x_1 : J) (x_2 : F.obj x_1), \u00act.\u03b9.app x_1 x_2 = x\nj : J\n\u22a2 (t.\u03b9.app j \u226b fun x => { down := True }) = t.\u03b9.app j \u226b fun x_1 => { down := x_1 \u2260 x }",
+                "state_before": "J : Type v\ninst\u271d\u00b9 : Category.{w, v} J\nF\u271d : J \u2964 Type u\ninst\u271d : HasColimit F\u271d\nF : J \u2964 Type u\nt : Cocone F\nh : IsColimit t\nx : t.pt\nhx : \u2200 (x_1 : J) (x_2 : F.obj x_1), \u00act.\u03b9.app x_1 x_2 = x\n\u22a2 (fun x => { down := True }) = fun x_1 => { down := x_1 \u2260 x }",
+                "tactic": "refine h.hom_ext fun j \u21a6 ?_"
+              },
+              {
+                "annotated_tactic": [
+                  "\"ext y\"",
+                  "[]"
+                ],
+                "state_after": "case h.h.a\nJ : Type v\ninst\u271d\u00b9 : Category.{w, v} J\nF\u271d : J \u2964 Type u\ninst\u271d : HasColimit F\u271d\nF : J \u2964 Type u\nt : Cocone F\nh : IsColimit t\nx : t.pt\nhx : \u2200 (x_1 : J) (x_2 : F.obj x_1), \u00act.\u03b9.app x_1 x_2 = x\nj : J\ny : F.obj j\n\u22a2 ((t.\u03b9.app j \u226b fun x => { down := True }) y).down \u2194 ((t.\u03b9.app j \u226b fun x_1 => { down := x_1 \u2260 x }) y).down",
+                "state_before": "J : Type v\ninst\u271d\u00b9 : Category.{w, v} J\nF\u271d : J \u2964 Type u\ninst\u271d : HasColimit F\u271d\nF : J \u2964 Type u\nt : Cocone F\nh : IsColimit t\nx : t.pt\nhx : \u2200 (x_1 : J) (x_2 : F.obj x_1), \u00act.\u03b9.app x_1 x_2 = x\nj : J\n\u22a2 (t.\u03b9.app j \u226b fun x => { down := True }) = t.\u03b9.app j \u226b fun x_1 => { down := x_1 \u2260 x }",
+                "tactic": "ext y"
+              },
+              {
+                "annotated_tactic": [
+                  "\"exact (<a>true_iff<\\/a> _).<a>mpr<\\/a> (hx j y)\"",
+                  "[{\"full_name\":\"true_iff\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/SimpLemmas.lean\",\"def_pos\":[128,17],\"def_end_pos\":[128,25]},{\"full_name\":\"Eq.mpr\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Core.lean\",\"def_pos\":[675,21],\"def_end_pos\":[675,27]}]"
+                ],
+                "state_after": "no goals",
+                "state_before": "case h.h.a\nJ : Type v\ninst\u271d\u00b9 : Category.{w, v} J\nF\u271d : J \u2964 Type u\ninst\u271d : HasColimit F\u271d\nF : J \u2964 Type u\nt : Cocone F\nh : IsColimit t\nx : t.pt\nhx : \u2200 (x_1 : J) (x_2 : F.obj x_1), \u00act.\u03b9.app x_1 x_2 = x\nj : J\ny : F.obj j\n\u22a2 ((t.\u03b9.app j \u226b fun x => { down := True }) y).down \u2194 ((t.\u03b9.app j \u226b fun x_1 => { down := x_1 \u2260 x }) y).down",
+                "tactic": "exact (true_iff _).mpr (hx j y)"
+              },
+              {
+                "annotated_tactic": [
+                  "\"exact fun he \\u21a6 <a>of_eq_true<\\/a> (<a>congr_arg<\\/a> <a>ULift.down<\\/a> <| <a>congr_fun<\\/a> he x).<a>symm<\\/a> <a>rfl<\\/a>\"",
+                  "[{\"full_name\":\"of_eq_true\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/SimpLemmas.lean\",\"def_pos\":[12,9],\"def_end_pos\":[12,19]},{\"full_name\":\"congr_arg\",\"def_path\":\".lake\\/packages\\/batteries\\/Batteries\\/Logic.lean\",\"def_pos\":[76,7],\"def_end_pos\":[76,16]},{\"full_name\":\"ULift.down\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[811,41],\"def_end_pos\":[811,45]},{\"full_name\":\"congr_fun\",\"def_path\":\".lake\\/packages\\/batteries\\/Batteries\\/Logic.lean\",\"def_pos\":[78,7],\"def_end_pos\":[78,16]},{\"full_name\":\"Eq.symm\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[323,9],\"def_end_pos\":[323,16]},{\"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": "J : Type v\ninst\u271d\u00b9 : Category.{w, v} J\nF\u271d : J \u2964 Type u\ninst\u271d : HasColimit F\u271d\nF : J \u2964 Type u\nt : Cocone F\nh : IsColimit t\nx : t.pt\nhx : \u2200 (x_1 : J) (x_2 : F.obj x_1), \u00act.\u03b9.app x_1 x_2 = x\n\u22a2 (fun x => { down := True }) \u2260 fun x_1 => { down := x_1 \u2260 x }",
+                "tactic": "exact fun he \u21a6 of_eq_true (congr_arg ULift.down <| congr_fun he x).symm rfl"
+              }
+            ],
+            "url": "https://github.com/leanprover-community/mathlib4"
+          }
+        },
+        "theorem_name": "CategoryTheory.Limits.Types.jointly_surjective_of_isColimit"
+      }
+    ],
+    "validation_rejected_proofs": 3,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/mathlib-000710-0000-f781aad44b92ea6d.parquet",
+      "sha256": "f781aad44b92ea6d1746e1f17eb8499633b6382aafc57281d76114dfd8daba62",
+      "bytes": 93858,
+      "rows": 24,
+      "revision": "22515991803e73ecc3c0bc878466a6d683e86be7"
+    },
+    {
+      "path": "data/internal_test/mathlib-000710-0000-f10f076f0fdeed89.parquet",
+      "sha256": "f10f076f0fdeed89783698eda101aa60f56be7f0f719313126f32b4a8cd9d8d7",
+      "bytes": 55074,
+      "rows": 4,
+      "revision": "22515991803e73ecc3c0bc878466a6d683e86be7"
+    }
+  ],
+  "proof_ids": [
+    "mathlib:CategoryTheory.Limits.IsZero.obj",
+    "mathlib:CategoryTheory.Limits.Types.Image.lift_fac",
+    "mathlib:CategoryTheory.Limits.Types.Limit.\u03c0_mk",
+    "mathlib:CategoryTheory.Limits.Types.Quot.desc_colimitCocone",
+    "mathlib:CategoryTheory.Limits.Types.Quot.desc_toCocone_desc",
+    "mathlib:CategoryTheory.Limits.Types.Small.limitCone_pt_ext",
+    "mathlib:CategoryTheory.Limits.Types.colimitEquivQuot_apply",
+    "mathlib:CategoryTheory.Limits.Types.colimit_eq",
+    "mathlib:CategoryTheory.Limits.Types.colimit_sound",
+    "mathlib:CategoryTheory.Limits.Types.colimit_sound'",
+    "mathlib:CategoryTheory.Limits.Types.isLimitEquivSections_symm_apply",
+    "mathlib:CategoryTheory.Limits.Types.isLimit_iff_bijective_sectionOfCone",
+    "mathlib:CategoryTheory.Limits.Types.limit_ext"
+  ],
+  "proof_keys": [
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean\",null,null,\"CategoryTheory.Limits.IsZero.obj\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Types.lean\",null,null,\"CategoryTheory.Limits.Types.Image.lift_fac\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Types.lean\",null,null,\"CategoryTheory.Limits.Types.Limit.\u03c0_mk\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Types.lean\",null,null,\"CategoryTheory.Limits.Types.Quot.desc_colimitCocone\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Types.lean\",null,null,\"CategoryTheory.Limits.Types.Quot.desc_toCocone_desc\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Types.lean\",null,null,\"CategoryTheory.Limits.Types.Small.limitCone_pt_ext\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Types.lean\",null,null,\"CategoryTheory.Limits.Types.colimitEquivQuot_apply\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Types.lean\",null,null,\"CategoryTheory.Limits.Types.colimit_eq\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Types.lean\",null,null,\"CategoryTheory.Limits.Types.colimit_sound\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Types.lean\",null,null,\"CategoryTheory.Limits.Types.colimit_sound'\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Types.lean\",null,null,\"CategoryTheory.Limits.Types.isLimitEquivSections_symm_apply\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Types.lean\",null,null,\"CategoryTheory.Limits.Types.isLimit_iff_bijective_sectionOfCone\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Types.lean\",null,null,\"CategoryTheory.Limits.Types.limit_ext\"]"
+  ]
+}

manifests/batches/mathlib/000712.json

@@ -0,0 +1,110 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "mathlib/000712",
+  "batch_fingerprint": "c9bc8c8831f20a033ff4103db10eda222fe659b58631f01220a6fc80645884fb",
+  "evidence": {
+    "batch_fingerprint": "c9bc8c8831f20a033ff4103db10eda222fe659b58631f01220a6fc80645884fb",
+    "contamination_matches": [],
+    "failures": [
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Linear.homCongr_apply",
+        "id": "CategoryTheory.Linear.homCongr_apply",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            164,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Linear/Basic.lean",
+          "full_name": "CategoryTheory.Linear.homCongr_apply",
+          "start": [
+            161,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Linear/Basic.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Linear.homCongr_symm_apply",
+        "id": "CategoryTheory.Linear.homCongr_symm_apply",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            170,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Linear/Basic.lean",
+          "full_name": "CategoryTheory.Linear.homCongr_symm_apply",
+          "start": [
+            167,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Linear/Basic.lean"
+      },
+      {
+        "full_name": "CategoryTheory.NatTrans.app_smul",
+        "id": "CategoryTheory.NatTrans.app_smul",
+        "reason": "missing_trace",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            82,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Linear/FunctorCategory.lean",
+          "full_name": "CategoryTheory.NatTrans.app_smul",
+          "start": [
+            81,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Linear/FunctorCategory.lean"
+      }
+    ],
+    "input_proofs": 5,
+    "input_units": 2,
+    "proofs": 2,
+    "published_proofs": 2,
+    "published_transitions": 2,
+    "replay_failures": [],
+    "transitions": 2,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/mathlib-000712-0000-659e1dcb7fc4f606.parquet",
+      "sha256": "659e1dcb7fc4f60616626337d4ae779cc3075d393b63c29c1124cba29f5d49e6",
+      "bytes": 33895,
+      "rows": 1,
+      "revision": "22515991803e73ecc3c0bc878466a6d683e86be7"
+    },
+    {
+      "path": "data/dev/mathlib-000712-0000-4ae8e2e40ff77a38.parquet",
+      "sha256": "4ae8e2e40ff77a38abb7136a5c5a6abbe2f85749d31961398774c37f9c544bbb",
+      "bytes": 34012,
+      "rows": 1,
+      "revision": "22515991803e73ecc3c0bc878466a6d683e86be7"
+    }
+  ],
+  "proof_ids": [
+    "mathlib:CategoryTheory.Linear.comp_units_smul",
+    "mathlib:CategoryTheory.Linear.units_smul_comp"
+  ],
+  "proof_keys": [
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Linear/Basic.lean\",null,null,\"CategoryTheory.Linear.comp_units_smul\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Linear/Basic.lean\",null,null,\"CategoryTheory.Linear.units_smul_comp\"]"
+  ]
+}

manifests/batches/mathlib/000713.json

@@ -0,0 +1,168 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "mathlib/000713",
+  "batch_fingerprint": "88bef5c7b9cefdb6ee1027a3b13c596c148afe4b83a7377deb7159bbbf11525c",
+  "evidence": {
+    "batch_fingerprint": "88bef5c7b9cefdb6ee1027a3b13c596c148afe4b83a7377deb7159bbbf11525c",
+    "contamination_matches": [],
+    "failures": [
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Functor.coe_mapLinearMap",
+        "id": "CategoryTheory.Functor.coe_mapLinearMap",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            70,
+            90
+          ],
+          "file_path": "Mathlib/CategoryTheory/Linear/LinearFunctor.lean",
+          "full_name": "CategoryTheory.Functor.coe_mapLinearMap",
+          "start": [
+            70,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Linear/LinearFunctor.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Functor.map_smul",
+        "id": "CategoryTheory.Functor.map_smul",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            50,
+            30
+          ],
+          "file_path": "Mathlib/CategoryTheory/Linear/LinearFunctor.lean",
+          "full_name": "CategoryTheory.Functor.map_smul",
+          "start": [
+            49,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Linear/LinearFunctor.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.whiskering_linearCoyoneda",
+        "id": "CategoryTheory.whiskering_linearCoyoneda",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            84,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Linear/Yoneda.lean",
+          "full_name": "CategoryTheory.whiskering_linearCoyoneda",
+          "start": [
+            82,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Linear/Yoneda.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.whiskering_linearCoyoneda\u2082",
+        "id": "CategoryTheory.whiskering_linearCoyoneda\u2082",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            92,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Linear/Yoneda.lean",
+          "full_name": "CategoryTheory.whiskering_linearCoyoneda\u2082",
+          "start": [
+            88,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Linear/Yoneda.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.whiskering_linearYoneda",
+        "id": "CategoryTheory.whiskering_linearYoneda",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            71,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Linear/Yoneda.lean",
+          "full_name": "CategoryTheory.whiskering_linearYoneda",
+          "start": [
+            69,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Linear/Yoneda.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.whiskering_linearYoneda\u2082",
+        "id": "CategoryTheory.whiskering_linearYoneda\u2082",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            78,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Linear/Yoneda.lean",
+          "full_name": "CategoryTheory.whiskering_linearYoneda\u2082",
+          "start": [
+            75,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Linear/Yoneda.lean"
+      }
+    ],
+    "input_proofs": 7,
+    "input_units": 2,
+    "proofs": 1,
+    "published_proofs": 1,
+    "published_transitions": 1,
+    "replay_failures": [],
+    "transitions": 1,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/mathlib-000713-0000-784cd3733323e8de.parquet",
+      "sha256": "784cd3733323e8de62e4bae21a1691e0aa96a03bb665a9906e3d767e22331c3c",
+      "bytes": 40894,
+      "rows": 1,
+      "revision": "22515991803e73ecc3c0bc878466a6d683e86be7"
+    }
+  ],
+  "proof_ids": [
+    "mathlib:CategoryTheory.Functor.map_units_smul"
+  ],
+  "proof_keys": [
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Linear/LinearFunctor.lean\",null,null,\"CategoryTheory.Functor.map_units_smul\"]"
+  ]
+}

manifests/batches/mathlib/000714.json

@@ -0,0 +1,569 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "mathlib/000714",
+  "batch_fingerprint": "930b31b8165deba229a1e96255a4b62ae0c21db61ec8f070f9460dc84827b598",
+  "evidence": {
+    "batch_fingerprint": "930b31b8165deba229a1e96255a4b62ae0c21db61ec8f070f9460dc84827b598",
+    "contamination_matches": [],
+    "failures": [
+      {
+        "error": "no internal trace for tactic 'change IsIso _'",
+        "full_name": "CategoryTheory.Adjunction.isLocalization",
+        "id": "CategoryTheory.Adjunction.isLocalization",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            145,
+            32
+          ],
+          "file_path": "Mathlib/CategoryTheory/Localization/Adjunction.lean",
+          "full_name": "CategoryTheory.Adjunction.isLocalization",
+          "start": [
+            130,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"let W := ((<a>MorphismProperty.isomorphisms<\\/a> C\\u2082).<a>inverseImage<\\/a> G)\"",
+                "[{\"full_name\":\"CategoryTheory.MorphismProperty.isomorphisms\",\"def_path\":\"Mathlib\\/CategoryTheory\\/MorphismProperty\\/Basic.lean\",\"def_pos\":[296,5],\"def_end_pos\":[296,17]},{\"full_name\":\"CategoryTheory.MorphismProperty.inverseImage\",\"def_path\":\"Mathlib\\/CategoryTheory\\/MorphismProperty\\/Basic.lean\",\"def_pos\":[84,5],\"def_end_pos\":[84,17]}]"
+              ],
+              "state_after": "C\u2081 : Type u_1\nC\u2082 : Type u_2\nD\u2081 : Type u_3\nD\u2082 : Type u_4\ninst\u271d\u2075 : Category.{u_6, u_1} C\u2081\ninst\u271d\u2074 : Category.{u_5, u_2} C\u2082\ninst\u271d\u00b3 : Category.{?u.46714, u_3} D\u2081\ninst\u271d\u00b2 : Category.{?u.46718, u_4} D\u2082\nG : C\u2081 \u2964 C\u2082\nF : C\u2082 \u2964 C\u2081\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nW : MorphismProperty C\u2081 := (MorphismProperty.isomorphisms C\u2082).inverseImage G\n\u22a2 G.IsLocalization ((MorphismProperty.isomorphisms C\u2082).inverseImage G)",
+              "state_before": "C\u2081 : Type u_1\nC\u2082 : Type u_2\nD\u2081 : Type u_3\nD\u2082 : Type u_4\ninst\u271d\u2075 : Category.{u_6, u_1} C\u2081\ninst\u271d\u2074 : Category.{u_5, u_2} C\u2082\ninst\u271d\u00b3 : Category.{?u.46714, u_3} D\u2081\ninst\u271d\u00b2 : Category.{?u.46718, u_4} D\u2082\nG : C\u2081 \u2964 C\u2082\nF : C\u2082 \u2964 C\u2081\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\n\u22a2 G.IsLocalization ((MorphismProperty.isomorphisms C\u2082).inverseImage G)",
+              "tactic": "let W := ((MorphismProperty.isomorphisms C\u2082).inverseImage G)"
+            },
+            {
+              "annotated_tactic": [
+                "\"have hG : W.IsInvertedBy G := fun _ _ _ hf => hf\"",
+                "[]"
+              ],
+              "state_after": "C\u2081 : Type u_1\nC\u2082 : Type u_2\nD\u2081 : Type u_3\nD\u2082 : Type u_4\ninst\u271d\u2075 : Category.{u_6, u_1} C\u2081\ninst\u271d\u2074 : Category.{u_5, u_2} C\u2082\ninst\u271d\u00b3 : Category.{?u.46714, u_3} D\u2081\ninst\u271d\u00b2 : Category.{?u.46718, u_4} D\u2082\nG : C\u2081 \u2964 C\u2082\nF : C\u2082 \u2964 C\u2081\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nW : MorphismProperty C\u2081 := (MorphismProperty.isomorphisms C\u2082).inverseImage G\nhG : W.IsInvertedBy G\n\u22a2 G.IsLocalization ((MorphismProperty.isomorphisms C\u2082).inverseImage G)",
+              "state_before": "C\u2081 : Type u_1\nC\u2082 : Type u_2\nD\u2081 : Type u_3\nD\u2082 : Type u_4\ninst\u271d\u2075 : Category.{u_6, u_1} C\u2081\ninst\u271d\u2074 : Category.{u_5, u_2} C\u2082\ninst\u271d\u00b3 : Category.{?u.46714, u_3} D\u2081\ninst\u271d\u00b2 : Category.{?u.46718, u_4} D\u2082\nG : C\u2081 \u2964 C\u2082\nF : C\u2082 \u2964 C\u2081\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nW : MorphismProperty C\u2081 := (MorphismProperty.isomorphisms C\u2082).inverseImage G\n\u22a2 G.IsLocalization ((MorphismProperty.isomorphisms C\u2082).inverseImage G)",
+              "tactic": "have hG : W.IsInvertedBy G := fun _ _ _ hf => hf"
+            },
+            {
+              "annotated_tactic": [
+                "\"have : \\u2200 (X : C\\u2081), <a>IsIso<\\/a> ((<a>whiskerRight<\\/a> adj.unit W.Q).<a>app<\\/a> X) := fun X =>\\n    <a>Localization.inverts<\\/a> W.Q W _ (by\\n      change <a>IsIso<\\/a> _\\n      infer_instance)\"",
+                "[{\"full_name\":\"CategoryTheory.IsIso\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Iso.lean\",\"def_pos\":[272,7],\"def_end_pos\":[272,12]},{\"full_name\":\"CategoryTheory.whiskerRight\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Whiskering.lean\",\"def_pos\":[58,5],\"def_end_pos\":[58,17]},{\"full_name\":\"CategoryTheory.NatTrans.app\",\"def_path\":\"Mathlib\\/CategoryTheory\\/NatTrans.lean\",\"def_pos\":[50,3],\"def_end_pos\":[50,6]},{\"full_name\":\"CategoryTheory.Localization.inverts\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Localization\\/Predicate.lean\",\"def_pos\":[143,9],\"def_end_pos\":[143,16]},{\"full_name\":\"CategoryTheory.IsIso\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Iso.lean\",\"def_pos\":[272,7],\"def_end_pos\":[272,12]}]"
+              ],
+              "state_after": "C\u2081 : Type u_1\nC\u2082 : Type u_2\nD\u2081 : Type u_3\nD\u2082 : Type u_4\ninst\u271d\u2075 : Category.{u_6, u_1} C\u2081\ninst\u271d\u2074 : Category.{u_5, u_2} C\u2082\ninst\u271d\u00b3 : Category.{?u.46714, u_3} D\u2081\ninst\u271d\u00b2 : Category.{?u.46718, u_4} D\u2082\nG : C\u2081 \u2964 C\u2082\nF : C\u2082 \u2964 C\u2081\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nW : MorphismProperty C\u2081 := (MorphismProperty.isomorphisms C\u2082).inverseImage G\nhG : W.IsInvertedBy G\nthis : \u2200 (X : C\u2081), IsIso ((whiskerRight adj.unit W.Q).app X)\n\u22a2 G.IsLocalization ((MorphismProperty.isomorphisms C\u2082).inverseImage G)",
+              "state_before": "C\u2081 : Type u_1\nC\u2082 : Type u_2\nD\u2081 : Type u_3\nD\u2082 : Type u_4\ninst\u271d\u2075 : Category.{u_6, u_1} C\u2081\ninst\u271d\u2074 : Category.{u_5, u_2} C\u2082\ninst\u271d\u00b3 : Category.{?u.46714, u_3} D\u2081\ninst\u271d\u00b2 : Category.{?u.46718, u_4} D\u2082\nG : C\u2081 \u2964 C\u2082\nF : C\u2082 \u2964 C\u2081\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nW : MorphismProperty C\u2081 := (MorphismProperty.isomorphisms C\u2082).inverseImage G\nhG : W.IsInvertedBy G\n\u22a2 G.IsLocalization ((MorphismProperty.isomorphisms C\u2082).inverseImage G)",
+              "tactic": "have : \u2200 (X : C\u2081), IsIso ((whiskerRight adj.unit W.Q).app X) := fun X =>\n  Localization.inverts W.Q W _ (by\n    change IsIso _\n    infer_instance)"
+            },
+            {
+              "annotated_tactic": [
+                "\"have : <a>IsIso<\\/a> (<a>whiskerRight<\\/a> adj.unit W.Q) := <a>NatIso.isIso_of_isIso_app<\\/a> _\"",
+                "[{\"full_name\":\"CategoryTheory.IsIso\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Iso.lean\",\"def_pos\":[272,7],\"def_end_pos\":[272,12]},{\"full_name\":\"CategoryTheory.whiskerRight\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Whiskering.lean\",\"def_pos\":[58,5],\"def_end_pos\":[58,17]},{\"full_name\":\"CategoryTheory.NatIso.isIso_of_isIso_app\",\"def_path\":\"Mathlib\\/CategoryTheory\\/NatIso.lean\",\"def_pos\":[238,9],\"def_end_pos\":[238,27]}]"
+              ],
+              "state_after": "C\u2081 : Type u_1\nC\u2082 : Type u_2\nD\u2081 : Type u_3\nD\u2082 : Type u_4\ninst\u271d\u2075 : Category.{u_6, u_1} C\u2081\ninst\u271d\u2074 : Category.{u_5, u_2} C\u2082\ninst\u271d\u00b3 : Category.{?u.46714, u_3} D\u2081\ninst\u271d\u00b2 : Category.{?u.46718, u_4} D\u2082\nG : C\u2081 \u2964 C\u2082\nF : C\u2082 \u2964 C\u2081\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nW : MorphismProperty C\u2081 := (MorphismProperty.isomorphisms C\u2082).inverseImage G\nhG : W.IsInvertedBy G\nthis\u271d : \u2200 (X : C\u2081), IsIso ((whiskerRight adj.unit W.Q).app X)\nthis : IsIso (whiskerRight adj.unit W.Q)\n\u22a2 G.IsLocalization ((MorphismProperty.isomorphisms C\u2082).inverseImage G)",
+              "state_before": "C\u2081 : Type u_1\nC\u2082 : Type u_2\nD\u2081 : Type u_3\nD\u2082 : Type u_4\ninst\u271d\u2075 : Category.{u_6, u_1} C\u2081\ninst\u271d\u2074 : Category.{u_5, u_2} C\u2082\ninst\u271d\u00b3 : Category.{?u.46714, u_3} D\u2081\ninst\u271d\u00b2 : Category.{?u.46718, u_4} D\u2082\nG : C\u2081 \u2964 C\u2082\nF : C\u2082 \u2964 C\u2081\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nW : MorphismProperty C\u2081 := (MorphismProperty.isomorphisms C\u2082).inverseImage G\nhG : W.IsInvertedBy G\nthis : \u2200 (X : C\u2081), IsIso ((whiskerRight adj.unit W.Q).app X)\n\u22a2 G.IsLocalization ((MorphismProperty.isomorphisms C\u2082).inverseImage G)",
+              "tactic": "have : IsIso (whiskerRight adj.unit W.Q) := NatIso.isIso_of_isIso_app _"
+            },
+            {
+              "annotated_tactic": [
+                "\"let e : W.Localization \\u224c C\\u2082 := <a>Equivalence.mk<\\/a> (<a>Localization.lift<\\/a> G hG W.Q) (F \\u22d9 W.Q)\\n    (<a>liftNatIso<\\/a> W.Q W W.Q (G \\u22d9 F \\u22d9 W.Q) _ _\\n    (W.Q.leftUnitor.symm \\u226a\\u226b <a>asIso<\\/a> (<a>whiskerRight<\\/a> adj.unit W.Q)))\\n    (<a>Functor.associator<\\/a> _ _ _ \\u226a\\u226b <a>isoWhiskerLeft<\\/a> _ (<a>Localization.fac<\\/a> G hG W.Q) \\u226a\\u226b\\n      <a>asIso<\\/a> adj.counit)\"",
+                "[{\"full_name\":\"CategoryTheory.Equivalence.mk\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Equivalence.lean\",\"def_pos\":[275,15],\"def_end_pos\":[275,17]},{\"full_name\":\"CategoryTheory.Localization.lift\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Localization\\/Predicate.lean\",\"def_pos\":[306,5],\"def_end_pos\":[306,9]},{\"full_name\":\"CategoryTheory.Localization.liftNatIso\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Localization\\/Predicate.lean\",\"def_pos\":[368,5],\"def_end_pos\":[368,15]},{\"full_name\":\"CategoryTheory.asIso\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Iso.lean\",\"def_pos\":[329,19],\"def_end_pos\":[329,24]},{\"full_name\":\"CategoryTheory.whiskerRight\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Whiskering.lean\",\"def_pos\":[58,5],\"def_end_pos\":[58,17]},{\"full_name\":\"CategoryTheory.Functor.associator\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Whiskering.lean\",\"def_pos\":[280,5],\"def_end_pos\":[280,15]},{\"full_name\":\"CategoryTheory.isoWhiskerLeft\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Whiskering.lean\",\"def_pos\":[172,5],\"def_end_pos\":[172,19]},{\"full_name\":\"CategoryTheory.Localization.fac\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Localization\\/Predicate.lean\",\"def_pos\":[318,5],\"def_end_pos\":[318,8]},{\"full_name\":\"CategoryTheory.asIso\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Iso.lean\",\"def_pos\":[329,19],\"def_end_pos\":[329,24]}]"
+              ],
+              "state_after": "C\u2081 : Type u_1\nC\u2082 : Type u_2\nD\u2081 : Type u_3\nD\u2082 : Type u_4\ninst\u271d\u2075 : Category.{u_6, u_1} C\u2081\ninst\u271d\u2074 : Category.{u_5, u_2} C\u2082\ninst\u271d\u00b3 : Category.{?u.46714, u_3} D\u2081\ninst\u271d\u00b2 : Category.{?u.46718, u_4} D\u2082\nG : C\u2081 \u2964 C\u2082\nF : C\u2082 \u2964 C\u2081\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nW : MorphismProperty C\u2081 := (MorphismProperty.isomorphisms C\u2082).inverseImage G\nhG : W.IsInvertedBy G\nthis\u271d : \u2200 (X : C\u2081), IsIso ((whiskerRight adj.unit W.Q).app X)\nthis : IsIso (whiskerRight adj.unit W.Q)\ne : W.Localization \u224c C\u2082 :=\n  Equivalence.mk (lift G hG W.Q) (F \u22d9 W.Q)\n    (liftNatIso W.Q W W.Q (G \u22d9 F \u22d9 W.Q) (\ud835\udfed W.Localization) (lift G hG W.Q \u22d9 F \u22d9 W.Q)\n      (W.Q.leftUnitor.symm \u226a\u226b asIso (whiskerRight adj.unit W.Q)))\n    (F.associator W.Q (lift G hG W.Q) \u226a\u226b isoWhiskerLeft F (fac G hG W.Q) \u226a\u226b asIso adj.counit)\n\u22a2 G.IsLocalization ((MorphismProperty.isomorphisms C\u2082).inverseImage G)",
+              "state_before": "C\u2081 : Type u_1\nC\u2082 : Type u_2\nD\u2081 : Type u_3\nD\u2082 : Type u_4\ninst\u271d\u2075 : Category.{u_6, u_1} C\u2081\ninst\u271d\u2074 : Category.{u_5, u_2} C\u2082\ninst\u271d\u00b3 : Category.{?u.46714, u_3} D\u2081\ninst\u271d\u00b2 : Category.{?u.46718, u_4} D\u2082\nG : C\u2081 \u2964 C\u2082\nF : C\u2082 \u2964 C\u2081\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nW : MorphismProperty C\u2081 := (MorphismProperty.isomorphisms C\u2082).inverseImage G\nhG : W.IsInvertedBy G\nthis\u271d : \u2200 (X : C\u2081), IsIso ((whiskerRight adj.unit W.Q).app X)\nthis : IsIso (whiskerRight adj.unit W.Q)\n\u22a2 G.IsLocalization ((MorphismProperty.isomorphisms C\u2082).inverseImage G)",
+              "tactic": "let e : W.Localization \u224c C\u2082 := Equivalence.mk (Localization.lift G hG W.Q) (F \u22d9 W.Q)\n  (liftNatIso W.Q W W.Q (G \u22d9 F \u22d9 W.Q) _ _\n  (W.Q.leftUnitor.symm \u226a\u226b asIso (whiskerRight adj.unit W.Q)))\n  (Functor.associator _ _ _ \u226a\u226b isoWhiskerLeft _ (Localization.fac G hG W.Q) \u226a\u226b\n    asIso adj.counit)"
+            },
+            {
+              "annotated_tactic": [
+                "\"apply <a>Functor.IsLocalization.of_equivalence_target<\\/a> W.Q W G e\\n    (<a>Localization.fac<\\/a> G hG W.Q)\"",
+                "[{\"full_name\":\"CategoryTheory.Functor.IsLocalization.of_equivalence_target\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Localization\\/Predicate.lean\",\"def_pos\":[421,9],\"def_end_pos\":[421,30]},{\"full_name\":\"CategoryTheory.Localization.fac\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Localization\\/Predicate.lean\",\"def_pos\":[318,5],\"def_end_pos\":[318,8]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C\u2081 : Type u_1\nC\u2082 : Type u_2\nD\u2081 : Type u_3\nD\u2082 : Type u_4\ninst\u271d\u2075 : Category.{u_6, u_1} C\u2081\ninst\u271d\u2074 : Category.{u_5, u_2} C\u2082\ninst\u271d\u00b3 : Category.{?u.46714, u_3} D\u2081\ninst\u271d\u00b2 : Category.{?u.46718, u_4} D\u2082\nG : C\u2081 \u2964 C\u2082\nF : C\u2082 \u2964 C\u2081\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nW : MorphismProperty C\u2081 := (MorphismProperty.isomorphisms C\u2082).inverseImage G\nhG : W.IsInvertedBy G\nthis\u271d : \u2200 (X : C\u2081), IsIso ((whiskerRight adj.unit W.Q).app X)\nthis : IsIso (whiskerRight adj.unit W.Q)\ne : W.Localization \u224c C\u2082 :=\n  Equivalence.mk (lift G hG W.Q) (F \u22d9 W.Q)\n    (liftNatIso W.Q W W.Q (G \u22d9 F \u22d9 W.Q) (\ud835\udfed W.Localization) (lift G hG W.Q \u22d9 F \u22d9 W.Q)\n      (W.Q.leftUnitor.symm \u226a\u226b asIso (whiskerRight adj.unit W.Q)))\n    (F.associator W.Q (lift G hG W.Q) \u226a\u226b isoWhiskerLeft F (fac G hG W.Q) \u226a\u226b asIso adj.counit)\n\u22a2 G.IsLocalization ((MorphismProperty.isomorphisms C\u2082).inverseImage G)",
+              "tactic": "apply Functor.IsLocalization.of_equivalence_target W.Q W G e\n  (Localization.fac G hG W.Q)"
+            },
+            {
+              "annotated_tactic": [
+                "\"change <a>IsIso<\\/a> _\"",
+                "[{\"full_name\":\"CategoryTheory.IsIso\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Iso.lean\",\"def_pos\":[272,7],\"def_end_pos\":[272,12]}]"
+              ],
+              "state_after": "C\u2081 : Type u_1\nC\u2082 : Type u_2\nD\u2081 : Type u_3\nD\u2082 : Type u_4\ninst\u271d\u2075 : Category.{u_6, u_1} C\u2081\ninst\u271d\u2074 : Category.{u_5, u_2} C\u2082\ninst\u271d\u00b3 : Category.{?u.46714, u_3} D\u2081\ninst\u271d\u00b2 : Category.{?u.46718, u_4} D\u2082\nG : C\u2081 \u2964 C\u2082\nF : C\u2082 \u2964 C\u2081\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nW : MorphismProperty C\u2081 := (MorphismProperty.isomorphisms C\u2082).inverseImage G\nhG : W.IsInvertedBy G\nX : C\u2081\n\u22a2 IsIso (G.map (adj.unit.app X))",
+              "state_before": "C\u2081 : Type u_1\nC\u2082 : Type u_2\nD\u2081 : Type u_3\nD\u2082 : Type u_4\ninst\u271d\u2075 : Category.{u_6, u_1} C\u2081\ninst\u271d\u2074 : Category.{u_5, u_2} C\u2082\ninst\u271d\u00b3 : Category.{?u.46714, u_3} D\u2081\ninst\u271d\u00b2 : Category.{?u.46718, u_4} D\u2082\nG : C\u2081 \u2964 C\u2082\nF : C\u2082 \u2964 C\u2081\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nW : MorphismProperty C\u2081 := (MorphismProperty.isomorphisms C\u2082).inverseImage G\nhG : W.IsInvertedBy G\nX : C\u2081\n\u22a2 W (adj.unit.app X)",
+              "tactic": "change IsIso _"
+            },
+            {
+              "annotated_tactic": [
+                "\"infer_instance\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C\u2081 : Type u_1\nC\u2082 : Type u_2\nD\u2081 : Type u_3\nD\u2082 : Type u_4\ninst\u271d\u2075 : Category.{u_6, u_1} C\u2081\ninst\u271d\u2074 : Category.{u_5, u_2} C\u2082\ninst\u271d\u00b3 : Category.{?u.46714, u_3} D\u2081\ninst\u271d\u00b2 : Category.{?u.46718, u_4} D\u2082\nG : C\u2081 \u2964 C\u2082\nF : C\u2082 \u2964 C\u2081\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nW : MorphismProperty C\u2081 := (MorphismProperty.isomorphisms C\u2082).inverseImage G\nhG : W.IsInvertedBy G\nX : C\u2081\n\u22a2 IsIso (G.map (adj.unit.app X))",
+              "tactic": "infer_instance"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Localization/Adjunction.lean"
+      },
+      {
+        "error": "no internal trace for tactic 'simp only [reassoc_of% hg, comp_id]'",
+        "full_name": "CategoryTheory.Localization.LeftBousfield.W_iff_isIso",
+        "id": "CategoryTheory.Localization.LeftBousfield.W_iff_isIso",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            104,
+            21
+          ],
+          "file_path": "Mathlib/CategoryTheory/Localization/Bousfield.lean",
+          "full_name": "CategoryTheory.Localization.LeftBousfield.W_iff_isIso",
+          "start": [
+            98,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"constructor\"",
+                "[]"
+              ],
+              "state_after": "case mp\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.3866, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhX : P X\nhY : P Y\n\u22a2 W P f \u2192 IsIso f\n\ncase mpr\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.3866, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhX : P X\nhY : P Y\n\u22a2 IsIso f \u2192 W P f",
+              "state_before": "C : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.3866, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhX : P X\nhY : P Y\n\u22a2 W P f \u2194 IsIso f",
+              "tactic": "constructor"
+            },
+            {
+              "annotated_tactic": [
+                "\"intro hf\"",
+                "[]"
+              ],
+              "state_after": "case mp\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.3866, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhX : P X\nhY : P Y\nhf : W P f\n\u22a2 IsIso f",
+              "state_before": "case mp\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.3866, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhX : P X\nhY : P Y\n\u22a2 W P f \u2192 IsIso f",
+              "tactic": "intro hf"
+            },
+            {
+              "annotated_tactic": [
+                "\"obtain \\u27e8g, hg\\u27e9 := (hf _ hX).2 (\\ud835\\udfd9 X)\"",
+                "[]"
+              ],
+              "state_after": "case mp.intro\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.3866, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhX : P X\nhY : P Y\nhf : W P f\ng : Y \u27f6 X\nhg : (fun g => f \u226b g) g = \ud835\udfd9 X\n\u22a2 IsIso f",
+              "state_before": "case mp\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.3866, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhX : P X\nhY : P Y\nhf : W P f\n\u22a2 IsIso f",
+              "tactic": "obtain \u27e8g, hg\u27e9 := (hf _ hX).2 (\ud835\udfd9 X)"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact \\u27e8g, hg, (hf _ hY).1 (by simp only [reassoc_of% hg, <a>comp_id<\\/a>])\\u27e9\"",
+                "[{\"full_name\":\"CategoryTheory.Category.comp_id\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[179,3],\"def_end_pos\":[179,10]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case mp.intro\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.3866, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhX : P X\nhY : P Y\nhf : W P f\ng : Y \u27f6 X\nhg : (fun g => f \u226b g) g = \ud835\udfd9 X\n\u22a2 IsIso f",
+              "tactic": "exact \u27e8g, hg, (hf _ hY).1 (by simp only [reassoc_of% hg, comp_id])\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp only [reassoc_of% hg, <a>comp_id<\\/a>]\"",
+                "[{\"full_name\":\"CategoryTheory.Category.comp_id\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[179,3],\"def_end_pos\":[179,10]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.3866, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhX : P X\nhY : P Y\nhf : W P f\ng : Y \u27f6 X\nhg : (fun g => f \u226b g) g = \ud835\udfd9 X\n\u22a2 (fun g => f \u226b g) (g \u226b f) = (fun g => f \u226b g) (\ud835\udfd9 Y)",
+              "tactic": "simp only [reassoc_of% hg, comp_id]"
+            },
+            {
+              "annotated_tactic": [
+                "\"apply <a>W_of_isIso<\\/a>\"",
+                "[{\"full_name\":\"CategoryTheory.Localization.LeftBousfield.W_of_isIso\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Localization\\/Bousfield.lean\",\"def_pos\":[91,7],\"def_end_pos\":[91,17]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case mpr\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.3866, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhX : P X\nhY : P Y\n\u22a2 IsIso f \u2192 W P f",
+              "tactic": "apply W_of_isIso"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Localization/Bousfield.lean"
+      },
+      {
+        "error": "no internal trace for tactic 'intro hf Z hZ'",
+        "full_name": "CategoryTheory.Localization.LeftBousfield.W_isoClosure",
+        "id": "CategoryTheory.Localization.LeftBousfield.W_isoClosure",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            74,
+            77
+          ],
+          "file_path": "Mathlib/CategoryTheory/Localization/Bousfield.lean",
+          "full_name": "CategoryTheory.Localization.LeftBousfield.W_isoClosure",
+          "start": [
+            61,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"ext X Y f\"",
+                "[]"
+              ],
+              "state_after": "case h\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.563, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\n\u22a2 W (isoClosure P) f \u2194 W P f",
+              "state_before": "C : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.563, u_2} D\nP : C \u2192 Prop\n\u22a2 W (isoClosure P) = W P",
+              "tactic": "ext X Y f"
+            },
+            {
+              "annotated_tactic": [
+                "\"constructor\"",
+                "[]"
+              ],
+              "state_after": "case h.mp\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.563, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\n\u22a2 W (isoClosure P) f \u2192 W P f\n\ncase h.mpr\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.563, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\n\u22a2 W P f \u2192 W (isoClosure P) f",
+              "state_before": "case h\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.563, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\n\u22a2 W (isoClosure P) f \u2194 W P f",
+              "tactic": "constructor"
+            },
+            {
+              "annotated_tactic": [
+                "\"intro hf Z hZ\"",
+                "[]"
+              ],
+              "state_after": "case h.mp\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.563, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhf : W (isoClosure P) f\nZ : C\nhZ : P Z\n\u22a2 Function.Bijective fun g => f \u226b g",
+              "state_before": "case h.mp\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.563, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\n\u22a2 W (isoClosure P) f \u2192 W P f",
+              "tactic": "intro hf Z hZ"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact hf _ (<a>le_isoClosure<\\/a> _ _ hZ)\"",
+                "[{\"full_name\":\"CategoryTheory.le_isoClosure\",\"def_path\":\"Mathlib\\/CategoryTheory\\/ClosedUnderIsomorphisms.lean\",\"def_pos\":[47,7],\"def_end_pos\":[47,20]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case h.mp\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.563, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhf : W (isoClosure P) f\nZ : C\nhZ : P Z\n\u22a2 Function.Bijective fun g => f \u226b g",
+              "tactic": "exact hf _ (le_isoClosure _ _ hZ)"
+            },
+            {
+              "annotated_tactic": [
+                "\"rintro hf Z \\u27e8Z', hZ', \\u27e8e\\u27e9\\u27e9\"",
+                "[]"
+              ],
+              "state_after": "case h.mpr.intro.intro.intro\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.563, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhf : W P f\nZ Z' : C\nhZ' : P Z'\ne : Z \u2245 Z'\n\u22a2 Function.Bijective fun g => f \u226b g",
+              "state_before": "case h.mpr\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.563, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\n\u22a2 W P f \u2192 W (isoClosure P) f",
+              "tactic": "rintro hf Z \u27e8Z', hZ', \u27e8e\u27e9\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"constructor\"",
+                "[]"
+              ],
+              "state_after": "case h.mpr.intro.intro.intro.left\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.563, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhf : W P f\nZ Z' : C\nhZ' : P Z'\ne : Z \u2245 Z'\n\u22a2 Function.Injective fun g => f \u226b g\n\ncase h.mpr.intro.intro.intro.right\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.563, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhf : W P f\nZ Z' : C\nhZ' : P Z'\ne : Z \u2245 Z'\n\u22a2 Function.Surjective fun g => f \u226b g",
+              "state_before": "case h.mpr.intro.intro.intro\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.563, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhf : W P f\nZ Z' : C\nhZ' : P Z'\ne : Z \u2245 Z'\n\u22a2 Function.Bijective fun g => f \u226b g",
+              "tactic": "constructor"
+            },
+            {
+              "annotated_tactic": [
+                "\"intro g\\u2081 g\\u2082 eq\"",
+                "[]"
+              ],
+              "state_after": "case h.mpr.intro.intro.intro.left\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.563, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhf : W P f\nZ Z' : C\nhZ' : P Z'\ne : Z \u2245 Z'\ng\u2081 g\u2082 : Y \u27f6 Z\neq : (fun g => f \u226b g) g\u2081 = (fun g => f \u226b g) g\u2082\n\u22a2 g\u2081 = g\u2082",
+              "state_before": "case h.mpr.intro.intro.intro.left\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.563, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhf : W P f\nZ Z' : C\nhZ' : P Z'\ne : Z \u2245 Z'\n\u22a2 Function.Injective fun g => f \u226b g",
+              "tactic": "intro g\u2081 g\u2082 eq"
+            },
+            {
+              "annotated_tactic": [
+                "\"rw [\\u2190 <a>cancel_mono<\\/a> e.hom]\"",
+                "[{\"full_name\":\"CategoryTheory.cancel_mono\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[310,9],\"def_end_pos\":[310,20]}]"
+              ],
+              "state_after": "case h.mpr.intro.intro.intro.left\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.563, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhf : W P f\nZ Z' : C\nhZ' : P Z'\ne : Z \u2245 Z'\ng\u2081 g\u2082 : Y \u27f6 Z\neq : (fun g => f \u226b g) g\u2081 = (fun g => f \u226b g) g\u2082\n\u22a2 g\u2081 \u226b e.hom = g\u2082 \u226b e.hom",
+              "state_before": "case h.mpr.intro.intro.intro.left\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.563, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhf : W P f\nZ Z' : C\nhZ' : P Z'\ne : Z \u2245 Z'\ng\u2081 g\u2082 : Y \u27f6 Z\neq : (fun g => f \u226b g) g\u2081 = (fun g => f \u226b g) g\u2082\n\u22a2 g\u2081 = g\u2082",
+              "tactic": "rw [\u2190 cancel_mono e.hom]"
+            },
+            {
+              "annotated_tactic": [
+                "\"apply (hf _ hZ').1\"",
+                "[]"
+              ],
+              "state_after": "case h.mpr.intro.intro.intro.left.a\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.563, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhf : W P f\nZ Z' : C\nhZ' : P Z'\ne : Z \u2245 Z'\ng\u2081 g\u2082 : Y \u27f6 Z\neq : (fun g => f \u226b g) g\u2081 = (fun g => f \u226b g) g\u2082\n\u22a2 (fun g => f \u226b g) (g\u2081 \u226b e.hom) = (fun g => f \u226b g) (g\u2082 \u226b e.hom)",
+              "state_before": "case h.mpr.intro.intro.intro.left\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.563, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhf : W P f\nZ Z' : C\nhZ' : P Z'\ne : Z \u2245 Z'\ng\u2081 g\u2082 : Y \u27f6 Z\neq : (fun g => f \u226b g) g\u2081 = (fun g => f \u226b g) g\u2082\n\u22a2 g\u2081 \u226b e.hom = g\u2082 \u226b e.hom",
+              "tactic": "apply (hf _ hZ').1"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp only [reassoc_of% eq]\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case h.mpr.intro.intro.intro.left.a\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.563, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhf : W P f\nZ Z' : C\nhZ' : P Z'\ne : Z \u2245 Z'\ng\u2081 g\u2082 : Y \u27f6 Z\neq : (fun g => f \u226b g) g\u2081 = (fun g => f \u226b g) g\u2082\n\u22a2 (fun g => f \u226b g) (g\u2081 \u226b e.hom) = (fun g => f \u226b g) (g\u2082 \u226b e.hom)",
+              "tactic": "simp only [reassoc_of% eq]"
+            },
+            {
+              "annotated_tactic": [
+                "\"intro g\"",
+                "[]"
+              ],
+              "state_after": "case h.mpr.intro.intro.intro.right\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.563, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhf : W P f\nZ Z' : C\nhZ' : P Z'\ne : Z \u2245 Z'\ng : X \u27f6 Z\n\u22a2 \u2203 a, (fun g => f \u226b g) a = g",
+              "state_before": "case h.mpr.intro.intro.intro.right\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.563, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhf : W P f\nZ Z' : C\nhZ' : P Z'\ne : Z \u2245 Z'\n\u22a2 Function.Surjective fun g => f \u226b g",
+              "tactic": "intro g"
+            },
+            {
+              "annotated_tactic": [
+                "\"obtain \\u27e8a, h\\u27e9 := (hf _ hZ').2 (g \\u226b e.hom)\"",
+                "[]"
+              ],
+              "state_after": "case h.mpr.intro.intro.intro.right.intro\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.563, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhf : W P f\nZ Z' : C\nhZ' : P Z'\ne : Z \u2245 Z'\ng : X \u27f6 Z\na : Y \u27f6 Z'\nh : (fun g => f \u226b g) a = g \u226b e.hom\n\u22a2 \u2203 a, (fun g => f \u226b g) a = g",
+              "state_before": "case h.mpr.intro.intro.intro.right\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.563, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhf : W P f\nZ Z' : C\nhZ' : P Z'\ne : Z \u2245 Z'\ng : X \u27f6 Z\n\u22a2 \u2203 a, (fun g => f \u226b g) a = g",
+              "tactic": "obtain \u27e8a, h\u27e9 := (hf _ hZ').2 (g \u226b e.hom)"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact \\u27e8a \\u226b e.inv, by simp only [reassoc_of% h, e.hom_inv_id, <a>comp_id<\\/a>]\\u27e9\"",
+                "[{\"full_name\":\"CategoryTheory.Category.comp_id\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[179,3],\"def_end_pos\":[179,10]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case h.mpr.intro.intro.intro.right.intro\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.563, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhf : W P f\nZ Z' : C\nhZ' : P Z'\ne : Z \u2245 Z'\ng : X \u27f6 Z\na : Y \u27f6 Z'\nh : (fun g => f \u226b g) a = g \u226b e.hom\n\u22a2 \u2203 a, (fun g => f \u226b g) a = g",
+              "tactic": "exact \u27e8a \u226b e.inv, by simp only [reassoc_of% h, e.hom_inv_id, comp_id]\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp only [reassoc_of% h, e.hom_inv_id, <a>comp_id<\\/a>]\"",
+                "[{\"full_name\":\"CategoryTheory.Category.comp_id\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[179,3],\"def_end_pos\":[179,10]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{?u.563, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\nhf : W P f\nZ Z' : C\nhZ' : P Z'\ne : Z \u2245 Z'\ng : X \u27f6 Z\na : Y \u27f6 Z'\nh : (fun g => f \u226b g) a = g \u226b e.hom\n\u22a2 (fun g => f \u226b g) (a \u226b e.inv) = g",
+              "tactic": "simp only [reassoc_of% h, e.hom_inv_id, comp_id]"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Localization/Bousfield.lean"
+      },
+      {
+        "error": "no internal trace for tactic 'simp'",
+        "full_name": "CategoryTheory.Localization.LeftBousfield.W_of_isIso",
+        "id": "CategoryTheory.Localization.LeftBousfield.W_of_isIso",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            96,
+            31
+          ],
+          "file_path": "Mathlib/CategoryTheory/Localization/Bousfield.lean",
+          "full_name": "CategoryTheory.Localization.LeftBousfield.W_of_isIso",
+          "start": [
+            91,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"constructor\"",
+                "[]"
+              ],
+              "state_after": "case left\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b2 : Category.{u_3, u_1} C\ninst\u271d\u00b9 : Category.{?u.3005, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\ninst\u271d : IsIso f\nZ : C\nx\u271d : P Z\n\u22a2 Function.Injective fun g => f \u226b g\n\ncase right\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b2 : Category.{u_3, u_1} C\ninst\u271d\u00b9 : Category.{?u.3005, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\ninst\u271d : IsIso f\nZ : C\nx\u271d : P Z\n\u22a2 Function.Surjective fun g => f \u226b g",
+              "state_before": "C : Type u_1\nD : Type u_2\ninst\u271d\u00b2 : Category.{u_3, u_1} C\ninst\u271d\u00b9 : Category.{?u.3005, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\ninst\u271d : IsIso f\nZ : C\nx\u271d : P Z\n\u22a2 Function.Bijective fun g => f \u226b g",
+              "tactic": "constructor"
+            },
+            {
+              "annotated_tactic": [
+                "\"intro g\\u2081 g\\u2082 _\"",
+                "[]"
+              ],
+              "state_after": "case left\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b2 : Category.{u_3, u_1} C\ninst\u271d\u00b9 : Category.{?u.3005, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\ninst\u271d : IsIso f\nZ : C\nx\u271d : P Z\ng\u2081 g\u2082 : Y \u27f6 Z\na\u271d : (fun g => f \u226b g) g\u2081 = (fun g => f \u226b g) g\u2082\n\u22a2 g\u2081 = g\u2082",
+              "state_before": "case left\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b2 : Category.{u_3, u_1} C\ninst\u271d\u00b9 : Category.{?u.3005, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\ninst\u271d : IsIso f\nZ : C\nx\u271d : P Z\n\u22a2 Function.Injective fun g => f \u226b g",
+              "tactic": "intro g\u2081 g\u2082 _"
+            },
+            {
+              "annotated_tactic": [
+                "\"simpa only [\\u2190 <a>cancel_epi<\\/a> f]\"",
+                "[{\"full_name\":\"CategoryTheory.cancel_epi\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[306,9],\"def_end_pos\":[306,19]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case left\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b2 : Category.{u_3, u_1} C\ninst\u271d\u00b9 : Category.{?u.3005, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\ninst\u271d : IsIso f\nZ : C\nx\u271d : P Z\ng\u2081 g\u2082 : Y \u27f6 Z\na\u271d : (fun g => f \u226b g) g\u2081 = (fun g => f \u226b g) g\u2082\n\u22a2 g\u2081 = g\u2082",
+              "tactic": "simpa only [\u2190 cancel_epi f]"
+            },
+            {
+              "annotated_tactic": [
+                "\"intro g\"",
+                "[]"
+              ],
+              "state_after": "case right\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b2 : Category.{u_3, u_1} C\ninst\u271d\u00b9 : Category.{?u.3005, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\ninst\u271d : IsIso f\nZ : C\nx\u271d : P Z\ng : X \u27f6 Z\n\u22a2 \u2203 a, (fun g => f \u226b g) a = g",
+              "state_before": "case right\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b2 : Category.{u_3, u_1} C\ninst\u271d\u00b9 : Category.{?u.3005, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\ninst\u271d : IsIso f\nZ : C\nx\u271d : P Z\n\u22a2 Function.Surjective fun g => f \u226b g",
+              "tactic": "intro g"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact \\u27e8<a>inv<\\/a> f \\u226b g, by simp\\u27e9\"",
+                "[{\"full_name\":\"CategoryTheory.inv\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Iso.lean\",\"def_pos\":[279,19],\"def_end_pos\":[279,22]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case right\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b2 : Category.{u_3, u_1} C\ninst\u271d\u00b9 : Category.{?u.3005, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\ninst\u271d : IsIso f\nZ : C\nx\u271d : P Z\ng : X \u27f6 Z\n\u22a2 \u2203 a, (fun g => f \u226b g) a = g",
+              "tactic": "exact \u27e8inv f \u226b g, by simp\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u_1\nD : Type u_2\ninst\u271d\u00b2 : Category.{u_3, u_1} C\ninst\u271d\u00b9 : Category.{?u.3005, u_2} D\nP : C \u2192 Prop\nX Y : C\nf : X \u27f6 Y\ninst\u271d : IsIso f\nZ : C\nx\u271d : P Z\ng : X \u27f6 Z\n\u22a2 (fun g => f \u226b g) (inv f \u226b g) = g",
+              "tactic": "simp"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Localization/Bousfield.lean"
+      }
+    ],
+    "input_proofs": 11,
+    "input_units": 2,
+    "proofs": 7,
+    "published_proofs": 6,
+    "published_transitions": 12,
+    "replay_failures": [],
+    "transitions": 22,
+    "validation_failures": [
+      {
+        "errors": [
+          "internal transition boundary mismatch",
+          "internal transition boundary mismatch"
+        ],
+        "file_path": "Mathlib/CategoryTheory/Localization/Bousfield.lean",
+        "proof_id": "mathlib:CategoryTheory.Localization.LeftBousfield.W_iff_isIso_map",
+        "provenance": {
+          "selection": {
+            "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+            "end": [
+              130,
+              19
+            ],
+            "file_path": "Mathlib/CategoryTheory/Localization/Bousfield.lean",
+            "full_name": "CategoryTheory.Localization.LeftBousfield.W_iff_isIso_map",
+            "start": [
+              118,
+              1
+            ],
+            "traced_tactics": [
+              {
+                "annotated_tactic": [
+                  "\"rw [\\u2190 <a>MorphismProperty.postcomp_iff<\\/a> _ _ _ (<a>W_adj_unit_app<\\/a> adj Y)]\"",
+                  "[{\"full_name\":\"CategoryTheory.MorphismProperty.postcomp_iff\",\"def_path\":\"Mathlib\\/CategoryTheory\\/MorphismProperty\\/Composition.lean\",\"def_pos\":[201,7],\"def_end_pos\":[201,19]},{\"full_name\":\"CategoryTheory.Localization.LeftBousfield.W_adj_unit_app\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Localization\\/Bousfield.lean\",\"def_pos\":[112,7],\"def_end_pos\":[112,21]}]"
+                ],
+                "state_after": "C : Type u_1\nD : Type u_2\ninst\u271d\u00b3 : Category.{u_4, u_1} C\ninst\u271d\u00b2 : Category.{u_3, u_2} D\nF : C \u2964 D\nG : D \u2964 C\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nX Y : D\nf : X \u27f6 Y\n\u22a2 W (fun x => x \u2208 Set.range F.obj) (f \u226b adj.unit.app Y) \u2194 IsIso (G.map f)",
+                "state_before": "C : Type u_1\nD : Type u_2\ninst\u271d\u00b3 : Category.{u_4, u_1} C\ninst\u271d\u00b2 : Category.{u_3, u_2} D\nF : C \u2964 D\nG : D \u2964 C\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nX Y : D\nf : X \u27f6 Y\n\u22a2 W (fun x => x \u2208 Set.range F.obj) f \u2194 IsIso (G.map f)",
+                "tactic": "rw [\u2190 MorphismProperty.postcomp_iff _ _ _ (W_adj_unit_app adj Y)]"
+              },
+              {
+                "annotated_tactic": [
+                  "\"erw [adj.unit.naturality f]\"",
+                  "[]"
+                ],
+                "state_after": "C : Type u_1\nD : Type u_2\ninst\u271d\u00b3 : Category.{u_4, u_1} C\ninst\u271d\u00b2 : Category.{u_3, u_2} D\nF : C \u2964 D\nG : D \u2964 C\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nX Y : D\nf : X \u27f6 Y\n\u22a2 W (fun x => x \u2208 Set.range F.obj) (adj.unit.app X \u226b (G \u22d9 F).map f) \u2194 IsIso (G.map f)",
+                "state_before": "C : Type u_1\nD : Type u_2\ninst\u271d\u00b3 : Category.{u_4, u_1} C\ninst\u271d\u00b2 : Category.{u_3, u_2} D\nF : C \u2964 D\nG : D \u2964 C\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nX Y : D\nf : X \u27f6 Y\n\u22a2 W (fun x => x \u2208 Set.range F.obj) (f \u226b adj.unit.app Y) \u2194 IsIso (G.map f)",
+                "tactic": "erw [adj.unit.naturality f]"
+              },
+              {
+                "annotated_tactic": [
+                  "\"rw [<a>MorphismProperty.precomp_iff<\\/a> _ _ _ (<a>W_adj_unit_app<\\/a> adj X),\\n    <a>W_iff_isIso<\\/a> _ _ \\u27e8_, <a>rfl<\\/a>\\u27e9 \\u27e8_, <a>rfl<\\/a>\\u27e9]\"",
+                  "[{\"full_name\":\"CategoryTheory.MorphismProperty.precomp_iff\",\"def_path\":\"Mathlib\\/CategoryTheory\\/MorphismProperty\\/Composition.lean\",\"def_pos\":[205,7],\"def_end_pos\":[205,18]},{\"full_name\":\"CategoryTheory.Localization.LeftBousfield.W_adj_unit_app\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Localization\\/Bousfield.lean\",\"def_pos\":[112,7],\"def_end_pos\":[112,21]},{\"full_name\":\"CategoryTheory.Localization.LeftBousfield.W_iff_isIso\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Localization\\/Bousfield.lean\",\"def_pos\":[98,7],\"def_end_pos\":[98,18]},{\"full_name\":\"rfl\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[294,22],\"def_end_pos\":[294,25]},{\"full_name\":\"rfl\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[294,22],\"def_end_pos\":[294,25]}]"
+                ],
+                "state_after": "C : Type u_1\nD : Type u_2\ninst\u271d\u00b3 : Category.{u_4, u_1} C\ninst\u271d\u00b2 : Category.{u_3, u_2} D\nF : C \u2964 D\nG : D \u2964 C\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nX Y : D\nf : X \u27f6 Y\n\u22a2 IsIso ((G \u22d9 F).map f) \u2194 IsIso (G.map f)",
+                "state_before": "C : Type u_1\nD : Type u_2\ninst\u271d\u00b3 : Category.{u_4, u_1} C\ninst\u271d\u00b2 : Category.{u_3, u_2} D\nF : C \u2964 D\nG : D \u2964 C\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nX Y : D\nf : X \u27f6 Y\n\u22a2 W (fun x => x \u2208 Set.range F.obj) (adj.unit.app X \u226b (G \u22d9 F).map f) \u2194 IsIso (G.map f)",
+                "tactic": "rw [MorphismProperty.precomp_iff _ _ _ (W_adj_unit_app adj X),\n  W_iff_isIso _ _ \u27e8_, rfl\u27e9 \u27e8_, rfl\u27e9]"
+              },
+              {
+                "annotated_tactic": [
+                  "\"constructor\"",
+                  "[]"
+                ],
+                "state_after": "case mp\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b3 : Category.{u_4, u_1} C\ninst\u271d\u00b2 : Category.{u_3, u_2} D\nF : C \u2964 D\nG : D \u2964 C\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nX Y : D\nf : X \u27f6 Y\n\u22a2 IsIso ((G \u22d9 F).map f) \u2192 IsIso (G.map f)\n\ncase mpr\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b3 : Category.{u_4, u_1} C\ninst\u271d\u00b2 : Category.{u_3, u_2} D\nF : C \u2964 D\nG : D \u2964 C\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nX Y : D\nf : X \u27f6 Y\n\u22a2 IsIso (G.map f) \u2192 IsIso ((G \u22d9 F).map f)",
+                "state_before": "C : Type u_1\nD : Type u_2\ninst\u271d\u00b3 : Category.{u_4, u_1} C\ninst\u271d\u00b2 : Category.{u_3, u_2} D\nF : C \u2964 D\nG : D \u2964 C\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nX Y : D\nf : X \u27f6 Y\n\u22a2 IsIso ((G \u22d9 F).map f) \u2194 IsIso (G.map f)",
+                "tactic": "constructor"
+              },
+              {
+                "annotated_tactic": [
+                  "\"intro h\"",
+                  "[]"
+                ],
+                "state_after": "case mp\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b3 : Category.{u_4, u_1} C\ninst\u271d\u00b2 : Category.{u_3, u_2} D\nF : C \u2964 D\nG : D \u2964 C\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nX Y : D\nf : X \u27f6 Y\nh : IsIso ((G \u22d9 F).map f)\n\u22a2 IsIso (G.map f)",
+                "state_before": "case mp\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b3 : Category.{u_4, u_1} C\ninst\u271d\u00b2 : Category.{u_3, u_2} D\nF : C \u2964 D\nG : D \u2964 C\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nX Y : D\nf : X \u27f6 Y\n\u22a2 IsIso ((G \u22d9 F).map f) \u2192 IsIso (G.map f)",
+                "tactic": "intro h"
+              },
+              {
+                "annotated_tactic": [
+                  "\"dsimp at h\"",
+                  "[]"
+                ],
+                "state_after": "case mp\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b3 : Category.{u_4, u_1} C\ninst\u271d\u00b2 : Category.{u_3, u_2} D\nF : C \u2964 D\nG : D \u2964 C\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nX Y : D\nf : X \u27f6 Y\nh : IsIso (F.map (G.map f))\n\u22a2 IsIso (G.map f)",
+                "state_before": "case mp\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b3 : Category.{u_4, u_1} C\ninst\u271d\u00b2 : Category.{u_3, u_2} D\nF : C \u2964 D\nG : D \u2964 C\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nX Y : D\nf : X \u27f6 Y\nh : IsIso ((G \u22d9 F).map f)\n\u22a2 IsIso (G.map f)",
+                "tactic": "dsimp at h"
+              },
+              {
+                "annotated_tactic": [
+                  "\"exact <a>isIso_of_fully_faithful<\\/a> F (G.map f)\"",
+                  "[{\"full_name\":\"CategoryTheory.isIso_of_fully_faithful\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Functor\\/FullyFaithful.lean\",\"def_pos\":[228,9],\"def_end_pos\":[228,32]}]"
+                ],
+                "state_after": "no goals",
+                "state_before": "case mp\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b3 : Category.{u_4, u_1} C\ninst\u271d\u00b2 : Category.{u_3, u_2} D\nF : C \u2964 D\nG : D \u2964 C\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nX Y : D\nf : X \u27f6 Y\nh : IsIso (F.map (G.map f))\n\u22a2 IsIso (G.map f)",
+                "tactic": "exact isIso_of_fully_faithful F (G.map f)"
+              },
+              {
+                "annotated_tactic": [
+                  "\"intro\"",
+                  "[]"
+                ],
+                "state_after": "case mpr\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b3 : Category.{u_4, u_1} C\ninst\u271d\u00b2 : Category.{u_3, u_2} D\nF : C \u2964 D\nG : D \u2964 C\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nX Y : D\nf : X \u27f6 Y\na\u271d : IsIso (G.map f)\n\u22a2 IsIso ((G \u22d9 F).map f)",
+                "state_before": "case mpr\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b3 : Category.{u_4, u_1} C\ninst\u271d\u00b2 : Category.{u_3, u_2} D\nF : C \u2964 D\nG : D \u2964 C\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nX Y : D\nf : X \u27f6 Y\n\u22a2 IsIso (G.map f) \u2192 IsIso ((G \u22d9 F).map f)",
+                "tactic": "intro"
+              },
+              {
+                "annotated_tactic": [
+                  "\"rw [<a>Functor.comp_map<\\/a>]\"",
+                  "[{\"full_name\":\"CategoryTheory.Functor.comp_map\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Functor\\/Basic.lean\",\"def_pos\":[122,9],\"def_end_pos\":[122,17]}]"
+                ],
+                "state_after": "case mpr\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b3 : Category.{u_4, u_1} C\ninst\u271d\u00b2 : Category.{u_3, u_2} D\nF : C \u2964 D\nG : D \u2964 C\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nX Y : D\nf : X \u27f6 Y\na\u271d : IsIso (G.map f)\n\u22a2 IsIso (F.map (G.map f))",
+                "state_before": "case mpr\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b3 : Category.{u_4, u_1} C\ninst\u271d\u00b2 : Category.{u_3, u_2} D\nF : C \u2964 D\nG : D \u2964 C\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nX Y : D\nf : X \u27f6 Y\na\u271d : IsIso (G.map f)\n\u22a2 IsIso ((G \u22d9 F).map f)",
+                "tactic": "rw [Functor.comp_map]"
+              },
+              {
+                "annotated_tactic": [
+                  "\"infer_instance\"",
+                  "[]"
+                ],
+                "state_after": "no goals",
+                "state_before": "case mpr\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b3 : Category.{u_4, u_1} C\ninst\u271d\u00b2 : Category.{u_3, u_2} D\nF : C \u2964 D\nG : D \u2964 C\nadj : G \u22a3 F\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nX Y : D\nf : X \u27f6 Y\na\u271d : IsIso (G.map f)\n\u22a2 IsIso (F.map (G.map f))",
+                "tactic": "infer_instance"
+              }
+            ],
+            "url": "https://github.com/leanprover-community/mathlib4"
+          }
+        },
+        "theorem_name": "CategoryTheory.Localization.LeftBousfield.W_iff_isIso_map"
+      }
+    ],
+    "validation_rejected_proofs": 1,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/mathlib-000714-0000-c1fc51157ee9273a.parquet",
+      "sha256": "c1fc51157ee9273a35f7aad04a12110da5456e3d3e6a1308db742aa3b3044d16",
+      "bytes": 81517,
+      "rows": 10,
+      "revision": "22515991803e73ecc3c0bc878466a6d683e86be7"
+    },
+    {
+      "path": "data/dev/mathlib-000714-0000-74dab00ef252e216.parquet",
+      "sha256": "74dab00ef252e216db327a3d8a55b6c7b47e4fb0e6343e6124fa5f02587b3d8e",
+      "bytes": 59907,
+      "rows": 2,
+      "revision": "22515991803e73ecc3c0bc878466a6d683e86be7"
+    }
+  ],
+  "proof_ids": [
+    "mathlib:CategoryTheory.Adjunction.Localization.\u03b5_app",
+    "mathlib:CategoryTheory.Adjunction.localization_counit_app",
+    "mathlib:CategoryTheory.Adjunction.localization_unit_app",
+    "mathlib:CategoryTheory.Localization.LeftBousfield.W_adj_unit_app",
+    "mathlib:CategoryTheory.Localization.LeftBousfield.W_eq_inverseImage_isomorphisms",
+    "mathlib:CategoryTheory.Localization.LeftBousfield.isLocalization"
+  ],
+  "proof_keys": [
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Localization/Adjunction.lean\",null,null,\"CategoryTheory.Adjunction.Localization.\u03b5_app\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Localization/Adjunction.lean\",null,null,\"CategoryTheory.Adjunction.localization_counit_app\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Localization/Adjunction.lean\",null,null,\"CategoryTheory.Adjunction.localization_unit_app\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Localization/Bousfield.lean\",null,null,\"CategoryTheory.Localization.LeftBousfield.W_adj_unit_app\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Localization/Bousfield.lean\",null,null,\"CategoryTheory.Localization.LeftBousfield.W_eq_inverseImage_isomorphisms\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Localization/Bousfield.lean\",null,null,\"CategoryTheory.Localization.LeftBousfield.isLocalization\"]"
+  ]
+}

manifests/batches/mathlib/000719.json

@@ -0,0 +1,196 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "mathlib/000719",
+  "batch_fingerprint": "69917832eff001b2fb58cfe0c86a3d38b87a87a90b22727c7672a0de8c3552cc",
+  "evidence": {
+    "batch_fingerprint": "69917832eff001b2fb58cfe0c86a3d38b87a87a90b22727c7672a0de8c3552cc",
+    "contamination_matches": [],
+    "failures": [
+      {
+        "error": "no internal trace for tactic \"obtain \u27e8_, _, f', hf', \u27e8e\u27e9\u27e9 := hW\u2081 f hf\"",
+        "full_name": "CategoryTheory.Functor.IsLocalization.of_equivalence_source",
+        "id": "CategoryTheory.Functor.IsLocalization.of_equivalence_source",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            93,
+            93
+          ],
+          "file_path": "Mathlib/CategoryTheory/Localization/Equivalence.lean",
+          "full_name": "CategoryTheory.Functor.IsLocalization.of_equivalence_source",
+          "start": [
+            64,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"have h : W\\u2081.IsInvertedBy (E.functor \\u22d9 W\\u2082.Q) := fun _ _ f hf => by\\n    obtain \\u27e8_, _, f', hf', \\u27e8e\\u27e9\\u27e9 := hW\\u2081 f hf\\n    exact ((<a>MorphismProperty.RespectsIso.isomorphisms<\\/a> _).<a>arrow_mk_iso_iff<\\/a>\\n      (W\\u2082.Q.mapArrow.mapIso e)).1 (<a>Localization.inverts<\\/a> W\\u2082.Q W\\u2082 _ hf')\"",
+                "[{\"full_name\":\"CategoryTheory.MorphismProperty.RespectsIso.isomorphisms\",\"def_path\":\"Mathlib\\/CategoryTheory\\/MorphismProperty\\/Basic.lean\",\"def_pos\":[354,9],\"def_end_pos\":[354,33]},{\"full_name\":\"CategoryTheory.MorphismProperty.RespectsIso.arrow_mk_iso_iff\",\"def_path\":\"Mathlib\\/CategoryTheory\\/MorphismProperty\\/Basic.lean\",\"def_pos\":[153,9],\"def_end_pos\":[153,37]},{\"full_name\":\"CategoryTheory.Localization.inverts\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Localization\\/Predicate.lean\",\"def_pos\":[143,9],\"def_end_pos\":[143,16]}]"
+              ],
+              "state_after": "C\u2081 : Type u_1\nC\u2082 : Type u_2\nD : Type u_3\nD\u2081 : Type u_4\nD\u2082 : Type u_5\ninst\u271d\u2075 : Category.{u_6, u_1} C\u2081\ninst\u271d\u2074 : Category.{u_8, u_2} C\u2082\ninst\u271d\u00b3 : Category.{u_7, u_3} D\ninst\u271d\u00b2 : Category.{?u.10785, u_4} D\u2081\ninst\u271d\u00b9 : Category.{?u.10789, u_5} D\u2082\nL\u2081 : C\u2081 \u2964 D\nW\u2081 : MorphismProperty C\u2081\nL\u2082 : C\u2082 \u2964 D\nW\u2082 : MorphismProperty C\u2082\nE : C\u2081 \u224c C\u2082\nhW\u2081 : W\u2081 \u2264 W\u2082.isoClosure.inverseImage E.functor\nhW\u2082 : W\u2082.IsInvertedBy L\u2082\ninst\u271d : L\u2081.IsLocalization W\u2081\niso : E.functor \u22d9 L\u2082 \u2245 L\u2081\nh : W\u2081.IsInvertedBy (E.functor \u22d9 W\u2082.Q)\n\u22a2 L\u2082.IsLocalization W\u2082",
+              "state_before": "C\u2081 : Type u_1\nC\u2082 : Type u_2\nD : Type u_3\nD\u2081 : Type u_4\nD\u2082 : Type u_5\ninst\u271d\u2075 : Category.{u_6, u_1} C\u2081\ninst\u271d\u2074 : Category.{u_8, u_2} C\u2082\ninst\u271d\u00b3 : Category.{u_7, u_3} D\ninst\u271d\u00b2 : Category.{?u.10785, u_4} D\u2081\ninst\u271d\u00b9 : Category.{?u.10789, u_5} D\u2082\nL\u2081 : C\u2081 \u2964 D\nW\u2081 : MorphismProperty C\u2081\nL\u2082 : C\u2082 \u2964 D\nW\u2082 : MorphismProperty C\u2082\nE : C\u2081 \u224c C\u2082\nhW\u2081 : W\u2081 \u2264 W\u2082.isoClosure.inverseImage E.functor\nhW\u2082 : W\u2082.IsInvertedBy L\u2082\ninst\u271d : L\u2081.IsLocalization W\u2081\niso : E.functor \u22d9 L\u2082 \u2245 L\u2081\n\u22a2 L\u2082.IsLocalization W\u2082",
+              "tactic": "have h : W\u2081.IsInvertedBy (E.functor \u22d9 W\u2082.Q) := fun _ _ f hf => by\n  obtain \u27e8_, _, f', hf', \u27e8e\u27e9\u27e9 := hW\u2081 f hf\n  exact ((MorphismProperty.RespectsIso.isomorphisms _).arrow_mk_iso_iff\n    (W\u2082.Q.mapArrow.mapIso e)).1 (Localization.inverts W\u2082.Q W\u2082 _ hf')"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact\\n    { inverts := hW\\u2082\\n      isEquivalence :=\\n        <a>Localization.isEquivalence<\\/a> W\\u2082.Q W\\u2082 L\\u2081 W\\u2081 L\\u2082 (<a>Construction.lift<\\/a> L\\u2082 hW\\u2082)\\n          (E.functor \\u22d9 W\\u2082.Q) (<a>Localization.lift<\\/a> (E.functor \\u22d9 W\\u2082.Q) h L\\u2081) (by\\n            calc\\n              L\\u2082 \\u22d9 <a>lift<\\/a> (E.functor \\u22d9 W\\u2082.Q) h L\\u2081 \\u2245 _ := (<a>leftUnitor<\\/a> _).<a>symm<\\/a>\\n              _ \\u2245 _ := <a>isoWhiskerRight<\\/a> E.counitIso.symm _\\n              _ \\u2245 E.inverse \\u22d9 E.functor \\u22d9 L\\u2082 \\u22d9 <a>lift<\\/a> (E.functor \\u22d9 W\\u2082.Q) h L\\u2081 :=\\n                    <a>Functor.associator<\\/a> _ _ _\\n              _ \\u2245 E.inverse \\u22d9 L\\u2081 \\u22d9 <a>lift<\\/a> (E.functor \\u22d9 W\\u2082.Q) h L\\u2081 :=\\n                    <a>isoWhiskerLeft<\\/a> E.inverse ((<a>Functor.associator<\\/a> _ _ _).<a>symm<\\/a> \\u226a\\u226b\\n                      <a>isoWhiskerRight<\\/a> iso _)\\n              _ \\u2245 E.inverse \\u22d9 E.functor \\u22d9 W\\u2082.Q :=\\n                    <a>isoWhiskerLeft<\\/a> _ (<a>Localization.fac<\\/a> (E.functor \\u22d9 W\\u2082.Q) h L\\u2081)\\n              _ \\u2245 (E.inverse \\u22d9 E.functor) \\u22d9 W\\u2082.Q := (<a>Functor.associator<\\/a> _ _ _).<a>symm<\\/a>\\n              _ \\u2245 \\ud835\\udfed C\\u2082 \\u22d9 W\\u2082.Q := <a>isoWhiskerRight<\\/a> E.counitIso _\\n              _ \\u2245 W\\u2082.Q := <a>leftUnitor<\\/a> _)\\n          (<a>Functor.associator<\\/a> _ _ _ \\u226a\\u226b <a>isoWhiskerLeft<\\/a> _ (<a>Lifting.iso<\\/a> W\\u2082.Q W\\u2082 _ _)  \\u226a\\u226b iso) }\"",
+                "[{\"full_name\":\"CategoryTheory.Localization.isEquivalence\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Localization\\/Equivalence.lean\",\"def_pos\":[55,7],\"def_end_pos\":[55,20]},{\"full_name\":\"CategoryTheory.Localization.Construction.lift\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Localization\\/Construction.lean\",\"def_pos\":[167,5],\"def_end_pos\":[167,9]},{\"full_name\":\"CategoryTheory.Localization.lift\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Localization\\/Predicate.lean\",\"def_pos\":[306,5],\"def_end_pos\":[306,9]},{\"full_name\":\"CategoryTheory.Localization.lift\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Localization\\/Predicate.lean\",\"def_pos\":[306,5],\"def_end_pos\":[306,9]},{\"full_name\":\"CategoryTheory.Functor.leftUnitor\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Whiskering.lean\",\"def_pos\":[252,5],\"def_end_pos\":[252,15]},{\"full_name\":\"CategoryTheory.Iso.symm\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Iso.lean\",\"def_pos\":[94,5],\"def_end_pos\":[94,9]},{\"full_name\":\"CategoryTheory.isoWhiskerRight\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Whiskering.lean\",\"def_pos\":[191,5],\"def_end_pos\":[191,20]},{\"full_name\":\"CategoryTheory.Localization.lift\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Localization\\/Predicate.lean\",\"def_pos\":[306,5],\"def_end_pos\":[306,9]},{\"full_name\":\"CategoryTheory.Functor.associator\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Whiskering.lean\",\"def_pos\":[280,5],\"def_end_pos\":[280,15]},{\"full_name\":\"CategoryTheory.Localization.lift\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Localization\\/Predicate.lean\",\"def_pos\":[306,5],\"def_end_pos\":[306,9]},{\"full_name\":\"CategoryTheory.isoWhiskerLeft\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Whiskering.lean\",\"def_pos\":[172,5],\"def_end_pos\":[172,19]},{\"full_name\":\"CategoryTheory.Functor.associator\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Whiskering.lean\",\"def_pos\":[280,5],\"def_end_pos\":[280,15]},{\"full_name\":\"CategoryTheory.Iso.symm\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Iso.lean\",\"def_pos\":[94,5],\"def_end_pos\":[94,9]},{\"full_name\":\"CategoryTheory.isoWhiskerRight\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Whiskering.lean\",\"def_pos\":[191,5],\"def_end_pos\":[191,20]},{\"full_name\":\"CategoryTheory.isoWhiskerLeft\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Whiskering.lean\",\"def_pos\":[172,5],\"def_end_pos\":[172,19]},{\"full_name\":\"CategoryTheory.Localization.fac\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Localization\\/Predicate.lean\",\"def_pos\":[318,5],\"def_end_pos\":[318,8]},{\"full_name\":\"CategoryTheory.Functor.associator\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Whiskering.lean\",\"def_pos\":[280,5],\"def_end_pos\":[280,15]},{\"full_name\":\"CategoryTheory.Iso.symm\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Iso.lean\",\"def_pos\":[94,5],\"def_end_pos\":[94,9]},{\"full_name\":\"CategoryTheory.isoWhiskerRight\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Whiskering.lean\",\"def_pos\":[191,5],\"def_end_pos\":[191,20]},{\"full_name\":\"CategoryTheory.Functor.leftUnitor\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Whiskering.lean\",\"def_pos\":[252,5],\"def_end_pos\":[252,15]},{\"full_name\":\"CategoryTheory.Functor.associator\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Whiskering.lean\",\"def_pos\":[280,5],\"def_end_pos\":[280,15]},{\"full_name\":\"CategoryTheory.isoWhiskerLeft\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Whiskering.lean\",\"def_pos\":[172,5],\"def_end_pos\":[172,19]},{\"full_name\":\"CategoryTheory.Localization.Lifting.iso\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Localization\\/Predicate.lean\",\"def_pos\":[297,5],\"def_end_pos\":[297,16]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C\u2081 : Type u_1\nC\u2082 : Type u_2\nD : Type u_3\nD\u2081 : Type u_4\nD\u2082 : Type u_5\ninst\u271d\u2075 : Category.{u_6, u_1} C\u2081\ninst\u271d\u2074 : Category.{u_8, u_2} C\u2082\ninst\u271d\u00b3 : Category.{u_7, u_3} D\ninst\u271d\u00b2 : Category.{?u.10785, u_4} D\u2081\ninst\u271d\u00b9 : Category.{?u.10789, u_5} D\u2082\nL\u2081 : C\u2081 \u2964 D\nW\u2081 : MorphismProperty C\u2081\nL\u2082 : C\u2082 \u2964 D\nW\u2082 : MorphismProperty C\u2082\nE : C\u2081 \u224c C\u2082\nhW\u2081 : W\u2081 \u2264 W\u2082.isoClosure.inverseImage E.functor\nhW\u2082 : W\u2082.IsInvertedBy L\u2082\ninst\u271d : L\u2081.IsLocalization W\u2081\niso : E.functor \u22d9 L\u2082 \u2245 L\u2081\nh : W\u2081.IsInvertedBy (E.functor \u22d9 W\u2082.Q)\n\u22a2 L\u2082.IsLocalization W\u2082",
+              "tactic": "exact\n  { inverts := hW\u2082\n    isEquivalence :=\n      Localization.isEquivalence W\u2082.Q W\u2082 L\u2081 W\u2081 L\u2082 (Construction.lift L\u2082 hW\u2082)\n        (E.functor \u22d9 W\u2082.Q) (Localization.lift (E.functor \u22d9 W\u2082.Q) h L\u2081) (by\n          calc\n            L\u2082 \u22d9 lift (E.functor \u22d9 W\u2082.Q) h L\u2081 \u2245 _ := (leftUnitor _).symm\n            _ \u2245 _ := isoWhiskerRight E.counitIso.symm _\n            _ \u2245 E.inverse \u22d9 E.functor \u22d9 L\u2082 \u22d9 lift (E.functor \u22d9 W\u2082.Q) h L\u2081 :=\n                  Functor.associator _ _ _\n            _ \u2245 E.inverse \u22d9 L\u2081 \u22d9 lift (E.functor \u22d9 W\u2082.Q) h L\u2081 :=\n                  isoWhiskerLeft E.inverse ((Functor.associator _ _ _).symm \u226a\u226b\n                    isoWhiskerRight iso _)\n            _ \u2245 E.inverse \u22d9 E.functor \u22d9 W\u2082.Q :=\n                  isoWhiskerLeft _ (Localization.fac (E.functor \u22d9 W\u2082.Q) h L\u2081)\n            _ \u2245 (E.inverse \u22d9 E.functor) \u22d9 W\u2082.Q := (Functor.associator _ _ _).symm\n            _ \u2245 \ud835\udfed C\u2082 \u22d9 W\u2082.Q := isoWhiskerRight E.counitIso _\n            _ \u2245 W\u2082.Q := leftUnitor _)\n        (Functor.associator _ _ _ \u226a\u226b isoWhiskerLeft _ (Lifting.iso W\u2082.Q W\u2082 _ _)  \u226a\u226b iso) }"
+            },
+            {
+              "annotated_tactic": [
+                "\"obtain \\u27e8_, _, f', hf', \\u27e8e\\u27e9\\u27e9 := hW\\u2081 f hf\"",
+                "[]"
+              ],
+              "state_after": "case intro.intro.intro.intro.intro\nC\u2081 : Type u_1\nC\u2082 : Type u_2\nD : Type u_3\nD\u2081 : Type u_4\nD\u2082 : Type u_5\ninst\u271d\u2075 : Category.{u_6, u_1} C\u2081\ninst\u271d\u2074 : Category.{u_8, u_2} C\u2082\ninst\u271d\u00b3 : Category.{u_7, u_3} D\ninst\u271d\u00b2 : Category.{?u.10785, u_4} D\u2081\ninst\u271d\u00b9 : Category.{?u.10789, u_5} D\u2082\nL\u2081 : C\u2081 \u2964 D\nW\u2081 : MorphismProperty C\u2081\nL\u2082 : C\u2082 \u2964 D\nW\u2082 : MorphismProperty C\u2082\nE : C\u2081 \u224c C\u2082\nhW\u2081 : W\u2081 \u2264 W\u2082.isoClosure.inverseImage E.functor\nhW\u2082 : W\u2082.IsInvertedBy L\u2082\ninst\u271d : L\u2081.IsLocalization W\u2081\niso : E.functor \u22d9 L\u2082 \u2245 L\u2081\nx\u271d\u00b9 x\u271d : C\u2081\nf : x\u271d\u00b9 \u27f6 x\u271d\nhf : W\u2081 f\nw\u271d\u00b9 w\u271d : C\u2082\nf' : w\u271d\u00b9 \u27f6 w\u271d\nhf' : W\u2082 f'\ne : Arrow.mk f' \u2245 Arrow.mk (E.functor.map f)\n\u22a2 IsIso ((E.functor \u22d9 W\u2082.Q).map f)",
+              "state_before": "C\u2081 : Type u_1\nC\u2082 : Type u_2\nD : Type u_3\nD\u2081 : Type u_4\nD\u2082 : Type u_5\ninst\u271d\u2075 : Category.{u_6, u_1} C\u2081\ninst\u271d\u2074 : Category.{u_8, u_2} C\u2082\ninst\u271d\u00b3 : Category.{u_7, u_3} D\ninst\u271d\u00b2 : Category.{?u.10785, u_4} D\u2081\ninst\u271d\u00b9 : Category.{?u.10789, u_5} D\u2082\nL\u2081 : C\u2081 \u2964 D\nW\u2081 : MorphismProperty C\u2081\nL\u2082 : C\u2082 \u2964 D\nW\u2082 : MorphismProperty C\u2082\nE : C\u2081 \u224c C\u2082\nhW\u2081 : W\u2081 \u2264 W\u2082.isoClosure.inverseImage E.functor\nhW\u2082 : W\u2082.IsInvertedBy L\u2082\ninst\u271d : L\u2081.IsLocalization W\u2081\niso : E.functor \u22d9 L\u2082 \u2245 L\u2081\nx\u271d\u00b9 x\u271d : C\u2081\nf : x\u271d\u00b9 \u27f6 x\u271d\nhf : W\u2081 f\n\u22a2 IsIso ((E.functor \u22d9 W\u2082.Q).map f)",
+              "tactic": "obtain \u27e8_, _, f', hf', \u27e8e\u27e9\u27e9 := hW\u2081 f hf"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact ((<a>MorphismProperty.RespectsIso.isomorphisms<\\/a> _).<a>arrow_mk_iso_iff<\\/a>\\n      (W\\u2082.Q.mapArrow.mapIso e)).1 (<a>Localization.inverts<\\/a> W\\u2082.Q W\\u2082 _ hf')\"",
+                "[{\"full_name\":\"CategoryTheory.MorphismProperty.RespectsIso.isomorphisms\",\"def_path\":\"Mathlib\\/CategoryTheory\\/MorphismProperty\\/Basic.lean\",\"def_pos\":[354,9],\"def_end_pos\":[354,33]},{\"full_name\":\"CategoryTheory.MorphismProperty.RespectsIso.arrow_mk_iso_iff\",\"def_path\":\"Mathlib\\/CategoryTheory\\/MorphismProperty\\/Basic.lean\",\"def_pos\":[153,9],\"def_end_pos\":[153,37]},{\"full_name\":\"CategoryTheory.Localization.inverts\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Localization\\/Predicate.lean\",\"def_pos\":[143,9],\"def_end_pos\":[143,16]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case intro.intro.intro.intro.intro\nC\u2081 : Type u_1\nC\u2082 : Type u_2\nD : Type u_3\nD\u2081 : Type u_4\nD\u2082 : Type u_5\ninst\u271d\u2075 : Category.{u_6, u_1} C\u2081\ninst\u271d\u2074 : Category.{u_8, u_2} C\u2082\ninst\u271d\u00b3 : Category.{u_7, u_3} D\ninst\u271d\u00b2 : Category.{?u.10785, u_4} D\u2081\ninst\u271d\u00b9 : Category.{?u.10789, u_5} D\u2082\nL\u2081 : C\u2081 \u2964 D\nW\u2081 : MorphismProperty C\u2081\nL\u2082 : C\u2082 \u2964 D\nW\u2082 : MorphismProperty C\u2082\nE : C\u2081 \u224c C\u2082\nhW\u2081 : W\u2081 \u2264 W\u2082.isoClosure.inverseImage E.functor\nhW\u2082 : W\u2082.IsInvertedBy L\u2082\ninst\u271d : L\u2081.IsLocalization W\u2081\niso : E.functor \u22d9 L\u2082 \u2245 L\u2081\nx\u271d\u00b9 x\u271d : C\u2081\nf : x\u271d\u00b9 \u27f6 x\u271d\nhf : W\u2081 f\nw\u271d\u00b9 w\u271d : C\u2082\nf' : w\u271d\u00b9 \u27f6 w\u271d\nhf' : W\u2082 f'\ne : Arrow.mk f' \u2245 Arrow.mk (E.functor.map f)\n\u22a2 IsIso ((E.functor \u22d9 W\u2082.Q).map f)",
+              "tactic": "exact ((MorphismProperty.RespectsIso.isomorphisms _).arrow_mk_iso_iff\n  (W\u2082.Q.mapArrow.mapIso e)).1 (Localization.inverts W\u2082.Q W\u2082 _ hf')"
+            },
+            {
+              "annotated_tactic": [
+                "\"calc\\n              L\\u2082 \\u22d9 <a>lift<\\/a> (E.functor \\u22d9 W\\u2082.Q) h L\\u2081 \\u2245 _ := (<a>leftUnitor<\\/a> _).<a>symm<\\/a>\\n              _ \\u2245 _ := <a>isoWhiskerRight<\\/a> E.counitIso.symm _\\n              _ \\u2245 E.inverse \\u22d9 E.functor \\u22d9 L\\u2082 \\u22d9 <a>lift<\\/a> (E.functor \\u22d9 W\\u2082.Q) h L\\u2081 :=\\n                    <a>Functor.associator<\\/a> _ _ _\\n              _ \\u2245 E.inverse \\u22d9 L\\u2081 \\u22d9 <a>lift<\\/a> (E.functor \\u22d9 W\\u2082.Q) h L\\u2081 :=\\n                    <a>isoWhiskerLeft<\\/a> E.inverse ((<a>Functor.associator<\\/a> _ _ _).<a>symm<\\/a> \\u226a\\u226b\\n                      <a>isoWhiskerRight<\\/a> iso _)\\n              _ \\u2245 E.inverse \\u22d9 E.functor \\u22d9 W\\u2082.Q :=\\n                    <a>isoWhiskerLeft<\\/a> _ (<a>Localization.fac<\\/a> (E.functor \\u22d9 W\\u2082.Q) h L\\u2081)\\n              _ \\u2245 (E.inverse \\u22d9 E.functor) \\u22d9 W\\u2082.Q := (<a>Functor.associator<\\/a> _ _ _).<a>symm<\\/a>\\n              _ \\u2245 \\ud835\\udfed C\\u2082 \\u22d9 W\\u2082.Q := <a>isoWhiskerRight<\\/a> E.counitIso _\\n              _ \\u2245 W\\u2082.Q := <a>leftUnitor<\\/a> _\"",
+                "[{\"full_name\":\"CategoryTheory.Localization.lift\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Localization\\/Predicate.lean\",\"def_pos\":[306,5],\"def_end_pos\":[306,9]},{\"full_name\":\"CategoryTheory.Functor.leftUnitor\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Whiskering.lean\",\"def_pos\":[252,5],\"def_end_pos\":[252,15]},{\"full_name\":\"CategoryTheory.Iso.symm\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Iso.lean\",\"def_pos\":[94,5],\"def_end_pos\":[94,9]},{\"full_name\":\"CategoryTheory.isoWhiskerRight\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Whiskering.lean\",\"def_pos\":[191,5],\"def_end_pos\":[191,20]},{\"full_name\":\"CategoryTheory.Localization.lift\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Localization\\/Predicate.lean\",\"def_pos\":[306,5],\"def_end_pos\":[306,9]},{\"full_name\":\"CategoryTheory.Functor.associator\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Whiskering.lean\",\"def_pos\":[280,5],\"def_end_pos\":[280,15]},{\"full_name\":\"CategoryTheory.Localization.lift\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Localization\\/Predicate.lean\",\"def_pos\":[306,5],\"def_end_pos\":[306,9]},{\"full_name\":\"CategoryTheory.isoWhiskerLeft\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Whiskering.lean\",\"def_pos\":[172,5],\"def_end_pos\":[172,19]},{\"full_name\":\"CategoryTheory.Functor.associator\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Whiskering.lean\",\"def_pos\":[280,5],\"def_end_pos\":[280,15]},{\"full_name\":\"CategoryTheory.Iso.symm\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Iso.lean\",\"def_pos\":[94,5],\"def_end_pos\":[94,9]},{\"full_name\":\"CategoryTheory.isoWhiskerRight\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Whiskering.lean\",\"def_pos\":[191,5],\"def_end_pos\":[191,20]},{\"full_name\":\"CategoryTheory.isoWhiskerLeft\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Whiskering.lean\",\"def_pos\":[172,5],\"def_end_pos\":[172,19]},{\"full_name\":\"CategoryTheory.Localization.fac\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Localization\\/Predicate.lean\",\"def_pos\":[318,5],\"def_end_pos\":[318,8]},{\"full_name\":\"CategoryTheory.Functor.associator\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Whiskering.lean\",\"def_pos\":[280,5],\"def_end_pos\":[280,15]},{\"full_name\":\"CategoryTheory.Iso.symm\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Iso.lean\",\"def_pos\":[94,5],\"def_end_pos\":[94,9]},{\"full_name\":\"CategoryTheory.isoWhiskerRight\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Whiskering.lean\",\"def_pos\":[191,5],\"def_end_pos\":[191,20]},{\"full_name\":\"CategoryTheory.Functor.leftUnitor\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Whiskering.lean\",\"def_pos\":[252,5],\"def_end_pos\":[252,15]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C\u2081 : Type u_1\nC\u2082 : Type u_2\nD : Type u_3\nD\u2081 : Type u_4\nD\u2082 : Type u_5\ninst\u271d\u2075 : Category.{u_6, u_1} C\u2081\ninst\u271d\u2074 : Category.{u_8, u_2} C\u2082\ninst\u271d\u00b3 : Category.{u_7, u_3} D\ninst\u271d\u00b2 : Category.{?u.10785, u_4} D\u2081\ninst\u271d\u00b9 : Category.{?u.10789, u_5} D\u2082\nL\u2081 : C\u2081 \u2964 D\nW\u2081 : MorphismProperty C\u2081\nL\u2082 : C\u2082 \u2964 D\nW\u2082 : MorphismProperty C\u2082\nE : C\u2081 \u224c C\u2082\nhW\u2081 : W\u2081 \u2264 W\u2082.isoClosure.inverseImage E.functor\nhW\u2082 : W\u2082.IsInvertedBy L\u2082\ninst\u271d : L\u2081.IsLocalization W\u2081\niso : E.functor \u22d9 L\u2082 \u2245 L\u2081\nh : W\u2081.IsInvertedBy (E.functor \u22d9 W\u2082.Q)\n\u22a2 L\u2082 \u22d9 lift (E.functor \u22d9 W\u2082.Q) h L\u2081 \u2245 W\u2082.Q",
+              "tactic": "calc\n  L\u2082 \u22d9 lift (E.functor \u22d9 W\u2082.Q) h L\u2081 \u2245 _ := (leftUnitor _).symm\n  _ \u2245 _ := isoWhiskerRight E.counitIso.symm _\n  _ \u2245 E.inverse \u22d9 E.functor \u22d9 L\u2082 \u22d9 lift (E.functor \u22d9 W\u2082.Q) h L\u2081 :=\n        Functor.associator _ _ _\n  _ \u2245 E.inverse \u22d9 L\u2081 \u22d9 lift (E.functor \u22d9 W\u2082.Q) h L\u2081 :=\n        isoWhiskerLeft E.inverse ((Functor.associator _ _ _).symm \u226a\u226b\n          isoWhiskerRight iso _)\n  _ \u2245 E.inverse \u22d9 E.functor \u22d9 W\u2082.Q :=\n        isoWhiskerLeft _ (Localization.fac (E.functor \u22d9 W\u2082.Q) h L\u2081)\n  _ \u2245 (E.inverse \u22d9 E.functor) \u22d9 W\u2082.Q := (Functor.associator _ _ _).symm\n  _ \u2245 \ud835\udfed C\u2082 \u22d9 W\u2082.Q := isoWhiskerRight E.counitIso _\n  _ \u2245 W\u2082.Q := leftUnitor _"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Localization/Equivalence.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Localization.isEquivalence",
+        "id": "CategoryTheory.Localization.isEquivalence",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            56,
+            64
+          ],
+          "file_path": "Mathlib/CategoryTheory/Localization/Equivalence.lean",
+          "full_name": "CategoryTheory.Localization.isEquivalence",
+          "start": [
+            54,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Localization/Equivalence.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Localization.HasProductsOfShapeAux.inverts",
+        "id": "CategoryTheory.Localization.HasProductsOfShapeAux.inverts",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            40,
+            63
+          ],
+          "file_path": "Mathlib/CategoryTheory/Localization/FiniteProducts.lean",
+          "full_name": "CategoryTheory.Localization.HasProductsOfShapeAux.inverts",
+          "start": [
+            38,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Localization/FiniteProducts.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Localization.hasFiniteProducts",
+        "id": "CategoryTheory.Localization.hasFiniteProducts",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            107,
+            71
+          ],
+          "file_path": "Mathlib/CategoryTheory/Localization/FiniteProducts.lean",
+          "full_name": "CategoryTheory.Localization.hasFiniteProducts",
+          "start": [
+            105,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Localization/FiniteProducts.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Localization.hasProductsOfShape",
+        "id": "CategoryTheory.Localization.hasProductsOfShape",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            92,
+            51
+          ],
+          "file_path": "Mathlib/CategoryTheory/Localization/FiniteProducts.lean",
+          "full_name": "CategoryTheory.Localization.hasProductsOfShape",
+          "start": [
+            88,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Localization/FiniteProducts.lean"
+      }
+    ],
+    "input_proofs": 8,
+    "input_units": 2,
+    "proofs": 3,
+    "published_proofs": 3,
+    "published_transitions": 8,
+    "replay_failures": [],
+    "transitions": 8,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/mathlib-000719-0000-2181f6bd1a70ae0c.parquet",
+      "sha256": "2181f6bd1a70ae0c425c5359dd53ae09cc7f4ae58b719a615df3b75226f06be4",
+      "bytes": 87522,
+      "rows": 8,
+      "revision": "22515991803e73ecc3c0bc878466a6d683e86be7"
+    }
+  ],
+  "proof_ids": [
+    "mathlib:CategoryTheory.Functor.IsLocalization.of_equivalences",
+    "mathlib:CategoryTheory.Localization.HasProductsOfShapeAux.adj_counit_app",
+    "mathlib:CategoryTheory.Localization.equivalence_counitIso_app"
+  ],
+  "proof_keys": [
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Localization/Equivalence.lean\",null,null,\"CategoryTheory.Functor.IsLocalization.of_equivalences\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Localization/Equivalence.lean\",null,null,\"CategoryTheory.Localization.equivalence_counitIso_app\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Localization/FiniteProducts.lean\",null,null,\"CategoryTheory.Localization.HasProductsOfShapeAux.adj_counit_app\"]"
+  ]
+}

manifests/batches/numina/001469.json

@@ -0,0 +1,51 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "numina/001469",
+  "batch_fingerprint": "cfe2e71a217ba00dc7b43c08a430eb78876df17a12dd41f569a090f79561c765",
+  "evidence": {
+    "batch_fingerprint": "cfe2e71a217ba00dc7b43c08a430eb78876df17a12dd41f569a090f79561c765",
+    "contamination_matches": [],
+    "failures": [],
+    "input_proofs": 5,
+    "input_units": 5,
+    "proofs": 5,
+    "published_proofs": 5,
+    "published_transitions": 43,
+    "replay_failures": [],
+    "trace_mode": "bundle",
+    "transitions": 43,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/numina-001469-0000-64b1090b4ee0c7a9.parquet",
+      "sha256": "64b1090b4ee0c7a917444016888ab5e243b4f0f7ec27540d31e12075f95ca657",
+      "bytes": 594003,
+      "rows": 42,
+      "revision": "22515991803e73ecc3c0bc878466a6d683e86be7"
+    },
+    {
+      "path": "data/train/numina-001469-0001-22d162f4eaf4683a.parquet",
+      "sha256": "22d162f4eaf4683a36401b88af88b70dca126f7714d03ee44c77fa892136713f",
+      "bytes": 40460,
+      "rows": 1,
+      "revision": "22515991803e73ecc3c0bc878466a6d683e86be7"
+    }
+  ],
+  "proof_ids": [
+    "numina:669a1192-881f-55f9-911b-791438beb743",
+    "numina:66fa1fc5-0689-515c-9ee8-fa69c080b3f8",
+    "numina:7fb462b1-14d8-52a1-9a7c-e763202e321d",
+    "numina:c6bd3484-aed7-55b9-a446-ee4b6fbd6ff6",
+    "numina:ebc1acfa-b6af-5d13-a8e9-088d0942299b"
+  ],
+  "proof_keys": [
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007345.lean\",\"fb69ac8043c801f1d0a2e7a7e96c80663adeda14d956986720ce9daa56e8dc9a\",0,\"algebra_6052\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007346.lean\",\"584d59b8061d8e9a6ce276a85a9fea47cd8f8b4687c1ec0a760020258e7254cf\",0,\"algebra_15931\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007347.lean\",\"4b4070b79212aa577221c34cafb3903e4a89f6a092265a9a8351671609cc61b3\",0,\"algebra_604793\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007348.lean\",\"1491ddd725b4d62da81dff1ab60066e5f26604304349401edf742c4a6c89aaaf\",0,\"algebra_190349\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007349.lean\",\"ffb12bb848ce032ba2e3a1dfa552ffa8195a52616295707855c86e454c772c95\",0,\"inequalities_145332\"]"
+  ]
+}

manifests/batches/numina/001470.json

@@ -0,0 +1,44 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "numina/001470",
+  "batch_fingerprint": "6287390398cd2e0d01338a7f1153a65aa64a008c7a37a5b47b562972c6f25cf6",
+  "evidence": {
+    "batch_fingerprint": "6287390398cd2e0d01338a7f1153a65aa64a008c7a37a5b47b562972c6f25cf6",
+    "contamination_matches": [],
+    "failures": [],
+    "input_proofs": 5,
+    "input_units": 5,
+    "proofs": 5,
+    "published_proofs": 5,
+    "published_transitions": 68,
+    "replay_failures": [],
+    "trace_mode": "bundle",
+    "transitions": 68,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/numina-001470-0000-0600adafabe41acf.parquet",
+      "sha256": "0600adafabe41acfa4f51bdf47f7744e6a67d268882a4b8e1d48b29ef4422b8e",
+      "bytes": 496155,
+      "rows": 68,
+      "revision": "22515991803e73ecc3c0bc878466a6d683e86be7"
+    }
+  ],
+  "proof_ids": [
+    "numina:06ec654b-d746-5a4f-82f2-63a7466b6c97",
+    "numina:43cbe160-f5c0-527c-a779-a8d0dc77c50d",
+    "numina:7948db81-333d-560c-8ec4-5ca012c87b2f",
+    "numina:c6689f42-0a1f-52fe-b2ee-fd4396a3a463",
+    "numina:fdbb3b54-1a23-5c54-bb4a-d81042a1412d"
+  ],
+  "proof_keys": [
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007350.lean\",\"2f1e886318a4355de273ca1d8b051f4e10d231fcccf8d2a7d232132eb68a6d36\",0,\"algebra_9178\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007351.lean\",\"c784de69e6bad021bbea5401ade21c02cd1f817b40ed117944c85b46d1b210b3\",0,\"algebra_21695\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007352.lean\",\"5317440d6219612ffc39bd54c4afe209e8181dce6a07821d3ab9451ed55a0a32\",0,\"number_theory_97765\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007353.lean\",\"9789253093697f6158f63767cd5e9957d65959cec7bdb2ca9f810c6322bee00d\",0,\"algebra_607887\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007354.lean\",\"4c840abd82025cab4a78d424ba855877ef2234c15bd3027a03ce9b0581baa2ca\",0,\"algebra_166490\"]"
+  ]
+}

manifests/batches/numina/001471.json

@@ -0,0 +1,44 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "numina/001471",
+  "batch_fingerprint": "9a091e026878d81912809ed4ce40862e8cc6fb467ddb425502ea192d45dff104",
+  "evidence": {
+    "batch_fingerprint": "9a091e026878d81912809ed4ce40862e8cc6fb467ddb425502ea192d45dff104",
+    "contamination_matches": [],
+    "failures": [],
+    "input_proofs": 5,
+    "input_units": 5,
+    "proofs": 5,
+    "published_proofs": 5,
+    "published_transitions": 31,
+    "replay_failures": [],
+    "trace_mode": "bundle",
+    "transitions": 31,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/numina-001471-0000-e3ecb61016d7e488.parquet",
+      "sha256": "e3ecb61016d7e488e8fed4977a9f68bb6f67ed8426740ca6e5523a5b0f528e67",
+      "bytes": 158912,
+      "rows": 31,
+      "revision": "22515991803e73ecc3c0bc878466a6d683e86be7"
+    }
+  ],
+  "proof_ids": [
+    "numina:098afa21-881d-5f05-8a50-bd047f58696b",
+    "numina:6a6d5739-1d46-5a1d-8b94-5012c43085e6",
+    "numina:8316b478-86ae-5839-8dfa-f1e4886fb762",
+    "numina:d3386314-5e74-5bb0-98c3-91192d55a24c",
+    "numina:eb8281ab-886f-5520-a607-a04314795687"
+  ],
+  "proof_keys": [
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007355.lean\",\"36e63ef04334b8218782cc8cdf07d59aca052f03f0d719e35b1574cbe96a9f48\",0,\"algebra_9336\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007356.lean\",\"0ab16060bd58e777bc42ceccc94251265d4b1c7ee42451519cba19b01c0c8d60\",0,\"algebra_19929\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007357.lean\",\"038ca0bd0a42a3263bc7db8b28a8623abc4433bf17c4d48da21e9984bab2ea1c\",0,\"inequalities_607602\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007358.lean\",\"30fc01138c04f237feca60e1de0743894903285d2e7ebc94958e692546dc89a8\",0,\"inequalities_618378\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007359.lean\",\"a7a448289c8889b5777d48fb40254a6ca7bbd158780cbb6fd7d830f97d396035\",0,\"algebra_13164\"]"
+  ]
+}

manifests/batches/numina/001472.json

@@ -0,0 +1,51 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "numina/001472",
+  "batch_fingerprint": "bf57d69dba51b9c95ee5baefcf7328ae1b38c0106c6a373fb8e94acf2e613b2b",
+  "evidence": {
+    "batch_fingerprint": "bf57d69dba51b9c95ee5baefcf7328ae1b38c0106c6a373fb8e94acf2e613b2b",
+    "contamination_matches": [],
+    "failures": [],
+    "input_proofs": 5,
+    "input_units": 5,
+    "proofs": 5,
+    "published_proofs": 5,
+    "published_transitions": 47,
+    "replay_failures": [],
+    "trace_mode": "bundle",
+    "transitions": 47,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/numina-001472-0000-72e5ec7da84577d3.parquet",
+      "sha256": "72e5ec7da84577d35880aaf9666fb5d68c13c1d54d9d368668c1da10e76a1351",
+      "bytes": 193664,
+      "rows": 24,
+      "revision": "22515991803e73ecc3c0bc878466a6d683e86be7"
+    },
+    {
+      "path": "data/internal_test/numina-001472-0000-ef27a0460460a33a.parquet",
+      "sha256": "ef27a0460460a33a191401778d2b5c27259af483c2bd7d6909f946f042b69c5e",
+      "bytes": 198461,
+      "rows": 23,
+      "revision": "22515991803e73ecc3c0bc878466a6d683e86be7"
+    }
+  ],
+  "proof_ids": [
+    "numina:1be83995-a045-509c-bb10-4a58fc239f09",
+    "numina:7099cf8f-4fef-58d4-aff1-186d13ff376c",
+    "numina:820bfdd6-62f3-5721-82c8-91bbb382a7ea",
+    "numina:d00383f7-42fa-57f7-a1f8-dbee8e79702b",
+    "numina:f847ba4a-6230-50d6-b814-5e14ba45d4a6"
+  ],
+  "proof_keys": [
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007360.lean\",\"096dd9da351c9950135fb15af6162c5d7630a7d0ca1cf08363d555dd60fa9ee2\",0,\"algebra_9339\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007361.lean\",\"938887b5242947456d5b781d0421da2fe1067a59d6cc461f63c62f712ad16612\",0,\"algebra_19932\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007362.lean\",\"f49b25c9c50553510e218e5695ef12b952ec7c05f32c169ea4ddffae6ece4a8a\",0,\"algebra_97791\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007363.lean\",\"1ce2377a78df92e737a1a7c9795ee00093a382f598ab89f17b3a9d24ef4f1d84\",0,\"inequalities_607468\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007364.lean\",\"a0c69205e021411fffb779f7ca38ecc52558772092203ea03f4ea4b32331193f\",0,\"algebra_618628\"]"
+  ]
+}

manifests/batches/numina/001474.json

@@ -0,0 +1,44 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "numina/001474",
+  "batch_fingerprint": "ab844af25e680dbf7c88ce818df3956a9b29540ed39fb8f2094706e0526e1ecf",
+  "evidence": {
+    "batch_fingerprint": "ab844af25e680dbf7c88ce818df3956a9b29540ed39fb8f2094706e0526e1ecf",
+    "contamination_matches": [],
+    "failures": [],
+    "input_proofs": 5,
+    "input_units": 5,
+    "proofs": 5,
+    "published_proofs": 5,
+    "published_transitions": 40,
+    "replay_failures": [],
+    "trace_mode": "bundle",
+    "transitions": 40,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/numina-001474-0000-28337bff780dc5e2.parquet",
+      "sha256": "28337bff780dc5e28d437dc0b3d641484bb38fb9d7928e0e10b020a7a20f024c",
+      "bytes": 335629,
+      "rows": 40,
+      "revision": "22515991803e73ecc3c0bc878466a6d683e86be7"
+    }
+  ],
+  "proof_ids": [
+    "numina:2e4d1862-5bf4-5126-b815-00717ea1d108",
+    "numina:3949d68e-ba11-54e4-bf93-4b2193d64564",
+    "numina:849a0a8a-64c4-5ff4-98cf-3cbec13c33b9",
+    "numina:98599489-3165-555e-b749-778e992439fa",
+    "numina:e682d4d3-f44a-5361-9194-1ddb8a213f23"
+  ],
+  "proof_keys": [
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007370.lean\",\"fe49cd473c4bf365dcaa536bef2968d07ecf5e8be154733e6b3a86a542ffd15c\",0,\"algebra_9275\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007371.lean\",\"aac739e4912481127a8048dddb3ce9f155a79c7e1436f8f74d23d705e8d73ed6\",0,\"algebra_21957\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007372.lean\",\"b082bd2d535dad4cfa199155790dbb83baa9f47209d1fbf51bbd034c6d79ebc3\",0,\"algebra_232861\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007373.lean\",\"786adbf0480bf8b771e77261d20eafcb3483aef98ddcefddc08cea5e1c5e4bed\",0,\"algebra_19551\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007374.lean\",\"6432da79e088718e5aa2c7830f0524480f88867edd893457875f420d6d575bba\",0,\"number_theory_97806\"]"
+  ]
+}

manifests/batches/numina/001475.json

@@ -0,0 +1,58 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "numina/001475",
+  "batch_fingerprint": "6f6b65c3b71fbb493f4c7583ada46dfa344c0f28cdffb5e26499478ef12416dd",
+  "evidence": {
+    "batch_fingerprint": "6f6b65c3b71fbb493f4c7583ada46dfa344c0f28cdffb5e26499478ef12416dd",
+    "contamination_matches": [],
+    "failures": [],
+    "input_proofs": 5,
+    "input_units": 5,
+    "proofs": 5,
+    "published_proofs": 5,
+    "published_transitions": 63,
+    "replay_failures": [],
+    "trace_mode": "bundle",
+    "transitions": 63,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/numina-001475-0000-72d8e8d05dabba44.parquet",
+      "sha256": "72d8e8d05dabba44dcefbb0e0fa5fa1a10bd81452431145feb71c5dad7329e4a",
+      "bytes": 312547,
+      "rows": 55,
+      "revision": "22515991803e73ecc3c0bc878466a6d683e86be7"
+    },
+    {
+      "path": "data/dev/numina-001475-0000-b8eeac8e664c3b36.parquet",
+      "sha256": "b8eeac8e664c3b36dbf878134ba58ea89f426469ed70b32474b21b5fd4e29358",
+      "bytes": 93225,
+      "rows": 7,
+      "revision": "22515991803e73ecc3c0bc878466a6d683e86be7"
+    },
+    {
+      "path": "data/internal_test/numina-001475-0000-404a4e86535d9412.parquet",
+      "sha256": "404a4e86535d9412f4b72de09675a40557b38dc202c527fce6d77c5f6bf82322",
+      "bytes": 31168,
+      "rows": 1,
+      "revision": "22515991803e73ecc3c0bc878466a6d683e86be7"
+    }
+  ],
+  "proof_ids": [
+    "numina:0bdfb703-d138-5a06-90c9-36e9a3cfcc9f",
+    "numina:0d17e1c3-cf6e-5204-8297-95f6fd36717d",
+    "numina:1930e249-edf5-548b-b836-3eb252bcccb1",
+    "numina:2a15fe37-7f7c-5799-89b4-10363d622a23",
+    "numina:57c4dba0-f8a4-5215-8668-a3855f0a4443"
+  ],
+  "proof_keys": [
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007375.lean\",\"98147356c46c81b1474a8465c713439fd07fe67d7840042d66f7272492cd7a3a\",0,\"algebra_607470\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007376.lean\",\"3a001bc71685df5a040dc5bf0ae7d86c8f46e041f40e5588eb269fad274fba60\",0,\"algebra_604541\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007377.lean\",\"74ec79d85d145a351559a47f08783b9c29f1bb2c3b17e10923c02155cd968d57\",0,\"algebra_246806\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007378.lean\",\"65984660b40003c86df454ff31a8121e318406cfdf7f7ee45ff27223f10e9f05\",0,\"inequalities_45118\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007379.lean\",\"366d126857f6d352128b4c6d10607368f1bb94ebfab0e88545472d9ccffe3556\",0,\"number_theory_172704\"]"
+  ]
+}

manifests/batches/numina/001476.json

@@ -0,0 +1,51 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "numina/001476",
+  "batch_fingerprint": "c8006e89288677e5d0efc042bdfb869166b1e3effab7f434047be12b52a3d5b3",
+  "evidence": {
+    "batch_fingerprint": "c8006e89288677e5d0efc042bdfb869166b1e3effab7f434047be12b52a3d5b3",
+    "contamination_matches": [],
+    "failures": [],
+    "input_proofs": 5,
+    "input_units": 5,
+    "proofs": 5,
+    "published_proofs": 5,
+    "published_transitions": 40,
+    "replay_failures": [],
+    "trace_mode": "bundle",
+    "transitions": 40,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/numina-001476-0000-f03e4cf279dcec89.parquet",
+      "sha256": "f03e4cf279dcec89d0dea33e03c6bf89e72fa82363534d1db167f40d706e4b1d",
+      "bytes": 296958,
+      "rows": 36,
+      "revision": "22515991803e73ecc3c0bc878466a6d683e86be7"
+    },
+    {
+      "path": "data/dev/numina-001476-0000-082009264860c80f.parquet",
+      "sha256": "082009264860c80fa0c7bb8391e7ac581c91453fb0888b1384e5f7f26c88cc8e",
+      "bytes": 68066,
+      "rows": 4,
+      "revision": "22515991803e73ecc3c0bc878466a6d683e86be7"
+    }
+  ],
+  "proof_ids": [
+    "numina:b042f469-2c60-5d26-865c-fea5bbe9b5e9",
+    "numina:c8f98e90-0f99-5e6f-b7cd-0760da798c18",
+    "numina:e0e159b0-9572-5eca-8833-d4ddfa2a8f8c",
+    "numina:e0f26d7b-0c8a-5dd8-9a37-01d70d721892",
+    "numina:f31c3661-4be4-513e-91f1-a8b319bacbf7"
+  ],
+  "proof_keys": [
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007380.lean\",\"d5f0cdde614e3fb12366da4cc389243a17886bd573aaed26f9cc34f6372c7b5b\",0,\"algebra_9276\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007381.lean\",\"86cfd0422a2db990b8aa7a2dc5faa6477ae3ac1896a1c4c84ba5a1ac8e8c9d4a\",0,\"algebra_21959\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007382.lean\",\"df98d26ac775553b03f690378b40fb4f208754151c79ccf84e927db0cd286eca\",0,\"number_theory_19553\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007383.lean\",\"6fee48b3bbaa68c7eb85172d62e50812e4675e1fd58005505a7b394700e5768f\",0,\"algebra_97810\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007384.lean\",\"c3102446d52ce17ed20ba4e5c586ae973d535d2e595aed6057019e28e13b7865\",0,\"algebra_611164\"]"
+  ]
+}

manifests/batches/numina/001477.json

@@ -0,0 +1,51 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "numina/001477",
+  "batch_fingerprint": "ec5e8b1a0d964f2ac56987c412baf361df75e8bff3ee86fc730ebf8af3127064",
+  "evidence": {
+    "batch_fingerprint": "ec5e8b1a0d964f2ac56987c412baf361df75e8bff3ee86fc730ebf8af3127064",
+    "contamination_matches": [],
+    "failures": [],
+    "input_proofs": 5,
+    "input_units": 5,
+    "proofs": 5,
+    "published_proofs": 5,
+    "published_transitions": 17,
+    "replay_failures": [],
+    "trace_mode": "bundle",
+    "transitions": 17,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/numina-001477-0000-fbfab680e37eda95.parquet",
+      "sha256": "fbfab680e37eda95162b37bd48de9c0517b847fce1d6874e1ae28f9b5a02cd5c",
+      "bytes": 343300,
+      "rows": 14,
+      "revision": "22515991803e73ecc3c0bc878466a6d683e86be7"
+    },
+    {
+      "path": "data/internal_test/numina-001477-0000-08df06c13714872e.parquet",
+      "sha256": "08df06c13714872ebff507ac807dfda43aa9d652f7ea2eb4a4e9e085203ab042",
+      "bytes": 33902,
+      "rows": 3,
+      "revision": "22515991803e73ecc3c0bc878466a6d683e86be7"
+    }
+  ],
+  "proof_ids": [
+    "numina:47fc5e13-f54a-55e4-85b7-af3dd92660a4",
+    "numina:9a445e92-7566-5386-8027-2fe62843df17",
+    "numina:9b88506d-f827-57a8-9e89-f6da2f669f01",
+    "numina:a44b8f64-73d9-5bff-8105-57febfae7bf7",
+    "numina:f0cb5297-4d10-5a52-8440-cecddcc01a72"
+  ],
+  "proof_keys": [
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007385.lean\",\"0c85dc11ae2e242167760d203d783eeaa99caae9a031ce2f44d2d8ae61c6b172\",0,\"algebra_604557\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007386.lean\",\"31e1436fc370dce32e5afb719207598ecae932e9d35523150f22ccd6b1e7500a\",0,\"algebra_251576\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007387.lean\",\"567927bf1251f23279b06cfcf9e671eb305b279c17bc4bfbda77258412dd2f04\",0,\"algebra_134693\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007388.lean\",\"4f3907b88e114fe8af9f66dfbfe75774e3467b2a42698506be22dac6bc512951\",0,\"algebra_9277\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007389.lean\",\"4726c7ad3d8eab273652c656293cbe6a54d04674cd2e14a2d9e453ec4ddb9a3f\",0,\"number_theory_241034\"]"
+  ]
+}

manifests/batches/numina/001478.json

@@ -0,0 +1,44 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "numina/001478",
+  "batch_fingerprint": "7e47ff00fc4934e899daa8ea288f8d340064151504a864b3418d5b347e30ebf6",
+  "evidence": {
+    "batch_fingerprint": "7e47ff00fc4934e899daa8ea288f8d340064151504a864b3418d5b347e30ebf6",
+    "contamination_matches": [],
+    "failures": [],
+    "input_proofs": 5,
+    "input_units": 5,
+    "proofs": 5,
+    "published_proofs": 5,
+    "published_transitions": 52,
+    "replay_failures": [],
+    "trace_mode": "bundle",
+    "transitions": 52,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/numina-001478-0000-43c15349ba062b62.parquet",
+      "sha256": "43c15349ba062b6244a72517f9a565cb658dcd00067c1b327200cb8b043b1525",
+      "bytes": 589896,
+      "rows": 52,
+      "revision": "22515991803e73ecc3c0bc878466a6d683e86be7"
+    }
+  ],
+  "proof_ids": [
+    "numina:162dda01-0d74-5fb3-a4b8-2eb5abc518b4",
+    "numina:180050f6-8bd2-50a0-a9d6-0213b3fe7e49",
+    "numina:83f3671b-1b79-5516-9a0e-a6763f07f3f1",
+    "numina:9a50fe82-d9fe-5cf3-93ff-11d1dcafb209",
+    "numina:a9100fa4-1445-5681-87e3-51ce94782af8"
+  ],
+  "proof_keys": [
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007390.lean\",\"2888c51a1c7a8d84584ba2018e586b0c19a77b5db842a60c573fe6b961744b02\",0,\"algebra_21962\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007391.lean\",\"cfb3d721c848784ef6788931342745b50de5c0c14ade384438d494e1b35ca27c\",0,\"number_theory_97831\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007392.lean\",\"33a3e50ea3234a219cb22a25e795b4f6f629adc135cfffdefe814261440af3cf\",0,\"algebra_607472\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007393.lean\",\"8495d8788b1a30ef8782071c195b5e44764f815a379ad572399a8b197828c574\",0,\"number_theory_611167\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007394.lean\",\"444f8f3d6346326c28c521368384fb32a95acf3b2f141813b542070cf746e519\",0,\"number_theory_251614\"]"
+  ]
+}

manifests/batches/numina/001479.json

@@ -0,0 +1,44 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "numina/001479",
+  "batch_fingerprint": "c9b5277da1d4f28c1b97fdf58bbf27c667c81cc210028afe4283a2019a1df93d",
+  "evidence": {
+    "batch_fingerprint": "c9b5277da1d4f28c1b97fdf58bbf27c667c81cc210028afe4283a2019a1df93d",
+    "contamination_matches": [],
+    "failures": [],
+    "input_proofs": 5,
+    "input_units": 5,
+    "proofs": 5,
+    "published_proofs": 5,
+    "published_transitions": 48,
+    "replay_failures": [],
+    "trace_mode": "bundle",
+    "transitions": 48,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/numina-001479-0000-7cbca8888e2d30ef.parquet",
+      "sha256": "7cbca8888e2d30ef7065150a64084f5b550b82c9df638b16e7340d64b014e55d",
+      "bytes": 283828,
+      "rows": 48,
+      "revision": "22515991803e73ecc3c0bc878466a6d683e86be7"
+    }
+  ],
+  "proof_ids": [
+    "numina:0a110f77-9283-5fff-96a0-d80a4a5d4d21",
+    "numina:1744b787-010a-57a2-a6d9-8443cb5ab6bb",
+    "numina:636a73be-0d06-5518-bbc7-0256d92bba9e",
+    "numina:902e2a57-73a8-5021-995c-1e11af9b5a57",
+    "numina:ce9aff5a-6716-586e-9017-f6697dacd46a"
+  ],
+  "proof_keys": [
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007395.lean\",\"51a79a7d87ffef302215ddfe094260f53321fbb4a722bd82ad27b9f57c4df5b1\",0,\"inequalities_29447\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007396.lean\",\"e5f8fa1cf96a6c7cf193dc61e76cf3d15d120a5f4c03efb10450a5ed6faef18e\",0,\"algebra_182922\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007397.lean\",\"6dab5fd83e7c1763c6405637a3a6e8f12572282c76355091c7de1778d6588620\",0,\"algebra_9168\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007398.lean\",\"9f8558e7078d193db17f6dd48207bdf0ed45582b456a16344f69d3789e07c45b\",0,\"number_theory_287259\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007399.lean\",\"b324c667b591b1ff44cb274ff5e5a493112067240214600124301e91e02e182a\",0,\"number_theory_607363\"]"
+  ]
+}