Hugging Face's logo

Datasets:
HyperCactus0
/
LeanTransitionCorpus

Tasks:
Text Generation
Tags:
lean
lean4
automated-theorem-proving
theorem-proving
formal-mathematics
mathematics
License:
Dataset card Data Studio Files
xet
 Community
1
HyperCactus0 commited on
Commit
41eeada
·
verified ·
1 Parent(s): 4c50b3d

Record 19 verified HPC batch manifests

Browse files
Files changed (19) hide show
  1. manifests/batches/mathlib/000667.json +139 -0
  2. manifests/batches/mathlib/000668.json +186 -0
  3. manifests/batches/mathlib/000669.json +198 -0
  4. manifests/batches/mathlib/000670.json +520 -0
  5. manifests/batches/mathlib/000671.json +64 -0
  6. manifests/batches/mathlib/000672.json +236 -0
  7. manifests/batches/mathlib/000674.json +140 -0
  8. manifests/batches/mathlib/000675.json +491 -0
  9. manifests/batches/mathlib/000676.json +263 -0
  10. manifests/batches/numina/001426.json +51 -0
  11. manifests/batches/numina/001427.json +81 -0
  12. manifests/batches/numina/001428.json +51 -0
  13. manifests/batches/numina/001429.json +44 -0
  14. manifests/batches/numina/001430.json +51 -0
  15. manifests/batches/numina/001431.json +51 -0
  16. manifests/batches/numina/001432.json +51 -0
  17. manifests/batches/numina/001433.json +44 -0
  18. manifests/batches/numina/001434.json +51 -0
  19. manifests/batches/numina/001436.json +58 -0
