ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: List.getLast_pmap
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Prop
f : (a : α) → p a → β
l : List α
hl₁ : ∀ (a : α), a ∈ l → p a
hl₂ : l ≠ []
⊢ (pmap f l hl₁).getLast ⋯ = f (l.getLast hl₂) ⋯
state_after: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Prop
f : (a : α) → p a → β
hl₁ : ∀ (a : α), a ∈ [] → p a
hl₂ : [] ≠ []
⊢ (pmap f [] hl₁).getLast ⋯ = f ([].getLast hl₂) ⋯

case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Prop
f : (a : α) → p a → β
l_hd : α
l_tl : List α
l_ih : ∀ (hl₁ : ∀ (a : α), a ∈ l_tl → p a) (hl₂ : l_tl ≠ []), (pmap f l_tl hl₁).getLast ⋯ = f (l_tl.getLast hl₂) ⋯
hl₁ : ∀ (a : α), a ∈ l_hd :: l_tl → p a
hl₂ : l_hd :: l_tl ≠ []
⊢ (pmap f (l_hd :: l_tl) hl₁).getLast ⋯ = f ((l_hd :: l_tl).getLast hl₂) ⋯
tactic: induction' l with l_hd l_tl l_ih
Theorem: CategoryTheory.Sieve.overEquiv_iff
File: Mathlib/CategoryTheory/Sites/Over.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X : C
Y : Over X
S : Sieve Y
Z : C
f : Z ⟶ Y.left
⊢ ((overEquiv Y) S).arrows f ↔ S.arrows (Over.homMk f ⋯)
state_after: case intro
C : Type u
inst✝ : Category.{v, u} C
X : C
Y : Over X
Z : C
f : Z ⟶ Y.left
S : Sieve Y.left
⊢ ((overEquiv Y) ((overEquiv Y).symm S)).arrows f ↔ ((overEquiv Y).symm S).arrows (Over.homMk f ⋯)
tactic: obtain ⟨S, rfl⟩ := (overEquiv Y).symm.surjective S
state_before: case intro
C : Type u
inst✝ : Category.{v, u} C
X : C
Y : Over X
Z : C
f : Z ⟶ Y.left
S : Sieve Y.left
⊢ ((overEquiv Y) ((overEquiv Y).symm S)).arrows f ↔ ((overEquiv Y).symm S).arrows (Over.homMk f ⋯)
state_after: no goals
tactic: simp
Theorem: frontier_compl
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s✝ s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
s : Set X
⊢ frontier sᶜ = frontier s
state_after: no goals
tactic: simp only [frontier_eq_closure_inter_closure, compl_compl, inter_comm]
Theorem: succChain_spec
File: Mathlib/Order/Chain.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
h : ∃ t, IsChain r s ∧ SuperChain r s t
⊢ SuperChain r s (SuccChain r s)
state_after: α : Type u_1
β : Type u_2
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
h : ∃ t, IsChain r s ∧ SuperChain r s t
this : IsChain r s ∧ SuperChain r s h.choose
⊢ SuperChain r s (SuccChain r s)
tactic: have : IsChain r s ∧ SuperChain r s h.choose := h.choose_spec
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
h : ∃ t, IsChain r s ∧ SuperChain r s t
this : IsChain r s ∧ SuperChain r s h.choose
⊢ SuperChain r s (SuccChain r s)
state_after: no goals
tactic: simpa [SuccChain, dif_pos, exists_and_left.mp h] using this.2
Theorem: CategoryTheory.Over.CreatesConnected.raiseCone_π_app
File: Mathlib/CategoryTheory/Limits/Constructions/Over/Connected.lean

Proof steps:
state_before: J : Type v
inst✝² : SmallCategory J
C : Type u
inst✝¹ : Category.{v, u} C
X : C
inst✝ : IsConnected J
B : C
F : J ⥤ Over B
c : Cone (F ⋙ forget B)
⊢ ∀ ⦃X Y : J⦄ (f : X ⟶ Y),
    ((Functor.const J).obj (mk (c.π.app (Classical.arbitrary J) ≫ (F.obj (Classical.arbitrary J)).hom))).map f ≫
        (fun j => homMk (c.π.app j) ⋯) Y =
      (fun j => homMk (c.π.app j) ⋯) X ≫ F.map f
