tasksource/leandojo huggingface dataset:
Theorem: ContinuousLinearMap.comp_smul
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: ext x
state_before: R : Type u_4
R₂ : Type ?u.1028649
R₃ : Type ?u.1028652
S : Type u_3
S₃ : Type ?u.1028658
inst✝³³ : Semiring R
inst✝³² : Semiring R₂
inst✝³¹ : Semiring R₃
inst✝³⁰ : Monoid S
inst✝²⁹ : Monoid S₃
M : Type u_5
inst✝²⁸ : TopologicalSpace M
inst✝²⁷ : AddCommMonoid M
inst✝²⁶ : Module R M
M₂ : Type ?u.1028711
inst✝²⁵ : TopologicalSpace M₂
inst✝²⁴ : AddCommMonoid M₂
inst✝²³ : Module R₂ M₂
M₃ : Type ?u.1028746
inst✝²² : TopologicalSpace M₃
inst✝²¹ : AddCommMonoid M₃
inst✝²⁰ : Module R₃ M₃
N₂ : Type u_1
inst✝¹⁹ : TopologicalSpace N₂
inst✝¹⁸ : AddCommMonoid N₂
inst✝¹⁷ : Module R N₂
N₃ : Type u_2
inst✝¹⁶ : TopologicalSpace N₃
inst✝¹⁵ : AddCommMonoid N₃
inst✝¹⁴ : Module R N₃
inst✝¹³ : DistribMulAction S₃ M₃
inst✝¹² : SMulCommClass R₃ S₃ M₃
inst✝¹¹ : ContinuousConstSMul S₃ M₃
inst✝¹⁰ : DistribMulAction S N₃
inst✝⁹ : SMulCommClass R S N₃
inst✝⁸ : ContinuousConstSMul S N₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁷ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁶ : DistribMulAction S₃ M₂
inst✝⁵ : ContinuousConstSMul S₃ M₂
inst✝⁴ : SMulCommClass R₂ S₃ M₂
inst✝³ : DistribMulAction S N₂
inst✝² : ContinuousConstSMul S N₂
inst✝¹ : SMulCommClass R S N₂
inst✝ : LinearMap.CompatibleSMul N₂ N₃ S R
hₗ : N₂ →L[R] N₃
c : S
fₗ : M →L[R] N₂
⊢ comp hₗ (c • fₗ) = c • comp hₗ fₗ

tactic: exact hₗ.map_smul_of_tower c (fₗ x)
state_before: case h
R : Type u_4
R₂ : Type ?u.1028649
R₃ : Type ?u.1028652
S : Type u_3
S₃ : Type ?u.1028658
inst✝³³ : Semiring R
inst✝³² : Semiring R₂
inst✝³¹ : Semiring R₃
inst✝³⁰ : Monoid S
inst✝²⁹ : Monoid S₃
M : Type u_5
inst✝²⁸ : TopologicalSpace M
inst✝²⁷ : AddCommMonoid M
inst✝²⁶ : Module R M
M₂ : Type ?u.1028711
inst✝²⁵ : TopologicalSpace M₂
inst✝²⁴ : AddCommMonoid M₂
inst✝²³ : Module R₂ M₂
M₃ : Type ?u.1028746
inst✝²² : TopologicalSpace M₃
inst✝²¹ : AddCommMonoid M₃
inst✝²⁰ : Module R₃ M₃
N₂ : Type u_1
inst✝¹⁹ : TopologicalSpace N₂
inst✝¹⁸ : AddCommMonoid N₂
inst✝¹⁷ : Module R N₂
N₃ : Type u_2
inst✝¹⁶ : TopologicalSpace N₃
inst✝¹⁵ : AddCommMonoid N₃
inst✝¹⁴ : Module R N₃
inst✝¹³ : DistribMulAction S₃ M₃
inst✝¹² : SMulCommClass R₃ S₃ M₃
inst✝¹¹ : ContinuousConstSMul S₃ M₃
inst✝¹⁰ : DistribMulAction S N₃
inst✝⁹ : SMulCommClass R S N₃
inst✝⁸ : ContinuousConstSMul S N₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁷ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁶ : DistribMulAction S₃ M₂
inst✝⁵ : ContinuousConstSMul S₃ M₂
inst✝⁴ : SMulCommClass R₂ S₃ M₂
inst✝³ : DistribMulAction S N₂
inst✝² : ContinuousConstSMul S N₂
inst✝¹ : SMulCommClass R S N₂
inst✝ : LinearMap.CompatibleSMul N₂ N₃ S R
hₗ : N₂ →L[R] N₃
c : S
fₗ : M →L[R] N₂
x : M
⊢ ↑(comp hₗ (c • fₗ)) x = ↑(c • comp hₗ fₗ) x
Theorem: Finset.mem_convexHull
File: Mathlib/Analysis/Convex/Combination.lean

