tasksource/leandojo huggingface dataset:
Theorem: nilpotencyClass_le_of_ker_le_center
File: Mathlib/GroupTheory/Nilpotent.lean

tactic: haveI : IsNilpotent G := isNilpotent_of_ker_le_center f hf1 hH
state_before: G : Type u_2
inst✝² : Group G
H✝ : Subgroup G
inst✝¹ : Normal H✝
H : Type u_1
inst✝ : Group H
f : G →* H
hf1 : MonoidHom.ker f ≤ center G
hH : Group.IsNilpotent H
⊢ nilpotencyClass G ≤ nilpotencyClass H + 1

tactic: rw [← lowerCentralSeries_length_eq_nilpotencyClass]
state_before: G : Type u_2
inst✝² : Group G
H✝ : Subgroup G
inst✝¹ : Normal H✝
H : Type u_1
inst✝ : Group H
f : G →* H
hf1 : MonoidHom.ker f ≤ center G
hH : Group.IsNilpotent H
this : Group.IsNilpotent G
⊢ nilpotencyClass G ≤ nilpotencyClass H + 1

tactic: refine @Nat.find_min' _ (Classical.decPred _) _ _ ?_
state_before: G : Type u_2
inst✝² : Group G
H✝ : Subgroup G
inst✝¹ : Normal H✝
H : Type u_1
inst✝ : Group H
f : G →* H
hf1 : MonoidHom.ker f ≤ center G
hH : Group.IsNilpotent H
this : Group.IsNilpotent G
⊢ Nat.find (_ : ∃ n, lowerCentralSeries G n = ⊥) ≤ nilpotencyClass H + 1

tactic: refine lowerCentralSeries_succ_eq_bot (le_trans ((Subgroup.map_eq_bot_iff _).mp ?_) hf1)
state_before: G : Type u_2
inst✝² : Group G
H✝ : Subgroup G
inst✝¹ : Normal H✝
H : Type u_1
inst✝ : Group H
f : G →* H
hf1 : MonoidHom.ker f ≤ center G
hH : Group.IsNilpotent H
this : Group.IsNilpotent G
⊢ lowerCentralSeries G (nilpotencyClass H + 1) = ⊥

tactic: apply eq_bot_iff.mpr
state_before: G : Type u_2
inst✝² : Group G
H✝ : Subgroup G
inst✝¹ : Normal H✝
H : Type u_1
inst✝ : Group H
f : G →* H
hf1 : MonoidHom.ker f ≤ center G
hH : Group.IsNilpotent H
this : Group.IsNilpotent G
⊢ Subgroup.map f (lowerCentralSeries G (nilpotencyClass H)) = ⊥

tactic: apply le_trans (lowerCentralSeries.map f _)
state_before: G : Type u_2
inst✝² : Group G
H✝ : Subgroup G
inst✝¹ : Normal H✝
H : Type u_1
inst✝ : Group H
f : G →* H
hf1 : MonoidHom.ker f ≤ center G
hH : Group.IsNilpotent H
this : Group.IsNilpotent G
⊢ Subgroup.map f (lowerCentralSeries G (nilpotencyClass H)) ≤ ⊥

