ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Functor.toPreimages_nonempty_of_surjective
File: Mathlib/CategoryTheory/CofilteredSystem.lean

Proof steps:
state_before: J : Type u
inst✝¹ : Category.{u_1, u} J
F : J ⥤ Type v
i j✝ k : J
s : Set (F.obj i)
inst✝ : IsCofilteredOrEmpty J
hFn : ∀ (j : J), Nonempty (F.obj j)
Fsur : ∀ ⦃i j : J⦄ (f : i ⟶ j), Function.Surjective (F.map f)
hs : s.Nonempty
j : J
⊢ Nonempty ((F.toPreimages s).obj j)
state_after: J : Type u
inst✝¹ : Category.{u_1, u} J
F : J ⥤ Type v
i j✝ k : J
s : Set (F.obj i)
inst✝ : IsCofilteredOrEmpty J
hFn : ∀ (j : J), Nonempty (F.obj j)
Fsur : ∀ ⦃i j : J⦄ (f : i ⟶ j), Function.Surjective (F.map f)
hs : s.Nonempty
j : J
⊢ ∃ x, ∀ (i_1 : j ⟶ i), F.map i_1 x ∈ s
tactic: simp only [toPreimages_obj, nonempty_coe_sort, nonempty_iInter, mem_preimage]
state_before: J : Type u
inst✝¹ : Category.{u_1, u} J
F : J ⥤ Type v
i j✝ k : J
s : Set (F.obj i)
inst✝ : IsCofilteredOrEmpty J
hFn : ∀ (j : J), Nonempty (F.obj j)
Fsur : ∀ ⦃i j : J⦄ (f : i ⟶ j), Function.Surjective (F.map f)
hs : s.Nonempty
j : J
⊢ ∃ x, ∀ (i_1 : j ⟶ i), F.map i_1 x ∈ s
state_after: case inl
J : Type u
inst✝¹ : Category.{u_1, u} J
F : J ⥤ Type v
i j✝ k : J
s : Set (F.obj i)
inst✝ : IsCofilteredOrEmpty J
hFn : ∀ (j : J), Nonempty (F.obj j)
Fsur : ∀ ⦃i j : J⦄ (f : i ⟶ j), Function.Surjective (F.map f)
hs : s.Nonempty
j : J
h : IsEmpty (j ⟶ i)
⊢ ∃ x, ∀ (i_1 : j ⟶ i), F.map i_1 x ∈ s

case inr.intro
J : Type u
inst✝¹ : Category.{u_1, u} J
F : J ⥤ Type v
i j✝ k : J
s : Set (F.obj i)
inst✝ : IsCofilteredOrEmpty J
hFn : ∀ (j : J), Nonempty (F.obj j)
Fsur : ∀ ⦃i j : J⦄ (f : i ⟶ j), Function.Surjective (F.map f)
hs : s.Nonempty
j : J
ji : j ⟶ i
⊢ ∃ x, ∀ (i_1 : j ⟶ i), F.map i_1 x ∈ s
tactic: obtain h | ⟨⟨ji⟩⟩ := isEmpty_or_nonempty (j ⟶ i)
Theorem: CategoryTheory.ShortComplex.unop_X₃
File: Mathlib/Algebra/Homology/ShortComplex/Basic.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.60429, u_1} C
inst✝² : Category.{?u.60433, u_2} D
inst✝¹ : HasZeroMorphisms C
S✝ S₁ S₂ S₃ : ShortComplex C
inst✝ : HasZeroMorphisms D
S : ShortComplex Cᵒᵖ
⊢ S.g.unop ≫ S.f.unop = 0
state_after: C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.60429, u_1} C
inst✝² : Category.{?u.60433, u_2} D
inst✝¹ : HasZeroMorphisms C
S✝ S₁ S₂ S₃ : ShortComplex C
inst✝ : HasZeroMorphisms D
S : ShortComplex Cᵒᵖ
⊢ Quiver.Hom.unop 0 = 0
tactic: simp only [← unop_comp, S.zero]
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.60429, u_1} C
inst✝² : Category.{?u.60433, u_2} D
inst✝¹ : HasZeroMorphisms C
S✝ S₁ S₂ S₃ : ShortComplex C
inst✝ : HasZeroMorphisms D
S : ShortComplex Cᵒᵖ
⊢ Quiver.Hom.unop 0 = 0
state_after: no goals
tactic: rfl
Theorem: reesAlgebra.monomial_mem
File: Mathlib/RingTheory/ReesAlgebra.lean

