ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: List.alternatingProd_eq_finset_prod
File: Mathlib/Algebra/BigOperators/Fin.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
inst✝ : CommGroup G
⊢ [].alternatingProd = ∏ i : Fin [].length, [].get i ^ (-1) ^ ↑i
state_after: α : Type u_1
β : Type u_2
G : Type u_3
inst✝ : CommGroup G
⊢ ∀ x ∈ univ, [].get x ^ (-1) ^ ↑x = 1
tactic: rw [alternatingProd, Finset.prod_eq_one]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
inst✝ : CommGroup G
⊢ ∀ x ∈ univ, [].get x ^ (-1) ^ ↑x = 1
state_after: no goals
tactic: rintro ⟨i, ⟨⟩⟩
state_before: α : Type u_1
β : Type u_2
G : Type u_3
inst✝ : CommGroup G
g : G
⊢ [g].alternatingProd = ∏ i : Fin [g].length, [g].get i ^ (-1) ^ ↑i
state_after: α : Type u_1
β : Type u_2
G : Type u_3
inst✝ : CommGroup G
g : G
⊢ g = ∏ i : Fin 1, [g].get i ^ (-1) ^ ↑i
tactic: show g = ∏ i : Fin 1, [g].get i ^ (-1 : ℤ) ^ (i : ℕ)
state_before: α : Type u_1
β : Type u_2
G : Type u_3
inst✝ : CommGroup G
g : G
⊢ g = ∏ i : Fin 1, [g].get i ^ (-1) ^ ↑i
state_after: α : Type u_1
β : Type u_2
G : Type u_3
inst✝ : CommGroup G
g : G
⊢ g = [g].get 0 ^ (-1) ^ ↑0 * ∏ i : Fin 0, [g].get i.succ ^ (-1) ^ ↑i.succ
tactic: rw [Fin.prod_univ_succ]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
inst✝ : CommGroup G
g : G
⊢ g = [g].get 0 ^ (-1) ^ ↑0 * ∏ i : Fin 0, [g].get i.succ ^ (-1) ^ ↑i.succ
state_after: no goals
tactic: simp
state_before: α : Type u_1
β : Type u_2
G : Type u_3
inst✝ : CommGroup G
g h : G
L : List G
⊢ g * h⁻¹ * ∏ i : Fin L.length, L.get i ^ (-1) ^ ↑i = ∏ i : Fin (L.length + 2), (g :: h :: L).get i ^ (-1) ^ ↑i
state_after: α : Type u_1
β : Type u_2
G : Type u_3
inst✝ : CommGroup G
g h : G
L : List G
⊢ g * (h⁻¹ * ∏ i : Fin L.length, L.get i ^ (-1) ^ ↑i) =
    (g :: h :: L).get 0 ^ (-1) ^ ↑0 *
      ((g :: h :: L).get (Fin.succ 0) ^ (-1) ^ ↑(Fin.succ 0) *
        ∏ i : Fin L.length, (g :: h :: L).get i.succ.succ ^ (-1) ^ ↑i.succ.succ)
tactic: rw [Fin.prod_univ_succ, Fin.prod_univ_succ, mul_assoc]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
inst✝ : CommGroup G
g h : G
L : List G
⊢ g * (h⁻¹ * ∏ i : Fin L.length, L.get i ^ (-1) ^ ↑i) =
    (g :: h :: L).get 0 ^ (-1) ^ ↑0 *
      ((g :: h :: L).get (Fin.succ 0) ^ (-1) ^ ↑(Fin.succ 0) *
        ∏ i : Fin L.length, (g :: h :: L).get i.succ.succ ^ (-1) ^ ↑i.succ.succ)
