ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Limits.colimitCurrySwapCompColimIsoColimitCurryCompColim_ι_ι_hom
File: Mathlib/CategoryTheory/Limits/Fubini.lean

Proof steps:
state_before: J K : Type v
inst✝³ : SmallCategory J
inst✝² : SmallCategory K
C : Type u
inst✝¹ : Category.{v, u} C
F : J ⥤ K ⥤ C
G : J × K ⥤ C
inst✝ : HasColimits C
j : J
k : K
⊢ colimit.ι ((curry.obj (Prod.swap K J ⋙ G)).obj k) j ≫
      colimit.ι (curry.obj (Prod.swap K J ⋙ G) ⋙ colim) k ≫ (colimitCurrySwapCompColimIsoColimitCurryCompColim G).hom =
    colimit.ι ((curry.obj G).obj j) k ≫ colimit.ι (curry.obj G ⋙ colim) j
state_after: J K : Type v
inst✝³ : SmallCategory J
inst✝² : SmallCategory K
C : Type u
inst✝¹ : Category.{v, u} C
F : J ⥤ K ⥤ C
G : J × K ⥤ C
inst✝ : HasColimits C
j : J
k : K
⊢ colimit.ι ((curry.obj (Prod.swap K J ⋙ G)).obj k) j ≫
      colimit.ι (curry.obj (Prod.swap K J ⋙ G) ⋙ colim) k ≫
        ((colimitIsoColimitCurryCompColim (Prod.swap K J ⋙ G)).inv ≫
            (HasColimit.isoOfEquivalence (Prod.braiding K J) (Iso.refl ((Prod.braiding K J).functor ⋙ G))).hom) ≫
          (colimitIsoColimitCurryCompColim G).hom =
    colimit.ι ((curry.obj G).obj j) k ≫ colimit.ι (curry.obj G ⋙ colim) j
tactic: dsimp [colimitCurrySwapCompColimIsoColimitCurryCompColim]
state_before: J K : Type v
inst✝³ : SmallCategory J
inst✝² : SmallCategory K
C : Type u
inst✝¹ : Category.{v, u} C
F : J ⥤ K ⥤ C
G : J × K ⥤ C
inst✝ : HasColimits C
j : J
k : K
⊢ colimit.ι ((curry.obj (Prod.swap K J ⋙ G)).obj k) j ≫
      colimit.ι (curry.obj (Prod.swap K J ⋙ G) ⋙ colim) k ≫
        ((colimitIsoColimitCurryCompColim (Prod.swap K J ⋙ G)).inv ≫
            (HasColimit.isoOfEquivalence (Prod.braiding K J) (Iso.refl ((Prod.braiding K J).functor ⋙ G))).hom) ≫
          (colimitIsoColimitCurryCompColim G).hom =
    colimit.ι ((curry.obj G).obj j) k ≫ colimit.ι (curry.obj G ⋙ colim) j
state_after: J K : Type v
inst✝³ : SmallCategory J
inst✝² : SmallCategory K
C : Type u
inst✝¹ : Category.{v, u} C
F : J ⥤ K ⥤ C
G : J × K ⥤ C
inst✝ : HasColimits C
j : J
k : K
⊢ ((colimit.ι ((curry.obj (Prod.swap K J ⋙ G)).obj k) j ≫
          colimit.ι (curry.obj (Prod.swap K J ⋙ G) ⋙ colim) k ≫
            (colimitIsoColimitCurryCompColim (Prod.swap K J ⋙ G)).inv) ≫
        (HasColimit.isoOfEquivalence (Prod.braiding K J) (Iso.refl ((Prod.braiding K J).functor ⋙ G))).hom) ≫
      (colimitIsoColimitCurryCompColim G).hom =
    colimit.ι ((curry.obj G).obj j) k ≫ colimit.ι (curry.obj G ⋙ colim) j