Proof steps:
state_before: R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I✝ I : Ideal R
i : ℕ
r : R
⊢ (monomial i) r ∈ reesAlgebra I ↔ r ∈ I ^ i
state_after: no goals
tactic: simp (config := { contextual := true }) [mem_reesAlgebra_iff_support, coeff_monomial, ←
    imp_iff_not_or]
Theorem: Finset.disjoint_filter_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✝ s t : Finset α
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : _root_.Disjoint p q
⊢ _root_.Disjoint (filter p s) (filter q t)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
p✝ q✝ : α → Prop
inst✝³ : DecidablePred p✝
inst✝² : DecidablePred q✝
s✝ t✝ s t : Finset α
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : _root_.Disjoint p q
⊢ ∀ ⦃a : α⦄, a ∈ s ∧ p a → ¬(a ∈ t ∧ q a)
tactic: simp_rw [disjoint_left, mem_filter]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p✝ q✝ : α → Prop
inst✝³ : DecidablePred p✝
inst✝² : DecidablePred q✝
s✝ t✝ s t : Finset α
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : _root_.Disjoint p q
⊢ ∀ ⦃a : α⦄, a ∈ s ∧ p a → ¬(a ∈ t ∧ q a)
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
p✝ q✝ : α → Prop
inst✝³ : DecidablePred p✝
inst✝² : DecidablePred q✝
s✝ t✝ s t : Finset α
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : _root_.Disjoint p q
a : α
left✝¹ : a ∈ s
hp : p a
left✝ : a ∈ t
hq : q a
⊢ False
tactic: rintro a ⟨_, hp⟩ ⟨_, hq⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
p✝ q✝ : α → Prop
inst✝³ : DecidablePred p✝
inst✝² : DecidablePred q✝
s✝ t✝ s t : Finset α
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : _root_.Disjoint p q
a : α
left✝¹ : a ∈ s
hp : p a
left✝ : a ∈ t
hq : q a
⊢ False
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
p✝ q✝ : α → Prop
inst✝³ : DecidablePred p✝
inst✝² : DecidablePred q✝
s✝ t✝ s t : Finset α
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : ∀ (i : α), _root_.Disjoint (p i) (q i)
a : α
left✝¹ : a ∈ s
hp : p a
left✝ : a ∈ t
hq : q a
⊢ False
tactic: rw [Pi.disjoint_iff] at h
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
p✝ q✝ : α → Prop
inst✝³ : DecidablePred p✝
inst✝² : DecidablePred q✝
s✝ t✝ s t : Finset α
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : ∀ (i : α), _root_.Disjoint (p i) (q i)
a : α
left✝¹ : a ∈ s
hp : p a
left✝ : a ∈ t
hq : q a
⊢ False
state_after: no goals
tactic: simpa [hp, hq] using h a
Theorem: HahnSeries.SummableFamily.support_hsum_subset
File: Mathlib/RingTheory/HahnSeries/Summable.lean