manifests/batches/mathlib/000667.json ADDED
@@ -0,0 +1,139 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "format": "leangpt-parquet-v2",
3
+ "batch": "mathlib/000667",
4
+ "batch_fingerprint": "f636761fc4137478bf10b39fe0eec4960d653d7f1111fa9ef93aa42ab04e409a",
5
+ "evidence": {
6
+ "batch_fingerprint": "f636761fc4137478bf10b39fe0eec4960d653d7f1111fa9ef93aa42ab04e409a",
7
+ "contamination_matches": [],
8
+ "failures": [
9
+ {
10
+ "error": "theorem has no selected tactic transitions",
11
+ "full_name": "CategoryTheory.Groupoid.isIsomorphic_iff_nonempty_hom",
12
+ "id": "CategoryTheory.Groupoid.isIsomorphic_iff_nonempty_hom",
13
+ "reason": "import_failure",
14
+ "selection": {
15
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
16
+ "end": [
17
+ 65,
18
+ 44
19
+ ],
20
+ "file_path": "Mathlib/CategoryTheory/IsomorphismClasses.lean",
21
+ "full_name": "CategoryTheory.Groupoid.isIsomorphic_iff_nonempty_hom",
22
+ "start": [
23
+ 63,
24
+ 1
25
+ ],
26
+ "traced_tactics": [],
27
+ "url": "https://github.com/leanprover-community/mathlib4"
28
+ },
29
+ "source_file": "Mathlib/CategoryTheory/IsomorphismClasses.lean"
30
+ },
31
+ {
32
+ "error": "no internal trace for tactic 'rw [\u2190 sq.right_adjoint_hasLift_iff adj]'",
33
+ "full_name": "CategoryTheory.Adjunction.hasLiftingProperty_iff",
34
+ "id": "CategoryTheory.Adjunction.hasLiftingProperty_iff",
35
+ "reason": "import_failure",
36
+ "selection": {
37
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
38
+ "end": [
39
+ 132,
40
+ 19
41
+ ],
42
+ "file_path": "Mathlib/CategoryTheory/LiftingProperties/Adjunction.lean",
43
+ "full_name": "CategoryTheory.Adjunction.hasLiftingProperty_iff",
44
+ "start": [
45
+ 126,
46
+ 1
47
+ ],
48
+ "traced_tactics": [
49
+ {
50
+ "annotated_tactic": [
51
+ "\"constructor <;> intro <;> constructor <;> intro f g sq\"",
52
+ "[]"
53
+ ],
54
+ "state_after": "case mp.sq_hasLift\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{u_4, u_2} D\nG : C \u2964 D\nF : D \u2964 C\nadj : G \u22a3 F\nA B : C\nX Y : D\ni : A \u27f6 B\np : X \u27f6 Y\na\u271d : HasLiftingProperty (G.map i) p\nf : A \u27f6 F.obj X\ng : B \u27f6 F.obj Y\nsq : CommSq f i (F.map p) g\n\u22a2 sq.HasLift\n\ncase mpr.sq_hasLift\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{u_4, u_2} D\nG : C \u2964 D\nF : D \u2964 C\nadj : G \u22a3 F\nA B : C\nX Y : D\ni : A \u27f6 B\np : X \u27f6 Y\na\u271d : HasLiftingProperty i (F.map p)\nf : G.obj A \u27f6 X\ng : G.obj B \u27f6 Y\nsq : CommSq f (G.map i) p g\n\u22a2 sq.HasLift",
55
+ "state_before": "C : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{u_4, u_2} D\nG : C \u2964 D\nF : D \u2964 C\nadj : G \u22a3 F\nA B : C\nX Y : D\ni : A \u27f6 B\np : X \u27f6 Y\n\u22a2 HasLiftingProperty (G.map i) p \u2194 HasLiftingProperty i (F.map p)",
56
+ "tactic": "constructor <;> intro <;> constructor <;> intro f g sq"
57
+ },
58
+ {
59
+ "annotated_tactic": [
60
+ "\"rw [\\u2190 sq.left_adjoint_hasLift_iff adj]\"",
61
+ "[]"
62
+ ],
63
+ "state_after": "case mp.sq_hasLift\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{u_4, u_2} D\nG : C \u2964 D\nF : D \u2964 C\nadj : G \u22a3 F\nA B : C\nX Y : D\ni : A \u27f6 B\np : X \u27f6 Y\na\u271d : HasLiftingProperty (G.map i) p\nf : A \u27f6 F.obj X\ng : B \u27f6 F.obj Y\nsq : CommSq f i (F.map p) g\n\u22a2 \u22ef.HasLift",
64
+ "state_before": "case mp.sq_hasLift\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{u_4, u_2} D\nG : C \u2964 D\nF : D \u2964 C\nadj : G \u22a3 F\nA B : C\nX Y : D\ni : A \u27f6 B\np : X \u27f6 Y\na\u271d : HasLiftingProperty (G.map i) p\nf : A \u27f6 F.obj X\ng : B \u27f6 F.obj Y\nsq : CommSq f i (F.map p) g\n\u22a2 sq.HasLift",
65
+ "tactic": "rw [\u2190 sq.left_adjoint_hasLift_iff adj]"
66
+ },
67
+ {
68
+ "annotated_tactic": [
69
+ "\"infer_instance\"",
70
+ "[]"
71
+ ],
72
+ "state_after": "no goals",
73
+ "state_before": "case mp.sq_hasLift\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{u_4, u_2} D\nG : C \u2964 D\nF : D \u2964 C\nadj : G \u22a3 F\nA B : C\nX Y : D\ni : A \u27f6 B\np : X \u27f6 Y\na\u271d : HasLiftingProperty (G.map i) p\nf : A \u27f6 F.obj X\ng : B \u27f6 F.obj Y\nsq : CommSq f i (F.map p) g\n\u22a2 \u22ef.HasLift",
74
+ "tactic": "infer_instance"
75
+ },
76
+ {
77
+ "annotated_tactic": [
78
+ "\"rw [\\u2190 sq.right_adjoint_hasLift_iff adj]\"",
79
+ "[]"
80
+ ],
81
+ "state_after": "case mpr.sq_hasLift\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{u_4, u_2} D\nG : C \u2964 D\nF : D \u2964 C\nadj : G \u22a3 F\nA B : C\nX Y : D\ni : A \u27f6 B\np : X \u27f6 Y\na\u271d : HasLiftingProperty i (F.map p)\nf : G.obj A \u27f6 X\ng : G.obj B \u27f6 Y\nsq : CommSq f (G.map i) p g\n\u22a2 \u22ef.HasLift",
82
+ "state_before": "case mpr.sq_hasLift\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{u_4, u_2} D\nG : C \u2964 D\nF : D \u2964 C\nadj : G \u22a3 F\nA B : C\nX Y : D\ni : A \u27f6 B\np : X \u27f6 Y\na\u271d : HasLiftingProperty i (F.map p)\nf : G.obj A \u27f6 X\ng : G.obj B \u27f6 Y\nsq : CommSq f (G.map i) p g\n\u22a2 sq.HasLift",
83
+ "tactic": "rw [\u2190 sq.right_adjoint_hasLift_iff adj]"
84
+ },
85
+ {
86
+ "annotated_tactic": [
87
+ "\"infer_instance\"",
88
+ "[]"
89
+ ],
90
+ "state_after": "no goals",
91
+ "state_before": "case mpr.sq_hasLift\nC : Type u_1\nD : Type u_2\ninst\u271d\u00b9 : Category.{u_3, u_1} C\ninst\u271d : Category.{u_4, u_2} D\nG : C \u2964 D\nF : D \u2964 C\nadj : G \u22a3 F\nA B : C\nX Y : D\ni : A \u27f6 B\np : X \u27f6 Y\na\u271d : HasLiftingProperty i (F.map p)\nf : G.obj A \u27f6 X\ng : G.obj B \u27f6 Y\nsq : CommSq f (G.map i) p g\n\u22a2 \u22ef.HasLift",
92
+ "tactic": "infer_instance"
93
+ }
94
+ ],
95
+ "url": "https://github.com/leanprover-community/mathlib4"
96
+ },
97
+ "source_file": "Mathlib/CategoryTheory/LiftingProperties/Adjunction.lean"
98
+ }
99
+ ],
100
+ "input_proofs": 6,
101
+ "input_units": 2,
102
+ "proofs": 4,
103
+ "published_proofs": 4,
104
+ "published_transitions": 8,
105
+ "replay_failures": [],
106
+ "transitions": 8,
107
+ "validation_failures": [],
108
+ "validation_rejected_proofs": 0,
109
+ "zero_transition_proofs": 0
110
+ },
111
+ "shards": [
112
+ {
113
+ "path": "data/train/mathlib-000667-0000-0ea00aa04498dfc2.parquet",
114
+ "sha256": "0ea00aa04498dfc2bb7fa2888ccaa8ab2bc4ce432b392e57e7d75ede4e12d158",
115
+ "bytes": 63372,
116
+ "rows": 4,
117
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
118
+ },
119
+ {
120
+ "path": "data/internal_test/mathlib-000667-0000-11ce27b6df01aa9b.parquet",
121
+ "sha256": "11ce27b6df01aa9b204048fe063b171c634c4b30c7a4cfe98c7ccbd90864e1e4",
122
+ "bytes": 65348,
123
+ "rows": 4,
124
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
125
+ }
126
+ ],
127
+ "proof_ids": [
128
+ "mathlib:CategoryTheory.CommSq.left_adjoint",
129
+ "mathlib:CategoryTheory.CommSq.left_adjoint_hasLift_iff",
130
+ "mathlib:CategoryTheory.CommSq.right_adjoint",
131
+ "mathlib:CategoryTheory.CommSq.right_adjoint_hasLift_iff"
132
+ ],
133
+ "proof_keys": [
134
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/LiftingProperties/Adjunction.lean\",null,null,\"CategoryTheory.CommSq.left_adjoint\"]",
135
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/LiftingProperties/Adjunction.lean\",null,null,\"CategoryTheory.CommSq.left_adjoint_hasLift_iff\"]",
136
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/LiftingProperties/Adjunction.lean\",null,null,\"CategoryTheory.CommSq.right_adjoint\"]",
137
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/LiftingProperties/Adjunction.lean\",null,null,\"CategoryTheory.CommSq.right_adjoint_hasLift_iff\"]"
138
+ ]
139
+ }
manifests/batches/mathlib/000668.json ADDED
@@ -0,0 +1,186 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "format": "leangpt-parquet-v2",
3
+ "batch": "mathlib/000668",
4
+ "batch_fingerprint": "cb7339321dc604e15ded86844bc63f99283025064ab454db41ebf678bb59a3e6",
5
+ "evidence": {
6
+ "batch_fingerprint": "cb7339321dc604e15ded86844bc63f99283025064ab454db41ebf678bb59a3e6",
7
+ "contamination_matches": [],
8
+ "failures": [
9
+ {
10
+ "error": "theorem has no selected tactic transitions",
11
+ "full_name": "CategoryTheory.HasLiftingProperty.iff_op",
12
+ "id": "CategoryTheory.HasLiftingProperty.iff_op",
13
+ "reason": "import_failure",
14
+ "selection": {
15
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
16
+ "end": [
17
+ 70,
18
+ 13
19
+ ],
20
+ "file_path": "Mathlib/CategoryTheory/LiftingProperties/Basic.lean",
21
+ "full_name": "CategoryTheory.HasLiftingProperty.iff_op",
22
+ "start": [
23
+ 69,
24
+ 1
25
+ ],
26
+ "traced_tactics": [],
27
+ "url": "https://github.com/leanprover-community/mathlib4"
28
+ },
29
+ "source_file": "Mathlib/CategoryTheory/LiftingProperties/Basic.lean"
30
+ },
31
+ {
32
+ "error": "theorem has no selected tactic transitions",
33
+ "full_name": "CategoryTheory.HasLiftingProperty.iff_unop",
34
+ "id": "CategoryTheory.HasLiftingProperty.iff_unop",
35
+ "reason": "import_failure",
36
+ "selection": {
37
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
38
+ "end": [
39
+ 75,
40
+ 13
41
+ ],
42
+ "file_path": "Mathlib/CategoryTheory/LiftingProperties/Basic.lean",
43
+ "full_name": "CategoryTheory.HasLiftingProperty.iff_unop",
44
+ "start": [
45
+ 73,
46
+ 1
47
+ ],
48
+ "traced_tactics": [],
49
+ "url": "https://github.com/leanprover-community/mathlib4"
50
+ },
51
+ "source_file": "Mathlib/CategoryTheory/LiftingProperties/Basic.lean"
52
+ },
53
+ {
54
+ "error": "theorem has no selected tactic transitions",
55
+ "full_name": "CategoryTheory.Limits.map_id_left_eq_curry_map",
56
+ "id": "CategoryTheory.Limits.map_id_left_eq_curry_map",
57
+ "reason": "import_failure",
58
+ "selection": {
59
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
60
+ "end": [
61
+ 42,
62
+ 6
63
+ ],
64
+ "file_path": "Mathlib/CategoryTheory/Limits/ColimitLimit.lean",
65
+ "full_name": "CategoryTheory.Limits.map_id_left_eq_curry_map",
66
+ "start": [
67
+ 40,
68
+ 1
69
+ ],
70
+ "traced_tactics": [],
71
+ "url": "https://github.com/leanprover-community/mathlib4"
72
+ },
73
+ "source_file": "Mathlib/CategoryTheory/Limits/ColimitLimit.lean"
74
+ },
75
+ {
76
+ "error": "theorem has no selected tactic transitions",
77
+ "full_name": "CategoryTheory.Limits.map_id_right_eq_curry_swap_map",
78
+ "id": "CategoryTheory.Limits.map_id_right_eq_curry_swap_map",
79
+ "reason": "import_failure",
80
+ "selection": {
81
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
82
+ "end": [
83
+ 47,
84
+ 6
85
+ ],
86
+ "file_path": "Mathlib/CategoryTheory/Limits/ColimitLimit.lean",
87
+ "full_name": "CategoryTheory.Limits.map_id_right_eq_curry_swap_map",
88
+ "start": [
89
+ 45,
90
+ 1
91
+ ],
92
+ "traced_tactics": [],
93
+ "url": "https://github.com/leanprover-community/mathlib4"
94
+ },
95
+ "source_file": "Mathlib/CategoryTheory/Limits/ColimitLimit.lean"
96
+ }
97
+ ],
98
+ "input_proofs": 11,
99
+ "input_units": 2,
100
+ "proofs": 7,
101
+ "published_proofs": 6,
102
+ "published_transitions": 15,
103
+ "replay_failures": [],
104
+ "transitions": 17,
105
+ "validation_failures": [
106
+ {
107
+ "errors": [
108
+ "internal transition boundary mismatch"
109
+ ],
110
+ "file_path": "Mathlib/CategoryTheory/LiftingProperties/Basic.lean",
111
+ "proof_id": "mathlib:CategoryTheory.HasLiftingProperty.unop",
112
+ "provenance": {
113
+ "selection": {
114
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
115
+ "end": [
116
+ 66,
117
+ 20
118
+ ],
119
+ "file_path": "Mathlib/CategoryTheory/LiftingProperties/Basic.lean",
120
+ "full_name": "CategoryTheory.HasLiftingProperty.unop",
121
+ "start": [
122
+ 61,
123
+ 1
124
+ ],
125
+ "traced_tactics": [
126
+ {
127
+ "annotated_tactic": [
128
+ "\"rw [<a>CommSq.HasLift.iff_op<\\/a>]\"",
129
+ "[{\"full_name\":\"CategoryTheory.CommSq.HasLift.iff_op\",\"def_path\":\"Mathlib\\/CategoryTheory\\/CommSq.lean\",\"def_pos\":[246,9],\"def_end_pos\":[246,15]}]"
130
+ ],
131
+ "state_after": "C : Type u_1\ninst\u271d : Category.{u_2, u_1} C\nA\u271d B\u271d B' X\u271d Y\u271d Y' : C\ni\u271d : A\u271d \u27f6 B\u271d\ni' : B\u271d \u27f6 B'\np\u271d : X\u271d \u27f6 Y\u271d\np' : Y\u271d \u27f6 Y'\nA B X Y : C\u1d52\u1d56\ni : A \u27f6 B\np : X \u27f6 Y\nh : HasLiftingProperty i p\nf : Y.unop \u27f6 B.unop\ng : X.unop \u27f6 A.unop\nsq : CommSq f p.unop i.unop g\n\u22a2 \u22ef.HasLift",
132
+ "state_before": "C : Type u_1\ninst\u271d : Category.{u_2, u_1} C\nA\u271d B\u271d B' X\u271d Y\u271d Y' : C\ni\u271d : A\u271d \u27f6 B\u271d\ni' : B\u271d \u27f6 B'\np\u271d : X\u271d \u27f6 Y\u271d\np' : Y\u271d \u27f6 Y'\nA B X Y : C\u1d52\u1d56\ni : A \u27f6 B\np : X \u27f6 Y\nh : HasLiftingProperty i p\nf : Y.unop \u27f6 B.unop\ng : X.unop \u27f6 A.unop\nsq : CommSq f p.unop i.unop g\n\u22a2 sq.HasLift",
133
+ "tactic": "rw [CommSq.HasLift.iff_op]"
134
+ },
135
+ {
136
+ "annotated_tactic": [
137
+ "\"infer_instance\"",
138
+ "[]"
139
+ ],
140
+ "state_after": "no goals",
141
+ "state_before": "C : Type u_1\ninst\u271d : Category.{u_2, u_1} C\nA\u271d B\u271d B' X\u271d Y\u271d Y' : C\ni\u271d : A\u271d \u27f6 B\u271d\ni' : B\u271d \u27f6 B'\np\u271d : X\u271d \u27f6 Y\u271d\np' : Y\u271d \u27f6 Y'\nA B X Y : C\u1d52\u1d56\ni : A \u27f6 B\np : X \u27f6 Y\nh : HasLiftingProperty i p\nf : Y.unop \u27f6 B.unop\ng : X.unop \u27f6 A.unop\nsq : CommSq f p.unop i.unop g\n\u22a2 \u22ef.HasLift",
142
+ "tactic": "infer_instance"
143
+ }
144
+ ],
145
+ "url": "https://github.com/leanprover-community/mathlib4"
146
+ }
147
+ },
148
+ "theorem_name": "CategoryTheory.HasLiftingProperty.unop"
149
+ }
150
+ ],
151
+ "validation_rejected_proofs": 1,
152
+ "zero_transition_proofs": 0
153
+ },
154
+ "shards": [
155
+ {
156
+ "path": "data/train/mathlib-000668-0000-4869711afd3cac87.parquet",
157
+ "sha256": "4869711afd3cac870c48c3f6567eaabf4374c5fefac52cf6c54cdf92d12176fd",
158
+ "bytes": 193086,
159
+ "rows": 13,
160
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
161
+ },
162
+ {
163
+ "path": "data/internal_test/mathlib-000668-0000-9b2e62ef7dcc540a.parquet",
164
+ "sha256": "9b2e62ef7dcc540a05c087ee2b311d43e05508c1e357b9a2fba81c66b2505d4b",
165
+ "bytes": 50572,
166
+ "rows": 2,
167
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
168
+ }
169
+ ],
170
+ "proof_ids": [
171
+ "mathlib:CategoryTheory.HasLiftingProperty.iff_of_arrow_iso_left",
172
+ "mathlib:CategoryTheory.HasLiftingProperty.of_arrow_iso_left",
173
+ "mathlib:CategoryTheory.HasLiftingProperty.of_arrow_iso_right",
174
+ "mathlib:CategoryTheory.HasLiftingProperty.op",
175
+ "mathlib:CategoryTheory.Limits.\u03b9_colimitLimitToLimitColimit_\u03c0",
176
+ "mathlib:CategoryTheory.Limits.\u03b9_colimitLimitToLimitColimit_\u03c0_apply"
177
+ ],
178
+ "proof_keys": [
179
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/LiftingProperties/Basic.lean\",null,null,\"CategoryTheory.HasLiftingProperty.iff_of_arrow_iso_left\"]",
180
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/LiftingProperties/Basic.lean\",null,null,\"CategoryTheory.HasLiftingProperty.of_arrow_iso_left\"]",
181
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/LiftingProperties/Basic.lean\",null,null,\"CategoryTheory.HasLiftingProperty.of_arrow_iso_right\"]",
182
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/LiftingProperties/Basic.lean\",null,null,\"CategoryTheory.HasLiftingProperty.op\"]",
183
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/ColimitLimit.lean\",null,null,\"CategoryTheory.Limits.\u03b9_colimitLimitToLimitColimit_\u03c0\"]",
184
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/ColimitLimit.lean\",null,null,\"CategoryTheory.Limits.\u03b9_colimitLimitToLimitColimit_\u03c0_apply\"]"
185
+ ]
186
+ }
manifests/batches/mathlib/000669.json ADDED
@@ -0,0 +1,198 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "format": "leangpt-parquet-v2",
3
+ "batch": "mathlib/000669",
4
+ "batch_fingerprint": "c6bb087c67f906853ca464406442c7bf68bf691ab9d96e5918bbd2bf98725877",
5
+ "evidence": {
6
+ "batch_fingerprint": "c6bb087c67f906853ca464406442c7bf68bf691ab9d96e5918bbd2bf98725877",
7
+ "contamination_matches": [],
8
+ "failures": [
9
+ {
10
+ "error": "theorem has no selected tactic transitions",
11
+ "full_name": "CategoryTheory.StructuredArrow.mono_iff_mono_right",
12
+ "id": "CategoryTheory.StructuredArrow.mono_iff_mono_right",
13
+ "reason": "import_failure",
14
+ "selection": {
15
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
16
+ "end": [
17
+ 247,
18
+ 58
19
+ ],
20
+ "file_path": "Mathlib/CategoryTheory/Limits/Comma.lean",
21
+ "full_name": "CategoryTheory.StructuredArrow.mono_iff_mono_right",
22
+ "start": [
23
+ 245,
24
+ 1
25
+ ],
26
+ "traced_tactics": [],
27
+ "url": "https://github.com/leanprover-community/mathlib4"
28
+ },
29
+ "source_file": "Mathlib/CategoryTheory/Limits/Comma.lean"
30
+ },
31
+ {
32
+ "error": "theorem has no selected tactic transitions",
33
+ "full_name": "CategoryTheory.Limits.Concrete.colimit_exists_of_rep_eq",
34
+ "id": "CategoryTheory.Limits.Concrete.colimit_exists_of_rep_eq",
35
+ "reason": "import_failure",
36
+ "selection": {
37
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
38
+ "end": [
39
+ 140,
40
+ 72
41
+ ],
42
+ "file_path": "Mathlib/CategoryTheory/Limits/ConcreteCategory.lean",
43
+ "full_name": "CategoryTheory.Limits.Concrete.colimit_exists_of_rep_eq",
44
+ "start": [
45
+ 137,
46
+ 1
47
+ ],
48
+ "traced_tactics": [],
49
+ "url": "https://github.com/leanprover-community/mathlib4"
50
+ },
51
+ "source_file": "Mathlib/CategoryTheory/Limits/ConcreteCategory.lean"
52
+ },
53
+ {
54
+ "error": "theorem has no selected tactic transitions",
55
+ "full_name": "CategoryTheory.Limits.Concrete.colimit_exists_rep",
56
+ "id": "CategoryTheory.Limits.Concrete.colimit_exists_rep",
57
+ "reason": "import_failure",
58
+ "selection": {
59
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
60
+ "end": [
61
+ 94,
62
+ 58
63
+ ],
64
+ "file_path": "Mathlib/CategoryTheory/Limits/ConcreteCategory.lean",
65
+ "full_name": "CategoryTheory.Limits.Concrete.colimit_exists_rep",
66
+ "start": [
67
+ 92,
68
+ 1
69
+ ],
70
+ "traced_tactics": [],
71
+ "url": "https://github.com/leanprover-community/mathlib4"
72
+ },
73
+ "source_file": "Mathlib/CategoryTheory/Limits/ConcreteCategory.lean"
74
+ },
75
+ {
76
+ "error": "theorem has no selected tactic transitions",
77
+ "full_name": "CategoryTheory.Limits.Concrete.colimit_rep_eq_iff_exists",
78
+ "id": "CategoryTheory.Limits.Concrete.colimit_rep_eq_iff_exists",
79
+ "reason": "import_failure",
80
+ "selection": {
81
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
82
+ "end": [
83
+ 145,
84
+ 89
85
+ ],
86
+ "file_path": "Mathlib/CategoryTheory/Limits/ConcreteCategory.lean",
87
+ "full_name": "CategoryTheory.Limits.Concrete.colimit_rep_eq_iff_exists",
88
+ "start": [
89
+ 143,
90
+ 1
91
+ ],
92
+ "traced_tactics": [],
93
+ "url": "https://github.com/leanprover-community/mathlib4"
94
+ },
95
+ "source_file": "Mathlib/CategoryTheory/Limits/ConcreteCategory.lean"
96
+ },
97
+ {
98
+ "error": "theorem has no selected tactic transitions",
99
+ "full_name": "CategoryTheory.Limits.Concrete.colimit_rep_eq_of_exists",
100
+ "id": "CategoryTheory.Limits.Concrete.colimit_rep_eq_of_exists",
101
+ "reason": "import_failure",
102
+ "selection": {
103
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
104
+ "end": [
105
+ 112,
106
+ 46
107
+ ],
108
+ "file_path": "Mathlib/CategoryTheory/Limits/ConcreteCategory.lean",
109
+ "full_name": "CategoryTheory.Limits.Concrete.colimit_rep_eq_of_exists",
110
+ "start": [
111
+ 109,
112
+ 1
113
+ ],
114
+ "traced_tactics": [],
115
+ "url": "https://github.com/leanprover-community/mathlib4"
116
+ },
117
+ "source_file": "Mathlib/CategoryTheory/Limits/ConcreteCategory.lean"
118
+ },
119
+ {
120
+ "error": "theorem has no selected tactic transitions",
121
+ "full_name": "CategoryTheory.Limits.Concrete.isLimit_ext",
122
+ "id": "CategoryTheory.Limits.Concrete.isLimit_ext",
123
+ "reason": "import_failure",
124
+ "selection": {
125
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
126
+ "end": [
127
+ 59,
128
+ 59
129
+ ],
130
+ "file_path": "Mathlib/CategoryTheory/Limits/ConcreteCategory.lean",
131
+ "full_name": "CategoryTheory.Limits.Concrete.isLimit_ext",
132
+ "start": [
133
+ 57,
134
+ 1
135
+ ],
136
+ "traced_tactics": [],
137
+ "url": "https://github.com/leanprover-community/mathlib4"
138
+ },
139
+ "source_file": "Mathlib/CategoryTheory/Limits/ConcreteCategory.lean"
140
+ },
141
+ {
142
+ "error": "theorem has no selected tactic transitions",
143
+ "full_name": "CategoryTheory.Limits.Concrete.limit_ext",
144
+ "id": "CategoryTheory.Limits.Concrete.limit_ext",
145
+ "reason": "import_failure",
146
+ "selection": {
147
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
148
+ "end": [
149
+ 64,
150
+ 47
151
+ ],
152
+ "file_path": "Mathlib/CategoryTheory/Limits/ConcreteCategory.lean",
153
+ "full_name": "CategoryTheory.Limits.Concrete.limit_ext",
154
+ "start": [
155
+ 62,
156
+ 1
157
+ ],
158
+ "traced_tactics": [],
159
+ "url": "https://github.com/leanprover-community/mathlib4"
160
+ },
161
+ "source_file": "Mathlib/CategoryTheory/Limits/ConcreteCategory.lean"
162
+ }
163
+ ],
164
+ "input_proofs": 12,
165
+ "input_units": 2,
166
+ "proofs": 5,
167
+ "published_proofs": 5,
168
+ "published_transitions": 19,
169
+ "replay_failures": [],
170
+ "transitions": 19,
171
+ "validation_failures": [],
172
+ "validation_rejected_proofs": 0,
173
+ "zero_transition_proofs": 0
174
+ },
175
+ "shards": [
176
+ {
177
+ "path": "data/train/mathlib-000669-0000-94560b57f326b734.parquet",
178
+ "sha256": "94560b57f326b7346f1329ca7224c2cbece266750f8c96ec94915f9adccf0725",
179
+ "bytes": 202301,
180
+ "rows": 19,
181
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
182
+ }
183
+ ],
184
+ "proof_ids": [
185
+ "mathlib:CategoryTheory.Limits.Concrete.from_union_surjective_of_isColimit",
186
+ "mathlib:CategoryTheory.Limits.Concrete.isColimit_exists_of_rep_eq",
187
+ "mathlib:CategoryTheory.Limits.Concrete.isColimit_exists_rep",
188
+ "mathlib:CategoryTheory.Limits.Concrete.isColimit_rep_eq_of_exists",
189
+ "mathlib:CategoryTheory.Limits.Concrete.small_sections_of_hasLimit"
190
+ ],
191
+ "proof_keys": [
192
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/ConcreteCategory.lean\",null,null,\"CategoryTheory.Limits.Concrete.from_union_surjective_of_isColimit\"]",
193
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/ConcreteCategory.lean\",null,null,\"CategoryTheory.Limits.Concrete.isColimit_exists_of_rep_eq\"]",
194
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/ConcreteCategory.lean\",null,null,\"CategoryTheory.Limits.Concrete.isColimit_exists_rep\"]",
195
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/ConcreteCategory.lean\",null,null,\"CategoryTheory.Limits.Concrete.isColimit_rep_eq_of_exists\"]",
196
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/ConcreteCategory.lean\",null,null,\"CategoryTheory.Limits.Concrete.small_sections_of_hasLimit\"]"
197
+ ]
198
+ }
manifests/batches/mathlib/000670.json ADDED
@@ -0,0 +1,520 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "format": "leangpt-parquet-v2",
3
+ "batch": "mathlib/000670",
4
+ "batch_fingerprint": "c1bb04984d03da17af23cd996529644f734f5447fbeb128a98418f5cf51b69ab",
5
+ "evidence": {
6
+ "batch_fingerprint": "c1bb04984d03da17af23cd996529644f734f5447fbeb128a98418f5cf51b69ab",
7
+ "batch_outcome": "all_inputs_failed_with_evidence",
8
+ "contamination_matches": [],
9
+ "failures": [
10
+ {
11
+ "error": "theorem has no selected tactic transitions",
12
+ "full_name": "CategoryTheory.Limits.Cocone.toCostructuredArrow_comp_proj",
13
+ "id": "CategoryTheory.Limits.Cocone.toCostructuredArrow_comp_proj",
14
+ "reason": "import_failure",
15
+ "selection": {
16
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
17
+ "end": [
18
+ 251,
19
+ 6
20
+ ],
21
+ "file_path": "Mathlib/CategoryTheory/Limits/ConeCategory.lean",
22
+ "full_name": "CategoryTheory.Limits.Cocone.toCostructuredArrow_comp_proj",
23
+ "start": [
24
+ 248,
25
+ 1
26
+ ],
27
+ "traced_tactics": [],
28
+ "url": "https://github.com/leanprover-community/mathlib4"
29
+ },
30
+ "source_file": "Mathlib/CategoryTheory/Limits/ConeCategory.lean"
31
+ },
32
+ {
33
+ "error": "theorem has no selected tactic transitions",
34
+ "full_name": "CategoryTheory.Limits.Cocone.toCostructuredArrow_comp_toOver_comp_forget",
35
+ "id": "CategoryTheory.Limits.Cocone.toCostructuredArrow_comp_toOver_comp_forget",
36
+ "reason": "import_failure",
37
+ "selection": {
38
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
39
+ "end": [
40
+ 264,
41
+ 6
42
+ ],
43
+ "file_path": "Mathlib/CategoryTheory/Limits/ConeCategory.lean",
44
+ "full_name": "CategoryTheory.Limits.Cocone.toCostructuredArrow_comp_toOver_comp_forget",
45
+ "start": [
46
+ 261,
47
+ 1
48
+ ],
49
+ "traced_tactics": [],
50
+ "url": "https://github.com/leanprover-community/mathlib4"
51
+ },
52
+ "source_file": "Mathlib/CategoryTheory/Limits/ConeCategory.lean"
53
+ },
54
+ {
55
+ "error": "theorem has no selected tactic transitions",
56
+ "full_name": "CategoryTheory.Limits.Cone.toStructuredArrow_comp_proj",
57
+ "id": "CategoryTheory.Limits.Cone.toStructuredArrow_comp_proj",
58
+ "reason": "import_failure",
59
+ "selection": {
60
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
61
+ "end": [
62
+ 75,
63
+ 6
64
+ ],
65
+ "file_path": "Mathlib/CategoryTheory/Limits/ConeCategory.lean",
66
+ "full_name": "CategoryTheory.Limits.Cone.toStructuredArrow_comp_proj",
67
+ "start": [
68
+ 72,
69
+ 1
70
+ ],
71
+ "traced_tactics": [],
72
+ "url": "https://github.com/leanprover-community/mathlib4"
73
+ },
74
+ "source_file": "Mathlib/CategoryTheory/Limits/ConeCategory.lean"
75
+ },
76
+ {
77
+ "error": "theorem has no selected tactic transitions",
78
+ "full_name": "CategoryTheory.Limits.Cone.toStructuredArrow_comp_toUnder_comp_forget",
79
+ "id": "CategoryTheory.Limits.Cone.toStructuredArrow_comp_toUnder_comp_forget",
80
+ "reason": "import_failure",
81
+ "selection": {
82
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
83
+ "end": [
84
+ 88,
85
+ 6
86
+ ],
87
+ "file_path": "Mathlib/CategoryTheory/Limits/ConeCategory.lean",
88
+ "full_name": "CategoryTheory.Limits.Cone.toStructuredArrow_comp_toUnder_comp_forget",
89
+ "start": [
90
+ 85,
91
+ 1
92
+ ],
93
+ "traced_tactics": [],
94
+ "url": "https://github.com/leanprover-community/mathlib4"
95
+ },
96
+ "source_file": "Mathlib/CategoryTheory/Limits/ConeCategory.lean"
97
+ },
98
+ {
99
+ "error": "theorem has no selected tactic transitions",
100
+ "full_name": "CategoryTheory.Limits.IsColimit.descCoconeMorphism_eq_isInitial_to",
101
+ "id": "CategoryTheory.Limits.IsColimit.descCoconeMorphism_eq_isInitial_to",
102
+ "reason": "import_failure",
103
+ "selection": {
104
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
105
+ "end": [
106
+ 361,
107
+ 6
108
+ ],
109
+ "file_path": "Mathlib/CategoryTheory/Limits/ConeCategory.lean",
110
+ "full_name": "CategoryTheory.Limits.IsColimit.descCoconeMorphism_eq_isInitial_to",
111
+ "start": [
112
+ 358,
113
+ 1
114
+ ],
115
+ "traced_tactics": [],
116
+ "url": "https://github.com/leanprover-community/mathlib4"
117
+ },
118
+ "source_file": "Mathlib/CategoryTheory/Limits/ConeCategory.lean"
119
+ },
120
+ {
121
+ "error": "theorem has no selected tactic transitions",
122
+ "full_name": "CategoryTheory.Limits.IsInitial.to_eq_descCoconeMorphism",
123
+ "id": "CategoryTheory.Limits.IsInitial.to_eq_descCoconeMorphism",
124
+ "reason": "import_failure",
125
+ "selection": {
126
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
127
+ "end": [
128
+ 367,
129
+ 92
130
+ ],
131
+ "file_path": "Mathlib/CategoryTheory/Limits/ConeCategory.lean",
132
+ "full_name": "CategoryTheory.Limits.IsInitial.to_eq_descCoconeMorphism",
133
+ "start": [
134
+ 364,
135
+ 1
136
+ ],
137
+ "traced_tactics": [],
138
+ "url": "https://github.com/leanprover-community/mathlib4"
139
+ },
140
+ "source_file": "Mathlib/CategoryTheory/Limits/ConeCategory.lean"
141
+ },
142
+ {
143
+ "error": "theorem has no selected tactic transitions",
144
+ "full_name": "CategoryTheory.Limits.IsLimit.liftConeMorphism_eq_isTerminal_from",
145
+ "id": "CategoryTheory.Limits.IsLimit.liftConeMorphism_eq_isTerminal_from",
146
+ "reason": "import_failure",
147
+ "selection": {
148
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
149
+ "end": [
150
+ 192,
151
+ 6
152
+ ],
153
+ "file_path": "Mathlib/CategoryTheory/Limits/ConeCategory.lean",
154
+ "full_name": "CategoryTheory.Limits.IsLimit.liftConeMorphism_eq_isTerminal_from",
155
+ "start": [
156
+ 190,
157
+ 1
158
+ ],
159
+ "traced_tactics": [],
160
+ "url": "https://github.com/leanprover-community/mathlib4"
161
+ },
162
+ "source_file": "Mathlib/CategoryTheory/Limits/ConeCategory.lean"
163
+ },
164
+ {
165
+ "error": "theorem has no selected tactic transitions",
166
+ "full_name": "CategoryTheory.Limits.IsTerminal.from_eq_liftConeMorphism",
167
+ "id": "CategoryTheory.Limits.IsTerminal.from_eq_liftConeMorphism",
168
+ "reason": "import_failure",
169
+ "selection": {
170
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
171
+ "end": [
172
+ 198,
173
+ 90
174
+ ],
175
+ "file_path": "Mathlib/CategoryTheory/Limits/ConeCategory.lean",
176
+ "full_name": "CategoryTheory.Limits.IsTerminal.from_eq_liftConeMorphism",
177
+ "start": [
178
+ 195,
179
+ 1
180
+ ],
181
+ "traced_tactics": [],
182
+ "url": "https://github.com/leanprover-community/mathlib4"
183
+ },
184
+ "source_file": "Mathlib/CategoryTheory/Limits/ConeCategory.lean"
185
+ },
186
+ {
187
+ "error": "theorem has no selected tactic transitions",
188
+ "full_name": "CategoryTheory.Limits.hasColimit_iff_hasInitial_cocone",
189
+ "id": "CategoryTheory.Limits.hasColimit_iff_hasInitial_cocone",
190
+ "reason": "import_failure",
191
+ "selection": {
192
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
193
+ "end": [
194
+ 343,
195
+ 74
196
+ ],
197
+ "file_path": "Mathlib/CategoryTheory/Limits/ConeCategory.lean",
198
+ "full_name": "CategoryTheory.Limits.hasColimit_iff_hasInitial_cocone",
199
+ "start": [
200
+ 340,
201
+ 1
202
+ ],
203
+ "traced_tactics": [],
204
+ "url": "https://github.com/leanprover-community/mathlib4"
205
+ },
206
+ "source_file": "Mathlib/CategoryTheory/Limits/ConeCategory.lean"
207
+ },
208
+ {
209
+ "error": "theorem has no selected tactic transitions",
210
+ "full_name": "CategoryTheory.Limits.hasColimitsOfShape_iff_isRightAdjoint_const",
211
+ "id": "CategoryTheory.Limits.hasColimitsOfShape_iff_isRightAdjoint_const",
212
+ "reason": "import_failure",
213
+ "selection": {
214
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
215
+ "end": [
216
+ 355,
217
+ 57
218
+ ],
219
+ "file_path": "Mathlib/CategoryTheory/Limits/ConeCategory.lean",
220
+ "full_name": "CategoryTheory.Limits.hasColimitsOfShape_iff_isRightAdjoint_const",
221
+ "start": [
222
+ 346,
223
+ 1
224
+ ],
225
+ "traced_tactics": [],
226
+ "url": "https://github.com/leanprover-community/mathlib4"
227
+ },
228
+ "source_file": "Mathlib/CategoryTheory/Limits/ConeCategory.lean"
229
+ },
230
+ {
231
+ "error": "theorem has no selected tactic transitions",
232
+ "full_name": "CategoryTheory.Limits.hasLimit_iff_hasTerminal_cone",
233
+ "id": "CategoryTheory.Limits.hasLimit_iff_hasTerminal_cone",
234
+ "reason": "import_failure",
235
+ "selection": {
236
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
237
+ "end": [
238
+ 175,
239
+ 73
240
+ ],
241
+ "file_path": "Mathlib/CategoryTheory/Limits/ConeCategory.lean",
242
+ "full_name": "CategoryTheory.Limits.hasLimit_iff_hasTerminal_cone",
243
+ "start": [
244
+ 172,
245
+ 1
246
+ ],
247
+ "traced_tactics": [],
248
+ "url": "https://github.com/leanprover-community/mathlib4"
249
+ },
250
+ "source_file": "Mathlib/CategoryTheory/Limits/ConeCategory.lean"
251
+ },
252
+ {
253
+ "error": "theorem has no selected tactic transitions",
254
+ "full_name": "CategoryTheory.Limits.hasLimitsOfShape_iff_isLeftAdjoint_const",
255
+ "id": "CategoryTheory.Limits.hasLimitsOfShape_iff_isLeftAdjoint_const",
256
+ "reason": "import_failure",
257
+ "selection": {
258
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
259
+ "end": [
260
+ 187,
261
+ 59
262
+ ],
263
+ "file_path": "Mathlib/CategoryTheory/Limits/ConeCategory.lean",
264
+ "full_name": "CategoryTheory.Limits.hasLimitsOfShape_iff_isLeftAdjoint_const",
265
+ "start": [
266
+ 178,
267
+ 1
268
+ ],
269
+ "traced_tactics": [],
270
+ "url": "https://github.com/leanprover-community/mathlib4"
271
+ },
272
+ "source_file": "Mathlib/CategoryTheory/Limits/ConeCategory.lean"
273
+ },
274
+ {
275
+ "full_name": "CategoryTheory.Limits.Cocone.w",
276
+ "id": "CategoryTheory.Limits.Cocone.w",
277
+ "reason": "missing_trace",
278
+ "selection": {
279
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
280
+ "end": [
281
+ 184,
282
+ 16
283
+ ],
284
+ "file_path": "Mathlib/CategoryTheory/Limits/Cones.lean",
285
+ "full_name": "CategoryTheory.Limits.Cocone.w",
286
+ "start": [
287
+ 181,
288
+ 1
289
+ ],
290
+ "traced_tactics": [
291
+ {
292
+ "annotated_tactic": [
293
+ "\"rw [c.\\u03b9.naturality f]\"",
294
+ "[]"
295
+ ],
296
+ "state_after": "J : Type u\u2081\ninst\u271d\u00b3 : Category.{v\u2081, u\u2081} J\nK : Type u\u2082\ninst\u271d\u00b2 : Category.{v\u2082, u\u2082} K\nC : Type u\u2083\ninst\u271d\u00b9 : Category.{v\u2083, u\u2083} C\nD : Type u\u2084\ninst\u271d : Category.{v\u2084, u\u2084} D\nF : J \u2964 C\nc : Cocone F\nj j' : J\nf : j \u27f6 j'\n\u22a2 c.\u03b9.app j \u226b ((const J).obj c.pt).map f = c.\u03b9.app j",
297
+ "state_before": "J : Type u\u2081\ninst\u271d\u00b3 : Category.{v\u2081, u\u2081} J\nK : Type u\u2082\ninst\u271d\u00b2 : Category.{v\u2082, u\u2082} K\nC : Type u\u2083\ninst\u271d\u00b9 : Category.{v\u2083, u\u2083} C\nD : Type u\u2084\ninst\u271d : Category.{v\u2084, u\u2084} D\nF : J \u2964 C\nc : Cocone F\nj j' : J\nf : j \u27f6 j'\n\u22a2 F.map f \u226b c.\u03b9.app j' = c.\u03b9.app j",
298
+ "tactic": "rw [c.\u03b9.naturality f]"
299
+ },
300
+ {
301
+ "annotated_tactic": [
302
+ "\"apply <a>comp_id<\\/a>\"",
303
+ "[{\"full_name\":\"CategoryTheory.Category.comp_id\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[179,3],\"def_end_pos\":[179,10]}]"
304
+ ],
305
+ "state_after": "no goals",
306
+ "state_before": "J : Type u\u2081\ninst\u271d\u00b3 : Category.{v\u2081, u\u2081} J\nK : Type u\u2082\ninst\u271d\u00b2 : Category.{v\u2082, u\u2082} K\nC : Type u\u2083\ninst\u271d\u00b9 : Category.{v\u2083, u\u2083} C\nD : Type u\u2084\ninst\u271d : Category.{v\u2084, u\u2084} D\nF : J \u2964 C\nc : Cocone F\nj j' : J\nf : j \u27f6 j'\n\u22a2 c.\u03b9.app j \u226b ((const J).obj c.pt).map f = c.\u03b9.app j",
307
+ "tactic": "apply comp_id"
308
+ }
309
+ ],
310
+ "url": "https://github.com/leanprover-community/mathlib4"
311
+ },
312
+ "source_file": "Mathlib/CategoryTheory/Limits/Cones.lean"
313
+ },
314
+ {
315
+ "full_name": "CategoryTheory.Limits.Cocones.cocone_iso_of_hom_iso",
316
+ "id": "CategoryTheory.Limits.Cocones.cocone_iso_of_hom_iso",
317
+ "reason": "missing_trace",
318
+ "selection": {
319
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
320
+ "end": [
321
+ 557,
322
+ 79
323
+ ],
324
+ "file_path": "Mathlib/CategoryTheory/Limits/Cones.lean",
325
+ "full_name": "CategoryTheory.Limits.Cocones.cocone_iso_of_hom_iso",
326
+ "start": [
327
+ 554,
328
+ 1
329
+ ],
330
+ "traced_tactics": [
331
+ {
332
+ "annotated_tactic": [
333
+ "\"aesop_cat\"",
334
+ "[]"
335
+ ],
336
+ "state_after": "no goals",
337
+ "state_before": "J : Type u\u2081\ninst\u271d\u00b3 : Category.{v\u2081, u\u2081} J\nK\u271d : Type u\u2082\ninst\u271d\u00b2 : Category.{v\u2082, u\u2082} K\u271d\nC : Type u\u2083\ninst\u271d\u00b9 : Category.{v\u2083, u\u2083} C\nD : Type u\u2084\ninst\u271d : Category.{v\u2084, u\u2084} D\nF K : J \u2964 C\nc d : Cocone K\nf : c \u27f6 d\ni : IsIso f.hom\n\u22a2 f \u226b { hom := inv f.hom, w := \u22ef } = \ud835\udfd9 c \u2227 { hom := inv f.hom, w := \u22ef } \u226b f = \ud835\udfd9 d",
338
+ "tactic": "aesop_cat"
339
+ }
340
+ ],
341
+ "url": "https://github.com/leanprover-community/mathlib4"
342
+ },
343
+ "source_file": "Mathlib/CategoryTheory/Limits/Cones.lean"
344
+ },
345
+ {
346
+ "full_name": "CategoryTheory.Limits.Cone.w",
347
+ "id": "CategoryTheory.Limits.Cone.w",
348
+ "reason": "missing_trace",
349
+ "selection": {
350
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
351
+ "end": [
352
+ 146,
353
+ 16
354
+ ],
355
+ "file_path": "Mathlib/CategoryTheory/Limits/Cones.lean",
356
+ "full_name": "CategoryTheory.Limits.Cone.w",
357
+ "start": [
358
+ 143,
359
+ 1
360
+ ],
361
+ "traced_tactics": [
362
+ {
363
+ "annotated_tactic": [
364
+ "\"rw [\\u2190 c.\\u03c0.naturality f]\"",
365
+ "[]"
366
+ ],
367
+ "state_after": "J : Type u\u2081\ninst\u271d\u00b3 : Category.{v\u2081, u\u2081} J\nK : Type u\u2082\ninst\u271d\u00b2 : Category.{v\u2082, u\u2082} K\nC : Type u\u2083\ninst\u271d\u00b9 : Category.{v\u2083, u\u2083} C\nD : Type u\u2084\ninst\u271d : Category.{v\u2084, u\u2084} D\nF : J \u2964 C\nc : Cone F\nj j' : J\nf : j \u27f6 j'\n\u22a2 ((const J).obj c.pt).map f \u226b c.\u03c0.app j' = c.\u03c0.app j'",
368
+ "state_before": "J : Type u\u2081\ninst\u271d\u00b3 : Category.{v\u2081, u\u2081} J\nK : Type u\u2082\ninst\u271d\u00b2 : Category.{v\u2082, u\u2082} K\nC : Type u\u2083\ninst\u271d\u00b9 : Category.{v\u2083, u\u2083} C\nD : Type u\u2084\ninst\u271d : Category.{v\u2084, u\u2084} D\nF : J \u2964 C\nc : Cone F\nj j' : J\nf : j \u27f6 j'\n\u22a2 c.\u03c0.app j \u226b F.map f = c.\u03c0.app j'",
369
+ "tactic": "rw [\u2190 c.\u03c0.naturality f]"
370
+ },
371
+ {
372
+ "annotated_tactic": [
373
+ "\"apply <a>id_comp<\\/a>\"",
374
+ "[{\"full_name\":\"CategoryTheory.Category.id_comp\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[177,3],\"def_end_pos\":[177,10]}]"
375
+ ],
376
+ "state_after": "no goals",
377
+ "state_before": "J : Type u\u2081\ninst\u271d\u00b3 : Category.{v\u2081, u\u2081} J\nK : Type u\u2082\ninst\u271d\u00b2 : Category.{v\u2082, u\u2082} K\nC : Type u\u2083\ninst\u271d\u00b9 : Category.{v\u2083, u\u2083} C\nD : Type u\u2084\ninst\u271d : Category.{v\u2084, u\u2084} D\nF : J \u2964 C\nc : Cone F\nj j' : J\nf : j \u27f6 j'\n\u22a2 ((const J).obj c.pt).map f \u226b c.\u03c0.app j' = c.\u03c0.app j'",
378
+ "tactic": "apply id_comp"
379
+ }
380
+ ],
381
+ "url": "https://github.com/leanprover-community/mathlib4"
382
+ },
383
+ "source_file": "Mathlib/CategoryTheory/Limits/Cones.lean"
384
+ },
385
+ {
386
+ "full_name": "CategoryTheory.Limits.ConeMorphism.ext",
387
+ "id": "CategoryTheory.Limits.ConeMorphism.ext",
388
+ "reason": "missing_trace",
389
+ "selection": {
390
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
391
+ "end": [
392
+ 307,
393
+ 8
394
+ ],
395
+ "file_path": "Mathlib/CategoryTheory/Limits/Cones.lean",
396
+ "full_name": "CategoryTheory.Limits.ConeMorphism.ext",
397
+ "start": [
398
+ 304,
399
+ 1
400
+ ],
401
+ "traced_tactics": [
402
+ {
403
+ "annotated_tactic": [
404
+ "\"cases f\"",
405
+ "[]"
406
+ ],
407
+ "state_after": "case mk\nJ : Type u\u2081\ninst\u271d\u00b3 : Category.{v\u2081, u\u2081} J\nK : Type u\u2082\ninst\u271d\u00b2 : Category.{v\u2082, u\u2082} K\nC : Type u\u2083\ninst\u271d\u00b9 : Category.{v\u2083, u\u2083} C\nD : Type u\u2084\ninst\u271d : Category.{v\u2084, u\u2084} D\nF : J \u2964 C\nc c' : Cone F\ng : c \u27f6 c'\nhom\u271d : c.pt \u27f6 c'.pt\nw\u271d : \u2200 (j : J), hom\u271d \u226b c'.\u03c0.app j = c.\u03c0.app j\nw : { hom := hom\u271d, w := w\u271d }.hom = g.hom\n\u22a2 { hom := hom\u271d, w := w\u271d } = g",
408
+ "state_before": "J : Type u\u2081\ninst\u271d\u00b3 : Category.{v\u2081, u\u2081} J\nK : Type u\u2082\ninst\u271d\u00b2 : Category.{v\u2082, u\u2082} K\nC : Type u\u2083\ninst\u271d\u00b9 : Category.{v\u2083, u\u2083} C\nD : Type u\u2084\ninst\u271d : Category.{v\u2084, u\u2084} D\nF : J \u2964 C\nc c' : Cone F\nf g : c \u27f6 c'\nw : f.hom = g.hom\n\u22a2 f = g",
409
+ "tactic": "cases f"
410
+ },
411
+ {
412
+ "annotated_tactic": [
413
+ "\"cases g\"",
414
+ "[]"
415
+ ],
416
+ "state_after": "case mk.mk\nJ : Type u\u2081\ninst\u271d\u00b3 : Category.{v\u2081, u\u2081} J\nK : Type u\u2082\ninst\u271d\u00b2 : Category.{v\u2082, u\u2082} K\nC : Type u\u2083\ninst\u271d\u00b9 : Category.{v\u2083, u\u2083} C\nD : Type u\u2084\ninst\u271d : Category.{v\u2084, u\u2084} D\nF : J \u2964 C\nc c' : Cone F\nhom\u271d\u00b9 : c.pt \u27f6 c'.pt\nw\u271d\u00b9 : \u2200 (j : J), hom\u271d\u00b9 \u226b c'.\u03c0.app j = c.\u03c0.app j\nhom\u271d : c.pt \u27f6 c'.pt\nw\u271d : \u2200 (j : J), hom\u271d \u226b c'.\u03c0.app j = c.\u03c0.app j\nw : { hom := hom\u271d\u00b9, w := w\u271d\u00b9 }.hom = { hom := hom\u271d, w := w\u271d }.hom\n\u22a2 { hom := hom\u271d\u00b9, w := w\u271d\u00b9 } = { hom := hom\u271d, w := w\u271d }",
417
+ "state_before": "case mk\nJ : Type u\u2081\ninst\u271d\u00b3 : Category.{v\u2081, u\u2081} J\nK : Type u\u2082\ninst\u271d\u00b2 : Category.{v\u2082, u\u2082} K\nC : Type u\u2083\ninst\u271d\u00b9 : Category.{v\u2083, u\u2083} C\nD : Type u\u2084\ninst\u271d : Category.{v\u2084, u\u2084} D\nF : J \u2964 C\nc c' : Cone F\ng : c \u27f6 c'\nhom\u271d : c.pt \u27f6 c'.pt\nw\u271d : \u2200 (j : J), hom\u271d \u226b c'.\u03c0.app j = c.\u03c0.app j\nw : { hom := hom\u271d, w := w\u271d }.hom = g.hom\n\u22a2 { hom := hom\u271d, w := w\u271d } = g",
418
+ "tactic": "cases g"
419
+ },
420
+ {
421
+ "annotated_tactic": [
422
+ "\"congr\"",
423
+ "[]"
424
+ ],
425
+ "state_after": "no goals",
426
+ "state_before": "case mk.mk\nJ : Type u\u2081\ninst\u271d\u00b3 : Category.{v\u2081, u\u2081} J\nK : Type u\u2082\ninst\u271d\u00b2 : Category.{v\u2082, u\u2082} K\nC : Type u\u2083\ninst\u271d\u00b9 : Category.{v\u2083, u\u2083} C\nD : Type u\u2084\ninst\u271d : Category.{v\u2084, u\u2084} D\nF : J \u2964 C\nc c' : Cone F\nhom\u271d\u00b9 : c.pt \u27f6 c'.pt\nw\u271d\u00b9 : \u2200 (j : J), hom\u271d\u00b9 \u226b c'.\u03c0.app j = c.\u03c0.app j\nhom\u271d : c.pt \u27f6 c'.pt\nw\u271d : \u2200 (j : J), hom\u271d \u226b c'.\u03c0.app j = c.\u03c0.app j\nw : { hom := hom\u271d\u00b9, w := w\u271d\u00b9 }.hom = { hom := hom\u271d, w := w\u271d }.hom\n\u22a2 { hom := hom\u271d\u00b9, w := w\u271d\u00b9 } = { hom := hom\u271d, w := w\u271d }",
427
+ "tactic": "congr"
428
+ }
429
+ ],
430
+ "url": "https://github.com/leanprover-community/mathlib4"
431
+ },
432
+ "source_file": "Mathlib/CategoryTheory/Limits/Cones.lean"
433
+ },
434
+ {
435
+ "full_name": "CategoryTheory.Limits.Cones.cone_iso_of_hom_iso",
436
+ "id": "CategoryTheory.Limits.Cones.cone_iso_of_hom_iso",
437
+ "reason": "missing_trace",
438
+ "selection": {
439
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
440
+ "end": [
441
+ 335,
442
+ 81
443
+ ],
444
+ "file_path": "Mathlib/CategoryTheory/Limits/Cones.lean",
445
+ "full_name": "CategoryTheory.Limits.Cones.cone_iso_of_hom_iso",
446
+ "start": [
447
+ 333,
448
+ 1
449
+ ],
450
+ "traced_tactics": [
451
+ {
452
+ "annotated_tactic": [
453
+ "\"aesop_cat\"",
454
+ "[]"
455
+ ],
456
+ "state_after": "no goals",
457
+ "state_before": "J : Type u\u2081\ninst\u271d\u00b3 : Category.{v\u2081, u\u2081} J\nK\u271d : Type u\u2082\ninst\u271d\u00b2 : Category.{v\u2082, u\u2082} K\u271d\nC : Type u\u2083\ninst\u271d\u00b9 : Category.{v\u2083, u\u2083} C\nD : Type u\u2084\ninst\u271d : Category.{v\u2084, u\u2084} D\nF K : J \u2964 C\nc d : Cone K\nf : c \u27f6 d\ni : IsIso f.hom\n\u22a2 f \u226b { hom := inv f.hom, w := \u22ef } = \ud835\udfd9 c \u2227 { hom := inv f.hom, w := \u22ef } \u226b f = \ud835\udfd9 d",
458
+ "tactic": "aesop_cat"
459
+ }
460
+ ],
461
+ "url": "https://github.com/leanprover-community/mathlib4"
462
+ },
463
+ "source_file": "Mathlib/CategoryTheory/Limits/Cones.lean"
464
+ },
465
+ {
466
+ "full_name": "CategoryTheory.Limits.coconeOfConeLeftOp_\u03b9_app",
467
+ "id": "CategoryTheory.Limits.coconeOfConeLeftOp_\u03b9_app",
468
+ "reason": "missing_trace",
469
+ "selection": {
470
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
471
+ "end": [
472
+ 992,
473
+ 7
474
+ ],
475
+ "file_path": "Mathlib/CategoryTheory/Limits/Cones.lean",
476
+ "full_name": "CategoryTheory.Limits.coconeOfConeLeftOp_\u03b9_app",
477
+ "start": [
478
+ 989,
479
+ 1
480
+ ],
481
+ "traced_tactics": [
482
+ {
483
+ "annotated_tactic": [
484
+ "\"dsimp only [<a>coconeOfConeLeftOp<\\/a>]\"",
485
+ "[{\"full_name\":\"CategoryTheory.Limits.coconeOfConeLeftOp\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Cones.lean\",\"def_pos\":[983,5],\"def_end_pos\":[983,23]}]"
486
+ ],
487
+ "state_after": "J : Type u\u2081\ninst\u271d\u00b3 : Category.{v\u2081, u\u2081} J\nK : Type u\u2082\ninst\u271d\u00b2 : Category.{v\u2082, u\u2082} K\nC : Type u\u2083\ninst\u271d\u00b9 : Category.{v\u2083, u\u2083} C\nD : Type u\u2084\ninst\u271d : Category.{v\u2084, u\u2084} D\nF : J \u2964 C\u1d52\u1d56\nc : Cone F.leftOp\nj : J\n\u22a2 (NatTrans.removeLeftOp c.\u03c0).app j = (c.\u03c0.app { unop := j }).op",
488
+ "state_before": "J : Type u\u2081\ninst\u271d\u00b3 : Category.{v\u2081, u\u2081} J\nK : Type u\u2082\ninst\u271d\u00b2 : Category.{v\u2082, u\u2082} K\nC : Type u\u2083\ninst\u271d\u00b9 : Category.{v\u2083, u\u2083} C\nD : Type u\u2084\ninst\u271d : Category.{v\u2084, u\u2084} D\nF : J \u2964 C\u1d52\u1d56\nc : Cone F.leftOp\nj : J\n\u22a2 (coconeOfConeLeftOp c).\u03b9.app j = (c.\u03c0.app { unop := j }).op",
489
+ "tactic": "dsimp only [coconeOfConeLeftOp]"
490
+ },
491
+ {
492
+ "annotated_tactic": [
493
+ "\"simp\"",
494
+ "[]"
495
+ ],
496
+ "state_after": "no goals",
497
+ "state_before": "J : Type u\u2081\ninst\u271d\u00b3 : Category.{v\u2081, u\u2081} J\nK : Type u\u2082\ninst\u271d\u00b2 : Category.{v\u2082, u\u2082} K\nC : Type u\u2083\ninst\u271d\u00b9 : Category.{v\u2083, u\u2083} C\nD : Type u\u2084\ninst\u271d : Category.{v\u2084, u\u2084} D\nF : J \u2964 C\u1d52\u1d56\nc : Cone F.leftOp\nj : J\n\u22a2 (NatTrans.removeLeftOp c.\u03c0).app j = (c.\u03c0.app { unop := j }).op",
498
+ "tactic": "simp"
499
+ }
500
+ ],
501
+ "url": "https://github.com/leanprover-community/mathlib4"
502
+ },
503
+ "source_file": "Mathlib/CategoryTheory/Limits/Cones.lean"
504
+ }
505
+ ],
506
+ "input_proofs": 18,
507
+ "input_units": 2,
508
+ "proofs": 0,
509
+ "published_proofs": 0,
510
+ "published_transitions": 0,
511
+ "replay_failures": [],
512
+ "transitions": 0,
513
+ "validation_failures": [],
514
+ "validation_rejected_proofs": 0,
515
+ "zero_transition_proofs": 0
516
+ },
517
+ "shards": [],
518
+ "proof_ids": [],
519
+ "proof_keys": []
520
+ }
manifests/batches/mathlib/000671.json ADDED
@@ -0,0 +1,64 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "format": "leangpt-parquet-v2",
3
+ "batch": "mathlib/000671",
4
+ "batch_fingerprint": "cc145b58bd057a07c18e9d6712752c9ec576ba83b4a4a5c9e952025fd600064d",
5
+ "evidence": {
6
+ "batch_fingerprint": "cc145b58bd057a07c18e9d6712752c9ec576ba83b4a4a5c9e952025fd600064d",
7
+ "contamination_matches": [],
8
+ "failures": [
9
+ {
10
+ "error": "theorem has no selected tactic transitions",
11
+ "full_name": "hasBinaryCoproducts_of_hasInitial_and_pushouts",
12
+ "id": "hasBinaryCoproducts_of_hasInitial_and_pushouts",
13
+ "reason": "import_failure",
14
+ "selection": {
15
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
16
+ "end": [
17
+ 191,
18
+ 82
19
+ ],
20
+ "file_path": "Mathlib/CategoryTheory/Limits/Constructions/BinaryProducts.lean",
21
+ "full_name": "hasBinaryCoproducts_of_hasInitial_and_pushouts",
22
+ "start": [
23
+ 189,
24
+ 1
25
+ ],
26
+ "traced_tactics": [],
27
+ "url": "https://github.com/leanprover-community/mathlib4"
28
+ },
29
+ "source_file": "Mathlib/CategoryTheory/Limits/Constructions/BinaryProducts.lean"
30
+ }
31
+ ],
32
+ "input_proofs": 5,
33
+ "input_units": 2,
34
+ "proofs": 4,
35
+ "published_proofs": 4,
36
+ "published_transitions": 12,
37
+ "replay_failures": [],
38
+ "transitions": 12,
39
+ "validation_failures": [],
40
+ "validation_rejected_proofs": 0,
41
+ "zero_transition_proofs": 0
42
+ },
43
+ "shards": [
44
+ {
45
+ "path": "data/train/mathlib-000671-0000-abbacd1dda5038db.parquet",
46
+ "sha256": "abbacd1dda5038db68d11fbcb444cdf6ff72e398f67c29875cc54c88033076c1",
47
+ "bytes": 97142,
48
+ "rows": 12,
49
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
50
+ }
51
+ ],
52
+ "proof_ids": [
53
+ "mathlib:CategoryTheory.preserves_epi_of_preservesColimit",
54
+ "mathlib:CategoryTheory.preserves_mono_of_preservesLimit",
55
+ "mathlib:CategoryTheory.reflects_epi_of_reflectsColimit",
56
+ "mathlib:CategoryTheory.reflects_mono_of_reflectsLimit"
57
+ ],
58
+ "proof_keys": [
59
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Constructions/EpiMono.lean\",null,null,\"CategoryTheory.preserves_epi_of_preservesColimit\"]",
60
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Constructions/EpiMono.lean\",null,null,\"CategoryTheory.preserves_mono_of_preservesLimit\"]",
61
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Constructions/EpiMono.lean\",null,null,\"CategoryTheory.reflects_epi_of_reflectsColimit\"]",
62
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Constructions/EpiMono.lean\",null,null,\"CategoryTheory.reflects_mono_of_reflectsLimit\"]"
63
+ ]
64
+ }
manifests/batches/mathlib/000672.json ADDED
@@ -0,0 +1,236 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "format": "leangpt-parquet-v2",
3
+ "batch": "mathlib/000672",
4
+ "batch_fingerprint": "07545c8cd2240728b913d21303688adeb293519b2f28bfea61290815c45c5b94",
5
+ "evidence": {
6
+ "batch_fingerprint": "07545c8cd2240728b913d21303688adeb293519b2f28bfea61290815c45c5b94",
7
+ "batch_outcome": "all_inputs_failed_with_evidence",
8
+ "contamination_matches": [],
9
+ "failures": [
10
+ {
11
+ "full_name": "CategoryTheory.Limits.HasCoequalizersOfHasPushoutsAndBinaryCoproducts.pushoutInl_eq_pushout_inr",
12
+ "id": "CategoryTheory.Limits.HasCoequalizersOfHasPushoutsAndBinaryCoproducts.pushoutInl_eq_pushout_inr",
13
+ "reason": "missing_trace",
14
+ "selection": {
15
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
16
+ "end": [
17
+ 151,
18
+ 57
19
+ ],
20
+ "file_path": "Mathlib/CategoryTheory/Limits/Constructions/Equalizers.lean",
21
+ "full_name": "CategoryTheory.Limits.HasCoequalizersOfHasPushoutsAndBinaryCoproducts.pushoutInl_eq_pushout_inr",
22
+ "start": [
23
+ 149,
24
+ 1
25
+ ],
26
+ "traced_tactics": [
27
+ {
28
+ "annotated_tactic": [
29
+ "\"convert (<a>whisker_eq<\\/a> <a>Limits.coprod.inl<\\/a> <a>pushout.condition<\\/a> :\\n (_ : F.obj _ \\u27f6 <a>constructCoequalizer<\\/a> _) = _) <;> simp\"",
30
+ "[{\"full_name\":\"CategoryTheory.whisker_eq\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[217,9],\"def_end_pos\":[217,19]},{\"full_name\":\"CategoryTheory.Limits.coprod.inl\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/BinaryProducts.lean\",\"def_pos\":[556,8],\"def_end_pos\":[556,18]},{\"full_name\":\"CategoryTheory.Limits.pushout.condition\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/Pullbacks.lean\",\"def_pos\":[1251,9],\"def_end_pos\":[1251,26]},{\"full_name\":\"CategoryTheory.Limits.HasCoequalizersOfHasPushoutsAndBinaryCoproducts.constructCoequalizer\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Constructions\\/Equalizers.lean\",\"def_pos\":[138,8],\"def_end_pos\":[138,28]}]"
31
+ ],
32
+ "state_after": "no goals",
33
+ "state_before": "C : Type u\ninst\u271d\u00b3 : Category.{v, u} C\nD : Type u'\ninst\u271d\u00b2 : Category.{v', u'} D\nG : C \u2964 D\ninst\u271d\u00b9 : HasBinaryCoproducts C\ninst\u271d : HasPushouts C\nF : WalkingParallelPair \u2964 C\n\u22a2 pushoutInl F = pushout.inr",
34
+ "tactic": "convert (whisker_eq Limits.coprod.inl pushout.condition :\n (_ : F.obj _ \u27f6 constructCoequalizer _) = _) <;> simp"
35
+ }
36
+ ],
37
+ "url": "https://github.com/leanprover-community/mathlib4"
38
+ },
39
+ "source_file": "Mathlib/CategoryTheory/Limits/Constructions/Equalizers.lean"
40
+ },
41
+ {
42
+ "full_name": "CategoryTheory.Limits.HasEqualizersOfHasPullbacksAndBinaryProducts.pullbackFst_eq_pullback_snd",
43
+ "id": "CategoryTheory.Limits.HasEqualizersOfHasPullbacksAndBinaryProducts.pullbackFst_eq_pullback_snd",
44
+ "reason": "missing_trace",
45
+ "selection": {
46
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
47
+ "end": [
48
+ 54,
49
+ 80
50
+ ],
51
+ "file_path": "Mathlib/CategoryTheory/Limits/Constructions/Equalizers.lean",
52
+ "full_name": "CategoryTheory.Limits.HasEqualizersOfHasPullbacksAndBinaryProducts.pullbackFst_eq_pullback_snd",
53
+ "start": [
54
+ 51,
55
+ 1
56
+ ],
57
+ "traced_tactics": [
58
+ {
59
+ "annotated_tactic": [
60
+ "\"convert (<a>eq_whisker<\\/a> <a>pullback.condition<\\/a> <a>Limits.prod.fst<\\/a> :\\n (_ : <a>constructEqualizer<\\/a> F \\u27f6 F.obj <a>WalkingParallelPair.zero<\\/a>) = _) <;> simp\"",
61
+ "[{\"full_name\":\"CategoryTheory.eq_whisker\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[213,9],\"def_end_pos\":[213,19]},{\"full_name\":\"CategoryTheory.Limits.pullback.condition\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/Pullbacks.lean\",\"def_pos\":[1245,9],\"def_end_pos\":[1245,27]},{\"full_name\":\"CategoryTheory.Limits.prod.fst\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/BinaryProducts.lean\",\"def_pos\":[546,8],\"def_end_pos\":[546,16]},{\"full_name\":\"CategoryTheory.Limits.HasEqualizersOfHasPullbacksAndBinaryProducts.constructEqualizer\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Constructions\\/Equalizers.lean\",\"def_pos\":[40,8],\"def_end_pos\":[40,26]},{\"full_name\":\"CategoryTheory.Limits.WalkingParallelPair.zero\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/Equalizers.lean\",\"def_pos\":[62,5],\"def_end_pos\":[62,9]}]"
62
+ ],
63
+ "state_after": "no goals",
64
+ "state_before": "C : Type u\ninst\u271d\u00b3 : Category.{v, u} C\nD : Type u'\ninst\u271d\u00b2 : Category.{v', u'} D\nG : C \u2964 D\ninst\u271d\u00b9 : HasBinaryProducts C\ninst\u271d : HasPullbacks C\nF : WalkingParallelPair \u2964 C\n\u22a2 pullbackFst F = pullback.snd",
65
+ "tactic": "convert (eq_whisker pullback.condition Limits.prod.fst :\n (_ : constructEqualizer F \u27f6 F.obj WalkingParallelPair.zero) = _) <;> simp"
66
+ }
67
+ ],
68
+ "url": "https://github.com/leanprover-community/mathlib4"
69
+ },
70
+ "source_file": "Mathlib/CategoryTheory/Limits/Constructions/Equalizers.lean"
71
+ },
72
+ {
73
+ "full_name": "CategoryTheory.Limits.hasCoequalizers_of_hasPushouts_and_binary_coproducts",
74
+ "id": "CategoryTheory.Limits.hasCoequalizers_of_hasPushouts_and_binary_coproducts",
75
+ "reason": "missing_trace",
76
+ "selection": {
77
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
78
+ "end": [
79
+ 192,
80
+ 56
81
+ ],
82
+ "file_path": "Mathlib/CategoryTheory/Limits/Constructions/Equalizers.lean",
83
+ "full_name": "CategoryTheory.Limits.hasCoequalizers_of_hasPushouts_and_binary_coproducts",
84
+ "start": [
85
+ 186,
86
+ 1
87
+ ],
88
+ "traced_tactics": [],
89
+ "url": "https://github.com/leanprover-community/mathlib4"
90
+ },
91
+ "source_file": "Mathlib/CategoryTheory/Limits/Constructions/Equalizers.lean"
92
+ },
93
+ {
94
+ "full_name": "CategoryTheory.Limits.hasEqualizers_of_hasPullbacks_and_binary_products",
95
+ "id": "CategoryTheory.Limits.hasEqualizers_of_hasPullbacks_and_binary_products",
96
+ "reason": "missing_trace",
97
+ "selection": {
98
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
99
+ "end": [
100
+ 92,
101
+ 48
102
+ ],
103
+ "file_path": "Mathlib/CategoryTheory/Limits/Constructions/Equalizers.lean",
104
+ "full_name": "CategoryTheory.Limits.hasEqualizers_of_hasPullbacks_and_binary_products",
105
+ "start": [
106
+ 87,
107
+ 1
108
+ ],
109
+ "traced_tactics": [],
110
+ "url": "https://github.com/leanprover-community/mathlib4"
111
+ },
112
+ "source_file": "Mathlib/CategoryTheory/Limits/Constructions/Equalizers.lean"
113
+ },
114
+ {
115
+ "error": "no internal trace for tactic 'exact \u27e8fun F => HasColimit.mk (liftToFinsetColimitCocone F)\u27e9'",
116
+ "full_name": "CategoryTheory.Limits.hasCoproducts_of_finite_and_filtered",
117
+ "id": "CategoryTheory.Limits.hasCoproducts_of_finite_and_filtered",
118
+ "reason": "import_failure",
119
+ "selection": {
120
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
121
+ "end": [
122
+ 81,
123
+ 73
124
+ ],
125
+ "file_path": "Mathlib/CategoryTheory/Limits/Constructions/Filtered.lean",
126
+ "full_name": "CategoryTheory.Limits.hasCoproducts_of_finite_and_filtered",
127
+ "start": [
128
+ 79,
129
+ 1
130
+ ],
131
+ "traced_tactics": [
132
+ {
133
+ "annotated_tactic": [
134
+ "\"classical exact \\u27e8fun F => <a>HasColimit.mk<\\/a> (<a>liftToFinsetColimitCocone<\\/a> F)\\u27e9\"",
135
+ "[{\"full_name\":\"CategoryTheory.Limits.HasColimit.mk\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/HasLimits.lean\",\"def_pos\":[677,9],\"def_end_pos\":[677,22]},{\"full_name\":\"CategoryTheory.Limits.CoproductsFromFiniteFiltered.liftToFinsetColimitCocone\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Constructions\\/Filtered.lean\",\"def_pos\":[50,5],\"def_end_pos\":[50,30]}]"
136
+ ],
137
+ "state_after": "no goals",
138
+ "state_before": "C : Type u\ninst\u271d\u00b2 : Category.{v, u} C\n\u03b1\u271d : Type w\ninst\u271d\u00b9 : HasFiniteCoproducts C\ninst\u271d : HasFilteredColimitsOfSize.{w, w, v, u} C\n\u03b1 : Type w\n\u22a2 HasColimitsOfShape (Discrete \u03b1) C",
139
+ "tactic": "classical exact \u27e8fun F => HasColimit.mk (liftToFinsetColimitCocone F)\u27e9"
140
+ },
141
+ {
142
+ "annotated_tactic": [
143
+ "\"exact \\u27e8fun F => <a>HasColimit.mk<\\/a> (<a>liftToFinsetColimitCocone<\\/a> F)\\u27e9\"",
144
+ "[{\"full_name\":\"CategoryTheory.Limits.HasColimit.mk\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/HasLimits.lean\",\"def_pos\":[677,9],\"def_end_pos\":[677,22]},{\"full_name\":\"CategoryTheory.Limits.CoproductsFromFiniteFiltered.liftToFinsetColimitCocone\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Constructions\\/Filtered.lean\",\"def_pos\":[50,5],\"def_end_pos\":[50,30]}]"
145
+ ],
146
+ "state_after": "no goals",
147
+ "state_before": "C : Type u\ninst\u271d\u00b2 : Category.{v, u} C\n\u03b1\u271d : Type w\ninst\u271d\u00b9 : HasFiniteCoproducts C\ninst\u271d : HasFilteredColimitsOfSize.{w, w, v, u} C\n\u03b1 : Type w\n\u22a2 HasColimitsOfShape (Discrete \u03b1) C",
148
+ "tactic": "exact \u27e8fun F => HasColimit.mk (liftToFinsetColimitCocone F)\u27e9"
149
+ }
150
+ ],
151
+ "url": "https://github.com/leanprover-community/mathlib4"
152
+ },
153
+ "source_file": "Mathlib/CategoryTheory/Limits/Constructions/Filtered.lean"
154
+ },
155
+ {
156
+ "error": "theorem has no selected tactic transitions",
157
+ "full_name": "CategoryTheory.Limits.hasProducts_of_finite_and_cofiltered",
158
+ "id": "CategoryTheory.Limits.hasProducts_of_finite_and_cofiltered",
159
+ "reason": "import_failure",
160
+ "selection": {
161
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
162
+ "end": [
163
+ 93,
164
+ 26
165
+ ],
166
+ "file_path": "Mathlib/CategoryTheory/Limits/Constructions/Filtered.lean",
167
+ "full_name": "CategoryTheory.Limits.hasProducts_of_finite_and_cofiltered",
168
+ "start": [
169
+ 90,
170
+ 1
171
+ ],
172
+ "traced_tactics": [],
173
+ "url": "https://github.com/leanprover-community/mathlib4"
174
+ },
175
+ "source_file": "Mathlib/CategoryTheory/Limits/Constructions/Filtered.lean"
176
+ },
177
+ {
178
+ "error": "theorem has no selected tactic transitions",
179
+ "full_name": "CategoryTheory.Limits.has_colimits_of_finite_and_filtered",
180
+ "id": "CategoryTheory.Limits.has_colimits_of_finite_and_filtered",
181
+ "reason": "import_failure",
182
+ "selection": {
183
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
184
+ "end": [
185
+ 87,
186
+ 49
187
+ ],
188
+ "file_path": "Mathlib/CategoryTheory/Limits/Constructions/Filtered.lean",
189
+ "full_name": "CategoryTheory.Limits.has_colimits_of_finite_and_filtered",
190
+ "start": [
191
+ 84,
192
+ 1
193
+ ],
194
+ "traced_tactics": [],
195
+ "url": "https://github.com/leanprover-community/mathlib4"
196
+ },
197
+ "source_file": "Mathlib/CategoryTheory/Limits/Constructions/Filtered.lean"
198
+ },
199
+ {
200
+ "error": "theorem has no selected tactic transitions",
201
+ "full_name": "CategoryTheory.Limits.has_limits_of_finite_and_cofiltered",
202
+ "id": "CategoryTheory.Limits.has_limits_of_finite_and_cofiltered",
203
+ "reason": "import_failure",
204
+ "selection": {
205
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
206
+ "end": [
207
+ 99,
208
+ 43
209
+ ],
210
+ "file_path": "Mathlib/CategoryTheory/Limits/Constructions/Filtered.lean",
211
+ "full_name": "CategoryTheory.Limits.has_limits_of_finite_and_cofiltered",
212
+ "start": [
213
+ 96,
214
+ 1
215
+ ],
216
+ "traced_tactics": [],
217
+ "url": "https://github.com/leanprover-community/mathlib4"
218
+ },
219
+ "source_file": "Mathlib/CategoryTheory/Limits/Constructions/Filtered.lean"
220
+ }
221
+ ],
222
+ "input_proofs": 8,
223
+ "input_units": 2,
224
+ "proofs": 0,
225
+ "published_proofs": 0,
226
+ "published_transitions": 0,
227
+ "replay_failures": [],
228
+ "transitions": 0,
229
+ "validation_failures": [],
230
+ "validation_rejected_proofs": 0,
231
+ "zero_transition_proofs": 0
232
+ },
233
+ "shards": [],
234
+ "proof_ids": [],
235
+ "proof_keys": []
236
+ }
manifests/batches/mathlib/000674.json ADDED
@@ -0,0 +1,140 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "format": "leangpt-parquet-v2",
3
+ "batch": "mathlib/000674",
4
+ "batch_fingerprint": "941798c1e78ae97520293f7dd7ea95e6871e8dcb64756f0beb762065befa8ad8",
5
+ "evidence": {
6
+ "batch_fingerprint": "941798c1e78ae97520293f7dd7ea95e6871e8dcb64756f0beb762065befa8ad8",
7
+ "contamination_matches": [],
8
+ "failures": [
9
+ {
10
+ "error": "theorem has no selected tactic transitions",
11
+ "full_name": "CategoryTheory.Over.ConstructProducts.over_binaryProduct_of_pullback",
12
+ "id": "CategoryTheory.Over.ConstructProducts.over_binaryProduct_of_pullback",
13
+ "reason": "import_failure",
14
+ "selection": {
15
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
16
+ "end": [
17
+ 145,
18
+ 31
19
+ ],
20
+ "file_path": "Mathlib/CategoryTheory/Limits/Constructions/Over/Products.lean",
21
+ "full_name": "CategoryTheory.Over.ConstructProducts.over_binaryProduct_of_pullback",
22
+ "start": [
23
+ 144,
24
+ 1
25
+ ],
26
+ "traced_tactics": [],
27
+ "url": "https://github.com/leanprover-community/mathlib4"
28
+ },
29
+ "source_file": "Mathlib/CategoryTheory/Limits/Constructions/Over/Products.lean"
30
+ },
31
+ {
32
+ "error": "theorem has no selected tactic transitions",
33
+ "full_name": "CategoryTheory.Over.ConstructProducts.over_finiteProducts_of_finiteWidePullbacks",
34
+ "id": "CategoryTheory.Over.ConstructProducts.over_finiteProducts_of_finiteWidePullbacks",
35
+ "reason": "import_failure",
36
+ "selection": {
37
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
38
+ "end": [
39
+ 157,
40
+ 42
41
+ ],
42
+ "file_path": "Mathlib/CategoryTheory/Limits/Constructions/Over/Products.lean",
43
+ "full_name": "CategoryTheory.Over.ConstructProducts.over_finiteProducts_of_finiteWidePullbacks",
44
+ "start": [
45
+ 155,
46
+ 1
47
+ ],
48
+ "traced_tactics": [],
49
+ "url": "https://github.com/leanprover-community/mathlib4"
50
+ },
51
+ "source_file": "Mathlib/CategoryTheory/Limits/Constructions/Over/Products.lean"
52
+ },
53
+ {
54
+ "error": "theorem has no selected tactic transitions",
55
+ "full_name": "CategoryTheory.Over.ConstructProducts.over_product_of_widePullback",
56
+ "id": "CategoryTheory.Over.ConstructProducts.over_product_of_widePullback",
57
+ "reason": "import_failure",
58
+ "selection": {
59
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
60
+ "end": [
61
+ 140,
62
+ 76
63
+ ],
64
+ "file_path": "Mathlib/CategoryTheory/Limits/Constructions/Over/Products.lean",
65
+ "full_name": "CategoryTheory.Over.ConstructProducts.over_product_of_widePullback",
66
+ "start": [
67
+ 138,
68
+ 1
69
+ ],
70
+ "traced_tactics": [],
71
+ "url": "https://github.com/leanprover-community/mathlib4"
72
+ },
73
+ "source_file": "Mathlib/CategoryTheory/Limits/Constructions/Over/Products.lean"
74
+ },
75
+ {
76
+ "error": "theorem has no selected tactic transitions",
77
+ "full_name": "CategoryTheory.Over.ConstructProducts.over_products_of_widePullbacks",
78
+ "id": "CategoryTheory.Over.ConstructProducts.over_products_of_widePullbacks",
79
+ "reason": "import_failure",
80
+ "selection": {
81
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
82
+ "end": [
83
+ 151,
84
+ 40
85
+ ],
86
+ "file_path": "Mathlib/CategoryTheory/Limits/Constructions/Over/Products.lean",
87
+ "full_name": "CategoryTheory.Over.ConstructProducts.over_products_of_widePullbacks",
88
+ "start": [
89
+ 149,
90
+ 1
91
+ ],
92
+ "traced_tactics": [],
93
+ "url": "https://github.com/leanprover-community/mathlib4"
94
+ },
95
+ "source_file": "Mathlib/CategoryTheory/Limits/Constructions/Over/Products.lean"
96
+ }
97
+ ],
98
+ "input_proofs": 6,
99
+ "input_units": 2,
100
+ "proofs": 2,
101
+ "published_proofs": 2,
102
+ "published_transitions": 7,
103
+ "replay_failures": [],
104
+ "transitions": 7,
105
+ "validation_failures": [],
106
+ "validation_rejected_proofs": 0,
107
+ "zero_transition_proofs": 0
108
+ },
109
+ "shards": [
110
+ {
111
+ "path": "data/train/mathlib-000674-0000-939bbb7bf9f71678.parquet",
112
+ "sha256": "939bbb7bf9f71678c0b9bc727822dc940c7c0276b7644f77e48353d84bc54903",
113
+ "bytes": 30930,
114
+ "rows": 1,
115
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
116
+ },
117
+ {
118
+ "path": "data/internal_test/mathlib-000674-0000-e1c5d20b1430e174.parquet",
119
+ "sha256": "e1c5d20b1430e1742b9a631871bc77502aaaa1a299cd50e9157c9216c6fcc61d",
120
+ "bytes": 308889,
121
+ "rows": 3,
122
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
123
+ },
124
+ {
125
+ "path": "data/internal_test/mathlib-000674-0001-602b8b6a6b48f07e.parquet",
126
+ "sha256": "602b8b6a6b48f07ebc00db5a1c602fcf2afe8c6ffb070e2557fe4ed64b41d761",
127
+ "bytes": 228330,
128
+ "rows": 3,
129
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
130
+ }
131
+ ],
132
+ "proof_ids": [
133
+ "mathlib:CategoryTheory.Over.CreatesConnected.raised_cone_lowers_to_original",
134
+ "mathlib:CategoryTheory.Over.over_hasTerminal"
135
+ ],
136
+ "proof_keys": [
137
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Constructions/Over/Connected.lean\",null,null,\"CategoryTheory.Over.CreatesConnected.raised_cone_lowers_to_original\"]",
138
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Constructions/Over/Products.lean\",null,null,\"CategoryTheory.Over.over_hasTerminal\"]"
139
+ ]
140
+ }
manifests/batches/mathlib/000675.json ADDED
@@ -0,0 +1,491 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "format": "leangpt-parquet-v2",
3
+ "batch": "mathlib/000675",
4
+ "batch_fingerprint": "f855738b8ad35cadeaf3b0569c7abad6fdf2fa034895d81f4a27393a8058fa9c",
5
+ "evidence": {
6
+ "batch_fingerprint": "f855738b8ad35cadeaf3b0569c7abad6fdf2fa034895d81f4a27393a8058fa9c",
7
+ "contamination_matches": [],
8
+ "failures": [
9
+ {
10
+ "error": "theorem has no selected tactic transitions",
11
+ "full_name": "CategoryTheory.Limits.hasPullbacks_of_hasBinaryProducts_of_hasEqualizers",
12
+ "id": "CategoryTheory.Limits.hasPullbacks_of_hasBinaryProducts_of_hasEqualizers",
13
+ "reason": "import_failure",
14
+ "selection": {
15
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
16
+ "end": [
17
+ 57,
18
+ 68
19
+ ],
20
+ "file_path": "Mathlib/CategoryTheory/Limits/Constructions/Pullbacks.lean",
21
+ "full_name": "CategoryTheory.Limits.hasPullbacks_of_hasBinaryProducts_of_hasEqualizers",
22
+ "start": [
23
+ 55,
24
+ 1
25
+ ],
26
+ "traced_tactics": [],
27
+ "url": "https://github.com/leanprover-community/mathlib4"
28
+ },
29
+ "source_file": "Mathlib/CategoryTheory/Limits/Constructions/Pullbacks.lean"
30
+ },
31
+ {
32
+ "error": "theorem has no selected tactic transitions",
33
+ "full_name": "CategoryTheory.Limits.hasPushouts_of_hasBinaryCoproducts_of_hasCoequalizers",
34
+ "id": "CategoryTheory.Limits.hasPushouts_of_hasBinaryCoproducts_of_hasCoequalizers",
35
+ "reason": "import_failure",
36
+ "selection": {
37
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
38
+ "end": [
39
+ 95,
40
+ 35
41
+ ],
42
+ "file_path": "Mathlib/CategoryTheory/Limits/Constructions/Pullbacks.lean",
43
+ "full_name": "CategoryTheory.Limits.hasPushouts_of_hasBinaryCoproducts_of_hasCoequalizers",
44
+ "start": [
45
+ 93,
46
+ 1
47
+ ],
48
+ "traced_tactics": [],
49
+ "url": "https://github.com/leanprover-community/mathlib4"
50
+ },
51
+ "source_file": "Mathlib/CategoryTheory/Limits/Constructions/Pullbacks.lean"
52
+ },
53
+ {
54
+ "error": "no internal trace for tactic 'intro X'",
55
+ "full_name": "CategoryTheory.hasInitial_of_weakly_initial_and_hasWideEqualizers",
56
+ "id": "CategoryTheory.hasInitial_of_weakly_initial_and_hasWideEqualizers",
57
+ "reason": "import_failure",
58
+ "selection": {
59
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
60
+ "end": [
61
+ 64,
62
+ 66
63
+ ],
64
+ "file_path": "Mathlib/CategoryTheory/Limits/Constructions/WeaklyInitial.lean",
65
+ "full_name": "CategoryTheory.hasInitial_of_weakly_initial_and_hasWideEqualizers",
66
+ "start": [
67
+ 46,
68
+ 1
69
+ ],
70
+ "traced_tactics": [
71
+ {
72
+ "annotated_tactic": [
73
+ "\"let endos := T \\u27f6 T\"",
74
+ "[]"
75
+ ],
76
+ "state_after": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\n\u22a2 HasInitial C",
77
+ "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\n\u22a2 HasInitial C",
78
+ "tactic": "let endos := T \u27f6 T"
79
+ },
80
+ {
81
+ "annotated_tactic": [
82
+ "\"let i := <a>wideEqualizer.\\u03b9<\\/a> (<a>id<\\/a> : endos \\u2192 endos)\"",
83
+ "[{\"full_name\":\"CategoryTheory.Limits.wideEqualizer.\\u03b9\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/WideEqualizers.lean\",\"def_pos\":[549,8],\"def_end_pos\":[549,23]},{\"full_name\":\"id\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[33,15],\"def_end_pos\":[33,17]}]"
84
+ ],
85
+ "state_after": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\ni : wideEqualizer id \u27f6 T := wideEqualizer.\u03b9 id\n\u22a2 HasInitial C",
86
+ "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\n\u22a2 HasInitial C",
87
+ "tactic": "let i := wideEqualizer.\u03b9 (id : endos \u2192 endos)"
88
+ },
89
+ {
90
+ "annotated_tactic": [
91
+ "\"haveI : <a>Nonempty<\\/a> endos := \\u27e8\\ud835\\udfd9 _\\u27e9\"",
92
+ "[{\"full_name\":\"Nonempty\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[709,17],\"def_end_pos\":[709,25]}]"
93
+ ],
94
+ "state_after": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\ni : wideEqualizer id \u27f6 T := wideEqualizer.\u03b9 id\nthis : Nonempty endos\n\u22a2 HasInitial C",
95
+ "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\ni : wideEqualizer id \u27f6 T := wideEqualizer.\u03b9 id\n\u22a2 HasInitial C",
96
+ "tactic": "haveI : Nonempty endos := \u27e8\ud835\udfd9 _\u27e9"
97
+ },
98
+ {
99
+ "annotated_tactic": [
100
+ "\"have : \\u2200 X : C, <a>Unique<\\/a> (<a>wideEqualizer<\\/a> (<a>id<\\/a> : endos \\u2192 endos) \\u27f6 X) := by\\n intro X\\n refine \\u27e8\\u27e8i \\u226b <a>Classical.choice<\\/a> (hT X)\\u27e9, fun a => ?_\\u27e9\\n let E := <a>equalizer<\\/a> a (i \\u226b <a>Classical.choice<\\/a> (hT _))\\n let e : E \\u27f6 <a>wideEqualizer<\\/a> <a>id<\\/a> := <a>equalizer.\\u03b9<\\/a> _ _\\n let h : T \\u27f6 E := <a>Classical.choice<\\/a> (hT E)\\n have : ((i \\u226b h) \\u226b e) \\u226b i = i \\u226b \\ud835\\udfd9 _ := by\\n rw [<a>Category.assoc<\\/a>, <a>Category.assoc<\\/a>]\\n apply <a>wideEqualizer.condition<\\/a> (<a>id<\\/a> : endos \\u2192 endos) (h \\u226b e \\u226b i)\\n rw [<a>Category.comp_id<\\/a>, <a>cancel_mono_id<\\/a> i] at this\\n haveI : <a>IsSplitEpi<\\/a> e := <a>IsSplitEpi.mk'<\\/a> \\u27e8i \\u226b h, this\\u27e9\\n rw [\\u2190 <a>cancel_epi<\\/a> e]\\n apply <a>equalizer.condition<\\/a>\"",
101
+ "[{\"full_name\":\"Unique\",\"def_path\":\"Mathlib\\/Logic\\/Unique.lean\",\"def_pos\":[52,11],\"def_end_pos\":[52,17]},{\"full_name\":\"CategoryTheory.Limits.wideEqualizer\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/WideEqualizers.lean\",\"def_pos\":[543,8],\"def_end_pos\":[543,21]},{\"full_name\":\"id\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[33,15],\"def_end_pos\":[33,17]},{\"full_name\":\"Classical.choice\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[735,7],\"def_end_pos\":[735,23]},{\"full_name\":\"CategoryTheory.Limits.equalizer\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/Equalizers.lean\",\"def_pos\":[770,22],\"def_end_pos\":[770,31]},{\"full_name\":\"Classical.choice\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[735,7],\"def_end_pos\":[735,23]},{\"full_name\":\"CategoryTheory.Limits.wideEqualizer\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/WideEqualizers.lean\",\"def_pos\":[543,8],\"def_end_pos\":[543,21]},{\"full_name\":\"id\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[33,15],\"def_end_pos\":[33,17]},{\"full_name\":\"CategoryTheory.Limits.equalizer.\\u03b9\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/Equalizers.lean\",\"def_pos\":[776,22],\"def_end_pos\":[776,33]},{\"full_name\":\"Classical.choice\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[735,7],\"def_end_pos\":[735,23]},{\"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]},{\"full_name\":\"CategoryTheory.Limits.wideEqualizer.condition\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/WideEqualizers.lean\",\"def_pos\":[571,9],\"def_end_pos\":[571,32]},{\"full_name\":\"id\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[33,15],\"def_end_pos\":[33,17]},{\"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.cancel_mono_id\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[320,9],\"def_end_pos\":[320,23]},{\"full_name\":\"CategoryTheory.IsSplitEpi\",\"def_path\":\"Mathlib\\/CategoryTheory\\/EpiMono.lean\",\"def_pos\":[89,7],\"def_end_pos\":[89,17]},{\"full_name\":\"CategoryTheory.IsSplitEpi.mk'\",\"def_path\":\"Mathlib\\/CategoryTheory\\/EpiMono.lean\",\"def_pos\":[96,9],\"def_end_pos\":[96,23]},{\"full_name\":\"CategoryTheory.cancel_epi\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[306,9],\"def_end_pos\":[306,19]},{\"full_name\":\"CategoryTheory.Limits.equalizer.condition\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/Equalizers.lean\",\"def_pos\":[796,9],\"def_end_pos\":[796,28]}]"
102
+ ],
103
+ "state_after": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\ni : wideEqualizer id \u27f6 T := wideEqualizer.\u03b9 id\nthis\u271d : Nonempty endos\nthis : (X : C) \u2192 Unique (wideEqualizer id \u27f6 X)\n\u22a2 HasInitial C",
104
+ "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\ni : wideEqualizer id \u27f6 T := wideEqualizer.\u03b9 id\nthis : Nonempty endos\n\u22a2 HasInitial C",
105
+ "tactic": "have : \u2200 X : C, Unique (wideEqualizer (id : endos \u2192 endos) \u27f6 X) := by\n intro X\n refine \u27e8\u27e8i \u226b Classical.choice (hT X)\u27e9, fun a => ?_\u27e9\n let E := equalizer a (i \u226b Classical.choice (hT _))\n let e : E \u27f6 wideEqualizer id := equalizer.\u03b9 _ _\n let h : T \u27f6 E := Classical.choice (hT E)\n have : ((i \u226b h) \u226b e) \u226b i = i \u226b \ud835\udfd9 _ := by\n rw [Category.assoc, Category.assoc]\n apply wideEqualizer.condition (id : endos \u2192 endos) (h \u226b e \u226b i)\n rw [Category.comp_id, cancel_mono_id i] at this\n haveI : IsSplitEpi e := IsSplitEpi.mk' \u27e8i \u226b h, this\u27e9\n rw [\u2190 cancel_epi e]\n apply equalizer.condition"
106
+ },
107
+ {
108
+ "annotated_tactic": [
109
+ "\"exact <a>hasInitial_of_unique<\\/a> (<a>wideEqualizer<\\/a> (<a>id<\\/a> : endos \\u2192 endos))\"",
110
+ "[{\"full_name\":\"CategoryTheory.Limits.hasInitial_of_unique\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/Terminal.lean\",\"def_pos\":[360,9],\"def_end_pos\":[360,29]},{\"full_name\":\"CategoryTheory.Limits.wideEqualizer\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/WideEqualizers.lean\",\"def_pos\":[543,8],\"def_end_pos\":[543,21]},{\"full_name\":\"id\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[33,15],\"def_end_pos\":[33,17]}]"
111
+ ],
112
+ "state_after": "no goals",
113
+ "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\ni : wideEqualizer id \u27f6 T := wideEqualizer.\u03b9 id\nthis\u271d : Nonempty endos\nthis : (X : C) \u2192 Unique (wideEqualizer id \u27f6 X)\n\u22a2 HasInitial C",
114
+ "tactic": "exact hasInitial_of_unique (wideEqualizer (id : endos \u2192 endos))"
115
+ },
116
+ {
117
+ "annotated_tactic": [
118
+ "\"intro X\"",
119
+ "[]"
120
+ ],
121
+ "state_after": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\ni : wideEqualizer id \u27f6 T := wideEqualizer.\u03b9 id\nthis : Nonempty endos\nX : C\n\u22a2 Unique (wideEqualizer id \u27f6 X)",
122
+ "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\ni : wideEqualizer id \u27f6 T := wideEqualizer.\u03b9 id\nthis : Nonempty endos\n\u22a2 (X : C) \u2192 Unique (wideEqualizer id \u27f6 X)",
123
+ "tactic": "intro X"
124
+ },
125
+ {
126
+ "annotated_tactic": [
127
+ "\"refine \\u27e8\\u27e8i \\u226b <a>Classical.choice<\\/a> (hT X)\\u27e9, fun a => ?_\\u27e9\"",
128
+ "[{\"full_name\":\"Classical.choice\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[735,7],\"def_end_pos\":[735,23]}]"
129
+ ],
130
+ "state_after": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\ni : wideEqualizer id \u27f6 T := wideEqualizer.\u03b9 id\nthis : Nonempty endos\nX : C\na : wideEqualizer id \u27f6 X\n\u22a2 a = default",
131
+ "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\ni : wideEqualizer id \u27f6 T := wideEqualizer.\u03b9 id\nthis : Nonempty endos\nX : C\n\u22a2 Unique (wideEqualizer id \u27f6 X)",
132
+ "tactic": "refine \u27e8\u27e8i \u226b Classical.choice (hT X)\u27e9, fun a => ?_\u27e9"
133
+ },
134
+ {
135
+ "annotated_tactic": [
136
+ "\"let E := <a>equalizer<\\/a> a (i \\u226b <a>Classical.choice<\\/a> (hT _))\"",
137
+ "[{\"full_name\":\"CategoryTheory.Limits.equalizer\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/Equalizers.lean\",\"def_pos\":[770,22],\"def_end_pos\":[770,31]},{\"full_name\":\"Classical.choice\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[735,7],\"def_end_pos\":[735,23]}]"
138
+ ],
139
+ "state_after": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\ni : wideEqualizer id \u27f6 T := wideEqualizer.\u03b9 id\nthis : Nonempty endos\nX : C\na : wideEqualizer id \u27f6 X\nE : C := equalizer a (i \u226b Classical.choice \u22ef)\n\u22a2 a = default",
140
+ "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\ni : wideEqualizer id \u27f6 T := wideEqualizer.\u03b9 id\nthis : Nonempty endos\nX : C\na : wideEqualizer id \u27f6 X\n\u22a2 a = default",
141
+ "tactic": "let E := equalizer a (i \u226b Classical.choice (hT _))"
142
+ },
143
+ {
144
+ "annotated_tactic": [
145
+ "\"let e : E \\u27f6 <a>wideEqualizer<\\/a> <a>id<\\/a> := <a>equalizer.\\u03b9<\\/a> _ _\"",
146
+ "[{\"full_name\":\"CategoryTheory.Limits.wideEqualizer\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/WideEqualizers.lean\",\"def_pos\":[543,8],\"def_end_pos\":[543,21]},{\"full_name\":\"id\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[33,15],\"def_end_pos\":[33,17]},{\"full_name\":\"CategoryTheory.Limits.equalizer.\\u03b9\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/Equalizers.lean\",\"def_pos\":[776,22],\"def_end_pos\":[776,33]}]"
147
+ ],
148
+ "state_after": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\ni : wideEqualizer id \u27f6 T := wideEqualizer.\u03b9 id\nthis : Nonempty endos\nX : C\na : wideEqualizer id \u27f6 X\nE : C := equalizer a (i \u226b Classical.choice \u22ef)\ne : E \u27f6 wideEqualizer id := equalizer.\u03b9 a (i \u226b Classical.choice \u22ef)\n\u22a2 a = default",
149
+ "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\ni : wideEqualizer id \u27f6 T := wideEqualizer.\u03b9 id\nthis : Nonempty endos\nX : C\na : wideEqualizer id \u27f6 X\nE : C := equalizer a (i \u226b Classical.choice \u22ef)\n\u22a2 a = default",
150
+ "tactic": "let e : E \u27f6 wideEqualizer id := equalizer.\u03b9 _ _"
151
+ },
152
+ {
153
+ "annotated_tactic": [
154
+ "\"let h : T \\u27f6 E := <a>Classical.choice<\\/a> (hT E)\"",
155
+ "[{\"full_name\":\"Classical.choice\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[735,7],\"def_end_pos\":[735,23]}]"
156
+ ],
157
+ "state_after": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\ni : wideEqualizer id \u27f6 T := wideEqualizer.\u03b9 id\nthis : Nonempty endos\nX : C\na : wideEqualizer id \u27f6 X\nE : C := equalizer a (i \u226b Classical.choice \u22ef)\ne : E \u27f6 wideEqualizer id := equalizer.\u03b9 a (i \u226b Classical.choice \u22ef)\nh : T \u27f6 E := Classical.choice \u22ef\n\u22a2 a = default",
158
+ "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\ni : wideEqualizer id \u27f6 T := wideEqualizer.\u03b9 id\nthis : Nonempty endos\nX : C\na : wideEqualizer id \u27f6 X\nE : C := equalizer a (i \u226b Classical.choice \u22ef)\ne : E \u27f6 wideEqualizer id := equalizer.\u03b9 a (i \u226b Classical.choice \u22ef)\n\u22a2 a = default",
159
+ "tactic": "let h : T \u27f6 E := Classical.choice (hT E)"
160
+ },
161
+ {
162
+ "annotated_tactic": [
163
+ "\"have : ((i \\u226b h) \\u226b e) \\u226b i = i \\u226b \\ud835\\udfd9 _ := by\\n rw [<a>Category.assoc<\\/a>, <a>Category.assoc<\\/a>]\\n apply <a>wideEqualizer.condition<\\/a> (<a>id<\\/a> : endos \\u2192 endos) (h \\u226b e \\u226b i)\"",
164
+ "[{\"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]},{\"full_name\":\"CategoryTheory.Limits.wideEqualizer.condition\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/WideEqualizers.lean\",\"def_pos\":[571,9],\"def_end_pos\":[571,32]},{\"full_name\":\"id\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[33,15],\"def_end_pos\":[33,17]}]"
165
+ ],
166
+ "state_after": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\ni : wideEqualizer id \u27f6 T := wideEqualizer.\u03b9 id\nthis\u271d : Nonempty endos\nX : C\na : wideEqualizer id \u27f6 X\nE : C := equalizer a (i \u226b Classical.choice \u22ef)\ne : E \u27f6 wideEqualizer id := equalizer.\u03b9 a (i \u226b Classical.choice \u22ef)\nh : T \u27f6 E := Classical.choice \u22ef\nthis : ((i \u226b h) \u226b e) \u226b i = i \u226b \ud835\udfd9 T\n\u22a2 a = default",
167
+ "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\ni : wideEqualizer id \u27f6 T := wideEqualizer.\u03b9 id\nthis : Nonempty endos\nX : C\na : wideEqualizer id \u27f6 X\nE : C := equalizer a (i \u226b Classical.choice \u22ef)\ne : E \u27f6 wideEqualizer id := equalizer.\u03b9 a (i \u226b Classical.choice \u22ef)\nh : T \u27f6 E := Classical.choice \u22ef\n\u22a2 a = default",
168
+ "tactic": "have : ((i \u226b h) \u226b e) \u226b i = i \u226b \ud835\udfd9 _ := by\n rw [Category.assoc, Category.assoc]\n apply wideEqualizer.condition (id : endos \u2192 endos) (h \u226b e \u226b i)"
169
+ },
170
+ {
171
+ "annotated_tactic": [
172
+ "\"rw [<a>Category.comp_id<\\/a>, <a>cancel_mono_id<\\/a> i] at this\"",
173
+ "[{\"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.cancel_mono_id\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[320,9],\"def_end_pos\":[320,23]}]"
174
+ ],
175
+ "state_after": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\ni : wideEqualizer id \u27f6 T := wideEqualizer.\u03b9 id\nthis\u271d : Nonempty endos\nX : C\na : wideEqualizer id \u27f6 X\nE : C := equalizer a (i \u226b Classical.choice \u22ef)\ne : E \u27f6 wideEqualizer id := equalizer.\u03b9 a (i \u226b Classical.choice \u22ef)\nh : T \u27f6 E := Classical.choice \u22ef\nthis : (i \u226b h) \u226b e = \ud835\udfd9 (wideEqualizer id)\n\u22a2 a = default",
176
+ "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\ni : wideEqualizer id \u27f6 T := wideEqualizer.\u03b9 id\nthis\u271d : Nonempty endos\nX : C\na : wideEqualizer id \u27f6 X\nE : C := equalizer a (i \u226b Classical.choice \u22ef)\ne : E \u27f6 wideEqualizer id := equalizer.\u03b9 a (i \u226b Classical.choice \u22ef)\nh : T \u27f6 E := Classical.choice \u22ef\nthis : ((i \u226b h) \u226b e) \u226b i = i \u226b \ud835\udfd9 T\n\u22a2 a = default",
177
+ "tactic": "rw [Category.comp_id, cancel_mono_id i] at this"
178
+ },
179
+ {
180
+ "annotated_tactic": [
181
+ "\"haveI : <a>IsSplitEpi<\\/a> e := <a>IsSplitEpi.mk'<\\/a> \\u27e8i \\u226b h, this\\u27e9\"",
182
+ "[{\"full_name\":\"CategoryTheory.IsSplitEpi\",\"def_path\":\"Mathlib\\/CategoryTheory\\/EpiMono.lean\",\"def_pos\":[89,7],\"def_end_pos\":[89,17]},{\"full_name\":\"CategoryTheory.IsSplitEpi.mk'\",\"def_path\":\"Mathlib\\/CategoryTheory\\/EpiMono.lean\",\"def_pos\":[96,9],\"def_end_pos\":[96,23]}]"
183
+ ],
184
+ "state_after": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\ni : wideEqualizer id \u27f6 T := wideEqualizer.\u03b9 id\nthis\u271d\u00b9 : Nonempty endos\nX : C\na : wideEqualizer id \u27f6 X\nE : C := equalizer a (i \u226b Classical.choice \u22ef)\ne : E \u27f6 wideEqualizer id := equalizer.\u03b9 a (i \u226b Classical.choice \u22ef)\nh : T \u27f6 E := Classical.choice \u22ef\nthis\u271d : (i \u226b h) \u226b e = \ud835\udfd9 (wideEqualizer id)\nthis : IsSplitEpi e\n\u22a2 a = default",
185
+ "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\ni : wideEqualizer id \u27f6 T := wideEqualizer.\u03b9 id\nthis\u271d : Nonempty endos\nX : C\na : wideEqualizer id \u27f6 X\nE : C := equalizer a (i \u226b Classical.choice \u22ef)\ne : E \u27f6 wideEqualizer id := equalizer.\u03b9 a (i \u226b Classical.choice \u22ef)\nh : T \u27f6 E := Classical.choice \u22ef\nthis : (i \u226b h) \u226b e = \ud835\udfd9 (wideEqualizer id)\n\u22a2 a = default",
186
+ "tactic": "haveI : IsSplitEpi e := IsSplitEpi.mk' \u27e8i \u226b h, this\u27e9"
187
+ },
188
+ {
189
+ "annotated_tactic": [
190
+ "\"rw [\\u2190 <a>cancel_epi<\\/a> e]\"",
191
+ "[{\"full_name\":\"CategoryTheory.cancel_epi\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[306,9],\"def_end_pos\":[306,19]}]"
192
+ ],
193
+ "state_after": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\ni : wideEqualizer id \u27f6 T := wideEqualizer.\u03b9 id\nthis\u271d\u00b9 : Nonempty endos\nX : C\na : wideEqualizer id \u27f6 X\nE : C := equalizer a (i \u226b Classical.choice \u22ef)\ne : E \u27f6 wideEqualizer id := equalizer.\u03b9 a (i \u226b Classical.choice \u22ef)\nh : T \u27f6 E := Classical.choice \u22ef\nthis\u271d : (i \u226b h) \u226b e = \ud835\udfd9 (wideEqualizer id)\nthis : IsSplitEpi e\n\u22a2 e \u226b a = e \u226b default",
194
+ "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\ni : wideEqualizer id \u27f6 T := wideEqualizer.\u03b9 id\nthis\u271d\u00b9 : Nonempty endos\nX : C\na : wideEqualizer id \u27f6 X\nE : C := equalizer a (i \u226b Classical.choice \u22ef)\ne : E \u27f6 wideEqualizer id := equalizer.\u03b9 a (i \u226b Classical.choice \u22ef)\nh : T \u27f6 E := Classical.choice \u22ef\nthis\u271d : (i \u226b h) \u226b e = \ud835\udfd9 (wideEqualizer id)\nthis : IsSplitEpi e\n\u22a2 a = default",
195
+ "tactic": "rw [\u2190 cancel_epi e]"
196
+ },
197
+ {
198
+ "annotated_tactic": [
199
+ "\"apply <a>equalizer.condition<\\/a>\"",
200
+ "[{\"full_name\":\"CategoryTheory.Limits.equalizer.condition\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/Equalizers.lean\",\"def_pos\":[796,9],\"def_end_pos\":[796,28]}]"
201
+ ],
202
+ "state_after": "no goals",
203
+ "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\ni : wideEqualizer id \u27f6 T := wideEqualizer.\u03b9 id\nthis\u271d\u00b9 : Nonempty endos\nX : C\na : wideEqualizer id \u27f6 X\nE : C := equalizer a (i \u226b Classical.choice \u22ef)\ne : E \u27f6 wideEqualizer id := equalizer.\u03b9 a (i \u226b Classical.choice \u22ef)\nh : T \u27f6 E := Classical.choice \u22ef\nthis\u271d : (i \u226b h) \u226b e = \ud835\udfd9 (wideEqualizer id)\nthis : IsSplitEpi e\n\u22a2 e \u226b a = e \u226b default",
204
+ "tactic": "apply equalizer.condition"
205
+ },
206
+ {
207
+ "annotated_tactic": [
208
+ "\"rw [<a>Category.assoc<\\/a>, <a>Category.assoc<\\/a>]\"",
209
+ "[{\"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]}]"
210
+ ],
211
+ "state_after": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\ni : wideEqualizer id \u27f6 T := wideEqualizer.\u03b9 id\nthis : Nonempty endos\nX : C\na : wideEqualizer id \u27f6 X\nE : C := equalizer a (i \u226b Classical.choice \u22ef)\ne : E \u27f6 wideEqualizer id := equalizer.\u03b9 a (i \u226b Classical.choice \u22ef)\nh : T \u27f6 E := Classical.choice \u22ef\n\u22a2 i \u226b h \u226b e \u226b i = i \u226b \ud835\udfd9 T",
212
+ "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\ni : wideEqualizer id \u27f6 T := wideEqualizer.\u03b9 id\nthis : Nonempty endos\nX : C\na : wideEqualizer id \u27f6 X\nE : C := equalizer a (i \u226b Classical.choice \u22ef)\ne : E \u27f6 wideEqualizer id := equalizer.\u03b9 a (i \u226b Classical.choice \u22ef)\nh : T \u27f6 E := Classical.choice \u22ef\n\u22a2 ((i \u226b h) \u226b e) \u226b i = i \u226b \ud835\udfd9 T",
213
+ "tactic": "rw [Category.assoc, Category.assoc]"
214
+ },
215
+ {
216
+ "annotated_tactic": [
217
+ "\"apply <a>wideEqualizer.condition<\\/a> (<a>id<\\/a> : endos \\u2192 endos) (h \\u226b e \\u226b i)\"",
218
+ "[{\"full_name\":\"CategoryTheory.Limits.wideEqualizer.condition\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/WideEqualizers.lean\",\"def_pos\":[571,9],\"def_end_pos\":[571,32]},{\"full_name\":\"id\",\"def_path\":\".lake\\/packages\\/lean4\\/src\\/lean\\/Init\\/Prelude.lean\",\"def_pos\":[33,15],\"def_end_pos\":[33,17]}]"
219
+ ],
220
+ "state_after": "no goals",
221
+ "state_before": "C : Type u\ninst\u271d\u00b9 : Category.{v, u} C\ninst\u271d : HasWideEqualizers C\nT : C\nhT : \u2200 (X : C), Nonempty (T \u27f6 X)\nendos : Type v := T \u27f6 T\ni : wideEqualizer id \u27f6 T := wideEqualizer.\u03b9 id\nthis : Nonempty endos\nX : C\na : wideEqualizer id \u27f6 X\nE : C := equalizer a (i \u226b Classical.choice \u22ef)\ne : E \u27f6 wideEqualizer id := equalizer.\u03b9 a (i \u226b Classical.choice \u22ef)\nh : T \u27f6 E := Classical.choice \u22ef\n\u22a2 i \u226b h \u226b e \u226b i = i \u226b \ud835\udfd9 T",
222
+ "tactic": "apply wideEqualizer.condition (id : endos \u2192 endos) (h \u226b e \u226b i)"
223
+ }
224
+ ],
225
+ "url": "https://github.com/leanprover-community/mathlib4"
226
+ },
227
+ "source_file": "Mathlib/CategoryTheory/Limits/Constructions/WeaklyInitial.lean"
228
+ },
229
+ {
230
+ "error": "theorem has no selected tactic transitions",
231
+ "full_name": "CategoryTheory.has_weakly_initial_of_weakly_initial_set_and_hasProducts",
232
+ "id": "CategoryTheory.has_weakly_initial_of_weakly_initial_set_and_hasProducts",
233
+ "reason": "import_failure",
234
+ "selection": {
235
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
236
+ "end": [
237
+ 38,
238
+ 56
239
+ ],
240
+ "file_path": "Mathlib/CategoryTheory/Limits/Constructions/WeaklyInitial.lean",
241
+ "full_name": "CategoryTheory.has_weakly_initial_of_weakly_initial_set_and_hasProducts",
242
+ "start": [
243
+ 36,
244
+ 1
245
+ ],
246
+ "traced_tactics": [],
247
+ "url": "https://github.com/leanprover-community/mathlib4"
248
+ },
249
+ "source_file": "Mathlib/CategoryTheory/Limits/Constructions/WeaklyInitial.lean"
250
+ }
251
+ ],
252
+ "input_proofs": 6,
253
+ "input_units": 2,
254
+ "proofs": 2,
255
+ "published_proofs": 0,
256
+ "published_transitions": 0,
257
+ "replay_failures": [],
258
+ "transitions": 18,
259
+ "validation_failures": [
260
+ {
261
+ "errors": [
262
+ "internal transition boundary mismatch",
263
+ "internal transition boundary mismatch",
264
+ "internal transition boundary mismatch",
265
+ "internal transition boundary mismatch",
266
+ "internal transition boundary mismatch",
267
+ "internal transition boundary mismatch"
268
+ ],
269
+ "file_path": "Mathlib/CategoryTheory/Limits/Constructions/Pullbacks.lean",
270
+ "proof_id": "mathlib:CategoryTheory.Limits.hasColimit_span_of_hasColimit_pair_of_hasColimit_parallelPair",
271
+ "provenance": {
272
+ "selection": {
273
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
274
+ "end": [
275
+ 83,
276
+ 29
277
+ ],
278
+ "file_path": "Mathlib/CategoryTheory/Limits/Constructions/Pullbacks.lean",
279
+ "full_name": "CategoryTheory.Limits.hasColimit_span_of_hasColimit_pair_of_hasColimit_parallelPair",
280
+ "start": [
281
+ 64,
282
+ 1
283
+ ],
284
+ "traced_tactics": [
285
+ {
286
+ "annotated_tactic": [
287
+ "\"rw [\\u2190 <a>Category.assoc<\\/a>, \\u2190 <a>Category.assoc<\\/a>, <a>coequalizer.condition<\\/a>]\"",
288
+ "[{\"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]},{\"full_name\":\"CategoryTheory.Limits.coequalizer.condition\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/Equalizers.lean\",\"def_pos\":[975,9],\"def_end_pos\":[975,30]}]"
289
+ ],
290
+ "state_after": "no goals",
291
+ "state_before": "C : Type u\n\ud835\udc9e : Category.{v, u} C\nX Y Z : C\nf : X \u27f6 Y\ng : X \u27f6 Z\ninst\u271d\u00b9 : HasColimit (pair Y Z)\ninst\u271d : HasColimit (parallelPair (f \u226b coprod.inl) (g \u226b coprod.inr))\n\u03b9\u2081 : Y \u27f6 Y \u2a3f Z := coprod.inl\n\u03b9\u2082 : Z \u27f6 Y \u2a3f Z := coprod.inr\nc : Y \u2a3f Z \u27f6 coequalizer (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082) := coequalizer.\u03c0 (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082)\n\u22a2 f \u226b \u03b9\u2081 \u226b c = g \u226b \u03b9\u2082 \u226b c",
292
+ "tactic": "rw [\u2190 Category.assoc, \u2190 Category.assoc, coequalizer.condition]"
293
+ },
294
+ {
295
+ "annotated_tactic": [
296
+ "\"rw [<a>Category.assoc<\\/a>, <a>colimit.\\u03b9_desc<\\/a>, <a>Category.assoc<\\/a>, <a>colimit.\\u03b9_desc<\\/a>]\"",
297
+ "[{\"full_name\":\"CategoryTheory.Category.assoc\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[181,3],\"def_end_pos\":[181,8]},{\"full_name\":\"CategoryTheory.Limits.colimit.\\u03b9_desc\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/HasLimits.lean\",\"def_pos\":[789,9],\"def_end_pos\":[789,23]},{\"full_name\":\"CategoryTheory.Category.assoc\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[181,3],\"def_end_pos\":[181,8]},{\"full_name\":\"CategoryTheory.Limits.colimit.\\u03b9_desc\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/HasLimits.lean\",\"def_pos\":[789,9],\"def_end_pos\":[789,23]}]"
298
+ ],
299
+ "state_after": "C : Type u\n\ud835\udc9e : Category.{v, u} C\nX Y Z : C\nf : X \u27f6 Y\ng : X \u27f6 Z\ninst\u271d\u00b9 : HasColimit (pair Y Z)\ninst\u271d : HasColimit (parallelPair (f \u226b coprod.inl) (g \u226b coprod.inr))\n\u03b9\u2081 : Y \u27f6 Y \u2a3f Z := coprod.inl\n\u03b9\u2082 : Z \u27f6 Y \u2a3f Z := coprod.inr\nc : Y \u2a3f Z \u27f6 coequalizer (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082) := coequalizer.\u03c0 (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082)\ns : PushoutCocone f g\n\u22a2 f \u226b (BinaryCofan.mk (s.\u03b9.app WalkingSpan.left) (s.\u03b9.app WalkingSpan.right)).\u03b9.app { as := WalkingPair.left } =\n g \u226b (BinaryCofan.mk (s.\u03b9.app WalkingSpan.left) (s.\u03b9.app WalkingSpan.right)).\u03b9.app { as := WalkingPair.right }",
300
+ "state_before": "C : Type u\n\ud835\udc9e : Category.{v, u} C\nX Y Z : C\nf : X \u27f6 Y\ng : X \u27f6 Z\ninst\u271d\u00b9 : HasColimit (pair Y Z)\ninst\u271d : HasColimit (parallelPair (f \u226b coprod.inl) (g \u226b coprod.inr))\n\u03b9\u2081 : Y \u27f6 Y \u2a3f Z := coprod.inl\n\u03b9\u2082 : Z \u27f6 Y \u2a3f Z := coprod.inr\nc : Y \u2a3f Z \u27f6 coequalizer (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082) := coequalizer.\u03c0 (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082)\ns : PushoutCocone f g\n\u22a2 (f \u226b \u03b9\u2081) \u226b coprod.desc (s.\u03b9.app WalkingSpan.left) (s.\u03b9.app WalkingSpan.right) =\n (g \u226b \u03b9\u2082) \u226b coprod.desc (s.\u03b9.app WalkingSpan.left) (s.\u03b9.app WalkingSpan.right)",
301
+ "tactic": "rw [Category.assoc, colimit.\u03b9_desc, Category.assoc, colimit.\u03b9_desc]"
302
+ },
303
+ {
304
+ "annotated_tactic": [
305
+ "\"exact <a>PushoutCocone.condition<\\/a> _\"",
306
+ "[{\"full_name\":\"CategoryTheory.Limits.PushoutCocone.condition\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/Pullbacks.lean\",\"def_pos\":[880,9],\"def_end_pos\":[880,18]}]"
307
+ ],
308
+ "state_after": "no goals",
309
+ "state_before": "C : Type u\n\ud835\udc9e : Category.{v, u} C\nX Y Z : C\nf : X \u27f6 Y\ng : X \u27f6 Z\ninst\u271d\u00b9 : HasColimit (pair Y Z)\ninst\u271d : HasColimit (parallelPair (f \u226b coprod.inl) (g \u226b coprod.inr))\n\u03b9\u2081 : Y \u27f6 Y \u2a3f Z := coprod.inl\n\u03b9\u2082 : Z \u27f6 Y \u2a3f Z := coprod.inr\nc : Y \u2a3f Z \u27f6 coequalizer (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082) := coequalizer.\u03c0 (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082)\ns : PushoutCocone f g\n\u22a2 f \u226b (BinaryCofan.mk (s.\u03b9.app WalkingSpan.left) (s.\u03b9.app WalkingSpan.right)).\u03b9.app { as := WalkingPair.left } =\n g \u226b (BinaryCofan.mk (s.\u03b9.app WalkingSpan.left) (s.\u03b9.app WalkingSpan.right)).\u03b9.app { as := WalkingPair.right }",
310
+ "tactic": "exact PushoutCocone.condition _"
311
+ },
312
+ {
313
+ "annotated_tactic": [
314
+ "\"simp [\\u03b9\\u2081, c]\"",
315
+ "[]"
316
+ ],
317
+ "state_after": "no goals",
318
+ "state_before": "C : Type u\n\ud835\udc9e : Category.{v, u} C\nX Y Z : C\nf : X \u27f6 Y\ng : X \u27f6 Z\ninst\u271d\u00b9 : HasColimit (pair Y Z)\ninst\u271d : HasColimit (parallelPair (f \u226b coprod.inl) (g \u226b coprod.inr))\n\u03b9\u2081 : Y \u27f6 Y \u2a3f Z := coprod.inl\n\u03b9\u2082 : Z \u27f6 Y \u2a3f Z := coprod.inr\nc : Y \u2a3f Z \u27f6 coequalizer (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082) := coequalizer.\u03c0 (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082)\n\u22a2 \u2200 (s : PushoutCocone f g),\n (\u03b9\u2081 \u226b c) \u226b (fun s => coequalizer.desc (coprod.desc (s.\u03b9.app WalkingSpan.left) (s.\u03b9.app WalkingSpan.right)) \u22ef) s =\n s.inl",
319
+ "tactic": "simp [\u03b9\u2081, c]"
320
+ },
321
+ {
322
+ "annotated_tactic": [
323
+ "\"simp [\\u03b9\\u2082, c]\"",
324
+ "[]"
325
+ ],
326
+ "state_after": "no goals",
327
+ "state_before": "C : Type u\n\ud835\udc9e : Category.{v, u} C\nX Y Z : C\nf : X \u27f6 Y\ng : X \u27f6 Z\ninst\u271d\u00b9 : HasColimit (pair Y Z)\ninst\u271d : HasColimit (parallelPair (f \u226b coprod.inl) (g \u226b coprod.inr))\n\u03b9\u2081 : Y \u27f6 Y \u2a3f Z := coprod.inl\n\u03b9\u2082 : Z \u27f6 Y \u2a3f Z := coprod.inr\nc : Y \u2a3f Z \u27f6 coequalizer (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082) := coequalizer.\u03c0 (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082)\n\u22a2 \u2200 (s : PushoutCocone f g),\n (\u03b9\u2082 \u226b c) \u226b (fun s => coequalizer.desc (coprod.desc (s.\u03b9.app WalkingSpan.left) (s.\u03b9.app WalkingSpan.right)) \u22ef) s =\n s.inr",
328
+ "tactic": "simp [\u03b9\u2082, c]"
329
+ },
330
+ {
331
+ "annotated_tactic": [
332
+ "\"ext\"",
333
+ "[]"
334
+ ],
335
+ "state_after": "case h.h\u2081\nC : Type u\n\ud835\udc9e : Category.{v, u} C\nX Y Z : C\nf : X \u27f6 Y\ng : X \u27f6 Z\ninst\u271d\u00b9 : HasColimit (pair Y Z)\ninst\u271d : HasColimit (parallelPair (f \u226b coprod.inl) (g \u226b coprod.inr))\n\u03b9\u2081 : Y \u27f6 Y \u2a3f Z := coprod.inl\n\u03b9\u2082 : Z \u27f6 Y \u2a3f Z := coprod.inr\nc : Y \u2a3f Z \u27f6 coequalizer (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082) := coequalizer.\u03c0 (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082)\ns : PushoutCocone f g\nm : coequalizer (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082) \u27f6 s.pt\nh\u2081 : (\u03b9\u2081 \u226b c) \u226b m = s.inl\nh\u2082 : (\u03b9\u2082 \u226b c) \u226b m = s.inr\n\u22a2 coprod.inl \u226b coequalizer.\u03c0 (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082) \u226b m =\n coprod.inl \u226b\n coequalizer.\u03c0 (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082) \u226b\n (fun s => coequalizer.desc (coprod.desc (s.\u03b9.app WalkingSpan.left) (s.\u03b9.app WalkingSpan.right)) \u22ef) s\n\ncase h.h\u2082\nC : Type u\n\ud835\udc9e : Category.{v, u} C\nX Y Z : C\nf : X \u27f6 Y\ng : X \u27f6 Z\ninst\u271d\u00b9 : HasColimit (pair Y Z)\ninst\u271d : HasColimit (parallelPair (f \u226b coprod.inl) (g \u226b coprod.inr))\n\u03b9\u2081 : Y \u27f6 Y \u2a3f Z := coprod.inl\n\u03b9\u2082 : Z \u27f6 Y \u2a3f Z := coprod.inr\nc : Y \u2a3f Z \u27f6 coequalizer (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082) := coequalizer.\u03c0 (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082)\ns : PushoutCocone f g\nm : coequalizer (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082) \u27f6 s.pt\nh\u2081 : (\u03b9\u2081 \u226b c) \u226b m = s.inl\nh\u2082 : (\u03b9\u2082 \u226b c) \u226b m = s.inr\n\u22a2 coprod.inr \u226b coequalizer.\u03c0 (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082) \u226b m =\n coprod.inr \u226b\n coequalizer.\u03c0 (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082) \u226b\n (fun s => coequalizer.desc (coprod.desc (s.\u03b9.app WalkingSpan.left) (s.\u03b9.app WalkingSpan.right)) \u22ef) s",
336
+ "state_before": "C : Type u\n\ud835\udc9e : Category.{v, u} C\nX Y Z : C\nf : X \u27f6 Y\ng : X \u27f6 Z\ninst\u271d\u00b9 : HasColimit (pair Y Z)\ninst\u271d : HasColimit (parallelPair (f \u226b coprod.inl) (g \u226b coprod.inr))\n\u03b9\u2081 : Y \u27f6 Y \u2a3f Z := coprod.inl\n\u03b9\u2082 : Z \u27f6 Y \u2a3f Z := coprod.inr\nc : Y \u2a3f Z \u27f6 coequalizer (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082) := coequalizer.\u03c0 (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082)\ns : PushoutCocone f g\nm : coequalizer (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082) \u27f6 s.pt\nh\u2081 : (\u03b9\u2081 \u226b c) \u226b m = s.inl\nh\u2082 : (\u03b9\u2082 \u226b c) \u226b m = s.inr\n\u22a2 m = (fun s => coequalizer.desc (coprod.desc (s.\u03b9.app WalkingSpan.left) (s.\u03b9.app WalkingSpan.right)) \u22ef) s",
337
+ "tactic": "ext"
338
+ },
339
+ {
340
+ "annotated_tactic": [
341
+ "\"simpa using h\\u2081\"",
342
+ "[]"
343
+ ],
344
+ "state_after": "no goals",
345
+ "state_before": "case h.h\u2081\nC : Type u\n\ud835\udc9e : Category.{v, u} C\nX Y Z : C\nf : X \u27f6 Y\ng : X \u27f6 Z\ninst\u271d\u00b9 : HasColimit (pair Y Z)\ninst\u271d : HasColimit (parallelPair (f \u226b coprod.inl) (g \u226b coprod.inr))\n\u03b9\u2081 : Y \u27f6 Y \u2a3f Z := coprod.inl\n\u03b9\u2082 : Z \u27f6 Y \u2a3f Z := coprod.inr\nc : Y \u2a3f Z \u27f6 coequalizer (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082) := coequalizer.\u03c0 (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082)\ns : PushoutCocone f g\nm : coequalizer (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082) \u27f6 s.pt\nh\u2081 : (\u03b9\u2081 \u226b c) \u226b m = s.inl\nh\u2082 : (\u03b9\u2082 \u226b c) \u226b m = s.inr\n\u22a2 coprod.inl \u226b coequalizer.\u03c0 (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082) \u226b m =\n coprod.inl \u226b\n coequalizer.\u03c0 (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082) \u226b\n (fun s => coequalizer.desc (coprod.desc (s.\u03b9.app WalkingSpan.left) (s.\u03b9.app WalkingSpan.right)) \u22ef) s",
346
+ "tactic": "simpa using h\u2081"
347
+ },
348
+ {
349
+ "annotated_tactic": [
350
+ "\"simpa using h\\u2082\"",
351
+ "[]"
352
+ ],
353
+ "state_after": "no goals",
354
+ "state_before": "case h.h\u2082\nC : Type u\n\ud835\udc9e : Category.{v, u} C\nX Y Z : C\nf : X \u27f6 Y\ng : X \u27f6 Z\ninst\u271d\u00b9 : HasColimit (pair Y Z)\ninst\u271d : HasColimit (parallelPair (f \u226b coprod.inl) (g \u226b coprod.inr))\n\u03b9\u2081 : Y \u27f6 Y \u2a3f Z := coprod.inl\n\u03b9\u2082 : Z \u27f6 Y \u2a3f Z := coprod.inr\nc : Y \u2a3f Z \u27f6 coequalizer (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082) := coequalizer.\u03c0 (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082)\ns : PushoutCocone f g\nm : coequalizer (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082) \u27f6 s.pt\nh\u2081 : (\u03b9\u2081 \u226b c) \u226b m = s.inl\nh\u2082 : (\u03b9\u2082 \u226b c) \u226b m = s.inr\n\u22a2 coprod.inr \u226b coequalizer.\u03c0 (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082) \u226b m =\n coprod.inr \u226b\n coequalizer.\u03c0 (f \u226b \u03b9\u2081) (g \u226b \u03b9\u2082) \u226b\n (fun s => coequalizer.desc (coprod.desc (s.\u03b9.app WalkingSpan.left) (s.\u03b9.app WalkingSpan.right)) \u22ef) s",
355
+ "tactic": "simpa using h\u2082"
356
+ }
357
+ ],
358
+ "url": "https://github.com/leanprover-community/mathlib4"
359
+ }
360
+ },
361
+ "theorem_name": "CategoryTheory.Limits.hasColimit_span_of_hasColimit_pair_of_hasColimit_parallelPair"
362
+ },
363
+ {
364
+ "errors": [
365
+ "internal transition boundary mismatch",
366
+ "internal transition boundary mismatch",
367
+ "internal transition boundary mismatch",
368
+ "internal transition boundary mismatch",
369
+ "internal transition boundary mismatch",
370
+ "internal transition boundary mismatch"
371
+ ],
372
+ "file_path": "Mathlib/CategoryTheory/Limits/Constructions/Pullbacks.lean",
373
+ "proof_id": "mathlib:CategoryTheory.Limits.hasLimit_cospan_of_hasLimit_pair_of_hasLimit_parallelPair",
374
+ "provenance": {
375
+ "selection": {
376
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
377
+ "end": [
378
+ 45,
379
+ 29
380
+ ],
381
+ "file_path": "Mathlib/CategoryTheory/Limits/Constructions/Pullbacks.lean",
382
+ "full_name": "CategoryTheory.Limits.hasLimit_cospan_of_hasLimit_pair_of_hasLimit_parallelPair",
383
+ "start": [
384
+ 28,
385
+ 1
386
+ ],
387
+ "traced_tactics": [
388
+ {
389
+ "annotated_tactic": [
390
+ "\"rw [<a>Category.assoc<\\/a>, <a>equalizer.condition<\\/a>]\"",
391
+ "[{\"full_name\":\"CategoryTheory.Category.assoc\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[181,3],\"def_end_pos\":[181,8]},{\"full_name\":\"CategoryTheory.Limits.equalizer.condition\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/Equalizers.lean\",\"def_pos\":[796,9],\"def_end_pos\":[796,28]}]"
392
+ ],
393
+ "state_after": "C : Type u\n\ud835\udc9e : Category.{v, u} C\nX Y Z : C\nf : X \u27f6 Z\ng : Y \u27f6 Z\ninst\u271d\u00b9 : HasLimit (pair X Y)\ninst\u271d : HasLimit (parallelPair (prod.fst \u226b f) (prod.snd \u226b g))\n\u03c0\u2081 : X \u2a2f Y \u27f6 X := prod.fst\n\u03c0\u2082 : X \u2a2f Y \u27f6 Y := prod.snd\ne : equalizer (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g) \u27f6 X \u2a2f Y := equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)\n\u22a2 equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g) \u226b \u03c0\u2082 \u226b g = (e \u226b \u03c0\u2082) \u226b g",
394
+ "state_before": "C : Type u\n\ud835\udc9e : Category.{v, u} C\nX Y Z : C\nf : X \u27f6 Z\ng : Y \u27f6 Z\ninst\u271d\u00b9 : HasLimit (pair X Y)\ninst\u271d : HasLimit (parallelPair (prod.fst \u226b f) (prod.snd \u226b g))\n\u03c0\u2081 : X \u2a2f Y \u27f6 X := prod.fst\n\u03c0\u2082 : X \u2a2f Y \u27f6 Y := prod.snd\ne : equalizer (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g) \u27f6 X \u2a2f Y := equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)\n\u22a2 (e \u226b \u03c0\u2081) \u226b f = (e \u226b \u03c0\u2082) \u226b g",
395
+ "tactic": "rw [Category.assoc, equalizer.condition]"
396
+ },
397
+ {
398
+ "annotated_tactic": [
399
+ "\"simp\"",
400
+ "[]"
401
+ ],
402
+ "state_after": "no goals",
403
+ "state_before": "C : Type u\n\ud835\udc9e : Category.{v, u} C\nX Y Z : C\nf : X \u27f6 Z\ng : Y \u27f6 Z\ninst\u271d\u00b9 : HasLimit (pair X Y)\ninst\u271d : HasLimit (parallelPair (prod.fst \u226b f) (prod.snd \u226b g))\n\u03c0\u2081 : X \u2a2f Y \u27f6 X := prod.fst\n\u03c0\u2082 : X \u2a2f Y \u27f6 Y := prod.snd\ne : equalizer (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g) \u27f6 X \u2a2f Y := equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)\n\u22a2 equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g) \u226b \u03c0\u2082 \u226b g = (e \u226b \u03c0\u2082) \u226b g",
404
+ "tactic": "simp"
405
+ },
406
+ {
407
+ "annotated_tactic": [
408
+ "\"rw [\\u2190 <a>Category.assoc<\\/a>, <a>limit.lift_\\u03c0<\\/a>, \\u2190 <a>Category.assoc<\\/a>, <a>limit.lift_\\u03c0<\\/a>]\"",
409
+ "[{\"full_name\":\"CategoryTheory.Category.assoc\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[181,3],\"def_end_pos\":[181,8]},{\"full_name\":\"CategoryTheory.Limits.limit.lift_\\u03c0\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/HasLimits.lean\",\"def_pos\":[192,9],\"def_end_pos\":[192,21]},{\"full_name\":\"CategoryTheory.Category.assoc\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Category\\/Basic.lean\",\"def_pos\":[181,3],\"def_end_pos\":[181,8]},{\"full_name\":\"CategoryTheory.Limits.limit.lift_\\u03c0\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/HasLimits.lean\",\"def_pos\":[192,9],\"def_end_pos\":[192,21]}]"
410
+ ],
411
+ "state_after": "C : Type u\n\ud835\udc9e : Category.{v, u} C\nX Y Z : C\nf : X \u27f6 Z\ng : Y \u27f6 Z\ninst\u271d\u00b9 : HasLimit (pair X Y)\ninst\u271d : HasLimit (parallelPair (prod.fst \u226b f) (prod.snd \u226b g))\n\u03c0\u2081 : X \u2a2f Y \u27f6 X := prod.fst\n\u03c0\u2082 : X \u2a2f Y \u27f6 Y := prod.snd\ne : equalizer (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g) \u27f6 X \u2a2f Y := equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)\ns : PullbackCone f g\n\u22a2 (BinaryFan.mk (s.\u03c0.app WalkingCospan.left) (s.\u03c0.app WalkingCospan.right)).\u03c0.app { as := WalkingPair.left } \u226b f =\n (BinaryFan.mk (s.\u03c0.app WalkingCospan.left) (s.\u03c0.app WalkingCospan.right)).\u03c0.app { as := WalkingPair.right } \u226b g",
412
+ "state_before": "C : Type u\n\ud835\udc9e : Category.{v, u} C\nX Y Z : C\nf : X \u27f6 Z\ng : Y \u27f6 Z\ninst\u271d\u00b9 : HasLimit (pair X Y)\ninst\u271d : HasLimit (parallelPair (prod.fst \u226b f) (prod.snd \u226b g))\n\u03c0\u2081 : X \u2a2f Y \u27f6 X := prod.fst\n\u03c0\u2082 : X \u2a2f Y \u27f6 Y := prod.snd\ne : equalizer (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g) \u27f6 X \u2a2f Y := equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)\ns : PullbackCone f g\n\u22a2 prod.lift (s.\u03c0.app WalkingCospan.left) (s.\u03c0.app WalkingCospan.right) \u226b \u03c0\u2081 \u226b f =\n prod.lift (s.\u03c0.app WalkingCospan.left) (s.\u03c0.app WalkingCospan.right) \u226b \u03c0\u2082 \u226b g",
413
+ "tactic": "rw [\u2190 Category.assoc, limit.lift_\u03c0, \u2190 Category.assoc, limit.lift_\u03c0]"
414
+ },
415
+ {
416
+ "annotated_tactic": [
417
+ "\"exact <a>PullbackCone.condition<\\/a> _\"",
418
+ "[{\"full_name\":\"CategoryTheory.Limits.PullbackCone.condition\",\"def_path\":\"Mathlib\\/CategoryTheory\\/Limits\\/Shapes\\/Pullbacks.lean\",\"def_pos\":[609,9],\"def_end_pos\":[609,18]}]"
419
+ ],
420
+ "state_after": "no goals",
421
+ "state_before": "C : Type u\n\ud835\udc9e : Category.{v, u} C\nX Y Z : C\nf : X \u27f6 Z\ng : Y \u27f6 Z\ninst\u271d\u00b9 : HasLimit (pair X Y)\ninst\u271d : HasLimit (parallelPair (prod.fst \u226b f) (prod.snd \u226b g))\n\u03c0\u2081 : X \u2a2f Y \u27f6 X := prod.fst\n\u03c0\u2082 : X \u2a2f Y \u27f6 Y := prod.snd\ne : equalizer (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g) \u27f6 X \u2a2f Y := equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)\ns : PullbackCone f g\n\u22a2 (BinaryFan.mk (s.\u03c0.app WalkingCospan.left) (s.\u03c0.app WalkingCospan.right)).\u03c0.app { as := WalkingPair.left } \u226b f =\n (BinaryFan.mk (s.\u03c0.app WalkingCospan.left) (s.\u03c0.app WalkingCospan.right)).\u03c0.app { as := WalkingPair.right } \u226b g",
422
+ "tactic": "exact PullbackCone.condition _"
423
+ },
424
+ {
425
+ "annotated_tactic": [
426
+ "\"simp [\\u03c0\\u2081, e]\"",
427
+ "[]"
428
+ ],
429
+ "state_after": "no goals",
430
+ "state_before": "C : Type u\n\ud835\udc9e : Category.{v, u} C\nX Y Z : C\nf : X \u27f6 Z\ng : Y \u27f6 Z\ninst\u271d\u00b9 : HasLimit (pair X Y)\ninst\u271d : HasLimit (parallelPair (prod.fst \u226b f) (prod.snd \u226b g))\n\u03c0\u2081 : X \u2a2f Y \u27f6 X := prod.fst\n\u03c0\u2082 : X \u2a2f Y \u27f6 Y := prod.snd\ne : equalizer (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g) \u27f6 X \u2a2f Y := equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)\n\u22a2 \u2200 (s : PullbackCone f g),\n (fun s => equalizer.lift (prod.lift (s.\u03c0.app WalkingCospan.left) (s.\u03c0.app WalkingCospan.right)) \u22ef) s \u226b e \u226b \u03c0\u2081 =\n s.fst",
431
+ "tactic": "simp [\u03c0\u2081, e]"
432
+ },
433
+ {
434
+ "annotated_tactic": [
435
+ "\"simp [\\u03c0\\u2082, e]\"",
436
+ "[]"
437
+ ],
438
+ "state_after": "no goals",
439
+ "state_before": "C : Type u\n\ud835\udc9e : Category.{v, u} C\nX Y Z : C\nf : X \u27f6 Z\ng : Y \u27f6 Z\ninst\u271d\u00b9 : HasLimit (pair X Y)\ninst\u271d : HasLimit (parallelPair (prod.fst \u226b f) (prod.snd \u226b g))\n\u03c0\u2081 : X \u2a2f Y \u27f6 X := prod.fst\n\u03c0\u2082 : X \u2a2f Y \u27f6 Y := prod.snd\ne : equalizer (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g) \u27f6 X \u2a2f Y := equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)\n\u22a2 \u2200 (s : PullbackCone f g),\n (fun s => equalizer.lift (prod.lift (s.\u03c0.app WalkingCospan.left) (s.\u03c0.app WalkingCospan.right)) \u22ef) s \u226b e \u226b \u03c0\u2082 =\n s.snd",
440
+ "tactic": "simp [\u03c0\u2082, e]"
441
+ },
442
+ {
443
+ "annotated_tactic": [
444
+ "\"ext\"",
445
+ "[]"
446
+ ],
447
+ "state_after": "case h.h\u2081\nC : Type u\n\ud835\udc9e : Category.{v, u} C\nX Y Z : C\nf : X \u27f6 Z\ng : Y \u27f6 Z\ninst\u271d\u00b9 : HasLimit (pair X Y)\ninst\u271d : HasLimit (parallelPair (prod.fst \u226b f) (prod.snd \u226b g))\n\u03c0\u2081 : X \u2a2f Y \u27f6 X := prod.fst\n\u03c0\u2082 : X \u2a2f Y \u27f6 Y := prod.snd\ne : equalizer (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g) \u27f6 X \u2a2f Y := equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)\ns : PullbackCone f g\nm : s.pt \u27f6 equalizer (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)\nh\u2081 : m \u226b e \u226b \u03c0\u2081 = s.fst\nh\u2082 : m \u226b e \u226b \u03c0\u2082 = s.snd\n\u22a2 (m \u226b equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)) \u226b prod.fst =\n ((fun s => equalizer.lift (prod.lift (s.\u03c0.app WalkingCospan.left) (s.\u03c0.app WalkingCospan.right)) \u22ef) s \u226b\n equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)) \u226b\n prod.fst\n\ncase h.h\u2082\nC : Type u\n\ud835\udc9e : Category.{v, u} C\nX Y Z : C\nf : X \u27f6 Z\ng : Y \u27f6 Z\ninst\u271d\u00b9 : HasLimit (pair X Y)\ninst\u271d : HasLimit (parallelPair (prod.fst \u226b f) (prod.snd \u226b g))\n\u03c0\u2081 : X \u2a2f Y \u27f6 X := prod.fst\n\u03c0\u2082 : X \u2a2f Y \u27f6 Y := prod.snd\ne : equalizer (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g) \u27f6 X \u2a2f Y := equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)\ns : PullbackCone f g\nm : s.pt \u27f6 equalizer (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)\nh\u2081 : m \u226b e \u226b \u03c0\u2081 = s.fst\nh\u2082 : m \u226b e \u226b \u03c0\u2082 = s.snd\n\u22a2 (m \u226b equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)) \u226b prod.snd =\n ((fun s => equalizer.lift (prod.lift (s.\u03c0.app WalkingCospan.left) (s.\u03c0.app WalkingCospan.right)) \u22ef) s \u226b\n equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)) \u226b\n prod.snd",
448
+ "state_before": "C : Type u\n\ud835\udc9e : Category.{v, u} C\nX Y Z : C\nf : X \u27f6 Z\ng : Y \u27f6 Z\ninst\u271d\u00b9 : HasLimit (pair X Y)\ninst\u271d : HasLimit (parallelPair (prod.fst \u226b f) (prod.snd \u226b g))\n\u03c0\u2081 : X \u2a2f Y \u27f6 X := prod.fst\n\u03c0\u2082 : X \u2a2f Y \u27f6 Y := prod.snd\ne : equalizer (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g) \u27f6 X \u2a2f Y := equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)\ns : PullbackCone f g\nm : s.pt \u27f6 equalizer (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)\nh\u2081 : m \u226b e \u226b \u03c0\u2081 = s.fst\nh\u2082 : m \u226b e \u226b \u03c0\u2082 = s.snd\n\u22a2 m = (fun s => equalizer.lift (prod.lift (s.\u03c0.app WalkingCospan.left) (s.\u03c0.app WalkingCospan.right)) \u22ef) s",
449
+ "tactic": "ext"
450
+ },
451
+ {
452
+ "annotated_tactic": [
453
+ "\"dsimp\"",
454
+ "[]"
455
+ ],
456
+ "state_after": "case h.h\u2081\nC : Type u\n\ud835\udc9e : Category.{v, u} C\nX Y Z : C\nf : X \u27f6 Z\ng : Y \u27f6 Z\ninst\u271d\u00b9 : HasLimit (pair X Y)\ninst\u271d : HasLimit (parallelPair (prod.fst \u226b f) (prod.snd \u226b g))\n\u03c0\u2081 : X \u2a2f Y \u27f6 X := prod.fst\n\u03c0\u2082 : X \u2a2f Y \u27f6 Y := prod.snd\ne : equalizer (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g) \u27f6 X \u2a2f Y := equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)\ns : PullbackCone f g\nm : s.pt \u27f6 equalizer (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)\nh\u2081 : m \u226b e \u226b \u03c0\u2081 = s.fst\nh\u2082 : m \u226b e \u226b \u03c0\u2082 = s.snd\n\u22a2 (m \u226b equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)) \u226b prod.fst =\n (equalizer.lift (prod.lift s.fst s.snd) \u22ef \u226b equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)) \u226b prod.fst",
457
+ "state_before": "case h.h\u2081\nC : Type u\n\ud835\udc9e : Category.{v, u} C\nX Y Z : C\nf : X \u27f6 Z\ng : Y \u27f6 Z\ninst\u271d\u00b9 : HasLimit (pair X Y)\ninst\u271d : HasLimit (parallelPair (prod.fst \u226b f) (prod.snd \u226b g))\n\u03c0\u2081 : X \u2a2f Y \u27f6 X := prod.fst\n\u03c0\u2082 : X \u2a2f Y \u27f6 Y := prod.snd\ne : equalizer (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g) \u27f6 X \u2a2f Y := equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)\ns : PullbackCone f g\nm : s.pt \u27f6 equalizer (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)\nh\u2081 : m \u226b e \u226b \u03c0\u2081 = s.fst\nh\u2082 : m \u226b e \u226b \u03c0\u2082 = s.snd\n\u22a2 (m \u226b equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)) \u226b prod.fst =\n ((fun s => equalizer.lift (prod.lift (s.\u03c0.app WalkingCospan.left) (s.\u03c0.app WalkingCospan.right)) \u22ef) s \u226b\n equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)) \u226b\n prod.fst",
458
+ "tactic": "dsimp"
459
+ },
460
+ {
461
+ "annotated_tactic": [
462
+ "\"simpa using h\\u2081\"",
463
+ "[]"
464
+ ],
465
+ "state_after": "no goals",
466
+ "state_before": "case h.h\u2081\nC : Type u\n\ud835\udc9e : Category.{v, u} C\nX Y Z : C\nf : X \u27f6 Z\ng : Y \u27f6 Z\ninst\u271d\u00b9 : HasLimit (pair X Y)\ninst\u271d : HasLimit (parallelPair (prod.fst \u226b f) (prod.snd \u226b g))\n\u03c0\u2081 : X \u2a2f Y \u27f6 X := prod.fst\n\u03c0\u2082 : X \u2a2f Y \u27f6 Y := prod.snd\ne : equalizer (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g) \u27f6 X \u2a2f Y := equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)\ns : PullbackCone f g\nm : s.pt \u27f6 equalizer (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)\nh\u2081 : m \u226b e \u226b \u03c0\u2081 = s.fst\nh\u2082 : m \u226b e \u226b \u03c0\u2082 = s.snd\n\u22a2 (m \u226b equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)) \u226b prod.fst =\n (equalizer.lift (prod.lift s.fst s.snd) \u22ef \u226b equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)) \u226b prod.fst",
467
+ "tactic": "simpa using h\u2081"
468
+ },
469
+ {
470
+ "annotated_tactic": [
471
+ "\"simpa using h\\u2082\"",
472
+ "[]"
473
+ ],
474
+ "state_after": "no goals",
475
+ "state_before": "case h.h\u2082\nC : Type u\n\ud835\udc9e : Category.{v, u} C\nX Y Z : C\nf : X \u27f6 Z\ng : Y \u27f6 Z\ninst\u271d\u00b9 : HasLimit (pair X Y)\ninst\u271d : HasLimit (parallelPair (prod.fst \u226b f) (prod.snd \u226b g))\n\u03c0\u2081 : X \u2a2f Y \u27f6 X := prod.fst\n\u03c0\u2082 : X \u2a2f Y \u27f6 Y := prod.snd\ne : equalizer (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g) \u27f6 X \u2a2f Y := equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)\ns : PullbackCone f g\nm : s.pt \u27f6 equalizer (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)\nh\u2081 : m \u226b e \u226b \u03c0\u2081 = s.fst\nh\u2082 : m \u226b e \u226b \u03c0\u2082 = s.snd\n\u22a2 (m \u226b equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)) \u226b prod.snd =\n ((fun s => equalizer.lift (prod.lift (s.\u03c0.app WalkingCospan.left) (s.\u03c0.app WalkingCospan.right)) \u22ef) s \u226b\n equalizer.\u03b9 (\u03c0\u2081 \u226b f) (\u03c0\u2082 \u226b g)) \u226b\n prod.snd",
476
+ "tactic": "simpa using h\u2082"
477
+ }
478
+ ],
479
+ "url": "https://github.com/leanprover-community/mathlib4"
480
+ }
481
+ },
482
+ "theorem_name": "CategoryTheory.Limits.hasLimit_cospan_of_hasLimit_pair_of_hasLimit_parallelPair"
483
+ }
484
+ ],
485
+ "validation_rejected_proofs": 2,
486
+ "zero_transition_proofs": 0
487
+ },
488
+ "shards": [],
489
+ "proof_ids": [],
490
+ "proof_keys": []
491
+ }
manifests/batches/mathlib/000676.json ADDED
@@ -0,0 +1,263 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "format": "leangpt-parquet-v2",
3
+ "batch": "mathlib/000676",
4
+ "batch_fingerprint": "33f3123534d3d23d29e9d16c3c06adb667313e299d04fd6bdd6a8527f4815a48",
5
+ "evidence": {
6
+ "batch_fingerprint": "33f3123534d3d23d29e9d16c3c06adb667313e299d04fd6bdd6a8527f4815a48",
7
+ "contamination_matches": [],
8
+ "failures": [
9
+ {
10
+ "error": "theorem has no selected tactic transitions",
11
+ "full_name": "CategoryTheory.Limits.coprodZeroIso_inv",
12
+ "id": "CategoryTheory.Limits.coprodZeroIso_inv",
13
+ "reason": "import_failure",
14
+ "selection": {
15
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
16
+ "end": [
17
+ 153,
18
+ 6
19
+ ],
20
+ "file_path": "Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean",
21
+ "full_name": "CategoryTheory.Limits.coprodZeroIso_inv",
22
+ "start": [
23
+ 152,
24
+ 1
25
+ ],
26
+ "traced_tactics": [],
27
+ "url": "https://github.com/leanprover-community/mathlib4"
28
+ },
29
+ "source_file": "Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean"
30
+ },
31
+ {
32
+ "error": "theorem has no selected tactic transitions",
33
+ "full_name": "CategoryTheory.Limits.zeroCoprodIso_inv",
34
+ "id": "CategoryTheory.Limits.zeroCoprodIso_inv",
35
+ "reason": "import_failure",
36
+ "selection": {
37
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
38
+ "end": [
39
+ 122,
40
+ 6
41
+ ],
42
+ "file_path": "Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean",
43
+ "full_name": "CategoryTheory.Limits.zeroCoprodIso_inv",
44
+ "start": [
45
+ 121,
46
+ 1
47
+ ],
48
+ "traced_tactics": [],
49
+ "url": "https://github.com/leanprover-community/mathlib4"
50
+ },
51
+ "source_file": "Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean"
52
+ },
53
+ {
54
+ "error": "theorem has no selected tactic transitions",
55
+ "full_name": "CategoryTheory.Limits.zeroProdIso_hom",
56
+ "id": "CategoryTheory.Limits.zeroProdIso_hom",
57
+ "reason": "import_failure",
58
+ "selection": {
59
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
60
+ "end": [
61
+ 54,
62
+ 6
63
+ ],
64
+ "file_path": "Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean",
65
+ "full_name": "CategoryTheory.Limits.zeroProdIso_hom",
66
+ "start": [
67
+ 53,
68
+ 1
69
+ ],
70
+ "traced_tactics": [],
71
+ "url": "https://github.com/leanprover-community/mathlib4"
72
+ },
73
+ "source_file": "Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean"
74
+ },
75
+ {
76
+ "error": "theorem has no selected tactic transitions",
77
+ "full_name": "CategoryTheory.hasColimit_of_created",
78
+ "id": "CategoryTheory.hasColimit_of_created",
79
+ "reason": "import_failure",
80
+ "selection": {
81
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
82
+ "end": [
83
+ 200,
84
+ 46
85
+ ],
86
+ "file_path": "Mathlib/CategoryTheory/Limits/Creates.lean",
87
+ "full_name": "CategoryTheory.hasColimit_of_created",
88
+ "start": [
89
+ 196,
90
+ 1
91
+ ],
92
+ "traced_tactics": [],
93
+ "url": "https://github.com/leanprover-community/mathlib4"
94
+ },
95
+ "source_file": "Mathlib/CategoryTheory/Limits/Creates.lean"
96
+ },
97
+ {
98
+ "error": "theorem has no selected tactic transitions",
99
+ "full_name": "CategoryTheory.hasColimitsOfShape_of_hasColimitsOfShape_createsColimitsOfShape",
100
+ "id": "CategoryTheory.hasColimitsOfShape_of_hasColimitsOfShape_createsColimitsOfShape",
101
+ "reason": "import_failure",
102
+ "selection": {
103
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
104
+ "end": [
105
+ 208,
106
+ 39
107
+ ],
108
+ "file_path": "Mathlib/CategoryTheory/Limits/Creates.lean",
109
+ "full_name": "CategoryTheory.hasColimitsOfShape_of_hasColimitsOfShape_createsColimitsOfShape",
110
+ "start": [
111
+ 206,
112
+ 1
113
+ ],
114
+ "traced_tactics": [],
115
+ "url": "https://github.com/leanprover-community/mathlib4"
116
+ },
117
+ "source_file": "Mathlib/CategoryTheory/Limits/Creates.lean"
118
+ },
119
+ {
120
+ "error": "theorem has no selected tactic transitions",
121
+ "full_name": "CategoryTheory.hasColimits_of_hasColimits_createsColimits",
122
+ "id": "CategoryTheory.hasColimits_of_hasColimits_createsColimits",
123
+ "reason": "import_failure",
124
+ "selection": {
125
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
126
+ "end": [
127
+ 214,
128
+ 81
129
+ ],
130
+ "file_path": "Mathlib/CategoryTheory/Limits/Creates.lean",
131
+ "full_name": "CategoryTheory.hasColimits_of_hasColimits_createsColimits",
132
+ "start": [
133
+ 212,
134
+ 1
135
+ ],
136
+ "traced_tactics": [],
137
+ "url": "https://github.com/leanprover-community/mathlib4"
138
+ },
139
+ "source_file": "Mathlib/CategoryTheory/Limits/Creates.lean"
140
+ },
141
+ {
142
+ "error": "theorem has no selected tactic transitions",
143
+ "full_name": "CategoryTheory.hasLimit_of_created",
144
+ "id": "CategoryTheory.hasLimit_of_created",
145
+ "reason": "import_failure",
146
+ "selection": {
147
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
148
+ "end": [
149
+ 159,
150
+ 40
151
+ ],
152
+ "file_path": "Mathlib/CategoryTheory/Limits/Creates.lean",
153
+ "full_name": "CategoryTheory.hasLimit_of_created",
154
+ "start": [
155
+ 155,
156
+ 1
157
+ ],
158
+ "traced_tactics": [],
159
+ "url": "https://github.com/leanprover-community/mathlib4"
160
+ },
161
+ "source_file": "Mathlib/CategoryTheory/Limits/Creates.lean"
162
+ },
163
+ {
164
+ "error": "theorem has no selected tactic transitions",
165
+ "full_name": "CategoryTheory.hasLimitsOfShape_of_hasLimitsOfShape_createsLimitsOfShape",
166
+ "id": "CategoryTheory.hasLimitsOfShape_of_hasLimitsOfShape_createsLimitsOfShape",
167
+ "reason": "import_failure",
168
+ "selection": {
169
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
170
+ "end": [
171
+ 167,
172
+ 37
173
+ ],
174
+ "file_path": "Mathlib/CategoryTheory/Limits/Creates.lean",
175
+ "full_name": "CategoryTheory.hasLimitsOfShape_of_hasLimitsOfShape_createsLimitsOfShape",
176
+ "start": [
177
+ 165,
178
+ 1
179
+ ],
180
+ "traced_tactics": [],
181
+ "url": "https://github.com/leanprover-community/mathlib4"
182
+ },
183
+ "source_file": "Mathlib/CategoryTheory/Limits/Creates.lean"
184
+ },
185
+ {
186
+ "error": "theorem has no selected tactic transitions",
187
+ "full_name": "CategoryTheory.hasLimits_of_hasLimits_createsLimits",
188
+ "id": "CategoryTheory.hasLimits_of_hasLimits_createsLimits",
189
+ "reason": "import_failure",
190
+ "selection": {
191
+ "commit": "29dcec074de168ac2bf835a77ef68bbe069194c5",
192
+ "end": [
193
+ 173,
194
+ 75
195
+ ],
196
+ "file_path": "Mathlib/CategoryTheory/Limits/Creates.lean",
197
+ "full_name": "CategoryTheory.hasLimits_of_hasLimits_createsLimits",
198
+ "start": [
199
+ 171,
200
+ 1
201
+ ],
202
+ "traced_tactics": [],
203
+ "url": "https://github.com/leanprover-community/mathlib4"
204
+ },
205
+ "source_file": "Mathlib/CategoryTheory/Limits/Creates.lean"
206
+ }
207
+ ],
208
+ "input_proofs": 21,
209
+ "input_units": 2,
210
+ "proofs": 12,
211
+ "published_proofs": 12,
212
+ "published_transitions": 20,
213
+ "replay_failures": [],
214
+ "transitions": 20,
215
+ "validation_failures": [],
216
+ "validation_rejected_proofs": 0,
217
+ "zero_transition_proofs": 0
218
+ },
219
+ "shards": [
220
+ {
221
+ "path": "data/train/mathlib-000676-0000-8838254166bf697a.parquet",
222
+ "sha256": "8838254166bf697af4c59f89bd7fe3a101f35c09a19fdd1b8d9b35f80e676957",
223
+ "bytes": 73169,
224
+ "rows": 15,
225
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
226
+ },
227
+ {
228
+ "path": "data/internal_test/mathlib-000676-0000-1ee9b6909fcece11.parquet",
229
+ "sha256": "1ee9b6909fcece11e54dfa53db4f0f830367fda662e7f9b9efd300d99784f896",
230
+ "bytes": 47982,
231
+ "rows": 5,
232
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
233
+ }
234
+ ],
235
+ "proof_ids": [
236
+ "mathlib:CategoryTheory.Limits.inl_pushoutZeroZeroIso_hom",
237
+ "mathlib:CategoryTheory.Limits.inl_pushoutZeroZeroIso_inv",
238
+ "mathlib:CategoryTheory.Limits.inr_coprodZeroIso_hom",
239
+ "mathlib:CategoryTheory.Limits.inr_pushoutZeroZeroIso_hom",
240
+ "mathlib:CategoryTheory.Limits.inr_pushoutZeroZeroIso_inv",
241
+ "mathlib:CategoryTheory.Limits.inr_zeroCoprodIso_hom",
242
+ "mathlib:CategoryTheory.Limits.prodZeroIso_iso_inv_snd",
243
+ "mathlib:CategoryTheory.Limits.pullbackZeroZeroIso_hom_fst",
244
+ "mathlib:CategoryTheory.Limits.pullbackZeroZeroIso_hom_snd",
245
+ "mathlib:CategoryTheory.Limits.pullbackZeroZeroIso_inv_fst",
246
+ "mathlib:CategoryTheory.Limits.pullbackZeroZeroIso_inv_snd",
247
+ "mathlib:CategoryTheory.Limits.zeroProdIso_inv_snd"
248
+ ],
249
+ "proof_keys": [
250
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean\",null,null,\"CategoryTheory.Limits.inl_pushoutZeroZeroIso_hom\"]",
251
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean\",null,null,\"CategoryTheory.Limits.inl_pushoutZeroZeroIso_inv\"]",
252
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean\",null,null,\"CategoryTheory.Limits.inr_coprodZeroIso_hom\"]",
253
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean\",null,null,\"CategoryTheory.Limits.inr_pushoutZeroZeroIso_hom\"]",
254
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean\",null,null,\"CategoryTheory.Limits.inr_pushoutZeroZeroIso_inv\"]",
255
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean\",null,null,\"CategoryTheory.Limits.inr_zeroCoprodIso_hom\"]",
256
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean\",null,null,\"CategoryTheory.Limits.prodZeroIso_iso_inv_snd\"]",
257
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean\",null,null,\"CategoryTheory.Limits.pullbackZeroZeroIso_hom_fst\"]",
258
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean\",null,null,\"CategoryTheory.Limits.pullbackZeroZeroIso_hom_snd\"]",
259
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean\",null,null,\"CategoryTheory.Limits.pullbackZeroZeroIso_inv_fst\"]",
260
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean\",null,null,\"CategoryTheory.Limits.pullbackZeroZeroIso_inv_snd\"]",
261
+ "[\"mathlib\",\"29dcec074de168ac2bf835a77ef68bbe069194c5\",\"Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean\",null,null,\"CategoryTheory.Limits.zeroProdIso_inv_snd\"]"
262
+ ]
263
+ }
manifests/batches/numina/001426.json ADDED
@@ -0,0 +1,51 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "format": "leangpt-parquet-v2",
3
+ "batch": "numina/001426",
4
+ "batch_fingerprint": "55600603cab838f3b4f17cc50b631abd9a710068689a50bfeda3793322345d8d",
5
+ "evidence": {
6
+ "batch_fingerprint": "55600603cab838f3b4f17cc50b631abd9a710068689a50bfeda3793322345d8d",
7
+ "contamination_matches": [],
8
+ "failures": [],
9
+ "input_proofs": 5,
10
+ "input_units": 5,
11
+ "proofs": 5,
12
+ "published_proofs": 5,
13
+ "published_transitions": 16,
14
+ "replay_failures": [],
15
+ "trace_mode": "bundle",
16
+ "transitions": 16,
17
+ "validation_failures": [],
18
+ "validation_rejected_proofs": 0,
19
+ "zero_transition_proofs": 0
20
+ },
21
+ "shards": [
22
+ {
23
+ "path": "data/train/numina-001426-0000-504b79e5e228ac62.parquet",
24
+ "sha256": "504b79e5e228ac621e22deaf796787e57a90b012189ca977dbe68d9977250079",
25
+ "bytes": 144921,
26
+ "rows": 13,
27
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
28
+ },
29
+ {
30
+ "path": "data/internal_test/numina-001426-0000-0d6a01ec87d17d12.parquet",
31
+ "sha256": "0d6a01ec87d17d120605a5c9137401b82eecfb21cb5cf205ba31d47eb869436e",
32
+ "bytes": 600245,
33
+ "rows": 3,
34
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
35
+ }
36
+ ],
37
+ "proof_ids": [
38
+ "numina:7fe0d894-606f-5a72-b3b1-fb943ad8f440",
39
+ "numina:95098642-56e5-527e-83f6-83c67df69954",
40
+ "numina:a0095248-0824-57f7-89f8-3f4f28232a19",
41
+ "numina:ee90bb4a-22c5-5605-84e8-a07c848b4926",
42
+ "numina:f87b20a4-a78a-5fab-8e2f-686ca32443ae"
43
+ ],
44
+ "proof_keys": [
45
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007130.lean\",\"993f5046f2a53b3a8a46e488ae8c2a0121bf57c46701c1bf33908e5dcacc4b77\",0,\"number_theory_605021\"]",
46
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007131.lean\",\"36ab94e0d145390a0e0bc0b6b61a3ca760420b8bcf76cad8c8be5b1751094c7a\",0,\"algebra_20368\"]",
47
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007132.lean\",\"73071227bb42e3bc21284d7f34f1458d96ad78250f17d3be49df357347d46a13\",0,\"inequalities_137418\"]",
48
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007133.lean\",\"05223d9da0fc1d0b9107de66b72b8cd7e1ccf9fabafa10513ce2d98fb2d022c5\",0,\"algebra_166621\"]",
49
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007134.lean\",\"af557aee10c9dec680be072504f7c4f6e7f349d074968500bd45ca35efbb196d\",0,\"number_theory_96705\"]"
50
+ ]
51
+ }
manifests/batches/numina/001427.json ADDED
@@ -0,0 +1,81 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "format": "leangpt-parquet-v2",
3
+ "batch": "numina/001427",
4
+ "batch_fingerprint": "8150852ac3793ae4d131e474f98fbcefbae7fc2ec0ad50699fd83656ff853ec5",
5
+ "evidence": {
6
+ "batch_fingerprint": "8150852ac3793ae4d131e474f98fbcefbae7fc2ec0ad50699fd83656ff853ec5",
7
+ "contamination_matches": [],
8
+ "failures": [],
9
+ "input_proofs": 5,
10
+ "input_units": 5,
11
+ "proofs": 5,
12
+ "published_proofs": 4,
13
+ "published_transitions": 21,
14
+ "replay_failures": [],
15
+ "trace_mode": "bundle",
16
+ "transitions": 32,
17
+ "validation_failures": [
18
+ {
19
+ "errors": [
20
+ "internal transition boundary mismatch",
21
+ "internal transition boundary mismatch",
22
+ "internal transition boundary mismatch"
23
+ ],
24
+ "file_path": "Full/Proof_007138.lean",
25
+ "proof_id": "numina:d59a9513-7264-58c8-89ab-271f89cb1246",
26
+ "provenance": {
27
+ "atomic_transition_count": 14,
28
+ "bundle_ordinal": 3,
29
+ "compound_transition_count": 7,
30
+ "declaration_kind": "theorem",
31
+ "metadata": {
32
+ "bundle_ordinal": 3,
33
+ "declaration_kind": "theorem",
34
+ "original_file_path": "Full/Proof_007138.lean",
35
+ "source_dataset": "numina",
36
+ "theorem_name": "inequalities_228653",
37
+ "theorem_ordinal": 0
38
+ },
39
+ "original_file_path": "Full/Proof_007138.lean",
40
+ "selection_index": 7138,
41
+ "source_dataset": "numina",
42
+ "source_id": "d59a9513-7264-58c8-89ab-271f89cb1246",
43
+ "source_sha256": "9248cd183d039d74002b176f445e6e6bd091d80d5c030b83c98c12980fe83ab2",
44
+ "theorem_name": "inequalities_228653",
45
+ "theorem_ordinal": 0
46
+ },
47
+ "theorem_name": "inequalities_228653"
48
+ }
49
+ ],
50
+ "validation_rejected_proofs": 1,
51
+ "zero_transition_proofs": 0
52
+ },
53
+ "shards": [
54
+ {
55
+ "path": "data/train/numina-001427-0000-45f17c77a9abe748.parquet",
56
+ "sha256": "45f17c77a9abe748feac53b9e3dbfddedb46c74338bd10b3acefef518c443c0b",
57
+ "bytes": 112339,
58
+ "rows": 18,
59
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
60
+ },
61
+ {
62
+ "path": "data/dev/numina-001427-0000-555d796ee97f0740.parquet",
63
+ "sha256": "555d796ee97f074098ac950cc70633818d5581b6574977d62433fbe9597b0033",
64
+ "bytes": 76948,
65
+ "rows": 3,
66
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
67
+ }
68
+ ],
69
+ "proof_ids": [
70
+ "numina:99a6edea-0cb4-510b-92a1-f14af5d022fc",
71
+ "numina:c0c7a36e-0edf-59f7-8994-ff4b1a001a83",
72
+ "numina:e492bd2e-cf15-5003-ad9d-f96169375846",
73
+ "numina:e6e0a67e-a3b8-597e-897a-8a1c75ff1adb"
74
+ ],
75
+ "proof_keys": [
76
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007135.lean\",\"d920e1fcf49735bb7169c865698bbbc4c2dd818c227fda64d8771cfc20fda97b\",0,\"algebra_296788\"]",
77
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007136.lean\",\"fa3d00dab009064e4e0af100f5a34f5d47b1d62f5cd983f9468396cd6096c890\",0,\"algebra_21499\"]",
78
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007137.lean\",\"172e9aa61758fc82ca7f30c83bedec2d59bfdae5d08f55c1df018d5ae957e564\",0,\"inequalities_604925\"]",
79
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007139.lean\",\"f5fcd69de486a1e5ad5d2bfdc15f841c7f191f346ef1e101605813a7f49cefee\",0,\"inequalities_623016\"]"
80
+ ]
81
+ }
manifests/batches/numina/001428.json ADDED
@@ -0,0 +1,51 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "format": "leangpt-parquet-v2",
3
+ "batch": "numina/001428",
4
+ "batch_fingerprint": "da7cdb19e2c1641036a0fd15066de3b00009e6c2d42961124129ed54455da996",
5
+ "evidence": {
6
+ "batch_fingerprint": "da7cdb19e2c1641036a0fd15066de3b00009e6c2d42961124129ed54455da996",
7
+ "contamination_matches": [],
8
+ "failures": [],
9
+ "input_proofs": 5,
10
+ "input_units": 5,
11
+ "proofs": 5,
12
+ "published_proofs": 5,
13
+ "published_transitions": 32,
14
+ "replay_failures": [],
15
+ "trace_mode": "bundle",
16
+ "transitions": 32,
17
+ "validation_failures": [],
18
+ "validation_rejected_proofs": 0,
19
+ "zero_transition_proofs": 0
20
+ },
21
+ "shards": [
22
+ {
23
+ "path": "data/train/numina-001428-0000-7239247474010c04.parquet",
24
+ "sha256": "7239247474010c041b76a3694be866618e8c510097570011ca34fb16799863cb",
25
+ "bytes": 287771,
26
+ "rows": 29,
27
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
28
+ },
29
+ {
30
+ "path": "data/internal_test/numina-001428-0000-c470c5615a5edf79.parquet",
31
+ "sha256": "c470c5615a5edf79141bfe1504a3295187acd17b990be18bc14818ecb257d325",
32
+ "bytes": 49625,
33
+ "rows": 3,
34
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
35
+ }
36
+ ],
37
+ "proof_ids": [
38
+ "numina:0f421760-6b27-5b60-92d8-1922254dca24",
39
+ "numina:47c28704-506b-5bf9-b5e3-570cf5205497",
40
+ "numina:6de1172d-929e-5076-a456-44fa9257b337",
41
+ "numina:8a6cfa24-98e9-5786-838e-4d000734ec8f",
42
+ "numina:dfae9f87-57ea-53d5-a29b-54dc297d71d6"
43
+ ],
44
+ "proof_keys": [
45
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007140.lean\",\"fbd7cf7817bd65687fe75f52f707aa8c685fddb80fe7115bd17654a2d4c6f288\",0,\"algebra_120847\"]",
46
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007141.lean\",\"f9ff0dac46dc18019ad44860442fbd2ba84ba7e3dedf01916e90e24a9603c425\",0,\"algebra_202712\"]",
47
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007142.lean\",\"92f9c7635c5b3e7830f0118f0ae6af876dd62645c340ee091b6b3f649c6fdcda\",0,\"algebra_96923\"]",
48
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007143.lean\",\"7ae6cbba01d9483e8755370f65883c5de46d4a1329e053ca95d417ae9c223793\",0,\"algebra_296944\"]",
49
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007144.lean\",\"75d5889df1e85de86ed9c94b0a06aa0d7e7fb7b60fa1c178d6f46c64c045bbc3\",0,\"inequalities_605069\"]"
50
+ ]
51
+ }
manifests/batches/numina/001429.json ADDED
@@ -0,0 +1,44 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "format": "leangpt-parquet-v2",
3
+ "batch": "numina/001429",
4
+ "batch_fingerprint": "0c2e3ca1f9a0d49aacac8ea71e2a06a946d9d6e3a8240baf50a6528436e099e0",
5
+ "evidence": {
6
+ "batch_fingerprint": "0c2e3ca1f9a0d49aacac8ea71e2a06a946d9d6e3a8240baf50a6528436e099e0",
7
+ "contamination_matches": [],
8
+ "failures": [],
9
+ "input_proofs": 5,
10
+ "input_units": 5,
11
+ "proofs": 5,
12
+ "published_proofs": 5,
13
+ "published_transitions": 20,
14
+ "replay_failures": [],
15
+ "trace_mode": "bundle",
16
+ "transitions": 20,
17
+ "validation_failures": [],
18
+ "validation_rejected_proofs": 0,
19
+ "zero_transition_proofs": 0
20
+ },
21
+ "shards": [
22
+ {
23
+ "path": "data/train/numina-001429-0000-a66ff6d8d8b8d50f.parquet",
24
+ "sha256": "a66ff6d8d8b8d50fa672f5b6406fa134607bb77fa84f96e4610586df6a624f72",
25
+ "bytes": 195327,
26
+ "rows": 20,
27
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
28
+ }
29
+ ],
30
+ "proof_ids": [
31
+ "numina:02f18045-4cb7-5510-8b2e-9ed21aeb3e0d",
32
+ "numina:86914820-081d-539f-868d-6fddc5642c89",
33
+ "numina:89abbe54-4c7f-5d95-98f4-11eb6b6e50ac",
34
+ "numina:c6caa552-818a-5840-abdd-9e1d8919e561",
35
+ "numina:fc8ce097-0b28-52c6-95a7-134caf6b35e6"
36
+ ],
37
+ "proof_keys": [
38
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007145.lean\",\"fb7490ac65d4c3942c91deed6461c407d6b7dc415721391b4cf26fa7c5cf0547\",0,\"number_theory_623167\"]",
39
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007146.lean\",\"19fd672d3ac2c318fbf4c3b3367884360e13cb42c97f68a1581142a0226cfba1\",0,\"algebra_708\"]",
40
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007147.lean\",\"3759680e057eb07e1a9fb37fa06e4087bbaa07f59c3f0f62524f080a87677b80\",0,\"algebra_9144\"]",
41
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007148.lean\",\"d20d1028a04fc0ad5af6f950465f72917aa83ea5aa6bb2c115e5cf21cfb99cae\",0,\"algebra_21504\"]",
42
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007149.lean\",\"f7386337fc7817e2ec65abab7ff2d7424834f0c1e9dd186856e33d4dfe50da20\",0,\"algebra_12907\"]"
43
+ ]
44
+ }
manifests/batches/numina/001430.json ADDED
@@ -0,0 +1,51 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "format": "leangpt-parquet-v2",
3
+ "batch": "numina/001430",
4
+ "batch_fingerprint": "3358970b051818607066535d3a4e04f052279a0cf8fe7cc8b8af21e02202bc2b",
5
+ "evidence": {
6
+ "batch_fingerprint": "3358970b051818607066535d3a4e04f052279a0cf8fe7cc8b8af21e02202bc2b",
7
+ "contamination_matches": [],
8
+ "failures": [],
9
+ "input_proofs": 5,
10
+ "input_units": 5,
11
+ "proofs": 5,
12
+ "published_proofs": 5,
13
+ "published_transitions": 36,
14
+ "replay_failures": [],
15
+ "trace_mode": "bundle",
16
+ "transitions": 36,
17
+ "validation_failures": [],
18
+ "validation_rejected_proofs": 0,
19
+ "zero_transition_proofs": 0
20
+ },
21
+ "shards": [
22
+ {
23
+ "path": "data/train/numina-001430-0000-1f9cacefdf063634.parquet",
24
+ "sha256": "1f9cacefdf06363455050181aafb89c8d0b724e29a62f75af192fef3adeba7ef",
25
+ "bytes": 241050,
26
+ "rows": 26,
27
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
28
+ },
29
+ {
30
+ "path": "data/internal_test/numina-001430-0000-5bd3737da33160c1.parquet",
31
+ "sha256": "5bd3737da33160c1d7662495996839f2ad47569f171d16029ee0fc34ca38a3cc",
32
+ "bytes": 62047,
33
+ "rows": 10,
34
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
35
+ }
36
+ ],
37
+ "proof_ids": [
38
+ "numina:16b9baf3-5bf2-5599-9f6b-5c5dc6ca566f",
39
+ "numina:1a87e145-3743-5c23-b4a1-d9a3d5903873",
40
+ "numina:9b1e2bdf-9ddb-56ee-8892-e4f98c64381c",
41
+ "numina:a1be69b6-c5d7-5206-800d-7e68775dddcf",
42
+ "numina:e2657659-105b-510d-8407-e37bb29f3052"
43
+ ],
44
+ "proof_keys": [
45
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007150.lean\",\"22925381c355f3b3415c34b22a7c305f2d37280c22b29af26d05903d57c39831\",0,\"number_theory_94387\"]",
46
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007151.lean\",\"656e336a173349db5590e87e7828cc567b4f9776d77c4b69118700a8a41cd665\",0,\"algebra_228718\"]",
47
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007152.lean\",\"a4c38ff9da3ea21cd04859b9e375d732e55ba267df5412b9d249315520ffcf1f\",0,\"number_theory_32185\"]",
48
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007153.lean\",\"74b0b62398cf3b58de3b6fd13f15afd5d06beb1647fcd303b7e0d052857d9601\",0,\"algebra_13790\"]",
49
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007154.lean\",\"c097cb7f8f6ccd9f85294276651ccab38826274d9df49647f2eb1ce8def9df8e\",0,\"inequalities_202989\"]"
50
+ ]
51
+ }
manifests/batches/numina/001431.json ADDED
@@ -0,0 +1,51 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "format": "leangpt-parquet-v2",
3
+ "batch": "numina/001431",
4
+ "batch_fingerprint": "2b95683d0d7cf0e99ded82d288d5481cfaa43a148019839f4644c8ca29196222",
5
+ "evidence": {
6
+ "batch_fingerprint": "2b95683d0d7cf0e99ded82d288d5481cfaa43a148019839f4644c8ca29196222",
7
+ "contamination_matches": [],
8
+ "failures": [],
9
+ "input_proofs": 5,
10
+ "input_units": 5,
11
+ "proofs": 5,
12
+ "published_proofs": 5,
13
+ "published_transitions": 38,
14
+ "replay_failures": [],
15
+ "trace_mode": "bundle",
16
+ "transitions": 38,
17
+ "validation_failures": [],
18
+ "validation_rejected_proofs": 0,
19
+ "zero_transition_proofs": 0
20
+ },
21
+ "shards": [
22
+ {
23
+ "path": "data/train/numina-001431-0000-bd8a8543ba667304.parquet",
24
+ "sha256": "bd8a8543ba667304f0070670016b20cf926e13ec4292319bb8ff9bbc9f119655",
25
+ "bytes": 169546,
26
+ "rows": 16,
27
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
28
+ },
29
+ {
30
+ "path": "data/dev/numina-001431-0000-7271fd624ba6735a.parquet",
31
+ "sha256": "7271fd624ba6735a54e3211d5c5e33450075182ed75ee4b95279943bae51eef0",
32
+ "bytes": 120378,
33
+ "rows": 22,
34
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
35
+ }
36
+ ],
37
+ "proof_ids": [
38
+ "numina:10bd73b4-881c-5812-8476-3cfbdced04a5",
39
+ "numina:9216aca3-7ce4-5ada-9a1a-6095e10a01fb",
40
+ "numina:d606dc92-e08a-5064-a53f-1c5b6338d52e",
41
+ "numina:f6b0c526-9421-5b86-9e04-b168f6ded2db",
42
+ "numina:fba502ed-9674-5101-ab4c-31f3feed5fd6"
43
+ ],
44
+ "proof_keys": [
45
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007155.lean\",\"02d89d857a22d4270315f75513813423aece481c498495569f003754b4f64554\",0,\"algebra_9145\"]",
46
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007156.lean\",\"32687a5d07f863197c844b3d7abbec524955e5800da9a9eadc75c53366bcf889\",0,\"algebra_21511\"]",
47
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007157.lean\",\"815a4065414e5eeda28ee4a8f007d003877e3b3ac2d7b46584786194f3b2a0c6\",0,\"number_theory_258524\"]",
48
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007158.lean\",\"37a5ed1cc44ed580bf70c4c8e9974f9d857b147dc53c10d0d3fe11b4f2842c11\",0,\"number_theory_607233\"]",
49
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007159.lean\",\"04a280405d3df5da7b9c5f22228684fc20745c5c4651472f413c28bc09cde7ae\",0,\"algebra_94395\"]"
50
+ ]
51
+ }
manifests/batches/numina/001432.json ADDED
@@ -0,0 +1,51 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "format": "leangpt-parquet-v2",
3
+ "batch": "numina/001432",
4
+ "batch_fingerprint": "ba18a37abc15d0a89978e7bd72f6d022a05630e0de3d85c3a9eafac3fe4639a6",
5
+ "evidence": {
6
+ "batch_fingerprint": "ba18a37abc15d0a89978e7bd72f6d022a05630e0de3d85c3a9eafac3fe4639a6",
7
+ "contamination_matches": [],
8
+ "failures": [],
9
+ "input_proofs": 5,
10
+ "input_units": 5,
11
+ "proofs": 5,
12
+ "published_proofs": 5,
13
+ "published_transitions": 36,
14
+ "replay_failures": [],
15
+ "trace_mode": "bundle",
16
+ "transitions": 36,
17
+ "validation_failures": [],
18
+ "validation_rejected_proofs": 0,
19
+ "zero_transition_proofs": 0
20
+ },
21
+ "shards": [
22
+ {
23
+ "path": "data/train/numina-001432-0000-51df6f7c40d54a70.parquet",
24
+ "sha256": "51df6f7c40d54a70485df3a3a091fa8d4ad5b7ce0fe1cea7ee82f981dfb9288a",
25
+ "bytes": 259073,
26
+ "rows": 34,
27
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
28
+ },
29
+ {
30
+ "path": "data/internal_test/numina-001432-0000-24133952efbafe62.parquet",
31
+ "sha256": "24133952efbafe62328ca0cc78863045fc5e6fdb2fbee07353d1abd5e3e2217c",
32
+ "bytes": 179242,
33
+ "rows": 2,
34
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
35
+ }
36
+ ],
37
+ "proof_ids": [
38
+ "numina:067385e0-61eb-50c7-a516-87d24462666d",
39
+ "numina:1f6f597a-b94f-5205-a5a8-9ce3dd461c62",
40
+ "numina:5ea16220-639e-51de-ba78-d499845dad40",
41
+ "numina:76d9772f-0a6b-5f15-b50a-babe493d644b",
42
+ "numina:dc3efc48-5a50-5d4a-b27b-d3b9041a6016"
43
+ ],
44
+ "proof_keys": [
45
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007160.lean\",\"2e0aa9c0ae0864d465bc4425750a722a5c69ed0aee50a14f0cfc275584adc490\",0,\"number_theory_26744\"]",
46
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007161.lean\",\"4dffe6497a70a834835b367372b2e58a6066774d69c5a22a46228fdda671a05a\",0,\"algebra_7924\"]",
47
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007162.lean\",\"4429186ed1dae18f0a09b6ff7319b093e0855a41acc6b9f6b3ca887f8190b72b\",0,\"number_theory_709\"]",
48
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007163.lean\",\"cffe1ed7ee7706202b0fc4e30c69a947e7c4ae56f64fc977768de21f1e3fbb81\",0,\"algebra_203168\"]",
49
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007164.lean\",\"9fa3730a878710cdd20122800ac6eb3b12dc15d103b6407f37d92bdd671f6ec5\",0,\"algebra_935\"]"
50
+ ]
51
+ }
manifests/batches/numina/001433.json ADDED
@@ -0,0 +1,44 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "format": "leangpt-parquet-v2",
3
+ "batch": "numina/001433",
4
+ "batch_fingerprint": "9f3f2f916f93f77c881a767d492def9ab4d4f7e249e5f2f836aab403e34aacc9",
5
+ "evidence": {
6
+ "batch_fingerprint": "9f3f2f916f93f77c881a767d492def9ab4d4f7e249e5f2f836aab403e34aacc9",
7
+ "contamination_matches": [],
8
+ "failures": [],
9
+ "input_proofs": 5,
10
+ "input_units": 5,
11
+ "proofs": 5,
12
+ "published_proofs": 5,
13
+ "published_transitions": 29,
14
+ "replay_failures": [],
15
+ "trace_mode": "bundle",
16
+ "transitions": 29,
17
+ "validation_failures": [],
18
+ "validation_rejected_proofs": 0,
19
+ "zero_transition_proofs": 0
20
+ },
21
+ "shards": [
22
+ {
23
+ "path": "data/train/numina-001433-0000-042248b85b164f19.parquet",
24
+ "sha256": "042248b85b164f19c25077881f824a998dc8348ebcf32660aa8923e725114404",
25
+ "bytes": 248635,
26
+ "rows": 29,
27
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
28
+ }
29
+ ],
30
+ "proof_ids": [
31
+ "numina:26a07f50-74a2-57c6-afd0-b9ef9869c294",
32
+ "numina:a3bb836b-8b77-5c14-aa41-da1f954fb4aa",
33
+ "numina:a3d34b33-9582-50f7-82c3-91d769e6c481",
34
+ "numina:c039ab41-0e20-547b-8648-45bfe12571a0",
35
+ "numina:f20f3fbd-5824-5725-b953-7e025332ec19"
36
+ ],
37
+ "proof_keys": [
38
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007165.lean\",\"0b0baa7687b0d0c455939c65aa4c911e88fb31c6bf113eb03d444857e4816ade\",0,\"algebra_9118\"]",
39
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007166.lean\",\"058232f73ee9290a98f71d6e168d2c30da5ade01bb0233a28b7f5f2833bddad6\",0,\"inequalities_262557\"]",
40
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007167.lean\",\"ca3aa1469d12c30cd438e17242dab349b3029d942356bd4bdc51baa19ec10974\",0,\"algebra_9119\"]",
41
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007168.lean\",\"edc8384a97180c1a3ff940e65ca754d400254eac0d73d02c4e4e4ace05875982\",0,\"number_theory_604212\"]",
42
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007169.lean\",\"224468efa821e8227a1fe3c250247c2d8f32eb052b5a40547b325efbeb48f895\",0,\"algebra_607898\"]"
43
+ ]
44
+ }
manifests/batches/numina/001434.json ADDED
@@ -0,0 +1,51 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "format": "leangpt-parquet-v2",
3
+ "batch": "numina/001434",
4
+ "batch_fingerprint": "5b1b19600fae15339400546bad4d316f32c77f46a6643794028596b4dad222fb",
5
+ "evidence": {
6
+ "batch_fingerprint": "5b1b19600fae15339400546bad4d316f32c77f46a6643794028596b4dad222fb",
7
+ "contamination_matches": [],
8
+ "failures": [],
9
+ "input_proofs": 5,
10
+ "input_units": 5,
11
+ "proofs": 5,
12
+ "published_proofs": 5,
13
+ "published_transitions": 37,
14
+ "replay_failures": [],
15
+ "trace_mode": "bundle",
16
+ "transitions": 37,
17
+ "validation_failures": [],
18
+ "validation_rejected_proofs": 0,
19
+ "zero_transition_proofs": 0
20
+ },
21
+ "shards": [
22
+ {
23
+ "path": "data/train/numina-001434-0000-4366fde90d652fed.parquet",
24
+ "sha256": "4366fde90d652fedf1b0ec075a37cdedec6cae08cf572301d5580cd724153302",
25
+ "bytes": 575136,
26
+ "rows": 33,
27
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
28
+ },
29
+ {
30
+ "path": "data/internal_test/numina-001434-0000-fc42c3aa7948ba13.parquet",
31
+ "sha256": "fc42c3aa7948ba1366dfc17ce7b33cf8880d8db6fe8a77baffa685a66b8da6c8",
32
+ "bytes": 39881,
33
+ "rows": 4,
34
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
35
+ }
36
+ ],
37
+ "proof_ids": [
38
+ "numina:1530bf95-f7eb-54a0-b4ed-941baeeae622",
39
+ "numina:2fadaf57-87f0-5cb5-b81d-984e02b8e7a8",
40
+ "numina:8a51ab03-9a40-5748-905d-e3a2bb96b7b3",
41
+ "numina:9303b87b-f914-5cac-bacf-a75ade72a9ec",
42
+ "numina:edb437e9-eb6f-54f4-a3d9-2f50a550d1c3"
43
+ ],
44
+ "proof_keys": [
45
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007170.lean\",\"955257473b95d146a82504ae83b7b86daca0dea1d96168898754dda8567385d7\",0,\"number_theory_611465\"]",
46
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007171.lean\",\"9c6e2fff896df07babfafd324f402fd0a55c96060ead5d000ad58f188b620f26\",0,\"algebra_98009\"]",
47
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007172.lean\",\"7ccef3c234105695d9ab1a9234984be5fe3ee830c103ae4e90ea4331e3193277\",0,\"number_theory_604213\"]",
48
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007173.lean\",\"5cb681a7fd0d10173b2a8e4362541924b7bee76a2d417fdcb24118679ec3ab17\",0,\"algebra_9206\"]",
49
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007174.lean\",\"cf85036cf23d6905f26c0c47c9c2dfbf4de678ccd320bc5da894e4b40108b923\",0,\"algebra_98011\"]"
50
+ ]
51
+ }
manifests/batches/numina/001436.json ADDED
@@ -0,0 +1,58 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "format": "leangpt-parquet-v2",
3
+ "batch": "numina/001436",
4
+ "batch_fingerprint": "a45d97174b8ff633138a57171432588eb2a1c488e16bfbdc0f741a7436094f67",
5
+ "evidence": {
6
+ "batch_fingerprint": "a45d97174b8ff633138a57171432588eb2a1c488e16bfbdc0f741a7436094f67",
7
+ "contamination_matches": [],
8
+ "failures": [],
9
+ "input_proofs": 5,
10
+ "input_units": 5,
11
+ "proofs": 5,
12
+ "published_proofs": 5,
13
+ "published_transitions": 30,
14
+ "replay_failures": [],
15
+ "trace_mode": "bundle",
16
+ "transitions": 30,
17
+ "validation_failures": [],
18
+ "validation_rejected_proofs": 0,
19
+ "zero_transition_proofs": 0
20
+ },
21
+ "shards": [
22
+ {
23
+ "path": "data/train/numina-001436-0000-14bfe9beb1efe23a.parquet",
24
+ "sha256": "14bfe9beb1efe23a76d28a3a700f5436b9e6f9014604ea142b27839034c1495d",
25
+ "bytes": 640947,
26
+ "rows": 24,
27
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
28
+ },
29
+ {
30
+ "path": "data/dev/numina-001436-0000-8588fc2c22a3d0be.parquet",
31
+ "sha256": "8588fc2c22a3d0beea9f05d43f649d0bb2c19fb51f10b0af6f01918ced08fee6",
32
+ "bytes": 23567,
33
+ "rows": 1,
34
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
35
+ },
36
+ {
37
+ "path": "data/internal_test/numina-001436-0000-a11aa315663068d5.parquet",
38
+ "sha256": "a11aa315663068d504ce3a85a384abc1ab011941a82557a2420e124dce6111f8",
39
+ "bytes": 53330,
40
+ "rows": 5,
41
+ "revision": "4c50b3d576bded7e642f3be5ccf382d5be2f6868"
42
+ }
43
+ ],
44
+ "proof_ids": [
45
+ "numina:0b319a0b-f546-5a2a-9ace-8685ef9e2c95",
46
+ "numina:187c2515-5873-51b6-a07a-50cf8128c5bc",
47
+ "numina:37161fd4-f7ca-56d8-a051-a85ec155c9d7",
48
+ "numina:c9471a96-0684-52dd-b764-df0cf63faacd",
49
+ "numina:d238af45-d714-56fc-bc21-d5a25d027ce4"
50
+ ],
51
+ "proof_keys": [
52
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007180.lean\",\"8e45d51f7450cc6de62c8a05ff147555ef09875ebf2117cf5244229641bdffe1\",0,\"algebra_98341\"]",
53
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007181.lean\",\"4eaaba23fd8c6d626362edb3969c590a0d7c15ace7b1da3363d573e567ff3667\",0,\"algebra_21778\"]",
54
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007182.lean\",\"d25c19bd21c3e6db1731e602013314aca13e913d4346e7bf44a7a58f4455bac6\",0,\"number_theory_604407\"]",
55
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007183.lean\",\"b1621f0273f63b253218854bec295d20f491e8acdb8973d9edaec8958cb0c7d0\",0,\"algebra_9210\"]",
56
+ "[\"numina\",\"51fa67f1f647ae1ecd81eef9f19306aa8a7b3a94\",\"Full/Proof_007184.lean\",\"11234c7172cd1052589509643da2f907fdfb5d2116b6de8facfd8bbdc91d97dd\",0,\"number_theory_607523\"]"
57
+ ]
58
+ }