state_after: no goals
tactic: simp [pow_add]
Theorem: stdSimplex_of_isEmpty_index
File: Mathlib/Analysis/Convex/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
ι : Type u_5
inst✝³ : OrderedSemiring 𝕜
inst✝² : Fintype ι
inst✝¹ : IsEmpty ι
inst✝ : Nontrivial 𝕜
⊢ ∀ (x : ι → 𝕜), x ∉ stdSimplex 𝕜 ι
state_after: case intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
ι : Type u_5
inst✝³ : OrderedSemiring 𝕜
inst✝² : Fintype ι
inst✝¹ : IsEmpty ι
inst✝ : Nontrivial 𝕜
f : ι → 𝕜
hf : ∑ x : ι, f x = 1
⊢ False
tactic: rintro f ⟨-, hf⟩
state_before: case intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
ι : Type u_5
inst✝³ : OrderedSemiring 𝕜
inst✝² : Fintype ι
inst✝¹ : IsEmpty ι
inst✝ : Nontrivial 𝕜
f : ι → 𝕜
hf : ∑ x : ι, f x = 1
⊢ False
state_after: no goals
tactic: simp at hf
Theorem: quadraticCharFun_eq_one_of_char_two
File: Mathlib/NumberTheory/LegendreSymbol/QuadraticChar/Basic.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
hF : ringChar F = 2
a : F
ha : a ≠ 0
⊢ quadraticCharFun F a = 1
state_after: F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
hF : ringChar F = 2
a : F
ha : a ≠ 0
⊢ ¬IsSquare a → False
tactic: simp only [quadraticCharFun, ha, if_false, ite_eq_left_iff]
state_before: F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
hF : ringChar F = 2
a : F
ha : a ≠ 0
⊢ ¬IsSquare a → False
state_after: no goals
tactic: exact fun h ↦ (h (FiniteField.isSquare_of_char_two hF a)).elim
Theorem: Ordinal.ne_bmex
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: case h.e'_2.h.e'_1
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
i : Ordinal.{u}
hi : i < o
⊢ i = typein (fun x x_1 => x < x_1) (enum (fun x x_1 => x < x_1) i ⋯)
state_after: no goals
tactic: rw [typein_enum]
Theorem: CategoryTheory.Bicategory.rightUnitor_comp_inv
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

Proof steps:
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
⊢ (ρ_ (f ≫ g)).inv = f ◁ (ρ_ g).inv ≫ (α_ f g (𝟙 c)).inv
state_after: no goals
tactic: simp
Theorem: Con.zpow
File: Mathlib/GroupTheory/Congruence/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Group M
inst✝¹ : Group N
inst✝ : Group P
c : Con M
n : ℕ
w x : M
h : c w x
⊢ c (w ^ Int.ofNat n) (x ^ Int.ofNat n)
state_after: no goals
tactic: simpa only [zpow_natCast, Int.ofNat_eq_coe] using c.pow n h
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Group M
inst✝¹ : Group N
inst✝ : Group P
c : Con M
n : ℕ
w x : M
h : c w x
⊢ c (w ^ Int.negSucc n) (x ^ Int.negSucc n)
state_after: no goals
tactic: simpa only [zpow_negSucc] using c.inv (c.pow _ h)
Theorem: iUnion_Ici_eq_Ici_iInf
File: Mathlib/Order/Interval/Set/Disjoint.lean