Proof steps:
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddCommMonoid R
α : Type u_3
s : SummableFamily Γ R α
g : Γ
hg : g ∈ s.hsum.support
⊢ g ∈ ⋃ a, (s a).support
state_after: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddCommMonoid R
α : Type u_3
s : SummableFamily Γ R α
g : Γ
hg : ∑ i ∈ ⋯.toFinset, (s i).coeff g ≠ 0
⊢ g ∈ ⋃ a, (s a).support
tactic: rw [mem_support, hsum_coeff, finsum_eq_sum _ (s.finite_co_support _)] at hg
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddCommMonoid R
α : Type u_3
s : SummableFamily Γ R α
g : Γ
hg : ∑ i ∈ ⋯.toFinset, (s i).coeff g ≠ 0
⊢ g ∈ ⋃ a, (s a).support
state_after: case intro.intro
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddCommMonoid R
α : Type u_3
s : SummableFamily Γ R α
g : Γ
hg : ∑ i ∈ ⋯.toFinset, (s i).coeff g ≠ 0
a : α
left✝ : a ∈ ⋯.toFinset
h2 : (s a).coeff g ≠ 0
⊢ g ∈ ⋃ a, (s a).support
tactic: obtain ⟨a, _, h2⟩ := exists_ne_zero_of_sum_ne_zero hg
state_before: case intro.intro
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddCommMonoid R
α : Type u_3
s : SummableFamily Γ R α
g : Γ
hg : ∑ i ∈ ⋯.toFinset, (s i).coeff g ≠ 0
a : α
left✝ : a ∈ ⋯.toFinset
h2 : (s a).coeff g ≠ 0
⊢ g ∈ ⋃ a, (s a).support
state_after: case intro.intro
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddCommMonoid R
α : Type u_3
s : SummableFamily Γ R α
g : Γ
hg : ∑ i ∈ ⋯.toFinset, (s i).coeff g ≠ 0
a : α
left✝ : a ∈ ⋯.toFinset
h2 : (s a).coeff g ≠ 0
⊢ ∃ i, g ∈ (s i).support
tactic: rw [Set.mem_iUnion]
state_before: case intro.intro
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : AddCommMonoid R
α : Type u_3
s : SummableFamily Γ R α
g : Γ
hg : ∑ i ∈ ⋯.toFinset, (s i).coeff g ≠ 0
a : α
left✝ : a ∈ ⋯.toFinset
h2 : (s a).coeff g ≠ 0
⊢ ∃ i, g ∈ (s i).support
state_after: no goals
tactic: exact ⟨a, h2⟩
Theorem: Seminorm.mem_ball_zero
File: Mathlib/Analysis/Seminorm.lean

Proof steps:
state_before: R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : SMul 𝕜 E
p : Seminorm 𝕜 E
x y : E
r : ℝ
⊢ y ∈ p.ball 0 r ↔ p y < r
state_after: no goals
tactic: rw [mem_ball, sub_zero]
Theorem: Polynomial.coeff_coe_units_zero_ne_zero
File: Mathlib/Algebra/Polynomial/RingDivision.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
u : R[X]ˣ
⊢ (↑u).coeff 0 ≠ 0
state_after: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
u : R[X]ˣ
⊢ (↑u).coeff (↑u).natDegree ≠ 0
tactic: conv in 0 => rw [← natDegree_coe_units u]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
u : R[X]ˣ
⊢ (↑u).coeff (↑u).natDegree ≠ 0
state_after: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
u : R[X]ˣ
⊢ ¬↑u = 0
tactic: rw [← leadingCoeff, Ne, leadingCoeff_eq_zero]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
u : R[X]ˣ
⊢ ¬↑u = 0
state_after: no goals
tactic: exact Units.ne_zero _
Theorem: HomologicalComplex.singleMapHomologicalComplex_hom_app_ne
File: Mathlib/Algebra/Homology/Additive.lean

Proof steps:
state_before: ι : Type u_1
V : Type u
inst✝¹¹ : Category.{v, u} V
inst✝¹⁰ : Preadditive V
W : Type u_2
inst✝⁹ : Category.{?u.139827, u_2} W
inst✝⁸ : Preadditive W
W₁ : Type u_3
W₂ : Type u_4
inst✝⁷ : Category.{u_6, u_3} W₁
inst✝⁶ : Category.{u_5, u_4} W₂
inst✝⁵ : HasZeroMorphisms W₁
inst✝⁴ : HasZeroMorphisms W₂
c✝ : ComplexShape ι
C D E : HomologicalComplex V c✝
f g : C ⟶ D
h✝ k : D ⟶ E
i✝ : ι
inst✝³ : HasZeroObject W₁
inst✝² : HasZeroObject W₂
F : W₁ ⥤ W₂
inst✝¹ : F.PreservesZeroMorphisms
c : ComplexShape ι
inst✝ : DecidableEq ι
i j : ι
h : i ≠ j
X : W₁
⊢ ((singleMapHomologicalComplex F c j).hom.app X).f i = 0
state_after: no goals
tactic: simp [singleMapHomologicalComplex, h]
Theorem: CategoryTheory.StrongOplaxNatTrans.whiskerRight_naturality_comp
File: Mathlib/CategoryTheory/Bicategory/NaturalTransformation/Strong.lean