tactic: rw [Finset.convexHull_eq, Set.mem_setOf_eq]
state_before: R : Type u_2
E : Type u_1
F : Type ?u.232358
ι : Type ?u.232361
ι' : Type ?u.232364
α : Type ?u.232367
inst✝⁷ : LinearOrderedField R
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s✝ : Set E
i j : ι
c : R
t : Finset ι
w : ι → R
z : ι → E
s : Finset E
x : E
⊢ x ∈ ↑(convexHull R).toOrderHom ↑s ↔ ∃ w x_1 x_2, centerMass s w id = x
Theorem: Nat.card_Iio
File: Mathlib/Data/Nat/Interval.lean

tactic: rw [Iio_eq_Ico, card_Ico, bot_eq_zero, tsub_zero]
state_before: a b c : ℕ
⊢ card (Iio b) = b
Theorem: Set.infinite_image2
File: Mathlib/Data/Set/Finite.lean

tactic: refine' ⟨fun h => Set.infinite_prod.1 _, _⟩
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
f : α → β → γ
s : Set α
t : Set β
a : α
b : β
hfs : ∀ (b : β), b ∈ t → InjOn (fun a => f a b) s
hft : ∀ (a : α), a ∈ s → InjOn (f a) t
⊢ Set.Infinite (image2 f s t) ↔ Set.Infinite s ∧ Set.Nonempty t ∨ Set.Infinite t ∧ Set.Nonempty s

tactic: rw [← image_uncurry_prod] at h
state_before: case refine'_1
α : Type u
β : Type v
ι : Sort w
γ : Type x
f : α → β → γ
s : Set α
t : Set β
a : α
b : β
hfs : ∀ (b : β), b ∈ t → InjOn (fun a => f a b) s
hft : ∀ (a : α), a ∈ s → InjOn (f a) t
h : Set.Infinite (image2 f s t)
⊢ Set.Infinite (s ×ˢ t)

tactic: exact h.of_image _
state_before: case refine'_1
α : Type u
β : Type v
ι : Sort w
γ : Type x
f : α → β → γ
s : Set α
t : Set β
a : α
b : β
hfs : ∀ (b : β), b ∈ t → InjOn (fun a => f a b) s
hft : ∀ (a : α), a ∈ s → InjOn (f a) t
h : Set.Infinite (uncurry f '' s ×ˢ t)
⊢ Set.Infinite (s ×ˢ t)

tactic: rintro (⟨hs, b, hb⟩ | ⟨ht, a, ha⟩)
state_before: case refine'_2
α : Type u
β : Type v
ι : Sort w
γ : Type x
f : α → β → γ
s : Set α
t : Set β
a : α
b : β
hfs : ∀ (b : β), b ∈ t → InjOn (fun a => f a b) s
hft : ∀ (a : α), a ∈ s → InjOn (f a) t
⊢ Set.Infinite s ∧ Set.Nonempty t ∨ Set.Infinite t ∧ Set.Nonempty s → Set.Infinite (image2 f s t)

tactic: exact hs.image2_left hb (hfs _ hb)
state_before: case refine'_2.inl.intro.intro
α : Type u
β : Type v
ι : Sort w
γ : Type x
f : α → β → γ
s : Set α
t : Set β
a : α
b✝ : β
hfs : ∀ (b : β), b ∈ t → InjOn (fun a => f a b) s
hft : ∀ (a : α), a ∈ s → InjOn (f a) t
hs : Set.Infinite s
b : β
hb : b ∈ t
⊢ Set.Infinite (image2 f s t)

tactic: exact ht.image2_right ha (hft _ ha)
state_before: case refine'_2.inr.intro.intro
α : Type u
β : Type v
ι : Sort w
γ : Type x
f : α → β → γ
s : Set α
t : Set β
a✝ : α
b : β
hfs : ∀ (b : β), b ∈ t → InjOn (fun a => f a b) s
hft : ∀ (a : α), a ∈ s → InjOn (f a) t
ht : Set.Infinite t
a : α
ha : a ∈ s
⊢ Set.Infinite (image2 f s t)
Theorem: Units.liftRight_inv_mul
File: Mathlib/Algebra/Hom/Units.lean