Proof steps:
state_before: ι : Sort u
α : Type v
β : Type w
inst✝¹ : LinearOrder α
s : Set α
a : α
f✝ : ι → α
R : Type u_1
inst✝ : CompleteLinearOrder R
f : ι → R
has_least_elem : ⨅ i, f i ∈ range f
⊢ ⋃ i, Ici (f i) = Ici (⨅ i, f i)
state_after: no goals
tactic: simp only [← IsGLB.biUnion_Ici_eq_Ici (@isGLB_iInf _ _ _ f) has_least_elem, mem_range,
    iUnion_exists, iUnion_iUnion_eq']
Theorem: Filter.mem_prod_iff_left
File: Mathlib/Order/Filter/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t : Set β
f : Filter α
g : Filter β
s : Set (α × β)
⊢ s ∈ f ×ˢ g ↔ ∃ t ∈ f, ∀ᶠ (y : β) in g, ∀ x ∈ t, (x, y) ∈ s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t : Set β
f : Filter α
g : Filter β
s : Set (α × β)
⊢ (∃ t₁ ∈ f, ∃ t₂ ∈ g, ∀ x ∈ t₁, ∀ y ∈ t₂, (x, y) ∈ s) ↔ ∃ t ∈ f, ∀ᶠ (y : β) in g, ∀ x ∈ t, (x, y) ∈ s
tactic: simp only [mem_prod_iff, prod_subset_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t : Set β
f : Filter α
g : Filter β
s : Set (α × β)
⊢ (∃ t₁ ∈ f, ∃ t₂ ∈ g, ∀ x ∈ t₁, ∀ y ∈ t₂, (x, y) ∈ s) ↔ ∃ t ∈ f, ∀ᶠ (y : β) in g, ∀ x ∈ t, (x, y) ∈ s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t : Set β
f : Filter α
g : Filter β
s : Set (α × β)
x✝ : Set α
⊢ (∃ t₂ ∈ g, ∀ x ∈ x✝, ∀ y ∈ t₂, (x, y) ∈ s) ↔ ∃ t ∈ g, t ⊆ {x | (fun y => ∀ x ∈ x✝, (x, y) ∈ s) x}
tactic: refine exists_congr fun _ => Iff.rfl.and <| Iff.trans ?_ exists_mem_subset_iff
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t : Set β
f : Filter α
g : Filter β
s : Set (α × β)
x✝ : Set α
⊢ (∃ t₂ ∈ g, ∀ x ∈ x✝, ∀ y ∈ t₂, (x, y) ∈ s) ↔ ∃ t ∈ g, t ⊆ {x | (fun y => ∀ x ∈ x✝, (x, y) ∈ s) x}
state_after: no goals
tactic: exact exists_congr fun _ => Iff.rfl.and forall₂_swap
Theorem: Zsqrtd.dmuld
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

Proof steps:
state_before: d : ℤ
⊢ sqrtd * sqrtd = ↑d
state_after: no goals
tactic: ext <;> simp
Theorem: strictConcaveOn_of_slope_strict_anti_adjacent
File: Mathlib/Analysis/Convex/Slope.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hs : Convex 𝕜 s
hf : ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) < (f y - f x) / (y - x)
⊢ StrictConcaveOn 𝕜 s f
state_after: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hs : Convex 𝕜 s
hf : ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) < (f y - f x) / (y - x)
⊢ StrictConvexOn 𝕜 s (-f)
tactic: rw [← neg_strictConvexOn_iff]
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hs : Convex 𝕜 s
hf : ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) < (f y - f x) / (y - x)
⊢ StrictConvexOn 𝕜 s (-f)
state_after: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hs : Convex 𝕜 s
hf : ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) < (f y - f x) / (y - x)
x✝ y✝ z✝ : 𝕜
hx : x✝ ∈ s
hz : z✝ ∈ s
hxy : x✝ < y✝
hyz : y✝ < z✝
⊢ ((-f) y✝ - (-f) x✝) / (y✝ - x✝) < ((-f) z✝ - (-f) y✝) / (z✝ - y✝)
tactic: refine strictConvexOn_of_slope_strict_mono_adjacent hs fun hx hz hxy hyz => ?_
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hs : Convex 𝕜 s
hf : ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) < (f y - f x) / (y - x)
x✝ y✝ z✝ : 𝕜
hx : x✝ ∈ s
hz : z✝ ∈ s
hxy : x✝ < y✝
hyz : y✝ < z✝
⊢ ((-f) y✝ - (-f) x✝) / (y✝ - x✝) < ((-f) z✝ - (-f) y✝) / (z✝ - y✝)
state_after: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hs : Convex 𝕜 s
hf : ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) < (f y - f x) / (y - x)
x✝ y✝ z✝ : 𝕜
hx : x✝ ∈ s
hz : z✝ ∈ s
hxy : x✝ < y✝
hyz : y✝ < z✝
⊢ -(((-f) z✝ - (-f) y✝) / (z✝ - y✝)) < -(((-f) y✝ - (-f) x✝) / (y✝ - x✝))
tactic: rw [← neg_lt_neg_iff]
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hs : Convex 𝕜 s
hf : ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) < (f y - f x) / (y - x)
x✝ y✝ z✝ : 𝕜
hx : x✝ ∈ s
hz : z✝ ∈ s
hxy : x✝ < y✝
hyz : y✝ < z✝
⊢ -(((-f) z✝ - (-f) y✝) / (z✝ - y✝)) < -(((-f) y✝ - (-f) x✝) / (y✝ - x✝))
state_after: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hs : Convex 𝕜 s
hf : ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) < (f y - f x) / (y - x)
x✝ y✝ z✝ : 𝕜
hx : x✝ ∈ s
hz : z✝ ∈ s
hxy : x✝ < y✝
hyz : y✝ < z✝
⊢ (f z✝ - f y✝) / (z✝ - y✝) < (f y✝ - f x✝) / (y✝ - x✝)
tactic: simp_rw [← neg_div, neg_sub, Pi.neg_apply, neg_sub_neg]
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hs : Convex 𝕜 s
hf : ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) < (f y - f x) / (y - x)
x✝ y✝ z✝ : 𝕜
hx : x✝ ∈ s
hz : z✝ ∈ s
hxy : x✝ < y✝
hyz : y✝ < z✝
⊢ (f z✝ - f y✝) / (z✝ - y✝) < (f y✝ - f x✝) / (y✝ - x✝)
state_after: no goals
tactic: exact hf hx hz hxy hyz
Theorem: Real.surjOn_cos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: ⊢ SurjOn cos (Icc 0 π) (Icc (-1) 1)
state_after: no goals
tactic: simpa only [cos_zero, cos_pi] using intermediate_value_Icc' pi_pos.le continuous_cos.continuousOn
Theorem: continuous_tsum
File: Mathlib/Analysis/NormedSpace/FunctionSeries.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
F : Type u_3
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : TopologicalSpace β
f : α → β → F
hf : ∀ (i : α), Continuous (f i)
hu : Summable u
hfu : ∀ (n : α) (x : β), ‖f n x‖ ≤ u n
⊢ Continuous fun x => ∑' (n : α), f n x
state_after: α : Type u_1
β : Type u_2
F : Type u_3
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : TopologicalSpace β
f : α → β → F
hu : Summable u
hfu : ∀ (n : α) (x : β), ‖f n x‖ ≤ u n
hf : ∀ (i : α), ContinuousOn (f i) univ
⊢ ContinuousOn (fun x => ∑' (n : α), f n x) univ
tactic: simp_rw [continuous_iff_continuousOn_univ] at hf ⊢
state_before: α : Type u_1
β : Type u_2
F : Type u_3
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : TopologicalSpace β
f : α → β → F
hu : Summable u
hfu : ∀ (n : α) (x : β), ‖f n x‖ ≤ u n
hf : ∀ (i : α), ContinuousOn (f i) univ
⊢ ContinuousOn (fun x => ∑' (n : α), f n x) univ
state_after: no goals
tactic: exact continuousOn_tsum hf hu fun n x _ => hfu n x
Theorem: inv_le_inv_of_le
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 < a
h : a ≤ b
⊢ b⁻¹ ≤ a⁻¹
state_after: no goals
tactic: rwa [← one_div a, le_div_iff' ha, ← div_eq_mul_inv, div_le_iff (ha.trans_le h), one_mul]
Theorem: MeasureTheory.SimpleFunc.range_const_subset
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : MeasurableSpace α✝
α : Type u_5
inst✝ : MeasurableSpace α
b : β
⊢ ↑(const α b).range ⊆ ↑{b}
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Presheaf.isSheaf_coherent_of_hasPullbacks_of_comp
File: Mathlib/CategoryTheory/Sites/Coherent/SheafComparison.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁶ : Category.{u_3, u_1} C
inst✝⁵ : Category.{?u.55818, u_2} D
F✝ : C ⥤ D
A : Type u₃
inst✝⁴ : Category.{v₃, u₃} A
F : Cᵒᵖ ⥤ A
B : Type u₄
inst✝³ : Category.{v₄, u₄} B
s : A ⥤ B
inst✝² : Preregular C
inst✝¹ : FinitaryExtensive C
h : ∀ {Y X : C} (f : Y ⟶ X) [inst : EffectiveEpi f], HasPullback f f
inst✝ : ReflectsFiniteLimits s
hF : IsSheaf (coherentTopology C) (F ⋙ s)
⊢ IsSheaf (coherentTopology C) F
state_after: C : Type u_1
D : Type u_2
inst✝⁶ : Category.{u_3, u_1} C
inst✝⁵ : Category.{?u.55818, u_2} D
F✝ : C ⥤ D
A : Type u₃
inst✝⁴ : Category.{v₃, u₃} A
F : Cᵒᵖ ⥤ A
B : Type u₄
inst✝³ : Category.{v₄, u₄} B
s : A ⥤ B
inst✝² : Preregular C
inst✝¹ : FinitaryExtensive C
h : ∀ {Y X : C} (f : Y ⟶ X) [inst : EffectiveEpi f], HasPullback f f
inst✝ : ReflectsFiniteLimits s
hF : Nonempty (PreservesFiniteProducts (F ⋙ s)) ∧ EqualizerCondition (F ⋙ s)
⊢ Nonempty (PreservesFiniteProducts F) ∧ EqualizerCondition F
tactic: rw [isSheaf_iff_preservesFiniteProducts_and_equalizerCondition (h := h)] at hF ⊢
state_before: C : Type u_1
D : Type u_2
inst✝⁶ : Category.{u_3, u_1} C
inst✝⁵ : Category.{?u.55818, u_2} D
F✝ : C ⥤ D
A : Type u₃
inst✝⁴ : Category.{v₃, u₃} A
F : Cᵒᵖ ⥤ A
B : Type u₄
inst✝³ : Category.{v₄, u₄} B
s : A ⥤ B
inst✝² : Preregular C
inst✝¹ : FinitaryExtensive C
h : ∀ {Y X : C} (f : Y ⟶ X) [inst : EffectiveEpi f], HasPullback f f
inst✝ : ReflectsFiniteLimits s
hF : Nonempty (PreservesFiniteProducts (F ⋙ s)) ∧ EqualizerCondition (F ⋙ s)
⊢ Nonempty (PreservesFiniteProducts F) ∧ EqualizerCondition F
state_after: case refine_1
C : Type u_1
D : Type u_2
inst✝⁶ : Category.{u_3, u_1} C
inst✝⁵ : Category.{?u.55818, u_2} D
F✝ : C ⥤ D
A : Type u₃
inst✝⁴ : Category.{v₃, u₃} A
F : Cᵒᵖ ⥤ A
B : Type u₄
inst✝³ : Category.{v₄, u₄} B
s : A ⥤ B
inst✝² : Preregular C
inst✝¹ : FinitaryExtensive C
h : ∀ {Y X : C} (f : Y ⟶ X) [inst : EffectiveEpi f], HasPullback f f
inst✝ : ReflectsFiniteLimits s
hF : Nonempty (PreservesFiniteProducts (F ⋙ s)) ∧ EqualizerCondition (F ⋙ s)
J : Type
x✝ : Fintype J
K : Discrete J ⥤ Cᵒᵖ
c : Cone K
hc : IsLimit c
⊢ IsLimit (F.mapCone c)

case refine_2
C : Type u_1
D : Type u_2
inst✝⁶ : Category.{u_3, u_1} C
inst✝⁵ : Category.{?u.55818, u_2} D
F✝ : C ⥤ D
A : Type u₃
inst✝⁴ : Category.{v₃, u₃} A
F : Cᵒᵖ ⥤ A
B : Type u₄
inst✝³ : Category.{v₄, u₄} B
s : A ⥤ B
inst✝² : Preregular C
inst✝¹ : FinitaryExtensive C
h : ∀ {Y X : C} (f : Y ⟶ X) [inst : EffectiveEpi f], HasPullback f f
inst✝ : ReflectsFiniteLimits s
hF : Nonempty (PreservesFiniteProducts (F ⋙ s)) ∧ EqualizerCondition (F ⋙ s)
x✝² x✝¹ : C
π : x✝² ⟶ x✝¹
x✝ : EffectiveEpi π
c : PullbackCone π π
hc : IsLimit c
⊢ IsLimit (Fork.ofι (F.map π.op) ⋯)
tactic: refine ⟨⟨⟨fun J _ ↦ ⟨fun {K} ↦ ⟨fun {c} hc ↦ ?_⟩⟩⟩⟩, fun _ _ π _ c hc ↦ ⟨?_⟩⟩
Theorem: SetTheory.PGame.relabel_moveRight
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
x : PGame
xl' xr' : Type u_1
el : xl' ≃ x.LeftMoves
er : xr' ≃ x.RightMoves
j : x.RightMoves
⊢ (relabel el er).moveRight (er.symm j) = x.moveRight j
state_after: no goals
tactic: simp
Theorem: heq_eqRec_iff_heq
File: .lake/packages/batteries/Batteries/Logic.lean

Proof steps:
state_before: α : Sort u_1
a : α
motive : (a' : α) → a = a' → Sort u_2
x : motive a ⋯
a' : α
e : a = a'
β : Sort u_2
y : β
⊢ HEq y (e ▸ x) ↔ HEq y x
state_after: α : Sort u_1
a : α
motive : (a' : α) → a = a' → Sort u_2
x : motive a ⋯
β : Sort u_2
y : β
⊢ HEq y (⋯ ▸ x) ↔ HEq y x
tactic: subst e
state_before: α : Sort u_1
a : α
motive : (a' : α) → a = a' → Sort u_2
x : motive a ⋯
β : Sort u_2
y : β
⊢ HEq y (⋯ ▸ x) ↔ HEq y x
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.Adjunction.map_restrictFullyFaithful_unit_app
File: Mathlib/CategoryTheory/Adjunction/Restrict.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
C' : Type u₃
inst✝¹ : Category.{v₃, u₃} C'
D' : Type u₄
inst✝ : Category.{v₄, u₄} D'
iC : C ⥤ C'
iD : D ⥤ D'
L' : C' ⥤ D'
R' : D' ⥤ C'
adj : L' ⊣ R'
hiC : iC.FullyFaithful
hiD : iD.FullyFaithful
L : C ⥤ D
R : D ⥤ C
comm1 : iC ⋙ L' ≅ L ⋙ iD
comm2 : iD ⋙ R' ≅ R ⋙ iC
X : C
⊢ iC.map ((adj.restrictFullyFaithful hiC hiD comm1 comm2).unit.app X) =
    adj.unit.app (iC.obj X) ≫ R'.map (comm1.hom.app X) ≫ comm2.hom.app (L.obj X)
state_after: no goals
tactic: simp [restrictFullyFaithful]
Theorem: abs_sub
File: Mathlib/Algebra/Order/Group/Abs.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c d a b : α
⊢ |a - b| ≤ |a| + |b|
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c d a b : α
⊢ |a + -b| ≤ |a| + |(-b)|
tactic: rw [sub_eq_add_neg, ← abs_neg b]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c d a b : α
⊢ |a + -b| ≤ |a| + |(-b)|
state_after: no goals
tactic: exact abs_add a _
Theorem: Filter.prod_atTop_atTop_eq
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
⊢ atTop ×ˢ atTop = atTop
state_after: case inl
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
h✝ : IsEmpty α
⊢ atTop ×ˢ atTop = atTop

case inr
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
h✝ : Nonempty α
⊢ atTop ×ˢ atTop = atTop
tactic: cases isEmpty_or_nonempty α
state_before: case inr
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
h✝ : Nonempty α
⊢ atTop ×ˢ atTop = atTop
state_after: case inr.inl
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
h✝¹ : Nonempty α
h✝ : IsEmpty β
⊢ atTop ×ˢ atTop = atTop

case inr.inr
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
h✝¹ : Nonempty α
h✝ : Nonempty β
⊢ atTop ×ˢ atTop = atTop
tactic: cases isEmpty_or_nonempty β
state_before: case inr.inr
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
h✝¹ : Nonempty α
h✝ : Nonempty β
⊢ atTop ×ˢ atTop = atTop
state_after: no goals
tactic: simpa [atTop, prod_iInf_left, prod_iInf_right, iInf_prod] using iInf_comm
Theorem: Polynomial.natTrailingDegree_eq_zero
File: Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ p.natTrailingDegree = 0 ↔ p = 0 ∨ p.coeff 0 ≠ 0
state_after: no goals
tactic: simp [natTrailingDegree, or_comm]
Theorem: partialSups_eq_biSup
File: Mathlib/Order/PartialSups.lean

Proof steps:
state_before: α : Type u_1
inst✝ : CompleteLattice α
f : ℕ → α
n : ℕ
⊢ (partialSups f) n = ⨆ i, ⨆ (_ : i ≤ n), f i
state_after: no goals
tactic: simpa only [iSup_subtype] using partialSups_eq_ciSup_Iic f n
Theorem: map_nhds_induced_of_mem
File: Mathlib/Topology/Order.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
t : TopologicalSpace β
f : α → β
a : α
h : range f ∈ 𝓝 (f a)
⊢ map f (𝓝 a) = 𝓝 (f a)
state_after: no goals
tactic: rw [nhds_induced, Filter.map_comap_of_mem h]
Theorem: tendsto_floor_left_pure_sub_one
File: Mathlib/Topology/Algebra/Order/Floor.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
n : ℤ
⊢ Tendsto floor (𝓝[<] ↑n) (pure (n - 1))
state_after: no goals
tactic: simpa only [ceil_intCast] using tendsto_floor_left_pure_ceil_sub_one (n : α)
Theorem: rank_fun
File: Mathlib/LinearAlgebra/Dimension/Constructions.lean

Proof steps:
state_before: R S : Type u
M✝ : Type v
M' : Type v'
M₁ : Type v
ι : Type w
ι' : Type w'
η✝ : Type u₁'
φ : η✝ → Type u_1
inst✝¹⁷ : Ring R
inst✝¹⁶ : CommRing S
inst✝¹⁵ : AddCommGroup M✝
inst✝¹⁴ : AddCommGroup M'
inst✝¹³ : AddCommGroup M₁
inst✝¹² : Module R M✝
inst✝¹¹ : Module R M'
inst✝¹⁰ : Module R M₁
inst✝⁹ : StrongRankCondition R
inst✝⁸ : Module.Free R M✝
inst✝⁷ : (i : η✝) → AddCommGroup (φ i)
inst✝⁶ : (i : η✝) → Module R (φ i)
inst✝⁵ : ∀ (i : η✝), Module.Free R (φ i)
inst✝⁴ : Fintype η✝
M η : Type u
inst✝³ : Fintype η
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : Module.Free R M
⊢ Module.rank R (η → M) = ↑(Fintype.card η) * Module.rank R M
state_after: no goals
tactic: rw [rank_pi, Cardinal.sum_const', Cardinal.mk_fintype]
Theorem: Cardinal.mk_finsupp_lift_of_infinite
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝² : Infinite α
inst✝¹ : Zero β
inst✝ : Nontrivial β
⊢ #(α →₀ β) = max (lift.{v, u} #α) (lift.{u, v} #β)
state_after: case a
α : Type u
β : Type v
inst✝² : Infinite α
inst✝¹ : Zero β
inst✝ : Nontrivial β
⊢ #(α →₀ β) ≤ max (lift.{v, u} #α) (lift.{u, v} #β)

case a
α : Type u
β : Type v
inst✝² : Infinite α
inst✝¹ : Zero β
inst✝ : Nontrivial β
⊢ max (lift.{v, u} #α) (lift.{u, v} #β) ≤ #(α →₀ β)
tactic: apply le_antisymm
Theorem: MeasureTheory.SimpleFunc.setToSimpleFunc_zero_apply
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m✝ : MeasurableSpace α
μ : Measure α
m : MeasurableSpace α
T : Set α → F →L[ℝ] F'
⊢ setToSimpleFunc T 0 = 0
state_after: no goals
tactic: cases isEmpty_or_nonempty α <;> simp [setToSimpleFunc]
Theorem: Fin.univ_image_get'
File: Mathlib/Data/Fintype/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq β
l : List α
f : α → β
⊢ image (fun x => f (l.get x)) univ = (List.map f l).toFinset
state_after: no goals
tactic: simp
Theorem: List.sublistsLenAux_eq
File: Mathlib/Data/List/Sublists.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
l : List α
n : ℕ
f : List α → β
r : List β
⊢ sublistsLenAux n l f r = map f (sublistsLen n l) ++ r
state_after: α : Type u
β : Type v
γ : Type w
l : List α
n : ℕ
f : List α → β
r : List β
⊢ sublistsLenAux n l f r = sublistsLenAux n l (f ∘ id) (map f [] ++ r)
tactic: rw [sublistsLen, ← sublistsLenAux_append]
state_before: α : Type u
β : Type v
γ : Type w
l : List α
n : ℕ
f : List α → β
r : List β
⊢ sublistsLenAux n l f r = sublistsLenAux n l (f ∘ id) (map f [] ++ r)
state_after: no goals
tactic: rfl
Theorem: _private.Mathlib.Data.Nat.Defs.0.Nat.AM_GM
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
x✝ : ℕ
⊢ 4 * 0 * x✝ ≤ (0 + x✝) * (0 + x✝)
state_after: a b c d m n k : ℕ
p q : ℕ → Prop
x✝ : ℕ
⊢ 0 ≤ (0 + x✝) * (0 + x✝)
tactic: rw [Nat.mul_zero, Nat.zero_mul]
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
x✝ : ℕ
⊢ 0 ≤ (0 + x✝) * (0 + x✝)
state_after: no goals
tactic: exact zero_le _
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
x✝ : ℕ
⊢ 4 * x✝ * 0 ≤ (x✝ + 0) * (x✝ + 0)
state_after: a b c d m n k : ℕ
p q : ℕ → Prop
x✝ : ℕ
⊢ 0 ≤ (x✝ + 0) * (x✝ + 0)
tactic: rw [Nat.mul_zero]
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
x✝ : ℕ
⊢ 0 ≤ (x✝ + 0) * (x✝ + 0)
state_after: no goals
tactic: exact zero_le _
state_before: a✝ b✝ c d m n k : ℕ
p q : ℕ → Prop
a b : ℕ
⊢ 4 * (a + 1) * (b + 1) ≤ (a + 1 + (b + 1)) * (a + 1 + (b + 1))
state_after: no goals
tactic: simpa only [Nat.mul_add, Nat.add_mul, show (4 : ℕ) = 1 + 1 + 1 + 1 from rfl, Nat.one_mul,
      Nat.mul_one, Nat.add_assoc, Nat.add_left_comm, Nat.add_le_add_iff_left]
      using Nat.add_le_add_right (@AM_GM a b) 4