state_after: J : Type v
inst✝² : SmallCategory J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ : C
inst✝ : IsConnected J
B : C
F : J ⥤ Over B
c : Cone (F ⋙ forget B)
X Y : J
f : X ⟶ Y
⊢ ((Functor.const J).obj (mk (c.π.app (Classical.arbitrary J) ≫ (F.obj (Classical.arbitrary J)).hom))).map f ≫
      (fun j => homMk (c.π.app j) ⋯) Y =
    (fun j => homMk (c.π.app j) ⋯) X ≫ F.map f
tactic: intro X Y f
state_before: J : Type v
inst✝² : SmallCategory J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ : C
inst✝ : IsConnected J
B : C
F : J ⥤ Over B
c : Cone (F ⋙ forget B)
X Y : J
f : X ⟶ Y
⊢ ((Functor.const J).obj (mk (c.π.app (Classical.arbitrary J) ≫ (F.obj (Classical.arbitrary J)).hom))).map f ≫
      (fun j => homMk (c.π.app j) ⋯) Y =
    (fun j => homMk (c.π.app j) ⋯) X ≫ F.map f
state_after: case left
J : Type v
inst✝² : SmallCategory J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ : C
inst✝ : IsConnected J
B : C
F : J ⥤ Over B
c : Cone (F ⋙ forget B)
X Y : J
f : X ⟶ Y
⊢ (((Functor.const J).obj (mk (c.π.app (Classical.arbitrary J) ≫ (F.obj (Classical.arbitrary J)).hom))).map f ≫
        (fun j => homMk (c.π.app j) ⋯) Y).left =
    ((fun j => homMk (c.π.app j) ⋯) X ≫ F.map f).left

case right
J : Type v
inst✝² : SmallCategory J
C : Type u
inst✝¹ : Category.{v, u} C
X✝ : C
inst✝ : IsConnected J
B : C
F : J ⥤ Over B
c : Cone (F ⋙ forget B)
X Y : J
f : X ⟶ Y
⊢ (((Functor.const J).obj (mk (c.π.app (Classical.arbitrary J) ≫ (F.obj (Classical.arbitrary J)).hom))).map f ≫
        (fun j => homMk (c.π.app j) ⋯) Y).right =
    ((fun j => homMk (c.π.app j) ⋯) X ≫ F.map f).right
tactic: apply CommaMorphism.ext
Theorem: Complex.sub_conj
File: Mathlib/Data/Complex/Basic.lean