Proof steps:
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H : OplaxFunctor B C
η : StrongOplaxNatTrans F G
θ : StrongOplaxNatTrans G H
a b c : B
a' : C
f : a ⟶ b
g : b ⟶ c
h : G.obj c ⟶ a'
⊢ (η.naturality (f ≫ g)).hom ▷ h ≫ (α_ (η.app a) (G.map (f ≫ g)) h).hom ≫ η.app a ◁ G.mapComp f g ▷ h =
    F.mapComp f g ▷ η.app c ▷ h ≫
      (α_ (F.map f) (F.map g) (η.app c)).hom ▷ h ≫
        (α_ (F.map f) (F.map g ≫ η.app c) h).hom ≫
          F.map f ◁ (η.naturality g).hom ▷ h ≫
            (α_ (F.map f) (η.app b ≫ G.map g) h).inv ≫
              (α_ (F.map f) (η.app b) (G.map g)).inv ▷ h ≫
                (η.naturality f).hom ▷ G.map g ▷ h ≫
                  (α_ (η.app a) (G.map f) (G.map g)).hom ▷ h ≫ (α_ (η.app a) (G.map f ≫ G.map g) h).hom
state_after: no goals
tactic: apply η.toOplax.whiskerRight_naturality_comp
Theorem: zero_cpow_eq_nhds
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

Proof steps:
state_before: α : Type u_1
b : ℂ
hb : b ≠ 0
⊢ (fun x => 0 ^ x) =ᶠ[𝓝 b] 0
state_after: α : Type u_1
b : ℂ
hb : b ≠ 0
⊢ ∀ᶠ (x : ℂ) in 𝓝 b, x ≠ 0
tactic: suffices ∀ᶠ x : ℂ in 𝓝 b, x ≠ 0 from
    this.mono fun x hx ↦ by
      dsimp only
      rw [zero_cpow hx, Pi.zero_apply]
state_before: α : Type u_1
b : ℂ
hb : b ≠ 0
⊢ ∀ᶠ (x : ℂ) in 𝓝 b, x ≠ 0
state_after: no goals
tactic: exact IsOpen.eventually_mem isOpen_ne hb
Theorem: Holor.cast_type
File: Mathlib/Data/Holor.lean

Proof steps:
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
eq : ds₁ = ds₂
a : Holor α ds₁
⊢ cast ⋯ a = fun t => a (cast ⋯ t)
state_after: α : Type
d : ℕ
ds ds₁ ds₃ : List ℕ
a : Holor α ds₁
⊢ cast ⋯ a = fun t => a (cast ⋯ t)
tactic: subst eq
state_before: α : Type
d : ℕ
ds ds₁ ds₃ : List ℕ
a : Holor α ds₁
⊢ cast ⋯ a = fun t => a (cast ⋯ t)
state_after: no goals
tactic: rfl
Theorem: Fin.le_val_last
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
i : Fin (n + 1)
⊢ i ≤ ↑n
state_after: n m : ℕ
i : Fin (n + 1)
⊢ i ≤ last n
tactic: rw [Fin.natCast_eq_last]
state_before: n m : ℕ
i : Fin (n + 1)
⊢ i ≤ last n
state_after: no goals
tactic: exact Fin.le_last i
Theorem: Part.get_eq_get_of_eq
File: Mathlib/Data/Part.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a : Part α
ha : a.Dom
b : Part α
h : a = b
⊢ a.get ha = b.get ⋯
state_after: no goals
tactic: congr
Theorem: Associates.mem_factors_iff_dvd
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a p : α
ha0 : a ≠ 0
hp : Irreducible p
⊢ Associates.mk p ∈ (Associates.mk a).factors ↔ p ∣ a
state_after: case mp
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a p : α
ha0 : a ≠ 0
hp : Irreducible p
⊢ Associates.mk p ∈ (Associates.mk a).factors → p ∣ a

