tasksource/leandojo huggingface dataset:
Theorem: Pmf.uniformOfFinset_apply_of_mem
File: Mathlib/Probability/ProbabilityMassFunction/Uniform.lean

tactic: simp [ha]
state_before: α : Type u_1
β : Type ?u.4518
γ : Type ?u.4521
s : Finset α
hs : Finset.Nonempty s
a : α
ha : a ∈ s
⊢ ↑(uniformOfFinset s hs) a = (↑(Finset.card s))⁻¹
Theorem: Set.le_ncard_of_inj_on_range
File: Mathlib/Data/Set/Ncard.lean

tactic: rw [ncard_eq_toFinset_card _ hs]
state_before: α : Type u_1
β : Type ?u.90617
s t : Set α
a b x y : α
f✝ : α → β
n : ℕ
f : ℕ → α
hf : ∀ (i : ℕ), i < n → f i ∈ s
f_inj : ∀ (i : ℕ), i < n → ∀ (j : ℕ), j < n → f i = f j → i = j
hs : autoParam (Set.Finite s) _auto✝
⊢ n ≤ ncard s

tactic: apply Finset.le_card_of_inj_on_range <;> simpa
state_before: α : Type u_1
β : Type ?u.90617
s t : Set α
a b x y : α
f✝ : α → β
n : ℕ
f : ℕ → α
hf : ∀ (i : ℕ), i < n → f i ∈ s
f_inj : ∀ (i : ℕ), i < n → ∀ (j : ℕ), j < n → f i = f j → i = j
hs : autoParam (Set.Finite s) _auto✝
⊢ n ≤ Finset.card (Finite.toFinset hs)
Theorem: CategoryTheory.monadToFunctor_mapIso_monad_iso_mk
File: Mathlib/CategoryTheory/Monad/Basic.lean

tactic: ext
state_before: C : Type u₁
inst✝ : Category C
T : Monad C
G : Comonad C
M N : Monad C
f : M.toFunctor ≅ N.toFunctor
f_η : ∀ (X : C), (Monad.η M).app X ≫ f.hom.app X = (Monad.η N).app X
f_μ : ∀ (X : C), (Monad.μ M).app X ≫ f.hom.app X = (M.map (f.hom.app X) ≫ f.hom.app (N.obj X)) ≫ (Monad.μ N).app X
⊢ (monadToFunctor C).mapIso (MonadIso.mk f) = f

tactic: rfl
state_before: case w.w.h
C : Type u₁
inst✝ : Category C
T : Monad C
G : Comonad C
M N : Monad C
f : M.toFunctor ≅ N.toFunctor
f_η : ∀ (X : C), (Monad.η M).app X ≫ f.hom.app X = (Monad.η N).app X
f_μ : ∀ (X : C), (Monad.μ M).app X ≫ f.hom.app X = (M.map (f.hom.app X) ≫ f.hom.app (N.obj X)) ≫ (Monad.μ N).app X
x✝ : C
⊢ ((monadToFunctor C).mapIso (MonadIso.mk f)).hom.app x✝ = f.hom.app x✝
Theorem: LieHom.coe_injective
File: Mathlib/Algebra/Lie/Basic.lean

tactic: rintro ⟨⟨⟨f, _⟩, _⟩, _⟩ ⟨⟨⟨g, _⟩, _⟩, _⟩ h
state_before: R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
⊢ Injective FunLike.coe

tactic: congr
state_before: case mk.mk.mk.mk.mk.mk
R : Type u
L₁ : Type v
L₂ : Type w
L₃ : Type w₁
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L₁
inst✝⁴ : LieAlgebra R L₁
inst✝³ : LieRing L₂
inst✝² : LieAlgebra R L₂
inst✝¹ : LieRing L₃
inst✝ : LieAlgebra R L₃
f : L₁ → L₂
map_add'✝¹ : ∀ (x y : L₁), f (x + y) = f x + f y
map_smul'✝¹ :
  ∀ (r : R) (x : L₁),
    AddHom.toFun { toFun := f, map_add' := map_add'✝¹ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := f, map_add' := map_add'✝¹ } x
map_lie'✝¹ :
  ∀ {x y : L₁},
    AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom ⁅x, y⁆ =
      ⁅AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom x,
        AddHom.toFun { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ }.toAddHom y⁆