Proof steps:
state_before: z : ℂ
⊢ (z - (starRingEnd ℂ) z).re = (↑(2 * z.im) * I).re ∧ (z - (starRingEnd ℂ) z).im = (↑(2 * z.im) * I).im
state_after: no goals
tactic: simp [two_mul, sub_eq_add_neg, ofReal']
Theorem: Set.exists_eq_const_of_preimage_singleton
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
g : β → γ
inst✝ : Nonempty β
f : α → β
hf : ∀ (b : β), f ⁻¹' {b} = ∅ ∨ f ⁻¹' {b} = univ
⊢ ∃ b, f = const α b
state_after: case inl.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
g : β → γ
inst✝ : Nonempty β
f : α → β
hf : ∀ (b : β), f ⁻¹' {b} = ∅ ∨ f ⁻¹' {b} = univ
b : β
hb : f ⁻¹' {b} = univ
⊢ ∃ b, f = const α b

case inr
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
g : β → γ
inst✝ : Nonempty β
f : α → β
hf : ∀ (b : β), f ⁻¹' {b} = ∅ ∨ f ⁻¹' {b} = univ
hf' : ¬∃ b, f ⁻¹' {b} = univ
⊢ ∃ b, f = const α b
tactic: rcases em (∃ b, f ⁻¹' {b} = univ) with ⟨b, hb⟩ | hf'
Theorem: spectrum.mem_resolventSet_of_left_right_inverse
File: Mathlib/Algebra/Algebra/Spectrum.lean

Proof steps:
state_before: R : Type u
A : Type v
inst✝² : CommSemiring R
inst✝¹ : Ring A
inst✝ : Algebra R A
r : R
a b c : A
h₁ : (↑ₐ r - a) * b = 1
h₂ : c * (↑ₐ r - a) = 1
⊢ b * (↑ₐ r - a) = 1
state_after: no goals
tactic: rwa [← left_inv_eq_right_inv h₂ h₁]
Theorem: Finset.prod_hom_rel
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝¹ : CommMonoid β
inst✝ : CommMonoid γ
r : β → γ → Prop
f : α → β
g : α → γ
s : Finset α
h₁ : r 1 1
h₂ : ∀ (a : α) (b : β) (c : γ), r b c → r (f a * b) (g a * c)
⊢ r (∏ x ∈ s, f x) (∏ x ∈ s, g x)
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝¹ : CommMonoid β
inst✝ : CommMonoid γ
r : β → γ → Prop
f : α → β
g : α → γ
s : Finset α
h₁ : r 1 1
h₂ : ∀ (a : α) (b : β) (c : γ), r b c → r (f a * b) (g a * c)
⊢ r (Multiset.map (fun x => f x) s.val).prod (Multiset.map (fun x => g x) s.val).prod
tactic: delta Finset.prod
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝¹ : CommMonoid β
inst✝ : CommMonoid γ
r : β → γ → Prop
f : α → β
g : α → γ
s : Finset α
h₁ : r 1 1
h₂ : ∀ (a : α) (b : β) (c : γ), r b c → r (f a * b) (g a * c)
⊢ r (Multiset.map (fun x => f x) s.val).prod (Multiset.map (fun x => g x) s.val).prod
state_after: no goals
tactic: apply Multiset.prod_hom_rel <;> assumption
Theorem: orderOf_eq_zero
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
h : ¬IsOfFinOrder x
⊢ orderOf x = 0
state_after: no goals
tactic: rwa [orderOf, minimalPeriod, dif_neg]
Theorem: Int.modEq_iff_dvd
File: Mathlib/Data/Int/ModEq.lean

Proof steps:
state_before: m n a b c d : ℤ
⊢ a ≡ b [ZMOD n] ↔ n ∣ b - a
state_after: m n a b c d : ℤ
⊢ b % n = a % n ↔ n ∣ b - a
tactic: rw [ModEq, eq_comm]
state_before: m n a b c d : ℤ
⊢ b % n = a % n ↔ n ∣ b - a
state_after: no goals
tactic: simp [emod_eq_emod_iff_emod_sub_eq_zero, dvd_iff_emod_eq_zero]
Theorem: CategoryTheory.Groupoid.vertexGroupIsomOfMap_symm_apply
File: Mathlib/CategoryTheory/Groupoid/VertexGroup.lean

Proof steps:
state_before: C : Type u
inst✝ : Groupoid C
c d : C
f : c ⟶ d
γ : c ⟶ c
⊢ (fun δ => f ≫ δ ≫ inv f) ((fun γ => inv f ≫ γ ≫ f) γ) = γ
state_after: no goals
tactic: simp_rw [Category.assoc, comp_inv, Category.comp_id, ← Category.assoc, comp_inv,
      Category.id_comp]
state_before: C : Type u
inst✝ : Groupoid C
c d : C
f : c ⟶ d
δ : d ⟶ d
⊢ (fun γ => inv f ≫ γ ≫ f) ((fun δ => f ≫ δ ≫ inv f) δ) = δ
state_after: no goals
tactic: simp_rw [Category.assoc, inv_comp, ← Category.assoc, inv_comp, Category.id_comp,
      Category.comp_id]
state_before: C : Type u
inst✝ : Groupoid C
c d : C
f : c ⟶ d
γ₁ γ₂ : c ⟶ c
⊢ { toFun := fun γ => inv f ≫ γ ≫ f, invFun := fun δ => f ≫ δ ≫ inv f, left_inv := ⋯, right_inv := ⋯ }.toFun (γ₁ * γ₂) =
    { toFun := fun γ => inv f ≫ γ ≫ f, invFun := fun δ => f ≫ δ ≫ inv f, left_inv := ⋯, right_inv := ⋯ }.toFun γ₁ *
      { toFun := fun γ => inv f ≫ γ ≫ f, invFun := fun δ => f ≫ δ ≫ inv f, left_inv := ⋯, right_inv := ⋯ }.toFun γ₂
state_after: no goals
tactic: simp only [vertexGroup_mul, inv_eq_inv, Category.assoc, IsIso.hom_inv_id_assoc]
Theorem: Finset.inter_filter
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
s✝ t✝ : Finset α
inst✝ : DecidableEq α
s t : Finset α
⊢ s ∩ filter p t = filter p (s ∩ t)
state_after: no goals
tactic: rw [inter_comm, filter_inter, inter_comm]
Theorem: _private.Mathlib.Analysis.MeanInequalities.0.NNReal.inner_le_Lp_mul_Lp_of_norm_le_one
File: Mathlib/Analysis/MeanInequalities.lean

Proof steps:
state_before: ι : Type u
s : Finset ι
f g : ι → ℝ≥0
p q : ℝ
hpq : p.IsConjExponent q
hf : ∑ i ∈ s, f i ^ p ≤ 1
hg : ∑ i ∈ s, g i ^ q ≤ 1
⊢ ∑ i ∈ s, f i * g i ≤ 1
state_after: ι : Type u
s : Finset ι
f g : ι → ℝ≥0
p q : ℝ
hpq : p.IsConjExponent q
hf : ∑ i ∈ s, f i ^ p ≤ 1
hg : ∑ i ∈ s, g i ^ q ≤ 1
hp_ne_zero : p.toNNReal ≠ 0
⊢ ∑ i ∈ s, f i * g i ≤ 1
tactic: have hp_ne_zero : Real.toNNReal p ≠ 0 := (zero_lt_one.trans hpq.toNNReal.one_lt).ne.symm
state_before: ι : Type u
s : Finset ι
f g : ι → ℝ≥0
p q : ℝ
hpq : p.IsConjExponent q
hf : ∑ i ∈ s, f i ^ p ≤ 1
hg : ∑ i ∈ s, g i ^ q ≤ 1
hp_ne_zero : p.toNNReal ≠ 0
⊢ ∑ i ∈ s, f i * g i ≤ 1
state_after: ι : Type u
s : Finset ι
f g : ι → ℝ≥0
p q : ℝ
hpq : p.IsConjExponent q
hf : ∑ i ∈ s, f i ^ p ≤ 1
hg : ∑ i ∈ s, g i ^ q ≤ 1
hp_ne_zero : p.toNNReal ≠ 0
hq_ne_zero : q.toNNReal ≠ 0
⊢ ∑ i ∈ s, f i * g i ≤ 1
tactic: have hq_ne_zero : Real.toNNReal q ≠ 0 := (zero_lt_one.trans hpq.toNNReal.symm.one_lt).ne.symm
Theorem: CategoryTheory.GradedObject.Monoidal.triangle
File: Mathlib/CategoryTheory/GradedObject/Monoidal.lean

Proof steps:
state_before: I : Type u
inst✝¹¹ : AddMonoid I
C : Type u_1
inst✝¹⁰ : Category.{u_2, u_1} C
inst✝⁹ : MonoidalCategory C
inst✝⁸ : DecidableEq I
inst✝⁷ : HasInitial C
inst✝⁶ : (X₁ : C) → PreservesColimit (Functor.empty C) ((curriedTensor C).obj X₁)
inst✝⁵ : (X₂ : C) → PreservesColimit (Functor.empty C) ((curriedTensor C).flip.obj X₂)
X₁ X₃ : GradedObject I C
inst✝⁴ : X₁.HasTensor X₃
inst✝³ : (tensorObj X₁ tensorUnit).HasTensor X₃
inst✝² : X₁.HasTensor (tensorObj tensorUnit X₃)
inst✝¹ : X₁.HasGoodTensor₁₂Tensor tensorUnit X₃
inst✝ : X₁.HasGoodTensorTensor₂₃ tensorUnit X₃
⊢ (associator X₁ tensorUnit X₃).hom ≫ tensorHom (𝟙 X₁) (leftUnitor X₃).hom = tensorHom (rightUnitor X₁).hom (𝟙 X₃)
state_after: no goals
tactic: convert mapBifunctor_triangle (curriedAssociatorNatIso C) (𝟙_ C)
    (rightUnitorNatIso C) (leftUnitorNatIso C) (triangleIndexData I) X₁ X₃ (by simp)
Theorem: HomologicalComplex.extend_d_to_eq_zero
File: Mathlib/Algebra/Homology/Embedding/Extend.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
C : Type u_3
inst✝² : Category.{u_4, u_3} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
K : HomologicalComplex C c
e : c.Embedding c'
i' j' : ι'
j : ι
hj : e.f j = j'
hj' : ¬c.Rel (c.prev j) j
⊢ (K.extend e).d i' j' = 0
state_after: case inl
ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
C : Type u_3
inst✝² : Category.{u_4, u_3} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
K : HomologicalComplex C c
e : c.Embedding c'
i' j' : ι'
j : ι
hj : e.f j = j'
hj' : ¬c.Rel (c.prev j) j
hi' : e.r i' = none
⊢ (K.extend e).d i' j' = 0

case inr.intro
ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
C : Type u_3
inst✝² : Category.{u_4, u_3} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
K : HomologicalComplex C c
e : c.Embedding c'
i' j' : ι'
j : ι
hj : e.f j = j'
hj' : ¬c.Rel (c.prev j) j
i : ι
hi : e.r i' = some i
⊢ (K.extend e).d i' j' = 0
tactic: obtain hi'|⟨i, hi⟩ := (e.r i').eq_none_or_eq_some
Theorem: Profinite.NobelingProof.term_ord_aux
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)
i : I
ho : ord I i < Ordinal.type fun x x_1 => x < x_1
⊢ term I ho = i
state_after: no goals
tactic: simp only [term, ord, Ordinal.enum_typein]
Theorem: MvPolynomial.map_injective
File: Mathlib/Algebra/MvPolynomial/Basic.lean