case mpr
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a p : α
ha0 : a ≠ 0
hp : Irreducible p
⊢ p ∣ a → Associates.mk p ∈ (Associates.mk a).factors
tactic: constructor
Theorem: YoungDiagram.col_eq_prod
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

Proof steps:
state_before: μ : YoungDiagram
j : ℕ
⊢ μ.col j = Finset.range (μ.colLen j) ×ˢ {j}
state_after: case a.mk
μ : YoungDiagram
j a b : ℕ
⊢ (a, b) ∈ μ.col j ↔ (a, b) ∈ Finset.range (μ.colLen j) ×ˢ {j}
tactic: ext ⟨a, b⟩
state_before: case a.mk
μ : YoungDiagram
j a b : ℕ
⊢ (a, b) ∈ μ.col j ↔ (a, b) ∈ Finset.range (μ.colLen j) ×ˢ {j}
state_after: case a.mk
μ : YoungDiagram
j a b : ℕ
⊢ b = j → (a < μ.colLen b ↔ a < μ.colLen j)
tactic: simp only [Finset.mem_product, Finset.mem_singleton, Finset.mem_range, mem_col_iff,
    mem_iff_lt_colLen, and_comm, and_congr_right_iff]
state_before: case a.mk
μ : YoungDiagram
j a b : ℕ
⊢ b = j → (a < μ.colLen b ↔ a < μ.colLen j)
state_after: case a.mk
μ : YoungDiagram
a b : ℕ
⊢ a < μ.colLen b ↔ a < μ.colLen b
tactic: rintro rfl
state_before: case a.mk
μ : YoungDiagram
a b : ℕ
⊢ a < μ.colLen b ↔ a < μ.colLen b
state_after: no goals
tactic: rfl
Theorem: Int.Ioc_filter_dvd_eq
File: Mathlib/Data/Int/CardIntervalMod.lean