tactic: rw [Units.inv_mul_eq_iff_eq_mul, mul_one, coe_liftRight]
state_before: α : Type ?u.32564
M : Type u
N : Type v
P : Type w
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
f : M →* N
g : M → Nˣ
h : ∀ (x : M), ↑(g x) = ↑f x
x : M
⊢ ↑(↑(liftRight f g h) x)⁻¹ * ↑f x = 1
Theorem: Ordinal.lt_add_of_limit
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: have := IsNormal.bsup_eq.{u, u} (add_isNormal b) h
state_before: a b c : Ordinal
h : IsLimit c
⊢ a < b + c ↔ ∃ c', c' < c ∧ a < b + c'

tactic: dsimp only at this
state_before: a b c : Ordinal
h : IsLimit c
this : (bsup c fun x x_1 => (fun x x_2 => x + x_2) b x) = (fun x x_1 => x + x_1) b c
⊢ a < b + c ↔ ∃ c', c' < c ∧ a < b + c'

tactic: rw [← this, lt_bsup, bex_def]
state_before: a b c : Ordinal
h : IsLimit c
this : (bsup c fun x x_1 => b + x) = b + c
⊢ a < b + c ↔ ∃ c', c' < c ∧ a < b + c'
Theorem: CategoryTheory.Limits.prod.map_id_comp
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: simp
state_before: C : Type u
inst✝³ : Category C
X✝ Y✝ X Y Z W : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝² : HasBinaryProduct W X
inst✝¹ : HasBinaryProduct W Y
inst✝ : HasBinaryProduct W Z
⊢ map (𝟙 W) (f ≫ g) = map (𝟙 W) f ≫ map (𝟙 W) g
Theorem: Complex.real_lt_real
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [lt_def, ofReal']
state_before: x y : ℝ
⊢ ↑x < ↑y ↔ x < y
Theorem: Finset.image_mul_left'
File: Mathlib/Data/Finset/Pointwise.lean

tactic: simp
state_before: F : Type ?u.622921
α : Type u_1
β : Type ?u.622927
γ : Type ?u.622930
inst✝⁴ : DecidableEq α
inst✝³ : DecidableEq β
inst✝² : Group α
inst✝¹ : DivisionMonoid β
inst✝ : MonoidHomClass F α β
f : F
s t : Finset α
a b : α
⊢ image (fun b => a⁻¹ * b) t =
    preimage t (fun b => a * b) (_ : Set.InjOn ((fun x x_1 => x * x_1) a) ((fun b => a * b) ⁻¹' ↑t))
Theorem: Polynomial.splits_pow
File: Mathlib/Data/Polynomial/Splits.lean

tactic: rw [← Finset.card_range n, ← Finset.prod_const]
state_before: F : Type u
K : Type v
L : Type w
inst✝² : CommRing K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f : K[X]
hf : Splits i f
n : ℕ
⊢ Splits i (f ^ n)

tactic: exact splits_prod i fun j _ => hf
state_before: F : Type u
K : Type v
L : Type w
inst✝² : CommRing K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f : K[X]
hf : Splits i f
n : ℕ
⊢ Splits i (∏ _x in Finset.range n, f)
Theorem: Real.ofCauchy_sub
File: Mathlib/Data/Real/Basic.lean

tactic: rw [sub_eq_add_neg, ofCauchy_add, ofCauchy_neg]
state_before: x y : ℝ
a b : Cauchy abs
⊢ { cauchy := a - b } = { cauchy := a } - { cauchy := b }

tactic: rfl
state_before: x y : ℝ
a b : Cauchy abs
⊢ { cauchy := a } + -{ cauchy := b } = { cauchy := a } - { cauchy := b }
Theorem: Int.ceil_add_int
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← neg_inj, neg_add', ← floor_neg, ← floor_neg, neg_add', floor_sub_int]
state_before: F : Type ?u.212554
α : Type u_1
β : Type ?u.212560
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ a : α
z : ℤ
⊢ ⌈a + ↑z⌉ = ⌈a⌉ + z
Theorem: Filter.iInf_principal_finite
File: Mathlib/Order/Filter/Basic.lean

tactic: lift s to Finset ι using hs
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.124763
ι✝ : Sort x
f✝ g : Filter α
s✝ t : Set α
ι : Type w
s : Set ι
hs : Set.Finite s
f : ι → Set α
⊢ (⨅ (i : ι) (_ : i ∈ s), 𝓟 (f i)) = 𝓟 (⋂ (i : ι) (_ : i ∈ s), f i)

tactic: exact_mod_cast iInf_principal_finset s f
state_before: case intro
α : Type u
β : Type v
γ : Type w
δ : Type ?u.124763
ι✝ : Sort x
f✝ g : Filter α
s✝ t : Set α
ι : Type w
f : ι → Set α
s : Finset ι
⊢ (⨅ (i : ι) (_ : i ∈ ↑s), 𝓟 (f i)) = 𝓟 (⋂ (i : ι) (_ : i ∈ ↑s), f i)
Theorem: Irrational.of_mul_int
File: Mathlib/Data/Real/Irrational.lean

tactic: rwa [cast_coe_int]
state_before: q : ℚ
x y : ℝ
m : ℤ
h : Irrational (x * ↑m)
⊢ Irrational (x * ↑↑m)
Theorem: Polynomial.lifts_iff_set_range
File: Mathlib/Data/Polynomial/Lifts.lean

tactic: simp only [coe_mapRingHom, lifts, Set.mem_range, RingHom.mem_rangeS]
state_before: R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f : R →+* S
p : S[X]
⊢ p ∈ lifts f ↔ p ∈ Set.range (map f)
Theorem: ContinuousMap.coe_injective
File: Mathlib/Topology/ContinuousFunction/Basic.lean

tactic: cases f
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.24772
δ : Type ?u.24775
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f✝ g✝ f g : C(α, β)
h : ↑f = ↑g
⊢ f = g

tactic: cases g
state_before: case mk
α : Type u_2
β : Type u_1
γ : Type ?u.24772
δ : Type ?u.24775
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f g✝ g : C(α, β)
toFun✝ : α → β
continuous_toFun✝ : Continuous toFun✝
h : ↑(mk toFun✝) = ↑g
⊢ mk toFun✝ = g

tactic: congr
state_before: case mk.mk
α : Type u_2
β : Type u_1
γ : Type ?u.24772
δ : Type ?u.24775
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f g : C(α, β)
toFun✝¹ : α → β
continuous_toFun✝¹ : Continuous toFun✝¹
toFun✝ : α → β
continuous_toFun✝ : Continuous toFun✝
h : ↑(mk toFun✝¹) = ↑(mk toFun✝)
⊢ mk toFun✝¹ = mk toFun✝
Theorem: Int.map_round
File: Mathlib/Algebra/Order/Floor.lean

tactic: have H : f 2 = 2 := map_natCast f 2
state_before: F : Type u_3
α : Type u_1
β : Type u_2
inst✝⁴ : LinearOrderedField α
inst✝³ : LinearOrderedField β
inst✝² : FloorRing α
inst✝¹ : FloorRing β
inst✝ : RingHomClass F α β
a✝ : α
b : β
f : F
hf : StrictMono ↑f
a : α
⊢ round (↑f a) = round a

tactic: simp_rw [round_eq, ← map_floor _ hf, map_add, one_div, map_inv₀, H]
state_before: F : Type u_3
α : Type u_1
β : Type u_2
inst✝⁴ : LinearOrderedField α
inst✝³ : LinearOrderedField β
inst✝² : FloorRing α
inst✝¹ : FloorRing β
inst✝ : RingHomClass F α β
a✝ : α
b : β
f : F
hf : StrictMono ↑f
a : α
H : ↑f 2 = 2
⊢ round (↑f a) = round a
Theorem: Polynomial.tendsto_atBot_iff_leadingCoeff_nonpos
File: Mathlib/Analysis/SpecialFunctions/Polynomials.lean

tactic: simp only [← tendsto_neg_atTop_iff, ← eval_neg, tendsto_atTop_iff_leadingCoeff_nonneg,
  degree_neg, leadingCoeff_neg, neg_nonneg]
state_before: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
⊢ Tendsto (fun x => eval x P) atTop atBot ↔ 0 < degree P ∧ leadingCoeff P ≤ 0
Theorem: Polynomial.aeval_map_algebraMap
File: Mathlib/RingTheory/Polynomial/Tower.lean

tactic: rw [aeval_def, aeval_def, eval₂_map, IsScalarTower.algebraMap_eq R A B]
state_before: R : Type u_1
A : Type u_3
B : Type u_2
inst✝⁶ : CommSemiring R
inst✝⁵ : CommSemiring A
inst✝⁴ : Semiring B
inst✝³ : Algebra R A
inst✝² : Algebra A B
inst✝¹ : Algebra R B
inst✝ : IsScalarTower R A B
x : B
p : R[X]
⊢ ↑(aeval x) (map (algebraMap R A) p) = ↑(aeval x) p
Theorem: eq_mp_bijective
File: Mathlib/Logic/Function/Basic.lean

tactic: cases h
state_before: α β : Sort u_1
h : α = β
⊢ Bijective (Eq.mp h)

tactic: refine ⟨fun _ _ ↦ id, fun x ↦ ⟨x, rfl⟩⟩
state_before: case refl
α : Sort u_1
⊢ Bijective (Eq.mp (_ : α = α))
Theorem: Std.AssocList.find?_eq_findEntry?
File: Std/Data/AssocList.lean

tactic: induction l <;> simp [find?]
state_before: α : Type u_1
β : Type u_2
inst✝ : BEq α
a : α
l : AssocList α β
⊢ find? a l = Option.map (fun x => x.snd) (findEntry? a l)

tactic: split <;> simp [*]
state_before: case cons
α : Type u_1
β : Type u_2
inst✝ : BEq α
a key✝ : α
value✝ : β
tail✝ : AssocList α β
tail_ih✝ : find? a tail✝ = Option.map (fun x => x.snd) (findEntry? a tail✝)
⊢ (match key✝ == a with
    | true => some value✝
    | false => find? a tail✝) =
    Option.map (fun x => x.snd)
      (match key✝ == a with
      | true => some (key✝, value✝)
      | false => List.find? (fun x => x.fst == a) (toList tail✝))
Theorem: Polynomial.Monic.eq_X_add_C
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [← one_mul X, ← C_1, ← hm.coeff_natDegree, hnd, ← eq_X_add_C_of_natDegree_le_one hnd.le]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
hm : Monic p
hnd : natDegree p = 1
⊢ p = X + ↑C (coeff p 0)
Theorem: Multiset.Ico_cons_right
File: Mathlib/Data/Multiset/LocallyFinite.lean

tactic: classical
  rw [Ico, ← Finset.insert_val_of_not_mem right_not_mem_Ico, Finset.Ico_insert_right h]
  rfl
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a b : α
h : a ≤ b
⊢ b ::ₘ Ico a b = Icc a b

tactic: rw [Ico, ← Finset.insert_val_of_not_mem right_not_mem_Ico, Finset.Ico_insert_right h]
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a b : α
h : a ≤ b
⊢ b ::ₘ Ico a b = Icc a b

tactic: rfl
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a b : α
h : a ≤ b
⊢ (Finset.Icc a b).val = Icc a b
Theorem: Complex.norm_max_aux₃
File: Mathlib/Analysis/Complex/AbsMax.lean

tactic: subst r
state_before: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : ℂ → F
z w : ℂ
r : ℝ
hr : dist w z = r
hd : DiffContOnCl ℂ f (ball z r)
hz : IsMaxOn (norm ∘ f) (ball z r) z
⊢ ‖f w‖ = ‖f z‖

tactic: rcases eq_or_ne w z with (rfl | hne)
state_before: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : ℂ → F
z w : ℂ
hd : DiffContOnCl ℂ f (ball z (dist w z))
hz : IsMaxOn (norm ∘ f) (ball z (dist w z)) z
⊢ ‖f w‖ = ‖f z‖

tactic: rw [← dist_ne_zero] at hne
state_before: case inr
E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : ℂ → F
z w : ℂ
hd : DiffContOnCl ℂ f (ball z (dist w z))
hz : IsMaxOn (norm ∘ f) (ball z (dist w z)) z
hne : w ≠ z
⊢ ‖f w‖ = ‖f z‖

tactic: exact norm_max_aux₂ hd (closure_ball z hne ▸ hz.closure hd.continuousOn.norm)
state_before: case inr
E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : ℂ → F
z w : ℂ
hd : DiffContOnCl ℂ f (ball z (dist w z))
hz : IsMaxOn (norm ∘ f) (ball z (dist w z)) z
hne✝ : w ≠ z
hne : dist w z ≠ 0
⊢ ‖f w‖ = ‖f z‖

tactic: rfl
state_before: case inl
E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : ℂ → F
w : ℂ
hd : DiffContOnCl ℂ f (ball w (dist w w))
hz : IsMaxOn (norm ∘ f) (ball w (dist w w)) w
⊢ ‖f w‖ = ‖f w‖
Theorem: CategoryTheory.Subobject.factors_of_factors_right
File: Mathlib/CategoryTheory/Subobject/FactorThru.lean

tactic: induction' P using Quotient.ind' with P
state_before: C : Type u₁
inst✝¹ : Category C
X✝ Y✝ Z✝ : C
D : Type u₂
inst✝ : Category D
X Y Z : C
P : Subobject Z
f : X ⟶ Y
g : Y ⟶ Z
h : Factors P g
⊢ Factors P (f ≫ g)

tactic: obtain ⟨g, rfl⟩ := h
state_before: case h
C : Type u₁
inst✝¹ : Category C
X✝ Y✝ Z✝ : C
D : Type u₂
inst✝ : Category D
X Y Z : C
P✝ : Subobject Z
f : X ⟶ Y
g : Y ⟶ Z
h✝ : Factors P✝ g
P : MonoOver Z
h : Factors (Quotient.mk'' P) g
⊢ Factors (Quotient.mk'' P) (f ≫ g)

tactic: exact ⟨f ≫ g, by simp⟩
state_before: case h.intro
C : Type u₁
inst✝¹ : Category C
X✝ Y✝ Z✝ : C
D : Type u₂
inst✝ : Category D
X Y Z : C
P✝ : Subobject Z
f : X ⟶ Y
P : MonoOver Z
g : Y ⟶ P.obj.left
h : Factors P✝ (g ≫ MonoOver.arrow P)
⊢ Factors (Quotient.mk'' P) (f ≫ g ≫ MonoOver.arrow P)

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category C
X✝ Y✝ Z✝ : C
D : Type u₂
inst✝ : Category D
X Y Z : C
P✝ : Subobject Z
f : X ⟶ Y
P : MonoOver Z
g : Y ⟶ P.obj.left
h : Factors P✝ (g ≫ MonoOver.arrow P)
⊢ (f ≫ g) ≫ MonoOver.arrow P = f ≫ g ≫ MonoOver.arrow P
Theorem: le_of_forall_one_lt_lt_mul
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: simpa using h _ (lt_inv_mul_iff_lt.mpr h₁)
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LinearOrder α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
h : ∀ (ε : α), 1 < ε → a < b * ε
h₁ : b < a
⊢ a < a
Theorem: Polynomial.derivative_expand
File: Mathlib/Data/Polynomial/Expand.lean

tactic: rw [coe_expand, derivative_eval₂_C, derivative_pow, C_eq_nat_cast, derivative_X, mul_one]
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p q : ℕ
f : R[X]
⊢ ↑derivative (↑(expand R p) f) = ↑(expand R p) (↑derivative f) * (↑p * X ^ (p - 1))
Theorem: Configuration.sum_lineCount_eq_sum_pointCount
File: Mathlib/Combinatorics/Configuration.lean

tactic: simp only [lineCount, pointCount, Nat.card_eq_fintype_card, ← Fintype.card_sigma]
state_before: P : Type u_1
L : Type u_2
inst✝² : Membership P L
inst✝¹ : Fintype P
inst✝ : Fintype L
⊢ ∑ p : P, lineCount L p = ∑ l : L, pointCount P l

tactic: apply Fintype.card_congr
state_before: P : Type u_1
L : Type u_2
inst✝² : Membership P L
inst✝¹ : Fintype P
inst✝ : Fintype L
⊢ Fintype.card ((a : P) × { l // a ∈ l }) = Fintype.card ((a : L) × { p // p ∈ a })
Theorem: Option.orElse_eq_some
File: Mathlib/Data/Option/Basic.lean

tactic: cases o
state_before: α : Type u_1
β : Type ?u.19034
γ : Type ?u.19037
δ : Type ?u.19040
o o' : Option α
x : α
⊢ (HOrElse.hOrElse o fun x => o') = some x ↔ o = some x ∨ o = none ∧ o' = some x

tactic: simp only [true_and, false_or, eq_self_iff_true, none_orElse]
state_before: case none
α : Type u_1
β : Type ?u.19034
γ : Type ?u.19037
δ : Type ?u.19040
o' : Option α
x : α
⊢ (HOrElse.hOrElse none fun x => o') = some x ↔ none = some x ∨ none = none ∧ o' = some x

tactic: simp only [some_orElse, or_false, false_and]
state_before: case some
α : Type u_1
β : Type ?u.19034
γ : Type ?u.19037
δ : Type ?u.19040
o' : Option α
x val✝ : α
⊢ (HOrElse.hOrElse (some val✝) fun x => o') = some x ↔ some val✝ = some x ∨ some val✝ = none ∧ o' = some x
Theorem: Filter.hasBasis_iSup
File: Mathlib/Order/Filter/Bases.lean

tactic: simp only [hasBasis_iff, (hl _).mem_iff, Classical.skolem, forall_and, iUnion_subset_iff,
  mem_iSup]
state_before: α : Type u_3
β : Type ?u.41707
γ : Type ?u.41710
ι✝ : Sort ?u.41713
ι'✝ : Sort ?u.41716
l✝ l' : Filter α
p✝ : ι✝ → Prop
s✝ : ι✝ → Set α
t✝ : Set α
i : ι✝
p' : ι'✝ → Prop
s' : ι'✝ → Set α
i' : ι'✝
ι : Sort u_1
ι' : ι → Type u_2
l : ι → Filter α
p : (i : ι) → ι' i → Prop
s : (i : ι) → ι' i → Set α
hl : ∀ (i : ι), HasBasis (l i) (p i) (s i)
t : Set α
⊢ (t ∈ ⨆ (i : ι), l i) ↔ ∃ i, (∀ (i_1 : ι), p i_1 (i i_1)) ∧ (⋃ (i_1 : ι), s i_1 (i i_1)) ⊆ t
Theorem: eq_inv_mul_of_mul_eq
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp [h.symm]
state_before: α : Type ?u.50338
β : Type ?u.50341
G : Type u_1
inst✝ : Group G
a b c d : G
h : b * a = c
⊢ a = b⁻¹ * c
Theorem: MeasureTheory.Lp.norm_le_of_ae_bound
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: lift C to ℝ≥0 using hC
state_before: α : Type u_1
E : Type u_2
F : Type ?u.436188
G : Type ?u.436191
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
inst✝ : IsFiniteMeasure μ
f : { x // x ∈ Lp E p }
C : ℝ
hC : 0 ≤ C
hfC : ∀ᵐ (x : α) ∂μ, ‖↑↑f x‖ ≤ C
⊢ ‖f‖ ≤ ↑(measureUnivNNReal μ ^ (ENNReal.toReal p)⁻¹) * C

tactic: have := nnnorm_le_of_ae_bound hfC
state_before: case intro
α : Type u_1
E : Type u_2
F : Type ?u.436188
G : Type ?u.436191
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
inst✝ : IsFiniteMeasure μ
f : { x // x ∈ Lp E p }
C : ℝ≥0
hfC : ∀ᵐ (x : α) ∂μ, ‖↑↑f x‖ ≤ ↑C
⊢ ‖f‖ ≤ ↑(measureUnivNNReal μ ^ (ENNReal.toReal p)⁻¹) * ↑C

tactic: rwa [← NNReal.coe_le_coe, NNReal.coe_mul, NNReal.coe_rpow] at this
state_before: case intro
α : Type u_1
E : Type u_2
F : Type ?u.436188
G : Type ?u.436191
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
inst✝ : IsFiniteMeasure μ
f : { x // x ∈ Lp E p }
C : ℝ≥0
hfC : ∀ᵐ (x : α) ∂μ, ‖↑↑f x‖ ≤ ↑C
this : ‖f‖₊ ≤ measureUnivNNReal μ ^ (ENNReal.toReal p)⁻¹ * C
⊢ ‖f‖ ≤ ↑(measureUnivNNReal μ ^ (ENNReal.toReal p)⁻¹) * ↑C
Theorem: PEquiv.matrix_mul_apply
File: Mathlib/Data/Matrix/PEquiv.lean

tactic: dsimp [toMatrix, Matrix.mul_apply]
state_before: k : Type ?u.10982
l : Type u_3
m : Type u_1
n : Type u_2
α : Type v
inst✝² : Fintype m
inst✝¹ : Semiring α
inst✝ : DecidableEq n
M : Matrix l m α
f : m ≃. n
i : l
j : n
⊢ (M ⬝ toMatrix f) i j = Option.casesOn (↑(PEquiv.symm f) j) 0 fun fj => M i fj

tactic: cases' h : f.symm j with fj
state_before: k : Type ?u.10982
l : Type u_3
m : Type u_1
n : Type u_2
α : Type v
inst✝² : Fintype m
inst✝¹ : Semiring α
inst✝ : DecidableEq n
M : Matrix l m α
f : m ≃. n
i : l
j : n
⊢ (Finset.sum Finset.univ fun j_1 => M i j_1 * if j ∈ ↑f j_1 then 1 else 0) =
    Option.rec 0 (fun val => M i val) (↑(PEquiv.symm f) j)

tactic: simp [h, ← f.eq_some_iff]
state_before: case none
k : Type ?u.10982
l : Type u_3
m : Type u_1
n : Type u_2
α : Type v
inst✝² : Fintype m
inst✝¹ : Semiring α
inst✝ : DecidableEq n
M : Matrix l m α
f : m ≃. n
i : l
j : n
h : ↑(PEquiv.symm f) j = none
⊢ (Finset.sum Finset.univ fun j_1 => M i j_1 * if j ∈ ↑f j_1 then 1 else 0) = Option.rec 0 (fun val => M i val) none

tactic: rw [Finset.sum_eq_single fj]
state_before: case some
k : Type ?u.10982
l : Type u_3
m : Type u_1
n : Type u_2
α : Type v
inst✝² : Fintype m
inst✝¹ : Semiring α
inst✝ : DecidableEq n
M : Matrix l m α
f : m ≃. n
i : l
j : n
fj : m
h : ↑(PEquiv.symm f) j = some fj
⊢ (Finset.sum Finset.univ fun j_1 => M i j_1 * if j ∈ ↑f j_1 then 1 else 0) =
    Option.rec 0 (fun val => M i val) (some fj)

tactic: simp [h, ← f.eq_some_iff]
state_before: case some
k : Type ?u.10982
l : Type u_3
m : Type u_1
n : Type u_2
α : Type v
inst✝² : Fintype m
inst✝¹ : Semiring α
inst✝ : DecidableEq n
M : Matrix l m α
f : m ≃. n
i : l
j : n
fj : m
h : ↑(PEquiv.symm f) j = some fj
⊢ (M i fj * if j ∈ ↑f fj then 1 else 0) = Option.rec 0 (fun val => M i val) (some fj)

tactic: rintro b - n
state_before: case some.h₀
k : Type ?u.10982
l : Type u_3
m : Type u_1
n : Type u_2
α : Type v
inst✝² : Fintype m
inst✝¹ : Semiring α
inst✝ : DecidableEq n
M : Matrix l m α
f : m ≃. n
i : l
j : n
fj : m
h : ↑(PEquiv.symm f) j = some fj
⊢ ∀ (b : m), b ∈ Finset.univ → b ≠ fj → (M i b * if j ∈ ↑f b then 1 else 0) = 0

tactic: simp [h, ← f.eq_some_iff, n.symm]
state_before: case some.h₀
k : Type ?u.10982
l : Type u_3
m : Type u_1
n✝ : Type u_2
α : Type v
inst✝² : Fintype m
inst✝¹ : Semiring α
inst✝ : DecidableEq n✝
M : Matrix l m α
f : m ≃. n✝
i : l
j : n✝
fj : m
h : ↑(PEquiv.symm f) j = some fj
b : m
n : b ≠ fj
⊢ (M i b * if j ∈ ↑f b then 1 else 0) = 0

tactic: simp
state_before: case some.h₁
k : Type ?u.10982
l : Type u_3
m : Type u_1
n : Type u_2
α : Type v
inst✝² : Fintype m
inst✝¹ : Semiring α
inst✝ : DecidableEq n
M : Matrix l m α
f : m ≃. n
i : l
j : n
fj : m
h : ↑(PEquiv.symm f) j = some fj
⊢ ¬fj ∈ Finset.univ → (M i fj * if j ∈ ↑f fj then 1 else 0) = 0