Proof steps:
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f : R →+* S₁
hf : Injective ⇑f
⊢ Injective ⇑(map f)
state_after: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q✝ : MvPolynomial σ R
f : R →+* S₁
hf : Injective ⇑f
p q : MvPolynomial σ R
h : (map f) p = (map f) q
⊢ p = q
tactic: intro p q h
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q✝ : MvPolynomial σ R
f : R →+* S₁
hf : Injective ⇑f
p q : MvPolynomial σ R
h : (map f) p = (map f) q
⊢ p = q
state_after: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q✝ : MvPolynomial σ R
f : R →+* S₁
hf : Injective ⇑f
p q : MvPolynomial σ R
h : ∀ (m : σ →₀ ℕ), f (coeff m p) = f (coeff m q)
⊢ ∀ (m : σ →₀ ℕ), coeff m p = coeff m q
tactic: simp only [MvPolynomial.ext_iff, coeff_map] at h ⊢
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q✝ : MvPolynomial σ R
f : R →+* S₁
hf : Injective ⇑f
p q : MvPolynomial σ R
h : ∀ (m : σ →₀ ℕ), f (coeff m p) = f (coeff m q)
⊢ ∀ (m : σ →₀ ℕ), coeff m p = coeff m q
state_after: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m✝ : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q✝ : MvPolynomial σ R
f : R →+* S₁
hf : Injective ⇑f
p q : MvPolynomial σ R
h : ∀ (m : σ →₀ ℕ), f (coeff m p) = f (coeff m q)
m : σ →₀ ℕ
⊢ coeff m p = coeff m q
tactic: intro m
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m✝ : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q✝ : MvPolynomial σ R
f : R →+* S₁
hf : Injective ⇑f
p q : MvPolynomial σ R
h : ∀ (m : σ →₀ ℕ), f (coeff m p) = f (coeff m q)
m : σ →₀ ℕ
⊢ coeff m p = coeff m q
state_after: no goals
tactic: exact hf (h m)
Theorem: covBy_iff_quot_is_simple
File: Mathlib/RingTheory/SimpleModule.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝⁵ : Ring R
inst✝⁴ : Ring S
M : Type u_4
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type u_5
inst✝¹ : AddCommGroup N
inst✝ : Module R N
A B : Submodule R M
hAB : A ≤ B
⊢ A ⋖ B ↔ IsSimpleModule R (↥B ⧸ Submodule.comap B.subtype A)
state_after: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝⁵ : Ring R
inst✝⁴ : Ring S
M : Type u_4
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type u_5
inst✝¹ : AddCommGroup N
inst✝ : Module R N
A B : Submodule R M
hAB : A ≤ B
f : Submodule R ↥B ≃o ↑(Set.Iic B) := B.mapIic
hf : f = B.mapIic
⊢ A ⋖ B ↔ IsSimpleModule R (↥B ⧸ Submodule.comap B.subtype A)
tactic: set f : Submodule R B ≃o Set.Iic B := B.mapIic with hf
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝⁵ : Ring R
inst✝⁴ : Ring S
M : Type u_4
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type u_5
inst✝¹ : AddCommGroup N
inst✝ : Module R N
A B : Submodule R M
hAB : A ≤ B
f : Submodule R ↥B ≃o ↑(Set.Iic B) := B.mapIic
hf : f = B.mapIic
⊢ A ⋖ B ↔ IsSimpleModule R (↥B ⧸ Submodule.comap B.subtype A)
state_after: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝⁵ : Ring R
inst✝⁴ : Ring S
M : Type u_4
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type u_5
inst✝¹ : AddCommGroup N
inst✝ : Module R N
A B : Submodule R M
hAB : A ≤ B
f : Submodule R ↥B ≃o ↑(Set.Iic B) := B.mapIic
hf : f = B.mapIic
⊢ IsCoatom ⟨A, hAB⟩ ↔ IsCoatom (B.mapIic (Submodule.comap B.subtype A))
tactic: rw [covBy_iff_coatom_Iic hAB, isSimpleModule_iff_isCoatom, ← OrderIso.isCoatom_iff f, hf]
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝⁵ : Ring R
inst✝⁴ : Ring S
M : Type u_4
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type u_5
inst✝¹ : AddCommGroup N
inst✝ : Module R N
A B : Submodule R M
hAB : A ≤ B
f : Submodule R ↥B ≃o ↑(Set.Iic B) := B.mapIic
hf : f = B.mapIic
⊢ IsCoatom ⟨A, hAB⟩ ↔ IsCoatom (B.mapIic (Submodule.comap B.subtype A))
state_after: no goals
tactic: simp [-OrderIso.isCoatom_iff, Submodule.map_comap_subtype, inf_eq_right.2 hAB]
Theorem: List.rotate_one_eq_self_iff_eq_replicate
File: Mathlib/Data/List/Rotate.lean