g : L₁ → L₂
map_add'✝ : ∀ (x y : L₁), g (x + y) = g x + g y
map_smul'✝ :
  ∀ (r : R) (x : L₁),
    AddHom.toFun { toFun := g, map_add' := map_add'✝ } (r • x) =
      ↑(RingHom.id R) r • AddHom.toFun { toFun := g, map_add' := map_add'✝ } x
map_lie'✝ :
  ∀ {x y : L₁},
    AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom ⁅x, y⁆ =
      ⁅AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom x,
        AddHom.toFun { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ }.toAddHom y⁆
h :
  ↑{ toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
        map_lie' := map_lie'✝¹ } =
    ↑{ toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
        map_lie' := map_lie'✝ }
⊢ { toLinearMap := { toAddHom := { toFun := f, map_add' := map_add'✝¹ }, map_smul' := map_smul'✝¹ },
      map_lie' := map_lie'✝¹ } =
    { toLinearMap := { toAddHom := { toFun := g, map_add' := map_add'✝ }, map_smul' := map_smul'✝ },
      map_lie' := map_lie'✝ }
Theorem: Num.ldiff'_to_nat
File: Mathlib/Data/Num/Lemmas.lean

tactic: apply bitwise'_to_nat PosNum.ldiff <;> intros <;> cases_type* Bool <;> rfl
state_before: α : Type ?u.612393
⊢ ∀ (m n : Num), ↑(ldiff m n) = Nat.ldiff' ↑m ↑n
Theorem: Computation.bind_promises
File: Mathlib/Data/Seq/Computation.lean

tactic: rcases exists_of_mem_bind bB with ⟨a', a's, ba'⟩
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
f : α → Computation β
a : α
b : β
h1 : s ~> a
h2 : f a ~> b
b' : β
bB : b' ∈ bind s f
⊢ b = b'