Proof steps:
state_before: a b r : ℤ
hr : 0 < r
⊢ filter (fun x => r ∣ x) (Ioc a b) = map { toFun := fun x => x * r, inj' := ⋯ } (Ioc ⌊↑a / ↑r⌋ ⌊↑b / ↑r⌋)
state_after: case a
a b r : ℤ
hr : 0 < r
x : ℤ
⊢ x ∈ filter (fun x => r ∣ x) (Ioc a b) ↔ x ∈ map { toFun := fun x => x * r, inj' := ⋯ } (Ioc ⌊↑a / ↑r⌋ ⌊↑b / ↑r⌋)
tactic: ext x
state_before: case a
a b r : ℤ
hr : 0 < r
x : ℤ
⊢ x ∈ filter (fun x => r ∣ x) (Ioc a b) ↔ x ∈ map { toFun := fun x => x * r, inj' := ⋯ } (Ioc ⌊↑a / ↑r⌋ ⌊↑b / ↑r⌋)
state_after: case a
a b r : ℤ
hr : 0 < r
x : ℤ
⊢ ((a < x ∧ x ≤ b) ∧ ∃ c, x = c * r) ↔
    ∃ a_1, (a < a_1 * r ∧ a_1 * r ≤ b) ∧ { toFun := fun x => x * r, inj' := ⋯ } a_1 = x
tactic: simp only [mem_map, mem_filter, mem_Ioc, floor_lt, le_floor, div_lt_iff, le_div_iff,
    dvd_iff_exists_eq_mul_left, cast_pos.2 hr, ← cast_mul, cast_lt, cast_le]
state_before: case a
a b r : ℤ
hr : 0 < r
x : ℤ
⊢ ((a < x ∧ x ≤ b) ∧ ∃ c, x = c * r) ↔
    ∃ a_1, (a < a_1 * r ∧ a_1 * r ≤ b) ∧ { toFun := fun x => x * r, inj' := ⋯ } a_1 = x
state_after: no goals
tactic: aesop
Theorem: MonovaryOn.sum_smul_sum_le_card_smul_sum
File: Mathlib/Algebra/Order/Chebyshev.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : LinearOrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : OrderedSMul α β
s : Finset ι
σ : Perm ι
f : ι → α
g : ι → β
hfg : MonovaryOn f g ↑s
⊢ (∑ i ∈ s, f i) • ∑ i ∈ s, g i ≤ s.card • ∑ i ∈ s, f i • g i
state_after: no goals
tactic: classical
    obtain ⟨σ, hσ, hs⟩ := s.countable_toSet.exists_cycleOn
    rw [← card_range s.card, sum_smul_sum_eq_sum_perm hσ]
    exact
      sum_le_card_nsmul _ _ _ fun n _ =>
        hfg.sum_smul_comp_perm_le_sum_smul fun x hx => hs fun h => hx <| IsFixedPt.perm_pow h _
Theorem: hasSum_one_div_nat_pow_mul_sin
File: Mathlib/NumberTheory/ZetaValues.lean

Proof steps:
state_before: k : ℕ
hk : k ≠ 0
x : ℝ
hx : x ∈ Icc 0 1
this :
  HasSum (fun n => 1 / ↑n ^ (2 * k + 1) * ((fourier ↑n) ↑x - (fourier (-↑n)) ↑x))
    ((-1) ^ (k + 1) * I * (2 * ↑π) ^ (2 * k + 1) / ↑(2 * k + 1)! * ↑(bernoulliFun (2 * k + 1) x))
⊢ HasSum (fun n => 1 / ↑n ^ (2 * k + 1) * Real.sin (2 * π * ↑n * x))
    ((-1) ^ (k + 1) * (2 * π) ^ (2 * k + 1) / 2 / ↑(2 * k + 1)! *
      Polynomial.eval x (Polynomial.map (algebraMap ℚ ℝ) (Polynomial.bernoulli (2 * k + 1))))
state_after: k : ℕ
hk : k ≠ 0
x : ℝ
hx : x ∈ Icc 0 1
this :
  HasSum (fun n => 1 / ↑n ^ (2 * k + 1) * ((fourier ↑n) ↑x - (fourier (-↑n)) ↑x))
    ((-1) ^ (k + 1) * I * (2 * ↑π) ^ (2 * k + 1) / ↑(2 * k + 1)! * ↑(bernoulliFun (2 * k + 1) x))
ofReal_two : ↑2 = 2
⊢ HasSum (fun n => 1 / ↑n ^ (2 * k + 1) * Real.sin (2 * π * ↑n * x))
    ((-1) ^ (k + 1) * (2 * π) ^ (2 * k + 1) / 2 / ↑(2 * k + 1)! *
      Polynomial.eval x (Polynomial.map (algebraMap ℚ ℝ) (Polynomial.bernoulli (2 * k + 1))))
tactic: have ofReal_two : ((2 : ℝ) : ℂ) = 2 := by norm_cast
state_before: k : ℕ
hk : k ≠ 0
x : ℝ
hx : x ∈ Icc 0 1
this :
  HasSum (fun n => 1 / ↑n ^ (2 * k + 1) * ((fourier ↑n) ↑x - (fourier (-↑n)) ↑x))
    ((-1) ^ (k + 1) * I * (2 * ↑π) ^ (2 * k + 1) / ↑(2 * k + 1)! * ↑(bernoulliFun (2 * k + 1) x))
ofReal_two : ↑2 = 2
⊢ HasSum (fun n => 1 / ↑n ^ (2 * k + 1) * Real.sin (2 * π * ↑n * x))
    ((-1) ^ (k + 1) * (2 * π) ^ (2 * k + 1) / 2 / ↑(2 * k + 1)! *
      Polynomial.eval x (Polynomial.map (algebraMap ℚ ℝ) (Polynomial.bernoulli (2 * k + 1))))
state_after: case h.e'_5.h
k : ℕ
hk : k ≠ 0
x : ℝ
hx : x ∈ Icc 0 1
this :
  HasSum (fun n => 1 / ↑n ^ (2 * k + 1) * ((fourier ↑n) ↑x - (fourier (-↑n)) ↑x))
    ((-1) ^ (k + 1) * I * (2 * ↑π) ^ (2 * k + 1) / ↑(2 * k + 1)! * ↑(bernoulliFun (2 * k + 1) x))
ofReal_two : ↑2 = 2
x✝ : ℕ
⊢ 1 / ↑x✝ ^ (2 * k + 1) * Real.sin (2 * π * ↑x✝ * x) =
    (1 / ↑x✝ ^ (2 * k + 1) * ((fourier ↑x✝) ↑x - (fourier (-↑x✝)) ↑x) / (2 * I)).re

case h.e'_6
k : ℕ
hk : k ≠ 0
x : ℝ
hx : x ∈ Icc 0 1
this :
  HasSum (fun n => 1 / ↑n ^ (2 * k + 1) * ((fourier ↑n) ↑x - (fourier (-↑n)) ↑x))
    ((-1) ^ (k + 1) * I * (2 * ↑π) ^ (2 * k + 1) / ↑(2 * k + 1)! * ↑(bernoulliFun (2 * k + 1) x))
ofReal_two : ↑2 = 2
⊢ (-1) ^ (k + 1) * (2 * π) ^ (2 * k + 1) / 2 / ↑(2 * k + 1)! *
      Polynomial.eval x (Polynomial.map (algebraMap ℚ ℝ) (Polynomial.bernoulli (2 * k + 1))) =
    ((-1) ^ (k + 1) * I * (2 * ↑π) ^ (2 * k + 1) / ↑(2 * k + 1)! * ↑(bernoulliFun (2 * k + 1) x) / (2 * I)).re
tactic: convert ((hasSum_iff _ _).mp (this.div_const (2 * I))).1
Theorem: SimpleGraph.Subgraph.neighborSet_sSup
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
s : Set G.Subgraph
v : V
⊢ (sSup s).neighborSet v = ⋃ G' ∈ s, G'.neighborSet v
state_after: case h
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
s : Set G.Subgraph
v x✝ : V
⊢ x✝ ∈ (sSup s).neighborSet v ↔ x✝ ∈ ⋃ G' ∈ s, G'.neighborSet v
tactic: ext
state_before: case h
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
s : Set G.Subgraph
v x✝ : V
⊢ x✝ ∈ (sSup s).neighborSet v ↔ x✝ ∈ ⋃ G' ∈ s, G'.neighborSet v
state_after: no goals
tactic: simp
Theorem: isOpen_uniformity
File: Mathlib/Topology/UniformSpace/Basic.lean

Proof steps:
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
s : Set α
⊢ IsOpen s ↔ ∀ x ∈ s, {p | p.1 = x → p.2 ∈ s} ∈ 𝓤 α
state_after: no goals
tactic: simp only [isOpen_iff_mem_nhds, nhds_eq_comap_uniformity, mem_comap_prod_mk]
Theorem: CategoryTheory.IsIso.hom_inv_id_assoc
File: Mathlib/CategoryTheory/Iso.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z✝ : C
f : X ⟶ Y
I : IsIso f
Z : C
g : X ⟶ Z
⊢ f ≫ inv f ≫ g = g
state_after: no goals
tactic: simp [← Category.assoc]
Theorem: List.mem_sublists'
File: Mathlib/Data/List/Sublists.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s t : List α
⊢ s ∈ t.sublists' ↔ s <+ t
state_after: case nil
α : Type u
β : Type v
γ : Type w
s : List α
⊢ s ∈ [].sublists' ↔ s <+ []

case cons
α : Type u
β : Type v
γ : Type w
a : α
t : List α
IH : ∀ {s : List α}, s ∈ t.sublists' ↔ s <+ t
s : List α
⊢ s ∈ (a :: t).sublists' ↔ s <+ a :: t
tactic: induction' t with a t IH generalizing s
state_before: case cons
α : Type u
β : Type v
γ : Type w
a : α
t : List α
IH : ∀ {s : List α}, s ∈ t.sublists' ↔ s <+ t
s : List α
⊢ s ∈ (a :: t).sublists' ↔ s <+ a :: t
state_after: case cons
α : Type u
β : Type v
γ : Type w
a : α
t : List α
IH : ∀ {s : List α}, s ∈ t.sublists' ↔ s <+ t
s : List α
⊢ (s <+ t ∨ ∃ a_1, a_1 <+ t ∧ a :: a_1 = s) ↔ s <+ a :: t
tactic: simp only [sublists'_cons, mem_append, IH, mem_map]
state_before: case cons
α : Type u
β : Type v
γ : Type w
a : α
t : List α
IH : ∀ {s : List α}, s ∈ t.sublists' ↔ s <+ t
s : List α
⊢ (s <+ t ∨ ∃ a_1, a_1 <+ t ∧ a :: a_1 = s) ↔ s <+ a :: t
state_after: case cons.mp
α : Type u
β : Type v
γ : Type w
a : α
t : List α
IH : ∀ {s : List α}, s ∈ t.sublists' ↔ s <+ t
s : List α
h : s <+ t ∨ ∃ a_1, a_1 <+ t ∧ a :: a_1 = s
⊢ s <+ a :: t

case cons.mpr
α : Type u
β : Type v
γ : Type w
a : α
t : List α
IH : ∀ {s : List α}, s ∈ t.sublists' ↔ s <+ t
s : List α
h : s <+ a :: t
⊢ s <+ t ∨ ∃ a_1, a_1 <+ t ∧ a :: a_1 = s
tactic: constructor <;> intro h
Theorem: Polynomial.derivWithin
File: Mathlib/Analysis/Calculus/Deriv/Polynomial.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
R : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Algebra R 𝕜
p : 𝕜[X]
q : R[X]
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ derivWithin (fun x => eval x p) s x = eval x (derivative p)
state_after: 𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
R : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Algebra R 𝕜
p : 𝕜[X]
q : R[X]
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ deriv (fun x => eval x p) x = eval x (derivative p)
tactic: rw [DifferentiableAt.derivWithin p.differentiableAt hxs]
state_before: 𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
R : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Algebra R 𝕜
p : 𝕜[X]
q : R[X]
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ deriv (fun x => eval x p) x = eval x (derivative p)
state_after: no goals
tactic: exact p.deriv
Theorem: CategoryTheory.oppositeShiftFunctorAdd'_inv_app
File: Mathlib/CategoryTheory/Shift/Opposite.lean

Proof steps:
state_before: C : Type u_1
inst✝² : Category.{u_3, u_1} C
A : Type u_2
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
X : OppositeShift C A
a b c : A
h : a + b = c
⊢ (shiftFunctorAdd' (OppositeShift C A) a b c h).inv.app X = ((shiftFunctorAdd' C a b c h).hom.app (Opposite.unop X)).op
state_after: C : Type u_1
inst✝² : Category.{u_3, u_1} C
A : Type u_2
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
X : OppositeShift C A
a b : A
⊢ (shiftFunctorAdd' (OppositeShift C A) a b (a + b) ⋯).inv.app X =
    ((shiftFunctorAdd' C a b (a + b) ⋯).hom.app (Opposite.unop X)).op
tactic: subst h
state_before: C : Type u_1
inst✝² : Category.{u_3, u_1} C
A : Type u_2
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
X : OppositeShift C A
a b : A
⊢ (shiftFunctorAdd' (OppositeShift C A) a b (a + b) ⋯).inv.app X =
    ((shiftFunctorAdd' C a b (a + b) ⋯).hom.app (Opposite.unop X)).op
state_after: no goals
tactic: simp only [shiftFunctorAdd'_eq_shiftFunctorAdd, oppositeShiftFunctorAdd_inv_app]
Theorem: CategoryTheory.Functor.Faithful.of_iso
File: Mathlib/CategoryTheory/Functor/FullyFaithful.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
F F' : C ⥤ D
G : D ⥤ E
inst✝ : F.Faithful
α : F ≅ F'
X✝ Y✝ : C
a₁✝ a₂✝ : X✝ ⟶ Y✝
h : F'.map a₁✝ = F'.map a₂✝
⊢ F.map a₁✝ = F.map a₂✝
state_after: no goals
tactic: rw [← NatIso.naturality_1 α.symm, h, NatIso.naturality_1 α.symm]