Proof steps:
state_before: α : Type u
inst✝ : Nonempty α
l : List α
h : l.rotate 1 = l
n✝ n : ℕ
hn : l.rotate n = l
⊢ l.rotate n.succ = l
state_after: no goals
tactic: rwa [Nat.succ_eq_add_one, ← l.rotate_rotate, hn]
Theorem: MeasureTheory.measure_integral_le_pos
File: Mathlib/MeasureTheory/Integral/Average.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ ν : Measure α
s t N : Set α
f : α → ℝ
inst✝ : IsProbabilityMeasure μ
hf : Integrable f μ
⊢ 0 < μ {x | ∫ (a : α), f a ∂μ ≤ f x}
state_after: no goals
tactic: simpa only [average_eq_integral] using
    measure_average_le_pos (IsProbabilityMeasure.ne_zero μ) hf
Theorem: eventuallyEq_zero_nhds
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
f✝ : X → Y
s : Set X
x : X
y : Y
M₀ : Type u_4
inst✝ : Zero M₀
f : X → M₀
⊢ f =ᶠ[𝓝 x] 0 ↔ x ∉ closure (Function.support f)
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
f✝ : X → Y
s : Set X
x : X
y : Y
M₀ : Type u_4
inst✝ : Zero M₀
f : X → M₀
⊢ {x | f x = 0 x} ∈ 𝓝 x ↔ {x | f x = 0} ∈ 𝓝 x
tactic: rw [← mem_compl_iff, ← interior_compl, mem_interior_iff_mem_nhds, Function.compl_support,
    EventuallyEq, eventually_iff]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