tactic: rw [← h1 a's] at ba'
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
s : Computation α
f : α → Computation β
a : α
b : β
h1 : s ~> a
h2 : f a ~> b
b' : β
bB : b' ∈ bind s f
a' : α
a's : a' ∈ s
ba' : b' ∈ f a'
⊢ b = b'

tactic: exact h2 ba'
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
s : Computation α
f : α → Computation β
a : α
b : β
h1 : s ~> a
h2 : f a ~> b
b' : β
bB : b' ∈ bind s f
a' : α
a's : a' ∈ s
ba' : b' ∈ f a
⊢ b = b'
Theorem: List.map_reverse_tails
File: Mathlib/Data/List/Infix.lean

tactic: rw [tails_eq_inits l]
state_before: α : Type u_1
β : Type ?u.48141
l✝ l₁ l₂ l₃ : List α
a b : α
m n : ℕ
l : List α
⊢ map reverse (tails l) = reverse (inits (reverse l))

tactic: simp [reverse_involutive.comp_self, reverse_map]
state_before: α : Type u_1
β : Type ?u.48141
l✝ l₁ l₂ l₃ : List α
a b : α
m n : ℕ
l : List α
⊢ map reverse (reverse (map reverse (inits (reverse l)))) = reverse (inits (reverse l))
Theorem: mul_mem_cancel_left
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: simpa using mul_mem (inv_mem h) hab
state_before: G : Type u_1
G' : Type ?u.14819
inst✝⁶ : Group G
inst✝⁵ : Group G'
A : Type ?u.14828
inst✝⁴ : AddGroup A
M : Type ?u.14834
S : Type u_2
inst✝³ : DivInvMonoid M
inst✝² : SetLike S M
hSM : SubgroupClass S M
H K : S
inst✝¹ : SetLike S G
inst✝ : SubgroupClass S G
x y : G
h : x ∈ H
this : SubmonoidClass S G
hab : x * y ∈ H
⊢ y ∈ H
Theorem: Ideal.prime_of_isPrime
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: refine ⟨hP, mt Ideal.isUnit_iff.mp h.ne_top, fun I J hIJ => ?_⟩
state_before: R : Type ?u.797297
A : Type u_1
K : Type ?u.797303
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : Field K
inst✝³ : IsDomain A
inst✝² : IsDedekindDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
P : Ideal A
hP : P ≠ ⊥
h : IsPrime P
⊢ Prime P

tactic: simpa only [Ideal.dvd_iff_le] using h.mul_le.mp (Ideal.le_of_dvd hIJ)
state_before: R : Type ?u.797297
A : Type u_1
K : Type ?u.797303
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : Field K
inst✝³ : IsDomain A
inst✝² : IsDedekindDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
P : Ideal A
hP : P ≠ ⊥
h : IsPrime P
I J : Ideal A
hIJ : P ∣ I * J
⊢ P ∣ I ∨ P ∣ J
Theorem: CategoryTheory.braiding_leftUnitor_aux₁
File: Mathlib/CategoryTheory/Monoidal/Braided.lean

tactic: rw [← leftUnitor_tensor, leftUnitor_naturality]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X : C
⊢ (α_ (𝟙_ C) (𝟙_ C) X).hom ≫ (𝟙 (𝟙_ C) ⊗ (β_ X (𝟙_ C)).inv) ≫ (α_ (𝟙_ C) X (𝟙_ C)).inv ≫ ((λ_ X).hom ⊗ 𝟙 (𝟙_ C)) =
    ((λ_ (𝟙_ C)).hom ⊗ 𝟙 X) ≫ (β_ X (𝟙_ C)).inv

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X : C
⊢ (α_ (𝟙_ C) (𝟙_ C) X).hom ≫ (λ_ (𝟙_ C ⊗ X)).hom ≫ (β_ X (𝟙_ C)).inv = ((λ_ (𝟙_ C)).hom ⊗ 𝟙 X) ≫ (β_ X (𝟙_ C)).inv
Theorem: LipschitzWith.pow
File: Mathlib/Topology/MetricSpace/Lipschitz.lean

tactic: simpa only [pow_zero] using LipschitzWith.id
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K✝ : ℝ≥0
f✝ : α → β
x y : α
r : ℝ≥0∞
f : Function.End α
K : ℝ≥0
h : LipschitzWith K f
⊢ LipschitzWith (K ^ 0) (f ^ 0)

tactic: rw [pow_succ, pow_succ]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K✝ : ℝ≥0
f✝ : α → β
x y : α
r : ℝ≥0∞
f : Function.End α
K : ℝ≥0
h : LipschitzWith K f
n : ℕ
⊢ LipschitzWith (K ^ (n + 1)) (f ^ (n + 1))

tactic: exact h.mul (LipschitzWith.pow h n)
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K✝ : ℝ≥0
f✝ : α → β
x y : α
r : ℝ≥0∞
f : Function.End α
K : ℝ≥0
h : LipschitzWith K f
n : ℕ
⊢ LipschitzWith (K * K ^ n) (f * f ^ n)
Theorem: Polynomial.hasseDeriv_one'
File: Mathlib/Data/Polynomial/HasseDeriv.lean

tactic: simp only [hasseDeriv_apply, derivative_apply, ← C_mul_X_pow_eq_monomial, Nat.choose_one_right,
  (Nat.cast_commute _ _).eq]
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
⊢ ↑(hasseDeriv 1) f = ↑derivative f
Theorem: sum_eight_sq_mul_sum_eight_sq
File: Mathlib/Algebra/GroupPower/Identities.lean

tactic: ring
state_before: R : Type u_1
inst✝ : CommRing R
a b x₁ x₂ x₃ x₄ x₅ x₆ x₇ x₈ y₁ y₂ y₃ y₄ y₅ y₆ y₇ y₈ n : R
⊢ (x₁ ^ 2 + x₂ ^ 2 + x₃ ^ 2 + x₄ ^ 2 + x₅ ^ 2 + x₆ ^ 2 + x₇ ^ 2 + x₈ ^ 2) *
      (y₁ ^ 2 + y₂ ^ 2 + y₃ ^ 2 + y₄ ^ 2 + y₅ ^ 2 + y₆ ^ 2 + y₇ ^ 2 + y₈ ^ 2) =
    (x₁ * y₁ - x₂ * y₂ - x₃ * y₃ - x₄ * y₄ - x₅ * y₅ - x₆ * y₆ - x₇ * y₇ - x₈ * y₈) ^ 2 +
                  (x₁ * y₂ + x₂ * y₁ + x₃ * y₄ - x₄ * y₃ + x₅ * y₆ - x₆ * y₅ - x₇ * y₈ + x₈ * y₇) ^ 2 +
                (x₁ * y₃ - x₂ * y₄ + x₃ * y₁ + x₄ * y₂ + x₅ * y₇ + x₆ * y₈ - x₇ * y₅ - x₈ * y₆) ^ 2 +
              (x₁ * y₄ + x₂ * y₃ - x₃ * y₂ + x₄ * y₁ + x₅ * y₈ - x₆ * y₇ + x₇ * y₆ - x₈ * y₅) ^ 2 +
            (x₁ * y₅ - x₂ * y₆ - x₃ * y₇ - x₄ * y₈ + x₅ * y₁ + x₆ * y₂ + x₇ * y₃ + x₈ * y₄) ^ 2 +
          (x₁ * y₆ + x₂ * y₅ - x₃ * y₈ + x₄ * y₇ - x₅ * y₂ + x₆ * y₁ - x₇ * y₄ + x₈ * y₃) ^ 2 +
        (x₁ * y₇ + x₂ * y₈ + x₃ * y₅ - x₄ * y₆ - x₅ * y₃ + x₆ * y₄ + x₇ * y₁ - x₈ * y₂) ^ 2 +
      (x₁ * y₈ - x₂ * y₇ + x₃ * y₆ + x₄ * y₅ - x₅ * y₄ - x₆ * y₃ + x₇ * y₂ + x₈ * y₁) ^ 2
Theorem: Asymptotics.isBigOWith_zero'
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.260515
E : Type ?u.260518
F : Type u_3
G : Type ?u.260524
E' : Type u_2
F' : Type ?u.260530
G' : Type ?u.260533
E'' : Type ?u.260536
F'' : Type ?u.260539
G'' : Type ?u.260542
R : Type ?u.260545
R' : Type ?u.260548
𝕜 : Type ?u.260551
𝕜' : Type ?u.260554
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
x : α
⊢ x ∈ {x | (fun x => ‖0‖ ≤ 0 * ‖g x‖) x}
Theorem: MeasureTheory.measure_biUnion_le
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: haveI := hs.to_subtype
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.17016
δ : Type ?u.17019
ι : Type ?u.17022
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
s : Set β
hs : Set.Countable s
f : β → Set α
⊢ ↑↑μ (⋃ (b : β) (_ : b ∈ s), f b) ≤ ∑' (p : ↑s), ↑↑μ (f ↑p)

tactic: rw [biUnion_eq_iUnion]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.17016
δ : Type ?u.17019
ι : Type ?u.17022
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
s : Set β
hs : Set.Countable s
f : β → Set α
this : Countable ↑s
⊢ ↑↑μ (⋃ (b : β) (_ : b ∈ s), f b) ≤ ∑' (p : ↑s), ↑↑μ (f ↑p)

tactic: apply measure_iUnion_le
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.17016
δ : Type ?u.17019
ι : Type ?u.17022
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
s : Set β
hs : Set.Countable s
f : β → Set α
this : Countable ↑s
⊢ ↑↑μ (⋃ (x : ↑s), f ↑x) ≤ ∑' (p : ↑s), ↑↑μ (f ↑p)
Theorem: nndist_pi_le_iff
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simp [nndist_pi_def]
state_before: α : Type u
β : Type v
X : Type ?u.389587
ι : Type ?u.389590
inst✝² : PseudoMetricSpace α
π : β → Type u_1
inst✝¹ : Fintype β
inst✝ : (b : β) → PseudoMetricSpace (π b)
f g : (b : β) → π b
r : ℝ≥0
⊢ nndist f g ≤ r ↔ ∀ (b : β), nndist (f b) (g b) ≤ r
Theorem: RatFunc.ofFractionRing_div
File: Mathlib/FieldTheory/RatFunc.lean

tactic: simp only [Div.div, HDiv.hDiv,  RatFunc.div]
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
p q : FractionRing K[X]
⊢ { toFractionRing := p / q } = { toFractionRing := p } / { toFractionRing := q }
Theorem: Polynomial.taylor_coeff_one
File: Mathlib/Data/Polynomial/Taylor.lean

tactic: rw [taylor_coeff, hasseDeriv_one]
state_before: R : Type u_1
inst✝ : Semiring R
r : R
f : R[X]
⊢ coeff (↑(taylor r) f) 1 = eval r (↑derivative f)
Theorem: Asymptotics.isBigOWith_map
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [IsBigOWith_def]
state_before: α : Type u_2
β : Type u_1
E : Type u_3
F : Type u_4
G : Type ?u.69939
E' : Type ?u.69942
F' : Type ?u.69945
G' : Type ?u.69948
E'' : Type ?u.69951
F'' : Type ?u.69954
G'' : Type ?u.69957
R : Type ?u.69960
R' : Type ?u.69963
𝕜 : Type ?u.69966
𝕜' : Type ?u.69969
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k✝ : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l✝ l' : Filter α
k : β → α
l : Filter β
⊢ IsBigOWith c (map k l) f g ↔ IsBigOWith c l (f ∘ k) (g ∘ k)

tactic: exact eventually_map
state_before: α : Type u_2
β : Type u_1
E : Type u_3
F : Type u_4
G : Type ?u.69939
E' : Type ?u.69942
F' : Type ?u.69945
G' : Type ?u.69948
E'' : Type ?u.69951
F'' : Type ?u.69954
G'' : Type ?u.69957
R : Type ?u.69960
R' : Type ?u.69963
𝕜 : Type ?u.69966
𝕜' : Type ?u.69969
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k✝ : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l✝ l' : Filter α
k : β → α
l : Filter β
⊢ (∀ᶠ (x : α) in map k l, ‖f x‖ ≤ c * ‖g x‖) ↔ ∀ᶠ (x : β) in l, ‖(f ∘ k) x‖ ≤ c * ‖(g ∘ k) x‖
Theorem: Complex.two_pi_I_ne_zero
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: norm_num
state_before: ⊢ 2 * ↑π * I ≠ 0

tactic: simp [Real.pi_ne_zero, I_ne_zero]
state_before: ⊢ ¬(π = 0 ∨ I = 0)
Theorem: HasDerivAt.comp_ofReal
File: Mathlib/Analysis/Complex/RealDeriv.lean

tactic: simpa only [ofRealClm_apply, ofReal_one, mul_one] using hf.comp z ofRealClm.hasDerivAt
state_before: e : ℂ → ℂ
e' : ℂ
z : ℝ
E : Type ?u.147902
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
hf : HasDerivAt e e' ↑z
⊢ HasDerivAt (fun y => e ↑y) e' z
Theorem: UniformFun.precomp_uniformContinuous
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

tactic: rw [uniformContinuous_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type ?u.43134
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
f : γ → α
⊢ UniformContinuous fun g => ↑ofFun (g ∘ f)

tactic: change
  𝓤 (α →ᵤ β) ≤ (𝓤 (γ →ᵤ β)).comap (Prod.map (fun g : α →ᵤ β => g ∘ f) fun g : α →ᵤ β => g ∘ f)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type ?u.43134
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
f : γ → α
⊢ uniformSpace α β ≤ UniformSpace.comap (fun g => ↑ofFun (g ∘ f)) (uniformSpace γ β)

tactic: rw [(UniformFun.hasBasis_uniformity α β).le_basis_iff
    ((UniformFun.hasBasis_uniformity γ β).comap _)]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type ?u.43134
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
f : γ → α
⊢ 𝓤 (α →ᵤ β) ≤ comap (Prod.map (fun g => g ∘ f) fun g => g ∘ f) (𝓤 (γ →ᵤ β))

tactic: exact fun U hU => ⟨U, hU, fun uv huv x => huv (f x)⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type ?u.43134
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
f : γ → α
⊢ ∀ (i' : Set (β × β)),
    i' ∈ 𝓤 β →
      ∃ i, i ∈ 𝓤 β ∧ UniformFun.gen α β i ⊆ (Prod.map (fun g => g ∘ f) fun g => g ∘ f) ⁻¹' UniformFun.gen γ β i'
Theorem: Stream'.tail_const
File: Mathlib/Data/Stream/Init.lean

tactic: rwa [← const_eq] at this
state_before: α : Type u
β : Type v
δ : Type w
a : α
this : tail (a :: const a) = const a
⊢ tail (const a) = const a
Theorem: Matrix.rank_unit
File: Mathlib/Data/Matrix/Rank.lean

tactic: refine' le_antisymm (rank_le_card_width A) _
state_before: l : Type ?u.51935
m : Type ?u.51938
n : Type u_2
o : Type ?u.51944
R : Type u_1
m_fin : Fintype m
inst✝⁴ : Fintype n
inst✝³ : Fintype o
inst✝² : CommRing R
inst✝¹ : StrongRankCondition R
inst✝ : DecidableEq n
A : (Matrix n n R)ˣ
⊢ rank ↑A = Fintype.card n

tactic: have := rank_mul_le_left (A : Matrix n n R) (↑A⁻¹ : Matrix n n R)
state_before: l : Type ?u.51935
m : Type ?u.51938
n : Type u_2
o : Type ?u.51944
R : Type u_1
m_fin : Fintype m
inst✝⁴ : Fintype n
inst✝³ : Fintype o
inst✝² : CommRing R
inst✝¹ : StrongRankCondition R
inst✝ : DecidableEq n
A : (Matrix n n R)ˣ
⊢ Fintype.card n ≤ rank ↑A

tactic: rwa [← mul_eq_mul, ← Units.val_mul, mul_inv_self, Units.val_one, rank_one] at this
state_before: l : Type ?u.51935
m : Type ?u.51938
n : Type u_2
o : Type ?u.51944
R : Type u_1
m_fin : Fintype m
inst✝⁴ : Fintype n
inst✝³ : Fintype o
inst✝² : CommRing R
inst✝¹ : StrongRankCondition R
inst✝ : DecidableEq n
A : (Matrix n n R)ˣ
this : rank (↑A ⬝ ↑A⁻¹) ≤ rank ↑A
⊢ Fintype.card n ≤ rank ↑A
Theorem: Set.OrdConnected.smul
File: Mathlib/Algebra/Order/UpperLower.lean

tactic: rw [← hs.upperClosure_inter_lowerClosure, smul_set_inter]
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
hs : OrdConnected s
⊢ OrdConnected (a • s)

tactic: exact (upperClosure _).upper.smul.ordConnected.inter (lowerClosure _).lower.smul.ordConnected
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
hs : OrdConnected s
⊢ OrdConnected (a • ↑(upperClosure s) ∩ a • ↑(lowerClosure s))
Theorem: EMetric.tendstoUniformly_iff
File: Mathlib/Topology/MetricSpace/EMetricSpace.lean

tactic: simp only [← tendstoUniformlyOn_univ, tendstoUniformlyOn_iff, mem_univ, forall_const]
state_before: α : Type u
β : Type v
X : Type ?u.33140
inst✝ : PseudoEMetricSpace α
ι : Type u_1
F : ι → β → α
f : β → α
p : Filter ι
⊢ TendstoUniformly F f p ↔ ∀ (ε : ℝ≥0∞), ε > 0 → ∀ᶠ (n : ι) in p, ∀ (x : β), edist (f x) (F n x) < ε
Theorem: Finset.singleton_biUnion
File: Mathlib/Data/Finset/Basic.lean

tactic: classical rw [← insert_emptyc_eq, biUnion_insert, biUnion_empty, union_empty]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.508302
inst✝ : DecidableEq β
s s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
a : α
⊢ Finset.biUnion {a} t = t a

tactic: rw [← insert_emptyc_eq, biUnion_insert, biUnion_empty, union_empty]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.508302
inst✝ : DecidableEq β
s s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
a : α
⊢ Finset.biUnion {a} t = t a
Theorem: Subgroup.center_eq_iInf
File: Mathlib/GroupTheory/Subgroup/ZPowers.lean

tactic: rw [← centralizer_top, ← hS, centralizer_closure]
state_before: G : Type u_1
inst✝² : Group G
A : Type ?u.41553
inst✝¹ : AddGroup A
N : Type ?u.41559
inst✝ : Group N
s : Set G
g : G
S : Set G
hS : closure S = ⊤
⊢ center G = ⨅ (g : G) (_ : g ∈ S), centralizer (zpowers g)
Theorem: Module.free_of_finite_type_torsion_free'
File: Mathlib/LinearAlgebra/FreeModule/PID.lean

tactic: obtain ⟨n, b⟩ : Σn, Basis (Fin n) R M := Module.basisOfFiniteTypeTorsionFree'
state_before: ι : Type ?u.216849
R : Type u_1
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
inst✝⁴ : IsPrincipalIdealRing R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
b : ι → M
inst✝¹ : Finite R M
inst✝ : NoZeroSMulDivisors R M
⊢ Free R M

tactic: exact Module.Free.of_basis b
state_before: case mk
ι : Type ?u.216849
R : Type u_1
inst✝⁶ : CommRing R
inst✝⁵ : IsDomain R
inst✝⁴ : IsPrincipalIdealRing R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
b✝ : ι → M
inst✝¹ : Finite R M
inst✝ : NoZeroSMulDivisors R M
n : ℕ
b : Basis (Fin n) R M
⊢ Free R M
Theorem: OrderIso.bddAbove_preimage
File: Mathlib/Order/GaloisConnection.lean

tactic: rw [← e.bddAbove_image, e.image_preimage]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort ?u.32992
a a₁ a₂ : α
b b₁ b₂ : β
inst✝¹ : Preorder α
inst✝ : Preorder β
e : α ≃o β
s : Set β
⊢ BddAbove (↑e ⁻¹' s) ↔ BddAbove s
Theorem: Real.tendsto_mul_log_one_plus_div_atTop
File: Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean

tactic: have h₁ : Tendsto (fun h => h⁻¹ * log (1 + t * h)) (𝓝[≠] 0) (𝓝 t) := by
  simpa [hasDerivAt_iff_tendsto_slope, slope_fun_def] using
    (((hasDerivAt_id (0 : ℝ)).const_mul t).const_add 1).log (by simp)
state_before: t : ℝ
⊢ Tendsto (fun x => x * log (1 + t / x)) atTop (𝓝 t)

tactic: have h₂ : Tendsto (fun x : ℝ => x⁻¹) atTop (𝓝[≠] 0) :=
  tendsto_inv_atTop_zero'.mono_right (nhdsWithin_mono _ fun x hx => (Set.mem_Ioi.mp hx).ne')
state_before: t : ℝ
h₁ : Tendsto (fun h => h⁻¹ * log (1 + t * h)) (𝓝[{0}ᶜ] 0) (𝓝 t)
⊢ Tendsto (fun x => x * log (1 + t / x)) atTop (𝓝 t)

tactic: simpa [hasDerivAt_iff_tendsto_slope, slope_fun_def] using
  (((hasDerivAt_id (0 : ℝ)).const_mul t).const_add 1).log (by simp)
state_before: t : ℝ
⊢ Tendsto (fun h => h⁻¹ * log (1 + t * h)) (𝓝[{0}ᶜ] 0) (𝓝 t)

tactic: simp
state_before: t : ℝ
⊢ 1 + t * id 0 ≠ 0
Theorem: CategoryTheory.Arrow.mk_eq
File: Mathlib/CategoryTheory/Arrow.lean

tactic: cases f
state_before: T : Type u
inst✝ : Category T
f : Arrow T
⊢ mk f.hom = f

tactic: rfl
state_before: case mk
T : Type u
inst✝ : Category T
left✝ right✝ : T
hom✝ : (𝟭 T).obj left✝ ⟶ (𝟭 T).obj right✝
⊢ mk { left := left✝, right := right✝, hom := hom✝ }.hom = { left := left✝, right := right✝, hom := hom✝ }
Theorem: ENNReal.ae_eq_zero_of_lintegral_rpow_eq_zero
File: Mathlib/MeasureTheory/Integral/MeanInequalities.lean

tactic: rw [lintegral_eq_zero_iff' (hf.pow_const p)] at hf_zero
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
p : ℝ
hp0 : 0 ≤ p
f : α → ℝ≥0∞
hf : AEMeasurable f
hf_zero : (∫⁻ (a : α), f a ^ p ∂μ) = 0
⊢ f =ᵐ[μ] 0

tactic: refine' Filter.Eventually.mp hf_zero (Filter.eventually_of_forall fun x => _)
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
p : ℝ
hp0 : 0 ≤ p
f : α → ℝ≥0∞
hf : AEMeasurable f
hf_zero : (fun x => f x ^ p) =ᵐ[μ] 0
⊢ f =ᵐ[μ] 0

tactic: dsimp only
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
p : ℝ
hp0 : 0 ≤ p
f : α → ℝ≥0∞
hf : AEMeasurable f
hf_zero : (fun x => f x ^ p) =ᵐ[μ] 0
x : α
⊢ (fun x => f x ^ p) x = OfNat.ofNat 0 x → f x = OfNat.ofNat 0 x

tactic: rw [Pi.zero_apply, ← not_imp_not]
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
p : ℝ
hp0 : 0 ≤ p
f : α → ℝ≥0∞
hf : AEMeasurable f
hf_zero : (fun x => f x ^ p) =ᵐ[μ] 0
x : α
⊢ f x ^ p = OfNat.ofNat 0 x → f x = OfNat.ofNat 0 x

tactic: exact fun hx => (rpow_pos_of_nonneg (pos_iff_ne_zero.2 hx) hp0).ne'
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
p : ℝ
hp0 : 0 ≤ p
f : α → ℝ≥0∞
hf : AEMeasurable f
hf_zero : (fun x => f x ^ p) =ᵐ[μ] 0
x : α
⊢ ¬f x = 0 → ¬f x ^ p = 0