ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Profinite.NobelingProof.factors_prod_eq_basis
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

Proof steps:
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x : ↑(π C fun x => x ∈ s)
⊢ (factors C s x).prod = spanFinBasis C s x
state_after: case h
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x y : ↑(π C fun x => x ∈ s)
⊢ (factors C s x).prod y = (spanFinBasis C s x) y
tactic: ext y
state_before: case h
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x y : ↑(π C fun x => x ∈ s)
⊢ (factors C s x).prod y = (spanFinBasis C s x) y
state_after: case h
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x y : ↑(π C fun x => x ∈ s)
⊢ (factors C s x).prod y = if y = x then 1 else 0
tactic: dsimp [spanFinBasis]
state_before: case h
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x y : ↑(π C fun x => x ∈ s)
⊢ (factors C s x).prod y = if y = x then 1 else 0
state_after: no goals
tactic: split_ifs with h <;> [exact factors_prod_eq_basis_of_eq _ _ h;
    exact factors_prod_eq_basis_of_ne _ _ h]
Theorem: MeasureTheory.Measure.haar.mem_addPrehaar_empty
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

Proof steps:
state_before: G : Type u_1
inst✝¹ : Group G
inst✝ : TopologicalSpace G
K₀ : Set G
f : Compacts G → ℝ
⊢ f ∈ haarProduct K₀ ↔ ∀ (K : Compacts G), f K ∈ Icc 0 ↑(index (↑K) K₀)
state_after: no goals
tactic: simp only [haarProduct, Set.pi, forall_prop_of_true, mem_univ, mem_setOf_eq]
Theorem: Cardinal.card_biUnion_lt_iff_forall_of_isRegular
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