f✝ : X → Y
s : Set X
x : X
y : Y
M₀ : Type u_4
inst✝ : Zero M₀
f : X → M₀
⊢ {x | f x = 0 x} ∈ 𝓝 x ↔ {x | f x = 0} ∈ 𝓝 x
state_after: no goals
tactic: simp only [Pi.zero_apply]
Theorem: CategoryTheory.ShortComplex.HasLeftHomology.hasCokernel
File: Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
inst✝¹ : S.HasLeftHomology
inst✝ : HasKernel S.g
⊢ HasCokernel (kernel.lift S.g S.f ⋯)
state_after: C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
inst✝¹ : S.HasLeftHomology
inst✝ : HasKernel S.g
h : S.LeftHomologyData := S.leftHomologyData
⊢ HasCokernel (kernel.lift S.g S.f ⋯)
tactic: let h := S.leftHomologyData
state_before: C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
inst✝¹ : S.HasLeftHomology
inst✝ : HasKernel S.g
h : S.LeftHomologyData := S.leftHomologyData
⊢ HasCokernel (kernel.lift S.g S.f ⋯)
state_after: C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
inst✝¹ : S.HasLeftHomology
inst✝ : HasKernel S.g
h : S.LeftHomologyData := S.leftHomologyData
this : HasColimit (parallelPair h.f' 0)
⊢ HasCokernel (kernel.lift S.g S.f ⋯)
tactic: haveI : HasColimit (parallelPair h.f' 0) := ⟨⟨⟨_, h.hπ'⟩⟩⟩
state_before: C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
inst✝¹ : S.HasLeftHomology
inst✝ : HasKernel S.g
h : S.LeftHomologyData := S.leftHomologyData
this : HasColimit (parallelPair h.f' 0)
⊢ HasCokernel (kernel.lift S.g S.f ⋯)
state_after: C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
inst✝¹ : S.HasLeftHomology
inst✝ : HasKernel S.g
h : S.LeftHomologyData := S.leftHomologyData
this : HasColimit (parallelPair h.f' 0)
e : parallelPair (kernel.lift S.g S.f ⋯) 0 ≅ parallelPair h.f' 0 :=
  parallelPair.ext (Iso.refl ((parallelPair (kernel.lift S.g S.f ⋯) 0).obj WalkingParallelPair.zero))
    ((kernelIsKernel S.g).conePointUniqueUpToIso h.hi) ⋯ ⋯
⊢ HasCokernel (kernel.lift S.g S.f ⋯)
tactic: let e : parallelPair (kernel.lift S.g S.f S.zero) 0 ≅ parallelPair h.f' 0 :=
    parallelPair.ext (Iso.refl _) (IsLimit.conePointUniqueUpToIso (kernelIsKernel S.g) h.hi)
      (by aesop_cat) (by aesop_cat)
state_before: C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
inst✝¹ : S.HasLeftHomology
inst✝ : HasKernel S.g
h : S.LeftHomologyData := S.leftHomologyData
this : HasColimit (parallelPair h.f' 0)
e : parallelPair (kernel.lift S.g S.f ⋯) 0 ≅ parallelPair h.f' 0 :=
  parallelPair.ext (Iso.refl ((parallelPair (kernel.lift S.g S.f ⋯) 0).obj WalkingParallelPair.zero))
    ((kernelIsKernel S.g).conePointUniqueUpToIso h.hi) ⋯ ⋯
⊢ HasCokernel (kernel.lift S.g S.f ⋯)
state_after: no goals
tactic: exact hasColimitOfIso e
Theorem: discreteTopology_iff_orderTopology_of_pred_succ'
File: Mathlib/Topology/Instances/Discrete.lean

Proof steps:
state_before: α : Type u_1
inst✝⁵ : TopologicalSpace α
inst✝⁴ : PartialOrder α
inst✝³ : PredOrder α
inst✝² : SuccOrder α
inst✝¹ : NoMinOrder α
inst✝ : NoMaxOrder α
⊢ DiscreteTopology α ↔ OrderTopology α
state_after: case refine_1
α : Type u_1
inst✝⁵ : TopologicalSpace α
inst✝⁴ : PartialOrder α
inst✝³ : PredOrder α
inst✝² : SuccOrder α
inst✝¹ : NoMinOrder α
inst✝ : NoMaxOrder α
h : DiscreteTopology α
⊢ inst✝⁵ = generateFrom {s | ∃ a, s = Ioi a ∨ s = Iio a}

case refine_2
α : Type u_1
inst✝⁵ : TopologicalSpace α
inst✝⁴ : PartialOrder α
inst✝³ : PredOrder α
inst✝² : SuccOrder α
inst✝¹ : NoMinOrder α
inst✝ : NoMaxOrder α
h : OrderTopology α
⊢ inst✝⁵ = ⊥
tactic: refine ⟨fun h => ⟨?_⟩, fun h => ⟨?_⟩⟩