tactic: slice_lhs 1 3 => simp only []
state_before: J K : Type v
inst✝³ : SmallCategory J
inst✝² : SmallCategory K
C : Type u
inst✝¹ : Category.{v, u} C
F : J ⥤ K ⥤ C
G : J × K ⥤ C
inst✝ : HasColimits C
j : J
k : K
⊢ ((colimit.ι ((curry.obj (Prod.swap K J ⋙ G)).obj k) j ≫
          colimit.ι (curry.obj (Prod.swap K J ⋙ G) ⋙ colim) k ≫
            (colimitIsoColimitCurryCompColim (Prod.swap K J ⋙ G)).inv) ≫
        (HasColimit.isoOfEquivalence (Prod.braiding K J) (Iso.refl ((Prod.braiding K J).functor ⋙ G))).hom) ≫
      (colimitIsoColimitCurryCompColim G).hom =
    colimit.ι ((curry.obj G).obj j) k ≫ colimit.ι (curry.obj G ⋙ colim) j
state_after: no goals
tactic: simp
Theorem: BooleanAlgebra.eq_iff_atom_le_iff
File: Mathlib/Order/Atoms.lean

Proof steps:
state_before: ι : Sort u_1
α✝ : Type u_2
β : Type u_3
inst✝² : PartialOrder α✝
α : Type u_4
inst✝¹ : BooleanAlgebra α
inst✝ : IsAtomic α
x y : α
⊢ x = y ↔ ∀ (a : α), IsAtom a → (a ≤ x ↔ a ≤ y)
state_after: ι : Sort u_1
α✝ : Type u_2
β : Type u_3
inst✝² : PartialOrder α✝
α : Type u_4
inst✝¹ : BooleanAlgebra α
inst✝ : IsAtomic α
x y : α
h : ∀ (a : α), IsAtom a → (a ≤ x ↔ a ≤ y)
⊢ x = y
tactic: refine ⟨fun h => h ▸ by simp, fun h => ?_⟩
state_before: ι : Sort u_1
α✝ : Type u_2
β : Type u_3
inst✝² : PartialOrder α✝
α : Type u_4
inst✝¹ : BooleanAlgebra α
inst✝ : IsAtomic α
x y : α
h : ∀ (a : α), IsAtom a → (a ≤ x ↔ a ≤ y)
⊢ x = y
state_after: no goals
tactic: exact le_antisymm (le_iff_atom_le_imp.2 fun a ha hx => (h a ha).1 hx)
    (le_iff_atom_le_imp.2 fun a ha hy => (h a ha).2 hy)
Theorem: CategoryTheory.Over.ConstructProducts.conesEquivFunctor_map_hom
File: Mathlib/CategoryTheory/Limits/Constructions/Over/Products.lean

Proof steps:
state_before: J✝ : Type w
C : Type u
inst✝ : Category.{v, u} C
X✝ B : C
J : Type w
F : Discrete J ⥤ Over B
c : Cone (widePullbackDiagramOfDiagramOver B F)
x✝² x✝¹ : Discrete J
X Y : J
x✝ : { as := X } ⟶ { as := Y }
f : { as := X }.as = { as := Y }.as
⊢ ((Functor.const (Discrete J)).obj (mk (c.π.app none))).map { down := { down := f } } ≫
      (fun x =>
          match x with
          | { as := j } => homMk (c.π.app (some j)) ⋯)
        { as := Y } =
    (fun x =>
          match x with
          | { as := j } => homMk (c.π.app (some j)) ⋯)
        { as := X } ≫
      F.map { down := { down := f } }
state_after: J✝ : Type w
C : Type u
inst✝ : Category.{v, u} C
X✝ B : C
J : Type w
F : Discrete J ⥤ Over B
c : Cone (widePullbackDiagramOfDiagramOver B F)
x✝² x✝¹ : Discrete J
X Y : J
x✝ : { as := X } ⟶ { as := Y }
f : X = Y
⊢ 𝟙 (mk (c.π.app none)) ≫ homMk (c.π.app (some Y)) ⋯ = homMk (c.π.app (some X)) ⋯ ≫ F.map { down := { down := f } }
tactic: dsimp at f ⊢
state_before: J✝ : Type w
C : Type u
inst✝ : Category.{v, u} C
X✝ B : C
J : Type w
F : Discrete J ⥤ Over B
c : Cone (widePullbackDiagramOfDiagramOver B F)
x✝² x✝¹ : Discrete J
X Y : J
x✝ : { as := X } ⟶ { as := Y }
f : X = Y
⊢ 𝟙 (mk (c.π.app none)) ≫ homMk (c.π.app (some Y)) ⋯ = homMk (c.π.app (some X)) ⋯ ≫ F.map { down := { down := f } }
state_after: no goals
tactic: aesop_cat
Theorem: Polynomial.int_cyclotomic_rw
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