Proof steps:
state_before: α✝ : Type u_1
r : α✝ → α✝ → Prop
α β : Type u
s : Set α
t : (a : α) → a ∈ s → Set β
c : Cardinal.{u}
hc : c.IsRegular
hs : #↑s < c
⊢ #↑(⋃ a, ⋃ (h : a ∈ s), t a h) < c ↔ ∀ (a : α) (ha : a ∈ s), #↑(t a ha) < c
state_after: no goals
tactic: rw [biUnion_eq_iUnion, card_iUnion_lt_iff_forall_of_isRegular hc hs, SetCoe.forall']
Theorem: MeasureTheory.Measure.haar.prehaar_nonneg
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

Proof steps:
state_before: G : Type u_1
inst✝¹ : Group G
inst✝ : TopologicalSpace G
K₀ : PositiveCompacts G
U : Set G
K : Compacts G
⊢ 0 ≤ prehaar (↑K₀) U K
state_after: no goals
tactic: apply div_nonneg <;> norm_cast <;> apply zero_le
Theorem: Polynomial.X_mul
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ X * p = p * X
state_after: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
q : R[X]
toFinsupp✝ : R[ℕ]
⊢ X * { toFinsupp := toFinsupp✝ } = { toFinsupp := toFinsupp✝ } * X
tactic: rcases p with ⟨⟩
state_before: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
q : R[X]
toFinsupp✝ : R[ℕ]
⊢ X * { toFinsupp := toFinsupp✝ } = { toFinsupp := toFinsupp✝ } * X
state_after: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
q : R[X]
toFinsupp✝ : R[ℕ]
⊢ Finsupp.single 1 1 * toFinsupp✝ = toFinsupp✝ * Finsupp.single 1 1
tactic: simp only [X, ← ofFinsupp_single, ← ofFinsupp_mul, LinearMap.coe_mk, ofFinsupp.injEq]
state_before: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
q : R[X]
toFinsupp✝ : R[ℕ]
⊢ Finsupp.single 1 1 * toFinsupp✝ = toFinsupp✝ * Finsupp.single 1 1
state_after: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
q : R[X]
toFinsupp✝ : R[ℕ]
x✝ : ℕ
⊢ (Finsupp.single 1 1 * toFinsupp✝) x✝ = (toFinsupp✝ * Finsupp.single 1 1) x✝
tactic: refine Finsupp.ext fun _ => ?_
state_before: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
q : R[X]
toFinsupp✝ : R[ℕ]
x✝ : ℕ
⊢ (Finsupp.single 1 1 * toFinsupp✝) x✝ = (toFinsupp✝ * Finsupp.single 1 1) x✝
state_after: no goals
tactic: simp [AddMonoidAlgebra.mul_apply, AddMonoidAlgebra.sum_single_index, add_comm]
Theorem: Ordinal.cof_eq_sInf_lsub
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
⊢ o.cof = sInf {a | ∃ ι f, lsub f = o ∧ #ι = a}
state_after: case refine_1
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
⊢ ∀ b ∈ {a | ∃ ι f, lsub f = o ∧ #ι = a}, o.cof ≤ b

case refine_2
α : Type u_1
r : α → α → Prop
o : Ordinal.{u}
⊢ o.cof ∈ {a | ∃ ι f, lsub f = o ∧ #ι = a}
tactic: refine le_antisymm (le_csInf (cof_lsub_def_nonempty o) ?_) (csInf_le' ?_)
Theorem: Finset.insert_inter_of_mem
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u v : Finset α
a✝ b : α
s₁ s₂ : Finset α
a : α
h : a ∈ s₂
x : α
⊢ x ∈ insert a s₁ ∩ s₂ ↔ x ∈ insert a (s₁ ∩ s₂)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u v : Finset α
a✝ b : α
s₁ s₂ : Finset α
a : α
h : a ∈ s₂
x : α
this : x = a ∨ x ∈ s₂ ↔ x ∈ s₂
⊢ x ∈ insert a s₁ ∩ s₂ ↔ x ∈ insert a (s₁ ∩ s₂)
tactic: have : x = a ∨ x ∈ s₂ ↔ x ∈ s₂ := or_iff_right_of_imp <| by rintro rfl; exact h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u v : Finset α
a✝ b : α
s₁ s₂ : Finset α
a : α
h : a ∈ s₂
x : α
this : x = a ∨ x ∈ s₂ ↔ x ∈ s₂
⊢ x ∈ insert a s₁ ∩ s₂ ↔ x ∈ insert a (s₁ ∩ s₂)
state_after: no goals
tactic: simp only [mem_inter, mem_insert, or_and_left, this]
Theorem: CategoryTheory.GrothendieckTopology.preservesSheafification_iff_of_adjunctions
File: Mathlib/CategoryTheory/Sites/PreservesSheafification.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
J : GrothendieckTopology C
A : Type u_1
B : Type u_2
inst✝¹ : Category.{u_3, u_1} A
inst✝ : Category.{u_4, u_2} B
F : A ⥤ B
G₁ : (Cᵒᵖ ⥤ A) ⥤ Sheaf J A
adj₁ : G₁ ⊣ sheafToPresheaf J A
G₂ : (Cᵒᵖ ⥤ B) ⥤ Sheaf J B
adj₂ : G₂ ⊣ sheafToPresheaf J B
⊢ J.PreservesSheafification F ↔ ∀ (P : Cᵒᵖ ⥤ A), IsIso (G₂.map (whiskerRight (adj₁.unit.app P) F))
state_after: C : Type u
inst✝² : Category.{v, u} C
J : GrothendieckTopology C
A : Type u_1
B : Type u_2
inst✝¹ : Category.{u_3, u_1} A
inst✝ : Category.{u_4, u_2} B
F : A ⥤ B
G₁ : (Cᵒᵖ ⥤ A) ⥤ Sheaf J A
adj₁ : G₁ ⊣ sheafToPresheaf J A
G₂ : (Cᵒᵖ ⥤ B) ⥤ Sheaf J B
adj₂ : G₂ ⊣ sheafToPresheaf J B
⊢ J.PreservesSheafification F ↔ ∀ (P : Cᵒᵖ ⥤ A), J.W (whiskerRight (adj₁.unit.app P) F)
tactic: simp only [← J.W_iff_isIso_map_of_adjunction adj₂]
state_before: C : Type u
inst✝² : Category.{v, u} C
J : GrothendieckTopology C
A : Type u_1
B : Type u_2
inst✝¹ : Category.{u_3, u_1} A
inst✝ : Category.{u_4, u_2} B
F : A ⥤ B
G₁ : (Cᵒᵖ ⥤ A) ⥤ Sheaf J A
adj₁ : G₁ ⊣ sheafToPresheaf J A
G₂ : (Cᵒᵖ ⥤ B) ⥤ Sheaf J B
adj₂ : G₂ ⊣ sheafToPresheaf J B
⊢ J.PreservesSheafification F ↔ ∀ (P : Cᵒᵖ ⥤ A), J.W (whiskerRight (adj₁.unit.app P) F)
state_after: case mp
C : Type u
inst✝² : Category.{v, u} C
J : GrothendieckTopology C
A : Type u_1
B : Type u_2
inst✝¹ : Category.{u_3, u_1} A
inst✝ : Category.{u_4, u_2} B
F : A ⥤ B
G₁ : (Cᵒᵖ ⥤ A) ⥤ Sheaf J A
adj₁ : G₁ ⊣ sheafToPresheaf J A
G₂ : (Cᵒᵖ ⥤ B) ⥤ Sheaf J B
adj₂ : G₂ ⊣ sheafToPresheaf J B
⊢ J.PreservesSheafification F → ∀ (P : Cᵒᵖ ⥤ A), J.W (whiskerRight (adj₁.unit.app P) F)

case mpr
C : Type u
inst✝² : Category.{v, u} C
J : GrothendieckTopology C
A : Type u_1
B : Type u_2
inst✝¹ : Category.{u_3, u_1} A
inst✝ : Category.{u_4, u_2} B
F : A ⥤ B
G₁ : (Cᵒᵖ ⥤ A) ⥤ Sheaf J A
adj₁ : G₁ ⊣ sheafToPresheaf J A
G₂ : (Cᵒᵖ ⥤ B) ⥤ Sheaf J B
adj₂ : G₂ ⊣ sheafToPresheaf J B
⊢ (∀ (P : Cᵒᵖ ⥤ A), J.W (whiskerRight (adj₁.unit.app P) F)) → J.PreservesSheafification F
tactic: constructor
Theorem: Set.ext_iff
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u s t : Set α
h : s = t
x : α
⊢ x ∈ s ↔ x ∈ t
state_after: no goals
tactic: rw [h]
Theorem: Action.functorCategoryMonoidalEquivalence.μIso_inv_app
File: Mathlib/RepresentationTheory/Action/Monoidal.lean

Proof steps:
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
A B : Action V G
⊢ ((functorCategoryMonoidalEquivalence V G).μIso A B).inv.app PUnit.unit =
    𝟙 (((functorCategoryMonoidalEquivalence V G).obj (A ⊗ B)).obj PUnit.unit)
state_after: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
A B : Action V G
⊢ inv (((functorCategoryMonoidalEquivalence V G).μIso A B).app PUnit.unit).hom =
    𝟙 (((functorCategoryMonoidalEquivalence V G).obj (A ⊗ B)).obj PUnit.unit)
tactic: rw [← NatIso.app_inv, ← IsIso.Iso.inv_hom]
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
A B : Action V G
⊢ inv (((functorCategoryMonoidalEquivalence V G).μIso A B).app PUnit.unit).hom =
    𝟙 (((functorCategoryMonoidalEquivalence V G).obj (A ⊗ B)).obj PUnit.unit)
state_after: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
A B : Action V G
⊢ (((functorCategoryMonoidalEquivalence V G).μIso A B).app PUnit.unit).hom ≫
      𝟙 (((functorCategoryMonoidalEquivalence V G).obj (A ⊗ B)).obj PUnit.unit) =
    𝟙 (((functorCategoryMonoidalEquivalence V G).obj A ⊗ (functorCategoryMonoidalEquivalence V G).obj B).obj PUnit.unit)
tactic: refine IsIso.inv_eq_of_hom_inv_id ?_
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
A B : Action V G
⊢ (((functorCategoryMonoidalEquivalence V G).μIso A B).app PUnit.unit).hom ≫
      𝟙 (((functorCategoryMonoidalEquivalence V G).obj (A ⊗ B)).obj PUnit.unit) =
    𝟙 (((functorCategoryMonoidalEquivalence V G).obj A ⊗ (functorCategoryMonoidalEquivalence V G).obj B).obj PUnit.unit)
state_after: no goals
tactic: rw [Category.comp_id, NatIso.app_hom, MonoidalFunctor.μIso_hom,
    functorCategoryMonoidalEquivalence.μ_app]
Theorem: Bifunctor.fst_comp_snd
File: Mathlib/Control/Bifunctor.lean

Proof steps:
state_before: F : Type u₀ → Type u₁ → Type u₂
inst✝¹ : Bifunctor F
inst✝ : LawfulBifunctor F
α₀ α₁ : Type u₀
β₀ β₁ : Type u₁
f : α₀ → α₁
f' : β₀ → β₁
x : F α₀ β₀
⊢ fst f (snd f' x) = bimap f f' x
state_after: no goals
tactic: simp [fst, bimap_bimap]
Theorem: EReal.sign_eq_and_abs_eq_iff_eq
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: x y : EReal
⊢ x.abs = y.abs ∧ sign x = sign y ↔ x = y
state_after: case mp
x y : EReal
⊢ x.abs = y.abs ∧ sign x = sign y → x = y

case mpr
x y : EReal
⊢ x = y → x.abs = y.abs ∧ sign x = sign y
tactic: constructor
Theorem: FormalMultilinearSeries.le_comp_radius_of_summable
File: Mathlib/Analysis/Analytic/Composition.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
q : FormalMultilinearSeries 𝕜 F G
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0
hr : Summable fun i => ‖q.compAlongComposition p i.snd‖₊ * r ^ i.fst
⊢ ↑r ≤ (q.comp p).radius
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
q : FormalMultilinearSeries 𝕜 F G
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0
hr : Summable fun i => ‖q.compAlongComposition p i.snd‖₊ * r ^ i.fst
n : ℕ
⊢ ‖q.comp p n‖₊ * r ^ n ≤ ∑' (i : (n : ℕ) × Composition n), ‖q.compAlongComposition p i.snd‖₊ * r ^ i.fst
tactic: refine
    le_radius_of_bound_nnreal _
      (∑' i : Σ n, Composition n, ‖compAlongComposition q p i.snd‖₊ * r ^ i.fst) fun n => ?_
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
q : FormalMultilinearSeries 𝕜 F G
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0
hr : Summable fun i => ‖q.compAlongComposition p i.snd‖₊ * r ^ i.fst
n : ℕ
⊢ ‖q.comp p n‖₊ * r ^ n ≤ ∑' (i : (n : ℕ) × Composition n), ‖q.compAlongComposition p i.snd‖₊ * r ^ i.fst
state_after: no goals
tactic: calc
    ‖FormalMultilinearSeries.comp q p n‖₊ * r ^ n ≤
        ∑' c : Composition n, ‖compAlongComposition q p c‖₊ * r ^ n := by
      rw [tsum_fintype, ← Finset.sum_mul]
      exact mul_le_mul' (nnnorm_sum_le _ _) le_rfl
    _ ≤ ∑' i : Σ n : ℕ, Composition n, ‖compAlongComposition q p i.snd‖₊ * r ^ i.fst :=
      NNReal.tsum_comp_le_tsum_of_inj hr sigma_mk_injective
Theorem: not_bddAbove_iff'
File: Mathlib/Order/Bounds/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
s t : Set α
a b : α
⊢ ¬BddAbove s ↔ ∀ (x : α), ∃ y ∈ s, ¬y ≤ x
state_after: no goals
tactic: simp [BddAbove, upperBounds, Set.Nonempty]
Theorem: WithTop.isLUB_sSup
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLinearOrderBot α
s : Set (WithTop α)
⊢ IsLUB s (sSup s)
state_after: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLinearOrderBot α
s : Set (WithTop α)
hs : s = ∅
⊢ IsLUB s (sSup s)

case inr
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLinearOrderBot α
s : Set (WithTop α)
hs : s.Nonempty
⊢ IsLUB s (sSup s)
tactic: rcases s.eq_empty_or_nonempty with hs | hs
state_before: case inr
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLinearOrderBot α
s : Set (WithTop α)
hs : s.Nonempty
⊢ IsLUB s (sSup s)
state_after: no goals
tactic: exact isLUB_sSup' hs
Theorem: AddMonoidHom.compHom_apply_apply
File: Mathlib/Algebra/Group/Hom/Instances.lean

Proof steps:
state_before: M : Type uM
N : Type uN
P : Type uP
Q : Type uQ
inst✝² : MulOneClass M
inst✝¹ : CommMonoid N
inst✝ : CommMonoid P
⊢ (fun g => { toFun := g.comp, map_one' := ⋯, map_mul' := ⋯ }) 1 = 1
state_after: case h
M : Type uM
N : Type uN
P : Type uP
Q : Type uQ
inst✝² : MulOneClass M
inst✝¹ : CommMonoid N
inst✝ : CommMonoid P
f : M →* N
⊢ ((fun g => { toFun := g.comp, map_one' := ⋯, map_mul' := ⋯ }) 1) f = 1 f
tactic: ext1 f
state_before: case h
M : Type uM
N : Type uN
P : Type uP
Q : Type uQ
inst✝² : MulOneClass M
inst✝¹ : CommMonoid N
inst✝ : CommMonoid P
f : M →* N
⊢ ((fun g => { toFun := g.comp, map_one' := ⋯, map_mul' := ⋯ }) 1) f = 1 f
state_after: no goals
tactic: exact one_comp f
state_before: M : Type uM
N : Type uN
P : Type uP
Q : Type uQ
inst✝² : MulOneClass M
inst✝¹ : CommMonoid N
inst✝ : CommMonoid P
g₁ g₂ : N →* P
⊢ { toFun := fun g => { toFun := g.comp, map_one' := ⋯, map_mul' := ⋯ }, map_one' := ⋯ }.toFun (g₁ * g₂) =
    { toFun := fun g => { toFun := g.comp, map_one' := ⋯, map_mul' := ⋯ }, map_one' := ⋯ }.toFun g₁ *
      { toFun := fun g => { toFun := g.comp, map_one' := ⋯, map_mul' := ⋯ }, map_one' := ⋯ }.toFun g₂
state_after: case h
M : Type uM
N : Type uN
P : Type uP
Q : Type uQ
inst✝² : MulOneClass M
inst✝¹ : CommMonoid N
inst✝ : CommMonoid P
g₁ g₂ : N →* P
f : M →* N
⊢ ({ toFun := fun g => { toFun := g.comp, map_one' := ⋯, map_mul' := ⋯ }, map_one' := ⋯ }.toFun (g₁ * g₂)) f =
    ({ toFun := fun g => { toFun := g.comp, map_one' := ⋯, map_mul' := ⋯ }, map_one' := ⋯ }.toFun g₁ *
        { toFun := fun g => { toFun := g.comp, map_one' := ⋯, map_mul' := ⋯ }, map_one' := ⋯ }.toFun g₂)
      f
tactic: ext1 f
state_before: case h
M : Type uM
N : Type uN
P : Type uP
Q : Type uQ
inst✝² : MulOneClass M
inst✝¹ : CommMonoid N
inst✝ : CommMonoid P
g₁ g₂ : N →* P
f : M →* N
⊢ ({ toFun := fun g => { toFun := g.comp, map_one' := ⋯, map_mul' := ⋯ }, map_one' := ⋯ }.toFun (g₁ * g₂)) f =
    ({ toFun := fun g => { toFun := g.comp, map_one' := ⋯, map_mul' := ⋯ }, map_one' := ⋯ }.toFun g₁ *
        { toFun := fun g => { toFun := g.comp, map_one' := ⋯, map_mul' := ⋯ }, map_one' := ⋯ }.toFun g₂)
      f
state_after: no goals
tactic: exact mul_comp g₁ g₂ f
Theorem: Nat.divisors_prime_pow
File: Mathlib/NumberTheory/Divisors.lean

Proof steps:
state_before: n p : ℕ
pp : Prime p
k : ℕ
⊢ (p ^ k).divisors = map { toFun := fun x => p ^ x, inj' := ⋯ } (range (k + 1))
state_after: case a
n p : ℕ
pp : Prime p
k a : ℕ
⊢ a ∈ (p ^ k).divisors ↔ a ∈ map { toFun := fun x => p ^ x, inj' := ⋯ } (range (k + 1))
tactic: ext a
state_before: case a
n p : ℕ
pp : Prime p
k a : ℕ
⊢ a ∈ (p ^ k).divisors ↔ a ∈ map { toFun := fun x => p ^ x, inj' := ⋯ } (range (k + 1))
state_after: case a
n p : ℕ
pp : Prime p
k a : ℕ
⊢ (∃ j ≤ k, a = p ^ j) ↔ a ∈ map { toFun := fun x => p ^ x, inj' := ⋯ } (range (k + 1))
tactic: rw [mem_divisors_prime_pow pp]
state_before: case a
n p : ℕ
pp : Prime p
k a : ℕ
⊢ (∃ j ≤ k, a = p ^ j) ↔ a ∈ map { toFun := fun x => p ^ x, inj' := ⋯ } (range (k + 1))
state_after: no goals
tactic: simp [Nat.lt_succ, eq_comm]
Theorem: quasiIsoAt_iff_comp_left
File: Mathlib/Algebra/Homology/QuasiIso.lean

Proof steps:
state_before: ι : Type u_1
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
c : ComplexShape ι
K L M K' L' : HomologicalComplex C c
φ : K ⟶ L
φ' : L ⟶ M
i : ι
inst✝² : K.HasHomology i
inst✝¹ : L.HasHomology i
inst✝ : M.HasHomology i
hφ : QuasiIsoAt φ i
⊢ QuasiIsoAt (φ ≫ φ') i ↔ QuasiIsoAt φ' i
state_after: case mp
ι : Type u_1
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
c : ComplexShape ι
K L M K' L' : HomologicalComplex C c
φ : K ⟶ L
φ' : L ⟶ M
i : ι
inst✝² : K.HasHomology i
inst✝¹ : L.HasHomology i
inst✝ : M.HasHomology i
hφ : QuasiIsoAt φ i
⊢ QuasiIsoAt (φ ≫ φ') i → QuasiIsoAt φ' i

case mpr
ι : Type u_1
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
c : ComplexShape ι
K L M K' L' : HomologicalComplex C c
φ : K ⟶ L
φ' : L ⟶ M
i : ι
inst✝² : K.HasHomology i
inst✝¹ : L.HasHomology i
inst✝ : M.HasHomology i
hφ : QuasiIsoAt φ i
⊢ QuasiIsoAt φ' i → QuasiIsoAt (φ ≫ φ') i
tactic: constructor
Theorem: SetTheory.PGame.mul_moveRight_inl
File: Mathlib/SetTheory/Game/Basic.lean

Proof steps:
state_before: x y : PGame
i : x.LeftMoves
j : y.RightMoves
⊢ (x * y).moveRight (toRightMovesMul (Sum.inl (i, j))) =
    x.moveLeft i * y + x * y.moveRight j - x.moveLeft i * y.moveRight j
state_after: case mk
y : PGame
j : y.RightMoves
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : (mk α✝ β✝ a✝¹ a✝).LeftMoves
⊢ (mk α✝ β✝ a✝¹ a✝ * y).moveRight (toRightMovesMul (Sum.inl (i, j))) =
    (mk α✝ β✝ a✝¹ a✝).moveLeft i * y + mk α✝ β✝ a✝¹ a✝ * y.moveRight j - (mk α✝ β✝ a✝¹ a✝).moveLeft i * y.moveRight j
tactic: cases x
state_before: case mk
y : PGame
j : y.RightMoves
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : (mk α✝ β✝ a✝¹ a✝).LeftMoves
⊢ (mk α✝ β✝ a✝¹ a✝ * y).moveRight (toRightMovesMul (Sum.inl (i, j))) =
    (mk α✝ β✝ a✝¹ a✝).moveLeft i * y + mk α✝ β✝ a✝¹ a✝ * y.moveRight j - (mk α✝ β✝ a✝¹ a✝).moveLeft i * y.moveRight j
state_after: case mk.mk
α✝¹ β✝¹ : Type u_1
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
i : (mk α✝¹ β✝¹ a✝³ a✝²).LeftMoves
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
j : (mk α✝ β✝ a✝¹ a✝).RightMoves
⊢ (mk α✝¹ β✝¹ a✝³ a✝² * mk α✝ β✝ a✝¹ a✝).moveRight (toRightMovesMul (Sum.inl (i, j))) =
    (mk α✝¹ β✝¹ a✝³ a✝²).moveLeft i * mk α✝ β✝ a✝¹ a✝ + mk α✝¹ β✝¹ a✝³ a✝² * (mk α✝ β✝ a✝¹ a✝).moveRight j -
      (mk α✝¹ β✝¹ a✝³ a✝²).moveLeft i * (mk α✝ β✝ a✝¹ a✝).moveRight j
tactic: cases y
state_before: case mk.mk
α✝¹ β✝¹ : Type u_1
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
i : (mk α✝¹ β✝¹ a✝³ a✝²).LeftMoves
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
j : (mk α✝ β✝ a✝¹ a✝).RightMoves
⊢ (mk α✝¹ β✝¹ a✝³ a✝² * mk α✝ β✝ a✝¹ a✝).moveRight (toRightMovesMul (Sum.inl (i, j))) =
    (mk α✝¹ β✝¹ a✝³ a✝²).moveLeft i * mk α✝ β✝ a✝¹ a✝ + mk α✝¹ β✝¹ a✝³ a✝² * (mk α✝ β✝ a✝¹ a✝).moveRight j -
      (mk α✝¹ β✝¹ a✝³ a✝²).moveLeft i * (mk α✝ β✝ a✝¹ a✝).moveRight j
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.Localization.Construction.NatTransExtension.app_eq
File: Mathlib/CategoryTheory/Localization/Construction.lean

Proof steps:
state_before: C : Type uC
inst✝¹ : Category.{uC', uC} C
W : MorphismProperty C
D : Type uD
inst✝ : Category.{uD', uD} D
G : C ⥤ D
hG : W.IsInvertedBy G
F₁ F₂ : W.Localization ⥤ D
τ : W.Q ⋙ F₁ ⟶ W.Q ⋙ F₂
X : C
⊢ app τ (W.Q.obj X) = τ.app X
state_after: C : Type uC
inst✝¹ : Category.{uC', uC} C
W : MorphismProperty C
D : Type uD
inst✝ : Category.{uD', uD} D
G : C ⥤ D
hG : W.IsInvertedBy G
F₁ F₂ : W.Localization ⥤ D
τ : W.Q ⋙ F₁ ⟶ W.Q ⋙ F₂
X : C
⊢ τ.app ((objEquiv W).invFun (W.Q.obj X)) = τ.app X
tactic: simp only [app, eqToHom_refl, comp_id, id_comp]
state_before: C : Type uC
inst✝¹ : Category.{uC', uC} C
W : MorphismProperty C
D : Type uD
inst✝ : Category.{uD', uD} D
G : C ⥤ D
hG : W.IsInvertedBy G
F₁ F₂ : W.Localization ⥤ D
τ : W.Q ⋙ F₁ ⟶ W.Q ⋙ F₂
X : C
⊢ τ.app ((objEquiv W).invFun (W.Q.obj X)) = τ.app X
state_after: no goals
tactic: rfl
Theorem: Polynomial.mirror_trailingCoeff
File: Mathlib/Algebra/Polynomial/Mirror.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
p q : R[X]
⊢ p.mirror.trailingCoeff = p.leadingCoeff
state_after: no goals
tactic: rw [leadingCoeff, trailingCoeff, mirror_natTrailingDegree, coeff_mirror,
    revAt_le (Nat.le_add_left _ _), add_tsub_cancel_right]
Theorem: dist_le_zero
File: Mathlib/Topology/MetricSpace/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
γ : Type w
inst✝ : MetricSpace γ
x y : γ
⊢ dist x y ≤ 0 ↔ x = y
state_after: no goals
tactic: simpa [le_antisymm_iff, dist_nonneg] using @dist_eq_zero _ _ x y
Theorem: Isometry.antilipschitz
File: Mathlib/Topology/MetricSpace/Isometry.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
f : α → β
x✝ y✝ z : α
s : Set α
h : Isometry f
x y : α
⊢ edist x y ≤ ↑1 * edist (f x) (f y)
state_after: no goals
tactic: simp only [h x y, ENNReal.coe_one, one_mul, le_refl]
Theorem: TensorProduct.directLimitRight_tmul_of
File: Mathlib/LinearAlgebra/TensorProduct/DirectLimit.lean

Proof steps:
state_before: R : Type u_1
inst✝⁷ : CommRing R
ι : Type u_2
inst✝⁶ : DecidableEq ι
inst✝⁵ : Preorder ι
G : ι → Type u_3
inst✝⁴ : (i : ι) → AddCommGroup (G i)
inst✝³ : (i : ι) → Module R (G i)
f : (i j : ι) → i ≤ j → G i →ₗ[R] G j
M : Type u_4
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
i : ι
m : M
g : G i
⊢ (directLimitRight f M) (m ⊗ₜ[R] (of R ι G f i) g) =
    (of R ι (fun x => M ⊗[R] G x) (fun i j h => LinearMap.lTensor M (f i j h)) i) (m ⊗ₜ[R] g)
state_after: no goals
tactic: simp [directLimitRight, congr_apply_of]
Theorem: HahnSeries.single.addMonoidHom_apply_coeff
File: Mathlib/RingTheory/HahnSeries/Addition.lean

Proof steps:
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
a : Γ
x y : R
⊢ __src✝.toFun (x + y) = __src✝.toFun x + __src✝.toFun y
state_after: case coeff.h
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
a : Γ
x y : R
b : Γ
⊢ (__src✝.toFun (x + y)).coeff b = (__src✝.toFun x + __src✝.toFun y).coeff b
tactic: ext b
state_before: case coeff.h
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddMonoid R
a : Γ
x y : R
b : Γ
⊢ (__src✝.toFun (x + y)).coeff b = (__src✝.toFun x + __src✝.toFun y).coeff b
state_after: no goals
tactic: by_cases h : b = a <;> simp [h]
Theorem: Set.infinite_of_finite_compl
File: Mathlib/Data/Set/Finite.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s✝ t : Set α
inst✝ : Infinite α
s : Set α
hs : sᶜ.Finite
h : s.Finite
⊢ univ.Finite
state_after: no goals
tactic: simpa using hs.union h