Record 17 verified HPC batch manifests

manifests/batches/mathlib/000635.json

@@ -0,0 +1,1080 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "mathlib/000635",
+  "batch_fingerprint": "3dd30f8e0cc13b8d46284de12e74ee2dca3a567277093e1950951a33c7b3723b",
+  "evidence": {
+    "batch_fingerprint": "3dd30f8e0cc13b8d46284de12e74ee2dca3a567277093e1950951a33c7b3723b",
+    "contamination_matches": [],
+    "failures": [
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.CategoryOfElements.comp_val",
+        "id": "CategoryTheory.CategoryOfElements.comp_val",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            78,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Elements.lean",
+          "full_name": "CategoryTheory.CategoryOfElements.comp_val",
+          "start": [
+            76,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Elements.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.CategoryOfElements.ext",
+        "id": "CategoryTheory.CategoryOfElements.ext",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            72,
+            20
+          ],
+          "file_path": "Mathlib/CategoryTheory/Elements.lean",
+          "full_name": "CategoryTheory.CategoryOfElements.ext",
+          "start": [
+            71,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Elements.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.CategoryOfElements.fromCostructuredArrow_obj_mk",
+        "id": "CategoryTheory.CategoryOfElements.fromCostructuredArrow_obj_mk",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            225,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Elements.lean",
+          "full_name": "CategoryTheory.CategoryOfElements.fromCostructuredArrow_obj_mk",
+          "start": [
+            223,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Elements.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.CategoryOfElements.fromStructuredArrow_map",
+        "id": "CategoryTheory.CategoryOfElements.fromStructuredArrow_map",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            175,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Elements.lean",
+          "full_name": "CategoryTheory.CategoryOfElements.fromStructuredArrow_map",
+          "start": [
+            173,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Elements.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.CategoryOfElements.fromStructuredArrow_obj",
+        "id": "CategoryTheory.CategoryOfElements.fromStructuredArrow_obj",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            169,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Elements.lean",
+          "full_name": "CategoryTheory.CategoryOfElements.fromStructuredArrow_obj",
+          "start": [
+            168,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Elements.lean"
+      },
+      {
+        "error": "no internal trace for tactic 'simp [yonedaEquiv]'",
+        "full_name": "CategoryTheory.CategoryOfElements.from_toCostructuredArrow_eq",
+        "id": "CategoryTheory.CategoryOfElements.from_toCostructuredArrow_eq",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            240,
+            16
+          ],
+          "file_path": "Mathlib/CategoryTheory/Elements.lean",
+          "full_name": "CategoryTheory.CategoryOfElements.from_toCostructuredArrow_eq",
+          "start": [
+            229,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"refine <a>Functor.ext<\\/a> ?_ ?_\"",
+                "[{\"full_name\":\"CategoryTheory.Functor.ext\",\"def_path\":\"Mathlib\\/CategoryTheory\\/EqToHom.lean\",\"def_pos\":[200,9],\"def_end_pos\":[200,12]}]"
+              ],
+              "state_after": "case refine_1\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\n\u22a2 \u2200 (X : F.Elements), ((toCostructuredArrow F).rightOp \u22d9 fromCostructuredArrow F).obj X = (\ud835\udfed F.Elements).obj X\n\ncase refine_2\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\n\u22a2 \u2200 (X Y : F.Elements) (f : X \u27f6 Y),\n    ((toCostructuredArrow F).rightOp \u22d9 fromCostructuredArrow F).map f = eqToHom \u22ef \u226b (\ud835\udfed F.Elements).map f \u226b eqToHom \u22ef",
+              "state_before": "C : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\n\u22a2 (toCostructuredArrow F).rightOp \u22d9 fromCostructuredArrow F = \ud835\udfed F.Elements",
+              "tactic": "refine Functor.ext ?_ ?_"
+            },
+            {
+              "annotated_tactic": [
+                "\"intro X\"",
+                "[]"
+              ],
+              "state_after": "case refine_1\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX : F.Elements\n\u22a2 ((toCostructuredArrow F).rightOp \u22d9 fromCostructuredArrow F).obj X = (\ud835\udfed F.Elements).obj X",
+              "state_before": "case refine_1\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\n\u22a2 \u2200 (X : F.Elements), ((toCostructuredArrow F).rightOp \u22d9 fromCostructuredArrow F).obj X = (\ud835\udfed F.Elements).obj X",
+              "tactic": "intro X"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact <a>Functor.Elements.ext<\\/a> _ _ <a>rfl<\\/a> (by simp [<a>yonedaEquiv<\\/a>])\"",
+                "[{\"full_name\":\"CategoryTheory.Functor.Elements.ext\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Elements.lean\",\"def_pos\":[51,7],\"def_end_pos\":[51,27]},{\"full_name\":\"rfl\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[294,22],\"def_end_pos\":[294,25]},{\"full_name\":\"CategoryTheory.yonedaEquiv\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Yoneda.lean\",\"def_pos\":[300,5],\"def_end_pos\":[300,16]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case refine_1\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX : F.Elements\n\u22a2 ((toCostructuredArrow F).rightOp \u22d9 fromCostructuredArrow F).obj X = (\ud835\udfed F.Elements).obj X",
+              "tactic": "exact Functor.Elements.ext _ _ rfl (by simp [yonedaEquiv])"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp [<a>yonedaEquiv<\\/a>]\"",
+                "[{\"full_name\":\"CategoryTheory.yonedaEquiv\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Yoneda.lean\",\"def_pos\":[300,5],\"def_end_pos\":[300,16]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX : F.Elements\n\u22a2 F.map (eqToHom \u22ef) (((toCostructuredArrow F).rightOp \u22d9 fromCostructuredArrow F).obj X).snd = ((\ud835\udfed F.Elements).obj X).snd",
+              "tactic": "simp [yonedaEquiv]"
+            },
+            {
+              "annotated_tactic": [
+                "\"intro X Y f\"",
+                "[]"
+              ],
+              "state_after": "case refine_2\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX Y : F.Elements\nf : X \u27f6 Y\n\u22a2 ((toCostructuredArrow F).rightOp \u22d9 fromCostructuredArrow F).map f = eqToHom \u22ef \u226b (\ud835\udfed F.Elements).map f \u226b eqToHom \u22ef",
+              "state_before": "case refine_2\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\n\u22a2 \u2200 (X Y : F.Elements) (f : X \u27f6 Y),\n    ((toCostructuredArrow F).rightOp \u22d9 fromCostructuredArrow F).map f = eqToHom \u22ef \u226b (\ud835\udfed F.Elements).map f \u226b eqToHom \u22ef",
+              "tactic": "intro X Y f"
+            },
+            {
+              "annotated_tactic": [
+                "\"have : \\u2200 {a b : F.Elements} (H : a = b),\\n        (<a>eqToHom<\\/a> H).1 = <a>eqToHom<\\/a> (show a.fst = b.fst by cases H; rfl) := by\\n      rintro _ _ rfl\\n      simp\"",
+                "[{\"full_name\":\"CategoryTheory.eqToHom\",\"def_path\":\"Mathlib\\/CategoryTheory\\/EqToHom.lean\",\"def_pos\":[43,5],\"def_end_pos\":[43,12]},{\"full_name\":\"CategoryTheory.eqToHom\",\"def_path\":\"Mathlib\\/CategoryTheory\\/EqToHom.lean\",\"def_pos\":[43,5],\"def_end_pos\":[43,12]}]"
+              ],
+              "state_after": "case refine_2\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX Y : F.Elements\nf : X \u27f6 Y\nthis : \u2200 {a b : F.Elements} (H : a = b), \u2191(eqToHom H) = eqToHom \u22ef\n\u22a2 ((toCostructuredArrow F).rightOp \u22d9 fromCostructuredArrow F).map f = eqToHom \u22ef \u226b (\ud835\udfed F.Elements).map f \u226b eqToHom \u22ef",
+              "state_before": "case refine_2\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX Y : F.Elements\nf : X \u27f6 Y\n\u22a2 ((toCostructuredArrow F).rightOp \u22d9 fromCostructuredArrow F).map f = eqToHom \u22ef \u226b (\ud835\udfed F.Elements).map f \u226b eqToHom \u22ef",
+              "tactic": "have : \u2200 {a b : F.Elements} (H : a = b),\n    (eqToHom H).1 = eqToHom (show a.fst = b.fst by cases H; rfl) := by\n  rintro _ _ rfl\n  simp"
+            },
+            {
+              "annotated_tactic": [
+                "\"ext\"",
+                "[]"
+              ],
+              "state_after": "case refine_2.w\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX Y : F.Elements\nf : X \u27f6 Y\nthis : \u2200 {a b : F.Elements} (H : a = b), \u2191(eqToHom H) = eqToHom \u22ef\n\u22a2 \u2191(((toCostructuredArrow F).rightOp \u22d9 fromCostructuredArrow F).map f) = \u2191(eqToHom \u22ef \u226b (\ud835\udfed F.Elements).map f \u226b eqToHom \u22ef)",
+              "state_before": "case refine_2\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX Y : F.Elements\nf : X \u27f6 Y\nthis : \u2200 {a b : F.Elements} (H : a = b), \u2191(eqToHom H) = eqToHom \u22ef\n\u22a2 ((toCostructuredArrow F).rightOp \u22d9 fromCostructuredArrow F).map f = eqToHom \u22ef \u226b (\ud835\udfed F.Elements).map f \u226b eqToHom \u22ef",
+              "tactic": "ext"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp [this]\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case refine_2.w\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX Y : F.Elements\nf : X \u27f6 Y\nthis : \u2200 {a b : F.Elements} (H : a = b), \u2191(eqToHom H) = eqToHom \u22ef\n\u22a2 \u2191(((toCostructuredArrow F).rightOp \u22d9 fromCostructuredArrow F).map f) = \u2191(eqToHom \u22ef \u226b (\ud835\udfed F.Elements).map f \u226b eqToHom \u22ef)",
+              "tactic": "simp [this]"
+            },
+            {
+              "annotated_tactic": [
+                "\"cases H\"",
+                "[]"
+              ],
+              "state_after": "case refl\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX Y : F.Elements\nf : X \u27f6 Y\na : F.Elements\n\u22a2 a.fst = a.fst",
+              "state_before": "C : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX Y : F.Elements\nf : X \u27f6 Y\na b : F.Elements\nH : a = b\n\u22a2 a.fst = b.fst",
+              "tactic": "cases H"
+            },
+            {
+              "annotated_tactic": [
+                "\"rfl\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case refl\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX Y : F.Elements\nf : X \u27f6 Y\na : F.Elements\n\u22a2 a.fst = a.fst",
+              "tactic": "rfl"
+            },
+            {
+              "annotated_tactic": [
+                "\"rintro _ _ rfl\"",
+                "[]"
+              ],
+              "state_after": "C : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX Y : F.Elements\nf : X \u27f6 Y\na\u271d : F.Elements\n\u22a2 \u2191(eqToHom \u22ef) = eqToHom \u22ef",
+              "state_before": "C : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX Y : F.Elements\nf : X \u27f6 Y\n\u22a2 \u2200 {a b : F.Elements} (H : a = b), \u2191(eqToHom H) = eqToHom \u22ef",
+              "tactic": "rintro _ _ rfl"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX Y : F.Elements\nf : X \u27f6 Y\na\u271d : F.Elements\n\u22a2 \u2191(eqToHom \u22ef) = eqToHom \u22ef",
+              "tactic": "simp"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Elements.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.CategoryOfElements.id_val",
+        "id": "CategoryTheory.CategoryOfElements.id_val",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            83,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Elements.lean",
+          "full_name": "CategoryTheory.CategoryOfElements.id_val",
+          "start": [
+            82,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Elements.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.CategoryOfElements.map_snd",
+        "id": "CategoryTheory.CategoryOfElements.map_snd",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            88,
+            13
+          ],
+          "file_path": "Mathlib/CategoryTheory/Elements.lean",
+          "full_name": "CategoryTheory.CategoryOfElements.map_snd",
+          "start": [
+            87,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Elements.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.CategoryOfElements.map_\u03c0",
+        "id": "CategoryTheory.CategoryOfElements.map_\u03c0",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            138,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Elements.lean",
+          "full_name": "CategoryTheory.CategoryOfElements.map_\u03c0",
+          "start": [
+            137,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Elements.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.CategoryOfElements.toStructuredArrow_obj",
+        "id": "CategoryTheory.CategoryOfElements.toStructuredArrow_obj",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            153,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Elements.lean",
+          "full_name": "CategoryTheory.CategoryOfElements.toStructuredArrow_obj",
+          "start": [
+            148,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Elements.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.CategoryOfElements.to_comma_map_right",
+        "id": "CategoryTheory.CategoryOfElements.to_comma_map_right",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            158,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Elements.lean",
+          "full_name": "CategoryTheory.CategoryOfElements.to_comma_map_right",
+          "start": [
+            157,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Elements.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Endofunctor.Algebra.Initial.left_inv",
+        "id": "CategoryTheory.Endofunctor.Algebra.Initial.left_inv",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            235,
+            32
+          ],
+          "file_path": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean",
+          "full_name": "CategoryTheory.Endofunctor.Algebra.Initial.left_inv",
+          "start": [
+            234,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Endofunctor.Algebra.Initial.str_isIso",
+        "id": "CategoryTheory.Endofunctor.Algebra.Initial.str_isIso",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            248,
+            49
+          ],
+          "file_path": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean",
+          "full_name": "CategoryTheory.Endofunctor.Algebra.Initial.str_isIso",
+          "start": [
+            247,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Endofunctor.Algebra.comp_eq_comp",
+        "id": "CategoryTheory.Endofunctor.Algebra.comp_eq_comp",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            111,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean",
+          "full_name": "CategoryTheory.Endofunctor.Algebra.comp_eq_comp",
+          "start": [
+            110,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Endofunctor.Algebra.comp_f",
+        "id": "CategoryTheory.Endofunctor.Algebra.comp_f",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            116,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean",
+          "full_name": "CategoryTheory.Endofunctor.Algebra.comp_f",
+          "start": [
+            115,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Endofunctor.Algebra.epi_of_epi",
+        "id": "CategoryTheory.Endofunctor.Algebra.epi_of_epi",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            159,
+            30
+          ],
+          "file_path": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean",
+          "full_name": "CategoryTheory.Endofunctor.Algebra.epi_of_epi",
+          "start": [
+            158,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Endofunctor.Algebra.ext",
+        "id": "CategoryTheory.Endofunctor.Algebra.ext",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            95,
+            16
+          ],
+          "file_path": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean",
+          "full_name": "CategoryTheory.Endofunctor.Algebra.ext",
+          "start": [
+            93,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Endofunctor.Algebra.id_eq_id",
+        "id": "CategoryTheory.Endofunctor.Algebra.id_eq_id",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            99,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean",
+          "full_name": "CategoryTheory.Endofunctor.Algebra.id_eq_id",
+          "start": [
+            98,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Endofunctor.Algebra.id_f",
+        "id": "CategoryTheory.Endofunctor.Algebra.id_f",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            104,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean",
+          "full_name": "CategoryTheory.Endofunctor.Algebra.id_f",
+          "start": [
+            103,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean"
+      },
+      {
+        "error": "no internal trace for tactic 'aesop_cat'",
+        "full_name": "CategoryTheory.Endofunctor.Algebra.iso_of_iso",
+        "id": "CategoryTheory.Endofunctor.Algebra.iso_of_iso",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            148,
+            45
+          ],
+          "file_path": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean",
+          "full_name": "CategoryTheory.Endofunctor.Algebra.iso_of_iso",
+          "start": [
+            144,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"rw [<a>IsIso.eq_comp_inv<\\/a> f.1, <a>Category.assoc<\\/a>, \\u2190 f.h]\"",
+                "[{\"full_name\":\"CategoryTheory.IsIso.eq_comp_inv\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Iso.lean\",\"def_pos\":[456,9],\"def_end_pos\":[456,20]},{\"full_name\":\"CategoryTheory.Category.assoc\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[181,3],\"def_end_pos\":[181,8]}]"
+              ],
+              "state_after": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nF : C \u2964 C\nA A\u2080 A\u2081 A\u2082 : Algebra F\nf\u271d : A\u2080 \u27f6 A\u2081\ng : A\u2081 \u27f6 A\u2082\nf : A\u2080 \u27f6 A\u2081\ninst\u271d : IsIso f.f\n\u22a2 F.map (inv f.f) \u226b F.map f.f \u226b A\u2081.str = A\u2081.str",
+              "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nF : C \u2964 C\nA A\u2080 A\u2081 A\u2082 : Algebra F\nf\u271d : A\u2080 \u27f6 A\u2081\ng : A\u2081 \u27f6 A\u2082\nf : A\u2080 \u27f6 A\u2081\ninst\u271d : IsIso f.f\n\u22a2 F.map (inv f.f) \u226b A\u2080.str = A\u2081.str \u226b inv f.f",
+              "tactic": "rw [IsIso.eq_comp_inv f.1, Category.assoc, \u2190 f.h]"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nF : C \u2964 C\nA A\u2080 A\u2081 A\u2082 : Algebra F\nf\u271d : A\u2080 \u27f6 A\u2081\ng : A\u2081 \u27f6 A\u2082\nf : A\u2080 \u27f6 A\u2081\ninst\u271d : IsIso f.f\n\u22a2 F.map (inv f.f) \u226b F.map f.f \u226b A\u2081.str = A\u2081.str",
+              "tactic": "simp"
+            },
+            {
+              "annotated_tactic": [
+                "\"aesop_cat\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nF : C \u2964 C\nA A\u2080 A\u2081 A\u2082 : Algebra F\nf\u271d : A\u2080 \u27f6 A\u2081\ng : A\u2081 \u27f6 A\u2082\nf : A\u2080 \u27f6 A\u2081\ninst\u271d : IsIso f.f\n\u22a2 f \u226b { f := inv f.f, h := \u22ef } = \ud835\udfd9 A\u2080",
+              "tactic": "aesop_cat"
+            },
+            {
+              "annotated_tactic": [
+                "\"aesop_cat\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nF : C \u2964 C\nA A\u2080 A\u2081 A\u2082 : Algebra F\nf\u271d : A\u2080 \u27f6 A\u2081\ng : A\u2081 \u27f6 A\u2082\nf : A\u2080 \u27f6 A\u2081\ninst\u271d : IsIso f.f\n\u22a2 { f := inv f.f, h := \u22ef } \u226b f = \ud835\udfd9 A\u2081",
+              "tactic": "aesop_cat"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Endofunctor.Algebra.mono_of_mono",
+        "id": "CategoryTheory.Endofunctor.Algebra.mono_of_mono",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            164,
+            32
+          ],
+          "file_path": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean",
+          "full_name": "CategoryTheory.Endofunctor.Algebra.mono_of_mono",
+          "start": [
+            163,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Endofunctor.Coalgebra.comp_eq_comp",
+        "id": "CategoryTheory.Endofunctor.Coalgebra.comp_eq_comp",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            330,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean",
+          "full_name": "CategoryTheory.Endofunctor.Coalgebra.comp_eq_comp",
+          "start": [
+            329,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Endofunctor.Coalgebra.comp_f",
+        "id": "CategoryTheory.Endofunctor.Coalgebra.comp_f",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            335,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean",
+          "full_name": "CategoryTheory.Endofunctor.Coalgebra.comp_f",
+          "start": [
+            334,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Endofunctor.Coalgebra.epi_of_epi",
+        "id": "CategoryTheory.Endofunctor.Coalgebra.epi_of_epi",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            378,
+            30
+          ],
+          "file_path": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean",
+          "full_name": "CategoryTheory.Endofunctor.Coalgebra.epi_of_epi",
+          "start": [
+            377,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Endofunctor.Coalgebra.ext",
+        "id": "CategoryTheory.Endofunctor.Coalgebra.ext",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            314,
+            16
+          ],
+          "file_path": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean",
+          "full_name": "CategoryTheory.Endofunctor.Coalgebra.ext",
+          "start": [
+            312,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Endofunctor.Coalgebra.id_eq_id",
+        "id": "CategoryTheory.Endofunctor.Coalgebra.id_eq_id",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            318,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean",
+          "full_name": "CategoryTheory.Endofunctor.Coalgebra.id_eq_id",
+          "start": [
+            317,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Endofunctor.Coalgebra.id_f",
+        "id": "CategoryTheory.Endofunctor.Coalgebra.id_f",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            323,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean",
+          "full_name": "CategoryTheory.Endofunctor.Coalgebra.id_f",
+          "start": [
+            322,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean"
+      },
+      {
+        "error": "no internal trace for tactic 'aesop_cat'",
+        "full_name": "CategoryTheory.Endofunctor.Coalgebra.iso_of_iso",
+        "id": "CategoryTheory.Endofunctor.Coalgebra.iso_of_iso",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            367,
+            45
+          ],
+          "file_path": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean",
+          "full_name": "CategoryTheory.Endofunctor.Coalgebra.iso_of_iso",
+          "start": [
+            363,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"rw [<a>IsIso.eq_inv_comp<\\/a> f.1, \\u2190 <a>Category.assoc<\\/a>, \\u2190 f.h, <a>Category.assoc<\\/a>]\"",
+                "[{\"full_name\":\"CategoryTheory.IsIso.eq_inv_comp\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Iso.lean\",\"def_pos\":[446,9],\"def_end_pos\":[446,20]},{\"full_name\":\"CategoryTheory.Category.assoc\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[181,3],\"def_end_pos\":[181,8]},{\"full_name\":\"CategoryTheory.Category.assoc\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[181,3],\"def_end_pos\":[181,8]}]"
+              ],
+              "state_after": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nF : C \u2964 C\nV V\u2080 V\u2081 V\u2082 : Coalgebra F\nf\u271d : V\u2080 \u27f6 V\u2081\ng : V\u2081 \u27f6 V\u2082\nf : V\u2080 \u27f6 V\u2081\ninst\u271d : IsIso f.f\n\u22a2 V\u2080.str \u226b F.map f.f \u226b F.map (inv f.f) = V\u2080.str",
+              "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nF : C \u2964 C\nV V\u2080 V\u2081 V\u2082 : Coalgebra F\nf\u271d : V\u2080 \u27f6 V\u2081\ng : V\u2081 \u27f6 V\u2082\nf : V\u2080 \u27f6 V\u2081\ninst\u271d : IsIso f.f\n\u22a2 V\u2081.str \u226b F.map (inv f.f) = inv f.f \u226b V\u2080.str",
+              "tactic": "rw [IsIso.eq_inv_comp f.1, \u2190 Category.assoc, \u2190 f.h, Category.assoc]"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nF : C \u2964 C\nV V\u2080 V\u2081 V\u2082 : Coalgebra F\nf\u271d : V\u2080 \u27f6 V\u2081\ng : V\u2081 \u27f6 V\u2082\nf : V\u2080 \u27f6 V\u2081\ninst\u271d : IsIso f.f\n\u22a2 V\u2080.str \u226b F.map f.f \u226b F.map (inv f.f) = V\u2080.str",
+              "tactic": "simp"
+            },
+            {
+              "annotated_tactic": [
+                "\"aesop_cat\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nF : C \u2964 C\nV V\u2080 V\u2081 V\u2082 : Coalgebra F\nf\u271d : V\u2080 \u27f6 V\u2081\ng : V\u2081 \u27f6 V\u2082\nf : V\u2080 \u27f6 V\u2081\ninst\u271d : IsIso f.f\n\u22a2 f \u226b { f := inv f.f, h := \u22ef } = \ud835\udfd9 V\u2080",
+              "tactic": "aesop_cat"
+            },
+            {
+              "annotated_tactic": [
+                "\"aesop_cat\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\nF : C \u2964 C\nV V\u2080 V\u2081 V\u2082 : Coalgebra F\nf\u271d : V\u2080 \u27f6 V\u2081\ng : V\u2081 \u27f6 V\u2082\nf : V\u2080 \u27f6 V\u2081\ninst\u271d : IsIso f.f\n\u22a2 { f := inv f.f, h := \u22ef } \u226b f = \ud835\udfd9 V\u2081",
+              "tactic": "aesop_cat"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Endofunctor.Coalgebra.mono_of_mono",
+        "id": "CategoryTheory.Endofunctor.Coalgebra.mono_of_mono",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            383,
+            32
+          ],
+          "file_path": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean",
+          "full_name": "CategoryTheory.Endofunctor.Coalgebra.mono_of_mono",
+          "start": [
+            382,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Endofunctor/Algebra.lean"
+      }
+    ],
+    "input_proofs": 36,
+    "input_units": 2,
+    "proofs": 7,
+    "published_proofs": 5,
+    "published_transitions": 11,
+    "replay_failures": [],
+    "transitions": 28,
+    "validation_failures": [
+      {
+        "errors": [
+          "internal transition boundary mismatch",
+          "internal transition boundary mismatch"
+        ],
+        "file_path": "Mathlib/CategoryTheory/Elements.lean",
+        "proof_id": "mathlib:CategoryTheory.CategoryOfElements.costructuredArrow_yoneda_equivalence_naturality",
+        "provenance": {
+          "selection": {
+            "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+            "end": [
+              283,
+              21
+            ],
+            "file_path": "Mathlib/CategoryTheory/Elements.lean",
+            "full_name": "CategoryTheory.CategoryOfElements.costructuredArrow_yoneda_equivalence_naturality",
+            "start": [
+              274,
+              1
+            ],
+            "traced_tactics": [
+              {
+                "annotated_tactic": [
+                  "\"fapply <a>Functor.ext<\\/a>\"",
+                  "[{\"full_name\":\"CategoryTheory.Functor.ext\",\"def_path\":\"Mathlib\\/CategoryTheory\\/EqToHom.lean\",\"def_pos\":[200,9],\"def_end_pos\":[200,12]}]"
+                ],
+                "state_after": "case h_obj\nC : Type u\ninst\u271d : Category.{v, u} C\nF : C \u2964 Type w\nF\u2081 F\u2082 : C\u1d52\u1d56 \u2964 Type v\n\u03b1 : F\u2081 \u27f6 F\u2082\n\u22a2 \u2200 (X : F\u2081.Elements\u1d52\u1d56),\n    ((map \u03b1).op \u22d9 toCostructuredArrow F\u2082).obj X = (toCostructuredArrow F\u2081 \u22d9 CostructuredArrow.map \u03b1).obj X\n\ncase h_map\nC : Type u\ninst\u271d : Category.{v, u} C\nF : C \u2964 Type w\nF\u2081 F\u2082 : C\u1d52\u1d56 \u2964 Type v\n\u03b1 : F\u2081 \u27f6 F\u2082\n\u22a2 autoParam\n    (\u2200 (X Y : F\u2081.Elements\u1d52\u1d56) (f : X \u27f6 Y),\n      ((map \u03b1).op \u22d9 toCostructuredArrow F\u2082).map f =\n        eqToHom \u22ef \u226b (toCostructuredArrow F\u2081 \u22d9 CostructuredArrow.map \u03b1).map f \u226b eqToHom \u22ef)\n    _auto\u271d",
+                "state_before": "C : Type u\ninst\u271d : Category.{v, u} C\nF : C \u2964 Type w\nF\u2081 F\u2082 : C\u1d52\u1d56 \u2964 Type v\n\u03b1 : F\u2081 \u27f6 F\u2082\n\u22a2 (map \u03b1).op \u22d9 toCostructuredArrow F\u2082 = toCostructuredArrow F\u2081 \u22d9 CostructuredArrow.map \u03b1",
+                "tactic": "fapply Functor.ext"
+              },
+              {
+                "annotated_tactic": [
+                  "\"intro X\"",
+                  "[]"
+                ],
+                "state_after": "case h_obj\nC : Type u\ninst\u271d : Category.{v, u} C\nF : C \u2964 Type w\nF\u2081 F\u2082 : C\u1d52\u1d56 \u2964 Type v\n\u03b1 : F\u2081 \u27f6 F\u2082\nX : F\u2081.Elements\u1d52\u1d56\n\u22a2 ((map \u03b1).op \u22d9 toCostructuredArrow F\u2082).obj X = (toCostructuredArrow F\u2081 \u22d9 CostructuredArrow.map \u03b1).obj X",
+                "state_before": "case h_obj\nC : Type u\ninst\u271d : Category.{v, u} C\nF : C \u2964 Type w\nF\u2081 F\u2082 : C\u1d52\u1d56 \u2964 Type v\n\u03b1 : F\u2081 \u27f6 F\u2082\n\u22a2 \u2200 (X : F\u2081.Elements\u1d52\u1d56),\n    ((map \u03b1).op \u22d9 toCostructuredArrow F\u2082).obj X = (toCostructuredArrow F\u2081 \u22d9 CostructuredArrow.map \u03b1).obj X",
+                "tactic": "intro X"
+              },
+              {
+                "annotated_tactic": [
+                  "\"simp only [<a>CostructuredArrow.map_mk<\\/a>, <a>toCostructuredArrow_obj<\\/a>, <a>Functor.op_obj<\\/a>,\\n      <a>Functor.comp_obj<\\/a>]\"",
+                  "[{\"full_name\":\"CategoryTheory.CostructuredArrow.map_mk\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Comma\\/StructuredArrow.lean\",\"def_pos\":[618,9],\"def_end_pos\":[618,15]},{\"full_name\":\"CategoryTheory.CategoryOfElements.toCostructuredArrow_obj\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Elements.lean\",\"def_pos\":[193,3],\"def_end_pos\":[193,8]},{\"full_name\":\"CategoryTheory.Functor.op_obj\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Opposites.lean\",\"def_pos\":[181,3],\"def_end_pos\":[181,8]},{\"full_name\":\"CategoryTheory.Functor.comp_obj\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Functor\\/Basic.lean\",\"def_pos\":[110,9],\"def_end_pos\":[110,12]}]"
+                ],
+                "state_after": "case h_obj\nC : Type u\ninst\u271d : Category.{v, u} C\nF : C \u2964 Type w\nF\u2081 F\u2082 : C\u1d52\u1d56 \u2964 Type v\n\u03b1 : F\u2081 \u27f6 F\u2082\nX : F\u2081.Elements\u1d52\u1d56\n\u22a2 CostructuredArrow.mk (yonedaEquiv.symm ((map \u03b1).obj X.unop).snd) =\n    CostructuredArrow.mk (yonedaEquiv.symm X.unop.snd \u226b \u03b1)",
+                "state_before": "case h_obj\nC : Type u\ninst\u271d : Category.{v, u} C\nF : C \u2964 Type w\nF\u2081 F\u2082 : C\u1d52\u1d56 \u2964 Type v\n\u03b1 : F\u2081 \u27f6 F\u2082\nX : F\u2081.Elements\u1d52\u1d56\n\u22a2 ((map \u03b1).op \u22d9 toCostructuredArrow F\u2082).obj X = (toCostructuredArrow F\u2081 \u22d9 CostructuredArrow.map \u03b1).obj X",
+                "tactic": "simp only [CostructuredArrow.map_mk, toCostructuredArrow_obj, Functor.op_obj,\n  Functor.comp_obj]"
+              },
+              {
+                "annotated_tactic": [
+                  "\"congr\"",
+                  "[]"
+                ],
+                "state_after": "case h_obj.e_f\nC : Type u\ninst\u271d : Category.{v, u} C\nF : C \u2964 Type w\nF\u2081 F\u2082 : C\u1d52\u1d56 \u2964 Type v\n\u03b1 : F\u2081 \u27f6 F\u2082\nX : F\u2081.Elements\u1d52\u1d56\n\u22a2 yonedaEquiv.symm ((map \u03b1).obj X.unop).snd = yonedaEquiv.symm X.unop.snd \u226b \u03b1",
+                "state_before": "case h_obj\nC : Type u\ninst\u271d : Category.{v, u} C\nF : C \u2964 Type w\nF\u2081 F\u2082 : C\u1d52\u1d56 \u2964 Type v\n\u03b1 : F\u2081 \u27f6 F\u2082\nX : F\u2081.Elements\u1d52\u1d56\n\u22a2 CostructuredArrow.mk (yonedaEquiv.symm ((map \u03b1).obj X.unop).snd) =\n    CostructuredArrow.mk (yonedaEquiv.symm X.unop.snd \u226b \u03b1)",
+                "tactic": "congr"
+              },
+              {
+                "annotated_tactic": [
+                  "\"ext _ f\"",
+                  "[]"
+                ],
+                "state_after": "case h_obj.e_f.w.h.h\nC : Type u\ninst\u271d : Category.{v, u} C\nF : C \u2964 Type w\nF\u2081 F\u2082 : C\u1d52\u1d56 \u2964 Type v\n\u03b1 : F\u2081 \u27f6 F\u2082\nX : F\u2081.Elements\u1d52\u1d56\nx\u271d : C\u1d52\u1d56\nf : (yoneda.obj ((map \u03b1).obj X.unop).1.unop).obj x\u271d\n\u22a2 (yonedaEquiv.symm ((map \u03b1).obj X.unop).snd).app x\u271d f = (yonedaEquiv.symm X.unop.snd \u226b \u03b1).app x\u271d f",
+                "state_before": "case h_obj.e_f\nC : Type u\ninst\u271d : Category.{v, u} C\nF : C \u2964 Type w\nF\u2081 F\u2082 : C\u1d52\u1d56 \u2964 Type v\n\u03b1 : F\u2081 \u27f6 F\u2082\nX : F\u2081.Elements\u1d52\u1d56\n\u22a2 yonedaEquiv.symm ((map \u03b1).obj X.unop).snd = yonedaEquiv.symm X.unop.snd \u226b \u03b1",
+                "tactic": "ext _ f"
+              },
+              {
+                "annotated_tactic": [
+                  "\"simpa using <a>congr_fun<\\/a> (\\u03b1.naturality f.op).<a>symm<\\/a> (<a>unop<\\/a> X).<a>snd<\\/a>\"",
+                  "[{\"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\":\"Opposite.unop\",\"def_path\":\"Mathlib\\/Data\\/Opposite.lean\",\"def_pos\":[39,3],\"def_end_pos\":[39,7]},{\"full_name\":\"Sigma.snd\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Core.lean\",\"def_pos\":[177,3],\"def_end_pos\":[177,6]}]"
+                ],
+                "state_after": "no goals",
+                "state_before": "case h_obj.e_f.w.h.h\nC : Type u\ninst\u271d : Category.{v, u} C\nF : C \u2964 Type w\nF\u2081 F\u2082 : C\u1d52\u1d56 \u2964 Type v\n\u03b1 : F\u2081 \u27f6 F\u2082\nX : F\u2081.Elements\u1d52\u1d56\nx\u271d : C\u1d52\u1d56\nf : (yoneda.obj ((map \u03b1).obj X.unop).1.unop).obj x\u271d\n\u22a2 (yonedaEquiv.symm ((map \u03b1).obj X.unop).snd).app x\u271d f = (yonedaEquiv.symm X.unop.snd \u226b \u03b1).app x\u271d f",
+                "tactic": "simpa using congr_fun (\u03b1.naturality f.op).symm (unop X).snd"
+              },
+              {
+                "annotated_tactic": [
+                  "\"simp [<a>autoParam<\\/a>]\"",
+                  "[{\"full_name\":\"autoParam\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Tactics.lean\",\"def_pos\":[1614,8],\"def_end_pos\":[1614,17]}]"
+                ],
+                "state_after": "no goals",
+                "state_before": "case h_map\nC : Type u\ninst\u271d : Category.{v, u} C\nF : C \u2964 Type w\nF\u2081 F\u2082 : C\u1d52\u1d56 \u2964 Type v\n\u03b1 : F\u2081 \u27f6 F\u2082\n\u22a2 autoParam\n    (\u2200 (X Y : F\u2081.Elements\u1d52\u1d56) (f : X \u27f6 Y),\n      ((map \u03b1).op \u22d9 toCostructuredArrow F\u2082).map f =\n        eqToHom \u22ef \u226b (toCostructuredArrow F\u2081 \u22d9 CostructuredArrow.map \u03b1).map f \u226b eqToHom \u22ef)\n    _auto\u271d",
+                "tactic": "simp [autoParam]"
+              }
+            ],
+            "url": "https://github.com/leanprover-community/mathlib4"
+          }
+        },
+        "theorem_name": "CategoryTheory.CategoryOfElements.costructuredArrow_yoneda_equivalence_naturality"
+      },
+      {
+        "errors": [
+          "internal transition boundary mismatch",
+          "internal transition boundary mismatch"
+        ],
+        "file_path": "Mathlib/CategoryTheory/Elements.lean",
+        "proof_id": "mathlib:CategoryTheory.CategoryOfElements.to_fromCostructuredArrow_eq",
+        "provenance": {
+          "selection": {
+            "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+            "end": [
+              256,
+              10
+            ],
+            "file_path": "Mathlib/CategoryTheory/Elements.lean",
+            "full_name": "CategoryTheory.CategoryOfElements.to_fromCostructuredArrow_eq",
+            "start": [
+              244,
+              1
+            ],
+            "traced_tactics": [
+              {
+                "annotated_tactic": [
+                  "\"refine <a>Functor.ext<\\/a> ?_ ?_\"",
+                  "[{\"full_name\":\"CategoryTheory.Functor.ext\",\"def_path\":\"Mathlib\\/CategoryTheory\\/EqToHom.lean\",\"def_pos\":[200,9],\"def_end_pos\":[200,12]}]"
+                ],
+                "state_after": "case refine_1\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\n\u22a2 \u2200 (X : CostructuredArrow yoneda F),\n    ((fromCostructuredArrow F).rightOp \u22d9 toCostructuredArrow F).obj X = (\ud835\udfed (CostructuredArrow yoneda F)).obj X\n\ncase refine_2\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\n\u22a2 \u2200 (X Y : CostructuredArrow yoneda F) (f : X \u27f6 Y),\n    ((fromCostructuredArrow F).rightOp \u22d9 toCostructuredArrow F).map f =\n      eqToHom \u22ef \u226b (\ud835\udfed (CostructuredArrow yoneda F)).map f \u226b eqToHom \u22ef",
+                "state_before": "C : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\n\u22a2 (fromCostructuredArrow F).rightOp \u22d9 toCostructuredArrow F = \ud835\udfed (CostructuredArrow yoneda F)",
+                "tactic": "refine Functor.ext ?_ ?_"
+              },
+              {
+                "annotated_tactic": [
+                  "\"intro X\"",
+                  "[]"
+                ],
+                "state_after": "case refine_1\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX : CostructuredArrow yoneda F\n\u22a2 ((fromCostructuredArrow F).rightOp \u22d9 toCostructuredArrow F).obj X = (\ud835\udfed (CostructuredArrow yoneda F)).obj X",
+                "state_before": "case refine_1\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\n\u22a2 \u2200 (X : CostructuredArrow yoneda F),\n    ((fromCostructuredArrow F).rightOp \u22d9 toCostructuredArrow F).obj X = (\ud835\udfed (CostructuredArrow yoneda F)).obj X",
+                "tactic": "intro X"
+              },
+              {
+                "annotated_tactic": [
+                  "\"cases' X with X_left X_right X_hom\"",
+                  "[]"
+                ],
+                "state_after": "case refine_1.mk\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX_left : C\nX_right : Discrete PUnit.{1}\nX_hom : yoneda.obj X_left \u27f6 (Functor.fromPUnit F).obj X_right\n\u22a2 ((fromCostructuredArrow F).rightOp \u22d9 toCostructuredArrow F).obj { left := X_left, right := X_right, hom := X_hom } =\n    (\ud835\udfed (CostructuredArrow yoneda F)).obj { left := X_left, right := X_right, hom := X_hom }",
+                "state_before": "case refine_1\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX : CostructuredArrow yoneda F\n\u22a2 ((fromCostructuredArrow F).rightOp \u22d9 toCostructuredArrow F).obj X = (\ud835\udfed (CostructuredArrow yoneda F)).obj X",
+                "tactic": "cases' X with X_left X_right X_hom"
+              },
+              {
+                "annotated_tactic": [
+                  "\"cases X_right\"",
+                  "[]"
+                ],
+                "state_after": "case refine_1.mk.mk\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX_left : C\nas\u271d : PUnit.{1}\nX_hom : yoneda.obj X_left \u27f6 (Functor.fromPUnit F).obj { as := as\u271d }\n\u22a2 ((fromCostructuredArrow F).rightOp \u22d9 toCostructuredArrow F).obj\n      { left := X_left, right := { as := as\u271d }, hom := X_hom } =\n    (\ud835\udfed (CostructuredArrow yoneda F)).obj { left := X_left, right := { as := as\u271d }, hom := X_hom }",
+                "state_before": "case refine_1.mk\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX_left : C\nX_right : Discrete PUnit.{1}\nX_hom : yoneda.obj X_left \u27f6 (Functor.fromPUnit F).obj X_right\n\u22a2 ((fromCostructuredArrow F).rightOp \u22d9 toCostructuredArrow F).obj { left := X_left, right := X_right, hom := X_hom } =\n    (\ud835\udfed (CostructuredArrow yoneda F)).obj { left := X_left, right := X_right, hom := X_hom }",
+                "tactic": "cases X_right"
+              },
+              {
+                "annotated_tactic": [
+                  "\"simp only [<a>Functor.id_obj<\\/a>, <a>Functor.rightOp_obj<\\/a>, <a>toCostructuredArrow_obj<\\/a>, <a>Functor.comp_obj<\\/a>,\\n      <a>CostructuredArrow.mk<\\/a>]\"",
+                  "[{\"full_name\":\"CategoryTheory.Functor.id_obj\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Functor\\/Basic.lean\",\"def_pos\":[94,9],\"def_end_pos\":[94,15]},{\"full_name\":\"CategoryTheory.Functor.rightOp_obj\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Opposites.lean\",\"def_pos\":[247,3],\"def_end_pos\":[247,8]},{\"full_name\":\"CategoryTheory.CategoryOfElements.toCostructuredArrow_obj\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Elements.lean\",\"def_pos\":[193,3],\"def_end_pos\":[193,8]},{\"full_name\":\"CategoryTheory.Functor.comp_obj\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Functor\\/Basic.lean\",\"def_pos\":[110,9],\"def_end_pos\":[110,12]},{\"full_name\":\"CategoryTheory.CostructuredArrow.mk\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Comma\\/StructuredArrow.lean\",\"def_pos\":[446,5],\"def_end_pos\":[446,7]}]"
+                ],
+                "state_after": "case refine_1.mk.mk\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX_left : C\nas\u271d : PUnit.{1}\nX_hom : yoneda.obj X_left \u27f6 (Functor.fromPUnit F).obj { as := as\u271d }\n\u22a2 { left := ((fromCostructuredArrow F).obj { unop := { left := X_left, right := { as := as\u271d }, hom := X_hom } }).1.unop,\n      right := { as := PUnit.unit },\n      hom :=\n        yonedaEquiv.symm\n          ((fromCostructuredArrow F).obj { unop := { left := X_left, right := { as := as\u271d }, hom := X_hom } }).snd } =\n    { left := X_left, right := { as := as\u271d }, hom := X_hom }",
+                "state_before": "case refine_1.mk.mk\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX_left : C\nas\u271d : PUnit.{1}\nX_hom : yoneda.obj X_left \u27f6 (Functor.fromPUnit F).obj { as := as\u271d }\n\u22a2 ((fromCostructuredArrow F).rightOp \u22d9 toCostructuredArrow F).obj\n      { left := X_left, right := { as := as\u271d }, hom := X_hom } =\n    (\ud835\udfed (CostructuredArrow yoneda F)).obj { left := X_left, right := { as := as\u271d }, hom := X_hom }",
+                "tactic": "simp only [Functor.id_obj, Functor.rightOp_obj, toCostructuredArrow_obj, Functor.comp_obj,\n  CostructuredArrow.mk]"
+              },
+              {
+                "annotated_tactic": [
+                  "\"congr\"",
+                  "[]"
+                ],
+                "state_after": "case refine_1.mk.mk.e_hom\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX_left : C\nas\u271d : PUnit.{1}\nX_hom : yoneda.obj X_left \u27f6 (Functor.fromPUnit F).obj { as := as\u271d }\n\u22a2 yonedaEquiv.symm\n      ((fromCostructuredArrow F).obj { unop := { left := X_left, right := { as := as\u271d }, hom := X_hom } }).snd =\n    X_hom",
+                "state_before": "case refine_1.mk.mk\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX_left : C\nas\u271d : PUnit.{1}\nX_hom : yoneda.obj X_left \u27f6 (Functor.fromPUnit F).obj { as := as\u271d }\n\u22a2 { left := ((fromCostructuredArrow F).obj { unop := { left := X_left, right := { as := as\u271d }, hom := X_hom } }).1.unop,\n      right := { as := PUnit.unit },\n      hom :=\n        yonedaEquiv.symm\n          ((fromCostructuredArrow F).obj { unop := { left := X_left, right := { as := as\u271d }, hom := X_hom } }).snd } =\n    { left := X_left, right := { as := as\u271d }, hom := X_hom }",
+                "tactic": "congr"
+              },
+              {
+                "annotated_tactic": [
+                  "\"ext x f\"",
+                  "[]"
+                ],
+                "state_after": "case refine_1.mk.mk.e_hom.w.h.h\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX_left : C\nas\u271d : PUnit.{1}\nX_hom : yoneda.obj X_left \u27f6 (Functor.fromPUnit F).obj { as := as\u271d }\nx : C\u1d52\u1d56\nf :\n  (yoneda.obj\n        ((fromCostructuredArrow F).obj { unop := { left := X_left, right := { as := as\u271d }, hom := X_hom } }).1.unop).obj\n    x\n\u22a2 (yonedaEquiv.symm\n          ((fromCostructuredArrow F).obj { unop := { left := X_left, right := { as := as\u271d }, hom := X_hom } }).snd).app\n      x f =\n    X_hom.app x f",
+                "state_before": "case refine_1.mk.mk.e_hom\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX_left : C\nas\u271d : PUnit.{1}\nX_hom : yoneda.obj X_left \u27f6 (Functor.fromPUnit F).obj { as := as\u271d }\n\u22a2 yonedaEquiv.symm\n      ((fromCostructuredArrow F).obj { unop := { left := X_left, right := { as := as\u271d }, hom := X_hom } }).snd =\n    X_hom",
+                "tactic": "ext x f"
+              },
+              {
+                "annotated_tactic": [
+                  "\"convert <a>congr_fun<\\/a> (X_hom.naturality f.op).<a>symm<\\/a> (\\ud835\\udfd9 X_left)\"",
+                  "[{\"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]}]"
+                ],
+                "state_after": "case h.e'_3.h\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX_left : C\nas\u271d : PUnit.{1}\nX_hom : yoneda.obj X_left \u27f6 (Functor.fromPUnit F).obj { as := as\u271d }\nx : C\u1d52\u1d56\nf :\n  (yoneda.obj\n        ((fromCostructuredArrow F).obj { unop := { left := X_left, right := { as := as\u271d }, hom := X_hom } }).1.unop).obj\n    x\ne_1\u271d : F.obj x = ((Functor.fromPUnit F).obj { as := as\u271d }).obj { unop := x.unop }\n\u22a2 X_hom.app x f = ((yoneda.obj X_left).map (Quiver.Hom.op f) \u226b X_hom.app { unop := x.unop }) (\ud835\udfd9 X_left)",
+                "state_before": "case refine_1.mk.mk.e_hom.w.h.h\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX_left : C\nas\u271d : PUnit.{1}\nX_hom : yoneda.obj X_left \u27f6 (Functor.fromPUnit F).obj { as := as\u271d }\nx : C\u1d52\u1d56\nf :\n  (yoneda.obj\n        ((fromCostructuredArrow F).obj { unop := { left := X_left, right := { as := as\u271d }, hom := X_hom } }).1.unop).obj\n    x\n\u22a2 (yonedaEquiv.symm\n          ((fromCostructuredArrow F).obj { unop := { left := X_left, right := { as := as\u271d }, hom := X_hom } }).snd).app\n      x f =\n    X_hom.app x f",
+                "tactic": "convert congr_fun (X_hom.naturality f.op).symm (\ud835\udfd9 X_left)"
+              },
+              {
+                "annotated_tactic": [
+                  "\"simp\"",
+                  "[]"
+                ],
+                "state_after": "no goals",
+                "state_before": "case h.e'_3.h\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\nX_left : C\nas\u271d : PUnit.{1}\nX_hom : yoneda.obj X_left \u27f6 (Functor.fromPUnit F).obj { as := as\u271d }\nx : C\u1d52\u1d56\nf :\n  (yoneda.obj\n        ((fromCostructuredArrow F).obj { unop := { left := X_left, right := { as := as\u271d }, hom := X_hom } }).1.unop).obj\n    x\ne_1\u271d : F.obj x = ((Functor.fromPUnit F).obj { as := as\u271d }).obj { unop := x.unop }\n\u22a2 X_hom.app x f = ((yoneda.obj X_left).map (Quiver.Hom.op f) \u226b X_hom.app { unop := x.unop }) (\ud835\udfd9 X_left)",
+                "tactic": "simp"
+              },
+              {
+                "annotated_tactic": [
+                  "\"aesop\"",
+                  "[]"
+                ],
+                "state_after": "no goals",
+                "state_before": "case refine_2\nC : Type u\ninst\u271d : Category.{v, u} C\nF\u271d : C \u2964 Type w\nF : C\u1d52\u1d56 \u2964 Type v\n\u22a2 \u2200 (X Y : CostructuredArrow yoneda F) (f : X \u27f6 Y),\n    ((fromCostructuredArrow F).rightOp \u22d9 toCostructuredArrow F).map f =\n      eqToHom \u22ef \u226b (\ud835\udfed (CostructuredArrow yoneda F)).map f \u226b eqToHom \u22ef",
+                "tactic": "aesop"
+              }
+            ],
+            "url": "https://github.com/leanprover-community/mathlib4"
+          }
+        },
+        "theorem_name": "CategoryTheory.CategoryOfElements.to_fromCostructuredArrow_eq"
+      }
+    ],
+    "validation_rejected_proofs": 2,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/mathlib-000635-0000-573d7976988b1bd7.parquet",
+      "sha256": "573d7976988b1bd7965061658ef25cc4b060ce59b336c22e337b85449a2bbb0c",
+      "bytes": 58236,
+      "rows": 6,
+      "revision": "6a3d2d550a5e8f26af70e44381b84ab7563dc62c"
+    },
+    {
+      "path": "data/internal_test/mathlib-000635-0000-d7b19c81571fff56.parquet",
+      "sha256": "d7b19c81571fff56063b481f7e19ef4135b6fb97ded0f46a2529584430988eb9",
+      "bytes": 58509,
+      "rows": 5,
+      "revision": "6a3d2d550a5e8f26af70e44381b84ab7563dc62c"
+    }
+  ],
+  "proof_ids": [
+    "mathlib:CategoryTheory.Endofunctor.Adjunction.Algebra.homEquiv_naturality_str",
+    "mathlib:CategoryTheory.Endofunctor.Adjunction.Coalgebra.homEquiv_naturality_str_symm",
+    "mathlib:CategoryTheory.Endofunctor.Algebra.Initial.left_inv'",
+    "mathlib:CategoryTheory.Endofunctor.Algebra.Initial.right_inv",
+    "mathlib:CategoryTheory.Functor.Elements.ext"
+  ],
+  "proof_keys": [
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Elements.lean\",null,null,\"CategoryTheory.Functor.Elements.ext\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Endofunctor/Algebra.lean\",null,null,\"CategoryTheory.Endofunctor.Adjunction.Algebra.homEquiv_naturality_str\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Endofunctor/Algebra.lean\",null,null,\"CategoryTheory.Endofunctor.Adjunction.Coalgebra.homEquiv_naturality_str_symm\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Endofunctor/Algebra.lean\",null,null,\"CategoryTheory.Endofunctor.Algebra.Initial.left_inv'\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Endofunctor/Algebra.lean\",null,null,\"CategoryTheory.Endofunctor.Algebra.Initial.right_inv\"]"
+  ]
+}

manifests/batches/mathlib/000636.json

@@ -0,0 +1,443 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "mathlib/000636",
+  "batch_fingerprint": "6674b2d1788baebf7f28f4cdd23e54d6bde9ea9a0d593a5b88ffb563d058fdf9",
+  "evidence": {
+    "batch_fingerprint": "6674b2d1788baebf7f28f4cdd23e54d6bde9ea9a0d593a5b88ffb563d058fdf9",
+    "contamination_matches": [],
+    "failures": [
+      {
+        "full_name": "CategoryTheory.Aut.Aut_inv_def",
+        "id": "CategoryTheory.Aut.Aut_inv_def",
+        "reason": "missing_trace",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            158,
+            54
+          ],
+          "file_path": "Mathlib/CategoryTheory/Endomorphism.lean",
+          "full_name": "CategoryTheory.Aut.Aut_inv_def",
+          "start": [
+            158,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Endomorphism.lean"
+      },
+      {
+        "full_name": "CategoryTheory.Aut.Aut_mul_def",
+        "id": "CategoryTheory.Aut.Aut_mul_def",
+        "reason": "missing_trace",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            154,
+            61
+          ],
+          "file_path": "Mathlib/CategoryTheory/Endomorphism.lean",
+          "full_name": "CategoryTheory.Aut.Aut_mul_def",
+          "start": [
+            154,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Endomorphism.lean"
+      },
+      {
+        "full_name": "CategoryTheory.Aut.ext",
+        "id": "CategoryTheory.Aut.ext",
+        "reason": "missing_trace",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            139,
+            12
+          ],
+          "file_path": "Mathlib/CategoryTheory/Endomorphism.lean",
+          "full_name": "CategoryTheory.Aut.ext",
+          "start": [
+            137,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Endomorphism.lean"
+      },
+      {
+        "full_name": "CategoryTheory.End.mul_def",
+        "id": "CategoryTheory.End.mul_def",
+        "reason": "missing_trace",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            69,
+            59
+          ],
+          "file_path": "Mathlib/CategoryTheory/Endomorphism.lean",
+          "full_name": "CategoryTheory.End.mul_def",
+          "start": [
+            69,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Endomorphism.lean"
+      },
+      {
+        "full_name": "CategoryTheory.End.one_def",
+        "id": "CategoryTheory.End.one_def",
+        "reason": "missing_trace",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            65,
+            43
+          ],
+          "file_path": "Mathlib/CategoryTheory/Endomorphism.lean",
+          "full_name": "CategoryTheory.End.one_def",
+          "start": [
+            65,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Endomorphism.lean"
+      },
+      {
+        "full_name": "CategoryTheory.End.smul_left",
+        "id": "CategoryTheory.End.smul_left",
+        "reason": "missing_trace",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            104,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Endomorphism.lean",
+          "full_name": "CategoryTheory.End.smul_left",
+          "start": [
+            103,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Endomorphism.lean"
+      },
+      {
+        "full_name": "CategoryTheory.End.smul_right",
+        "id": "CategoryTheory.End.smul_right",
+        "reason": "missing_trace",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            100,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Endomorphism.lean",
+          "full_name": "CategoryTheory.End.smul_right",
+          "start": [
+            99,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Endomorphism.lean"
+      },
+      {
+        "full_name": "CategoryTheory.isUnit_iff_isIso",
+        "id": "CategoryTheory.isUnit_iff_isIso",
+        "reason": "missing_trace",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            120,
+            41
+          ],
+          "file_path": "Mathlib/CategoryTheory/Endomorphism.lean",
+          "full_name": "CategoryTheory.isUnit_iff_isIso",
+          "start": [
+            117,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"simp\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\ninst\u271d : Category.{v, u} C\nX : C\nf : End X\nh : IsIso f\n\u22a2 f * inv f = 1",
+              "tactic": "simp"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\ninst\u271d : Category.{v, u} C\nX : C\nf : End X\nh : IsIso f\n\u22a2 inv f * f = 1",
+              "tactic": "simp"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Endomorphism.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.ForgetEnrichment.homOf_homTo",
+        "id": "CategoryTheory.ForgetEnrichment.homOf_homTo",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            260,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Enriched/Basic.lean",
+          "full_name": "CategoryTheory.ForgetEnrichment.homOf_homTo",
+          "start": [
+            258,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Enriched/Basic.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.ForgetEnrichment.homTo_homOf",
+        "id": "CategoryTheory.ForgetEnrichment.homTo_homOf",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            254,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Enriched/Basic.lean",
+          "full_name": "CategoryTheory.ForgetEnrichment.homTo_homOf",
+          "start": [
+            252,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Enriched/Basic.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.ForgetEnrichment.of_to",
+        "id": "CategoryTheory.ForgetEnrichment.of_to",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            224,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Enriched/Basic.lean",
+          "full_name": "CategoryTheory.ForgetEnrichment.of_to",
+          "start": [
+            222,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Enriched/Basic.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.ForgetEnrichment.to_of",
+        "id": "CategoryTheory.ForgetEnrichment.to_of",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            218,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Enriched/Basic.lean",
+          "full_name": "CategoryTheory.ForgetEnrichment.to_of",
+          "start": [
+            217,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Enriched/Basic.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.e_assoc",
+        "id": "CategoryTheory.e_assoc",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            94,
+            33
+          ],
+          "file_path": "Mathlib/CategoryTheory/Enriched/Basic.lean",
+          "full_name": "CategoryTheory.e_assoc",
+          "start": [
+            91,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Enriched/Basic.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.e_comp_id",
+        "id": "CategoryTheory.e_comp_id",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            87,
+            31
+          ],
+          "file_path": "Mathlib/CategoryTheory/Enriched/Basic.lean",
+          "full_name": "CategoryTheory.e_comp_id",
+          "start": [
+            85,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Enriched/Basic.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.e_id_comp",
+        "id": "CategoryTheory.e_id_comp",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            81,
+            31
+          ],
+          "file_path": "Mathlib/CategoryTheory/Enriched/Basic.lean",
+          "full_name": "CategoryTheory.e_id_comp",
+          "start": [
+            79,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Enriched/Basic.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.forgetEnrichment_comp",
+        "id": "CategoryTheory.forgetEnrichment_comp",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            282,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Enriched/Basic.lean",
+          "full_name": "CategoryTheory.forgetEnrichment_comp",
+          "start": [
+            278,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Enriched/Basic.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.forgetEnrichment_id",
+        "id": "CategoryTheory.forgetEnrichment_id",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            267,
+            21
+          ],
+          "file_path": "Mathlib/CategoryTheory/Enriched/Basic.lean",
+          "full_name": "CategoryTheory.forgetEnrichment_id",
+          "start": [
+            265,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Enriched/Basic.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.forgetEnrichment_id'",
+        "id": "CategoryTheory.forgetEnrichment_id'",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            273,
+            57
+          ],
+          "file_path": "Mathlib/CategoryTheory/Enriched/Basic.lean",
+          "full_name": "CategoryTheory.forgetEnrichment_id'",
+          "start": [
+            271,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Enriched/Basic.lean"
+      }
+    ],
+    "input_proofs": 19,
+    "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-000636-0000-93bdb41c351dff8e.parquet",
+      "sha256": "93bdb41c351dff8ed90d2e090d40074327d85a69fb7febabc4dd86e747317e9a",
+      "bytes": 47067,
+      "rows": 1,
+      "revision": "6a3d2d550a5e8f26af70e44381b84ab7563dc62c"
+    }
+  ],
+  "proof_ids": [
+    "mathlib:CategoryTheory.e_assoc'"
+  ],
+  "proof_keys": [
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Enriched/Basic.lean\",null,null,\"CategoryTheory.e_assoc'\"]"
+  ]
+}

manifests/batches/mathlib/000637.json

@@ -0,0 +1,882 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "mathlib/000637",
+  "batch_fingerprint": "897fe0cf9caa7057039783cb9eac7e59e0650f72856ca45b357537532f12578d",
+  "evidence": {
+    "batch_fingerprint": "897fe0cf9caa7057039783cb9eac7e59e0650f72856ca45b357537532f12578d",
+    "contamination_matches": [],
+    "failures": [
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.IsIso.of_epi_section",
+        "id": "CategoryTheory.IsIso.of_epi_section",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            202,
+            63
+          ],
+          "file_path": "Mathlib/CategoryTheory/EpiMono.lean",
+          "full_name": "CategoryTheory.IsIso.of_epi_section",
+          "start": [
+            200,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/EpiMono.lean"
+      },
+      {
+        "error": "no internal trace for tactic 'simp'",
+        "full_name": "CategoryTheory.IsIso.of_epi_section'",
+        "id": "CategoryTheory.IsIso.of_epi_section'",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            196,
+            74
+          ],
+          "file_path": "Mathlib/CategoryTheory/EpiMono.lean",
+          "full_name": "CategoryTheory.IsIso.of_epi_section'",
+          "start": [
+            194,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"simp\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nX Y : C\nf : X \u27f6 Y\nhf : SplitEpi f\ninst\u271d : Epi hf.section_\n\u22a2 hf.section_ \u226b f \u226b hf.section_ = hf.section_",
+              "tactic": "simp"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nX Y : C\nf : X \u27f6 Y\nhf : SplitEpi f\ninst\u271d : Epi hf.section_\n\u22a2 hf.section_ \u226b f = \ud835\udfd9 Y",
+              "tactic": "simp"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/EpiMono.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.IsIso.of_mono_retraction",
+        "id": "CategoryTheory.IsIso.of_mono_retraction",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            190,
+            68
+          ],
+          "file_path": "Mathlib/CategoryTheory/EpiMono.lean",
+          "full_name": "CategoryTheory.IsIso.of_mono_retraction",
+          "start": [
+            188,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/EpiMono.lean"
+      },
+      {
+        "error": "no internal trace for tactic 'simp'",
+        "full_name": "CategoryTheory.IsIso.of_mono_retraction'",
+        "id": "CategoryTheory.IsIso.of_mono_retraction'",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            184,
+            79
+          ],
+          "file_path": "Mathlib/CategoryTheory/EpiMono.lean",
+          "full_name": "CategoryTheory.IsIso.of_mono_retraction'",
+          "start": [
+            182,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"simp\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nX Y : C\nf : X \u27f6 Y\nhf : SplitMono f\ninst\u271d : Mono hf.retraction\n\u22a2 f \u226b hf.retraction = \ud835\udfd9 X",
+              "tactic": "simp"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nX Y : C\nf : X \u27f6 Y\nhf : SplitMono f\ninst\u271d : Mono hf.retraction\n\u22a2 (hf.retraction \u226b f) \u226b hf.retraction = hf.retraction",
+              "tactic": "simp"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/EpiMono.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.IsSplitEpi.id",
+        "id": "CategoryTheory.IsSplitEpi.id",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            135,
+            29
+          ],
+          "file_path": "Mathlib/CategoryTheory/EpiMono.lean",
+          "full_name": "CategoryTheory.IsSplitEpi.id",
+          "start": [
+            134,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/EpiMono.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.IsSplitEpi.mk'",
+        "id": "CategoryTheory.IsSplitEpi.mk'",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            97,
+            22
+          ],
+          "file_path": "Mathlib/CategoryTheory/EpiMono.lean",
+          "full_name": "CategoryTheory.IsSplitEpi.mk'",
+          "start": [
+            96,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/EpiMono.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.IsSplitMono.id",
+        "id": "CategoryTheory.IsSplitMono.id",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            107,
+            30
+          ],
+          "file_path": "Mathlib/CategoryTheory/EpiMono.lean",
+          "full_name": "CategoryTheory.IsSplitMono.id",
+          "start": [
+            106,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/EpiMono.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.IsSplitMono.mk'",
+        "id": "CategoryTheory.IsSplitMono.mk'",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            67,
+            22
+          ],
+          "file_path": "Mathlib/CategoryTheory/EpiMono.lean",
+          "full_name": "CategoryTheory.IsSplitMono.mk'",
+          "start": [
+            66,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/EpiMono.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.isSplitEpi_of_epi",
+        "id": "CategoryTheory.isSplitEpi_of_epi",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            245,
+            39
+          ],
+          "file_path": "Mathlib/CategoryTheory/EpiMono.lean",
+          "full_name": "CategoryTheory.isSplitEpi_of_epi",
+          "start": [
+            244,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/EpiMono.lean"
+      },
+      {
+        "error": "no internal trace for tactic 'rw [hY]'",
+        "full_name": "CategoryTheory.Functor.congr_inv_of_congr_hom",
+        "id": "CategoryTheory.Functor.congr_inv_of_congr_hom",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            250,
+            20
+          ],
+          "file_path": "Mathlib/CategoryTheory/EqToHom.lean",
+          "full_name": "CategoryTheory.Functor.congr_inv_of_congr_hom",
+          "start": [
+            245,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"rw [hX]\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\n\u03b2 : Sort u_1\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF G : C \u2964 D\nX Y : C\ne : X \u2245 Y\nhX : F.obj X = G.obj X\nhY : F.obj Y = G.obj Y\n\u22a2 F.obj X = G.obj X",
+              "tactic": "rw [hX]"
+            },
+            {
+              "annotated_tactic": [
+                "\"rw [hY]\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\n\u03b2 : Sort u_1\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF G : C \u2964 D\nX Y : C\ne : X \u2245 Y\nhX : F.obj X = G.obj X\nhY : F.obj Y = G.obj Y\n\u22a2 G.obj Y = F.obj Y",
+              "tactic": "rw [hY]"
+            },
+            {
+              "annotated_tactic": [
+                "\"rw [hY]\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\n\u03b2 : Sort u_1\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF G : C \u2964 D\nX Y : C\ne : X \u2245 Y\nhX : F.obj X = G.obj X\nhY : F.obj Y = G.obj Y\nh\u2082 : F.map e.hom = eqToHom \u22ef \u226b G.map e.hom \u226b eqToHom \u22ef\n\u22a2 F.obj Y = G.obj Y",
+              "tactic": "rw [hY]"
+            },
+            {
+              "annotated_tactic": [
+                "\"rw [hX]\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\n\u03b2 : Sort u_1\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF G : C \u2964 D\nX Y : C\ne : X \u2245 Y\nhX : F.obj X = G.obj X\nhY : F.obj Y = G.obj Y\nh\u2082 : F.map e.hom = eqToHom \u22ef \u226b G.map e.hom \u226b eqToHom \u22ef\n\u22a2 G.obj X = F.obj X",
+              "tactic": "rw [hX]"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp only [\\u2190 <a>IsIso.Iso.inv_hom<\\/a> e, <a>Functor.map_inv<\\/a>, h\\u2082, <a>IsIso.inv_comp<\\/a>, <a>inv_eqToHom<\\/a>,\\n    <a>Category.assoc<\\/a>]\"",
+                "[{\"full_name\":\"CategoryTheory.IsIso.Iso.inv_hom\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Iso.lean\",\"def_pos\":[435,9],\"def_end_pos\":[435,20]},{\"full_name\":\"CategoryTheory.Functor.map_inv\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Iso.lean\",\"def_pos\":[651,9],\"def_end_pos\":[651,16]},{\"full_name\":\"CategoryTheory.IsIso.inv_comp\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Iso.lean\",\"def_pos\":[417,9],\"def_end_pos\":[417,17]},{\"full_name\":\"CategoryTheory.inv_eqToHom\",\"def_path\":\"Mathlib\\/CategoryTheory\\/EqToHom.lean\",\"def_pos\":[190,9],\"def_end_pos\":[190,20]},{\"full_name\":\"CategoryTheory.Category.assoc\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[181,3],\"def_end_pos\":[181,8]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\n\u03b2 : Sort u_1\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF G : C \u2964 D\nX Y : C\ne : X \u2245 Y\nhX : F.obj X = G.obj X\nhY : F.obj Y = G.obj Y\nh\u2082 : F.map e.hom = eqToHom \u22ef \u226b G.map e.hom \u226b eqToHom \u22ef\n\u22a2 F.map e.inv = eqToHom \u22ef \u226b G.map e.inv \u226b eqToHom \u22ef",
+              "tactic": "simp only [\u2190 IsIso.Iso.inv_hom e, Functor.map_inv, h\u2082, IsIso.inv_comp, inv_eqToHom,\n  Category.assoc]"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/EqToHom.lean"
+      },
+      {
+        "error": "no internal trace for tactic 'match F, G with\\n| mk F_pre _ _ , mk G_pre _ _ =>\\n  match F_pre, G_pre with  | Prefunctor.mk F_obj _ , Prefunctor.mk G_obj _ =>\\n  obtain rfl : F_obj = G_obj := by\\n    ext X\\n    apply h_obj\\n  congr\\n  funext X Y f\\n  simpa using h_map X Y f'",
+        "full_name": "CategoryTheory.Functor.ext",
+        "id": "CategoryTheory.Functor.ext",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            213,
+            28
+          ],
+          "file_path": "Mathlib/CategoryTheory/EqToHom.lean",
+          "full_name": "CategoryTheory.Functor.ext",
+          "start": [
+            200,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"match F, G with\\n  | <a>mk<\\/a> F_pre _ _ , <a>mk<\\/a> G_pre _ _ =>\\n    match F_pre, G_pre with  -- Porting note: did not unfold the Prefunctor unlike Lean3\\n    | <a>Prefunctor.mk<\\/a> F_obj _ , <a>Prefunctor.mk<\\/a> G_obj _ =>\\n    obtain rfl : F_obj = G_obj := by\\n      ext X\\n      apply h_obj\\n    congr\\n    funext X Y f\\n    simpa using h_map X Y f\"",
+                "[{\"full_name\":\"CategoryTheory.Functor.mk\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Functor\\/Basic.lean\",\"def_pos\":[38,11],\"def_end_pos\":[38,18]},{\"full_name\":\"CategoryTheory.Functor.mk\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Functor\\/Basic.lean\",\"def_pos\":[38,11],\"def_end_pos\":[38,18]},{\"full_name\":\"Prefunctor.mk\",\"def_path\":\"Mathlib\\/Combinatorics\\/Quiver\\/Basic.lean\",\"def_pos\":[57,11],\"def_end_pos\":[57,21]},{\"full_name\":\"Prefunctor.mk\",\"def_path\":\"Mathlib\\/Combinatorics\\/Quiver\\/Basic.lean\",\"def_pos\":[57,11],\"def_end_pos\":[57,21]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\n\u03b2 : Sort u_1\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF G : C \u2964 D\nh_obj : \u2200 (X : C), F.obj X = G.obj X\nh_map : autoParam (\u2200 (X Y : C) (f : X \u27f6 Y), F.map f = eqToHom \u22ef \u226b G.map f \u226b eqToHom \u22ef) _auto\u271d\n\u22a2 F = G",
+              "tactic": "match F, G with\n| mk F_pre _ _ , mk G_pre _ _ =>\n  match F_pre, G_pre with  | Prefunctor.mk F_obj _ , Prefunctor.mk G_obj _ =>\n  obtain rfl : F_obj = G_obj := by\n    ext X\n    apply h_obj\n  congr\n  funext X Y f\n  simpa using h_map X Y f"
+            },
+            {
+              "annotated_tactic": [
+                "\"match F_pre, G_pre with  -- Porting note: did not unfold the Prefunctor unlike Lean3\\n    | <a>Prefunctor.mk<\\/a> F_obj _ , <a>Prefunctor.mk<\\/a> G_obj _ =>\\n    obtain rfl : F_obj = G_obj := by\\n      ext X\\n      apply h_obj\\n    congr\\n    funext X Y f\\n    simpa using h_map X Y f\"",
+                "[{\"full_name\":\"Prefunctor.mk\",\"def_path\":\"Mathlib\\/Combinatorics\\/Quiver\\/Basic.lean\",\"def_pos\":[57,11],\"def_end_pos\":[57,21]},{\"full_name\":\"Prefunctor.mk\",\"def_path\":\"Mathlib\\/Combinatorics\\/Quiver\\/Basic.lean\",\"def_pos\":[57,11],\"def_end_pos\":[57,21]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\n\u03b2 : Sort u_1\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF G : C \u2964 D\nF_pre : C \u2964q D\nmap_id\u271d\u00b9 : \u2200 (X : C), F_pre.map (\ud835\udfd9 X) = \ud835\udfd9 (F_pre.obj X)\nmap_comp\u271d\u00b9 : \u2200 {X Y Z : C} (f : X \u27f6 Y) (g : Y \u27f6 Z), F_pre.map (f \u226b g) = F_pre.map f \u226b F_pre.map g\nG_pre : C \u2964q D\nmap_id\u271d : \u2200 (X : C), G_pre.map (\ud835\udfd9 X) = \ud835\udfd9 (G_pre.obj X)\nmap_comp\u271d : \u2200 {X Y Z : C} (f : X \u27f6 Y) (g : Y \u27f6 Z), G_pre.map (f \u226b g) = G_pre.map f \u226b G_pre.map g\nh_obj :\n  \u2200 (X : C),\n    { toPrefunctor := F_pre, map_id := map_id\u271d\u00b9, map_comp := map_comp\u271d\u00b9 }.obj X =\n      { toPrefunctor := G_pre, map_id := map_id\u271d, map_comp := map_comp\u271d }.obj X\nh_map :\n  autoParam\n    (\u2200 (X Y : C) (f : X \u27f6 Y),\n      { toPrefunctor := F_pre, map_id := map_id\u271d\u00b9, map_comp := map_comp\u271d\u00b9 }.map f =\n        eqToHom \u22ef \u226b { toPrefunctor := G_pre, map_id := map_id\u271d, map_comp := map_comp\u271d }.map f \u226b eqToHom \u22ef)\n    _auto\u271d\n\u22a2 { toPrefunctor := F_pre, map_id := map_id\u271d\u00b9, map_comp := map_comp\u271d\u00b9 } =\n    { toPrefunctor := G_pre, map_id := map_id\u271d, map_comp := map_comp\u271d }",
+              "tactic": "match F_pre, G_pre with  | Prefunctor.mk F_obj _ , Prefunctor.mk G_obj _ =>\nobtain rfl : F_obj = G_obj := by\n  ext X\n  apply h_obj\ncongr\nfunext X Y f\nsimpa using h_map X Y f"
+            },
+            {
+              "annotated_tactic": [
+                "\"obtain rfl : F_obj = G_obj := by\\n      ext X\\n      apply h_obj\"",
+                "[]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\n\u03b2 : Sort u_1\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF G : C \u2964 D\nF_pre G_pre : C \u2964q D\nF_obj : C \u2192 D\nmap\u271d\u00b9 : {X Y : C} \u2192 (X \u27f6 Y) \u2192 (F_obj X \u27f6 F_obj Y)\nmap_id\u271d\u00b9 : \u2200 (X : C), { obj := F_obj, map := map\u271d\u00b9 }.map (\ud835\udfd9 X) = \ud835\udfd9 ({ obj := F_obj, map := map\u271d\u00b9 }.obj X)\nmap_comp\u271d\u00b9 :\n  \u2200 {X Y Z : C} (f : X \u27f6 Y) (g : Y \u27f6 Z),\n    { obj := F_obj, map := map\u271d\u00b9 }.map (f \u226b g) =\n      { obj := F_obj, map := map\u271d\u00b9 }.map f \u226b { obj := F_obj, map := map\u271d\u00b9 }.map g\nmap\u271d : {X Y : C} \u2192 (X \u27f6 Y) \u2192 (F_obj X \u27f6 F_obj Y)\nmap_id\u271d : \u2200 (X : C), { obj := F_obj, map := map\u271d }.map (\ud835\udfd9 X) = \ud835\udfd9 ({ obj := F_obj, map := map\u271d }.obj X)\nmap_comp\u271d :\n  \u2200 {X Y Z : C} (f : X \u27f6 Y) (g : Y \u27f6 Z),\n    { obj := F_obj, map := map\u271d }.map (f \u226b g) =\n      { obj := F_obj, map := map\u271d }.map f \u226b { obj := F_obj, map := map\u271d }.map g\nh_obj :\n  \u2200 (X : C),\n    { obj := F_obj, map := map\u271d\u00b9, map_id := map_id\u271d\u00b9, map_comp := map_comp\u271d\u00b9 }.obj X =\n      { obj := F_obj, map := map\u271d, map_id := map_id\u271d, map_comp := map_comp\u271d }.obj X\nh_map :\n  autoParam\n    (\u2200 (X Y : C) (f : X \u27f6 Y),\n      { obj := F_obj, map := map\u271d\u00b9, map_id := map_id\u271d\u00b9, map_comp := map_comp\u271d\u00b9 }.map f =\n        eqToHom \u22ef \u226b { obj := F_obj, map := map\u271d, map_id := map_id\u271d, map_comp := map_comp\u271d }.map f \u226b eqToHom \u22ef)\n    _auto\u271d\n\u22a2 { obj := F_obj, map := map\u271d\u00b9, map_id := map_id\u271d\u00b9, map_comp := map_comp\u271d\u00b9 } =\n    { obj := F_obj, map := map\u271d, map_id := map_id\u271d, map_comp := map_comp\u271d }",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\n\u03b2 : Sort u_1\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF G : C \u2964 D\nF_pre G_pre : C \u2964q D\nF_obj : C \u2192 D\nmap\u271d\u00b9 : {X Y : C} \u2192 (X \u27f6 Y) \u2192 (F_obj X \u27f6 F_obj Y)\nG_obj : C \u2192 D\nmap\u271d : {X Y : C} \u2192 (X \u27f6 Y) \u2192 (G_obj X \u27f6 G_obj Y)\nmap_id\u271d\u00b9 : \u2200 (X : C), { obj := F_obj, map := map\u271d\u00b9 }.map (\ud835\udfd9 X) = \ud835\udfd9 ({ obj := F_obj, map := map\u271d\u00b9 }.obj X)\nmap_comp\u271d\u00b9 :\n  \u2200 {X Y Z : C} (f : X \u27f6 Y) (g : Y \u27f6 Z),\n    { obj := F_obj, map := map\u271d\u00b9 }.map (f \u226b g) =\n      { obj := F_obj, map := map\u271d\u00b9 }.map f \u226b { obj := F_obj, map := map\u271d\u00b9 }.map g\nmap_id\u271d : \u2200 (X : C), { obj := G_obj, map := map\u271d }.map (\ud835\udfd9 X) = \ud835\udfd9 ({ obj := G_obj, map := map\u271d }.obj X)\nmap_comp\u271d :\n  \u2200 {X Y Z : C} (f : X \u27f6 Y) (g : Y \u27f6 Z),\n    { obj := G_obj, map := map\u271d }.map (f \u226b g) =\n      { obj := G_obj, map := map\u271d }.map f \u226b { obj := G_obj, map := map\u271d }.map g\nh_obj :\n  \u2200 (X : C),\n    { obj := F_obj, map := map\u271d\u00b9, map_id := map_id\u271d\u00b9, map_comp := map_comp\u271d\u00b9 }.obj X =\n      { obj := G_obj, map := map\u271d, map_id := map_id\u271d, map_comp := map_comp\u271d }.obj X\nh_map :\n  autoParam\n    (\u2200 (X Y : C) (f : X \u27f6 Y),\n      { obj := F_obj, map := map\u271d\u00b9, map_id := map_id\u271d\u00b9, map_comp := map_comp\u271d\u00b9 }.map f =\n        eqToHom \u22ef \u226b { obj := G_obj, map := map\u271d, map_id := map_id\u271d, map_comp := map_comp\u271d }.map f \u226b eqToHom \u22ef)\n    _auto\u271d\n\u22a2 { obj := F_obj, map := map\u271d\u00b9, map_id := map_id\u271d\u00b9, map_comp := map_comp\u271d\u00b9 } =\n    { obj := G_obj, map := map\u271d, map_id := map_id\u271d, map_comp := map_comp\u271d }",
+              "tactic": "obtain rfl : F_obj = G_obj := by\n  ext X\n  apply h_obj"
+            },
+            {
+              "annotated_tactic": [
+                "\"congr\"",
+                "[]"
+              ],
+              "state_after": "case e_toPrefunctor.e_map\nC : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\n\u03b2 : Sort u_1\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF G : C \u2964 D\nF_pre G_pre : C \u2964q D\nF_obj : C \u2192 D\nmap\u271d\u00b9 : {X Y : C} \u2192 (X \u27f6 Y) \u2192 (F_obj X \u27f6 F_obj Y)\nmap_id\u271d\u00b9 : \u2200 (X : C), { obj := F_obj, map := map\u271d\u00b9 }.map (\ud835\udfd9 X) = \ud835\udfd9 ({ obj := F_obj, map := map\u271d\u00b9 }.obj X)\nmap_comp\u271d\u00b9 :\n  \u2200 {X Y Z : C} (f : X \u27f6 Y) (g : Y \u27f6 Z),\n    { obj := F_obj, map := map\u271d\u00b9 }.map (f \u226b g) =\n      { obj := F_obj, map := map\u271d\u00b9 }.map f \u226b { obj := F_obj, map := map\u271d\u00b9 }.map g\nmap\u271d : {X Y : C} \u2192 (X \u27f6 Y) \u2192 (F_obj X \u27f6 F_obj Y)\nmap_id\u271d : \u2200 (X : C), { obj := F_obj, map := map\u271d }.map (\ud835\udfd9 X) = \ud835\udfd9 ({ obj := F_obj, map := map\u271d }.obj X)\nmap_comp\u271d :\n  \u2200 {X Y Z : C} (f : X \u27f6 Y) (g : Y \u27f6 Z),\n    { obj := F_obj, map := map\u271d }.map (f \u226b g) =\n      { obj := F_obj, map := map\u271d }.map f \u226b { obj := F_obj, map := map\u271d }.map g\nh_obj :\n  \u2200 (X : C),\n    { obj := F_obj, map := map\u271d\u00b9, map_id := map_id\u271d\u00b9, map_comp := map_comp\u271d\u00b9 }.obj X =\n      { obj := F_obj, map := map\u271d, map_id := map_id\u271d, map_comp := map_comp\u271d }.obj X\nh_map :\n  autoParam\n    (\u2200 (X Y : C) (f : X \u27f6 Y),\n      { obj := F_obj, map := map\u271d\u00b9, map_id := map_id\u271d\u00b9, map_comp := map_comp\u271d\u00b9 }.map f =\n        eqToHom \u22ef \u226b { obj := F_obj, map := map\u271d, map_id := map_id\u271d, map_comp := map_comp\u271d }.map f \u226b eqToHom \u22ef)\n    _auto\u271d\n\u22a2 map\u271d\u00b9 = map\u271d",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\n\u03b2 : Sort u_1\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF G : C \u2964 D\nF_pre G_pre : C \u2964q D\nF_obj : C \u2192 D\nmap\u271d\u00b9 : {X Y : C} \u2192 (X \u27f6 Y) \u2192 (F_obj X \u27f6 F_obj Y)\nmap_id\u271d\u00b9 : \u2200 (X : C), { obj := F_obj, map := map\u271d\u00b9 }.map (\ud835\udfd9 X) = \ud835\udfd9 ({ obj := F_obj, map := map\u271d\u00b9 }.obj X)\nmap_comp\u271d\u00b9 :\n  \u2200 {X Y Z : C} (f : X \u27f6 Y) (g : Y \u27f6 Z),\n    { obj := F_obj, map := map\u271d\u00b9 }.map (f \u226b g) =\n      { obj := F_obj, map := map\u271d\u00b9 }.map f \u226b { obj := F_obj, map := map\u271d\u00b9 }.map g\nmap\u271d : {X Y : C} \u2192 (X \u27f6 Y) \u2192 (F_obj X \u27f6 F_obj Y)\nmap_id\u271d : \u2200 (X : C), { obj := F_obj, map := map\u271d }.map (\ud835\udfd9 X) = \ud835\udfd9 ({ obj := F_obj, map := map\u271d }.obj X)\nmap_comp\u271d :\n  \u2200 {X Y Z : C} (f : X \u27f6 Y) (g : Y \u27f6 Z),\n    { obj := F_obj, map := map\u271d }.map (f \u226b g) =\n      { obj := F_obj, map := map\u271d }.map f \u226b { obj := F_obj, map := map\u271d }.map g\nh_obj :\n  \u2200 (X : C),\n    { obj := F_obj, map := map\u271d\u00b9, map_id := map_id\u271d\u00b9, map_comp := map_comp\u271d\u00b9 }.obj X =\n      { obj := F_obj, map := map\u271d, map_id := map_id\u271d, map_comp := map_comp\u271d }.obj X\nh_map :\n  autoParam\n    (\u2200 (X Y : C) (f : X \u27f6 Y),\n      { obj := F_obj, map := map\u271d\u00b9, map_id := map_id\u271d\u00b9, map_comp := map_comp\u271d\u00b9 }.map f =\n        eqToHom \u22ef \u226b { obj := F_obj, map := map\u271d, map_id := map_id\u271d, map_comp := map_comp\u271d }.map f \u226b eqToHom \u22ef)\n    _auto\u271d\n\u22a2 { obj := F_obj, map := map\u271d\u00b9, map_id := map_id\u271d\u00b9, map_comp := map_comp\u271d\u00b9 } =\n    { obj := F_obj, map := map\u271d, map_id := map_id\u271d, map_comp := map_comp\u271d }",
+              "tactic": "congr"
+            },
+            {
+              "annotated_tactic": [
+                "\"funext X Y f\"",
+                "[]"
+              ],
+              "state_after": "case e_toPrefunctor.e_map.h.h.h\nC : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\n\u03b2 : Sort u_1\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF G : C \u2964 D\nF_pre G_pre : C \u2964q D\nF_obj : C \u2192 D\nmap\u271d\u00b9 : {X Y : C} \u2192 (X \u27f6 Y) \u2192 (F_obj X \u27f6 F_obj Y)\nmap_id\u271d\u00b9 : \u2200 (X : C), { obj := F_obj, map := map\u271d\u00b9 }.map (\ud835\udfd9 X) = \ud835\udfd9 ({ obj := F_obj, map := map\u271d\u00b9 }.obj X)\nmap_comp\u271d\u00b9 :\n  \u2200 {X Y Z : C} (f : X \u27f6 Y) (g : Y \u27f6 Z),\n    { obj := F_obj, map := map\u271d\u00b9 }.map (f \u226b g) =\n      { obj := F_obj, map := map\u271d\u00b9 }.map f \u226b { obj := F_obj, map := map\u271d\u00b9 }.map g\nmap\u271d : {X Y : C} \u2192 (X \u27f6 Y) \u2192 (F_obj X \u27f6 F_obj Y)\nmap_id\u271d : \u2200 (X : C), { obj := F_obj, map := map\u271d }.map (\ud835\udfd9 X) = \ud835\udfd9 ({ obj := F_obj, map := map\u271d }.obj X)\nmap_comp\u271d :\n  \u2200 {X Y Z : C} (f : X \u27f6 Y) (g : Y \u27f6 Z),\n    { obj := F_obj, map := map\u271d }.map (f \u226b g) =\n      { obj := F_obj, map := map\u271d }.map f \u226b { obj := F_obj, map := map\u271d }.map g\nh_obj :\n  \u2200 (X : C),\n    { obj := F_obj, map := map\u271d\u00b9, map_id := map_id\u271d\u00b9, map_comp := map_comp\u271d\u00b9 }.obj X =\n      { obj := F_obj, map := map\u271d, map_id := map_id\u271d, map_comp := map_comp\u271d }.obj X\nh_map :\n  autoParam\n    (\u2200 (X Y : C) (f : X \u27f6 Y),\n      { obj := F_obj, map := map\u271d\u00b9, map_id := map_id\u271d\u00b9, map_comp := map_comp\u271d\u00b9 }.map f =\n        eqToHom \u22ef \u226b { obj := F_obj, map := map\u271d, map_id := map_id\u271d, map_comp := map_comp\u271d }.map f \u226b eqToHom \u22ef)\n    _auto\u271d\nX Y : C\nf : X \u27f6 Y\n\u22a2 map\u271d\u00b9 f = map\u271d f",
+              "state_before": "case e_toPrefunctor.e_map\nC : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\n\u03b2 : Sort u_1\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF G : C \u2964 D\nF_pre G_pre : C \u2964q D\nF_obj : C \u2192 D\nmap\u271d\u00b9 : {X Y : C} \u2192 (X \u27f6 Y) \u2192 (F_obj X \u27f6 F_obj Y)\nmap_id\u271d\u00b9 : \u2200 (X : C), { obj := F_obj, map := map\u271d\u00b9 }.map (\ud835\udfd9 X) = \ud835\udfd9 ({ obj := F_obj, map := map\u271d\u00b9 }.obj X)\nmap_comp\u271d\u00b9 :\n  \u2200 {X Y Z : C} (f : X \u27f6 Y) (g : Y \u27f6 Z),\n    { obj := F_obj, map := map\u271d\u00b9 }.map (f \u226b g) =\n      { obj := F_obj, map := map\u271d\u00b9 }.map f \u226b { obj := F_obj, map := map\u271d\u00b9 }.map g\nmap\u271d : {X Y : C} \u2192 (X \u27f6 Y) \u2192 (F_obj X \u27f6 F_obj Y)\nmap_id\u271d : \u2200 (X : C), { obj := F_obj, map := map\u271d }.map (\ud835\udfd9 X) = \ud835\udfd9 ({ obj := F_obj, map := map\u271d }.obj X)\nmap_comp\u271d :\n  \u2200 {X Y Z : C} (f : X \u27f6 Y) (g : Y \u27f6 Z),\n    { obj := F_obj, map := map\u271d }.map (f \u226b g) =\n      { obj := F_obj, map := map\u271d }.map f \u226b { obj := F_obj, map := map\u271d }.map g\nh_obj :\n  \u2200 (X : C),\n    { obj := F_obj, map := map\u271d\u00b9, map_id := map_id\u271d\u00b9, map_comp := map_comp\u271d\u00b9 }.obj X =\n      { obj := F_obj, map := map\u271d, map_id := map_id\u271d, map_comp := map_comp\u271d }.obj X\nh_map :\n  autoParam\n    (\u2200 (X Y : C) (f : X \u27f6 Y),\n      { obj := F_obj, map := map\u271d\u00b9, map_id := map_id\u271d\u00b9, map_comp := map_comp\u271d\u00b9 }.map f =\n        eqToHom \u22ef \u226b { obj := F_obj, map := map\u271d, map_id := map_id\u271d, map_comp := map_comp\u271d }.map f \u226b eqToHom \u22ef)\n    _auto\u271d\n\u22a2 map\u271d\u00b9 = map\u271d",
+              "tactic": "funext X Y f"
+            },
+            {
+              "annotated_tactic": [
+                "\"simpa using h_map X Y f\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case e_toPrefunctor.e_map.h.h.h\nC : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\n\u03b2 : Sort u_1\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF G : C \u2964 D\nF_pre G_pre : C \u2964q D\nF_obj : C \u2192 D\nmap\u271d\u00b9 : {X Y : C} \u2192 (X \u27f6 Y) \u2192 (F_obj X \u27f6 F_obj Y)\nmap_id\u271d\u00b9 : \u2200 (X : C), { obj := F_obj, map := map\u271d\u00b9 }.map (\ud835\udfd9 X) = \ud835\udfd9 ({ obj := F_obj, map := map\u271d\u00b9 }.obj X)\nmap_comp\u271d\u00b9 :\n  \u2200 {X Y Z : C} (f : X \u27f6 Y) (g : Y \u27f6 Z),\n    { obj := F_obj, map := map\u271d\u00b9 }.map (f \u226b g) =\n      { obj := F_obj, map := map\u271d\u00b9 }.map f \u226b { obj := F_obj, map := map\u271d\u00b9 }.map g\nmap\u271d : {X Y : C} \u2192 (X \u27f6 Y) \u2192 (F_obj X \u27f6 F_obj Y)\nmap_id\u271d : \u2200 (X : C), { obj := F_obj, map := map\u271d }.map (\ud835\udfd9 X) = \ud835\udfd9 ({ obj := F_obj, map := map\u271d }.obj X)\nmap_comp\u271d :\n  \u2200 {X Y Z : C} (f : X \u27f6 Y) (g : Y \u27f6 Z),\n    { obj := F_obj, map := map\u271d }.map (f \u226b g) =\n      { obj := F_obj, map := map\u271d }.map f \u226b { obj := F_obj, map := map\u271d }.map g\nh_obj :\n  \u2200 (X : C),\n    { obj := F_obj, map := map\u271d\u00b9, map_id := map_id\u271d\u00b9, map_comp := map_comp\u271d\u00b9 }.obj X =\n      { obj := F_obj, map := map\u271d, map_id := map_id\u271d, map_comp := map_comp\u271d }.obj X\nh_map :\n  autoParam\n    (\u2200 (X Y : C) (f : X \u27f6 Y),\n      { obj := F_obj, map := map\u271d\u00b9, map_id := map_id\u271d\u00b9, map_comp := map_comp\u271d\u00b9 }.map f =\n        eqToHom \u22ef \u226b { obj := F_obj, map := map\u271d, map_id := map_id\u271d, map_comp := map_comp\u271d }.map f \u226b eqToHom \u22ef)\n    _auto\u271d\nX Y : C\nf : X \u27f6 Y\n\u22a2 map\u271d\u00b9 f = map\u271d f",
+              "tactic": "simpa using h_map X Y f"
+            },
+            {
+              "annotated_tactic": [
+                "\"ext X\"",
+                "[]"
+              ],
+              "state_after": "case h\nC : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\n\u03b2 : Sort u_1\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF G : C \u2964 D\nF_pre G_pre : C \u2964q D\nF_obj : C \u2192 D\nmap\u271d\u00b9 : {X Y : C} \u2192 (X \u27f6 Y) \u2192 (F_obj X \u27f6 F_obj Y)\nG_obj : C \u2192 D\nmap\u271d : {X Y : C} \u2192 (X \u27f6 Y) \u2192 (G_obj X \u27f6 G_obj Y)\nmap_id\u271d\u00b9 : \u2200 (X : C), { obj := F_obj, map := map\u271d\u00b9 }.map (\ud835\udfd9 X) = \ud835\udfd9 ({ obj := F_obj, map := map\u271d\u00b9 }.obj X)\nmap_comp\u271d\u00b9 :\n  \u2200 {X Y Z : C} (f : X \u27f6 Y) (g : Y \u27f6 Z),\n    { obj := F_obj, map := map\u271d\u00b9 }.map (f \u226b g) =\n      { obj := F_obj, map := map\u271d\u00b9 }.map f \u226b { obj := F_obj, map := map\u271d\u00b9 }.map g\nmap_id\u271d : \u2200 (X : C), { obj := G_obj, map := map\u271d }.map (\ud835\udfd9 X) = \ud835\udfd9 ({ obj := G_obj, map := map\u271d }.obj X)\nmap_comp\u271d :\n  \u2200 {X Y Z : C} (f : X \u27f6 Y) (g : Y \u27f6 Z),\n    { obj := G_obj, map := map\u271d }.map (f \u226b g) =\n      { obj := G_obj, map := map\u271d }.map f \u226b { obj := G_obj, map := map\u271d }.map g\nh_obj :\n  \u2200 (X : C),\n    { obj := F_obj, map := map\u271d\u00b9, map_id := map_id\u271d\u00b9, map_comp := map_comp\u271d\u00b9 }.obj X =\n      { obj := G_obj, map := map\u271d, map_id := map_id\u271d, map_comp := map_comp\u271d }.obj X\nh_map :\n  autoParam\n    (\u2200 (X Y : C) (f : X \u27f6 Y),\n      { obj := F_obj, map := map\u271d\u00b9, map_id := map_id\u271d\u00b9, map_comp := map_comp\u271d\u00b9 }.map f =\n        eqToHom \u22ef \u226b { obj := G_obj, map := map\u271d, map_id := map_id\u271d, map_comp := map_comp\u271d }.map f \u226b eqToHom \u22ef)\n    _auto\u271d\nX : C\n\u22a2 F_obj X = G_obj X",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\n\u03b2 : Sort u_1\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF G : C \u2964 D\nF_pre G_pre : C \u2964q D\nF_obj : C \u2192 D\nmap\u271d\u00b9 : {X Y : C} \u2192 (X \u27f6 Y) \u2192 (F_obj X \u27f6 F_obj Y)\nG_obj : C \u2192 D\nmap\u271d : {X Y : C} \u2192 (X \u27f6 Y) \u2192 (G_obj X \u27f6 G_obj Y)\nmap_id\u271d\u00b9 : \u2200 (X : C), { obj := F_obj, map := map\u271d\u00b9 }.map (\ud835\udfd9 X) = \ud835\udfd9 ({ obj := F_obj, map := map\u271d\u00b9 }.obj X)\nmap_comp\u271d\u00b9 :\n  \u2200 {X Y Z : C} (f : X \u27f6 Y) (g : Y \u27f6 Z),\n    { obj := F_obj, map := map\u271d\u00b9 }.map (f \u226b g) =\n      { obj := F_obj, map := map\u271d\u00b9 }.map f \u226b { obj := F_obj, map := map\u271d\u00b9 }.map g\nmap_id\u271d : \u2200 (X : C), { obj := G_obj, map := map\u271d }.map (\ud835\udfd9 X) = \ud835\udfd9 ({ obj := G_obj, map := map\u271d }.obj X)\nmap_comp\u271d :\n  \u2200 {X Y Z : C} (f : X \u27f6 Y) (g : Y \u27f6 Z),\n    { obj := G_obj, map := map\u271d }.map (f \u226b g) =\n      { obj := G_obj, map := map\u271d }.map f \u226b { obj := G_obj, map := map\u271d }.map g\nh_obj :\n  \u2200 (X : C),\n    { obj := F_obj, map := map\u271d\u00b9, map_id := map_id\u271d\u00b9, map_comp := map_comp\u271d\u00b9 }.obj X =\n      { obj := G_obj, map := map\u271d, map_id := map_id\u271d, map_comp := map_comp\u271d }.obj X\nh_map :\n  autoParam\n    (\u2200 (X Y : C) (f : X \u27f6 Y),\n      { obj := F_obj, map := map\u271d\u00b9, map_id := map_id\u271d\u00b9, map_comp := map_comp\u271d\u00b9 }.map f =\n        eqToHom \u22ef \u226b { obj := G_obj, map := map\u271d, map_id := map_id\u271d, map_comp := map_comp\u271d }.map f \u226b eqToHom \u22ef)\n    _auto\u271d\n\u22a2 F_obj = G_obj",
+              "tactic": "ext X"
+            },
+            {
+              "annotated_tactic": [
+                "\"apply h_obj\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case h\nC : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\n\u03b2 : Sort u_1\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF G : C \u2964 D\nF_pre G_pre : C \u2964q D\nF_obj : C \u2192 D\nmap\u271d\u00b9 : {X Y : C} \u2192 (X \u27f6 Y) \u2192 (F_obj X \u27f6 F_obj Y)\nG_obj : C \u2192 D\nmap\u271d : {X Y : C} \u2192 (X \u27f6 Y) \u2192 (G_obj X \u27f6 G_obj Y)\nmap_id\u271d\u00b9 : \u2200 (X : C), { obj := F_obj, map := map\u271d\u00b9 }.map (\ud835\udfd9 X) = \ud835\udfd9 ({ obj := F_obj, map := map\u271d\u00b9 }.obj X)\nmap_comp\u271d\u00b9 :\n  \u2200 {X Y Z : C} (f : X \u27f6 Y) (g : Y \u27f6 Z),\n    { obj := F_obj, map := map\u271d\u00b9 }.map (f \u226b g) =\n      { obj := F_obj, map := map\u271d\u00b9 }.map f \u226b { obj := F_obj, map := map\u271d\u00b9 }.map g\nmap_id\u271d : \u2200 (X : C), { obj := G_obj, map := map\u271d }.map (\ud835\udfd9 X) = \ud835\udfd9 ({ obj := G_obj, map := map\u271d }.obj X)\nmap_comp\u271d :\n  \u2200 {X Y Z : C} (f : X \u27f6 Y) (g : Y \u27f6 Z),\n    { obj := G_obj, map := map\u271d }.map (f \u226b g) =\n      { obj := G_obj, map := map\u271d }.map f \u226b { obj := G_obj, map := map\u271d }.map g\nh_obj :\n  \u2200 (X : C),\n    { obj := F_obj, map := map\u271d\u00b9, map_id := map_id\u271d\u00b9, map_comp := map_comp\u271d\u00b9 }.obj X =\n      { obj := G_obj, map := map\u271d, map_id := map_id\u271d, map_comp := map_comp\u271d }.obj X\nh_map :\n  autoParam\n    (\u2200 (X Y : C) (f : X \u27f6 Y),\n      { obj := F_obj, map := map\u271d\u00b9, map_id := map_id\u271d\u00b9, map_comp := map_comp\u271d\u00b9 }.map f =\n        eqToHom \u22ef \u226b { obj := G_obj, map := map\u271d, map_id := map_id\u271d, map_comp := map_comp\u271d }.map f \u226b eqToHom \u22ef)\n    _auto\u271d\nX : C\n\u22a2 F_obj X = G_obj X",
+              "tactic": "apply h_obj"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/EqToHom.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Functor.hext",
+        "id": "CategoryTheory.Functor.hext",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            233,
+            97
+          ],
+          "file_path": "Mathlib/CategoryTheory/EqToHom.lean",
+          "full_name": "CategoryTheory.Functor.hext",
+          "start": [
+            231,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/EqToHom.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Functor.precomp_map_heq",
+        "id": "CategoryTheory.Functor.precomp_map_heq",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            273,
+            9
+          ],
+          "file_path": "Mathlib/CategoryTheory/EqToHom.lean",
+          "full_name": "CategoryTheory.Functor.precomp_map_heq",
+          "start": [
+            271,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/EqToHom.lean"
+      },
+      {
+        "error": "no internal trace for tactic 'simp [w]'",
+        "full_name": "CategoryTheory.eqToHom_iso_hom_naturality",
+        "id": "CategoryTheory.eqToHom_iso_hom_naturality",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            89,
+            7
+          ],
+          "file_path": "Mathlib/CategoryTheory/EqToHom.lean",
+          "full_name": "CategoryTheory.eqToHom_iso_hom_naturality",
+          "start": [
+            86,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"simp [w]\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\u2081\ninst\u271d : Category.{v\u2081, u\u2081} C\n\u03b2 : Sort u_1\nf g : \u03b2 \u2192 C\nz : (b : \u03b2) \u2192 f b \u2245 g b\nj j' : \u03b2\nw : j = j'\n\u22a2 g j = g j'",
+              "tactic": "simp [w]"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp [w]\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\u2081\ninst\u271d : Category.{v\u2081, u\u2081} C\n\u03b2 : Sort u_1\nf g : \u03b2 \u2192 C\nz : (b : \u03b2) \u2192 f b \u2245 g b\nj j' : \u03b2\nw : j = j'\n\u22a2 f j = f j'",
+              "tactic": "simp [w]"
+            },
+            {
+              "annotated_tactic": [
+                "\"cases w\"",
+                "[]"
+              ],
+              "state_after": "case refl\nC : Type u\u2081\ninst\u271d : Category.{v\u2081, u\u2081} C\n\u03b2 : Sort u_1\nf g : \u03b2 \u2192 C\nz : (b : \u03b2) \u2192 f b \u2245 g b\nj : \u03b2\n\u22a2 (z j).hom \u226b eqToHom \u22ef = eqToHom \u22ef \u226b (z j).hom",
+              "state_before": "C : Type u\u2081\ninst\u271d : Category.{v\u2081, u\u2081} C\n\u03b2 : Sort u_1\nf g : \u03b2 \u2192 C\nz : (b : \u03b2) \u2192 f b \u2245 g b\nj j' : \u03b2\nw : j = j'\n\u22a2 (z j).hom \u226b eqToHom \u22ef = eqToHom \u22ef \u226b (z j').hom",
+              "tactic": "cases w"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case refl\nC : Type u\u2081\ninst\u271d : Category.{v\u2081, u\u2081} C\n\u03b2 : Sort u_1\nf g : \u03b2 \u2192 C\nz : (b : \u03b2) \u2192 f b \u2245 g b\nj : \u03b2\n\u22a2 (z j).hom \u226b eqToHom \u22ef = eqToHom \u22ef \u226b (z j).hom",
+              "tactic": "simp"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/EqToHom.lean"
+      },
+      {
+        "error": "no internal trace for tactic 'simp [w]'",
+        "full_name": "CategoryTheory.eqToHom_naturality",
+        "id": "CategoryTheory.eqToHom_naturality",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            80,
+            7
+          ],
+          "file_path": "Mathlib/CategoryTheory/EqToHom.lean",
+          "full_name": "CategoryTheory.eqToHom_naturality",
+          "start": [
+            77,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"simp [w]\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\u2081\ninst\u271d : Category.{v\u2081, u\u2081} C\n\u03b2 : Sort u_1\nf g : \u03b2 \u2192 C\nz : (b : \u03b2) \u2192 f b \u27f6 g b\nj j' : \u03b2\nw : j = j'\n\u22a2 g j = g j'",
+              "tactic": "simp [w]"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp [w]\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\u2081\ninst\u271d : Category.{v\u2081, u\u2081} C\n\u03b2 : Sort u_1\nf g : \u03b2 \u2192 C\nz : (b : \u03b2) \u2192 f b \u27f6 g b\nj j' : \u03b2\nw : j = j'\n\u22a2 f j = f j'",
+              "tactic": "simp [w]"
+            },
+            {
+              "annotated_tactic": [
+                "\"cases w\"",
+                "[]"
+              ],
+              "state_after": "case refl\nC : Type u\u2081\ninst\u271d : Category.{v\u2081, u\u2081} C\n\u03b2 : Sort u_1\nf g : \u03b2 \u2192 C\nz : (b : \u03b2) \u2192 f b \u27f6 g b\nj : \u03b2\n\u22a2 z j \u226b eqToHom \u22ef = eqToHom \u22ef \u226b z j",
+              "state_before": "C : Type u\u2081\ninst\u271d : Category.{v\u2081, u\u2081} C\n\u03b2 : Sort u_1\nf g : \u03b2 \u2192 C\nz : (b : \u03b2) \u2192 f b \u27f6 g b\nj j' : \u03b2\nw : j = j'\n\u22a2 z j \u226b eqToHom \u22ef = eqToHom \u22ef \u226b z j'",
+              "tactic": "cases w"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case refl\nC : Type u\u2081\ninst\u271d : Category.{v\u2081, u\u2081} C\n\u03b2 : Sort u_1\nf g : \u03b2 \u2192 C\nz : (b : \u03b2) \u2192 f b \u27f6 g b\nj : \u03b2\n\u22a2 z j \u226b eqToHom \u22ef = eqToHom \u22ef \u226b z j",
+              "tactic": "simp"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/EqToHom.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.eqToHom_refl",
+        "id": "CategoryTheory.eqToHom_refl",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            48,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/EqToHom.lean",
+          "full_name": "CategoryTheory.eqToHom_refl",
+          "start": [
+            47,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/EqToHom.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.eqToIso.hom",
+        "id": "CategoryTheory.eqToIso.hom",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            155,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/EqToHom.lean",
+          "full_name": "CategoryTheory.eqToIso.hom",
+          "start": [
+            154,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/EqToHom.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.eqToIso.inv",
+        "id": "CategoryTheory.eqToIso.inv",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            160,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/EqToHom.lean",
+          "full_name": "CategoryTheory.eqToIso.inv",
+          "start": [
+            159,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/EqToHom.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.eqToIso_refl",
+        "id": "CategoryTheory.eqToIso_refl",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            165,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/EqToHom.lean",
+          "full_name": "CategoryTheory.eqToIso_refl",
+          "start": [
+            164,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/EqToHom.lean"
+      }
+    ],
+    "input_proofs": 48,
+    "input_units": 2,
+    "proofs": 29,
+    "published_proofs": 26,
+    "published_transitions": 45,
+    "replay_failures": [],
+    "transitions": 51,
+    "validation_failures": [
+      {
+        "errors": [
+          "internal transition boundary mismatch"
+        ],
+        "file_path": "Mathlib/CategoryTheory/EpiMono.lean",
+        "proof_id": "mathlib:CategoryTheory.isIso_of_epi_of_isSplitMono",
+        "provenance": {
+          "selection": {
+            "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+            "end": [
+              123,
+              56
+            ],
+            "file_path": "Mathlib/CategoryTheory/EpiMono.lean",
+            "full_name": "CategoryTheory.isIso_of_epi_of_isSplitMono",
+            "start": [
+              122,
+              1
+            ],
+            "traced_tactics": [
+              {
+                "annotated_tactic": [
+                  "\"simp\"",
+                  "[]"
+                ],
+                "state_after": "no goals",
+                "state_before": "C : Type u\u2081\ninst\u271d\u00b2 : Category.{v\u2081, u\u2081} C\nX Y : C\nf : X \u27f6 Y\ninst\u271d\u00b9 : IsSplitMono f\ninst\u271d : Epi f\n\u22a2 f \u226b retraction f = \ud835\udfd9 X",
+                "tactic": "simp"
+              },
+              {
+                "annotated_tactic": [
+                  "\"simp [\\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": "C : Type u\u2081\ninst\u271d\u00b2 : Category.{v\u2081, u\u2081} C\nX Y : C\nf : X \u27f6 Y\ninst\u271d\u00b9 : IsSplitMono f\ninst\u271d : Epi f\n\u22a2 retraction f \u226b f = \ud835\udfd9 Y",
+                "tactic": "simp [\u2190 cancel_epi f]"
+              }
+            ],
+            "url": "https://github.com/leanprover-community/mathlib4"
+          }
+        },
+        "theorem_name": "CategoryTheory.isIso_of_epi_of_isSplitMono"
+      },
+      {
+        "errors": [
+          "internal transition boundary mismatch"
+        ],
+        "file_path": "Mathlib/CategoryTheory/EpiMono.lean",
+        "proof_id": "mathlib:CategoryTheory.isIso_of_mono_of_isSplitEpi",
+        "provenance": {
+          "selection": {
+            "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+            "end": [
+              150,
+              55
+            ],
+            "file_path": "Mathlib/CategoryTheory/EpiMono.lean",
+            "full_name": "CategoryTheory.isIso_of_mono_of_isSplitEpi",
+            "start": [
+              149,
+              1
+            ],
+            "traced_tactics": [
+              {
+                "annotated_tactic": [
+                  "\"simp [\\u2190 <a>cancel_mono<\\/a> f]\"",
+                  "[{\"full_name\":\"CategoryTheory.cancel_mono\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[310,9],\"def_end_pos\":[310,20]}]"
+                ],
+                "state_after": "no goals",
+                "state_before": "C : Type u\u2081\ninst\u271d\u00b2 : Category.{v\u2081, u\u2081} C\nX Y : C\nf : X \u27f6 Y\ninst\u271d\u00b9 : Mono f\ninst\u271d : IsSplitEpi f\n\u22a2 f \u226b section_ f = \ud835\udfd9 X",
+                "tactic": "simp [\u2190 cancel_mono f]"
+              },
+              {
+                "annotated_tactic": [
+                  "\"simp\"",
+                  "[]"
+                ],
+                "state_after": "no goals",
+                "state_before": "C : Type u\u2081\ninst\u271d\u00b2 : Category.{v\u2081, u\u2081} C\nX Y : C\nf : X \u27f6 Y\ninst\u271d\u00b9 : Mono f\ninst\u271d : IsSplitEpi f\n\u22a2 section_ f \u226b f = \ud835\udfd9 Y",
+                "tactic": "simp"
+              }
+            ],
+            "url": "https://github.com/leanprover-community/mathlib4"
+          }
+        },
+        "theorem_name": "CategoryTheory.isIso_of_mono_of_isSplitEpi"
+      },
+      {
+        "errors": [
+          "internal transition boundary mismatch"
+        ],
+        "file_path": "Mathlib/CategoryTheory/EqToHom.lean",
+        "proof_id": "mathlib:CategoryTheory.comp_eqToHom_iff",
+        "provenance": {
+          "selection": {
+            "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+            "end": [
+              62,
+              57
+            ],
+            "file_path": "Mathlib/CategoryTheory/EqToHom.lean",
+            "full_name": "CategoryTheory.comp_eqToHom_iff",
+            "start": [
+              59,
+              1
+            ],
+            "traced_tactics": [
+              {
+                "annotated_tactic": [
+                  "\"simp\"",
+                  "[]"
+                ],
+                "state_after": "no goals",
+                "state_before": "C : Type u\u2081\ninst\u271d : Category.{v\u2081, u\u2081} C\nX Y Y' : C\np : Y = Y'\nf : X \u27f6 Y\ng : X \u27f6 Y'\nh : f \u226b eqToHom p = g\n\u22a2 f = (f \u226b eqToHom p) \u226b eqToHom \u22ef",
+                "tactic": "simp"
+              },
+              {
+                "annotated_tactic": [
+                  "\"simp [<a>eq_whisker<\\/a> h (<a>eqToHom<\\/a> p)]\"",
+                  "[{\"full_name\":\"CategoryTheory.eq_whisker\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[213,9],\"def_end_pos\":[213,19]},{\"full_name\":\"CategoryTheory.eqToHom\",\"def_path\":\"Mathlib\\/CategoryTheory\\/EqToHom.lean\",\"def_pos\":[43,5],\"def_end_pos\":[43,12]}]"
+                ],
+                "state_after": "no goals",
+                "state_before": "C : Type u\u2081\ninst\u271d : Category.{v\u2081, u\u2081} C\nX Y Y' : C\np : Y = Y'\nf : X \u27f6 Y\ng : X \u27f6 Y'\nh : f = g \u226b eqToHom \u22ef\n\u22a2 f \u226b eqToHom p = g",
+                "tactic": "simp [eq_whisker h (eqToHom p)]"
+              }
+            ],
+            "url": "https://github.com/leanprover-community/mathlib4"
+          }
+        },
+        "theorem_name": "CategoryTheory.comp_eqToHom_iff"
+      }
+    ],
+    "validation_rejected_proofs": 3,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/mathlib-000637-0000-355fe98d2de57003.parquet",
+      "sha256": "355fe98d2de5700341e9dd46f4ff576a2c181b27091c082a76fb43f8841bf875",
+      "bytes": 126701,
+      "rows": 35,
+      "revision": "6a3d2d550a5e8f26af70e44381b84ab7563dc62c"
+    },
+    {
+      "path": "data/dev/mathlib-000637-0000-a609af52fea2881b.parquet",
+      "sha256": "a609af52fea2881b278fb045e06d4724d9d126e85e62a534deeb14eb0dfe626a",
+      "bytes": 54269,
+      "rows": 9,
+      "revision": "6a3d2d550a5e8f26af70e44381b84ab7563dc62c"
+    },
+    {
+      "path": "data/internal_test/mathlib-000637-0000-e39fe9d58b3fe812.parquet",
+      "sha256": "e39fe9d58b3fe8129366c12bf6fd594c30797d2ffe918381f9c4b34c6f946405",
+      "bytes": 25704,
+      "rows": 1,
+      "revision": "6a3d2d550a5e8f26af70e44381b84ab7563dc62c"
+    }
+  ],
+  "proof_ids": [
+    "mathlib:CategoryTheory.Functor.congr_hom",
+    "mathlib:CategoryTheory.Functor.congr_obj",
+    "mathlib:CategoryTheory.Functor.conj_eqToHom_iff_heq",
+    "mathlib:CategoryTheory.Functor.ext_of_iso",
+    "mathlib:CategoryTheory.Functor.hcongr_hom",
+    "mathlib:CategoryTheory.Functor.map_comp_heq",
+    "mathlib:CategoryTheory.Functor.map_comp_heq'",
+    "mathlib:CategoryTheory.Functor.postcomp_map_heq",
+    "mathlib:CategoryTheory.Functor.postcomp_map_heq'",
+    "mathlib:CategoryTheory.NatTrans.congr",
+    "mathlib:CategoryTheory.SplitEpi.epi",
+    "mathlib:CategoryTheory.SplitMono.mono",
+    "mathlib:CategoryTheory.congrArg_cast_hom_left",
+    "mathlib:CategoryTheory.congrArg_cast_hom_right",
+    "mathlib:CategoryTheory.congrArg_mpr_hom_left",
+    "mathlib:CategoryTheory.dcongr_arg",
+    "mathlib:CategoryTheory.eqToHom_app",
+    "mathlib:CategoryTheory.eqToHom_map",
+    "mathlib:CategoryTheory.eqToHom_map_comp",
+    "mathlib:CategoryTheory.eqToHom_op",
+    "mathlib:CategoryTheory.eqToHom_trans",
+    "mathlib:CategoryTheory.eqToHom_unop",
+    "mathlib:CategoryTheory.eqToIso_map_trans",
+    "mathlib:CategoryTheory.eqToIso_trans",
+    "mathlib:CategoryTheory.eq_conj_eqToHom",
+    "mathlib:CategoryTheory.inv_eqToHom"
+  ],
+  "proof_keys": [
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/EpiMono.lean\",null,null,\"CategoryTheory.SplitEpi.epi\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/EpiMono.lean\",null,null,\"CategoryTheory.SplitMono.mono\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/EqToHom.lean\",null,null,\"CategoryTheory.Functor.congr_hom\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/EqToHom.lean\",null,null,\"CategoryTheory.Functor.congr_obj\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/EqToHom.lean\",null,null,\"CategoryTheory.Functor.conj_eqToHom_iff_heq\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/EqToHom.lean\",null,null,\"CategoryTheory.Functor.ext_of_iso\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/EqToHom.lean\",null,null,\"CategoryTheory.Functor.hcongr_hom\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/EqToHom.lean\",null,null,\"CategoryTheory.Functor.map_comp_heq\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/EqToHom.lean\",null,null,\"CategoryTheory.Functor.map_comp_heq'\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/EqToHom.lean\",null,null,\"CategoryTheory.Functor.postcomp_map_heq\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/EqToHom.lean\",null,null,\"CategoryTheory.Functor.postcomp_map_heq'\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/EqToHom.lean\",null,null,\"CategoryTheory.NatTrans.congr\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/EqToHom.lean\",null,null,\"CategoryTheory.congrArg_cast_hom_left\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/EqToHom.lean\",null,null,\"CategoryTheory.congrArg_cast_hom_right\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/EqToHom.lean\",null,null,\"CategoryTheory.congrArg_mpr_hom_left\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/EqToHom.lean\",null,null,\"CategoryTheory.dcongr_arg\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/EqToHom.lean\",null,null,\"CategoryTheory.eqToHom_app\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/EqToHom.lean\",null,null,\"CategoryTheory.eqToHom_map\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/EqToHom.lean\",null,null,\"CategoryTheory.eqToHom_map_comp\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/EqToHom.lean\",null,null,\"CategoryTheory.eqToHom_op\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/EqToHom.lean\",null,null,\"CategoryTheory.eqToHom_trans\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/EqToHom.lean\",null,null,\"CategoryTheory.eqToHom_unop\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/EqToHom.lean\",null,null,\"CategoryTheory.eqToIso_map_trans\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/EqToHom.lean\",null,null,\"CategoryTheory.eqToIso_trans\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/EqToHom.lean\",null,null,\"CategoryTheory.eq_conj_eqToHom\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/EqToHom.lean\",null,null,\"CategoryTheory.inv_eqToHom\"]"
+  ]
+}

manifests/batches/mathlib/000638.json

@@ -0,0 +1,820 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "mathlib/000638",
+  "batch_fingerprint": "7cb16ed543d69fa0dfe3de0cc6f3aa23e78ecf49cc9647b95d57ba9edf050986",
+  "evidence": {
+    "batch_fingerprint": "7cb16ed543d69fa0dfe3de0cc6f3aa23e78ecf49cc9647b95d57ba9edf050986",
+    "contamination_matches": [],
+    "failures": [
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Equivalence.Equivalence_mk'_counit",
+        "id": "CategoryTheory.Equivalence.Equivalence_mk'_counit",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            137,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Equivalence.lean",
+          "full_name": "CategoryTheory.Equivalence.Equivalence_mk'_counit",
+          "start": [
+            135,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Equivalence.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Equivalence.Equivalence_mk'_unit",
+        "id": "CategoryTheory.Equivalence.Equivalence_mk'_unit",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            131,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Equivalence.lean",
+          "full_name": "CategoryTheory.Equivalence.Equivalence_mk'_unit",
+          "start": [
+            129,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Equivalence.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Equivalence.Equivalence_mk'_unitInv",
+        "id": "CategoryTheory.Equivalence.Equivalence_mk'_unitInv",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            143,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Equivalence.lean",
+          "full_name": "CategoryTheory.Equivalence.Equivalence_mk'_unitInv",
+          "start": [
+            141,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Equivalence.lean"
+      },
+      {
+        "error": "no internal trace for tactic 'clear this'",
+        "full_name": "CategoryTheory.Equivalence.adjointify_\u03b7_\u03b5",
+        "id": "CategoryTheory.Equivalence.adjointify_\u03b7_\u03b5",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            267,
+            83
+          ],
+          "file_path": "Mathlib/CategoryTheory/Equivalence.lean",
+          "full_name": "CategoryTheory.Equivalence.adjointify_\u03b7_\u03b5",
+          "start": [
+            259,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"dsimp [<a>adjointify\\u03b7<\\/a>,<a>Trans.trans<\\/a>]\"",
+                "[{\"full_name\":\"CategoryTheory.Equivalence.adjointify\\u03b7\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Equivalence.lean\",\"def_pos\":[247,5],\"def_end_pos\":[247,16]},{\"full_name\":\"Trans.trans\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[1163,3],\"def_end_pos\":[1163,8]}]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\n\u22a2 F.map\n        ((((((\u03b7.hom.app X \u226b \ud835\udfd9 (G.obj (F.obj X))) \u226b G.map (\u03b5.inv.app (F.obj X))) \u226b \ud835\udfd9 (G.obj (F.obj (G.obj (F.obj X))))) \u226b\n              \ud835\udfd9 (G.obj (F.obj (G.obj (F.obj X))))) \u226b\n            G.map (F.map (\u03b7.inv.app X))) \u226b\n          \ud835\udfd9 (G.obj (F.obj X))) \u226b\n      \u03b5.hom.app (F.obj X) =\n    \ud835\udfd9 (F.obj X)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\n\u22a2 F.map ((adjointify\u03b7 \u03b7 \u03b5).hom.app X) \u226b \u03b5.hom.app (F.obj X) = \ud835\udfd9 (F.obj X)",
+              "tactic": "dsimp [adjointify\u03b7,Trans.trans]"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp only [<a>comp_id<\\/a>, <a>assoc<\\/a>, <a>map_comp<\\/a>]\"",
+                "[{\"full_name\":\"CategoryTheory.Category.comp_id\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[179,3],\"def_end_pos\":[179,10]},{\"full_name\":\"CategoryTheory.Category.assoc\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[181,3],\"def_end_pos\":[181,8]},{\"full_name\":\"CategoryTheory.Functor.map_comp\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Functor\\/Basic.lean\",\"def_pos\":[43,3],\"def_end_pos\":[43,11]}]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\n\u22a2 F.map (\u03b7.hom.app X) \u226b\n      F.map (G.map (\u03b5.inv.app (F.obj X))) \u226b F.map (G.map (F.map (\u03b7.inv.app X))) \u226b \u03b5.hom.app (F.obj X) =\n    \ud835\udfd9 (F.obj X)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\n\u22a2 F.map\n        ((((((\u03b7.hom.app X \u226b \ud835\udfd9 (G.obj (F.obj X))) \u226b G.map (\u03b5.inv.app (F.obj X))) \u226b \ud835\udfd9 (G.obj (F.obj (G.obj (F.obj X))))) \u226b\n              \ud835\udfd9 (G.obj (F.obj (G.obj (F.obj X))))) \u226b\n            G.map (F.map (\u03b7.inv.app X))) \u226b\n          \ud835\udfd9 (G.obj (F.obj X))) \u226b\n      \u03b5.hom.app (F.obj X) =\n    \ud835\udfd9 (F.obj X)",
+              "tactic": "simp only [comp_id, assoc, map_comp]"
+            },
+            {
+              "annotated_tactic": [
+                "\"have := \\u03b5.hom.naturality (F.map (\\u03b7.inv.app X))\"",
+                "[]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\nthis :\n  (G \u22d9 F).map (F.map (\u03b7.inv.app X)) \u226b \u03b5.hom.app (F.obj ((\ud835\udfed C).obj X)) =\n    \u03b5.hom.app (F.obj ((F \u22d9 G).obj X)) \u226b (\ud835\udfed D).map (F.map (\u03b7.inv.app X))\n\u22a2 F.map (\u03b7.hom.app X) \u226b\n      F.map (G.map (\u03b5.inv.app (F.obj X))) \u226b F.map (G.map (F.map (\u03b7.inv.app X))) \u226b \u03b5.hom.app (F.obj X) =\n    \ud835\udfd9 (F.obj X)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\n\u22a2 F.map (\u03b7.hom.app X) \u226b\n      F.map (G.map (\u03b5.inv.app (F.obj X))) \u226b F.map (G.map (F.map (\u03b7.inv.app X))) \u226b \u03b5.hom.app (F.obj X) =\n    \ud835\udfd9 (F.obj X)",
+              "tactic": "have := \u03b5.hom.naturality (F.map (\u03b7.inv.app X))"
+            },
+            {
+              "annotated_tactic": [
+                "\"dsimp at this\"",
+                "[]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\nthis :\n  F.map (G.map (F.map (\u03b7.inv.app X))) \u226b \u03b5.hom.app (F.obj X) = \u03b5.hom.app (F.obj (G.obj (F.obj X))) \u226b F.map (\u03b7.inv.app X)\n\u22a2 F.map (\u03b7.hom.app X) \u226b\n      F.map (G.map (\u03b5.inv.app (F.obj X))) \u226b F.map (G.map (F.map (\u03b7.inv.app X))) \u226b \u03b5.hom.app (F.obj X) =\n    \ud835\udfd9 (F.obj X)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\nthis :\n  (G \u22d9 F).map (F.map (\u03b7.inv.app X)) \u226b \u03b5.hom.app (F.obj ((\ud835\udfed C).obj X)) =\n    \u03b5.hom.app (F.obj ((F \u22d9 G).obj X)) \u226b (\ud835\udfed D).map (F.map (\u03b7.inv.app X))\n\u22a2 F.map (\u03b7.hom.app X) \u226b\n      F.map (G.map (\u03b5.inv.app (F.obj X))) \u226b F.map (G.map (F.map (\u03b7.inv.app X))) \u226b \u03b5.hom.app (F.obj X) =\n    \ud835\udfd9 (F.obj X)",
+              "tactic": "dsimp at this"
+            },
+            {
+              "annotated_tactic": [
+                "\"rw [this]\"",
+                "[]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\nthis :\n  F.map (G.map (F.map (\u03b7.inv.app X))) \u226b \u03b5.hom.app (F.obj X) = \u03b5.hom.app (F.obj (G.obj (F.obj X))) \u226b F.map (\u03b7.inv.app X)\n\u22a2 F.map (\u03b7.hom.app X) \u226b\n      F.map (G.map (\u03b5.inv.app (F.obj X))) \u226b \u03b5.hom.app (F.obj (G.obj (F.obj X))) \u226b F.map (\u03b7.inv.app X) =\n    \ud835\udfd9 (F.obj X)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\nthis :\n  F.map (G.map (F.map (\u03b7.inv.app X))) \u226b \u03b5.hom.app (F.obj X) = \u03b5.hom.app (F.obj (G.obj (F.obj X))) \u226b F.map (\u03b7.inv.app X)\n\u22a2 F.map (\u03b7.hom.app X) \u226b\n      F.map (G.map (\u03b5.inv.app (F.obj X))) \u226b F.map (G.map (F.map (\u03b7.inv.app X))) \u226b \u03b5.hom.app (F.obj X) =\n    \ud835\udfd9 (F.obj X)",
+              "tactic": "rw [this]"
+            },
+            {
+              "annotated_tactic": [
+                "\"clear this\"",
+                "[]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\n\u22a2 F.map (\u03b7.hom.app X) \u226b\n      F.map (G.map (\u03b5.inv.app (F.obj X))) \u226b \u03b5.hom.app (F.obj (G.obj (F.obj X))) \u226b F.map (\u03b7.inv.app X) =\n    \ud835\udfd9 (F.obj X)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\nthis :\n  F.map (G.map (F.map (\u03b7.inv.app X))) \u226b \u03b5.hom.app (F.obj X) = \u03b5.hom.app (F.obj (G.obj (F.obj X))) \u226b F.map (\u03b7.inv.app X)\n\u22a2 F.map (\u03b7.hom.app X) \u226b\n      F.map (G.map (\u03b5.inv.app (F.obj X))) \u226b \u03b5.hom.app (F.obj (G.obj (F.obj X))) \u226b F.map (\u03b7.inv.app X) =\n    \ud835\udfd9 (F.obj X)",
+              "tactic": "clear this"
+            },
+            {
+              "annotated_tactic": [
+                "\"rw [\\u2190 <a>assoc<\\/a> _ _ (F.map _)]\"",
+                "[{\"full_name\":\"CategoryTheory.Category.assoc\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[181,3],\"def_end_pos\":[181,8]}]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\n\u22a2 F.map (\u03b7.hom.app X) \u226b\n      (F.map (G.map (\u03b5.inv.app (F.obj X))) \u226b \u03b5.hom.app (F.obj (G.obj (F.obj X)))) \u226b F.map (\u03b7.inv.app X) =\n    \ud835\udfd9 (F.obj X)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\n\u22a2 F.map (\u03b7.hom.app X) \u226b\n      F.map (G.map (\u03b5.inv.app (F.obj X))) \u226b \u03b5.hom.app (F.obj (G.obj (F.obj X))) \u226b F.map (\u03b7.inv.app X) =\n    \ud835\udfd9 (F.obj X)",
+              "tactic": "rw [\u2190 assoc _ _ (F.map _)]"
+            },
+            {
+              "annotated_tactic": [
+                "\"have := \\u03b5.hom.naturality (\\u03b5.inv.app <| F.obj X)\"",
+                "[]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\nthis :\n  (G \u22d9 F).map (\u03b5.inv.app (F.obj X)) \u226b \u03b5.hom.app ((G \u22d9 F).obj (F.obj X)) =\n    \u03b5.hom.app ((\ud835\udfed D).obj (F.obj X)) \u226b (\ud835\udfed D).map (\u03b5.inv.app (F.obj X))\n\u22a2 F.map (\u03b7.hom.app X) \u226b\n      (F.map (G.map (\u03b5.inv.app (F.obj X))) \u226b \u03b5.hom.app (F.obj (G.obj (F.obj X)))) \u226b F.map (\u03b7.inv.app X) =\n    \ud835\udfd9 (F.obj X)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\n\u22a2 F.map (\u03b7.hom.app X) \u226b\n      (F.map (G.map (\u03b5.inv.app (F.obj X))) \u226b \u03b5.hom.app (F.obj (G.obj (F.obj X)))) \u226b F.map (\u03b7.inv.app X) =\n    \ud835\udfd9 (F.obj X)",
+              "tactic": "have := \u03b5.hom.naturality (\u03b5.inv.app <| F.obj X)"
+            },
+            {
+              "annotated_tactic": [
+                "\"dsimp at this\"",
+                "[]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\nthis :\n  F.map (G.map (\u03b5.inv.app (F.obj X))) \u226b \u03b5.hom.app (F.obj (G.obj (F.obj X))) = \u03b5.hom.app (F.obj X) \u226b \u03b5.inv.app (F.obj X)\n\u22a2 F.map (\u03b7.hom.app X) \u226b\n      (F.map (G.map (\u03b5.inv.app (F.obj X))) \u226b \u03b5.hom.app (F.obj (G.obj (F.obj X)))) \u226b F.map (\u03b7.inv.app X) =\n    \ud835\udfd9 (F.obj X)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\nthis :\n  (G \u22d9 F).map (\u03b5.inv.app (F.obj X)) \u226b \u03b5.hom.app ((G \u22d9 F).obj (F.obj X)) =\n    \u03b5.hom.app ((\ud835\udfed D).obj (F.obj X)) \u226b (\ud835\udfed D).map (\u03b5.inv.app (F.obj X))\n\u22a2 F.map (\u03b7.hom.app X) \u226b\n      (F.map (G.map (\u03b5.inv.app (F.obj X))) \u226b \u03b5.hom.app (F.obj (G.obj (F.obj X)))) \u226b F.map (\u03b7.inv.app X) =\n    \ud835\udfd9 (F.obj X)",
+              "tactic": "dsimp at this"
+            },
+            {
+              "annotated_tactic": [
+                "\"rw [this]\"",
+                "[]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\nthis :\n  F.map (G.map (\u03b5.inv.app (F.obj X))) \u226b \u03b5.hom.app (F.obj (G.obj (F.obj X))) = \u03b5.hom.app (F.obj X) \u226b \u03b5.inv.app (F.obj X)\n\u22a2 F.map (\u03b7.hom.app X) \u226b (\u03b5.hom.app (F.obj X) \u226b \u03b5.inv.app (F.obj X)) \u226b F.map (\u03b7.inv.app X) = \ud835\udfd9 (F.obj X)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\nthis :\n  F.map (G.map (\u03b5.inv.app (F.obj X))) \u226b \u03b5.hom.app (F.obj (G.obj (F.obj X))) = \u03b5.hom.app (F.obj X) \u226b \u03b5.inv.app (F.obj X)\n\u22a2 F.map (\u03b7.hom.app X) \u226b\n      (F.map (G.map (\u03b5.inv.app (F.obj X))) \u226b \u03b5.hom.app (F.obj (G.obj (F.obj X)))) \u226b F.map (\u03b7.inv.app X) =\n    \ud835\udfd9 (F.obj X)",
+              "tactic": "rw [this]"
+            },
+            {
+              "annotated_tactic": [
+                "\"clear this\"",
+                "[]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\n\u22a2 F.map (\u03b7.hom.app X) \u226b (\u03b5.hom.app (F.obj X) \u226b \u03b5.inv.app (F.obj X)) \u226b F.map (\u03b7.inv.app X) = \ud835\udfd9 (F.obj X)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\nthis :\n  F.map (G.map (\u03b5.inv.app (F.obj X))) \u226b \u03b5.hom.app (F.obj (G.obj (F.obj X))) = \u03b5.hom.app (F.obj X) \u226b \u03b5.inv.app (F.obj X)\n\u22a2 F.map (\u03b7.hom.app X) \u226b (\u03b5.hom.app (F.obj X) \u226b \u03b5.inv.app (F.obj X)) \u226b F.map (\u03b7.inv.app X) = \ud835\udfd9 (F.obj X)",
+              "tactic": "clear this"
+            },
+            {
+              "annotated_tactic": [
+                "\"have := (\\u03b5.app <| F.obj X).<a>hom_inv_id<\\/a>\"",
+                "[{\"full_name\":\"CategoryTheory.Iso.hom_inv_id\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Iso.lean\",\"def_pos\":[57,3],\"def_end_pos\":[57,13]}]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\nthis : (\u03b5.app (F.obj X)).hom \u226b (\u03b5.app (F.obj X)).inv = \ud835\udfd9 ((G \u22d9 F).obj (F.obj X))\n\u22a2 F.map (\u03b7.hom.app X) \u226b (\u03b5.hom.app (F.obj X) \u226b \u03b5.inv.app (F.obj X)) \u226b F.map (\u03b7.inv.app X) = \ud835\udfd9 (F.obj X)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\n\u22a2 F.map (\u03b7.hom.app X) \u226b (\u03b5.hom.app (F.obj X) \u226b \u03b5.inv.app (F.obj X)) \u226b F.map (\u03b7.inv.app X) = \ud835\udfd9 (F.obj X)",
+              "tactic": "have := (\u03b5.app <| F.obj X).hom_inv_id"
+            },
+            {
+              "annotated_tactic": [
+                "\"dsimp at this\"",
+                "[]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\nthis : \u03b5.hom.app (F.obj X) \u226b \u03b5.inv.app (F.obj X) = \ud835\udfd9 (F.obj (G.obj (F.obj X)))\n\u22a2 F.map (\u03b7.hom.app X) \u226b (\u03b5.hom.app (F.obj X) \u226b \u03b5.inv.app (F.obj X)) \u226b F.map (\u03b7.inv.app X) = \ud835\udfd9 (F.obj X)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\nthis : (\u03b5.app (F.obj X)).hom \u226b (\u03b5.app (F.obj X)).inv = \ud835\udfd9 ((G \u22d9 F).obj (F.obj X))\n\u22a2 F.map (\u03b7.hom.app X) \u226b (\u03b5.hom.app (F.obj X) \u226b \u03b5.inv.app (F.obj X)) \u226b F.map (\u03b7.inv.app X) = \ud835\udfd9 (F.obj X)",
+              "tactic": "dsimp at this"
+            },
+            {
+              "annotated_tactic": [
+                "\"rw [this]\"",
+                "[]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\nthis : \u03b5.hom.app (F.obj X) \u226b \u03b5.inv.app (F.obj X) = \ud835\udfd9 (F.obj (G.obj (F.obj X)))\n\u22a2 F.map (\u03b7.hom.app X) \u226b \ud835\udfd9 (F.obj (G.obj (F.obj X))) \u226b F.map (\u03b7.inv.app X) = \ud835\udfd9 (F.obj X)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\nthis : \u03b5.hom.app (F.obj X) \u226b \u03b5.inv.app (F.obj X) = \ud835\udfd9 (F.obj (G.obj (F.obj X)))\n\u22a2 F.map (\u03b7.hom.app X) \u226b (\u03b5.hom.app (F.obj X) \u226b \u03b5.inv.app (F.obj X)) \u226b F.map (\u03b7.inv.app X) = \ud835\udfd9 (F.obj X)",
+              "tactic": "rw [this]"
+            },
+            {
+              "annotated_tactic": [
+                "\"clear this\"",
+                "[]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\n\u22a2 F.map (\u03b7.hom.app X) \u226b \ud835\udfd9 (F.obj (G.obj (F.obj X))) \u226b F.map (\u03b7.inv.app X) = \ud835\udfd9 (F.obj X)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\nthis : \u03b5.hom.app (F.obj X) \u226b \u03b5.inv.app (F.obj X) = \ud835\udfd9 (F.obj (G.obj (F.obj X)))\n\u22a2 F.map (\u03b7.hom.app X) \u226b \ud835\udfd9 (F.obj (G.obj (F.obj X))) \u226b F.map (\u03b7.inv.app X) = \ud835\udfd9 (F.obj X)",
+              "tactic": "clear this"
+            },
+            {
+              "annotated_tactic": [
+                "\"rw [<a>id_comp<\\/a>]\"",
+                "[{\"full_name\":\"CategoryTheory.Category.id_comp\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[177,3],\"def_end_pos\":[177,10]}]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\n\u22a2 F.map (\u03b7.hom.app X) \u226b F.map (\u03b7.inv.app X) = \ud835\udfd9 (F.obj X)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\n\u22a2 F.map (\u03b7.hom.app X) \u226b \ud835\udfd9 (F.obj (G.obj (F.obj X))) \u226b F.map (\u03b7.inv.app X) = \ud835\udfd9 (F.obj X)",
+              "tactic": "rw [id_comp]"
+            },
+            {
+              "annotated_tactic": [
+                "\"have := (F.mapIso <| \\u03b7.app X).<a>hom_inv_id<\\/a>\"",
+                "[{\"full_name\":\"CategoryTheory.Iso.hom_inv_id\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Iso.lean\",\"def_pos\":[57,3],\"def_end_pos\":[57,13]}]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\nthis : (F.mapIso (\u03b7.app X)).hom \u226b (F.mapIso (\u03b7.app X)).inv = \ud835\udfd9 (F.obj ((\ud835\udfed C).obj X))\n\u22a2 F.map (\u03b7.hom.app X) \u226b F.map (\u03b7.inv.app X) = \ud835\udfd9 (F.obj X)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\n\u22a2 F.map (\u03b7.hom.app X) \u226b F.map (\u03b7.inv.app X) = \ud835\udfd9 (F.obj X)",
+              "tactic": "have := (F.mapIso <| \u03b7.app X).hom_inv_id"
+            },
+            {
+              "annotated_tactic": [
+                "\"dsimp at this\"",
+                "[]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\nthis : F.map (\u03b7.hom.app X) \u226b F.map (\u03b7.inv.app X) = \ud835\udfd9 (F.obj X)\n\u22a2 F.map (\u03b7.hom.app X) \u226b F.map (\u03b7.inv.app X) = \ud835\udfd9 (F.obj X)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\nthis : (F.mapIso (\u03b7.app X)).hom \u226b (F.mapIso (\u03b7.app X)).inv = \ud835\udfd9 (F.obj ((\ud835\udfed C).obj X))\n\u22a2 F.map (\u03b7.hom.app X) \u226b F.map (\u03b7.inv.app X) = \ud835\udfd9 (F.obj X)",
+              "tactic": "dsimp at this"
+            },
+            {
+              "annotated_tactic": [
+                "\"rw [this]\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\nG : D \u2964 C\n\u03b7 : \ud835\udfed C \u2245 F \u22d9 G\n\u03b5 : G \u22d9 F \u2245 \ud835\udfed D\nX : C\nthis : F.map (\u03b7.hom.app X) \u226b F.map (\u03b7.inv.app X) = \ud835\udfd9 (F.obj X)\n\u22a2 F.map (\u03b7.hom.app X) \u226b F.map (\u03b7.inv.app X) = \ud835\udfd9 (F.obj X)",
+              "tactic": "rw [this]"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Equivalence.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Equivalence.fun_inv_map",
+        "id": "CategoryTheory.Equivalence.fun_inv_map",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            230,
+            43
+          ],
+          "file_path": "Mathlib/CategoryTheory/Equivalence.lean",
+          "full_name": "CategoryTheory.Equivalence.fun_inv_map",
+          "start": [
+            228,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Equivalence.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Equivalence.functor_unit_comp",
+        "id": "CategoryTheory.Equivalence.functor_unit_comp",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            155,
+            27
+          ],
+          "file_path": "Mathlib/CategoryTheory/Equivalence.lean",
+          "full_name": "CategoryTheory.Equivalence.functor_unit_comp",
+          "start": [
+            153,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Equivalence.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Equivalence.inv_fun_map",
+        "id": "CategoryTheory.Equivalence.inv_fun_map",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            236,
+            41
+          ],
+          "file_path": "Mathlib/CategoryTheory/Equivalence.lean",
+          "full_name": "CategoryTheory.Equivalence.inv_fun_map",
+          "start": [
+            234,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Equivalence.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Equivalence.pow_neg_one",
+        "id": "CategoryTheory.Equivalence.pow_neg_one",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            465,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Equivalence.lean",
+          "full_name": "CategoryTheory.Equivalence.pow_neg_one",
+          "start": [
+            464,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Equivalence.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Equivalence.pow_one",
+        "id": "CategoryTheory.Equivalence.pow_one",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            460,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Equivalence.lean",
+          "full_name": "CategoryTheory.Equivalence.pow_one",
+          "start": [
+            459,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Equivalence.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Equivalence.pow_zero",
+        "id": "CategoryTheory.Equivalence.pow_zero",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            455,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/Equivalence.lean",
+          "full_name": "CategoryTheory.Equivalence.pow_zero",
+          "start": [
+            454,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Equivalence.lean"
+      },
+      {
+        "error": "no internal trace for tactic 'slice_lhs 2 3 => erw [\u2190 map_comp e.inverse, e.counitIso.inv.naturality, map_comp]'",
+        "full_name": "CategoryTheory.Equivalence.unit_inverse_comp",
+        "id": "CategoryTheory.Equivalence.unit_inverse_comp",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            203,
+            51
+          ],
+          "file_path": "Mathlib/CategoryTheory/Equivalence.lean",
+          "full_name": "CategoryTheory.Equivalence.unit_inverse_comp",
+          "start": [
+            182,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"rw [\\u2190 <a>id_comp<\\/a> (e.inverse.map _), \\u2190 <a>map_id<\\/a> e.inverse, \\u2190 <a>counitInv_functor_comp<\\/a>, <a>map_comp<\\/a>]\"",
+                "[{\"full_name\":\"CategoryTheory.Category.id_comp\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[177,3],\"def_end_pos\":[177,10]},{\"full_name\":\"CategoryTheory.Functor.map_id\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Functor\\/Basic.lean\",\"def_pos\":[41,3],\"def_end_pos\":[41,9]},{\"full_name\":\"CategoryTheory.Equivalence.counitInv_functor_comp\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Equivalence.lean\",\"def_pos\":[159,9],\"def_end_pos\":[159,31]},{\"full_name\":\"CategoryTheory.Functor.map_comp\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Functor\\/Basic.lean\",\"def_pos\":[43,3],\"def_end_pos\":[43,11]}]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 e.unit.app (e.inverse.obj Y) \u226b\n      (e.inverse.map (e.counitInv.app (e.functor.obj (e.inverse.obj Y))) \u226b\n          e.inverse.map (e.functor.map (e.unitInv.app (e.inverse.obj Y)))) \u226b\n        e.inverse.map (e.counit.app Y) =\n    \ud835\udfd9 (e.inverse.obj Y)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 e.unit.app (e.inverse.obj Y) \u226b e.inverse.map (e.counit.app Y) = \ud835\udfd9 (e.inverse.obj Y)",
+              "tactic": "rw [\u2190 id_comp (e.inverse.map _), \u2190 map_id e.inverse, \u2190 counitInv_functor_comp, map_comp]"
+            },
+            {
+              "annotated_tactic": [
+                "\"rw [\\u2190 <a>Iso.hom_inv_id_assoc<\\/a> (e.unitIso.app _) (e.inverse.map (e.functor.map _)), <a>app_hom<\\/a>, <a>app_inv<\\/a>]\"",
+                "[{\"full_name\":\"CategoryTheory.Iso.hom_inv_id_assoc\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Iso.lean\",\"def_pos\":[67,12],\"def_end_pos\":[67,34]},{\"full_name\":\"CategoryTheory.NatIso.app_hom\",\"def_path\":\"Mathlib\\/CategoryTheory\\/NatIso.lean\",\"def_pos\":[89,9],\"def_end_pos\":[89,16]},{\"full_name\":\"CategoryTheory.NatIso.app_inv\",\"def_path\":\"Mathlib\\/CategoryTheory\\/NatIso.lean\",\"def_pos\":[93,9],\"def_end_pos\":[93,16]}]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 e.unit.app (e.inverse.obj Y) \u226b\n      (e.inverse.map (e.counitInv.app (e.functor.obj (e.inverse.obj Y))) \u226b\n          e.unitIso.hom.app\n              (e.inverse.toPrefunctor.1 (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y))))) \u226b\n            e.unitIso.inv.app\n                (e.inverse.toPrefunctor.1 (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y))))) \u226b\n              e.inverse.map (e.functor.map (e.unitInv.app (e.inverse.obj Y)))) \u226b\n        e.inverse.map (e.counit.app Y) =\n    \ud835\udfd9 (e.inverse.obj Y)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 e.unit.app (e.inverse.obj Y) \u226b\n      (e.inverse.map (e.counitInv.app (e.functor.obj (e.inverse.obj Y))) \u226b\n          e.inverse.map (e.functor.map (e.unitInv.app (e.inverse.obj Y)))) \u226b\n        e.inverse.map (e.counit.app Y) =\n    \ud835\udfd9 (e.inverse.obj Y)",
+              "tactic": "rw [\u2190 Iso.hom_inv_id_assoc (e.unitIso.app _) (e.inverse.map (e.functor.map _)), app_hom, app_inv]"
+            },
+            {
+              "annotated_tactic": [
+                "\"slice_lhs 2 3 => erw [e.unit.naturality]\"",
+                "[]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 e.unit.app (e.inverse.obj Y) \u226b\n      (((e.unit.app (e.inverse.toPrefunctor.1 (e.functor.obj (e.inverse.obj Y))) \u226b\n              (e.functor \u22d9 e.inverse).map\n                (e.inverse.toPrefunctor.2 (e.counitInv.app (e.functor.obj (e.inverse.obj Y))))) \u226b\n            e.unitIso.inv.app\n              (e.inverse.toPrefunctor.1 (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))) \u226b\n          e.inverse.map (e.functor.map (e.unitInv.app (e.inverse.obj Y)))) \u226b\n        e.inverse.map (e.counit.app Y) =\n    \ud835\udfd9 (e.inverse.obj Y)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 e.unit.app (e.inverse.obj Y) \u226b\n      (e.inverse.map (e.counitInv.app (e.functor.obj (e.inverse.obj Y))) \u226b\n          e.unitIso.hom.app\n              (e.inverse.toPrefunctor.1 (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y))))) \u226b\n            e.unitIso.inv.app\n                (e.inverse.toPrefunctor.1 (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y))))) \u226b\n              e.inverse.map (e.functor.map (e.unitInv.app (e.inverse.obj Y)))) \u226b\n        e.inverse.map (e.counit.app Y) =\n    \ud835\udfd9 (e.inverse.obj Y)",
+              "tactic": "slice_lhs 2 3 => erw [e.unit.naturality]"
+            },
+            {
+              "annotated_tactic": [
+                "\"slice_lhs 1 2 => erw [e.unit.naturality]\"",
+                "[]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 ((((e.unit.app ((\ud835\udfed C).obj (e.inverse.obj Y)) \u226b (e.functor \u22d9 e.inverse).map (e.unit.1 (e.inverse.obj Y))) \u226b\n            (e.functor \u22d9 e.inverse).map\n              (e.inverse.toPrefunctor.2 (e.counitInv.app (e.functor.obj (e.inverse.obj Y))))) \u226b\n          e.unitIso.inv.app\n            (e.inverse.toPrefunctor.1 (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))) \u226b\n        e.inverse.map (e.functor.map (e.unitInv.app (e.inverse.obj Y)))) \u226b\n      e.inverse.map (e.counit.app Y) =\n    \ud835\udfd9 (e.inverse.obj Y)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 e.unit.app (e.inverse.obj Y) \u226b\n      (((e.unit.app (e.inverse.toPrefunctor.1 (e.functor.obj (e.inverse.obj Y))) \u226b\n              (e.functor \u22d9 e.inverse).map\n                (e.inverse.toPrefunctor.2 (e.counitInv.app (e.functor.obj (e.inverse.obj Y))))) \u226b\n            e.unitIso.inv.app\n              (e.inverse.toPrefunctor.1 (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))) \u226b\n          e.inverse.map (e.functor.map (e.unitInv.app (e.inverse.obj Y)))) \u226b\n        e.inverse.map (e.counit.app Y) =\n    \ud835\udfd9 (e.inverse.obj Y)",
+              "tactic": "slice_lhs 1 2 => erw [e.unit.naturality]"
+            },
+            {
+              "annotated_tactic": [
+                "\"slice_lhs 4 4 =>\\n    rw [\\u2190 <a>Iso.hom_inv_id_assoc<\\/a> (e.inverse.mapIso (e.counitIso.app _)) (e.unitInv.app _)]\"",
+                "[{\"full_name\":\"CategoryTheory.Iso.hom_inv_id_assoc\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Iso.lean\",\"def_pos\":[67,12],\"def_end_pos\":[67,34]}]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 e.unit.app ((\ud835\udfed C).obj (e.inverse.obj Y)) \u226b\n      (e.functor \u22d9 e.inverse).map (e.unit.1 (e.inverse.obj Y)) \u226b\n        (e.functor \u22d9 e.inverse).map (e.inverse.toPrefunctor.2 (e.counitInv.app (e.functor.obj (e.inverse.obj Y)))) \u226b\n          (((e.inverse.mapIso (e.counitIso.app (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))).hom \u226b\n                (e.inverse.mapIso\n                      (e.counitIso.app (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))).inv \u226b\n                  e.unitInv.app (e.inverse.obj (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))) \u226b\n              e.inverse.map (e.functor.map (e.unitInv.app (e.inverse.obj Y)))) \u226b\n            e.inverse.map (e.counit.app Y) =\n    \ud835\udfd9 (e.inverse.obj Y)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 ((((e.unit.app ((\ud835\udfed C).obj (e.inverse.obj Y)) \u226b (e.functor \u22d9 e.inverse).map (e.unit.1 (e.inverse.obj Y))) \u226b\n            (e.functor \u22d9 e.inverse).map\n              (e.inverse.toPrefunctor.2 (e.counitInv.app (e.functor.obj (e.inverse.obj Y))))) \u226b\n          e.unitIso.inv.app\n            (e.inverse.toPrefunctor.1 (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))) \u226b\n        e.inverse.map (e.functor.map (e.unitInv.app (e.inverse.obj Y)))) \u226b\n      e.inverse.map (e.counit.app Y) =\n    \ud835\udfd9 (e.inverse.obj Y)",
+              "tactic": "slice_lhs 4 4 =>\n  rw [\u2190 Iso.hom_inv_id_assoc (e.inverse.mapIso (e.counitIso.app _)) (e.unitInv.app _)]"
+            },
+            {
+              "annotated_tactic": [
+                "\"slice_lhs 3 4 =>\\n    erw [\\u2190 <a>map_comp<\\/a> e.inverse, e.counit.naturality]\\n    erw [(e.counitIso.app _).<a>hom_inv_id<\\/a>, <a>map_id<\\/a>]\"",
+                "[{\"full_name\":\"CategoryTheory.Functor.map_comp\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Functor\\/Basic.lean\",\"def_pos\":[43,3],\"def_end_pos\":[43,11]},{\"full_name\":\"CategoryTheory.Iso.hom_inv_id\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Iso.lean\",\"def_pos\":[57,3],\"def_end_pos\":[57,13]},{\"full_name\":\"CategoryTheory.Functor.map_id\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Functor\\/Basic.lean\",\"def_pos\":[41,3],\"def_end_pos\":[41,9]}]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 e.unit.app ((\ud835\udfed C).obj (e.inverse.obj Y)) \u226b\n      (e.functor \u22d9 e.inverse).map (e.unit.1 (e.inverse.obj Y)) \u226b\n        (((\ud835\udfd9 (e.inverse.obj (e.functor.obj (e.inverse.toPrefunctor.1 (e.functor.obj (e.inverse.obj Y))))) \u226b\n                (e.inverse.mapIso\n                    (e.counitIso.app (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))).inv) \u226b\n              e.unitInv.app (e.inverse.obj (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))) \u226b\n            e.inverse.map (e.functor.map (e.unitInv.app (e.inverse.obj Y)))) \u226b\n          e.inverse.map (e.counit.app Y) =\n    \ud835\udfd9 (e.inverse.obj Y)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 e.unit.app ((\ud835\udfed C).obj (e.inverse.obj Y)) \u226b\n      (e.functor \u22d9 e.inverse).map (e.unit.1 (e.inverse.obj Y)) \u226b\n        (e.functor \u22d9 e.inverse).map (e.inverse.toPrefunctor.2 (e.counitInv.app (e.functor.obj (e.inverse.obj Y)))) \u226b\n          (((e.inverse.mapIso (e.counitIso.app (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))).hom \u226b\n                (e.inverse.mapIso\n                      (e.counitIso.app (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))).inv \u226b\n                  e.unitInv.app (e.inverse.obj (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))) \u226b\n              e.inverse.map (e.functor.map (e.unitInv.app (e.inverse.obj Y)))) \u226b\n            e.inverse.map (e.counit.app Y) =\n    \ud835\udfd9 (e.inverse.obj Y)",
+              "tactic": "slice_lhs 3 4 =>\n  erw [\u2190 map_comp e.inverse, e.counit.naturality]\n  erw [(e.counitIso.app _).hom_inv_id, map_id]"
+            },
+            {
+              "annotated_tactic": [
+                "\"erw [<a>id_comp<\\/a>]\"",
+                "[{\"full_name\":\"CategoryTheory.Category.id_comp\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[177,3],\"def_end_pos\":[177,10]}]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 e.unit.app ((\ud835\udfed C).obj (e.inverse.obj Y)) \u226b\n      (e.functor \u22d9 e.inverse).map (e.unit.1 (e.inverse.obj Y)) \u226b\n        (((e.inverse.mapIso (e.counitIso.app (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))).inv \u226b\n              e.unitInv.app (e.inverse.obj (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))) \u226b\n            e.inverse.map (e.functor.map (e.unitInv.app (e.inverse.obj Y)))) \u226b\n          e.inverse.map (e.counit.app Y) =\n    \ud835\udfd9 (e.inverse.obj Y)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 e.unit.app ((\ud835\udfed C).obj (e.inverse.obj Y)) \u226b\n      (e.functor \u22d9 e.inverse).map (e.unit.1 (e.inverse.obj Y)) \u226b\n        (((\ud835\udfd9 (e.inverse.obj (e.functor.obj (e.inverse.toPrefunctor.1 (e.functor.obj (e.inverse.obj Y))))) \u226b\n                (e.inverse.mapIso\n                    (e.counitIso.app (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))).inv) \u226b\n              e.unitInv.app (e.inverse.obj (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))) \u226b\n            e.inverse.map (e.functor.map (e.unitInv.app (e.inverse.obj Y)))) \u226b\n          e.inverse.map (e.counit.app Y) =\n    \ud835\udfd9 (e.inverse.obj Y)",
+              "tactic": "erw [id_comp]"
+            },
+            {
+              "annotated_tactic": [
+                "\"slice_lhs 2 3 => erw [\\u2190 <a>map_comp<\\/a> e.inverse, e.counitIso.inv.naturality, <a>map_comp<\\/a>]\"",
+                "[{\"full_name\":\"CategoryTheory.Functor.map_comp\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Functor\\/Basic.lean\",\"def_pos\":[43,3],\"def_end_pos\":[43,11]},{\"full_name\":\"CategoryTheory.Functor.map_comp\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Functor\\/Basic.lean\",\"def_pos\":[43,3],\"def_end_pos\":[43,11]}]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 e.unit.app ((\ud835\udfed C).obj (e.inverse.obj Y)) \u226b\n      (((e.inverse.map (e.counitIso.inv.app (e.functor.toPrefunctor.1 ((\ud835\udfed C).obj (e.inverse.obj Y)))) \u226b\n              e.inverse.map ((e.inverse \u22d9 e.functor).map (e.functor.toPrefunctor.2 (e.unit.1 (e.inverse.obj Y))))) \u226b\n            e.unitInv.app (e.inverse.obj (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))) \u226b\n          e.inverse.map (e.functor.map (e.unitInv.app (e.inverse.obj Y)))) \u226b\n        e.inverse.map (e.counit.app Y) =\n    \ud835\udfd9 (e.inverse.obj Y)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 e.unit.app ((\ud835\udfed C).obj (e.inverse.obj Y)) \u226b\n      (e.functor \u22d9 e.inverse).map (e.unit.1 (e.inverse.obj Y)) \u226b\n        (((e.inverse.mapIso (e.counitIso.app (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))).inv \u226b\n              e.unitInv.app (e.inverse.obj (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))) \u226b\n            e.inverse.map (e.functor.map (e.unitInv.app (e.inverse.obj Y)))) \u226b\n          e.inverse.map (e.counit.app Y) =\n    \ud835\udfd9 (e.inverse.obj Y)",
+              "tactic": "slice_lhs 2 3 => erw [\u2190 map_comp e.inverse, e.counitIso.inv.naturality, map_comp]"
+            },
+            {
+              "annotated_tactic": [
+                "\"slice_lhs 3 4 => erw [e.unitInv.naturality]\"",
+                "[]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 e.unit.app ((\ud835\udfed C).obj (e.inverse.obj Y)) \u226b\n      e.inverse.map (e.counitIso.inv.app (e.functor.toPrefunctor.1 ((\ud835\udfed C).obj (e.inverse.obj Y)))) \u226b\n        ((e.unitInv.app (e.inverse.obj (e.functor.toPrefunctor.1 ((\ud835\udfed C).obj (e.inverse.obj Y)))) \u226b\n              (\ud835\udfed C).map (e.inverse.map (e.functor.toPrefunctor.2 (e.unit.1 (e.inverse.obj Y))))) \u226b\n            e.inverse.map (e.functor.map (e.unitInv.app (e.inverse.obj Y)))) \u226b\n          e.inverse.map (e.counit.app Y) =\n    \ud835\udfd9 (e.inverse.obj Y)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 e.unit.app ((\ud835\udfed C).obj (e.inverse.obj Y)) \u226b\n      (((e.inverse.map (e.counitIso.inv.app (e.functor.toPrefunctor.1 ((\ud835\udfed C).obj (e.inverse.obj Y)))) \u226b\n              e.inverse.map ((e.inverse \u22d9 e.functor).map (e.functor.toPrefunctor.2 (e.unit.1 (e.inverse.obj Y))))) \u226b\n            e.unitInv.app (e.inverse.obj (e.functor.obj (e.inverse.obj (e.functor.obj (e.inverse.obj Y)))))) \u226b\n          e.inverse.map (e.functor.map (e.unitInv.app (e.inverse.obj Y)))) \u226b\n        e.inverse.map (e.counit.app Y) =\n    \ud835\udfd9 (e.inverse.obj Y)",
+              "tactic": "slice_lhs 3 4 => erw [e.unitInv.naturality]"
+            },
+            {
+              "annotated_tactic": [
+                "\"slice_lhs 4 5 => erw [\\u2190 <a>map_comp<\\/a> (e.functor \\u22d9 e.inverse), (e.unitIso.app _).<a>hom_inv_id<\\/a>, <a>map_id<\\/a>]\"",
+                "[{\"full_name\":\"CategoryTheory.Functor.map_comp\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Functor\\/Basic.lean\",\"def_pos\":[43,3],\"def_end_pos\":[43,11]},{\"full_name\":\"CategoryTheory.Iso.hom_inv_id\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Iso.lean\",\"def_pos\":[57,3],\"def_end_pos\":[57,13]},{\"full_name\":\"CategoryTheory.Functor.map_id\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Functor\\/Basic.lean\",\"def_pos\":[41,3],\"def_end_pos\":[41,9]}]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 e.unit.app ((\ud835\udfed C).obj (e.inverse.obj Y)) \u226b\n      e.inverse.map (e.counitIso.inv.app (e.functor.toPrefunctor.1 ((\ud835\udfed C).obj (e.inverse.obj Y)))) \u226b\n        e.unitInv.app (e.inverse.obj (e.functor.toPrefunctor.1 ((\ud835\udfed C).obj (e.inverse.obj Y)))) \u226b\n          \ud835\udfd9 ((e.functor \u22d9 e.inverse).obj ((\ud835\udfed C).obj (e.inverse.obj Y))) \u226b e.inverse.map (e.counit.app Y) =\n    \ud835\udfd9 (e.inverse.obj Y)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 e.unit.app ((\ud835\udfed C).obj (e.inverse.obj Y)) \u226b\n      e.inverse.map (e.counitIso.inv.app (e.functor.toPrefunctor.1 ((\ud835\udfed C).obj (e.inverse.obj Y)))) \u226b\n        ((e.unitInv.app (e.inverse.obj (e.functor.toPrefunctor.1 ((\ud835\udfed C).obj (e.inverse.obj Y)))) \u226b\n              (\ud835\udfed C).map (e.inverse.map (e.functor.toPrefunctor.2 (e.unit.1 (e.inverse.obj Y))))) \u226b\n            e.inverse.map (e.functor.map (e.unitInv.app (e.inverse.obj Y)))) \u226b\n          e.inverse.map (e.counit.app Y) =\n    \ud835\udfd9 (e.inverse.obj Y)",
+              "tactic": "slice_lhs 4 5 => erw [\u2190 map_comp (e.functor \u22d9 e.inverse), (e.unitIso.app _).hom_inv_id, map_id]"
+            },
+            {
+              "annotated_tactic": [
+                "\"erw [<a>id_comp<\\/a>]\"",
+                "[{\"full_name\":\"CategoryTheory.Category.id_comp\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[177,3],\"def_end_pos\":[177,10]}]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 e.unit.app ((\ud835\udfed C).obj (e.inverse.obj Y)) \u226b\n      e.inverse.map (e.counitIso.inv.app (e.functor.toPrefunctor.1 ((\ud835\udfed C).obj (e.inverse.obj Y)))) \u226b\n        e.unitInv.app (e.inverse.obj (e.functor.toPrefunctor.1 ((\ud835\udfed C).obj (e.inverse.obj Y)))) \u226b\n          e.inverse.map (e.counit.app Y) =\n    \ud835\udfd9 (e.inverse.obj Y)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 e.unit.app ((\ud835\udfed C).obj (e.inverse.obj Y)) \u226b\n      e.inverse.map (e.counitIso.inv.app (e.functor.toPrefunctor.1 ((\ud835\udfed C).obj (e.inverse.obj Y)))) \u226b\n        e.unitInv.app (e.inverse.obj (e.functor.toPrefunctor.1 ((\ud835\udfed C).obj (e.inverse.obj Y)))) \u226b\n          \ud835\udfd9 ((e.functor \u22d9 e.inverse).obj ((\ud835\udfed C).obj (e.inverse.obj Y))) \u226b e.inverse.map (e.counit.app Y) =\n    \ud835\udfd9 (e.inverse.obj Y)",
+              "tactic": "erw [id_comp]"
+            },
+            {
+              "annotated_tactic": [
+                "\"slice_lhs 3 4 => erw [\\u2190 e.unitInv.naturality]\"",
+                "[]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 e.unit.app ((\ud835\udfed C).obj (e.inverse.obj Y)) \u226b\n      e.inverse.map (e.counitIso.inv.app (e.functor.toPrefunctor.1 ((\ud835\udfed C).obj (e.inverse.obj Y)))) \u226b\n        (e.functor \u22d9 e.inverse).map (e.inverse.toPrefunctor.2 (e.counit.app Y)) \u226b\n          e.unitInv.app (e.inverse.toPrefunctor.1 Y) =\n    \ud835\udfd9 (e.inverse.obj Y)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 e.unit.app ((\ud835\udfed C).obj (e.inverse.obj Y)) \u226b\n      e.inverse.map (e.counitIso.inv.app (e.functor.toPrefunctor.1 ((\ud835\udfed C).obj (e.inverse.obj Y)))) \u226b\n        e.unitInv.app (e.inverse.obj (e.functor.toPrefunctor.1 ((\ud835\udfed C).obj (e.inverse.obj Y)))) \u226b\n          e.inverse.map (e.counit.app Y) =\n    \ud835\udfd9 (e.inverse.obj Y)",
+              "tactic": "slice_lhs 3 4 => erw [\u2190 e.unitInv.naturality]"
+            },
+            {
+              "annotated_tactic": [
+                "\"slice_lhs 2 3 =>\\n    erw [\\u2190 <a>map_comp<\\/a> e.inverse, \\u2190 e.counitIso.inv.naturality, (e.counitIso.app _).<a>hom_inv_id<\\/a>,\\n      <a>map_id<\\/a>]\"",
+                "[{\"full_name\":\"CategoryTheory.Functor.map_comp\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Functor\\/Basic.lean\",\"def_pos\":[43,3],\"def_end_pos\":[43,11]},{\"full_name\":\"CategoryTheory.Iso.hom_inv_id\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Iso.lean\",\"def_pos\":[57,3],\"def_end_pos\":[57,13]},{\"full_name\":\"CategoryTheory.Functor.map_id\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Functor\\/Basic.lean\",\"def_pos\":[41,3],\"def_end_pos\":[41,9]}]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 e.unit.app ((\ud835\udfed C).obj (e.inverse.obj Y)) \u226b\n      \ud835\udfd9 (e.inverse.obj (e.functor.obj ((\ud835\udfed C).obj (e.inverse.obj Y)))) \u226b e.unitInv.app (e.inverse.toPrefunctor.1 Y) =\n    \ud835\udfd9 (e.inverse.obj Y)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 e.unit.app ((\ud835\udfed C).obj (e.inverse.obj Y)) \u226b\n      e.inverse.map (e.counitIso.inv.app (e.functor.toPrefunctor.1 ((\ud835\udfed C).obj (e.inverse.obj Y)))) \u226b\n        (e.functor \u22d9 e.inverse).map (e.inverse.toPrefunctor.2 (e.counit.app Y)) \u226b\n          e.unitInv.app (e.inverse.toPrefunctor.1 Y) =\n    \ud835\udfd9 (e.inverse.obj Y)",
+              "tactic": "slice_lhs 2 3 =>\n  erw [\u2190 map_comp e.inverse, \u2190 e.counitIso.inv.naturality, (e.counitIso.app _).hom_inv_id,\n    map_id]"
+            },
+            {
+              "annotated_tactic": [
+                "\"erw [<a>id_comp<\\/a>, (e.unitIso.app _).<a>hom_inv_id<\\/a>]\"",
+                "[{\"full_name\":\"CategoryTheory.Category.id_comp\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[177,3],\"def_end_pos\":[177,10]},{\"full_name\":\"CategoryTheory.Iso.hom_inv_id\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Iso.lean\",\"def_pos\":[57,3],\"def_end_pos\":[57,13]}]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 \ud835\udfd9 ((\ud835\udfed C).obj ((\ud835\udfed C).obj (e.inverse.obj Y))) = \ud835\udfd9 (e.inverse.obj Y)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 e.unit.app ((\ud835\udfed C).obj (e.inverse.obj Y)) \u226b\n      \ud835\udfd9 (e.inverse.obj (e.functor.obj ((\ud835\udfed C).obj (e.inverse.obj Y)))) \u226b e.unitInv.app (e.inverse.toPrefunctor.1 Y) =\n    \ud835\udfd9 (e.inverse.obj Y)",
+              "tactic": "erw [id_comp, (e.unitIso.app _).hom_inv_id]"
+            },
+            {
+              "annotated_tactic": [
+                "\"rfl\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b9 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d : Category.{v\u2082, u\u2082} D\ne : C \u224c D\nY : D\n\u22a2 \ud835\udfd9 ((\ud835\udfed C).obj ((\ud835\udfed C).obj (e.inverse.obj Y))) = \ud835\udfd9 (e.inverse.obj Y)",
+              "tactic": "rfl"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Equivalence.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Functor.IsEquivalence.mk'",
+        "id": "CategoryTheory.Functor.IsEquivalence.mk'",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            562,
+            67
+          ],
+          "file_path": "Mathlib/CategoryTheory/Equivalence.lean",
+          "full_name": "CategoryTheory.Functor.IsEquivalence.mk'",
+          "start": [
+            558,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Equivalence.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Functor.isEquivalence_iff_of_iso",
+        "id": "CategoryTheory.Functor.isEquivalence_iff_of_iso",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            634,
+            74
+          ],
+          "file_path": "Mathlib/CategoryTheory/Equivalence.lean",
+          "full_name": "CategoryTheory.Functor.isEquivalence_iff_of_iso",
+          "start": [
+            632,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Equivalence.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Functor.isEquivalence_of_iso",
+        "id": "CategoryTheory.Functor.isEquivalence_of_iso",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            630,
+            60
+          ],
+          "file_path": "Mathlib/CategoryTheory/Equivalence.lean",
+          "full_name": "CategoryTheory.Functor.isEquivalence_of_iso",
+          "start": [
+            629,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Equivalence.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Functor.essImage.ofIso",
+        "id": "CategoryTheory.Functor.essImage.ofIso",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            58,
+            40
+          ],
+          "file_path": "Mathlib/CategoryTheory/EssentialImage.lean",
+          "full_name": "CategoryTheory.Functor.essImage.ofIso",
+          "start": [
+            57,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/EssentialImage.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Functor.essImage.ofNatIso",
+        "id": "CategoryTheory.Functor.essImage.ofNatIso",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            66,
+            58
+          ],
+          "file_path": "Mathlib/CategoryTheory/EssentialImage.lean",
+          "full_name": "CategoryTheory.Functor.essImage.ofNatIso",
+          "start": [
+            64,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/EssentialImage.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Functor.essImage_eq_of_natIso",
+        "id": "CategoryTheory.Functor.essImage_eq_of_natIso",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            71,
+            74
+          ],
+          "file_path": "Mathlib/CategoryTheory/EssentialImage.lean",
+          "full_name": "CategoryTheory.Functor.essImage_eq_of_natIso",
+          "start": [
+            70,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/EssentialImage.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Functor.essSurj_of_comp_fully_faithful",
+        "id": "CategoryTheory.Functor.essSurj_of_comp_fully_faithful",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            183,
+            79
+          ],
+          "file_path": "Mathlib/CategoryTheory/EssentialImage.lean",
+          "full_name": "CategoryTheory.Functor.essSurj_of_comp_fully_faithful",
+          "start": [
+            181,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/EssentialImage.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Functor.obj_mem_essImage",
+        "id": "CategoryTheory.Functor.obj_mem_essImage",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            76,
+            20
+          ],
+          "file_path": "Mathlib/CategoryTheory/EssentialImage.lean",
+          "full_name": "CategoryTheory.Functor.obj_mem_essImage",
+          "start": [
+            75,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/EssentialImage.lean"
+      }
+    ],
+    "input_proofs": 42,
+    "input_units": 2,
+    "proofs": 23,
+    "published_proofs": 23,
+    "published_transitions": 39,
+    "replay_failures": [],
+    "transitions": 39,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/mathlib-000638-0000-323fec98ff68c19b.parquet",
+      "sha256": "323fec98ff68c19b95cb913854536d53839c3349a7969ca737a49caae8f46db0",
+      "bytes": 130350,
+      "rows": 32,
+      "revision": "6a3d2d550a5e8f26af70e44381b84ab7563dc62c"
+    },
+    {
+      "path": "data/dev/mathlib-000638-0000-052bd433cbc0ec3f.parquet",
+      "sha256": "052bd433cbc0ec3f51334131b550b3c123dadea1ac2b419bd3e959c223febc36",
+      "bytes": 48748,
+      "rows": 1,
+      "revision": "6a3d2d550a5e8f26af70e44381b84ab7563dc62c"
+    },
+    {
+      "path": "data/internal_test/mathlib-000638-0000-bd5ce374b1ef3c0b.parquet",
+      "sha256": "bd5ce374b1ef3c0b8652a1848e089721e22dc07ebecfe6bb608d898c0e44c91d",
+      "bytes": 55555,
+      "rows": 6,
+      "revision": "6a3d2d550a5e8f26af70e44381b84ab7563dc62c"
+    }
+  ],
+  "proof_ids": [
+    "mathlib:CategoryTheory.Equivalence.cancel_counitInv_right",
+    "mathlib:CategoryTheory.Equivalence.cancel_counitInv_right_assoc",
+    "mathlib:CategoryTheory.Equivalence.cancel_counitInv_right_assoc'",
+    "mathlib:CategoryTheory.Equivalence.cancel_counit_right",
+    "mathlib:CategoryTheory.Equivalence.cancel_unitInv_right",
+    "mathlib:CategoryTheory.Equivalence.cancel_unit_right_assoc",
+    "mathlib:CategoryTheory.Equivalence.cancel_unit_right_assoc'",
+    "mathlib:CategoryTheory.Equivalence.changeFunctor_refl",
+    "mathlib:CategoryTheory.Equivalence.changeFunctor_trans",
+    "mathlib:CategoryTheory.Equivalence.counitInv_app_functor",
+    "mathlib:CategoryTheory.Equivalence.counitInv_functor_comp",
+    "mathlib:CategoryTheory.Equivalence.counit_app_functor",
+    "mathlib:CategoryTheory.Equivalence.funInvIdAssoc_hom_app",
+    "mathlib:CategoryTheory.Equivalence.funInvIdAssoc_inv_app",
+    "mathlib:CategoryTheory.Equivalence.invFunIdAssoc_inv_app",
+    "mathlib:CategoryTheory.Equivalence.inverse_counitInv_comp",
+    "mathlib:CategoryTheory.Equivalence.unitInv_app_inverse",
+    "mathlib:CategoryTheory.Equivalence.unit_app_inverse",
+    "mathlib:CategoryTheory.Functor.essSurj_of_surj",
+    "mathlib:CategoryTheory.Functor.fun_inv_map",
+    "mathlib:CategoryTheory.Functor.inv_fun_map",
+    "mathlib:CategoryTheory.Functor.isEquivalence_of_comp_left",
+    "mathlib:CategoryTheory.Functor.isEquivalence_of_comp_right"
+  ],
+  "proof_keys": [
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Equivalence.lean\",null,null,\"CategoryTheory.Equivalence.cancel_counitInv_right\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Equivalence.lean\",null,null,\"CategoryTheory.Equivalence.cancel_counitInv_right_assoc\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Equivalence.lean\",null,null,\"CategoryTheory.Equivalence.cancel_counitInv_right_assoc'\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Equivalence.lean\",null,null,\"CategoryTheory.Equivalence.cancel_counit_right\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Equivalence.lean\",null,null,\"CategoryTheory.Equivalence.cancel_unitInv_right\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Equivalence.lean\",null,null,\"CategoryTheory.Equivalence.cancel_unit_right_assoc\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Equivalence.lean\",null,null,\"CategoryTheory.Equivalence.cancel_unit_right_assoc'\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Equivalence.lean\",null,null,\"CategoryTheory.Equivalence.changeFunctor_refl\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Equivalence.lean\",null,null,\"CategoryTheory.Equivalence.changeFunctor_trans\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Equivalence.lean\",null,null,\"CategoryTheory.Equivalence.counitInv_app_functor\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Equivalence.lean\",null,null,\"CategoryTheory.Equivalence.counitInv_functor_comp\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Equivalence.lean\",null,null,\"CategoryTheory.Equivalence.counit_app_functor\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Equivalence.lean\",null,null,\"CategoryTheory.Equivalence.funInvIdAssoc_hom_app\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Equivalence.lean\",null,null,\"CategoryTheory.Equivalence.funInvIdAssoc_inv_app\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Equivalence.lean\",null,null,\"CategoryTheory.Equivalence.invFunIdAssoc_inv_app\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Equivalence.lean\",null,null,\"CategoryTheory.Equivalence.inverse_counitInv_comp\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Equivalence.lean\",null,null,\"CategoryTheory.Equivalence.unitInv_app_inverse\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Equivalence.lean\",null,null,\"CategoryTheory.Equivalence.unit_app_inverse\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Equivalence.lean\",null,null,\"CategoryTheory.Functor.fun_inv_map\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Equivalence.lean\",null,null,\"CategoryTheory.Functor.inv_fun_map\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Equivalence.lean\",null,null,\"CategoryTheory.Functor.isEquivalence_of_comp_left\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Equivalence.lean\",null,null,\"CategoryTheory.Functor.isEquivalence_of_comp_right\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/EssentialImage.lean\",null,null,\"CategoryTheory.Functor.essSurj_of_surj\"]"
+  ]
+}

manifests/batches/mathlib/000640.json

@@ -0,0 +1,163 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "mathlib/000640",
+  "batch_fingerprint": "54e192d84ac0a6e3133f21fcf4523deb886fc6baf9a11a27da563541d9c6ab7c",
+  "evidence": {
+    "batch_fingerprint": "54e192d84ac0a6e3133f21fcf4523deb886fc6baf9a11a27da563541d9c6ab7c",
+    "contamination_matches": [],
+    "failures": [
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.BasedFunctor.comp_assoc",
+        "id": "CategoryTheory.BasedFunctor.comp_assoc",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            96,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/FiberedCategory/BasedCategory.lean",
+          "full_name": "CategoryTheory.BasedFunctor.comp_assoc",
+          "start": [
+            93,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/FiberedCategory/BasedCategory.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.BasedFunctor.comp_id",
+        "id": "CategoryTheory.BasedFunctor.comp_id",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            87,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/FiberedCategory/BasedCategory.lean",
+          "full_name": "CategoryTheory.BasedFunctor.comp_id",
+          "start": [
+            85,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/FiberedCategory/BasedCategory.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.BasedNatTrans.homCategory.ext",
+        "id": "CategoryTheory.BasedNatTrans.homCategory.ext",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            188,
+            26
+          ],
+          "file_path": "Mathlib/CategoryTheory/FiberedCategory/BasedCategory.lean",
+          "full_name": "CategoryTheory.BasedNatTrans.homCategory.ext",
+          "start": [
+            186,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/FiberedCategory/BasedCategory.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Functor.IsCartesian.fac",
+        "id": "CategoryTheory.Functor.IsCartesian.fac",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            57,
+            88
+          ],
+          "file_path": "Mathlib/CategoryTheory/FiberedCategory/Cartesian.lean",
+          "full_name": "CategoryTheory.Functor.IsCartesian.fac",
+          "start": [
+            55,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/FiberedCategory/Cartesian.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Functor.IsCartesian.map_uniq",
+        "id": "CategoryTheory.Functor.IsCartesian.map_uniq",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            65,
+            26
+          ],
+          "file_path": "Mathlib/CategoryTheory/FiberedCategory/Cartesian.lean",
+          "full_name": "CategoryTheory.Functor.IsCartesian.map_uniq",
+          "start": [
+            59,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/FiberedCategory/Cartesian.lean"
+      }
+    ],
+    "input_proofs": 11,
+    "input_units": 2,
+    "proofs": 6,
+    "published_proofs": 6,
+    "published_transitions": 13,
+    "replay_failures": [],
+    "transitions": 13,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/mathlib-000640-0000-51681f00a857cac7.parquet",
+      "sha256": "51681f00a857cac795f5f2a0c6cc48d22025473895eb4cabc4fa3424e39c5fd8",
+      "bytes": 74697,
+      "rows": 10,
+      "revision": "6a3d2d550a5e8f26af70e44381b84ab7563dc62c"
+    },
+    {
+      "path": "data/internal_test/mathlib-000640-0000-48d907f4022203ba.parquet",
+      "sha256": "48d907f4022203baec6702eb25f3423f87d0d192edc36ffffd37612e6af739ca",
+      "bytes": 53224,
+      "rows": 3,
+      "revision": "6a3d2d550a5e8f26af70e44381b84ab7563dc62c"
+    }
+  ],
+  "proof_ids": [
+    "mathlib:CategoryTheory.BasedFunctor.isHomLift_map",
+    "mathlib:CategoryTheory.BasedNatIso.isIso_of_toNatTrans_isIso",
+    "mathlib:CategoryTheory.BasedNatTrans.ext",
+    "mathlib:CategoryTheory.BasedNatTrans.isHomLift",
+    "mathlib:CategoryTheory.Functor.IsCartesian.eq_of_fac",
+    "mathlib:CategoryTheory.Functor.IsCartesian.map_self"
+  ],
+  "proof_keys": [
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/FiberedCategory/BasedCategory.lean\",null,null,\"CategoryTheory.BasedFunctor.isHomLift_map\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/FiberedCategory/BasedCategory.lean\",null,null,\"CategoryTheory.BasedNatIso.isIso_of_toNatTrans_isIso\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/FiberedCategory/BasedCategory.lean\",null,null,\"CategoryTheory.BasedNatTrans.ext\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/FiberedCategory/BasedCategory.lean\",null,null,\"CategoryTheory.BasedNatTrans.isHomLift\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/FiberedCategory/Cartesian.lean\",null,null,\"CategoryTheory.Functor.IsCartesian.eq_of_fac\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/FiberedCategory/Cartesian.lean\",null,null,\"CategoryTheory.Functor.IsCartesian.map_self\"]"
+  ]
+}

manifests/batches/mathlib/000642.json

@@ -0,0 +1,688 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "mathlib/000642",
+  "batch_fingerprint": "1f5357e631fc930c5c019ad8f8eb0f6b50a26e99d47930c3d7e0cc90d2983af9",
+  "evidence": {
+    "batch_fingerprint": "1f5357e631fc930c5c019ad8f8eb0f6b50a26e99d47930c3d7e0cc90d2983af9",
+    "contamination_matches": [],
+    "failures": [
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.IsCofiltered.isConnected",
+        "id": "CategoryTheory.IsCofiltered.isConnected",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            35,
+            48
+          ],
+          "file_path": "Mathlib/CategoryTheory/Filtered/Connected.lean",
+          "full_name": "CategoryTheory.IsCofiltered.isConnected",
+          "start": [
+            34,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Filtered/Connected.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.IsCofilteredOrEmpty.isPreconnected",
+        "id": "CategoryTheory.IsCofilteredOrEmpty.isPreconnected",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            27,
+            64
+          ],
+          "file_path": "Mathlib/CategoryTheory/Filtered/Connected.lean",
+          "full_name": "CategoryTheory.IsCofilteredOrEmpty.isPreconnected",
+          "start": [
+            24,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Filtered/Connected.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.IsFiltered.isConnected",
+        "id": "CategoryTheory.IsFiltered.isConnected",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            31,
+            46
+          ],
+          "file_path": "Mathlib/CategoryTheory/Filtered/Connected.lean",
+          "full_name": "CategoryTheory.IsFiltered.isConnected",
+          "start": [
+            30,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Filtered/Connected.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.IsFilteredOrEmpty.isPreconnected",
+        "id": "CategoryTheory.IsFilteredOrEmpty.isPreconnected",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            22,
+            62
+          ],
+          "file_path": "Mathlib/CategoryTheory/Filtered/Connected.lean",
+          "full_name": "CategoryTheory.IsFilteredOrEmpty.isPreconnected",
+          "start": [
+            19,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Filtered/Connected.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Functor.Final.exists_coeq",
+        "id": "CategoryTheory.Functor.Final.exists_coeq",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            209,
+            55
+          ],
+          "file_path": "Mathlib/CategoryTheory/Filtered/Final.lean",
+          "full_name": "CategoryTheory.Functor.Final.exists_coeq",
+          "start": [
+            207,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Filtered/Final.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Functor.Initial.exists_eq",
+        "id": "CategoryTheory.Functor.Initial.exists_eq",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            213,
+            59
+          ],
+          "file_path": "Mathlib/CategoryTheory/Filtered/Final.lean",
+          "full_name": "CategoryTheory.Functor.Initial.exists_eq",
+          "start": [
+            211,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Filtered/Final.lean"
+      },
+      {
+        "error": "no internal trace for tactic 'apply (Final.colimitCompCoyonedaIso F d).toEquiv.injective'",
+        "full_name": "CategoryTheory.Functor.final_iff_of_isFiltered",
+        "id": "CategoryTheory.Functor.final_iff_of_isFiltered",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            190,
+            25
+          ],
+          "file_path": "Mathlib/CategoryTheory/Filtered/Final.lean",
+          "full_name": "CategoryTheory.Functor.final_iff_of_isFiltered",
+          "start": [
+            175,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"refine \\u27e8fun hF => \\u27e8?_, ?_\\u27e9, fun h => <a>final_of_exists_of_isFiltered<\\/a> F h.1 h.2\\u27e9\"",
+                "[{\"full_name\":\"CategoryTheory.Functor.final_of_exists_of_isFiltered\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Final.lean\",\"def_pos\":[91,9],\"def_end_pos\":[91,46]}]"
+              ],
+              "state_after": "case refine_1\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nhF : F.Final\n\u22a2 \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\n\ncase refine_2\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nhF : F.Final\n\u22a2 \u2200 {d : D} {c : C} (s s' : d \u27f6 F.obj c), \u2203 c' t, s \u226b F.map t = s' \u226b F.map t",
+              "state_before": "C : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\n\u22a2 F.Final \u2194\n    (\u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)) \u2227\n      \u2200 {d : D} {c : C} (s s' : d \u27f6 F.obj c), \u2203 c' t, s \u226b F.map t = s' \u226b F.map t",
+              "tactic": "refine \u27e8fun hF => \u27e8?_, ?_\u27e9, fun h => final_of_exists_of_isFiltered F h.1 h.2\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"intro d\"",
+                "[]"
+              ],
+              "state_after": "case refine_1\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nhF : F.Final\nd : D\n\u22a2 \u2203 c, Nonempty (d \u27f6 F.obj c)",
+              "state_before": "case refine_1\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nhF : F.Final\n\u22a2 \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)",
+              "tactic": "intro d"
+            },
+            {
+              "annotated_tactic": [
+                "\"obtain \\u27e8f\\u27e9 : <a>Nonempty<\\/a> (<a>StructuredArrow<\\/a> d F) := <a>IsConnected.is_nonempty<\\/a>\"",
+                "[{\"full_name\":\"Nonempty\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[709,17],\"def_end_pos\":[709,25]},{\"full_name\":\"CategoryTheory.StructuredArrow\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Comma\\/StructuredArrow.lean\",\"def_pos\":[41,5],\"def_end_pos\":[41,20]},{\"full_name\":\"CategoryTheory.IsConnected.is_nonempty\",\"def_path\":\"Mathlib\\/CategoryTheory\\/IsConnected.lean\",\"def_pos\":[78,4],\"def_end_pos\":[78,15]}]"
+              ],
+              "state_after": "case refine_1.intro\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nhF : F.Final\nd : D\nf : StructuredArrow d F\n\u22a2 \u2203 c, Nonempty (d \u27f6 F.obj c)",
+              "state_before": "case refine_1\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nhF : F.Final\nd : D\n\u22a2 \u2203 c, Nonempty (d \u27f6 F.obj c)",
+              "tactic": "obtain \u27e8f\u27e9 : Nonempty (StructuredArrow d F) := IsConnected.is_nonempty"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact \\u27e8_, \\u27e8f.hom\\u27e9\\u27e9\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case refine_1.intro\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nhF : F.Final\nd : D\nf : StructuredArrow d F\n\u22a2 \u2203 c, Nonempty (d \u27f6 F.obj c)",
+              "tactic": "exact \u27e8_, \u27e8f.hom\u27e9\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"intro d c s s'\"",
+                "[]"
+              ],
+              "state_after": "case refine_2\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nhF : F.Final\nd : D\nc : C\ns s' : d \u27f6 F.obj c\n\u22a2 \u2203 c' t, s \u226b F.map t = s' \u226b F.map t",
+              "state_before": "case refine_2\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nhF : F.Final\n\u22a2 \u2200 {d : D} {c : C} (s s' : d \u27f6 F.obj c), \u2203 c' t, s \u226b F.map t = s' \u226b F.map t",
+              "tactic": "intro d c s s'"
+            },
+            {
+              "annotated_tactic": [
+                "\"have : <a>colimit.\\u03b9<\\/a> (F \\u22d9 coyoneda.obj (<a>op<\\/a> d)) c s = <a>colimit.\\u03b9<\\/a> (F \\u22d9 coyoneda.obj (<a>op<\\/a> d)) c s' := by\\n      apply (<a>Final.colimitCompCoyonedaIso<\\/a> F d).toEquiv.injective\\n      exact <a>Subsingleton.elim<\\/a> _ _\"",
+                "[{\"full_name\":\"CategoryTheory.Limits.colimit.\\u03b9\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/HasLimits.lean\",\"def_pos\":[741,5],\"def_end_pos\":[741,14]},{\"full_name\":\"Opposite.op\",\"def_path\":\"Mathlib\\/Data\\/Opposite.lean\",\"def_pos\":[37,3],\"def_end_pos\":[37,5]},{\"full_name\":\"CategoryTheory.Limits.colimit.\\u03b9\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/HasLimits.lean\",\"def_pos\":[741,5],\"def_end_pos\":[741,14]},{\"full_name\":\"Opposite.op\",\"def_path\":\"Mathlib\\/Data\\/Opposite.lean\",\"def_pos\":[37,3],\"def_end_pos\":[37,5]},{\"full_name\":\"CategoryTheory.Functor.Final.colimitCompCoyonedaIso\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Final.lean\",\"def_pos\":[445,5],\"def_end_pos\":[445,33]},{\"full_name\":\"Subsingleton.elim\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Core.lean\",\"def_pos\":[1015,19],\"def_end_pos\":[1015,36]}]"
+              ],
+              "state_after": "case refine_2\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nhF : F.Final\nd : D\nc : C\ns s' : d \u27f6 F.obj c\nthis : colimit.\u03b9 (F \u22d9 coyoneda.obj { unop := d }) c s = colimit.\u03b9 (F \u22d9 coyoneda.obj { unop := d }) c s'\n\u22a2 \u2203 c' t, s \u226b F.map t = s' \u226b F.map t",
+              "state_before": "case refine_2\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nhF : F.Final\nd : D\nc : C\ns s' : d \u27f6 F.obj c\n\u22a2 \u2203 c' t, s \u226b F.map t = s' \u226b F.map t",
+              "tactic": "have : colimit.\u03b9 (F \u22d9 coyoneda.obj (op d)) c s = colimit.\u03b9 (F \u22d9 coyoneda.obj (op d)) c s' := by\n  apply (Final.colimitCompCoyonedaIso F d).toEquiv.injective\n  exact Subsingleton.elim _ _"
+            },
+            {
+              "annotated_tactic": [
+                "\"obtain \\u27e8c', t\\u2081, t\\u2082, h\\u27e9 := (<a>Types.FilteredColimit.colimit_eq_iff<\\/a>.{v\\u2081, v\\u2081, v\\u2081} _).<a>mp<\\/a> this\"",
+                "[{\"full_name\":\"CategoryTheory.Limits.Types.FilteredColimit.colimit_eq_iff\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/TypesFiltered.lean\",\"def_pos\":[131,9],\"def_end_pos\":[131,23]},{\"full_name\":\"Iff.mp\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Core.lean\",\"def_pos\":[118,3],\"def_end_pos\":[118,5]}]"
+              ],
+              "state_after": "case refine_2.intro.intro.intro\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nhF : F.Final\nd : D\nc : C\ns s' : d \u27f6 F.obj c\nthis : colimit.\u03b9 (F \u22d9 coyoneda.obj { unop := d }) c s = colimit.\u03b9 (F \u22d9 coyoneda.obj { unop := d }) c s'\nc' : C\nt\u2081 t\u2082 : c \u27f6 c'\nh : (F \u22d9 coyoneda.obj { unop := d }).map t\u2081 s = (F \u22d9 coyoneda.obj { unop := d }).map t\u2082 s'\n\u22a2 \u2203 c' t, s \u226b F.map t = s' \u226b F.map t",
+              "state_before": "case refine_2\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nhF : F.Final\nd : D\nc : C\ns s' : d \u27f6 F.obj c\nthis : colimit.\u03b9 (F \u22d9 coyoneda.obj { unop := d }) c s = colimit.\u03b9 (F \u22d9 coyoneda.obj { unop := d }) c s'\n\u22a2 \u2203 c' t, s \u226b F.map t = s' \u226b F.map t",
+              "tactic": "obtain \u27e8c', t\u2081, t\u2082, h\u27e9 := (Types.FilteredColimit.colimit_eq_iff.{v\u2081, v\u2081, v\u2081} _).mp this"
+            },
+            {
+              "annotated_tactic": [
+                "\"refine \\u27e8<a>IsFiltered.coeq<\\/a> t\\u2081 t\\u2082, t\\u2081 \\u226b <a>IsFiltered.coeqHom<\\/a> t\\u2081 t\\u2082, ?_\\u27e9\"",
+                "[{\"full_name\":\"CategoryTheory.IsFiltered.coeq\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Basic.lean\",\"def_pos\":[178,19],\"def_end_pos\":[178,23]},{\"full_name\":\"CategoryTheory.IsFiltered.coeqHom\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Basic.lean\",\"def_pos\":[187,19],\"def_end_pos\":[187,26]}]"
+              ],
+              "state_after": "case refine_2.intro.intro.intro\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nhF : F.Final\nd : D\nc : C\ns s' : d \u27f6 F.obj c\nthis : colimit.\u03b9 (F \u22d9 coyoneda.obj { unop := d }) c s = colimit.\u03b9 (F \u22d9 coyoneda.obj { unop := d }) c s'\nc' : C\nt\u2081 t\u2082 : c \u27f6 c'\nh : (F \u22d9 coyoneda.obj { unop := d }).map t\u2081 s = (F \u22d9 coyoneda.obj { unop := d }).map t\u2082 s'\n\u22a2 s \u226b F.map (t\u2081 \u226b IsFiltered.coeqHom t\u2081 t\u2082) = s' \u226b F.map (t\u2081 \u226b IsFiltered.coeqHom t\u2081 t\u2082)",
+              "state_before": "case refine_2.intro.intro.intro\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nhF : F.Final\nd : D\nc : C\ns s' : d \u27f6 F.obj c\nthis : colimit.\u03b9 (F \u22d9 coyoneda.obj { unop := d }) c s = colimit.\u03b9 (F \u22d9 coyoneda.obj { unop := d }) c s'\nc' : C\nt\u2081 t\u2082 : c \u27f6 c'\nh : (F \u22d9 coyoneda.obj { unop := d }).map t\u2081 s = (F \u22d9 coyoneda.obj { unop := d }).map t\u2082 s'\n\u22a2 \u2203 c' t, s \u226b F.map t = s' \u226b F.map t",
+              "tactic": "refine \u27e8IsFiltered.coeq t\u2081 t\u2082, t\u2081 \u226b IsFiltered.coeqHom t\u2081 t\u2082, ?_\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"conv_rhs => rw [<a>IsFiltered.coeq_condition<\\/a> t\\u2081 t\\u2082]\"",
+                "[{\"full_name\":\"CategoryTheory.IsFiltered.coeq_condition\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Basic.lean\",\"def_pos\":[196,9],\"def_end_pos\":[196,23]}]"
+              ],
+              "state_after": "case refine_2.intro.intro.intro\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nhF : F.Final\nd : D\nc : C\ns s' : d \u27f6 F.obj c\nthis : colimit.\u03b9 (F \u22d9 coyoneda.obj { unop := d }) c s = colimit.\u03b9 (F \u22d9 coyoneda.obj { unop := d }) c s'\nc' : C\nt\u2081 t\u2082 : c \u27f6 c'\nh : (F \u22d9 coyoneda.obj { unop := d }).map t\u2081 s = (F \u22d9 coyoneda.obj { unop := d }).map t\u2082 s'\n\u22a2 s \u226b F.map (t\u2081 \u226b IsFiltered.coeqHom t\u2081 t\u2082) = s' \u226b F.map (t\u2082 \u226b IsFiltered.coeqHom t\u2081 t\u2082)",
+              "state_before": "case refine_2.intro.intro.intro\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nhF : F.Final\nd : D\nc : C\ns s' : d \u27f6 F.obj c\nthis : colimit.\u03b9 (F \u22d9 coyoneda.obj { unop := d }) c s = colimit.\u03b9 (F \u22d9 coyoneda.obj { unop := d }) c s'\nc' : C\nt\u2081 t\u2082 : c \u27f6 c'\nh : (F \u22d9 coyoneda.obj { unop := d }).map t\u2081 s = (F \u22d9 coyoneda.obj { unop := d }).map t\u2082 s'\n\u22a2 s \u226b F.map (t\u2081 \u226b IsFiltered.coeqHom t\u2081 t\u2082) = s' \u226b F.map (t\u2081 \u226b IsFiltered.coeqHom t\u2081 t\u2082)",
+              "tactic": "conv_rhs => rw [IsFiltered.coeq_condition t\u2081 t\u2082]"
+            },
+            {
+              "annotated_tactic": [
+                "\"dsimp only [<a>comp_obj<\\/a>, <a>coyoneda_obj_obj<\\/a>, <a>unop_op<\\/a>, <a>Functor.comp_map<\\/a>, <a>coyoneda_obj_map<\\/a>] at h\"",
+                "[{\"full_name\":\"CategoryTheory.Functor.comp_obj\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Functor\\/Basic.lean\",\"def_pos\":[110,9],\"def_end_pos\":[110,12]},{\"full_name\":\"CategoryTheory.coyoneda_obj_obj\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Yoneda.lean\",\"def_pos\":[48,3],\"def_end_pos\":[48,8]},{\"full_name\":\"Opposite.unop_op\",\"def_path\":\"Mathlib\\/Data\\/Opposite.lean\",\"def_pos\":[66,9],\"def_end_pos\":[66,16]},{\"full_name\":\"CategoryTheory.Functor.comp_map\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Functor\\/Basic.lean\",\"def_pos\":[122,9],\"def_end_pos\":[122,17]},{\"full_name\":\"CategoryTheory.coyoneda_obj_map\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Yoneda.lean\",\"def_pos\":[48,3],\"def_end_pos\":[48,8]}]"
+              ],
+              "state_after": "case refine_2.intro.intro.intro\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nhF : F.Final\nd : D\nc : C\ns s' : d \u27f6 F.obj c\nthis : colimit.\u03b9 (F \u22d9 coyoneda.obj { unop := d }) c s = colimit.\u03b9 (F \u22d9 coyoneda.obj { unop := d }) c s'\nc' : C\nt\u2081 t\u2082 : c \u27f6 c'\nh : s \u226b F.map t\u2081 = s' \u226b F.map t\u2082\n\u22a2 s \u226b F.map (t\u2081 \u226b IsFiltered.coeqHom t\u2081 t\u2082) = s' \u226b F.map (t\u2082 \u226b IsFiltered.coeqHom t\u2081 t\u2082)",
+              "state_before": "case refine_2.intro.intro.intro\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nhF : F.Final\nd : D\nc : C\ns s' : d \u27f6 F.obj c\nthis : colimit.\u03b9 (F \u22d9 coyoneda.obj { unop := d }) c s = colimit.\u03b9 (F \u22d9 coyoneda.obj { unop := d }) c s'\nc' : C\nt\u2081 t\u2082 : c \u27f6 c'\nh : (F \u22d9 coyoneda.obj { unop := d }).map t\u2081 s = (F \u22d9 coyoneda.obj { unop := d }).map t\u2082 s'\n\u22a2 s \u226b F.map (t\u2081 \u226b IsFiltered.coeqHom t\u2081 t\u2082) = s' \u226b F.map (t\u2082 \u226b IsFiltered.coeqHom t\u2081 t\u2082)",
+              "tactic": "dsimp only [comp_obj, coyoneda_obj_obj, unop_op, Functor.comp_map, coyoneda_obj_map] at h"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp [reassoc_of% h]\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case refine_2.intro.intro.intro\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nhF : F.Final\nd : D\nc : C\ns s' : d \u27f6 F.obj c\nthis : colimit.\u03b9 (F \u22d9 coyoneda.obj { unop := d }) c s = colimit.\u03b9 (F \u22d9 coyoneda.obj { unop := d }) c s'\nc' : C\nt\u2081 t\u2082 : c \u27f6 c'\nh : s \u226b F.map t\u2081 = s' \u226b F.map t\u2082\n\u22a2 s \u226b F.map (t\u2081 \u226b IsFiltered.coeqHom t\u2081 t\u2082) = s' \u226b F.map (t\u2082 \u226b IsFiltered.coeqHom t\u2081 t\u2082)",
+              "tactic": "simp [reassoc_of% h]"
+            },
+            {
+              "annotated_tactic": [
+                "\"apply (<a>Final.colimitCompCoyonedaIso<\\/a> F d).toEquiv.injective\"",
+                "[{\"full_name\":\"CategoryTheory.Functor.Final.colimitCompCoyonedaIso\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Final.lean\",\"def_pos\":[445,5],\"def_end_pos\":[445,33]}]"
+              ],
+              "state_after": "case a\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nhF : F.Final\nd : D\nc : C\ns s' : d \u27f6 F.obj c\n\u22a2 (Final.colimitCompCoyonedaIso F d).toEquiv (colimit.\u03b9 (F \u22d9 coyoneda.obj { unop := d }) c s) =\n    (Final.colimitCompCoyonedaIso F d).toEquiv (colimit.\u03b9 (F \u22d9 coyoneda.obj { unop := d }) c s')",
+              "state_before": "C : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nhF : F.Final\nd : D\nc : C\ns s' : d \u27f6 F.obj c\n\u22a2 colimit.\u03b9 (F \u22d9 coyoneda.obj { unop := d }) c s = colimit.\u03b9 (F \u22d9 coyoneda.obj { unop := d }) c s'",
+              "tactic": "apply (Final.colimitCompCoyonedaIso F d).toEquiv.injective"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact <a>Subsingleton.elim<\\/a> _ _\"",
+                "[{\"full_name\":\"Subsingleton.elim\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Core.lean\",\"def_pos\":[1015,19],\"def_end_pos\":[1015,36]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case a\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nhF : F.Final\nd : D\nc : C\ns s' : d \u27f6 F.obj c\n\u22a2 (Final.colimitCompCoyonedaIso F d).toEquiv (colimit.\u03b9 (F \u22d9 coyoneda.obj { unop := d }) c s) =\n    (Final.colimitCompCoyonedaIso F d).toEquiv (colimit.\u03b9 (F \u22d9 coyoneda.obj { unop := d }) c s')",
+              "tactic": "exact Subsingleton.elim _ _"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Filtered/Final.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Functor.final_of_isFiltered_structuredArrow",
+        "id": "CategoryTheory.Functor.final_of_isFiltered_structuredArrow",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            47,
+            36
+          ],
+          "file_path": "Mathlib/CategoryTheory/Filtered/Final.lean",
+          "full_name": "CategoryTheory.Functor.final_of_isFiltered_structuredArrow",
+          "start": [
+            45,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Filtered/Final.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Functor.initial_of_isCofiltered_costructuredArrow",
+        "id": "CategoryTheory.Functor.initial_of_isCofiltered_costructuredArrow",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            54,
+            38
+          ],
+          "file_path": "Mathlib/CategoryTheory/Filtered/Final.lean",
+          "full_name": "CategoryTheory.Functor.initial_of_isCofiltered_costructuredArrow",
+          "start": [
+            52,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Filtered/Final.lean"
+      },
+      {
+        "error": "no internal trace for tactic 'obtain \u27e8c, \u27e8f\u27e9\u27e9 := h\u2081 d'",
+        "full_name": "CategoryTheory.isFiltered_structuredArrow_of_isFiltered_of_exists",
+        "id": "CategoryTheory.isFiltered_structuredArrow_of_isFiltered_of_exists",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            72,
+            46
+          ],
+          "file_path": "Mathlib/CategoryTheory/Filtered/Final.lean",
+          "full_name": "CategoryTheory.isFiltered_structuredArrow_of_isFiltered_of_exists",
+          "start": [
+            56,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"have : <a>Nonempty<\\/a> (<a>StructuredArrow<\\/a> d F) := by\\n    obtain \\u27e8c, \\u27e8f\\u27e9\\u27e9 := h\\u2081 d\\n    exact \\u27e8.mk f\\u27e9\"",
+                "[{\"full_name\":\"Nonempty\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[709,17],\"def_end_pos\":[709,25]},{\"full_name\":\"CategoryTheory.StructuredArrow\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Comma\\/StructuredArrow.lean\",\"def_pos\":[41,5],\"def_end_pos\":[41,20]}]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b2 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nh\u2081 : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nh\u2082 : \u2200 {d : D} {c : C} (s s' : d \u27f6 F.obj c), \u2203 c' t, s \u226b F.map t = s' \u226b F.map t\nd : D\nthis : Nonempty (StructuredArrow d F)\n\u22a2 IsFiltered (StructuredArrow d F)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b2 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nh\u2081 : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nh\u2082 : \u2200 {d : D} {c : C} (s s' : d \u27f6 F.obj c), \u2203 c' t, s \u226b F.map t = s' \u226b F.map t\nd : D\n\u22a2 IsFiltered (StructuredArrow d F)",
+              "tactic": "have : Nonempty (StructuredArrow d F) := by\n  obtain \u27e8c, \u27e8f\u27e9\u27e9 := h\u2081 d\n  exact \u27e8.mk f\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"suffices <a>IsFilteredOrEmpty<\\/a> (<a>StructuredArrow<\\/a> d F) from <a>IsFiltered.mk<\\/a>\"",
+                "[{\"full_name\":\"CategoryTheory.IsFilteredOrEmpty\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Basic.lean\",\"def_pos\":[76,7],\"def_end_pos\":[76,24]},{\"full_name\":\"CategoryTheory.StructuredArrow\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Comma\\/StructuredArrow.lean\",\"def_pos\":[41,5],\"def_end_pos\":[41,20]},{\"full_name\":\"CategoryTheory.IsFiltered.mk\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Basic.lean\",\"def_pos\":[92,7],\"def_end_pos\":[92,17]}]"
+              ],
+              "state_after": "C : Type u\u2081\ninst\u271d\u00b2 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nh\u2081 : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nh\u2082 : \u2200 {d : D} {c : C} (s s' : d \u27f6 F.obj c), \u2203 c' t, s \u226b F.map t = s' \u226b F.map t\nd : D\nthis : Nonempty (StructuredArrow d F)\n\u22a2 IsFilteredOrEmpty (StructuredArrow d F)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b2 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nh\u2081 : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nh\u2082 : \u2200 {d : D} {c : C} (s s' : d \u27f6 F.obj c), \u2203 c' t, s \u226b F.map t = s' \u226b F.map t\nd : D\nthis : Nonempty (StructuredArrow d F)\n\u22a2 IsFiltered (StructuredArrow d F)",
+              "tactic": "suffices IsFilteredOrEmpty (StructuredArrow d F) from IsFiltered.mk"
+            },
+            {
+              "annotated_tactic": [
+                "\"refine \\u27e8fun f g => ?_, fun f g \\u03b7 \\u03bc => ?_\\u27e9\"",
+                "[]"
+              ],
+              "state_after": "case refine_1\nC : Type u\u2081\ninst\u271d\u00b2 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nh\u2081 : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nh\u2082 : \u2200 {d : D} {c : C} (s s' : d \u27f6 F.obj c), \u2203 c' t, s \u226b F.map t = s' \u226b F.map t\nd : D\nthis : Nonempty (StructuredArrow d F)\nf g : StructuredArrow d F\n\u22a2 \u2203 Z x x, True\n\ncase refine_2\nC : Type u\u2081\ninst\u271d\u00b2 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nh\u2081 : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nh\u2082 : \u2200 {d : D} {c : C} (s s' : d \u27f6 F.obj c), \u2203 c' t, s \u226b F.map t = s' \u226b F.map t\nd : D\nthis : Nonempty (StructuredArrow d F)\nf g : StructuredArrow d F\n\u03b7 \u03bc : f \u27f6 g\n\u22a2 \u2203 Z h, \u03b7 \u226b h = \u03bc \u226b h",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b2 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nh\u2081 : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nh\u2082 : \u2200 {d : D} {c : C} (s s' : d \u27f6 F.obj c), \u2203 c' t, s \u226b F.map t = s' \u226b F.map t\nd : D\nthis : Nonempty (StructuredArrow d F)\n\u22a2 IsFilteredOrEmpty (StructuredArrow d F)",
+              "tactic": "refine \u27e8fun f g => ?_, fun f g \u03b7 \u03bc => ?_\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"obtain \\u27e8c, \\u27e8f\\u27e9\\u27e9 := h\\u2081 d\"",
+                "[]"
+              ],
+              "state_after": "case intro.intro\nC : Type u\u2081\ninst\u271d\u00b2 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nh\u2081 : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nh\u2082 : \u2200 {d : D} {c : C} (s s' : d \u27f6 F.obj c), \u2203 c' t, s \u226b F.map t = s' \u226b F.map t\nd : D\nc : C\nf : d \u27f6 F.obj c\n\u22a2 Nonempty (StructuredArrow d F)",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b2 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nh\u2081 : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nh\u2082 : \u2200 {d : D} {c : C} (s s' : d \u27f6 F.obj c), \u2203 c' t, s \u226b F.map t = s' \u226b F.map t\nd : D\n\u22a2 Nonempty (StructuredArrow d F)",
+              "tactic": "obtain \u27e8c, \u27e8f\u27e9\u27e9 := h\u2081 d"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact \\u27e8.mk f\\u27e9\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case intro.intro\nC : Type u\u2081\ninst\u271d\u00b2 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nh\u2081 : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nh\u2082 : \u2200 {d : D} {c : C} (s s' : d \u27f6 F.obj c), \u2203 c' t, s \u226b F.map t = s' \u226b F.map t\nd : D\nc : C\nf : d \u27f6 F.obj c\n\u22a2 Nonempty (StructuredArrow d F)",
+              "tactic": "exact \u27e8.mk f\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"obtain \\u27e8c, \\u27e8t, ht\\u27e9\\u27e9 := h\\u2082 (f.hom \\u226b F.map (<a>IsFiltered.leftToMax<\\/a> f.right g.right))\\n        (g.hom \\u226b F.map (<a>IsFiltered.rightToMax<\\/a> f.right g.right))\"",
+                "[{\"full_name\":\"CategoryTheory.IsFiltered.leftToMax\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Basic.lean\",\"def_pos\":[162,19],\"def_end_pos\":[162,28]},{\"full_name\":\"CategoryTheory.IsFiltered.rightToMax\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Basic.lean\",\"def_pos\":[169,19],\"def_end_pos\":[169,29]}]"
+              ],
+              "state_after": "case refine_1.intro.intro\nC : Type u\u2081\ninst\u271d\u00b2 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nh\u2081 : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nh\u2082 : \u2200 {d : D} {c : C} (s s' : d \u27f6 F.obj c), \u2203 c' t, s \u226b F.map t = s' \u226b F.map t\nd : D\nthis : Nonempty (StructuredArrow d F)\nf g : StructuredArrow d F\nc : C\nt : IsFiltered.max f.right g.right \u27f6 c\nht :\n  (f.hom \u226b F.map (IsFiltered.leftToMax f.right g.right)) \u226b F.map t =\n    (g.hom \u226b F.map (IsFiltered.rightToMax f.right g.right)) \u226b F.map t\n\u22a2 \u2203 Z x x, True",
+              "state_before": "case refine_1\nC : Type u\u2081\ninst\u271d\u00b2 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nh\u2081 : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nh\u2082 : \u2200 {d : D} {c : C} (s s' : d \u27f6 F.obj c), \u2203 c' t, s \u226b F.map t = s' \u226b F.map t\nd : D\nthis : Nonempty (StructuredArrow d F)\nf g : StructuredArrow d F\n\u22a2 \u2203 Z x x, True",
+              "tactic": "obtain \u27e8c, \u27e8t, ht\u27e9\u27e9 := h\u2082 (f.hom \u226b F.map (IsFiltered.leftToMax f.right g.right))\n    (g.hom \u226b F.map (IsFiltered.rightToMax f.right g.right))"
+            },
+            {
+              "annotated_tactic": [
+                "\"refine \\u27e8.mk (f.hom \\u226b F.map (<a>IsFiltered.leftToMax<\\/a> f.right g.right \\u226b t)), ?_, ?_, <a>trivial<\\/a>\\u27e9\"",
+                "[{\"full_name\":\"CategoryTheory.IsFiltered.leftToMax\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Basic.lean\",\"def_pos\":[162,19],\"def_end_pos\":[162,28]},{\"full_name\":\"trivial\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Core.lean\",\"def_pos\":[645,35],\"def_end_pos\":[645,42]}]"
+              ],
+              "state_after": "case refine_1.intro.intro.refine_1\nC : Type u\u2081\ninst\u271d\u00b2 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nh\u2081 : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nh\u2082 : \u2200 {d : D} {c : C} (s s' : d \u27f6 F.obj c), \u2203 c' t, s \u226b F.map t = s' \u226b F.map t\nd : D\nthis : Nonempty (StructuredArrow d F)\nf g : StructuredArrow d F\nc : C\nt : IsFiltered.max f.right g.right \u27f6 c\nht :\n  (f.hom \u226b F.map (IsFiltered.leftToMax f.right g.right)) \u226b F.map t =\n    (g.hom \u226b F.map (IsFiltered.rightToMax f.right g.right)) \u226b F.map t\n\u22a2 f \u27f6 StructuredArrow.mk (f.hom \u226b F.map (IsFiltered.leftToMax f.right g.right \u226b t))\n\ncase refine_1.intro.intro.refine_2\nC : Type u\u2081\ninst\u271d\u00b2 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nh\u2081 : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nh\u2082 : \u2200 {d : D} {c : C} (s s' : d \u27f6 F.obj c), \u2203 c' t, s \u226b F.map t = s' \u226b F.map t\nd : D\nthis : Nonempty (StructuredArrow d F)\nf g : StructuredArrow d F\nc : C\nt : IsFiltered.max f.right g.right \u27f6 c\nht :\n  (f.hom \u226b F.map (IsFiltered.leftToMax f.right g.right)) \u226b F.map t =\n    (g.hom \u226b F.map (IsFiltered.rightToMax f.right g.right)) \u226b F.map t\n\u22a2 g \u27f6 StructuredArrow.mk (f.hom \u226b F.map (IsFiltered.leftToMax f.right g.right \u226b t))",
+              "state_before": "case refine_1.intro.intro\nC : Type u\u2081\ninst\u271d\u00b2 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nh\u2081 : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nh\u2082 : \u2200 {d : D} {c : C} (s s' : d \u27f6 F.obj c), \u2203 c' t, s \u226b F.map t = s' \u226b F.map t\nd : D\nthis : Nonempty (StructuredArrow d F)\nf g : StructuredArrow d F\nc : C\nt : IsFiltered.max f.right g.right \u27f6 c\nht :\n  (f.hom \u226b F.map (IsFiltered.leftToMax f.right g.right)) \u226b F.map t =\n    (g.hom \u226b F.map (IsFiltered.rightToMax f.right g.right)) \u226b F.map t\n\u22a2 \u2203 Z x x, True",
+              "tactic": "refine \u27e8.mk (f.hom \u226b F.map (IsFiltered.leftToMax f.right g.right \u226b t)), ?_, ?_, trivial\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact <a>StructuredArrow.homMk<\\/a> (<a>IsFiltered.leftToMax<\\/a> _ _ \\u226b t) <a>rfl<\\/a>\"",
+                "[{\"full_name\":\"CategoryTheory.StructuredArrow.homMk\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Comma\\/StructuredArrow.lean\",\"def_pos\":[114,5],\"def_end_pos\":[114,10]},{\"full_name\":\"CategoryTheory.IsFiltered.leftToMax\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Basic.lean\",\"def_pos\":[162,19],\"def_end_pos\":[162,28]},{\"full_name\":\"rfl\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[294,22],\"def_end_pos\":[294,25]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case refine_1.intro.intro.refine_1\nC : Type u\u2081\ninst\u271d\u00b2 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nh\u2081 : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nh\u2082 : \u2200 {d : D} {c : C} (s s' : d \u27f6 F.obj c), \u2203 c' t, s \u226b F.map t = s' \u226b F.map t\nd : D\nthis : Nonempty (StructuredArrow d F)\nf g : StructuredArrow d F\nc : C\nt : IsFiltered.max f.right g.right \u27f6 c\nht :\n  (f.hom \u226b F.map (IsFiltered.leftToMax f.right g.right)) \u226b F.map t =\n    (g.hom \u226b F.map (IsFiltered.rightToMax f.right g.right)) \u226b F.map t\n\u22a2 f \u27f6 StructuredArrow.mk (f.hom \u226b F.map (IsFiltered.leftToMax f.right g.right \u226b t))",
+              "tactic": "exact StructuredArrow.homMk (IsFiltered.leftToMax _ _ \u226b t) rfl"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact <a>StructuredArrow.homMk<\\/a> (<a>IsFiltered.rightToMax<\\/a> _ _ \\u226b t) (by simpa using ht.symm)\"",
+                "[{\"full_name\":\"CategoryTheory.StructuredArrow.homMk\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Comma\\/StructuredArrow.lean\",\"def_pos\":[114,5],\"def_end_pos\":[114,10]},{\"full_name\":\"CategoryTheory.IsFiltered.rightToMax\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Basic.lean\",\"def_pos\":[169,19],\"def_end_pos\":[169,29]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case refine_1.intro.intro.refine_2\nC : Type u\u2081\ninst\u271d\u00b2 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nh\u2081 : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nh\u2082 : \u2200 {d : D} {c : C} (s s' : d \u27f6 F.obj c), \u2203 c' t, s \u226b F.map t = s' \u226b F.map t\nd : D\nthis : Nonempty (StructuredArrow d F)\nf g : StructuredArrow d F\nc : C\nt : IsFiltered.max f.right g.right \u27f6 c\nht :\n  (f.hom \u226b F.map (IsFiltered.leftToMax f.right g.right)) \u226b F.map t =\n    (g.hom \u226b F.map (IsFiltered.rightToMax f.right g.right)) \u226b F.map t\n\u22a2 g \u27f6 StructuredArrow.mk (f.hom \u226b F.map (IsFiltered.leftToMax f.right g.right \u226b t))",
+              "tactic": "exact StructuredArrow.homMk (IsFiltered.rightToMax _ _ \u226b t) (by simpa using ht.symm)"
+            },
+            {
+              "annotated_tactic": [
+                "\"simpa using ht.symm\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b2 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nh\u2081 : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nh\u2082 : \u2200 {d : D} {c : C} (s s' : d \u27f6 F.obj c), \u2203 c' t, s \u226b F.map t = s' \u226b F.map t\nd : D\nthis : Nonempty (StructuredArrow d F)\nf g : StructuredArrow d F\nc : C\nt : IsFiltered.max f.right g.right \u27f6 c\nht :\n  (f.hom \u226b F.map (IsFiltered.leftToMax f.right g.right)) \u226b F.map t =\n    (g.hom \u226b F.map (IsFiltered.rightToMax f.right g.right)) \u226b F.map t\n\u22a2 g.hom \u226b F.map (IsFiltered.rightToMax f.right g.right \u226b t) =\n    (StructuredArrow.mk (f.hom \u226b F.map (IsFiltered.leftToMax f.right g.right \u226b t))).hom",
+              "tactic": "simpa using ht.symm"
+            },
+            {
+              "annotated_tactic": [
+                "\"refine \\u27e8.mk (f.hom \\u226b F.map (\\u03b7.right \\u226b <a>IsFiltered.coeqHom<\\/a> \\u03b7.right \\u03bc.right)),\\n      <a>StructuredArrow.homMk<\\/a> (<a>IsFiltered.coeqHom<\\/a> \\u03b7.right \\u03bc.right) (by simp), ?_\\u27e9\"",
+                "[{\"full_name\":\"CategoryTheory.IsFiltered.coeqHom\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Basic.lean\",\"def_pos\":[187,19],\"def_end_pos\":[187,26]},{\"full_name\":\"CategoryTheory.StructuredArrow.homMk\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Comma\\/StructuredArrow.lean\",\"def_pos\":[114,5],\"def_end_pos\":[114,10]},{\"full_name\":\"CategoryTheory.IsFiltered.coeqHom\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Basic.lean\",\"def_pos\":[187,19],\"def_end_pos\":[187,26]}]"
+              ],
+              "state_after": "case refine_2\nC : Type u\u2081\ninst\u271d\u00b2 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nh\u2081 : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nh\u2082 : \u2200 {d : D} {c : C} (s s' : d \u27f6 F.obj c), \u2203 c' t, s \u226b F.map t = s' \u226b F.map t\nd : D\nthis : Nonempty (StructuredArrow d F)\nf g : StructuredArrow d F\n\u03b7 \u03bc : f \u27f6 g\n\u22a2 \u03b7 \u226b StructuredArrow.homMk (IsFiltered.coeqHom \u03b7.right \u03bc.right) \u22ef =\n    \u03bc \u226b StructuredArrow.homMk (IsFiltered.coeqHom \u03b7.right \u03bc.right) \u22ef",
+              "state_before": "case refine_2\nC : Type u\u2081\ninst\u271d\u00b2 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nh\u2081 : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nh\u2082 : \u2200 {d : D} {c : C} (s s' : d \u27f6 F.obj c), \u2203 c' t, s \u226b F.map t = s' \u226b F.map t\nd : D\nthis : Nonempty (StructuredArrow d F)\nf g : StructuredArrow d F\n\u03b7 \u03bc : f \u27f6 g\n\u22a2 \u2203 Z h, \u03b7 \u226b h = \u03bc \u226b h",
+              "tactic": "refine \u27e8.mk (f.hom \u226b F.map (\u03b7.right \u226b IsFiltered.coeqHom \u03b7.right \u03bc.right)),\n  StructuredArrow.homMk (IsFiltered.coeqHom \u03b7.right \u03bc.right) (by simp), ?_\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"simpa using <a>IsFiltered.coeq_condition<\\/a> _ _\"",
+                "[{\"full_name\":\"CategoryTheory.IsFiltered.coeq_condition\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Basic.lean\",\"def_pos\":[196,9],\"def_end_pos\":[196,23]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case refine_2\nC : Type u\u2081\ninst\u271d\u00b2 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nh\u2081 : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nh\u2082 : \u2200 {d : D} {c : C} (s s' : d \u27f6 F.obj c), \u2203 c' t, s \u226b F.map t = s' \u226b F.map t\nd : D\nthis : Nonempty (StructuredArrow d F)\nf g : StructuredArrow d F\n\u03b7 \u03bc : f \u27f6 g\n\u22a2 \u03b7 \u226b StructuredArrow.homMk (IsFiltered.coeqHom \u03b7.right \u03bc.right) \u22ef =\n    \u03bc \u226b StructuredArrow.homMk (IsFiltered.coeqHom \u03b7.right \u03bc.right) \u22ef",
+              "tactic": "simpa using IsFiltered.coeq_condition _ _"
+            },
+            {
+              "annotated_tactic": [
+                "\"simp\"",
+                "[]"
+              ],
+              "state_after": "no goals",
+              "state_before": "C : Type u\u2081\ninst\u271d\u00b2 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsFilteredOrEmpty C\nh\u2081 : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nh\u2082 : \u2200 {d : D} {c : C} (s s' : d \u27f6 F.obj c), \u2203 c' t, s \u226b F.map t = s' \u226b F.map t\nd : D\nthis : Nonempty (StructuredArrow d F)\nf g : StructuredArrow d F\n\u03b7 \u03bc : f \u27f6 g\n\u22a2 g.hom \u226b F.map (IsFiltered.coeqHom \u03b7.right \u03bc.right) =\n    (StructuredArrow.mk (f.hom \u226b F.map (\u03b7.right \u226b IsFiltered.coeqHom \u03b7.right \u03bc.right))).hom",
+              "tactic": "simp"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Filtered/Final.lean"
+      }
+    ],
+    "input_proofs": 21,
+    "input_units": 2,
+    "proofs": 11,
+    "published_proofs": 9,
+    "published_transitions": 29,
+    "replay_failures": [],
+    "transitions": 43,
+    "validation_failures": [
+      {
+        "errors": [
+          "internal transition boundary mismatch",
+          "internal transition boundary mismatch"
+        ],
+        "file_path": "Mathlib/CategoryTheory/Filtered/Final.lean",
+        "proof_id": "mathlib:CategoryTheory.Functor.initial_iff_of_isCofiltered",
+        "provenance": {
+          "selection": {
+            "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+            "end": [
+              205,
+              50
+            ],
+            "file_path": "Mathlib/CategoryTheory/Filtered/Final.lean",
+            "full_name": "CategoryTheory.Functor.initial_iff_of_isCofiltered",
+            "start": [
+              194,
+              1
+            ],
+            "traced_tactics": [
+              {
+                "annotated_tactic": [
+                  "\"refine \\u27e8fun hF => ?_, fun h => <a>initial_of_exists_of_isCofiltered<\\/a> F h.1 h.2\\u27e9\"",
+                  "[{\"full_name\":\"CategoryTheory.Functor.initial_of_exists_of_isCofiltered\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Final.lean\",\"def_pos\":[99,9],\"def_end_pos\":[99,50]}]"
+                ],
+                "state_after": "C : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsCofilteredOrEmpty C\nhF : F.Initial\n\u22a2 (\u2200 (d : D), \u2203 c, Nonempty (F.obj c \u27f6 d)) \u2227 \u2200 {d : D} {c : C} (s s' : F.obj c \u27f6 d), \u2203 c' t, F.map t \u226b s = F.map t \u226b s'",
+                "state_before": "C : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsCofilteredOrEmpty C\n\u22a2 F.Initial \u2194\n    (\u2200 (d : D), \u2203 c, Nonempty (F.obj c \u27f6 d)) \u2227\n      \u2200 {d : D} {c : C} (s s' : F.obj c \u27f6 d), \u2203 c' t, F.map t \u226b s = F.map t \u226b s'",
+                "tactic": "refine \u27e8fun hF => ?_, fun h => initial_of_exists_of_isCofiltered F h.1 h.2\u27e9"
+              },
+              {
+                "annotated_tactic": [
+                  "\"obtain \\u27e8h\\u2081, h\\u2082\\u27e9 := F.op.final_iff_of_isFiltered.mp <a>inferInstance<\\/a>\"",
+                  "[{\"full_name\":\"inferInstance\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[99,8],\"def_end_pos\":[99,21]}]"
+                ],
+                "state_after": "case intro\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsCofilteredOrEmpty C\nhF : F.Initial\nh\u2081 : \u2200 (d : D\u1d52\u1d56), \u2203 c, Nonempty (d \u27f6 F.op.obj c)\nh\u2082 : \u2200 {d : D\u1d52\u1d56} {c : C\u1d52\u1d56} (s s' : d \u27f6 F.op.obj c), \u2203 c' t, s \u226b F.op.map t = s' \u226b F.op.map t\n\u22a2 (\u2200 (d : D), \u2203 c, Nonempty (F.obj c \u27f6 d)) \u2227 \u2200 {d : D} {c : C} (s s' : F.obj c \u27f6 d), \u2203 c' t, F.map t \u226b s = F.map t \u226b s'",
+                "state_before": "C : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsCofilteredOrEmpty C\nhF : F.Initial\n\u22a2 (\u2200 (d : D), \u2203 c, Nonempty (F.obj c \u27f6 d)) \u2227 \u2200 {d : D} {c : C} (s s' : F.obj c \u27f6 d), \u2203 c' t, F.map t \u226b s = F.map t \u226b s'",
+                "tactic": "obtain \u27e8h\u2081, h\u2082\u27e9 := F.op.final_iff_of_isFiltered.mp inferInstance"
+              },
+              {
+                "annotated_tactic": [
+                  "\"refine \\u27e8?_, ?_\\u27e9\"",
+                  "[]"
+                ],
+                "state_after": "case intro.refine_1\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsCofilteredOrEmpty C\nhF : F.Initial\nh\u2081 : \u2200 (d : D\u1d52\u1d56), \u2203 c, Nonempty (d \u27f6 F.op.obj c)\nh\u2082 : \u2200 {d : D\u1d52\u1d56} {c : C\u1d52\u1d56} (s s' : d \u27f6 F.op.obj c), \u2203 c' t, s \u226b F.op.map t = s' \u226b F.op.map t\n\u22a2 \u2200 (d : D), \u2203 c, Nonempty (F.obj c \u27f6 d)\n\ncase intro.refine_2\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsCofilteredOrEmpty C\nhF : F.Initial\nh\u2081 : \u2200 (d : D\u1d52\u1d56), \u2203 c, Nonempty (d \u27f6 F.op.obj c)\nh\u2082 : \u2200 {d : D\u1d52\u1d56} {c : C\u1d52\u1d56} (s s' : d \u27f6 F.op.obj c), \u2203 c' t, s \u226b F.op.map t = s' \u226b F.op.map t\n\u22a2 \u2200 {d : D} {c : C} (s s' : F.obj c \u27f6 d), \u2203 c' t, F.map t \u226b s = F.map t \u226b s'",
+                "state_before": "case intro\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsCofilteredOrEmpty C\nhF : F.Initial\nh\u2081 : \u2200 (d : D\u1d52\u1d56), \u2203 c, Nonempty (d \u27f6 F.op.obj c)\nh\u2082 : \u2200 {d : D\u1d52\u1d56} {c : C\u1d52\u1d56} (s s' : d \u27f6 F.op.obj c), \u2203 c' t, s \u226b F.op.map t = s' \u226b F.op.map t\n\u22a2 (\u2200 (d : D), \u2203 c, Nonempty (F.obj c \u27f6 d)) \u2227 \u2200 {d : D} {c : C} (s s' : F.obj c \u27f6 d), \u2203 c' t, F.map t \u226b s = F.map t \u226b s'",
+                "tactic": "refine \u27e8?_, ?_\u27e9"
+              },
+              {
+                "annotated_tactic": [
+                  "\"intro d\"",
+                  "[]"
+                ],
+                "state_after": "case intro.refine_1\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsCofilteredOrEmpty C\nhF : F.Initial\nh\u2081 : \u2200 (d : D\u1d52\u1d56), \u2203 c, Nonempty (d \u27f6 F.op.obj c)\nh\u2082 : \u2200 {d : D\u1d52\u1d56} {c : C\u1d52\u1d56} (s s' : d \u27f6 F.op.obj c), \u2203 c' t, s \u226b F.op.map t = s' \u226b F.op.map t\nd : D\n\u22a2 \u2203 c, Nonempty (F.obj c \u27f6 d)",
+                "state_before": "case intro.refine_1\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsCofilteredOrEmpty C\nhF : F.Initial\nh\u2081 : \u2200 (d : D\u1d52\u1d56), \u2203 c, Nonempty (d \u27f6 F.op.obj c)\nh\u2082 : \u2200 {d : D\u1d52\u1d56} {c : C\u1d52\u1d56} (s s' : d \u27f6 F.op.obj c), \u2203 c' t, s \u226b F.op.map t = s' \u226b F.op.map t\n\u22a2 \u2200 (d : D), \u2203 c, Nonempty (F.obj c \u27f6 d)",
+                "tactic": "intro d"
+              },
+              {
+                "annotated_tactic": [
+                  "\"obtain \\u27e8c, \\u27e8t\\u27e9\\u27e9 := h\\u2081 (<a>op<\\/a> d)\"",
+                  "[{\"full_name\":\"Opposite.op\",\"def_path\":\"Mathlib\\/Data\\/Opposite.lean\",\"def_pos\":[37,3],\"def_end_pos\":[37,5]}]"
+                ],
+                "state_after": "case intro.refine_1.intro.intro\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsCofilteredOrEmpty C\nhF : F.Initial\nh\u2081 : \u2200 (d : D\u1d52\u1d56), \u2203 c, Nonempty (d \u27f6 F.op.obj c)\nh\u2082 : \u2200 {d : D\u1d52\u1d56} {c : C\u1d52\u1d56} (s s' : d \u27f6 F.op.obj c), \u2203 c' t, s \u226b F.op.map t = s' \u226b F.op.map t\nd : D\nc : C\u1d52\u1d56\nt : { unop := d } \u27f6 F.op.obj c\n\u22a2 \u2203 c, Nonempty (F.obj c \u27f6 d)",
+                "state_before": "case intro.refine_1\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsCofilteredOrEmpty C\nhF : F.Initial\nh\u2081 : \u2200 (d : D\u1d52\u1d56), \u2203 c, Nonempty (d \u27f6 F.op.obj c)\nh\u2082 : \u2200 {d : D\u1d52\u1d56} {c : C\u1d52\u1d56} (s s' : d \u27f6 F.op.obj c), \u2203 c' t, s \u226b F.op.map t = s' \u226b F.op.map t\nd : D\n\u22a2 \u2203 c, Nonempty (F.obj c \u27f6 d)",
+                "tactic": "obtain \u27e8c, \u27e8t\u27e9\u27e9 := h\u2081 (op d)"
+              },
+              {
+                "annotated_tactic": [
+                  "\"exact \\u27e8c.unop, \\u27e8t.unop\\u27e9\\u27e9\"",
+                  "[]"
+                ],
+                "state_after": "no goals",
+                "state_before": "case intro.refine_1.intro.intro\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsCofilteredOrEmpty C\nhF : F.Initial\nh\u2081 : \u2200 (d : D\u1d52\u1d56), \u2203 c, Nonempty (d \u27f6 F.op.obj c)\nh\u2082 : \u2200 {d : D\u1d52\u1d56} {c : C\u1d52\u1d56} (s s' : d \u27f6 F.op.obj c), \u2203 c' t, s \u226b F.op.map t = s' \u226b F.op.map t\nd : D\nc : C\u1d52\u1d56\nt : { unop := d } \u27f6 F.op.obj c\n\u22a2 \u2203 c, Nonempty (F.obj c \u27f6 d)",
+                "tactic": "exact \u27e8c.unop, \u27e8t.unop\u27e9\u27e9"
+              },
+              {
+                "annotated_tactic": [
+                  "\"intro d c s s'\"",
+                  "[]"
+                ],
+                "state_after": "case intro.refine_2\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsCofilteredOrEmpty C\nhF : F.Initial\nh\u2081 : \u2200 (d : D\u1d52\u1d56), \u2203 c, Nonempty (d \u27f6 F.op.obj c)\nh\u2082 : \u2200 {d : D\u1d52\u1d56} {c : C\u1d52\u1d56} (s s' : d \u27f6 F.op.obj c), \u2203 c' t, s \u226b F.op.map t = s' \u226b F.op.map t\nd : D\nc : C\ns s' : F.obj c \u27f6 d\n\u22a2 \u2203 c' t, F.map t \u226b s = F.map t \u226b s'",
+                "state_before": "case intro.refine_2\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsCofilteredOrEmpty C\nhF : F.Initial\nh\u2081 : \u2200 (d : D\u1d52\u1d56), \u2203 c, Nonempty (d \u27f6 F.op.obj c)\nh\u2082 : \u2200 {d : D\u1d52\u1d56} {c : C\u1d52\u1d56} (s s' : d \u27f6 F.op.obj c), \u2203 c' t, s \u226b F.op.map t = s' \u226b F.op.map t\n\u22a2 \u2200 {d : D} {c : C} (s s' : F.obj c \u27f6 d), \u2203 c' t, F.map t \u226b s = F.map t \u226b s'",
+                "tactic": "intro d c s s'"
+              },
+              {
+                "annotated_tactic": [
+                  "\"obtain \\u27e8c', t, ht\\u27e9 := h\\u2082 (<a>Quiver.Hom.op<\\/a> s) (<a>Quiver.Hom.op<\\/a> s')\"",
+                  "[{\"full_name\":\"Quiver.Hom.op\",\"def_path\":\"Mathlib\\/Combinatorics\\/Quiver\\/Basic.lean\",\"def_pos\":[152,5],\"def_end_pos\":[152,11]},{\"full_name\":\"Quiver.Hom.op\",\"def_path\":\"Mathlib\\/Combinatorics\\/Quiver\\/Basic.lean\",\"def_pos\":[152,5],\"def_end_pos\":[152,11]}]"
+                ],
+                "state_after": "case intro.refine_2.intro.intro\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsCofilteredOrEmpty C\nhF : F.Initial\nh\u2081 : \u2200 (d : D\u1d52\u1d56), \u2203 c, Nonempty (d \u27f6 F.op.obj c)\nh\u2082 : \u2200 {d : D\u1d52\u1d56} {c : C\u1d52\u1d56} (s s' : d \u27f6 F.op.obj c), \u2203 c' t, s \u226b F.op.map t = s' \u226b F.op.map t\nd : D\nc : C\ns s' : F.obj c \u27f6 d\nc' : C\u1d52\u1d56\nt : { unop := c } \u27f6 c'\nht : s.op \u226b F.op.map t = s'.op \u226b F.op.map t\n\u22a2 \u2203 c' t, F.map t \u226b s = F.map t \u226b s'",
+                "state_before": "case intro.refine_2\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsCofilteredOrEmpty C\nhF : F.Initial\nh\u2081 : \u2200 (d : D\u1d52\u1d56), \u2203 c, Nonempty (d \u27f6 F.op.obj c)\nh\u2082 : \u2200 {d : D\u1d52\u1d56} {c : C\u1d52\u1d56} (s s' : d \u27f6 F.op.obj c), \u2203 c' t, s \u226b F.op.map t = s' \u226b F.op.map t\nd : D\nc : C\ns s' : F.obj c \u27f6 d\n\u22a2 \u2203 c' t, F.map t \u226b s = F.map t \u226b s'",
+                "tactic": "obtain \u27e8c', t, ht\u27e9 := h\u2082 (Quiver.Hom.op s) (Quiver.Hom.op s')"
+              },
+              {
+                "annotated_tactic": [
+                  "\"exact \\u27e8c'.unop, t.unop, <a>Quiver.Hom.op_inj<\\/a> ht\\u27e9\"",
+                  "[{\"full_name\":\"Quiver.Hom.op_inj\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Opposites.lean\",\"def_pos\":[37,9],\"def_end_pos\":[37,26]}]"
+                ],
+                "state_after": "no goals",
+                "state_before": "case intro.refine_2.intro.intro\nC : Type v\u2081\ninst\u271d\u00b2 : Category.{v\u2081, v\u2081} C\nD : Type u\u2082\ninst\u271d\u00b9 : Category.{v\u2081, u\u2082} D\nF : C \u2964 D\ninst\u271d : IsCofilteredOrEmpty C\nhF : F.Initial\nh\u2081 : \u2200 (d : D\u1d52\u1d56), \u2203 c, Nonempty (d \u27f6 F.op.obj c)\nh\u2082 : \u2200 {d : D\u1d52\u1d56} {c : C\u1d52\u1d56} (s s' : d \u27f6 F.op.obj c), \u2203 c' t, s \u226b F.op.map t = s' \u226b F.op.map t\nd : D\nc : C\ns s' : F.obj c \u27f6 d\nc' : C\u1d52\u1d56\nt : { unop := c } \u27f6 c'\nht : s.op \u226b F.op.map t = s'.op \u226b F.op.map t\n\u22a2 \u2203 c' t, F.map t \u226b s = F.map t \u226b s'",
+                "tactic": "exact \u27e8c'.unop, t.unop, Quiver.Hom.op_inj ht\u27e9"
+              }
+            ],
+            "url": "https://github.com/leanprover-community/mathlib4"
+          }
+        },
+        "theorem_name": "CategoryTheory.Functor.initial_iff_of_isCofiltered"
+      },
+      {
+        "errors": [
+          "internal transition boundary mismatch"
+        ],
+        "file_path": "Mathlib/CategoryTheory/Filtered/Final.lean",
+        "proof_id": "mathlib:CategoryTheory.IsFilteredOrEmpty.of_exists_of_isFiltered_of_fullyFaithful",
+        "provenance": {
+          "selection": {
+            "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+            "end": [
+              117,
+              71
+            ],
+            "file_path": "Mathlib/CategoryTheory/Filtered/Final.lean",
+            "full_name": "CategoryTheory.IsFilteredOrEmpty.of_exists_of_isFiltered_of_fullyFaithful",
+            "start": [
+              108,
+              1
+            ],
+            "traced_tactics": [
+              {
+                "annotated_tactic": [
+                  "\"obtain \\u27e8c\\u2080, \\u27e8f\\u27e9\\u27e9 := h (<a>IsFiltered.max<\\/a> (F.obj c) (F.obj c'))\"",
+                  "[{\"full_name\":\"CategoryTheory.IsFiltered.max\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Basic.lean\",\"def_pos\":[155,19],\"def_end_pos\":[155,22]}]"
+                ],
+                "state_after": "case intro.intro\nC : Type u\u2081\ninst\u271d\u2074 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b3 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d\u00b2 : IsFilteredOrEmpty D\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nh : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nc c' c\u2080 : C\nf : IsFiltered.max (F.obj c) (F.obj c') \u27f6 F.obj c\u2080\n\u22a2 \u2203 Z x x, True",
+                "state_before": "C : Type u\u2081\ninst\u271d\u2074 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b3 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d\u00b2 : IsFilteredOrEmpty D\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nh : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nc c' : C\n\u22a2 \u2203 Z x x, True",
+                "tactic": "obtain \u27e8c\u2080, \u27e8f\u27e9\u27e9 := h (IsFiltered.max (F.obj c) (F.obj c'))"
+              },
+              {
+                "annotated_tactic": [
+                  "\"exact \\u27e8c\\u2080, F.preimage (<a>IsFiltered.leftToMax<\\/a> _ _ \\u226b f),\\n      F.preimage (<a>IsFiltered.rightToMax<\\/a> _ _ \\u226b f), <a>trivial<\\/a>\\u27e9\"",
+                  "[{\"full_name\":\"CategoryTheory.IsFiltered.leftToMax\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Basic.lean\",\"def_pos\":[162,19],\"def_end_pos\":[162,28]},{\"full_name\":\"CategoryTheory.IsFiltered.rightToMax\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Basic.lean\",\"def_pos\":[169,19],\"def_end_pos\":[169,29]},{\"full_name\":\"trivial\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Core.lean\",\"def_pos\":[645,35],\"def_end_pos\":[645,42]}]"
+                ],
+                "state_after": "no goals",
+                "state_before": "case intro.intro\nC : Type u\u2081\ninst\u271d\u2074 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b3 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d\u00b2 : IsFilteredOrEmpty D\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nh : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nc c' c\u2080 : C\nf : IsFiltered.max (F.obj c) (F.obj c') \u27f6 F.obj c\u2080\n\u22a2 \u2203 Z x x, True",
+                "tactic": "exact \u27e8c\u2080, F.preimage (IsFiltered.leftToMax _ _ \u226b f),\n  F.preimage (IsFiltered.rightToMax _ _ \u226b f), trivial\u27e9"
+              },
+              {
+                "annotated_tactic": [
+                  "\"obtain \\u27e8c\\u2080, \\u27e8f\\u2080\\u27e9\\u27e9 := h (<a>IsFiltered.coeq<\\/a> (F.map f) (F.map g))\"",
+                  "[{\"full_name\":\"CategoryTheory.IsFiltered.coeq\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Basic.lean\",\"def_pos\":[178,19],\"def_end_pos\":[178,23]}]"
+                ],
+                "state_after": "case intro.intro\nC : Type u\u2081\ninst\u271d\u2074 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b3 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d\u00b2 : IsFilteredOrEmpty D\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nh : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nc c' : C\nf g : c \u27f6 c'\nc\u2080 : C\nf\u2080 : IsFiltered.coeq (F.map f) (F.map g) \u27f6 F.obj c\u2080\n\u22a2 \u2203 Z h, f \u226b h = g \u226b h",
+                "state_before": "C : Type u\u2081\ninst\u271d\u2074 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b3 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d\u00b2 : IsFilteredOrEmpty D\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nh : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nc c' : C\nf g : c \u27f6 c'\n\u22a2 \u2203 Z h, f \u226b h = g \u226b h",
+                "tactic": "obtain \u27e8c\u2080, \u27e8f\u2080\u27e9\u27e9 := h (IsFiltered.coeq (F.map f) (F.map g))"
+              },
+              {
+                "annotated_tactic": [
+                  "\"refine \\u27e8_, F.preimage (<a>IsFiltered.coeqHom<\\/a> (F.map f) (F.map g) \\u226b f\\u2080), F.map_injective ?_\\u27e9\"",
+                  "[{\"full_name\":\"CategoryTheory.IsFiltered.coeqHom\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Basic.lean\",\"def_pos\":[187,19],\"def_end_pos\":[187,26]}]"
+                ],
+                "state_after": "case intro.intro\nC : Type u\u2081\ninst\u271d\u2074 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b3 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d\u00b2 : IsFilteredOrEmpty D\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nh : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nc c' : C\nf g : c \u27f6 c'\nc\u2080 : C\nf\u2080 : IsFiltered.coeq (F.map f) (F.map g) \u27f6 F.obj c\u2080\n\u22a2 F.map (f \u226b F.preimage (IsFiltered.coeqHom (F.map f) (F.map g) \u226b f\u2080)) =\n    F.map (g \u226b F.preimage (IsFiltered.coeqHom (F.map f) (F.map g) \u226b f\u2080))",
+                "state_before": "case intro.intro\nC : Type u\u2081\ninst\u271d\u2074 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b3 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d\u00b2 : IsFilteredOrEmpty D\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nh : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nc c' : C\nf g : c \u27f6 c'\nc\u2080 : C\nf\u2080 : IsFiltered.coeq (F.map f) (F.map g) \u27f6 F.obj c\u2080\n\u22a2 \u2203 Z h, f \u226b h = g \u226b h",
+                "tactic": "refine \u27e8_, F.preimage (IsFiltered.coeqHom (F.map f) (F.map g) \u226b f\u2080), F.map_injective ?_\u27e9"
+              },
+              {
+                "annotated_tactic": [
+                  "\"simp [reassoc_of% (<a>IsFiltered.coeq_condition<\\/a> (F.map f) (F.map g))]\"",
+                  "[{\"full_name\":\"CategoryTheory.IsFiltered.coeq_condition\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Basic.lean\",\"def_pos\":[196,9],\"def_end_pos\":[196,23]}]"
+                ],
+                "state_after": "no goals",
+                "state_before": "case intro.intro\nC : Type u\u2081\ninst\u271d\u2074 : Category.{v\u2081, u\u2081} C\nD : Type u\u2082\ninst\u271d\u00b3 : Category.{v\u2082, u\u2082} D\nF : C \u2964 D\ninst\u271d\u00b2 : IsFilteredOrEmpty D\ninst\u271d\u00b9 : F.Full\ninst\u271d : F.Faithful\nh : \u2200 (d : D), \u2203 c, Nonempty (d \u27f6 F.obj c)\nc c' : C\nf g : c \u27f6 c'\nc\u2080 : C\nf\u2080 : IsFiltered.coeq (F.map f) (F.map g) \u27f6 F.obj c\u2080\n\u22a2 F.map (f \u226b F.preimage (IsFiltered.coeqHom (F.map f) (F.map g) \u226b f\u2080)) =\n    F.map (g \u226b F.preimage (IsFiltered.coeqHom (F.map f) (F.map g) \u226b f\u2080))",
+                "tactic": "simp [reassoc_of% (IsFiltered.coeq_condition (F.map f) (F.map g))]"
+              }
+            ],
+            "url": "https://github.com/leanprover-community/mathlib4"
+          }
+        },
+        "theorem_name": "CategoryTheory.IsFilteredOrEmpty.of_exists_of_isFiltered_of_fullyFaithful"
+      }
+    ],
+    "validation_rejected_proofs": 2,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/mathlib-000642-0000-56d6a8c49c11f339.parquet",
+      "sha256": "56d6a8c49c11f339b26b137ffb8da2abedbb45130d25bb409caca9b016ff101b",
+      "bytes": 104791,
+      "rows": 29,
+      "revision": "6a3d2d550a5e8f26af70e44381b84ab7563dc62c"
+    }
+  ],
+  "proof_ids": [
+    "mathlib:CategoryTheory.Functor.final_iff_isFiltered_structuredArrow",
+    "mathlib:CategoryTheory.Functor.final_of_exists_of_isFiltered",
+    "mathlib:CategoryTheory.Functor.final_of_exists_of_isFiltered_of_fullyFaithful",
+    "mathlib:CategoryTheory.Functor.initial_iff_isCofiltered_costructuredArrow",
+    "mathlib:CategoryTheory.Functor.initial_of_exists_of_isCofiltered",
+    "mathlib:CategoryTheory.Functor.initial_of_exists_of_isCofiltered_of_fullyFaithful",
+    "mathlib:CategoryTheory.IsCofiltered.of_exists_of_isCofiltered_of_fullyFaithful",
+    "mathlib:CategoryTheory.IsCofilteredOrEmpty.of_exists_of_isCofiltered_of_fullyFaithful",
+    "mathlib:CategoryTheory.IsFiltered.of_exists_of_isFiltered_of_fullyFaithful"
+  ],
+  "proof_keys": [
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Filtered/Final.lean\",null,null,\"CategoryTheory.Functor.final_iff_isFiltered_structuredArrow\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Filtered/Final.lean\",null,null,\"CategoryTheory.Functor.final_of_exists_of_isFiltered\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Filtered/Final.lean\",null,null,\"CategoryTheory.Functor.final_of_exists_of_isFiltered_of_fullyFaithful\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Filtered/Final.lean\",null,null,\"CategoryTheory.Functor.initial_iff_isCofiltered_costructuredArrow\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Filtered/Final.lean\",null,null,\"CategoryTheory.Functor.initial_of_exists_of_isCofiltered\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Filtered/Final.lean\",null,null,\"CategoryTheory.Functor.initial_of_exists_of_isCofiltered_of_fullyFaithful\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Filtered/Final.lean\",null,null,\"CategoryTheory.IsCofiltered.of_exists_of_isCofiltered_of_fullyFaithful\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Filtered/Final.lean\",null,null,\"CategoryTheory.IsCofilteredOrEmpty.of_exists_of_isCofiltered_of_fullyFaithful\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Filtered/Final.lean\",null,null,\"CategoryTheory.IsFiltered.of_exists_of_isFiltered_of_fullyFaithful\"]"
+  ]
+}

manifests/batches/mathlib/000643.json

@@ -0,0 +1,484 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "mathlib/000643",
+  "batch_fingerprint": "e2b02e758889f82194ba1c67556d24a7f7a1e0e38068b36d4529044e68f4c447",
+  "evidence": {
+    "batch_fingerprint": "e2b02e758889f82194ba1c67556d24a7f7a1e0e38068b36d4529044e68f4c447",
+    "contamination_matches": [],
+    "failures": [
+      {
+        "error": "no internal trace for tactic 'exact \u27e8\u27e80, \u27e8x\u27e9\u27e9, rfl\u27e9'",
+        "full_name": "CategoryTheory.IsCofiltered.small_fullSubcategory_cofilteredClosure",
+        "id": "CategoryTheory.IsCofiltered.small_fullSubcategory_cofilteredClosure",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            250,
+            55
+          ],
+          "file_path": "Mathlib/CategoryTheory/Filtered/Small.lean",
+          "full_name": "CategoryTheory.IsCofiltered.small_fullSubcategory_cofilteredClosure",
+          "start": [
+            232,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"refine <a>small_of_injective_of_exists<\\/a>\\n    (<a>CofilteredClosureSmall.abstractCofilteredClosureRealization<\\/a> f) <a>FullSubcategory.ext<\\/a> ?_\"",
+                "[{\"full_name\":\"small_of_injective_of_exists\",\"def_path\":\"Mathlib\\/Logic\\/Small\\/Basic.lean\",\"def_pos\":[46,9],\"def_end_pos\":[46,37]},{\"full_name\":\"_private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Small.lean\",\"def_pos\":[227,27],\"def_end_pos\":[227,63]},{\"full_name\":\"CategoryTheory.FullSubcategory.ext\",\"def_path\":\"Mathlib\\/CategoryTheory\\/FullSubcategory.lean\",\"def_pos\":[108,3],\"def_end_pos\":[108,6]}]"
+              ],
+              "state_after": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\n\u22a2 \u2200 (b : FullSubcategory (CofilteredClosure f)),\n    \u2203 a, CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f a = b.obj",
+              "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\n\u22a2 Small.{max v w, u} (FullSubcategory (CofilteredClosure f))",
+              "tactic": "refine small_of_injective_of_exists\n  (CofilteredClosureSmall.abstractCofilteredClosureRealization f) FullSubcategory.ext ?_"
+            },
+            {
+              "annotated_tactic": [
+                "\"rintro \\u27e8j, h\\u27e9\"",
+                "[]"
+              ],
+              "state_after": "case mk\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nh : CofilteredClosure f j\n\u22a2 \u2203 a,\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f a =\n      { obj := j, property := h }.obj",
+              "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\n\u22a2 \u2200 (b : FullSubcategory (CofilteredClosure f)),\n    \u2203 a, CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f a = b.obj",
+              "tactic": "rintro \u27e8j, h\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"induction h with\\n  | <a>base<\\/a> x => exact \\u27e8\\u27e80, \\u27e8x\\u27e9\\u27e9, <a>rfl<\\/a>\\u27e9\\n  | <a>min<\\/a> hj\\u2081 hj\\u2082 ih ih' =>\\n    rcases ih with \\u27e8\\u27e8n, x\\u27e9, rfl\\u27e9\\n    rcases ih' with \\u27e8\\u27e8m, y\\u27e9, rfl\\u27e9\\n    refine \\u27e8\\u27e8(<a>Max.max<\\/a> n m).<a>succ<\\/a>, <a>CofilteredClosureSmall.InductiveStep.min<\\/a> ?_ ?_ x y\\u27e9, <a>rfl<\\/a>\\u27e9\\n    all_goals apply <a>Nat.lt_succ_of_le<\\/a>\\n    exacts [<a>Nat.le_max_left<\\/a> _ _, <a>Nat.le_max_right<\\/a> _ _]\\n  | <a>eq<\\/a> hj\\u2081 hj\\u2082 g g' ih ih' =>\\n    rcases ih with \\u27e8\\u27e8n, x\\u27e9, rfl\\u27e9\\n    rcases ih' with \\u27e8\\u27e8m, y\\u27e9, rfl\\u27e9\\n    refine \\u27e8\\u27e8(<a>Max.max<\\/a> n m).<a>succ<\\/a>, <a>CofilteredClosureSmall.InductiveStep.eq<\\/a> ?_ ?_ x y g g'\\u27e9, <a>rfl<\\/a>\\u27e9\\n    all_goals apply <a>Nat.lt_succ_of_le<\\/a>\\n    exacts [<a>Nat.le_max_left<\\/a> _ _, <a>Nat.le_max_right<\\/a> _ _]\"",
+                "[{\"full_name\":\"CategoryTheory.IsCofiltered.CofilteredClosure.base\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Small.lean\",\"def_pos\":[181,5],\"def_end_pos\":[181,9]},{\"full_name\":\"rfl\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[294,22],\"def_end_pos\":[294,25]},{\"full_name\":\"CategoryTheory.IsCofiltered.CofilteredClosure.min\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Small.lean\",\"def_pos\":[182,5],\"def_end_pos\":[182,8]},{\"full_name\":\"Max.max\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[1129,3],\"def_end_pos\":[1129,6]},{\"full_name\":\"Nat.succ\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[1083,5],\"def_end_pos\":[1083,9]},{\"full_name\":\"_private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsCofiltered.CofilteredClosureSmall.InductiveStep.min\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Small.lean\",\"def_pos\":[199,5],\"def_end_pos\":[199,8]},{\"full_name\":\"rfl\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[294,22],\"def_end_pos\":[294,25]},{\"full_name\":\"Nat.lt_succ_of_le\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/Basic.lean\",\"def_pos\":[262,9],\"def_end_pos\":[262,22]},{\"full_name\":\"Nat.le_max_left\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/MinMax.lean\",\"def_pos\":[53,19],\"def_end_pos\":[53,30]},{\"full_name\":\"Nat.le_max_right\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/MinMax.lean\",\"def_pos\":[55,19],\"def_end_pos\":[55,31]},{\"full_name\":\"CategoryTheory.IsCofiltered.CofilteredClosure.eq\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Small.lean\",\"def_pos\":[183,5],\"def_end_pos\":[183,7]},{\"full_name\":\"Max.max\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[1129,3],\"def_end_pos\":[1129,6]},{\"full_name\":\"Nat.succ\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[1083,5],\"def_end_pos\":[1083,9]},{\"full_name\":\"_private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsCofiltered.CofilteredClosureSmall.InductiveStep.eq\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Small.lean\",\"def_pos\":[200,5],\"def_end_pos\":[200,7]},{\"full_name\":\"rfl\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[294,22],\"def_end_pos\":[294,25]},{\"full_name\":\"Nat.lt_succ_of_le\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/Basic.lean\",\"def_pos\":[262,9],\"def_end_pos\":[262,22]},{\"full_name\":\"Nat.le_max_left\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/MinMax.lean\",\"def_pos\":[53,19],\"def_end_pos\":[53,30]},{\"full_name\":\"Nat.le_max_right\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/MinMax.lean\",\"def_pos\":[55,19],\"def_end_pos\":[55,31]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case mk\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nh : CofilteredClosure f j\n\u22a2 \u2203 a,\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f a =\n      { obj := j, property := h }.obj",
+              "tactic": "induction h with\n| base x => exact \u27e8\u27e80, \u27e8x\u27e9\u27e9, rfl\u27e9\n| min hj\u2081 hj\u2082 ih ih' =>\n  rcases ih with \u27e8\u27e8n, x\u27e9, rfl\u27e9\n  rcases ih' with \u27e8\u27e8m, y\u27e9, rfl\u27e9\n  refine \u27e8\u27e8(Max.max n m).succ, CofilteredClosureSmall.InductiveStep.min ?_ ?_ x y\u27e9, rfl\u27e9\n  all_goals apply Nat.lt_succ_of_le\n  exacts [Nat.le_max_left _ _, Nat.le_max_right _ _]\n| eq hj\u2081 hj\u2082 g g' ih ih' =>\n  rcases ih with \u27e8\u27e8n, x\u27e9, rfl\u27e9\n  rcases ih' with \u27e8\u27e8m, y\u27e9, rfl\u27e9\n  refine \u27e8\u27e8(Max.max n m).succ, CofilteredClosureSmall.InductiveStep.eq ?_ ?_ x y g g'\u27e9, rfl\u27e9\n  all_goals apply Nat.lt_succ_of_le\n  exacts [Nat.le_max_left _ _, Nat.le_max_right _ _]"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact \\u27e8\\u27e80, \\u27e8x\\u27e9\\u27e9, <a>rfl<\\/a>\\u27e9\"",
+                "[{\"full_name\":\"rfl\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[294,22],\"def_end_pos\":[294,25]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case mk.base\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nx : \u03b1\n\u22a2 \u2203 a,\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f a =\n      { obj := f x, property := \u22ef }.obj",
+              "tactic": "exact \u27e8\u27e80, \u27e8x\u27e9\u27e9, rfl\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"rcases ih with \\u27e8\\u27e8n, x\\u27e9, rfl\\u27e9\"",
+                "[]"
+              ],
+              "state_after": "case mk.min.intro.mk\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj j'\u271d : C\nhj\u2082 : CofilteredClosure f j'\u271d\nih' :\n  \u2203 a,\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f a =\n      { obj := j'\u271d, property := hj\u2082 }.obj\nn : \u2115\nx : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f n).fst\nhj\u2081 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\n\u22a2 \u2203 a,\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f a =\n      {\n          obj :=\n            min (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9) j'\u271d,\n          property := \u22ef }.obj",
+              "state_before": "case mk.min\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj j\u271d j'\u271d : C\nhj\u2081 : CofilteredClosure f j\u271d\nhj\u2082 : CofilteredClosure f j'\u271d\nih :\n  \u2203 a,\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f a =\n      { obj := j\u271d, property := hj\u2081 }.obj\nih' :\n  \u2203 a,\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f a =\n      { obj := j'\u271d, property := hj\u2082 }.obj\n\u22a2 \u2203 a,\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f a =\n      { obj := min j\u271d j'\u271d, property := \u22ef }.obj",
+              "tactic": "rcases ih with \u27e8\u27e8n, x\u27e9, rfl\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"rcases ih' with \\u27e8\\u27e8m, y\\u27e9, rfl\\u27e9\"",
+                "[]"
+              ],
+              "state_after": "case mk.min.intro.mk.intro.mk\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f n).fst\nhj\u2081 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f m).fst\nhj\u2082 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9)\n\u22a2 \u2203 a,\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f a =\n      {\n          obj :=\n            min (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\n              (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9),\n          property := \u22ef }.obj",
+              "state_before": "case mk.min.intro.mk\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj j'\u271d : C\nhj\u2082 : CofilteredClosure f j'\u271d\nih' :\n  \u2203 a,\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f a =\n      { obj := j'\u271d, property := hj\u2082 }.obj\nn : \u2115\nx : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f n).fst\nhj\u2081 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\n\u22a2 \u2203 a,\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f a =\n      {\n          obj :=\n            min (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9) j'\u271d,\n          property := \u22ef }.obj",
+              "tactic": "rcases ih' with \u27e8\u27e8m, y\u27e9, rfl\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"refine \\u27e8\\u27e8(<a>Max.max<\\/a> n m).<a>succ<\\/a>, <a>CofilteredClosureSmall.InductiveStep.min<\\/a> ?_ ?_ x y\\u27e9, <a>rfl<\\/a>\\u27e9\"",
+                "[{\"full_name\":\"Max.max\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[1129,3],\"def_end_pos\":[1129,6]},{\"full_name\":\"Nat.succ\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[1083,5],\"def_end_pos\":[1083,9]},{\"full_name\":\"_private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsCofiltered.CofilteredClosureSmall.InductiveStep.min\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Small.lean\",\"def_pos\":[199,5],\"def_end_pos\":[199,8]},{\"full_name\":\"rfl\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[294,22],\"def_end_pos\":[294,25]}]"
+              ],
+              "state_after": "case mk.min.intro.mk.intro.mk.refine_1\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f n).fst\nhj\u2081 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f m).fst\nhj\u2082 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9)\n\u22a2 n < max n m + 1\n\ncase mk.min.intro.mk.intro.mk.refine_2\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f n).fst\nhj\u2081 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f m).fst\nhj\u2082 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9)\n\u22a2 m < max n m + 1",
+              "state_before": "case mk.min.intro.mk.intro.mk\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f n).fst\nhj\u2081 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f m).fst\nhj\u2082 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9)\n\u22a2 \u2203 a,\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f a =\n      {\n          obj :=\n            min (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\n              (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9),\n          property := \u22ef }.obj",
+              "tactic": "refine \u27e8\u27e8(Max.max n m).succ, CofilteredClosureSmall.InductiveStep.min ?_ ?_ x y\u27e9, rfl\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"all_goals apply <a>Nat.lt_succ_of_le<\\/a>\"",
+                "[{\"full_name\":\"Nat.lt_succ_of_le\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/Basic.lean\",\"def_pos\":[262,9],\"def_end_pos\":[262,22]}]"
+              ],
+              "state_after": "case mk.min.intro.mk.intro.mk.refine_1.a\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f n).fst\nhj\u2081 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f m).fst\nhj\u2082 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9)\n\u22a2 n \u2264 max n m\n\ncase mk.min.intro.mk.intro.mk.refine_2.a\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f n).fst\nhj\u2081 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f m).fst\nhj\u2082 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9)\n\u22a2 m \u2264 max n m",
+              "state_before": "case mk.min.intro.mk.intro.mk.refine_1\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f n).fst\nhj\u2081 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f m).fst\nhj\u2082 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9)\n\u22a2 n < max n m + 1\n\ncase mk.min.intro.mk.intro.mk.refine_2\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f n).fst\nhj\u2081 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f m).fst\nhj\u2082 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9)\n\u22a2 m < max n m + 1",
+              "tactic": "all_goals apply Nat.lt_succ_of_le"
+            },
+            {
+              "annotated_tactic": [
+                "\"exacts [<a>Nat.le_max_left<\\/a> _ _, <a>Nat.le_max_right<\\/a> _ _]\"",
+                "[{\"full_name\":\"Nat.le_max_left\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/MinMax.lean\",\"def_pos\":[53,19],\"def_end_pos\":[53,30]},{\"full_name\":\"Nat.le_max_right\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/MinMax.lean\",\"def_pos\":[55,19],\"def_end_pos\":[55,31]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case mk.min.intro.mk.intro.mk.refine_1.a\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f n).fst\nhj\u2081 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f m).fst\nhj\u2082 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9)\n\u22a2 n \u2264 max n m\n\ncase mk.min.intro.mk.intro.mk.refine_2.a\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f n).fst\nhj\u2081 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f m).fst\nhj\u2082 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9)\n\u22a2 m \u2264 max n m",
+              "tactic": "exacts [Nat.le_max_left _ _, Nat.le_max_right _ _]"
+            },
+            {
+              "annotated_tactic": [
+                "\"apply <a>Nat.lt_succ_of_le<\\/a>\"",
+                "[{\"full_name\":\"Nat.lt_succ_of_le\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/Basic.lean\",\"def_pos\":[262,9],\"def_end_pos\":[262,22]}]"
+              ],
+              "state_after": "case mk.min.intro.mk.intro.mk.refine_2.a\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f n).fst\nhj\u2081 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f m).fst\nhj\u2082 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9)\n\u22a2 m \u2264 max n m",
+              "state_before": "case mk.min.intro.mk.intro.mk.refine_2\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f n).fst\nhj\u2081 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f m).fst\nhj\u2082 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9)\n\u22a2 m < max n m + 1",
+              "tactic": "apply Nat.lt_succ_of_le"
+            },
+            {
+              "annotated_tactic": [
+                "\"rcases ih with \\u27e8\\u27e8n, x\\u27e9, rfl\\u27e9\"",
+                "[]"
+              ],
+              "state_after": "case mk.eq.intro.mk\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj j'\u271d : C\nhj\u2082 : CofilteredClosure f j'\u271d\nih' :\n  \u2203 a,\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f a =\n      { obj := j'\u271d, property := hj\u2082 }.obj\nn : \u2115\nx : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f n).fst\nhj\u2081 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\ng g' : CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9 \u27f6 j'\u271d\n\u22a2 \u2203 a,\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f a =\n      { obj := eq g g', property := \u22ef }.obj",
+              "state_before": "case mk.eq\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj j\u271d j'\u271d : C\nhj\u2081 : CofilteredClosure f j\u271d\nhj\u2082 : CofilteredClosure f j'\u271d\ng g' : j\u271d \u27f6 j'\u271d\nih :\n  \u2203 a,\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f a =\n      { obj := j\u271d, property := hj\u2081 }.obj\nih' :\n  \u2203 a,\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f a =\n      { obj := j'\u271d, property := hj\u2082 }.obj\n\u22a2 \u2203 a,\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f a =\n      { obj := eq g g', property := \u22ef }.obj",
+              "tactic": "rcases ih with \u27e8\u27e8n, x\u27e9, rfl\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"rcases ih' with \\u27e8\\u27e8m, y\\u27e9, rfl\\u27e9\"",
+                "[]"
+              ],
+              "state_after": "case mk.eq.intro.mk.intro.mk\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f n).fst\nhj\u2081 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f m).fst\nhj\u2082 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9)\ng g' :\n  CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9 \u27f6\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9\n\u22a2 \u2203 a,\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f a =\n      { obj := eq g g', property := \u22ef }.obj",
+              "state_before": "case mk.eq.intro.mk\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj j'\u271d : C\nhj\u2082 : CofilteredClosure f j'\u271d\nih' :\n  \u2203 a,\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f a =\n      { obj := j'\u271d, property := hj\u2082 }.obj\nn : \u2115\nx : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f n).fst\nhj\u2081 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\ng g' : CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9 \u27f6 j'\u271d\n\u22a2 \u2203 a,\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f a =\n      { obj := eq g g', property := \u22ef }.obj",
+              "tactic": "rcases ih' with \u27e8\u27e8m, y\u27e9, rfl\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"refine \\u27e8\\u27e8(<a>Max.max<\\/a> n m).<a>succ<\\/a>, <a>CofilteredClosureSmall.InductiveStep.eq<\\/a> ?_ ?_ x y g g'\\u27e9, <a>rfl<\\/a>\\u27e9\"",
+                "[{\"full_name\":\"Max.max\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[1129,3],\"def_end_pos\":[1129,6]},{\"full_name\":\"Nat.succ\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[1083,5],\"def_end_pos\":[1083,9]},{\"full_name\":\"_private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsCofiltered.CofilteredClosureSmall.InductiveStep.eq\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Small.lean\",\"def_pos\":[200,5],\"def_end_pos\":[200,7]},{\"full_name\":\"rfl\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[294,22],\"def_end_pos\":[294,25]}]"
+              ],
+              "state_after": "case mk.eq.intro.mk.intro.mk.refine_1\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f n).fst\nhj\u2081 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f m).fst\nhj\u2082 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9)\ng g' :\n  CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9 \u27f6\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9\n\u22a2 n < max n m + 1\n\ncase mk.eq.intro.mk.intro.mk.refine_2\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f n).fst\nhj\u2081 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f m).fst\nhj\u2082 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9)\ng g' :\n  CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9 \u27f6\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9\n\u22a2 m < max n m + 1",
+              "state_before": "case mk.eq.intro.mk.intro.mk\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f n).fst\nhj\u2081 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f m).fst\nhj\u2082 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9)\ng g' :\n  CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9 \u27f6\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9\n\u22a2 \u2203 a,\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f a =\n      { obj := eq g g', property := \u22ef }.obj",
+              "tactic": "refine \u27e8\u27e8(Max.max n m).succ, CofilteredClosureSmall.InductiveStep.eq ?_ ?_ x y g g'\u27e9, rfl\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"all_goals apply <a>Nat.lt_succ_of_le<\\/a>\"",
+                "[{\"full_name\":\"Nat.lt_succ_of_le\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/Basic.lean\",\"def_pos\":[262,9],\"def_end_pos\":[262,22]}]"
+              ],
+              "state_after": "case mk.eq.intro.mk.intro.mk.refine_1.a\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f n).fst\nhj\u2081 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f m).fst\nhj\u2082 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9)\ng g' :\n  CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9 \u27f6\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9\n\u22a2 n \u2264 max n m\n\ncase mk.eq.intro.mk.intro.mk.refine_2.a\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f n).fst\nhj\u2081 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f m).fst\nhj\u2082 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9)\ng g' :\n  CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9 \u27f6\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9\n\u22a2 m \u2264 max n m",
+              "state_before": "case mk.eq.intro.mk.intro.mk.refine_1\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f n).fst\nhj\u2081 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f m).fst\nhj\u2082 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9)\ng g' :\n  CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9 \u27f6\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9\n\u22a2 n < max n m + 1\n\ncase mk.eq.intro.mk.intro.mk.refine_2\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f n).fst\nhj\u2081 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f m).fst\nhj\u2082 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9)\ng g' :\n  CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9 \u27f6\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9\n\u22a2 m < max n m + 1",
+              "tactic": "all_goals apply Nat.lt_succ_of_le"
+            },
+            {
+              "annotated_tactic": [
+                "\"exacts [<a>Nat.le_max_left<\\/a> _ _, <a>Nat.le_max_right<\\/a> _ _]\"",
+                "[{\"full_name\":\"Nat.le_max_left\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/MinMax.lean\",\"def_pos\":[53,19],\"def_end_pos\":[53,30]},{\"full_name\":\"Nat.le_max_right\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/MinMax.lean\",\"def_pos\":[55,19],\"def_end_pos\":[55,31]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case mk.eq.intro.mk.intro.mk.refine_1.a\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f n).fst\nhj\u2081 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f m).fst\nhj\u2082 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9)\ng g' :\n  CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9 \u27f6\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9\n\u22a2 n \u2264 max n m\n\ncase mk.eq.intro.mk.intro.mk.refine_2.a\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f n).fst\nhj\u2081 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f m).fst\nhj\u2082 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9)\ng g' :\n  CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9 \u27f6\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9\n\u22a2 m \u2264 max n m",
+              "tactic": "exacts [Nat.le_max_left _ _, Nat.le_max_right _ _]"
+            },
+            {
+              "annotated_tactic": [
+                "\"apply <a>Nat.lt_succ_of_le<\\/a>\"",
+                "[{\"full_name\":\"Nat.lt_succ_of_le\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/Basic.lean\",\"def_pos\":[262,9],\"def_end_pos\":[262,22]}]"
+              ],
+              "state_after": "case mk.eq.intro.mk.intro.mk.refine_2.a\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f n).fst\nhj\u2081 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f m).fst\nhj\u2082 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9)\ng g' :\n  CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9 \u27f6\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9\n\u22a2 m \u2264 max n m",
+              "state_before": "case mk.eq.intro.mk.intro.mk.refine_2\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsCofilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f n).fst\nhj\u2081 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsCofiltered.CofilteredClosureSmall.bundledAbstractCofilteredClosure f m).fst\nhj\u2082 :\n  CofilteredClosure f (CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9)\ng g' :\n  CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8n, x\u27e9 \u27f6\n    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f \u27e8m, y\u27e9\n\u22a2 m < max n m + 1",
+              "tactic": "apply Nat.lt_succ_of_le"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Filtered/Small.lean"
+      },
+      {
+        "error": "no internal trace for tactic 'exact \u27e8\u27e80, \u27e8x\u27e9\u27e9, rfl\u27e9'",
+        "full_name": "CategoryTheory.IsFiltered.small_fullSubcategory_filteredClosure",
+        "id": "CategoryTheory.IsFiltered.small_fullSubcategory_filteredClosure",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            115,
+            55
+          ],
+          "file_path": "Mathlib/CategoryTheory/Filtered/Small.lean",
+          "full_name": "CategoryTheory.IsFiltered.small_fullSubcategory_filteredClosure",
+          "start": [
+            97,
+            1
+          ],
+          "traced_tactics": [
+            {
+              "annotated_tactic": [
+                "\"refine <a>small_of_injective_of_exists<\\/a> (<a>FilteredClosureSmall.abstractFilteredClosureRealization<\\/a> f)\\n    <a>FullSubcategory.ext<\\/a> ?_\"",
+                "[{\"full_name\":\"small_of_injective_of_exists\",\"def_path\":\"Mathlib\\/Logic\\/Small\\/Basic.lean\",\"def_pos\":[46,9],\"def_end_pos\":[46,37]},{\"full_name\":\"_private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Small.lean\",\"def_pos\":[92,27],\"def_end_pos\":[92,61]},{\"full_name\":\"CategoryTheory.FullSubcategory.ext\",\"def_path\":\"Mathlib\\/CategoryTheory\\/FullSubcategory.lean\",\"def_pos\":[108,3],\"def_end_pos\":[108,6]}]"
+              ],
+              "state_after": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\n\u22a2 \u2200 (b : FullSubcategory (FilteredClosure f)),\n    \u2203 a, CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f a = b.obj",
+              "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\n\u22a2 Small.{max v w, u} (FullSubcategory (FilteredClosure f))",
+              "tactic": "refine small_of_injective_of_exists (FilteredClosureSmall.abstractFilteredClosureRealization f)\n  FullSubcategory.ext ?_"
+            },
+            {
+              "annotated_tactic": [
+                "\"rintro \\u27e8j, h\\u27e9\"",
+                "[]"
+              ],
+              "state_after": "case mk\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nh : FilteredClosure f j\n\u22a2 \u2203 a,\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f a =\n      { obj := j, property := h }.obj",
+              "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\n\u22a2 \u2200 (b : FullSubcategory (FilteredClosure f)),\n    \u2203 a, CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f a = b.obj",
+              "tactic": "rintro \u27e8j, h\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"induction h with\\n  | <a>base<\\/a> x => exact \\u27e8\\u27e80, \\u27e8x\\u27e9\\u27e9, <a>rfl<\\/a>\\u27e9\\n  | <a>max<\\/a> hj\\u2081 hj\\u2082 ih ih' =>\\n    rcases ih with \\u27e8\\u27e8n, x\\u27e9, rfl\\u27e9\\n    rcases ih' with \\u27e8\\u27e8m, y\\u27e9, rfl\\u27e9\\n    refine \\u27e8\\u27e8(<a>Max.max<\\/a> n m).<a>succ<\\/a>, <a>FilteredClosureSmall.InductiveStep.max<\\/a> ?_ ?_ x y\\u27e9, <a>rfl<\\/a>\\u27e9\\n    all_goals apply <a>Nat.lt_succ_of_le<\\/a>\\n    exacts [<a>Nat.le_max_left<\\/a> _ _, <a>Nat.le_max_right<\\/a> _ _]\\n  | <a>coeq<\\/a> hj\\u2081 hj\\u2082 g g' ih ih' =>\\n    rcases ih with \\u27e8\\u27e8n, x\\u27e9, rfl\\u27e9\\n    rcases ih' with \\u27e8\\u27e8m, y\\u27e9, rfl\\u27e9\\n    refine \\u27e8\\u27e8(<a>Max.max<\\/a> n m).<a>succ<\\/a>, <a>FilteredClosureSmall.InductiveStep.coeq<\\/a> ?_ ?_ x y g g'\\u27e9, <a>rfl<\\/a>\\u27e9\\n    all_goals apply <a>Nat.lt_succ_of_le<\\/a>\\n    exacts [<a>Nat.le_max_left<\\/a> _ _, <a>Nat.le_max_right<\\/a> _ _]\"",
+                "[{\"full_name\":\"CategoryTheory.IsFiltered.FilteredClosure.base\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Small.lean\",\"def_pos\":[33,5],\"def_end_pos\":[33,9]},{\"full_name\":\"rfl\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[294,22],\"def_end_pos\":[294,25]},{\"full_name\":\"CategoryTheory.IsFiltered.FilteredClosure.max\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Small.lean\",\"def_pos\":[34,5],\"def_end_pos\":[34,8]},{\"full_name\":\"Max.max\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[1129,3],\"def_end_pos\":[1129,6]},{\"full_name\":\"Nat.succ\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[1083,5],\"def_end_pos\":[1083,9]},{\"full_name\":\"_private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsFiltered.FilteredClosureSmall.InductiveStep.max\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Small.lean\",\"def_pos\":[66,5],\"def_end_pos\":[66,8]},{\"full_name\":\"rfl\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[294,22],\"def_end_pos\":[294,25]},{\"full_name\":\"Nat.lt_succ_of_le\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/Basic.lean\",\"def_pos\":[262,9],\"def_end_pos\":[262,22]},{\"full_name\":\"Nat.le_max_left\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/MinMax.lean\",\"def_pos\":[53,19],\"def_end_pos\":[53,30]},{\"full_name\":\"Nat.le_max_right\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/MinMax.lean\",\"def_pos\":[55,19],\"def_end_pos\":[55,31]},{\"full_name\":\"CategoryTheory.IsFiltered.FilteredClosure.coeq\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Small.lean\",\"def_pos\":[35,5],\"def_end_pos\":[35,9]},{\"full_name\":\"Max.max\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[1129,3],\"def_end_pos\":[1129,6]},{\"full_name\":\"Nat.succ\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[1083,5],\"def_end_pos\":[1083,9]},{\"full_name\":\"_private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsFiltered.FilteredClosureSmall.InductiveStep.coeq\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Small.lean\",\"def_pos\":[67,5],\"def_end_pos\":[67,9]},{\"full_name\":\"rfl\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[294,22],\"def_end_pos\":[294,25]},{\"full_name\":\"Nat.lt_succ_of_le\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/Basic.lean\",\"def_pos\":[262,9],\"def_end_pos\":[262,22]},{\"full_name\":\"Nat.le_max_left\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/MinMax.lean\",\"def_pos\":[53,19],\"def_end_pos\":[53,30]},{\"full_name\":\"Nat.le_max_right\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/MinMax.lean\",\"def_pos\":[55,19],\"def_end_pos\":[55,31]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case mk\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nh : FilteredClosure f j\n\u22a2 \u2203 a,\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f a =\n      { obj := j, property := h }.obj",
+              "tactic": "induction h with\n| base x => exact \u27e8\u27e80, \u27e8x\u27e9\u27e9, rfl\u27e9\n| max hj\u2081 hj\u2082 ih ih' =>\n  rcases ih with \u27e8\u27e8n, x\u27e9, rfl\u27e9\n  rcases ih' with \u27e8\u27e8m, y\u27e9, rfl\u27e9\n  refine \u27e8\u27e8(Max.max n m).succ, FilteredClosureSmall.InductiveStep.max ?_ ?_ x y\u27e9, rfl\u27e9\n  all_goals apply Nat.lt_succ_of_le\n  exacts [Nat.le_max_left _ _, Nat.le_max_right _ _]\n| coeq hj\u2081 hj\u2082 g g' ih ih' =>\n  rcases ih with \u27e8\u27e8n, x\u27e9, rfl\u27e9\n  rcases ih' with \u27e8\u27e8m, y\u27e9, rfl\u27e9\n  refine \u27e8\u27e8(Max.max n m).succ, FilteredClosureSmall.InductiveStep.coeq ?_ ?_ x y g g'\u27e9, rfl\u27e9\n  all_goals apply Nat.lt_succ_of_le\n  exacts [Nat.le_max_left _ _, Nat.le_max_right _ _]"
+            },
+            {
+              "annotated_tactic": [
+                "\"exact \\u27e8\\u27e80, \\u27e8x\\u27e9\\u27e9, <a>rfl<\\/a>\\u27e9\"",
+                "[{\"full_name\":\"rfl\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[294,22],\"def_end_pos\":[294,25]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case mk.base\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nx : \u03b1\n\u22a2 \u2203 a,\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f a =\n      { obj := f x, property := \u22ef }.obj",
+              "tactic": "exact \u27e8\u27e80, \u27e8x\u27e9\u27e9, rfl\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"rcases ih with \\u27e8\\u27e8n, x\\u27e9, rfl\\u27e9\"",
+                "[]"
+              ],
+              "state_after": "case mk.max.intro.mk\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj j'\u271d : C\nhj\u2082 : FilteredClosure f j'\u271d\nih' :\n  \u2203 a,\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f a =\n      { obj := j'\u271d, property := hj\u2082 }.obj\nn : \u2115\nx : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f n).fst\nhj\u2081 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\n\u22a2 \u2203 a,\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f a =\n      { obj := max (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9) j'\u271d,\n          property := \u22ef }.obj",
+              "state_before": "case mk.max\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj j\u271d j'\u271d : C\nhj\u2081 : FilteredClosure f j\u271d\nhj\u2082 : FilteredClosure f j'\u271d\nih :\n  \u2203 a,\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f a =\n      { obj := j\u271d, property := hj\u2081 }.obj\nih' :\n  \u2203 a,\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f a =\n      { obj := j'\u271d, property := hj\u2082 }.obj\n\u22a2 \u2203 a,\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f a =\n      { obj := max j\u271d j'\u271d, property := \u22ef }.obj",
+              "tactic": "rcases ih with \u27e8\u27e8n, x\u27e9, rfl\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"rcases ih' with \\u27e8\\u27e8m, y\\u27e9, rfl\\u27e9\"",
+                "[]"
+              ],
+              "state_after": "case mk.max.intro.mk.intro.mk\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f n).fst\nhj\u2081 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f m).fst\nhj\u2082 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9)\n\u22a2 \u2203 a,\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f a =\n      {\n          obj :=\n            max (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\n              (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9),\n          property := \u22ef }.obj",
+              "state_before": "case mk.max.intro.mk\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj j'\u271d : C\nhj\u2082 : FilteredClosure f j'\u271d\nih' :\n  \u2203 a,\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f a =\n      { obj := j'\u271d, property := hj\u2082 }.obj\nn : \u2115\nx : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f n).fst\nhj\u2081 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\n\u22a2 \u2203 a,\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f a =\n      { obj := max (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9) j'\u271d,\n          property := \u22ef }.obj",
+              "tactic": "rcases ih' with \u27e8\u27e8m, y\u27e9, rfl\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"refine \\u27e8\\u27e8(<a>Max.max<\\/a> n m).<a>succ<\\/a>, <a>FilteredClosureSmall.InductiveStep.max<\\/a> ?_ ?_ x y\\u27e9, <a>rfl<\\/a>\\u27e9\"",
+                "[{\"full_name\":\"Max.max\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[1129,3],\"def_end_pos\":[1129,6]},{\"full_name\":\"Nat.succ\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[1083,5],\"def_end_pos\":[1083,9]},{\"full_name\":\"_private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsFiltered.FilteredClosureSmall.InductiveStep.max\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Small.lean\",\"def_pos\":[66,5],\"def_end_pos\":[66,8]},{\"full_name\":\"rfl\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[294,22],\"def_end_pos\":[294,25]}]"
+              ],
+              "state_after": "case mk.max.intro.mk.intro.mk.refine_1\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f n).fst\nhj\u2081 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f m).fst\nhj\u2082 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9)\n\u22a2 n < Max.max n m + 1\n\ncase mk.max.intro.mk.intro.mk.refine_2\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f n).fst\nhj\u2081 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f m).fst\nhj\u2082 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9)\n\u22a2 m < Max.max n m + 1",
+              "state_before": "case mk.max.intro.mk.intro.mk\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f n).fst\nhj\u2081 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f m).fst\nhj\u2082 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9)\n\u22a2 \u2203 a,\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f a =\n      {\n          obj :=\n            max (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\n              (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9),\n          property := \u22ef }.obj",
+              "tactic": "refine \u27e8\u27e8(Max.max n m).succ, FilteredClosureSmall.InductiveStep.max ?_ ?_ x y\u27e9, rfl\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"all_goals apply <a>Nat.lt_succ_of_le<\\/a>\"",
+                "[{\"full_name\":\"Nat.lt_succ_of_le\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/Basic.lean\",\"def_pos\":[262,9],\"def_end_pos\":[262,22]}]"
+              ],
+              "state_after": "case mk.max.intro.mk.intro.mk.refine_1.a\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f n).fst\nhj\u2081 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f m).fst\nhj\u2082 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9)\n\u22a2 n \u2264 Max.max n m\n\ncase mk.max.intro.mk.intro.mk.refine_2.a\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f n).fst\nhj\u2081 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f m).fst\nhj\u2082 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9)\n\u22a2 m \u2264 Max.max n m",
+              "state_before": "case mk.max.intro.mk.intro.mk.refine_1\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f n).fst\nhj\u2081 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f m).fst\nhj\u2082 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9)\n\u22a2 n < Max.max n m + 1\n\ncase mk.max.intro.mk.intro.mk.refine_2\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f n).fst\nhj\u2081 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f m).fst\nhj\u2082 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9)\n\u22a2 m < Max.max n m + 1",
+              "tactic": "all_goals apply Nat.lt_succ_of_le"
+            },
+            {
+              "annotated_tactic": [
+                "\"exacts [<a>Nat.le_max_left<\\/a> _ _, <a>Nat.le_max_right<\\/a> _ _]\"",
+                "[{\"full_name\":\"Nat.le_max_left\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/MinMax.lean\",\"def_pos\":[53,19],\"def_end_pos\":[53,30]},{\"full_name\":\"Nat.le_max_right\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/MinMax.lean\",\"def_pos\":[55,19],\"def_end_pos\":[55,31]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case mk.max.intro.mk.intro.mk.refine_1.a\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f n).fst\nhj\u2081 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f m).fst\nhj\u2082 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9)\n\u22a2 n \u2264 Max.max n m\n\ncase mk.max.intro.mk.intro.mk.refine_2.a\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f n).fst\nhj\u2081 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f m).fst\nhj\u2082 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9)\n\u22a2 m \u2264 Max.max n m",
+              "tactic": "exacts [Nat.le_max_left _ _, Nat.le_max_right _ _]"
+            },
+            {
+              "annotated_tactic": [
+                "\"apply <a>Nat.lt_succ_of_le<\\/a>\"",
+                "[{\"full_name\":\"Nat.lt_succ_of_le\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/Basic.lean\",\"def_pos\":[262,9],\"def_end_pos\":[262,22]}]"
+              ],
+              "state_after": "case mk.max.intro.mk.intro.mk.refine_2.a\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f n).fst\nhj\u2081 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f m).fst\nhj\u2082 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9)\n\u22a2 m \u2264 Max.max n m",
+              "state_before": "case mk.max.intro.mk.intro.mk.refine_2\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f n).fst\nhj\u2081 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f m).fst\nhj\u2082 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9)\n\u22a2 m < Max.max n m + 1",
+              "tactic": "apply Nat.lt_succ_of_le"
+            },
+            {
+              "annotated_tactic": [
+                "\"rcases ih with \\u27e8\\u27e8n, x\\u27e9, rfl\\u27e9\"",
+                "[]"
+              ],
+              "state_after": "case mk.coeq.intro.mk\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj j'\u271d : C\nhj\u2082 : FilteredClosure f j'\u271d\nih' :\n  \u2203 a,\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f a =\n      { obj := j'\u271d, property := hj\u2082 }.obj\nn : \u2115\nx : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f n).fst\nhj\u2081 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\ng g' : CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9 \u27f6 j'\u271d\n\u22a2 \u2203 a,\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f a =\n      { obj := coeq g g', property := \u22ef }.obj",
+              "state_before": "case mk.coeq\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj j\u271d j'\u271d : C\nhj\u2081 : FilteredClosure f j\u271d\nhj\u2082 : FilteredClosure f j'\u271d\ng g' : j\u271d \u27f6 j'\u271d\nih :\n  \u2203 a,\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f a =\n      { obj := j\u271d, property := hj\u2081 }.obj\nih' :\n  \u2203 a,\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f a =\n      { obj := j'\u271d, property := hj\u2082 }.obj\n\u22a2 \u2203 a,\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f a =\n      { obj := coeq g g', property := \u22ef }.obj",
+              "tactic": "rcases ih with \u27e8\u27e8n, x\u27e9, rfl\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"rcases ih' with \\u27e8\\u27e8m, y\\u27e9, rfl\\u27e9\"",
+                "[]"
+              ],
+              "state_after": "case mk.coeq.intro.mk.intro.mk\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f n).fst\nhj\u2081 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f m).fst\nhj\u2082 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9)\ng g' :\n  CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9 \u27f6\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9\n\u22a2 \u2203 a,\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f a =\n      { obj := coeq g g', property := \u22ef }.obj",
+              "state_before": "case mk.coeq.intro.mk\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj j'\u271d : C\nhj\u2082 : FilteredClosure f j'\u271d\nih' :\n  \u2203 a,\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f a =\n      { obj := j'\u271d, property := hj\u2082 }.obj\nn : \u2115\nx : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f n).fst\nhj\u2081 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\ng g' : CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9 \u27f6 j'\u271d\n\u22a2 \u2203 a,\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f a =\n      { obj := coeq g g', property := \u22ef }.obj",
+              "tactic": "rcases ih' with \u27e8\u27e8m, y\u27e9, rfl\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"refine \\u27e8\\u27e8(<a>Max.max<\\/a> n m).<a>succ<\\/a>, <a>FilteredClosureSmall.InductiveStep.coeq<\\/a> ?_ ?_ x y g g'\\u27e9, <a>rfl<\\/a>\\u27e9\"",
+                "[{\"full_name\":\"Max.max\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[1129,3],\"def_end_pos\":[1129,6]},{\"full_name\":\"Nat.succ\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[1083,5],\"def_end_pos\":[1083,9]},{\"full_name\":\"_private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsFiltered.FilteredClosureSmall.InductiveStep.coeq\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Filtered\\/Small.lean\",\"def_pos\":[67,5],\"def_end_pos\":[67,9]},{\"full_name\":\"rfl\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[294,22],\"def_end_pos\":[294,25]}]"
+              ],
+              "state_after": "case mk.coeq.intro.mk.intro.mk.refine_1\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f n).fst\nhj\u2081 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f m).fst\nhj\u2082 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9)\ng g' :\n  CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9 \u27f6\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9\n\u22a2 n < Max.max n m + 1\n\ncase mk.coeq.intro.mk.intro.mk.refine_2\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f n).fst\nhj\u2081 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f m).fst\nhj\u2082 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9)\ng g' :\n  CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9 \u27f6\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9\n\u22a2 m < Max.max n m + 1",
+              "state_before": "case mk.coeq.intro.mk.intro.mk\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f n).fst\nhj\u2081 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f m).fst\nhj\u2082 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9)\ng g' :\n  CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9 \u27f6\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9\n\u22a2 \u2203 a,\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f a =\n      { obj := coeq g g', property := \u22ef }.obj",
+              "tactic": "refine \u27e8\u27e8(Max.max n m).succ, FilteredClosureSmall.InductiveStep.coeq ?_ ?_ x y g g'\u27e9, rfl\u27e9"
+            },
+            {
+              "annotated_tactic": [
+                "\"all_goals apply <a>Nat.lt_succ_of_le<\\/a>\"",
+                "[{\"full_name\":\"Nat.lt_succ_of_le\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/Basic.lean\",\"def_pos\":[262,9],\"def_end_pos\":[262,22]}]"
+              ],
+              "state_after": "case mk.coeq.intro.mk.intro.mk.refine_1.a\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f n).fst\nhj\u2081 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f m).fst\nhj\u2082 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9)\ng g' :\n  CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9 \u27f6\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9\n\u22a2 n \u2264 Max.max n m\n\ncase mk.coeq.intro.mk.intro.mk.refine_2.a\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f n).fst\nhj\u2081 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f m).fst\nhj\u2082 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9)\ng g' :\n  CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9 \u27f6\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9\n\u22a2 m \u2264 Max.max n m",
+              "state_before": "case mk.coeq.intro.mk.intro.mk.refine_1\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f n).fst\nhj\u2081 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f m).fst\nhj\u2082 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9)\ng g' :\n  CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9 \u27f6\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9\n\u22a2 n < Max.max n m + 1\n\ncase mk.coeq.intro.mk.intro.mk.refine_2\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f n).fst\nhj\u2081 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f m).fst\nhj\u2082 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9)\ng g' :\n  CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9 \u27f6\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9\n\u22a2 m < Max.max n m + 1",
+              "tactic": "all_goals apply Nat.lt_succ_of_le"
+            },
+            {
+              "annotated_tactic": [
+                "\"exacts [<a>Nat.le_max_left<\\/a> _ _, <a>Nat.le_max_right<\\/a> _ _]\"",
+                "[{\"full_name\":\"Nat.le_max_left\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/MinMax.lean\",\"def_pos\":[53,19],\"def_end_pos\":[53,30]},{\"full_name\":\"Nat.le_max_right\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/MinMax.lean\",\"def_pos\":[55,19],\"def_end_pos\":[55,31]}]"
+              ],
+              "state_after": "no goals",
+              "state_before": "case mk.coeq.intro.mk.intro.mk.refine_1.a\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f n).fst\nhj\u2081 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f m).fst\nhj\u2082 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9)\ng g' :\n  CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9 \u27f6\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9\n\u22a2 n \u2264 Max.max n m\n\ncase mk.coeq.intro.mk.intro.mk.refine_2.a\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f n).fst\nhj\u2081 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f m).fst\nhj\u2082 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9)\ng g' :\n  CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9 \u27f6\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9\n\u22a2 m \u2264 Max.max n m",
+              "tactic": "exacts [Nat.le_max_left _ _, Nat.le_max_right _ _]"
+            },
+            {
+              "annotated_tactic": [
+                "\"apply <a>Nat.lt_succ_of_le<\\/a>\"",
+                "[{\"full_name\":\"Nat.lt_succ_of_le\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Data\\/Nat\\/Basic.lean\",\"def_pos\":[262,9],\"def_end_pos\":[262,22]}]"
+              ],
+              "state_after": "case mk.coeq.intro.mk.intro.mk.refine_2.a\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f n).fst\nhj\u2081 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f m).fst\nhj\u2082 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9)\ng g' :\n  CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9 \u27f6\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9\n\u22a2 m \u2264 Max.max n m",
+              "state_before": "case mk.coeq.intro.mk.intro.mk.refine_2\nC : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : IsFilteredOrEmpty C\n\u03b1 : Type w\nf : \u03b1 \u2192 C\nj : C\nn : \u2115\nx : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f n).fst\nhj\u2081 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9)\nm : \u2115\ny : (CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure f m).fst\nhj\u2082 : FilteredClosure f (CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9)\ng g' :\n  CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8n, x\u27e9 \u27f6\n    CategoryTheory.IsFiltered.FilteredClosureSmall.abstractFilteredClosureRealization f \u27e8m, y\u27e9\n\u22a2 m < Max.max n m + 1",
+              "tactic": "apply Nat.lt_succ_of_le"
+            }
+          ],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Filtered/Small.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "FintypeCat.Skeleton.ext",
+        "id": "FintypeCat.Skeleton.ext",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            151,
+            16
+          ],
+          "file_path": "Mathlib/CategoryTheory/FintypeCat.lean",
+          "full_name": "FintypeCat.Skeleton.ext",
+          "start": [
+            150,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/FintypeCat.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "FintypeCat.comp_apply",
+        "id": "FintypeCat.comp_apply",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            83,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/FintypeCat.lean",
+          "full_name": "FintypeCat.comp_apply",
+          "start": [
+            82,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/FintypeCat.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "FintypeCat.hom_inv_id_apply",
+        "id": "FintypeCat.hom_inv_id_apply",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            89,
+            27
+          ],
+          "file_path": "Mathlib/CategoryTheory/FintypeCat.lean",
+          "full_name": "FintypeCat.hom_inv_id_apply",
+          "start": [
+            87,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/FintypeCat.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "FintypeCat.id_apply",
+        "id": "FintypeCat.id_apply",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            77,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/FintypeCat.lean",
+          "full_name": "FintypeCat.id_apply",
+          "start": [
+            76,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/FintypeCat.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "FintypeCat.inv_hom_id_apply",
+        "id": "FintypeCat.inv_hom_id_apply",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            93,
+            27
+          ],
+          "file_path": "Mathlib/CategoryTheory/FintypeCat.lean",
+          "full_name": "FintypeCat.inv_hom_id_apply",
+          "start": [
+            91,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/FintypeCat.lean"
+      }
+    ],
+    "input_proofs": 10,
+    "input_units": 2,
+    "proofs": 3,
+    "published_proofs": 3,
+    "published_transitions": 5,
+    "replay_failures": [],
+    "transitions": 5,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/mathlib-000643-0000-2b9eb238b5a260da.parquet",
+      "sha256": "2b9eb238b5a260da0f58159a0b49b433edd6ca86138c33dbfad4cf843db71c1d",
+      "bytes": 33132,
+      "rows": 5,
+      "revision": "6a3d2d550a5e8f26af70e44381b84ab7563dc62c"
+    }
+  ],
+  "proof_ids": [
+    "mathlib:FintypeCat.Skeleton.incl_mk_nat_card",
+    "mathlib:FintypeCat.hom_ext",
+    "mathlib:FintypeCat.isSkeleton"
+  ],
+  "proof_keys": [
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/FintypeCat.lean\",null,null,\"FintypeCat.Skeleton.incl_mk_nat_card\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/FintypeCat.lean\",null,null,\"FintypeCat.hom_ext\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/FintypeCat.lean\",null,null,\"FintypeCat.isSkeleton\"]"
+  ]
+}

manifests/batches/mathlib/000644.json

@@ -0,0 +1,306 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "mathlib/000644",
+  "batch_fingerprint": "4e806f197fc068480befdfe7992c3b1d8e2ec07a82879d4fcdb593755be80736",
+  "evidence": {
+    "batch_fingerprint": "4e806f197fc068480befdfe7992c3b1d8e2ec07a82879d4fcdb593755be80736",
+    "contamination_matches": [],
+    "failures": [
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.FullSubcategory.comp_def",
+        "id": "CategoryTheory.FullSubcategory.comp_def",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            127,
+            43
+          ],
+          "file_path": "Mathlib/CategoryTheory/FullSubcategory.lean",
+          "full_name": "CategoryTheory.FullSubcategory.comp_def",
+          "start": [
+            126,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/FullSubcategory.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.FullSubcategory.lift_comp_inclusion_eq",
+        "id": "CategoryTheory.FullSubcategory.lift_comp_inclusion_eq",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            199,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/FullSubcategory.lean",
+          "full_name": "CategoryTheory.FullSubcategory.lift_comp_inclusion_eq",
+          "start": [
+            197,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/FullSubcategory.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.FullSubcategory.lift_comp_map",
+        "id": "CategoryTheory.FullSubcategory.lift_comp_map",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            232,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/FullSubcategory.lean",
+          "full_name": "CategoryTheory.FullSubcategory.lift_comp_map",
+          "start": [
+            229,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/FullSubcategory.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.FullSubcategory.map_inclusion",
+        "id": "CategoryTheory.FullSubcategory.map_inclusion",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            179,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/FullSubcategory.lean",
+          "full_name": "CategoryTheory.FullSubcategory.map_inclusion",
+          "start": [
+            177,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/FullSubcategory.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.fullSubcategoryInclusion.map",
+        "id": "CategoryTheory.fullSubcategoryInclusion.map",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            143,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/FullSubcategory.lean",
+          "full_name": "CategoryTheory.fullSubcategoryInclusion.map",
+          "start": [
+            142,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/FullSubcategory.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.fullSubcategoryInclusion.obj",
+        "id": "CategoryTheory.fullSubcategoryInclusion.obj",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            138,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/FullSubcategory.lean",
+          "full_name": "CategoryTheory.fullSubcategoryInclusion.obj",
+          "start": [
+            137,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/FullSubcategory.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.fullSubcategoryInclusion_map_lift_map",
+        "id": "CategoryTheory.fullSubcategoryInclusion_map_lift_map",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            218,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/FullSubcategory.lean",
+          "full_name": "CategoryTheory.fullSubcategoryInclusion_map_lift_map",
+          "start": [
+            215,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/FullSubcategory.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.fullSubcategoryInclusion_obj_lift_obj",
+        "id": "CategoryTheory.fullSubcategoryInclusion_obj_lift_obj",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            211,
+            6
+          ],
+          "file_path": "Mathlib/CategoryTheory/FullSubcategory.lean",
+          "full_name": "CategoryTheory.fullSubcategoryInclusion_obj_lift_obj",
+          "start": [
+            209,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/FullSubcategory.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Functor.comp_map",
+        "id": "CategoryTheory.Functor.comp_map",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            123,
+            43
+          ],
+          "file_path": "Mathlib/CategoryTheory/Functor/Basic.lean",
+          "full_name": "CategoryTheory.Functor.comp_map",
+          "start": [
+            122,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Functor/Basic.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Functor.id_map",
+        "id": "CategoryTheory.Functor.id_map",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            98,
+            62
+          ],
+          "file_path": "Mathlib/CategoryTheory/Functor/Basic.lean",
+          "full_name": "CategoryTheory.Functor.id_map",
+          "start": [
+            98,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Functor/Basic.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Functor.id_obj",
+        "id": "CategoryTheory.Functor.id_obj",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            94,
+            48
+          ],
+          "file_path": "Mathlib/CategoryTheory/Functor/Basic.lean",
+          "full_name": "CategoryTheory.Functor.id_obj",
+          "start": [
+            94,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Functor/Basic.lean"
+      },
+      {
+        "error": "theorem has no selected tactic transitions",
+        "full_name": "CategoryTheory.Functor.toPrefunctor_comp",
+        "id": "CategoryTheory.Functor.toPrefunctor_comp",
+        "reason": "import_failure",
+        "selection": {
+          "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
+          "end": [
+            147,
+            69
+          ],
+          "file_path": "Mathlib/CategoryTheory/Functor/Basic.lean",
+          "full_name": "CategoryTheory.Functor.toPrefunctor_comp",
+          "start": [
+            146,
+            1
+          ],
+          "traced_tactics": [],
+          "url": "https://github.com/leanprover-community/mathlib4"
+        },
+        "source_file": "Mathlib/CategoryTheory/Functor/Basic.lean"
+      }
+    ],
+    "input_proofs": 16,
+    "input_units": 2,
+    "proofs": 4,
+    "published_proofs": 4,
+    "published_transitions": 6,
+    "replay_failures": [],
+    "transitions": 6,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/mathlib-000644-0000-973ca0d22c8ee7f5.parquet",
+      "sha256": "973ca0d22c8ee7f53fba5a4c0b75f051d11b987c6f6fbcacbca290fba572ba8a",
+      "bytes": 57332,
+      "rows": 6,
+      "revision": "6a3d2d550a5e8f26af70e44381b84ab7563dc62c"
+    }
+  ],
+  "proof_ids": [
+    "mathlib:CategoryTheory.Functor.comp_id",
+    "mathlib:CategoryTheory.Functor.id_comp",
+    "mathlib:CategoryTheory.Functor.map_comp_assoc",
+    "mathlib:CategoryTheory.Functor.map_dite"
+  ],
+  "proof_keys": [
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Functor/Basic.lean\",null,null,\"CategoryTheory.Functor.comp_id\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Functor/Basic.lean\",null,null,\"CategoryTheory.Functor.id_comp\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Functor/Basic.lean\",null,null,\"CategoryTheory.Functor.map_comp_assoc\"]",
+    "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Functor/Basic.lean\",null,null,\"CategoryTheory.Functor.map_dite\"]"
+  ]
+}

manifests/batches/numina/001394.json

@@ -0,0 +1,44 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "numina/001394",
+  "batch_fingerprint": "5faefaa343a27a4a066059aa7cb03524b359c00e773d2f420c368cb9e6d1bccd",
+  "evidence": {
+    "batch_fingerprint": "5faefaa343a27a4a066059aa7cb03524b359c00e773d2f420c368cb9e6d1bccd",
+    "contamination_matches": [],
+    "failures": [],
+    "input_proofs": 5,
+    "input_units": 5,
+    "proofs": 5,
+    "published_proofs": 5,
+    "published_transitions": 23,
+    "replay_failures": [],
+    "trace_mode": "bundle",
+    "transitions": 23,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/numina-001394-0000-0026f64b24d2f04d.parquet",
+      "sha256": "0026f64b24d2f04d83f9517c1146a6958f5d3df1e5ca7ba5b479292765e7cd65",
+      "bytes": 90091,
+      "rows": 23,
+      "revision": "6a3d2d550a5e8f26af70e44381b84ab7563dc62c"
+    }
+  ],
+  "proof_ids": [
+    "numina:006b5904-fa12-51d3-9554-96db63601486",
+    "numina:064daf4b-f9f1-5360-8a32-3aef7f0e6a30",
+    "numina:0f35cdb3-5eb8-5a33-a362-cc26fe3c199a",
+    "numina:38240e48-779f-5d1c-b0d7-b7bee5098700",
+    "numina:c3e36722-1dc2-56de-a538-0c89a033c626"
+  ],
+  "proof_keys": [
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_006970.lean\",\"44dfacfee89fb5e54454baec6766108aa62f20918e3728a4eb79723e66f50da1\",0,\"number_theory_604197\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_006971.lean\",\"dfbeed4423a7269676d26842305972c7790d17433be06dedb36273178af72526\",0,\"algebra_9065\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_006972.lean\",\"f6b11b83169c308d197d4849277985cd37109571d0878d80574f9bf396a4a360\",0,\"number_theory_276246\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_006973.lean\",\"b121ccc3e34ebc3116eccd360a9f19d3ab0a5ff838cfe4aea259b1535354b61f\",0,\"algebra_19511\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_006974.lean\",\"72c26428197b4b577da6ba7a6e60840e0012b9ead1f8aeaed341f6da3a0efd7b\",0,\"number_theory_165209\"]"
+  ]
+}

manifests/batches/numina/001395.json

@@ -0,0 +1,44 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "numina/001395",
+  "batch_fingerprint": "93652d776b40dc3b5c3ee4ecb57bd41db858dad4d4ae0610f23b4f137ae6c3e2",
+  "evidence": {
+    "batch_fingerprint": "93652d776b40dc3b5c3ee4ecb57bd41db858dad4d4ae0610f23b4f137ae6c3e2",
+    "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-001395-0000-6e124458d6bb5603.parquet",
+      "sha256": "6e124458d6bb5603040960786af4f4deb3d32241e30ac31128b1a4df98f95a33",
+      "bytes": 270731,
+      "rows": 43,
+      "revision": "6a3d2d550a5e8f26af70e44381b84ab7563dc62c"
+    }
+  ],
+  "proof_ids": [
+    "numina:09fba0e0-24db-558b-920e-882d4bb94f01",
+    "numina:8a465ac4-75c8-586a-92bc-a0bd3fbc8e7b",
+    "numina:8b7b4721-108f-5947-ade5-1b581a29ed4f",
+    "numina:bce92fe2-25ef-5c83-90c6-3b02f90ee0e6",
+    "numina:d1600aa5-6195-5ff9-9b61-bfe9e1c06ff0"
+  ],
+  "proof_keys": [
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_006975.lean\",\"ab0785ea5de6062c48b772b7c5013ca372827223fc60100259f06eadc9c3c765\",0,\"algebra_96450\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_006976.lean\",\"c75280cbd8c26813a44a061b988cdd7267ed3e96fa6b01d27af54104449f61c4\",0,\"inequalities_607357\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_006977.lean\",\"9204deeb1756beeaf8020f8f98d788892c5a931fa7d110b6a401121b5698a6d9\",0,\"algebra_604199\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_006978.lean\",\"a7f62567ba1da151ef5b35f425f5ed92b42e102b92684315810d8f45c7500d0a\",0,\"calculus_228554\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_006979.lean\",\"bbe8900a6e5ca5be95d21bf109d590f9a5337d1c7e116e91d5810273ddc5c3bf\",0,\"algebra_9067\"]"
+  ]
+}

manifests/batches/numina/001396.json

@@ -0,0 +1,44 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "numina/001396",
+  "batch_fingerprint": "f9acd7f59028d4ca9e11281d2ad80ac69bac7559e578c1a11188d5dc54947d52",
+  "evidence": {
+    "batch_fingerprint": "f9acd7f59028d4ca9e11281d2ad80ac69bac7559e578c1a11188d5dc54947d52",
+    "contamination_matches": [],
+    "failures": [],
+    "input_proofs": 5,
+    "input_units": 5,
+    "proofs": 5,
+    "published_proofs": 5,
+    "published_transitions": 70,
+    "replay_failures": [],
+    "trace_mode": "bundle",
+    "transitions": 70,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/numina-001396-0000-15b244e1f186dcd9.parquet",
+      "sha256": "15b244e1f186dcd95398826ce2bcdc0ead564433c5bc5e4a05c9928fe134270c",
+      "bytes": 565882,
+      "rows": 70,
+      "revision": "6a3d2d550a5e8f26af70e44381b84ab7563dc62c"
+    }
+  ],
+  "proof_ids": [
+    "numina:12673f39-4e96-5d2f-a618-c720bcedbcdf",
+    "numina:385b5403-3748-5b53-9651-86f74d028303",
+    "numina:9b743b7d-cb77-57d8-b653-c6fd09208db0",
+    "numina:ad8bc552-ff07-5918-a9eb-c91571d783fe",
+    "numina:b1ed66d4-8ddc-5129-a4c0-dbee8ac09fc9"
+  ],
+  "proof_keys": [
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_006980.lean\",\"f69a76e2acc0766ba12981a91ce5b091a6e5d4c7a17ee44992395adb355ac1fe\",0,\"number_theory_1857\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_006981.lean\",\"c011a3ed4595f01ed7164f41996a7f4b4b2d42ecebbc876c3c438194b8a2883b\",0,\"number_theory_214851\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_006982.lean\",\"4bec129ae92867d84b33a9e10e78622168a23433da9369c41f13bfbbf7fda18b\",0,\"inequalities_272484\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_006983.lean\",\"42f273620ea12dbef06ef66efc0b8494c5b52e6a453042d51e3ade3bb48fd36f\",0,\"algebra_96472\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_006984.lean\",\"8077b4ae7492bfebaf621701ed2fc42e887ca16f33cd039967a67660a12e146d\",0,\"algebra_19524\"]"
+  ]
+}

manifests/batches/numina/001398.json

@@ -0,0 +1,44 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "numina/001398",
+  "batch_fingerprint": "952f6d44ab1b17485362f88f80000ab46b348b26343271f24ebeaa749f4b9576",
+  "evidence": {
+    "batch_fingerprint": "952f6d44ab1b17485362f88f80000ab46b348b26343271f24ebeaa749f4b9576",
+    "contamination_matches": [],
+    "failures": [],
+    "input_proofs": 5,
+    "input_units": 5,
+    "proofs": 5,
+    "published_proofs": 5,
+    "published_transitions": 20,
+    "replay_failures": [],
+    "trace_mode": "bundle",
+    "transitions": 20,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/numina-001398-0000-519dccbce0e69519.parquet",
+      "sha256": "519dccbce0e695190a36bd1f697b39c9670af41e478f6f0fecfc825bb2833cf0",
+      "bytes": 141199,
+      "rows": 20,
+      "revision": "6a3d2d550a5e8f26af70e44381b84ab7563dc62c"
+    }
+  ],
+  "proof_ids": [
+    "numina:13a7fc5c-5700-5fc2-874f-f1e207c328a1",
+    "numina:140cb690-b3b8-5ae5-91e5-d580176e0abc",
+    "numina:562a09ce-e8af-50bd-8205-121e298995e3",
+    "numina:8427f2ea-2d5b-5921-b45f-bf9ca751c045",
+    "numina:d72da868-9e0e-5730-9c6d-733f2af143d7"
+  ],
+  "proof_keys": [
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_006990.lean\",\"e4f753cbe904c06dcd5f545bcd49b1e456bf4c8e10c19f7a9d16283a807a6202\",0,\"algebra_21650\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_006991.lean\",\"f7cd16d9f97fd82761a2cc31db04c98737c6495ac63216f787bd6de83c95b020\",0,\"inequalities_607359\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_006992.lean\",\"52e0760aa9eb5be7d4bd8acba6a73b2c2f882962271a04415edafc6b6995c94c\",0,\"algebra_9166\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_006993.lean\",\"d88b61c5c781c64d4efba6128bbe432d667e237dcb6b1baee29cfc0121ddfafd\",0,\"inequalities_4946\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_006994.lean\",\"4f4ed3042f234b9cf908f53b5b022d02eeb1dd2e5944f13cfe17129d6be3b7d9\",0,\"algebra_121912\"]"
+  ]
+}

manifests/batches/numina/001399.json

@@ -0,0 +1,51 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "numina/001399",
+  "batch_fingerprint": "8e66aa24d3cced0150eaeaef3cba06be7bf87d6cd7d545205e85ed69a61ea8c8",
+  "evidence": {
+    "batch_fingerprint": "8e66aa24d3cced0150eaeaef3cba06be7bf87d6cd7d545205e85ed69a61ea8c8",
+    "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-001399-0000-23bcd81ff677835f.parquet",
+      "sha256": "23bcd81ff677835f34fe337166522b94a87f1534159a1ca6e3d2d181c568804c",
+      "bytes": 434022,
+      "rows": 33,
+      "revision": "6a3d2d550a5e8f26af70e44381b84ab7563dc62c"
+    },
+    {
+      "path": "data/internal_test/numina-001399-0000-930c4fc11a3c11f1.parquet",
+      "sha256": "930c4fc11a3c11f1c7fc162f476716144a84134a0e1c8a00f00727a49f65c8c5",
+      "bytes": 92547,
+      "rows": 10,
+      "revision": "6a3d2d550a5e8f26af70e44381b84ab7563dc62c"
+    }
+  ],
+  "proof_ids": [
+    "numina:3c6709ee-35c4-58c8-a2c4-0c860753c4cb",
+    "numina:68455911-ca48-5fb8-bdd0-130921e9d559",
+    "numina:6ecd08e6-0322-5e36-a18e-99885db53431",
+    "numina:811f5179-11ae-5fe3-ae63-0d75744785e9",
+    "numina:fa2c39f5-4434-507e-9bc4-7ed4e3bdf8b2"
+  ],
+  "proof_keys": [
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_006995.lean\",\"4817aee1ae2bdfbf6621afc6d0555727cce01caff6f0bc9fceaf4cdfe0091f13\",0,\"number_theory_98579\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_006996.lean\",\"f0d02b10fede76f6f641bbca3c2f8bdf15cd9db02bb9d9abde84f5d56d76a0f9\",0,\"algebra_11710\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_006997.lean\",\"b3620b7439fa8e4213c4f9ed5e9e17f7c56e815f91a4c9a89bc5dd719da7889e\",0,\"algebra_189236\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_006998.lean\",\"7296a297604faaa2b62e79223e6dff5dc7796a7ee09d658ec6d0a5c02121fb89\",0,\"algebra_607360\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_006999.lean\",\"d9484aa44e5f231de6bf3671aa33ef793e0e0609e1973316a726f141026e05e0\",0,\"inequalities_605034\"]"
+  ]
+}

manifests/batches/numina/001400.json

@@ -0,0 +1,51 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "numina/001400",
+  "batch_fingerprint": "dae0b42edb24444274fa82ef700957c9ac8c2ef31458daaabcc9eeb014f62f74",
+  "evidence": {
+    "batch_fingerprint": "dae0b42edb24444274fa82ef700957c9ac8c2ef31458daaabcc9eeb014f62f74",
+    "contamination_matches": [],
+    "failures": [],
+    "input_proofs": 5,
+    "input_units": 5,
+    "proofs": 5,
+    "published_proofs": 5,
+    "published_transitions": 30,
+    "replay_failures": [],
+    "trace_mode": "bundle",
+    "transitions": 30,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/numina-001400-0000-b4e1c08996c46745.parquet",
+      "sha256": "b4e1c08996c46745b33f241a3f0b29a32e0aab42629311aa378b404b0daaf435",
+      "bytes": 64860,
+      "rows": 17,
+      "revision": "6a3d2d550a5e8f26af70e44381b84ab7563dc62c"
+    },
+    {
+      "path": "data/dev/numina-001400-0000-feec1c42a0722ecf.parquet",
+      "sha256": "feec1c42a0722ecf4b0cba34c85cd11df85d2624d0c5471385f96a256638ba9a",
+      "bytes": 105907,
+      "rows": 13,
+      "revision": "6a3d2d550a5e8f26af70e44381b84ab7563dc62c"
+    }
+  ],
+  "proof_ids": [
+    "numina:273e3ff4-3d9f-5718-b73d-4ed64eb7df95",
+    "numina:ad7b0d44-fb84-5768-8015-bb3792fbaa4c",
+    "numina:e2a44d8e-d20c-5769-a645-f74869c3f0b5",
+    "numina:e6e3e8db-3d60-5b7d-a119-e7e30da7bc1c",
+    "numina:fddef328-c882-50bb-a9a1-98aecde085d7"
+  ],
+  "proof_keys": [
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007000.lean\",\"06d03a6bf16852df526e15fede3cee17f5ed6d2644d205e30f28cfce36b1e4b5\",0,\"algebra_9107\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007001.lean\",\"31eadfe52488ecd1b2d9bc6df5e5f6c5ee4acbf155aa654f5f342554e2bd8fbd\",0,\"inequalities_6511\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007002.lean\",\"f3eba4d6186c5b56989ba43cd6c0801749aeda229f7694fdca46e0a599832e49\",0,\"number_theory_280132\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007003.lean\",\"263b91d37092037eac632b44d3fb4eb5b50034cd92d36cb4057c47d41a0a1f6d\",0,\"algebra_122063\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007004.lean\",\"5f7f5dcf2e2e13c08dea8d4e871da6492c6febb373e6db4d1314d2d332daa0f3\",0,\"algebra_21652\"]"
+  ]
+}

manifests/batches/numina/001403.json

@@ -0,0 +1,45 @@
+{
+  "format": "leangpt-parquet-v2",
+  "batch": "numina/001403",
+  "batch_fingerprint": "656d31d5c83368bc1ba5e4eb619a56740962bbb162f57a1720df9886f77ae9a4",
+  "evidence": {
+    "batch_fingerprint": "656d31d5c83368bc1ba5e4eb619a56740962bbb162f57a1720df9886f77ae9a4",
+    "bundle_error": "helper declarations require isolated extraction",
+    "contamination_matches": [],
+    "failures": [],
+    "input_proofs": 5,
+    "input_units": 5,
+    "proofs": 5,
+    "published_proofs": 5,
+    "published_transitions": 30,
+    "replay_failures": [],
+    "trace_mode": "individual",
+    "transitions": 30,
+    "validation_failures": [],
+    "validation_rejected_proofs": 0,
+    "zero_transition_proofs": 0
+  },
+  "shards": [
+    {
+      "path": "data/train/numina-001403-0000-cc5d037963df2f41.parquet",
+      "sha256": "cc5d037963df2f41aacea1c2ec361f65166d8625b3ef18f6cf30cd7811d29117",
+      "bytes": 509349,
+      "rows": 30,
+      "revision": "6a3d2d550a5e8f26af70e44381b84ab7563dc62c"
+    }
+  ],
+  "proof_ids": [
+    "numina:04f3d032-d13d-5519-89b9-3467ac868fb5",
+    "numina:30869115-24ff-589a-b517-2afd1bf88698",
+    "numina:4611e5a2-6355-5bbe-88ca-33e1e9fc3bab",
+    "numina:8e8abc64-1faf-524f-ada1-023dc59acc82",
+    "numina:9b72267a-cad1-5ba8-9111-61dcc29e2c8d"
+  ],
+  "proof_keys": [
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007015.lean\",\"577f68e463118dc5667b4df8c2f0665e1038943ce41bb0f9c1bea41fc5781d7d\",0,\"algebra_98619\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007016.lean\",\"4ad5bd672bec63c084882f2e9149492ef456109e5433e268a6b102033b95e3cf\",0,\"inequalities_175117\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007017.lean\",\"348f76c0720f631f9e52af823e91a84f9d4e6afd27938c5459abb60f15fe27a6\",0,\"algebra_19412\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007018.lean\",\"84eef59bbc567a4958f504c65d5b873255f18676c2730c5e037198bab61cfed5\",1,\"number_theory_214071.number_theory_214071_2\"]",
+    "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007019.lean\",\"ec42c476f8c80a7861f53385a38b8c7f2406753ea2f8c83ec25e4026807dcd29\",0,\"number_theory_605043\"]"
+  ]
+}