Proof steps:
state_before: n : ℕ
h : n ≠ 0
⊢ cyclotomic n ℤ = ⋯.choose
state_after: n : ℕ
h : n ≠ 0
⊢ map (Int.castRingHom ℤ) ⋯.choose = ⋯.choose
tactic: simp only [cyclotomic, h, dif_neg, not_false_iff]
state_before: n : ℕ
h : n ≠ 0
⊢ map (Int.castRingHom ℤ) ⋯.choose = ⋯.choose
state_after: case a
n : ℕ
h : n ≠ 0
i : ℕ
⊢ (map (Int.castRingHom ℤ) ⋯.choose).coeff i = ⋯.choose.coeff i
tactic: ext i
state_before: case a
n : ℕ
h : n ≠ 0
i : ℕ
⊢ (map (Int.castRingHom ℤ) ⋯.choose).coeff i = ⋯.choose.coeff i
state_after: no goals
tactic: simp only [coeff_map, Int.cast_id, eq_intCast]
Theorem: CategoryTheory.Pi.optionEquivalence_unitIso
File: Mathlib/CategoryTheory/Pi/Basic.lean

Proof steps:
state_before: I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝¹ : (i : I) → Category.{v₁, u₁} (C i)
C' : Option J → Type u₁
inst✝ : (i : Option J) → Category.{v₁, u₁} (C' i)
⊢ (Functor.pi' fun i =>
        match i with
        | none => Prod.fst (C' none) ((j : J) → C' (some j))
        | some i => Prod.snd (C' none) ((j : J) → C' (some j)) ⋙ eval (fun j => C' (some j)) i) ⋙
      (eval C' none).prod' (Functor.pi' fun i => eval C' (some i)) ≅
    𝟭 (C' none × ((j : J) → C' (some j)))
state_after: no goals
tactic: exact Iso.refl _
Theorem: Submodule.le_of_le_smul_of_le_jacobson_bot
File: Mathlib/RingTheory/Nakayama.lean

Proof steps:
state_before: R✝ : Type u_1
M✝ : Type u_2
inst✝⁵ : CommRing R✝
inst✝⁴ : AddCommGroup M✝
inst✝³ : Module R✝ M✝
R : Type u_3
M : Type u_4
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
N N' : Submodule R M
hN' : N'.FG
hIJ : I ≤ ⊥.jacobson
hNN : N' ≤ N ⊔ I • N'
⊢ N' ≤ N
state_after: no goals
tactic: rw [← sup_eq_left, sup_eq_sup_smul_of_le_smul_of_le_jacobson hN' hIJ hNN, bot_smul, sup_bot_eq]
Theorem: IsLocalizedModule.mk'_add
File: Mathlib/Algebra/Module/LocalizedModule.lean

Proof steps:
state_before: R : Type u_1
inst✝¹² : CommSemiring R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : AddCommMonoid M''
A : Type u_5
inst✝⁸ : CommSemiring A
inst✝⁷ : Algebra R A
inst✝⁶ : Module A M'
inst✝⁵ : IsLocalization S A
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M''
inst✝¹ : IsScalarTower R A M'
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
m₁ m₂ : M
s : ↥S
⊢ mk' f (m₁ + m₂) s = mk' f m₁ s + mk' f m₂ s
state_after: no goals
tactic: rw [mk'_add_mk', ← smul_add, mk'_cancel_left]
Theorem: HomotopyCategory.quotient_map_out_comp_out
File: Mathlib/Algebra/Homology/HomotopyCategory.lean

Proof steps:
state_before: R : Type u_1
inst✝² : Semiring R
ι : Type u_2
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomotopyCategory V c
f : C ⟶ D
g : D ⟶ E
⊢ (quotient V c).map (Quot.out f ≫ Quot.out g) = f ≫ g
state_after: no goals
tactic: simp
Theorem: Set.star_add
File: Mathlib/Algebra/Star/Pointwise.lean

Proof steps:
state_before: α : Type u_1
s✝ t✝ : Set α
a : α
inst✝¹ : AddMonoid α
inst✝ : StarAddMonoid α
s t : Set α
⊢ (s + t)⋆ = s⋆ + t⋆
state_after: no goals
tactic: simp_rw [← image_star, ← image2_add, image_image2, image2_image_left, image2_image_right,
   star_add]
Theorem: totallyBounded_iUnion
File: Mathlib/Topology/UniformSpace/Cauchy.lean

Proof steps:
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
ι : Sort u_1
inst✝ : Finite ι
s : ι → Set α
⊢ TotallyBounded (⋃ i, s i) ↔ ∀ (i : ι), TotallyBounded (s i)
state_after: α : Type u
β : Type v
uniformSpace : UniformSpace α
ι : Sort u_1
inst✝ : Finite ι
s : ι → Set α
h : ∀ (i : ι), TotallyBounded (s i)
U : Set (α × α)
hU : U ∈ 𝓤 α
⊢ ∃ t, t.Finite ∧ ⋃ i, s i ⊆ ⋃ y ∈ t, {x | (x, y) ∈ U}
tactic: refine ⟨fun h i ↦ h.subset (subset_iUnion _ _), fun h U hU ↦ ?_⟩
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
ι : Sort u_1
inst✝ : Finite ι
s : ι → Set α
h : ∀ (i : ι), TotallyBounded (s i)
U : Set (α × α)
hU : U ∈ 𝓤 α
t : ι → Set α
htf : ∀ (x : ι), (t x).Finite
ht : ∀ (x : ι), s x ⊆ ⋃ y ∈ t x, {x | (x, y) ∈ U}
⊢ ∃ t, t.Finite ∧ ⋃ i, s i ⊆ ⋃ y ∈ t, {x | (x, y) ∈ U}
state_after: α : Type u
β : Type v
uniformSpace : UniformSpace α
ι : Sort u_1
inst✝ : Finite ι
s : ι → Set α
h : ∀ (i : ι), TotallyBounded (s i)
U : Set (α × α)
hU : U ∈ 𝓤 α
t : ι → Set α
htf : ∀ (x : ι), (t x).Finite
ht : ∀ (x : ι), s x ⊆ ⋃ y ∈ t x, {x | (x, y) ∈ U}
⊢ ⋃ i, s i ⊆ ⋃ y ∈ ⋃ i, t i, {x | (x, y) ∈ U}
tactic: refine ⟨⋃ i, t i, finite_iUnion htf, ?_⟩
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
ι : Sort u_1
inst✝ : Finite ι
s : ι → Set α
h : ∀ (i : ι), TotallyBounded (s i)
U : Set (α × α)
hU : U ∈ 𝓤 α
t : ι → Set α
htf : ∀ (x : ι), (t x).Finite
ht : ∀ (x : ι), s x ⊆ ⋃ y ∈ t x, {x | (x, y) ∈ U}
⊢ ⋃ i, s i ⊆ ⋃ y ∈ ⋃ i, t i, {x | (x, y) ∈ U}
state_after: α : Type u
β : Type v
uniformSpace : UniformSpace α
ι : Sort u_1
inst✝ : Finite ι
s : ι → Set α
h : ∀ (i : ι), TotallyBounded (s i)
U : Set (α × α)
hU : U ∈ 𝓤 α
t : ι → Set α
htf : ∀ (x : ι), (t x).Finite
ht : ∀ (x : ι), s x ⊆ ⋃ y ∈ t x, {x | (x, y) ∈ U}
⊢ ⋃ i, s i ⊆ ⋃ i, ⋃ x ∈ t i, {x_1 | (x_1, x) ∈ U}
tactic: rw [biUnion_iUnion]
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
ι : Sort u_1
inst✝ : Finite ι
s : ι → Set α
h : ∀ (i : ι), TotallyBounded (s i)
U : Set (α × α)
hU : U ∈ 𝓤 α
t : ι → Set α
htf : ∀ (x : ι), (t x).Finite
ht : ∀ (x : ι), s x ⊆ ⋃ y ∈ t x, {x | (x, y) ∈ U}
⊢ ⋃ i, s i ⊆ ⋃ i, ⋃ x ∈ t i, {x_1 | (x_1, x) ∈ U}
state_after: case h
α : Type u
β : Type v
uniformSpace : UniformSpace α
ι : Sort u_1
inst✝ : Finite ι
s : ι → Set α
h : ∀ (i : ι), TotallyBounded (s i)
U : Set (α × α)
hU : U ∈ 𝓤 α
t : ι → Set α
htf : ∀ (x : ι), (t x).Finite
ht : ∀ (x : ι), s x ⊆ ⋃ y ∈ t x, {x | (x, y) ∈ U}
i✝ : ι
⊢ s i✝ ⊆ ⋃ x ∈ t i✝, {x_1 | (x_1, x) ∈ U}
tactic: gcongr
state_before: case h
α : Type u
β : Type v
uniformSpace : UniformSpace α
ι : Sort u_1
inst✝ : Finite ι
s : ι → Set α
h : ∀ (i : ι), TotallyBounded (s i)
U : Set (α × α)
hU : U ∈ 𝓤 α
t : ι → Set α
htf : ∀ (x : ι), (t x).Finite
ht : ∀ (x : ι), s x ⊆ ⋃ y ∈ t x, {x | (x, y) ∈ U}
i✝ : ι
⊢ s i✝ ⊆ ⋃ x ∈ t i✝, {x_1 | (x_1, x) ∈ U}
state_after: no goals
tactic: apply ht
Theorem: Units.inv_mul_eq_iff_eq_mul
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
inst✝ : Monoid α
a b✝ c✝ u : αˣ
b c : α
h : ↑a⁻¹ * b = c
⊢ b = ↑a * c
state_after: no goals
tactic: rw [← h, mul_inv_cancel_left]
state_before: α : Type u
inst✝ : Monoid α
a b✝ c✝ u : αˣ
b c : α
h : b = ↑a * c
⊢ ↑a⁻¹ * b = c
state_after: no goals
tactic: rw [h, inv_mul_cancel_left]
Theorem: MeasureTheory.Lp.mem_Lp_iff_memℒp
File: Mathlib/MeasureTheory/Function/LpSpace.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α →ₘ[μ] E
⊢ f ∈ Lp E p μ ↔ Memℒp (↑f) p μ
state_after: no goals
tactic: simp [mem_Lp_iff_eLpNorm_lt_top, Memℒp, f.stronglyMeasurable.aestronglyMeasurable]
Theorem: nhds_top_order
File: Mathlib/Topology/Order/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : Preorder α
inst✝¹ : OrderTop α
inst✝ : OrderTopology α
⊢ 𝓝 ⊤ = ⨅ l, ⨅ (_ : l < ⊤), 𝓟 (Ioi l)
state_after: no goals
tactic: simp [nhds_eq_order (⊤ : α)]
Theorem: Polynomial.eval₂_primPart_eq_zero
File: Mathlib/RingTheory/Polynomial/Content.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : NormalizedGCDMonoid R
S : Type u_2
inst✝¹ : CommRing S
inst✝ : IsDomain S
f : R →+* S
hinj : Function.Injective ⇑f
p : R[X]
s : S
hpzero : p ≠ 0
hp : eval₂ f s p = 0
⊢ eval₂ f s p.primPart = 0
state_after: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : NormalizedGCDMonoid R
S : Type u_2
inst✝¹ : CommRing S
inst✝ : IsDomain S
f : R →+* S
hinj : Function.Injective ⇑f
p : R[X]
s : S
hpzero : p ≠ 0
hp : f p.content * eval₂ f s p.primPart = 0
⊢ eval₂ f s p.primPart = 0
tactic: rw [eq_C_content_mul_primPart p, eval₂_mul, eval₂_C] at hp
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : NormalizedGCDMonoid R
S : Type u_2
inst✝¹ : CommRing S
inst✝ : IsDomain S
f : R →+* S
hinj : Function.Injective ⇑f
p : R[X]
s : S
hpzero : p ≠ 0
hp : f p.content * eval₂ f s p.primPart = 0
⊢ eval₂ f s p.primPart = 0
state_after: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : NormalizedGCDMonoid R
S : Type u_2
inst✝¹ : CommRing S
inst✝ : IsDomain S
f : R →+* S
hinj : Function.Injective ⇑f
p : R[X]
s : S
hpzero : p ≠ 0
hp : f p.content * eval₂ f s p.primPart = 0
hcont : p.content ≠ 0
⊢ eval₂ f s p.primPart = 0
tactic: have hcont : p.content ≠ 0 := fun h => hpzero (content_eq_zero_iff.1 h)
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : NormalizedGCDMonoid R
S : Type u_2
inst✝¹ : CommRing S
inst✝ : IsDomain S
f : R →+* S
hinj : Function.Injective ⇑f
p : R[X]
s : S
hpzero : p ≠ 0
hp : f p.content * eval₂ f s p.primPart = 0
hcont : p.content ≠ 0
⊢ eval₂ f s p.primPart = 0
state_after: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : NormalizedGCDMonoid R
S : Type u_2
inst✝¹ : CommRing S
inst✝ : IsDomain S
f : R →+* S
hinj : Function.Injective ⇑f
p : R[X]
s : S
hpzero : p ≠ 0
hp : f p.content * eval₂ f s p.primPart = 0
hcont : f p.content ≠ f 0
⊢ eval₂ f s p.primPart = 0
tactic: replace hcont := Function.Injective.ne hinj hcont
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : NormalizedGCDMonoid R
S : Type u_2
inst✝¹ : CommRing S
inst✝ : IsDomain S
f : R →+* S
hinj : Function.Injective ⇑f
p : R[X]
s : S
hpzero : p ≠ 0
hp : f p.content * eval₂ f s p.primPart = 0
hcont : f p.content ≠ f 0
⊢ eval₂ f s p.primPart = 0
state_after: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : NormalizedGCDMonoid R
S : Type u_2
inst✝¹ : CommRing S
inst✝ : IsDomain S
f : R →+* S
hinj : Function.Injective ⇑f
p : R[X]
s : S
hpzero : p ≠ 0
hp : f p.content * eval₂ f s p.primPart = 0
hcont : f p.content ≠ 0
⊢ eval₂ f s p.primPart = 0
tactic: rw [map_zero] at hcont
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : NormalizedGCDMonoid R
S : Type u_2
inst✝¹ : CommRing S
inst✝ : IsDomain S
f : R →+* S
hinj : Function.Injective ⇑f
p : R[X]
s : S
hpzero : p ≠ 0
hp : f p.content * eval₂ f s p.primPart = 0
hcont : f p.content ≠ 0
⊢ eval₂ f s p.primPart = 0
state_after: no goals
tactic: exact eq_zero_of_ne_zero_of_mul_left_eq_zero hcont hp
Theorem: Finset.prod_multiset_count_of_subset
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✝¹ : DecidableEq α
inst✝ : CommMonoid α
m : Multiset α
s : Finset α
hs : m.toFinset ⊆ s
⊢ m.prod = ∏ i ∈ s, i ^ Multiset.count i m
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✝¹ : DecidableEq α
inst✝ : CommMonoid α
m : Multiset α
s : Finset α
⊢ m.toFinset ⊆ s → m.prod = ∏ i ∈ s, i ^ Multiset.count i m
tactic: revert hs
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✝¹ : DecidableEq α
inst✝ : CommMonoid α
m : Multiset α
s : Finset α
⊢ m.toFinset ⊆ s → m.prod = ∏ i ∈ s, i ^ Multiset.count i m
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✝¹ : DecidableEq α
inst✝ : CommMonoid α
m : Multiset α
s : Finset α
l : List α
⊢ Multiset.toFinset (Quot.mk Setoid.r l) ⊆ s →
    Multiset.prod (Quot.mk Setoid.r l) = ∏ i ∈ s, i ^ Multiset.count i (Quot.mk Setoid.r l)
tactic: refine Quot.induction_on m fun l => ?_
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✝¹ : DecidableEq α
inst✝ : CommMonoid α
m : Multiset α
s : Finset α
l : List α
⊢ Multiset.toFinset (Quot.mk Setoid.r l) ⊆ s →
    Multiset.prod (Quot.mk Setoid.r l) = ∏ i ∈ s, i ^ Multiset.count i (Quot.mk Setoid.r l)
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✝¹ : DecidableEq α
inst✝ : CommMonoid α
m : Multiset α
s : Finset α
l : List α
⊢ (↑l).toFinset ⊆ s → l.prod = ∏ x ∈ s, x ^ List.count x l
tactic: simp only [quot_mk_to_coe'', prod_coe, coe_count]
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✝¹ : DecidableEq α
inst✝ : CommMonoid α
m : Multiset α
s : Finset α
l : List α
⊢ (↑l).toFinset ⊆ s → l.prod = ∏ x ∈ s, x ^ List.count x l
state_after: no goals
tactic: apply prod_list_count_of_subset l s
Theorem: EulerSine.integral_cos_pow_eq
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/EulerSineProd.lean

Proof steps:
state_before: z : ℂ
n✝ n : ℕ
⊢ ∫ (x : ℝ) in 0 ..π / 2, cos x ^ n = 1 / 2 * ∫ (x : ℝ) in 0 ..π, sin x ^ n
state_after: z : ℂ
n✝ n : ℕ
⊢ (∫ (x : ℝ) in 0 ..π / 2, cos x ^ n) + ∫ (x : ℝ) in 0 ..π / 2, cos x ^ n = ∫ (x : ℝ) in 0 ..π, sin x ^ n
tactic: rw [mul_comm (1 / 2 : ℝ), ← div_eq_iff (one_div_ne_zero (two_ne_zero' ℝ)), ← div_mul, div_one,
    mul_two]
state_before: z : ℂ
n✝ n : ℕ
⊢ (∫ (x : ℝ) in 0 ..π / 2, cos x ^ n) + ∫ (x : ℝ) in 0 ..π / 2, cos x ^ n = ∫ (x : ℝ) in 0 ..π, sin x ^ n
state_after: z : ℂ
n✝ n : ℕ
L : IntervalIntegrable (fun b => sin b ^ n) volume 0 (π / 2)
⊢ (∫ (x : ℝ) in 0 ..π / 2, cos x ^ n) + ∫ (x : ℝ) in 0 ..π / 2, cos x ^ n = ∫ (x : ℝ) in 0 ..π, sin x ^ n
tactic: have L : IntervalIntegrable _ volume 0 (π / 2) := (continuous_sin.pow n).intervalIntegrable _ _
state_before: z : ℂ
n✝ n : ℕ
L : IntervalIntegrable (fun b => sin b ^ n) volume 0 (π / 2)
⊢ (∫ (x : ℝ) in 0 ..π / 2, cos x ^ n) + ∫ (x : ℝ) in 0 ..π / 2, cos x ^ n = ∫ (x : ℝ) in 0 ..π, sin x ^ n
state_after: z : ℂ
n✝ n : ℕ
L : IntervalIntegrable (fun b => sin b ^ n) volume 0 (π / 2)
R : IntervalIntegrable (fun b => sin b ^ n) volume (π / 2) π
⊢ (∫ (x : ℝ) in 0 ..π / 2, cos x ^ n) + ∫ (x : ℝ) in 0 ..π / 2, cos x ^ n = ∫ (x : ℝ) in 0 ..π, sin x ^ n
tactic: have R : IntervalIntegrable _ volume (π / 2) π := (continuous_sin.pow n).intervalIntegrable _ _
state_before: z : ℂ
n✝ n : ℕ
L : IntervalIntegrable (fun b => sin b ^ n) volume 0 (π / 2)
R : IntervalIntegrable (fun b => sin b ^ n) volume (π / 2) π
⊢ (∫ (x : ℝ) in 0 ..π / 2, cos x ^ n) + ∫ (x : ℝ) in 0 ..π / 2, cos x ^ n = ∫ (x : ℝ) in 0 ..π, sin x ^ n
state_after: z : ℂ
n✝ n : ℕ
L : IntervalIntegrable (fun b => sin b ^ n) volume 0 (π / 2)
R : IntervalIntegrable (fun b => sin b ^ n) volume (π / 2) π
⊢ (∫ (x : ℝ) in 0 ..π / 2, cos x ^ n) + ∫ (x : ℝ) in 0 ..π / 2, cos x ^ n =
    (∫ (x : ℝ) in 0 ..π / 2, sin x ^ n) + ∫ (x : ℝ) in π / 2 ..π, sin x ^ n
tactic: rw [← integral_add_adjacent_intervals L R]
state_before: z : ℂ
n✝ n : ℕ
L : IntervalIntegrable (fun b => sin b ^ n) volume 0 (π / 2)
R : IntervalIntegrable (fun b => sin b ^ n) volume (π / 2) π
⊢ (∫ (x : ℝ) in 0 ..π / 2, cos x ^ n) + ∫ (x : ℝ) in 0 ..π / 2, cos x ^ n =
    (∫ (x : ℝ) in 0 ..π / 2, sin x ^ n) + ∫ (x : ℝ) in π / 2 ..π, sin x ^ n
state_after: case e_a
z : ℂ
n✝ n : ℕ
L : IntervalIntegrable (fun b => sin b ^ n) volume 0 (π / 2)
R : IntervalIntegrable (fun b => sin b ^ n) volume (π / 2) π
⊢ ∫ (x : ℝ) in 0 ..π / 2, cos x ^ n = ∫ (x : ℝ) in 0 ..π / 2, sin x ^ n

case e_a
z : ℂ
n✝ n : ℕ
L : IntervalIntegrable (fun b => sin b ^ n) volume 0 (π / 2)
R : IntervalIntegrable (fun b => sin b ^ n) volume (π / 2) π
⊢ ∫ (x : ℝ) in 0 ..π / 2, cos x ^ n = ∫ (x : ℝ) in π / 2 ..π, sin x ^ n
tactic: congr 1
Theorem: Finset.antidiagonal_congr
File: Mathlib/Algebra/Order/Antidiag/Prod.lean

Proof steps:
state_before: A : Type u_1
inst✝¹ : AddCancelMonoid A
inst✝ : HasAntidiagonal A
p q : A × A
n : A
hp : p ∈ antidiagonal n
hq : q ∈ antidiagonal n
⊢ p = q ↔ p.1 = q.1
state_after: A : Type u_1
inst✝¹ : AddCancelMonoid A
inst✝ : HasAntidiagonal A
p q : A × A
n : A
hp : p ∈ antidiagonal n
hq : q ∈ antidiagonal n
h : p.1 = q.1
⊢ q.1 + p.2 = q.1 + q.2
tactic: refine ⟨congr_arg Prod.fst, fun h ↦ Prod.ext h ((add_right_inj q.fst).mp ?_)⟩
state_before: A : Type u_1
inst✝¹ : AddCancelMonoid A
inst✝ : HasAntidiagonal A
p q : A × A
n : A
hp : p ∈ antidiagonal n
hq : q ∈ antidiagonal n
h : p.1 = q.1
⊢ q.1 + p.2 = q.1 + q.2
state_after: A : Type u_1
inst✝¹ : AddCancelMonoid A
inst✝ : HasAntidiagonal A
p q : A × A
n : A
hp : p.1 + p.2 = n
hq : q.1 + q.2 = n
h : p.1 = q.1
⊢ q.1 + p.2 = q.1 + q.2
tactic: rw [mem_antidiagonal] at hp hq
state_before: A : Type u_1
inst✝¹ : AddCancelMonoid A
inst✝ : HasAntidiagonal A
p q : A × A
n : A
hp : p.1 + p.2 = n
hq : q.1 + q.2 = n
h : p.1 = q.1
⊢ q.1 + p.2 = q.1 + q.2
state_after: no goals
tactic: rw [hq, ← h, hp]
Theorem: LieModule.shiftedWeightSpace.toEnd_eq
File: Mathlib/Algebra/Lie/Weights/Linear.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
inst✝¹ : LieAlgebra.IsNilpotent R L
inst✝ : LinearWeights R L M
χ : L → R
x : L
⊢ (toEnd R L ↥↑(shiftedWeightSpace R L M χ)) x =
    (shift R L M χ).conj ((toEnd R L ↥↑(weightSpace M χ)) x - χ x • LinearMap.id)
state_after: case h.a
R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
inst✝¹ : LieAlgebra.IsNilpotent R L
inst✝ : LinearWeights R L M
χ : L → R
x : L
x✝ : ↥↑(shiftedWeightSpace R L M χ)
⊢ ↑(((toEnd R L ↥↑(shiftedWeightSpace R L M χ)) x) x✝) =
    ↑(((shift R L M χ).conj ((toEnd R L ↥↑(weightSpace M χ)) x - χ x • LinearMap.id)) x✝)
tactic: ext
state_before: case h.a
R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
inst✝¹ : LieAlgebra.IsNilpotent R L
inst✝ : LinearWeights R L M
χ : L → R
x : L
x✝ : ↥↑(shiftedWeightSpace R L M χ)
⊢ ↑(((toEnd R L ↥↑(shiftedWeightSpace R L M χ)) x) x✝) =
    ↑(((shift R L M χ).conj ((toEnd R L ↥↑(weightSpace M χ)) x - χ x • LinearMap.id)) x✝)
state_after: no goals
tactic: simp [LinearEquiv.conj_apply]