tactic: simp only [lowerCentralSeries_nilpotencyClass, le_bot_iff]
state_before: G : Type u_2
inst✝² : Group G
H✝ : Subgroup G
inst✝¹ : Normal H✝
H : Type u_1
inst✝ : Group H
f : G →* H
hf1 : MonoidHom.ker f ≤ center G
hH : Group.IsNilpotent H
this : Group.IsNilpotent G
⊢ lowerCentralSeries H (nilpotencyClass H) ≤ ⊥
Theorem: MeasureTheory.FinMeasAdditive.add
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: intro s t hs ht hμs hμt hst
state_before: α : Type u_1
E : Type ?u.16086
F : Type ?u.16089
F' : Type ?u.16092
G : Type ?u.16095
𝕜 : Type ?u.16098
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
β : Type u_2
inst✝ : AddCommMonoid β
T T' : Set α → β
hT : FinMeasAdditive μ T
hT' : FinMeasAdditive μ T'
⊢ FinMeasAdditive μ (T + T')

tactic: simp only [hT s t hs ht hμs hμt hst, hT' s t hs ht hμs hμt hst, Pi.add_apply]
state_before: α : Type u_1
E : Type ?u.16086
F : Type ?u.16089
F' : Type ?u.16092
G : Type ?u.16095
𝕜 : Type ?u.16098
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
β : Type u_2
inst✝ : AddCommMonoid β
T T' : Set α → β
hT : FinMeasAdditive μ T
hT' : FinMeasAdditive μ T'
s t : Set α
hs : MeasurableSet s
ht : MeasurableSet t
hμs : ↑↑μ s ≠ ⊤
hμt : ↑↑μ t ≠ ⊤
hst : s ∩ t = ∅
⊢ (T + T') (s ∪ t) = (T + T') s + (T + T') t

tactic: abel
state_before: α : Type u_1
E : Type ?u.16086
F : Type ?u.16089
F' : Type ?u.16092
G : Type ?u.16095
𝕜 : Type ?u.16098
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
β : Type u_2
inst✝ : AddCommMonoid β
T T' : Set α → β
hT : FinMeasAdditive μ T
hT' : FinMeasAdditive μ T'
s t : Set α
hs : MeasurableSet s
ht : MeasurableSet t
hμs : ↑↑μ s ≠ ⊤
hμt : ↑↑μ t ≠ ⊤
hst : s ∩ t = ∅
⊢ T s + T t + (T' s + T' t) = T s + T' s + (T t + T' t)
Theorem: MeasureTheory.SignedMeasure.toJordanDecomposition_smul_real
File: Mathlib/MeasureTheory/Decomposition/Jordan.lean

tactic: by_cases hr : 0 ≤ r
state_before: α : Type u_1
β : Type ?u.79282
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ
⊢ toJordanDecomposition (r • s) = r • toJordanDecomposition s

tactic: exact toJordanDecomposition_smul_real_nonneg s r hr
state_before: case pos
α : Type u_1
β : Type ?u.79282
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ
hr : 0 ≤ r
⊢ toJordanDecomposition (r • s) = r • toJordanDecomposition s

tactic: ext1
state_before: case neg
α : Type u_1
β : Type ?u.79282
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ
hr : ¬0 ≤ r
⊢ toJordanDecomposition (r • s) = r • toJordanDecomposition s

tactic: rw [real_smul_posPart_neg _ _ (not_le.1 hr),
  show r • s = -(-r • s) by rw [neg_smul, neg_neg], toJordanDecomposition_neg, neg_posPart,
  toJordanDecomposition_smul_real_nonneg, ← smul_negPart, real_smul_nonneg]
state_before: case neg.posPart
α : Type u_1
β : Type ?u.79282
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ
hr : ¬0 ≤ r
⊢ (toJordanDecomposition (r • s)).posPart = (r • toJordanDecomposition s).posPart

tactic: all_goals exact Left.nonneg_neg_iff.2 (le_of_lt (not_le.1 hr))
state_before: case neg.posPart.hr
α : Type u_1
β : Type ?u.79282
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ
hr : ¬0 ≤ r
⊢ 0 ≤ -r

case neg.posPart.hr
α : Type u_1
β : Type ?u.79282
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ
hr : ¬0 ≤ r
⊢ 0 ≤ -r

tactic: rw [neg_smul, neg_neg]
state_before: α : Type u_1
β : Type ?u.79282
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ
hr : ¬0 ≤ r
⊢ r • s = -(-r • s)

tactic: exact Left.nonneg_neg_iff.2 (le_of_lt (not_le.1 hr))
state_before: case neg.posPart.hr
α : Type u_1
β : Type ?u.79282
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ
hr : ¬0 ≤ r
⊢ 0 ≤ -r

tactic: rw [real_smul_negPart_neg _ _ (not_le.1 hr),
  show r • s = -(-r • s) by rw [neg_smul, neg_neg], toJordanDecomposition_neg, neg_negPart,
  toJordanDecomposition_smul_real_nonneg, ← smul_posPart, real_smul_nonneg]
state_before: case neg.negPart
α : Type u_1
β : Type ?u.79282
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ
hr : ¬0 ≤ r
⊢ (toJordanDecomposition (r • s)).negPart = (r • toJordanDecomposition s).negPart

tactic: all_goals exact Left.nonneg_neg_iff.2 (le_of_lt (not_le.1 hr))
state_before: case neg.negPart.hr
α : Type u_1
β : Type ?u.79282
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ
hr : ¬0 ≤ r
⊢ 0 ≤ -r

case neg.negPart.hr
α : Type u_1
β : Type ?u.79282
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ
hr : ¬0 ≤ r
⊢ 0 ≤ -r

tactic: rw [neg_smul, neg_neg]
state_before: α : Type u_1
β : Type ?u.79282
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ
hr : ¬0 ≤ r
⊢ r • s = -(-r • s)

tactic: exact Left.nonneg_neg_iff.2 (le_of_lt (not_le.1 hr))
state_before: case neg.negPart.hr
α : Type u_1
β : Type ?u.79282
inst✝ : MeasurableSpace α
s : SignedMeasure α
r : ℝ
hr : ¬0 ≤ r
⊢ 0 ≤ -r
Theorem: div_lt_div_iff
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [lt_div_iff d0, div_mul_eq_mul_div, div_lt_iff b0]
state_before: ι : Type ?u.67571
α : Type u_1
β : Type ?u.67577
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
b0 : 0 < b
d0 : 0 < d
⊢ a / b < c / d ↔ a * d < c * b
Theorem: CategoryTheory.Bicategory.triangle_assoc_comp_right
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: rw [← triangle, inv_hom_id_assoc]
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
⊢ (α_ f (𝟙 b) g).inv ≫ (ρ_ f).hom ▷ g = f ◁ (λ_ g).hom
Theorem: CategoryTheory.Limits.strongEpi_of_strongEpiMonoFactorisation
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: rw [← IsImage.e_isoExt_hom F.toMonoIsImage hF']
state_before: C : Type u
inst✝ : Category C
X Y : C
f : X ⟶ Y
F : StrongEpiMonoFactorisation f
F' : MonoFactorisation f
hF' : IsImage F'
⊢ StrongEpi F'.e

tactic: apply strongEpi_comp
state_before: C : Type u
inst✝ : Category C
X Y : C
f : X ⟶ Y
F : StrongEpiMonoFactorisation f
F' : MonoFactorisation f
hF' : IsImage F'
⊢ StrongEpi (F.e ≫ (IsImage.isoExt (StrongEpiMonoFactorisation.toMonoIsImage F) hF').hom)
Theorem: Besicovitch.TauPackage.monotone_iUnionUpTo
File: Mathlib/MeasureTheory/Covering/Besicovitch.lean

tactic: intro i j hij
state_before: α : Type u_1
inst✝¹ : MetricSpace α
β : Type u
inst✝ : Nonempty β
p : TauPackage β α
⊢ Monotone (iUnionUpTo p)

tactic: simp only [iUnionUpTo]
state_before: α : Type u_1
inst✝¹ : MetricSpace α
β : Type u
inst✝ : Nonempty β
p : TauPackage β α
i j : Ordinal
hij : i ≤ j
⊢ iUnionUpTo p i ≤ iUnionUpTo p j

tactic: exact iUnion_mono' fun r => ⟨⟨r, r.2.trans_le hij⟩, Subset.rfl⟩
state_before: α : Type u_1
inst✝¹ : MetricSpace α
β : Type u
inst✝ : Nonempty β
p : TauPackage β α
i j : Ordinal
hij : i ≤ j
⊢ (⋃ (j : { j // j < i }),
      ball (BallPackage.c p.toBallPackage (index p ↑j)) (BallPackage.r p.toBallPackage (index p ↑j))) ≤
    ⋃ (j_1 : { j_1 // j_1 < j }),
      ball (BallPackage.c p.toBallPackage (index p ↑j_1)) (BallPackage.r p.toBallPackage (index p ↑j_1))
Theorem: Subalgebra.FG.map
File: Mathlib/RingTheory/Adjoin/FG.lean

tactic: rw [Finset.coe_image, Algebra.adjoin_image, hs]
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
f : A →ₐ[R] B
hs✝ : FG S
s : Finset A
hs : Algebra.adjoin R ↑s = S
⊢ Algebra.adjoin R ↑(Finset.image (↑f) s) = Subalgebra.map f S
Theorem: CategoryTheory.Limits.IsLimit.OfNatIso.coneOfHom_fac
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

tactic: dsimp [coneOfHom, limitCone, Cone.extend]
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor ≅ Functor.cones F
Y : C
f : Y ⟶ X
⊢ coneOfHom h f = Cone.extend (limitCone h) f

tactic: congr with j
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor ≅ Functor.cones F
Y : C
f : Y ⟶ X
⊢ { pt := Y, π := h.hom.app Y.op { down := f } } = { pt := Y, π := (const J).map f ≫ h.hom.app X.op { down := 𝟙 X } }

tactic: have t := congrFun (h.hom.naturality f.op) ⟨𝟙 X⟩
state_before: case e_π.w.h
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor ≅ Functor.cones F
Y : C
f : Y ⟶ X
j : J
⊢ (h.hom.app Y.op { down := f }).app j = ((const J).map f ≫ h.hom.app X.op { down := 𝟙 X }).app j

tactic: dsimp at t
state_before: case e_π.w.h
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t✝ : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor ≅ Functor.cones F
Y : C
f : Y ⟶ X
j : J
t :
  ((yoneda.obj X ⋙ uliftFunctor).map f.op ≫ h.hom.app Y.op) { down := 𝟙 X } =
    (h.hom.app X.op ≫ (Functor.cones F).map f.op) { down := 𝟙 X }
⊢ (h.hom.app Y.op { down := f }).app j = ((const J).map f ≫ h.hom.app X.op { down := 𝟙 X }).app j

tactic: simp only [comp_id] at t
state_before: case e_π.w.h
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t✝ : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor ≅ Functor.cones F
Y : C
f : Y ⟶ X
j : J
t : h.hom.app Y.op { down := f ≫ 𝟙 X } = (Functor.cones F).map f.op (h.hom.app X.op { down := 𝟙 X })
⊢ (h.hom.app Y.op { down := f }).app j = ((const J).map f ≫ h.hom.app X.op { down := 𝟙 X }).app j

tactic: rw [congrFun (congrArg NatTrans.app t) j]
state_before: case e_π.w.h
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t✝ : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor ≅ Functor.cones F
Y : C
f : Y ⟶ X
j : J
t : h.hom.app Y.op { down := f } = (Functor.cones F).map f.op (h.hom.app X.op { down := 𝟙 X })
⊢ (h.hom.app Y.op { down := f }).app j = ((const J).map f ≫ h.hom.app X.op { down := 𝟙 X }).app j

tactic: rfl
state_before: case e_π.w.h
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t✝ : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor ≅ Functor.cones F
Y : C
f : Y ⟶ X
j : J
t : h.hom.app Y.op { down := f } = (Functor.cones F).map f.op (h.hom.app X.op { down := 𝟙 X })
⊢ ((Functor.cones F).map f.op (h.hom.app X.op { down := 𝟙 X })).app j =
    ((const J).map f ≫ h.hom.app X.op { down := 𝟙 X }).app j
Theorem: List.take_add
File: Mathlib/Data/List/Basic.lean

tactic: convert_to take (m + n) (take m l ++ drop m l) = take m l ++ take n (drop m l)
state_before: ι : Type ?u.185033
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
m n : ℕ
⊢ take (m + n) l = take m l ++ take n (drop m l)

tactic: rw [take_append_eq_append_take, take_all_of_le, append_right_inj]
state_before: ι : Type ?u.185033
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
m n : ℕ
⊢ take (m + n) (take m l ++ drop m l) = take m l ++ take n (drop m l)

tactic: rw [take_append_drop]
state_before: case h.e'_2
ι : Type ?u.185033
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
m n : ℕ
⊢ take (m + n) l = take (m + n) (take m l ++ drop m l)

tactic: simp only [take_eq_take, length_take, length_drop]
state_before: ι : Type ?u.185033
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
m n : ℕ
⊢ take (m + n - length (take m l)) (drop m l) = take n (drop m l)

tactic: generalize l.length = k
state_before: ι : Type ?u.185033
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
m n : ℕ
⊢ min (m + n - min m (length l)) (length l - m) = min n (length l - m)

tactic: by_cases h : m ≤ k
state_before: ι : Type ?u.185033
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
m n k : ℕ
⊢ min (m + n - min m k) (k - m) = min n (k - m)

tactic: simp [min_eq_left_iff.mpr h]
state_before: case pos
ι : Type ?u.185033
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
m n k : ℕ
h : m ≤ k
⊢ min (m + n - min m k) (k - m) = min n (k - m)

tactic: push_neg  at h
state_before: case neg
ι : Type ?u.185033
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
m n k : ℕ
h : ¬m ≤ k
⊢ min (m + n - min m k) (k - m) = min n (k - m)

tactic: simp [Nat.sub_eq_zero_of_le (le_of_lt h)]
state_before: case neg
ι : Type ?u.185033
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
m n k : ℕ
h : k < m
⊢ min (m + n - min m k) (k - m) = min n (k - m)

tactic: trans m
state_before: ι : Type ?u.185033
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
m n : ℕ
⊢ length (take m l) ≤ m + n

tactic: apply length_take_le
state_before: ι : Type ?u.185033
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
m n : ℕ
⊢ length (take m l) ≤ m

tactic: simp
state_before: ι : Type ?u.185033
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
m n : ℕ
⊢ m ≤ m + n
Theorem: List.count_cons_of_ne
File: Mathlib/Data/List/Count.lean

tactic: simp [count_cons']
state_before: α : Type u_1
l✝ : List α
inst✝ : DecidableEq α
a b : α
h : a ≠ b
l : List α
⊢ count a (b :: l) = count a l

tactic: exact h
state_before: α : Type u_1
l✝ : List α
inst✝ : DecidableEq α
a b : α
h : a ≠ b
l : List α
⊢ a = b → False
Theorem: HasFTaylorSeriesUpTo.hasFDerivAt
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: rw [← hasFDerivWithinAt_univ]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x✝ x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : HasFTaylorSeriesUpTo n f p
hn : 1 ≤ n
x : E
⊢ HasFDerivAt f (↑(continuousMultilinearCurryFin1 𝕜 E F) (p x 1)) x

tactic: exact (hasFTaylorSeriesUpToOn_univ_iff.2 h).hasFDerivWithinAt hn (mem_univ _)
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x✝ x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : HasFTaylorSeriesUpTo n f p
hn : 1 ≤ n
x : E
⊢ HasFDerivWithinAt f (↑(continuousMultilinearCurryFin1 𝕜 E F) (p x 1)) univ x
Theorem: Int.associated_iff_natAbs
File: Mathlib/RingTheory/Int/Basic.lean

tactic: rw [← dvd_dvd_iff_associated, ← Int.natAbs_dvd_natAbs, ← Int.natAbs_dvd_natAbs,
  dvd_dvd_iff_associated]
state_before: a b : ℤ
⊢ Associated a b ↔ natAbs a = natAbs b

tactic: exact associated_iff_eq
state_before: a b : ℤ
⊢ Associated (natAbs a) (natAbs b) ↔ natAbs a = natAbs b
Theorem: Finset.weightedVSubOfPoint_map
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: simp_rw [weightedVSubOfPoint_apply]
state_before: k : Type u_4
V : Type u_3
P : Type u_5
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_2
s : Finset ι
ι₂ : Type u_1
s₂ : Finset ι₂
e : ι₂ ↪ ι
w : ι → k
p : ι → P
b : P
⊢ ↑(weightedVSubOfPoint (map e s₂) p b) w = ↑(weightedVSubOfPoint s₂ (p ∘ ↑e) b) (w ∘ ↑e)

tactic: exact Finset.sum_map _ _ _
state_before: k : Type u_4
V : Type u_3
P : Type u_5
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_2
s : Finset ι
ι₂ : Type u_1
s₂ : Finset ι₂
e : ι₂ ↪ ι
w : ι → k
p : ι → P
b : P
⊢ ∑ i in map e s₂, w i • (p i -ᵥ b) = ∑ i in s₂, (w ∘ ↑e) i • ((p ∘ ↑e) i -ᵥ b)
Theorem: Set.mulIndicator_image
File: Mathlib/Algebra/IndicatorFunction.lean

tactic: rw [← mulIndicator_comp_right, preimage_image_eq _ hg]
state_before: α : Type u_1
β : Type u_2
ι : Type ?u.22119
M : Type u_3
N : Type ?u.22125
inst✝¹ : One M
inst✝ : One N
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f : β → M
g : α → β
hg : Injective g
x : α
⊢ mulIndicator (g '' s) f (g x) = mulIndicator s (f ∘ g) x
Theorem: Set.indicator_one_inj
File: Mathlib/Algebra/IndicatorFunction.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.150393
ι : Type ?u.150396
M : Type u_2
N : Type ?u.150402
inst✝¹ : MulZeroOneClass M
inst✝ : Nontrivial M
U V : Set α
h : indicator U 1 = indicator V 1
⊢ U = V

tactic: simp_rw [← indicator_eq_one_iff_mem M, h]
state_before: case h
α : Type u_1
β : Type ?u.150393
ι : Type ?u.150396
M : Type u_2
N : Type ?u.150402
inst✝¹ : MulZeroOneClass M
inst✝ : Nontrivial M
U V : Set α
h : indicator U 1 = indicator V 1
x✝ : α
⊢ x✝ ∈ U ↔ x✝ ∈ V
Theorem: isIntegral_tower_top_of_isIntegral
File: Mathlib/RingTheory/IntegralClosure.lean

tactic: rcases h with ⟨p, ⟨hp, hp'⟩⟩
state_before: R : Type u_1
A : Type u_3
B : Type u_2
S : Type ?u.1578175
T : Type ?u.1578178
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : CommRing S
inst✝⁴ : CommRing T
inst✝³ : Algebra A B
inst✝² : Algebra R B
f : R →+* S
g : S →+* T
inst✝¹ : Algebra R A
inst✝ : IsScalarTower R A B
x : B
h : IsIntegral R x
⊢ IsIntegral A x

tactic: refine' ⟨p.map (algebraMap R A), ⟨hp.map (algebraMap R A), _⟩⟩
state_before: case intro.intro
R : Type u_1
A : Type u_3
B : Type u_2
S : Type ?u.1578175
T : Type ?u.1578178
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : CommRing S
inst✝⁴ : CommRing T
inst✝³ : Algebra A B
inst✝² : Algebra R B
f : R →+* S
g : S →+* T
inst✝¹ : Algebra R A
inst✝ : IsScalarTower R A B
x : B
p : R[X]
hp : Monic p
hp' : eval₂ (algebraMap R B) x p = 0
⊢ IsIntegral A x

tactic: rw [IsScalarTower.algebraMap_eq R A B, ← eval₂_map] at hp'
state_before: case intro.intro
R : Type u_1
A : Type u_3
B : Type u_2
S : Type ?u.1578175
T : Type ?u.1578178
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : CommRing S
inst✝⁴ : CommRing T
inst✝³ : Algebra A B
inst✝² : Algebra R B
f : R →+* S
g : S →+* T
inst✝¹ : Algebra R A
inst✝ : IsScalarTower R A B
x : B
p : R[X]
hp : Monic p
hp' : eval₂ (algebraMap R B) x p = 0
⊢ eval₂ (algebraMap A B) x (Polynomial.map (algebraMap R A) p) = 0

tactic: exact hp'
state_before: case intro.intro
R : Type u_1
A : Type u_3
B : Type u_2
S : Type ?u.1578175
T : Type ?u.1578178
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : CommRing S
inst✝⁴ : CommRing T
inst✝³ : Algebra A B
inst✝² : Algebra R B
f : R →+* S
g : S →+* T
inst✝¹ : Algebra R A
inst✝ : IsScalarTower R A B
x : B
p : R[X]
hp : Monic p
hp' : eval₂ (algebraMap A B) x (Polynomial.map (algebraMap R A) p) = 0
⊢ eval₂ (algebraMap A B) x (Polynomial.map (algebraMap R A) p) = 0
Theorem: Ordinal.mem_closure_iff_sup
File: Mathlib/SetTheory/Ordinal/Topology.lean

tactic: simp only [exists_prop]
state_before: s : Set Ordinal
a : Ordinal
⊢ (∃ ι, Nonempty ι ∧ ∃ f, (∀ (i : ι), f i ∈ s) ∧ sup f = a) ↔ ∃ ι x f, (∀ (i : ι), f i ∈ s) ∧ sup f = a
Theorem: SatisfiesM_StateRefT_eq
File: Std/Classes/LawfulMonad.lean

tactic: simp
state_before: m : Type → Type
ω σ α✝ : Type
p : α✝ → Prop
x : StateRefT' ω σ m α✝
inst✝ : Monad m
⊢ SatisfiesM p x ↔ ∀ (s : ST.Ref ω σ), SatisfiesM p (x s)
Theorem: Multiset.map_lt_map
File: Mathlib/Data/Multiset/Basic.lean

tactic: refine' (map_le_map h.le).lt_of_not_le fun H => h.ne <| eq_of_le_of_card_le h.le _
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.126138
f : α → β
s t : Multiset α
h : s < t
⊢ map f s < map f t

tactic: rw [← s.card_map f, ← t.card_map f]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.126138
f : α → β
s t : Multiset α
h : s < t
H : map f t ≤ map f s
⊢ ↑card t ≤ ↑card s

tactic: exact card_le_of_le H
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.126138
f : α → β
s t : Multiset α
h : s < t
H : map f t ≤ map f s
⊢ ↑card (map f t) ≤ ↑card (map f s)
Theorem: Set.image_comm
File: Mathlib/Data/Set/Image.lean

tactic: simp_rw [image_image, h_comm]
state_before: α : Type u_4
β : Type u_3
γ : Type u_2
ι : Sort ?u.27932
ι' : Sort ?u.27935
f✝ : α → β
s t : Set α
β' : Type u_1
f : β → γ
g : α → β
f' : α → β'
g' : β' → γ
h_comm : ∀ (a : α), f (g a) = g' (f' a)
⊢ f '' (g '' s) = g' '' (f' '' s)
Theorem: ZMod.χ₈'_int_eq_χ₄_mul_χ₈
File: Mathlib/NumberTheory/LegendreSymbol/ZModChar.lean

tactic: rw [← @cast_int_cast 8 (ZMod 4) _ 4 _ (by norm_num) a]
state_before: a : ℤ
⊢ ↑χ₈' ↑a = ↑χ₄ ↑a * ↑χ₈ ↑a

tactic: exact χ₈'_eq_χ₄_mul_χ₈ a
state_before: a : ℤ
⊢ ↑χ₈' ↑a = ↑χ₄ ↑↑a * ↑χ₈ ↑a

tactic: norm_num
state_before: a : ℤ
⊢ 4 ∣ 8
Theorem: NNReal.geom_mean_le_arith_mean3_weighted
File: Mathlib/Analysis/MeanInequalities.lean

tactic: simpa only [Fin.prod_univ_succ, Fin.sum_univ_succ, Finset.prod_empty, Finset.sum_empty,
  Fintype.univ_of_isEmpty, Fin.cons_succ, Fin.cons_zero, add_zero, mul_one, ← add_assoc,
  mul_assoc] using geom_mean_le_arith_mean_weighted univ ![w₁, w₂, w₃] ![p₁, p₂, p₃]
state_before: ι : Type u
s : Finset ι
w₁ w₂ w₃ p₁ p₂ p₃ : ℝ≥0
⊢ w₁ + w₂ + w₃ = 1 → p₁ ^ ↑w₁ * p₂ ^ ↑w₂ * p₃ ^ ↑w₃ ≤ w₁ * p₁ + w₂ * p₂ + w₃ * p₃