tasksource/leandojo huggingface dataset:
Theorem: Cycle.support_formPerm
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

tactic: induction' s using Quot.inductionOn with s
state_before: α : Type u_1
inst✝¹ : DecidableEq α
s✝ s' : Cycle α
inst✝ : Fintype α
s : Cycle α
h : Nodup s
hn : Nontrivial s
⊢ support (formPerm s h) = toFinset s

tactic: refine' support_formPerm_of_nodup s h _
state_before: case h
α : Type u_1
inst✝¹ : DecidableEq α
s✝¹ s' : Cycle α
inst✝ : Fintype α
s✝ : Cycle α
h✝ : Nodup s✝
hn✝ : Nontrivial s✝
s : List α
h : Nodup (Quot.mk Setoid.r s)
hn : Nontrivial (Quot.mk Setoid.r s)
⊢ support (formPerm (Quot.mk Setoid.r s) h) = toFinset (Quot.mk Setoid.r s)

tactic: rintro _ rfl
state_before: case h
α : Type u_1
inst✝¹ : DecidableEq α
s✝¹ s' : Cycle α
inst✝ : Fintype α
s✝ : Cycle α
h✝ : Nodup s✝
hn✝ : Nontrivial s✝
s : List α
h : Nodup (Quot.mk Setoid.r s)
hn : Nontrivial (Quot.mk Setoid.r s)
⊢ ∀ (x : α), s ≠ [x]

tactic: simpa [Nat.succ_le_succ_iff] using length_nontrivial hn
state_before: case h
α : Type u_1
inst✝¹ : DecidableEq α
s✝ s' : Cycle α
inst✝ : Fintype α
s : Cycle α
h✝ : Nodup s
hn✝ : Nontrivial s
x✝ : α
h : Nodup (Quot.mk Setoid.r [x✝])
hn : Nontrivial (Quot.mk Setoid.r [x✝])
⊢ False
Theorem: AffineSubspace.bot_ne_top
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: intro contra
state_before: k : Type u_2
V : Type u_3
P : Type u_1
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
⊢ ⊥ ≠ ⊤

tactic: rw [← ext_iff, bot_coe, top_coe] at contra
state_before: k : Type u_2
V : Type u_3
P : Type u_1
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
contra : ⊥ = ⊤
⊢ False

tactic: exact Set.empty_ne_univ contra
state_before: k : Type u_2
V : Type u_3
P : Type u_1
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
contra : ∅ = univ
⊢ False
Theorem: Equiv.Perm.formPerm_toList
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

tactic: by_cases hx : f x = x
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
x : α
⊢ formPerm (toList f x) = cycleOf f x

tactic: ext y
state_before: case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
x : α
hx : ¬↑f x = x
⊢ formPerm (toList f x) = cycleOf f x

tactic: by_cases hy : SameCycle f x y
state_before: case neg.H
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
x : α
hx : ¬↑f x = x
y : α
⊢ ↑(formPerm (toList f x)) y = ↑(cycleOf f x) y

tactic: rw [(cycleOf_eq_one_iff f).mpr hx, toList_eq_nil_iff.mpr (not_mem_support.mpr hx),
  formPerm_nil]
state_before: case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
x : α
hx : ↑f x = x
⊢ formPerm (toList f x) = cycleOf f x

tactic: obtain ⟨k, _, rfl⟩ := hy.exists_pow_eq_of_mem_support (mem_support.mpr hx)
state_before: case pos
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
x : α
hx : ¬↑f x = x
y : α
hy : SameCycle f x y
⊢ ↑(formPerm (toList f x)) y = ↑(cycleOf f x) y

tactic: rw [cycleOf_apply_apply_pow_self, List.formPerm_apply_mem_eq_next (nodup_toList f x),
  next_toList_eq_apply, pow_succ, mul_apply]
state_before: case pos.intro.intro
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
x : α
hx : ¬↑f x = x
k : ℕ
w✝ : k < Finset.card (support (cycleOf f x))
hy : SameCycle f x (↑(f ^ k) x)
⊢ ↑(formPerm (toList f x)) (↑(f ^ k) x) = ↑(cycleOf f x) (↑(f ^ k) x)

tactic: rw [mem_toList_iff]
state_before: case pos.intro.intro.hy
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
x : α
hx : ¬↑f x = x
k : ℕ
w✝ : k < Finset.card (support (cycleOf f x))
hy : SameCycle f x (↑(f ^ k) x)
⊢ ↑(f ^ k) x ∈ toList f x

tactic: exact ⟨⟨k, rfl⟩, mem_support.mpr hx⟩
state_before: case pos.intro.intro.hy
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
x : α
hx : ¬↑f x = x
k : ℕ
w✝ : k < Finset.card (support (cycleOf f x))
hy : SameCycle f x (↑(f ^ k) x)
⊢ SameCycle f x (↑(f ^ k) x) ∧ x ∈ support f

tactic: rw [cycleOf_apply_of_not_sameCycle hy, formPerm_apply_of_not_mem]
state_before: case neg
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
x : α
hx : ¬↑f x = x
y : α
hy : ¬SameCycle f x y
⊢ ↑(formPerm (toList f x)) y = ↑(cycleOf f x) y

tactic: simp [mem_toList_iff, hy]
state_before: case neg.h
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ : α
f : Perm α
x : α
hx : ¬↑f x = x
y : α
hy : ¬SameCycle f x y
⊢ ¬y ∈ toList f x
Theorem: SimpleGraph.Partition.partOfVertex_mem
File: Mathlib/Combinatorics/SimpleGraph/Partition.lean

tactic: obtain ⟨h, -⟩ := (P.isPartition.2 v).choose_spec.1
state_before: V : Type u
G : SimpleGraph V
P : Partition G
v : V
⊢ partOfVertex P v ∈ P.parts

tactic: exact h
state_before: case intro
V : Type u
G : SimpleGraph V
P : Partition G
v : V
h : Exists.choose (_ : ∃! b x, v ∈ b) ∈ P.parts
⊢ partOfVertex P v ∈ P.parts
Theorem: MeasureTheory.Measure.MutuallySingular.mk
File: Mathlib/MeasureTheory/Measure/MutuallySingular.lean

tactic: use toMeasurable μ s, measurableSet_toMeasurable _ _, (measure_toMeasurable _).trans hs
state_before: α : Type u_1
m0 : MeasurableSpace α
μ μ₁ μ₂ ν ν₁ ν₂ : Measure α
s t : Set α
hs : ↑↑μ s = 0
ht : ↑↑ν t = 0
hst : univ ⊆ s ∪ t
⊢ μ ⟂ₘ ν

tactic: refine' measure_mono_null (fun x hx => (hst trivial).resolve_left fun hxs => hx _) ht
state_before: α : Type u_1
m0 : MeasurableSpace α
μ μ₁ μ₂ ν ν₁ ν₂ : Measure α
s t : Set α
hs : ↑↑μ s = 0
ht : ↑↑ν t = 0
hst : univ ⊆ s ∪ t
⊢ ↑↑ν (toMeasurable μ sᶜ) = 0

tactic: exact subset_toMeasurable _ _ hxs
state_before: α : Type u_1
m0 : MeasurableSpace α
μ μ₁ μ₂ ν ν₁ ν₂ : Measure α
s t : Set α
hs : ↑↑μ s = 0
ht : ↑↑ν t = 0
hst : univ ⊆ s ∪ t
x : α
hx : x ∈ toMeasurable μ sᶜ
hxs : x ∈ s
⊢ x ∈ toMeasurable μ s
Theorem: Set.Ico_diff_left
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: simp [and_right_comm, ← lt_iff_le_and_ne, eq_comm]
state_before: α : Type u_1
β : Type ?u.37269
inst✝ : PartialOrder α
a b c x : α
⊢ x ∈ Ico a b \ {a} ↔ x ∈ Ioo a b
Theorem: Finset.weightedVSubVSubWeights_apply_left
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: simp [weightedVSubVSubWeights, h]
state_before: k : Type u_2
V : Type ?u.420383
P : Type ?u.420386
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_1
s : Finset ι
ι₂ : Type ?u.421042
s₂ : Finset ι₂
inst✝ : DecidableEq ι
i j : ι
h : i ≠ j
⊢ weightedVSubVSubWeights k i j i = 1
Theorem: HahnSeries.embDomain_smul
File: Mathlib/RingTheory/HahnSeries.lean

tactic: ext g
state_before: Γ : Type u_1
R : Type u_3
inst✝⁴ : PartialOrder Γ
inst✝³ : Semiring R
V : Type ?u.831652
inst✝² : AddCommMonoid V
inst✝¹ : Module R V
Γ' : Type u_2
inst✝ : PartialOrder Γ'
f : Γ ↪o Γ'
r : R
x : HahnSeries Γ R
⊢ embDomain f (r • x) = r • embDomain f x

tactic: by_cases hg : g ∈ Set.range f
state_before: case coeff.h
Γ : Type u_1
R : Type u_3
inst✝⁴ : PartialOrder Γ
inst✝³ : Semiring R
V : Type ?u.831652
inst✝² : AddCommMonoid V
inst✝¹ : Module R V
Γ' : Type u_2
inst✝ : PartialOrder Γ'
f : Γ ↪o Γ'
r : R
x : HahnSeries Γ R
g : Γ'
⊢ coeff (embDomain f (r • x)) g = coeff (r • embDomain f x) g

tactic: obtain ⟨a, rfl⟩ := hg
state_before: case pos
Γ : Type u_1
R : Type u_3
inst✝⁴ : PartialOrder Γ
inst✝³ : Semiring R
V : Type ?u.831652
inst✝² : AddCommMonoid V
inst✝¹ : Module R V
Γ' : Type u_2
inst✝ : PartialOrder Γ'
f : Γ ↪o Γ'
r : R
x : HahnSeries Γ R
g : Γ'
hg : g ∈ Set.range ↑f
⊢ coeff (embDomain f (r • x)) g = coeff (r • embDomain f x) g

tactic: simp
state_before: case pos.intro
Γ : Type u_1
R : Type u_3
inst✝⁴ : PartialOrder Γ
inst✝³ : Semiring R
V : Type ?u.831652
inst✝² : AddCommMonoid V
inst✝¹ : Module R V
Γ' : Type u_2
inst✝ : PartialOrder Γ'
f : Γ ↪o Γ'
r : R
x : HahnSeries Γ R
a : Γ
⊢ coeff (embDomain f (r • x)) (↑f a) = coeff (r • embDomain f x) (↑f a)

tactic: simp [embDomain_notin_range hg]
state_before: case neg
Γ : Type u_1
R : Type u_3
inst✝⁴ : PartialOrder Γ
inst✝³ : Semiring R
V : Type ?u.831652
inst✝² : AddCommMonoid V
inst✝¹ : Module R V
Γ' : Type u_2
inst✝ : PartialOrder Γ'
f : Γ ↪o Γ'
r : R
x : HahnSeries Γ R
g : Γ'
hg : ¬g ∈ Set.range ↑f
⊢ coeff (embDomain f (r • x)) g = coeff (r • embDomain f x) g
Theorem: Nat.Ioc_filter_dvd_card_eq_div
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: induction' n with n IH
state_before: n p : ℕ
⊢ card (Finset.filter (fun x => p ∣ x) (Ioc 0 n)) = n / p

tactic: simp [Nat.succ_div, add_ite, add_zero, h1, filter_insert, apply_ite card, card_insert_eq_ite, IH,
  Finset.mem_filter, mem_Ioc, not_le.2 (lt_add_one n), Nat.succ_eq_add_one]
state_before: case succ
p n : ℕ
IH : card (Finset.filter (fun x => p ∣ x) (Ioc 0 n)) = n / p
h1 : Ioc 0 (succ n) = insert (succ n) (Ioc 0 n)
⊢ card (Finset.filter (fun x => p ∣ x) (Ioc 0 (succ n))) = succ n / p

tactic: simp
state_before: case zero
p : ℕ
⊢ card (Finset.filter (fun x => p ∣ x) (Ioc 0 zero)) = zero / p

tactic: rcases n.eq_zero_or_pos with (rfl | hn)
state_before: p n : ℕ
IH : card (Finset.filter (fun x => p ∣ x) (Ioc 0 n)) = n / p
⊢ Ioc 0 (succ n) = insert (succ n) (Ioc 0 n)

tactic: simp_rw [← Ico_succ_succ, Ico_insert_right (succ_le_succ hn.le), Ico_succ_right]
state_before: case inr
p n : ℕ
IH : card (Finset.filter (fun x => p ∣ x) (Ioc 0 n)) = n / p
hn : n > 0
⊢ Ioc 0 (succ n) = insert (succ n) (Ioc 0 n)

tactic: simp
state_before: case inl
p : ℕ
IH : card (Finset.filter (fun x => p ∣ x) (Ioc 0 0)) = 0 / p
⊢ Ioc 0 (succ 0) = insert (succ 0) (Ioc 0 0)
Theorem: MvFunctor.exists_iff_exists_of_mono
File: Mathlib/Control/Functor/Multivariate.lean

tactic: constructor <;> rintro ⟨u, h₂⟩
state_before: n : ℕ
α β γ : TypeVec n
F : TypeVec n → Type v
inst✝¹ : MvFunctor F
P✝ : α ⟹ TypeVec.repeat n Prop
R : α ⊗ α ⟹ TypeVec.repeat n Prop
inst✝ : LawfulMvFunctor F
P : F α → Prop
q : F β → Prop
f : α ⟹ β
g : β ⟹ α
h₀ : f ⊚ g = TypeVec.id
h₁ : ∀ (u : F α), P u ↔ q (f <$$> u)
⊢ (∃ u, P u) ↔ ∃ u, q u

tactic: refine ⟨f <$$> u, ?_⟩
state_before: case mp.intro
n : ℕ
α β γ : TypeVec n
F : TypeVec n → Type v
inst✝¹ : MvFunctor F
P✝ : α ⟹ TypeVec.repeat n Prop
R : α ⊗ α ⟹ TypeVec.repeat n Prop
inst✝ : LawfulMvFunctor F
P : F α → Prop
q : F β → Prop
f : α ⟹ β
g : β ⟹ α
h₀ : f ⊚ g = TypeVec.id
h₁ : ∀ (u : F α), P u ↔ q (f <$$> u)
u : F α
h₂ : P u
⊢ ∃ u, q u

tactic: apply (h₁ u).mp h₂
state_before: case mp.intro
n : ℕ
α β γ : TypeVec n
F : TypeVec n → Type v
inst✝¹ : MvFunctor F
P✝ : α ⟹ TypeVec.repeat n Prop
R : α ⊗ α ⟹ TypeVec.repeat n Prop
inst✝ : LawfulMvFunctor F
P : F α → Prop
q : F β → Prop
f : α ⟹ β
g : β ⟹ α
h₀ : f ⊚ g = TypeVec.id
h₁ : ∀ (u : F α), P u ↔ q (f <$$> u)
u : F α
h₂ : P u
⊢ q (f <$$> u)

tactic: refine ⟨g <$$> u, ?_⟩
state_before: case mpr.intro
n : ℕ
α β γ : TypeVec n
F : TypeVec n → Type v
inst✝¹ : MvFunctor F
P✝ : α ⟹ TypeVec.repeat n Prop
R : α ⊗ α ⟹ TypeVec.repeat n Prop
inst✝ : LawfulMvFunctor F
P : F α → Prop
q : F β → Prop
f : α ⟹ β
g : β ⟹ α
h₀ : f ⊚ g = TypeVec.id
h₁ : ∀ (u : F α), P u ↔ q (f <$$> u)
u : F β
h₂ : q u
⊢ ∃ u, P u

tactic: apply (h₁ _).mpr _
state_before: case mpr.intro
n : ℕ
α β γ : TypeVec n
F : TypeVec n → Type v
inst✝¹ : MvFunctor F
P✝ : α ⟹ TypeVec.repeat n Prop
R : α ⊗ α ⟹ TypeVec.repeat n Prop
inst✝ : LawfulMvFunctor F
P : F α → Prop
q : F β → Prop
f : α ⟹ β
g : β ⟹ α
h₀ : f ⊚ g = TypeVec.id
h₁ : ∀ (u : F α), P u ↔ q (f <$$> u)
u : F β
h₂ : q u
⊢ P (g <$$> u)

tactic: simp only [MvFunctor.map_map, h₀, LawfulMvFunctor.id_map, h₂]
state_before: n : ℕ
α β γ : TypeVec n
F : TypeVec n → Type v
inst✝¹ : MvFunctor F
P✝ : α ⟹ TypeVec.repeat n Prop
R : α ⊗ α ⟹ TypeVec.repeat n Prop
inst✝ : LawfulMvFunctor F
P : F α → Prop
q : F β → Prop
f : α ⟹ β
g : β ⟹ α
h₀ : f ⊚ g = TypeVec.id
h₁ : ∀ (u : F α), P u ↔ q (f <$$> u)
u : F β
h₂ : q u
⊢ q (f <$$> g <$$> u)
Theorem: Std.PairingHeapImp.Heap.size_deleteMin
File: Std/Data/PairingHeap.lean

tactic: cases h with cases eq | node a c => rw [size_combine, size, size]
state_before: α : Type u_1
le : α → α → Bool
a : α
s' s : Heap α
h : NoSibling s
eq : deleteMin le s = some (a, s')
⊢ size s = size s' + 1

tactic: rw [size_combine, size, size]
state_before: case node.refl
α : Type u_1
le : α → α → Bool
a : α
c : Heap α
⊢ size (node a c nil) = size (combine le c) + 1
Theorem: Set.ncard_le_ncard_iff_ncard_diff_le_ncard_diff
File: Mathlib/Data/Set/Ncard.lean

tactic: rw [← ncard_inter_add_ncard_diff_eq_ncard s t hs, ← ncard_inter_add_ncard_diff_eq_ncard t s ht,
  inter_comm, add_le_add_iff_left]
state_before: α : Type u_1
β : Type ?u.129077
s t : Set α
a b x y : α
f : α → β
hs : autoParam (Set.Finite s) _auto✝
ht : autoParam (Set.Finite t) _auto✝
⊢ ncard s ≤ ncard t ↔ ncard (s \ t) ≤ ncard (t \ s)
Theorem: Finsupp.filter_eq_self_iff
File: Mathlib/Data/Finsupp/Basic.lean

tactic: simp only [FunLike.ext_iff, filter_eq_indicator, Set.indicator_apply_eq_self, Set.mem_setOf_eq,
  not_imp_comm]
state_before: α : Type u_1
β : Type ?u.425326
γ : Type ?u.425329
ι : Type ?u.425332
M : Type u_2
M' : Type ?u.425338
N : Type ?u.425341
P : Type ?u.425344
G : Type ?u.425347
H : Type ?u.425350
R : Type ?u.425353
S : Type ?u.425356
inst✝ : Zero M
p : α → Prop
f : α →₀ M
⊢ filter p f = f ↔ ∀ (x : α), ↑f x ≠ 0 → p x
Theorem: HasStrictDerivAt.real_of_complex
File: Mathlib/Analysis/Complex/RealDeriv.lean

tactic: have A : HasStrictFDerivAt ((↑) : ℝ → ℂ) ofRealClm z := ofRealClm.hasStrictFDerivAt
state_before: e : ℂ → ℂ
e' : ℂ
z : ℝ
h : HasStrictDerivAt e e' ↑z
⊢ HasStrictDerivAt (fun x => (e ↑x).re) e'.re z

tactic: have B :
  HasStrictFDerivAt e ((ContinuousLinearMap.smulRight 1 e' : ℂ →L[ℂ] ℂ).restrictScalars ℝ)
    (ofRealClm z) :=
  h.hasStrictFDerivAt.restrictScalars ℝ
state_before: e : ℂ → ℂ
e' : ℂ
z : ℝ
h : HasStrictDerivAt e e' ↑z
A : HasStrictFDerivAt ofReal' ofRealClm z
⊢ HasStrictDerivAt (fun x => (e ↑x).re) e'.re z

tactic: have C : HasStrictFDerivAt re reClm (e (ofRealClm z)) := reClm.hasStrictFDerivAt
state_before: e : ℂ → ℂ
e' : ℂ
z : ℝ
h : HasStrictDerivAt e e' ↑z
A : HasStrictFDerivAt ofReal' ofRealClm z
B : HasStrictFDerivAt e (ContinuousLinearMap.restrictScalars ℝ (ContinuousLinearMap.smulRight 1 e')) (↑ofRealClm z)
⊢ HasStrictDerivAt (fun x => (e ↑x).re) e'.re z

tactic: convert (C.comp z (B.comp z A)).hasStrictDerivAt
state_before: e : ℂ → ℂ
e' : ℂ
z : ℝ
h : HasStrictDerivAt e e' ↑z
A : HasStrictFDerivAt ofReal' ofRealClm z
B : HasStrictFDerivAt e (ContinuousLinearMap.restrictScalars ℝ (ContinuousLinearMap.smulRight 1 e')) (↑ofRealClm z)
C : HasStrictFDerivAt re reClm (e (↑ofRealClm z))
⊢ HasStrictDerivAt (fun x => (e ↑x).re) e'.re z

tactic: rw [ContinuousLinearMap.comp_apply, ContinuousLinearMap.comp_apply]
state_before: case h.e'_7
e : ℂ → ℂ
e' : ℂ
z : ℝ
h : HasStrictDerivAt e e' ↑z
A : HasStrictFDerivAt ofReal' ofRealClm z
B : HasStrictFDerivAt e (ContinuousLinearMap.restrictScalars ℝ (ContinuousLinearMap.smulRight 1 e')) (↑ofRealClm z)
C : HasStrictFDerivAt re reClm (e (↑ofRealClm z))
⊢ e'.re =
    ↑(ContinuousLinearMap.comp reClm
          (ContinuousLinearMap.comp (ContinuousLinearMap.restrictScalars ℝ (ContinuousLinearMap.smulRight 1 e'))
            ofRealClm))
      1

tactic: simp
state_before: case h.e'_7
e : ℂ → ℂ
e' : ℂ
z : ℝ
h : HasStrictDerivAt e e' ↑z
A : HasStrictFDerivAt ofReal' ofRealClm z
B : HasStrictFDerivAt e (ContinuousLinearMap.restrictScalars ℝ (ContinuousLinearMap.smulRight 1 e')) (↑ofRealClm z)
C : HasStrictFDerivAt re reClm (e (↑ofRealClm z))
⊢ e'.re = ↑reClm (↑(ContinuousLinearMap.restrictScalars ℝ (ContinuousLinearMap.smulRight 1 e')) (↑ofRealClm 1))
Theorem: isLittleO_exp_neg_mul_rpow_atTop
File: Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean

tactic: apply isLittleO_of_tendsto'
state_before: a : ℝ
ha : 0 < a
b : ℝ
⊢ (fun x => exp (-a * x)) =o[atTop] fun x => x ^ b

tactic: refine' (eventually_gt_atTop 0).mp (eventually_of_forall fun t ht h => _)
state_before: case hgf
a : ℝ
ha : 0 < a
b : ℝ
⊢ ∀ᶠ (x : ℝ) in atTop, x ^ b = 0 → exp (-a * x) = 0

tactic: rw [rpow_eq_zero_iff_of_nonneg ht.le] at h
state_before: case hgf
a : ℝ
ha : 0 < a
b t : ℝ
ht : 0 < t
h : t ^ b = 0
⊢ exp (-a * t) = 0

tactic: exact (ht.ne' h.1).elim
state_before: case hgf
a : ℝ
ha : 0 < a
b t : ℝ
ht : 0 < t
h : t = 0 ∧ b ≠ 0
⊢ exp (-a * t) = 0

tactic: refine' (tendsto_exp_mul_div_rpow_atTop (-b) a ha).inv_tendsto_atTop.congr' _
state_before: case a
a : ℝ
ha : 0 < a
b : ℝ
⊢ Tendsto (fun x => exp (-a * x) / x ^ b) atTop (𝓝 0)

tactic: refine' (eventually_ge_atTop 0).mp (eventually_of_forall fun t ht => _)
state_before: case a
a : ℝ
ha : 0 < a
b : ℝ
⊢ (fun x => exp (a * x) / x ^ (-b))⁻¹ =ᶠ[atTop] fun x => exp (-a * x) / x ^ b

tactic: dsimp only
state_before: case a
a : ℝ
ha : 0 < a
b t : ℝ
ht : 0 ≤ t
⊢ (fun x => exp (a * x) / x ^ (-b))⁻¹ t = (fun x => exp (-a * x) / x ^ b) t

tactic: rw [Pi.inv_apply, inv_div, ← inv_div_inv, neg_mul, Real.exp_neg, rpow_neg ht, inv_inv]
state_before: case a
a : ℝ
ha : 0 < a
b t : ℝ
ht : 0 ≤ t
⊢ (fun x => exp (a * x) / x ^ (-b))⁻¹ t = exp (-a * t) / t ^ b
Theorem: Real.sSup_empty
File: Mathlib/Data/Real/Basic.lean

tactic: simp
state_before: x y : ℝ
⊢ ¬(Set.Nonempty ∅ ∧ BddAbove ∅)
Theorem: Basis.toMatrix_map
File: Mathlib/LinearAlgebra/Matrix/Basis.lean

tactic: ext
state_before: ι : Type u_1
ι' : Type ?u.641315
κ : Type ?u.641318
κ' : Type ?u.641321
R : Type u_2
M : Type u_3
inst✝⁷ : CommSemiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
R₂ : Type ?u.641514
M₂ : Type ?u.641517
inst✝⁴ : CommRing R₂
inst✝³ : AddCommGroup M₂
inst✝² : Module R₂ M₂
e : Basis ι R M
v✝ : ι' → M
i : ι
j : ι'
N : Type u_4
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
b✝ : Basis ι R M
b' : Basis ι' R M
c : Basis κ R N
c' : Basis κ' R N
f✝ : M →ₗ[R] N
b : Basis ι R M
f : M ≃ₗ[R] N
v : ι → N
⊢ toMatrix (Basis.map b f) v = toMatrix b (↑(LinearEquiv.symm f) ∘ v)
Theorem: ENNReal.continuous_sub_right
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: by_cases a_infty : a = ∞
state_before: α : Type ?u.110881
β : Type ?u.110884
γ : Type ?u.110887
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
a : ℝ≥0∞
⊢ Continuous fun x => x - a

tactic: simp [a_infty, continuous_const]
state_before: case pos
α : Type ?u.110881
β : Type ?u.110884
γ : Type ?u.110887
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
a : ℝ≥0∞
a_infty : a = ⊤
⊢ Continuous fun x => x - a

tactic: rw [show (fun x => x - a) = (fun p : ℝ≥0∞ × ℝ≥0∞ => p.fst - p.snd) ∘ fun x => ⟨x, a⟩ by rfl]
state_before: case neg
α : Type ?u.110881
β : Type ?u.110884
γ : Type ?u.110887
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
a : ℝ≥0∞
a_infty : ¬a = ⊤
⊢ Continuous fun x => x - a

tactic: apply ContinuousOn.comp_continuous continuousOn_sub (continuous_id'.prod_mk continuous_const)
state_before: case neg
α : Type ?u.110881
β : Type ?u.110884
γ : Type ?u.110887
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
a : ℝ≥0∞
a_infty : ¬a = ⊤
⊢ Continuous ((fun p => p.fst - p.snd) ∘ fun x => (x, a))

tactic: intro x
state_before: case neg
α : Type ?u.110881
β : Type ?u.110884
γ : Type ?u.110887
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
a : ℝ≥0∞
a_infty : ¬a = ⊤
⊢ ∀ (x : ℝ≥0∞), (x, a) ∈ {p | p ≠ (⊤, ⊤)}

tactic: simp only [a_infty, Ne.def, mem_setOf_eq, Prod.mk.inj_iff, and_false_iff, not_false_iff]
state_before: case neg
α : Type ?u.110881
β : Type ?u.110884
γ : Type ?u.110887
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
a : ℝ≥0∞
a_infty : ¬a = ⊤
x : ℝ≥0∞
⊢ (x, a) ∈ {p | p ≠ (⊤, ⊤)}

tactic: rfl
state_before: α : Type ?u.110881
β : Type ?u.110884
γ : Type ?u.110887
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
a : ℝ≥0∞
a_infty : ¬a = ⊤
⊢ (fun x => x - a) = (fun p => p.fst - p.snd) ∘ fun x => (x, a)
Theorem: Lagrange.interpolate_eq_nodalWeight_mul_nodal_div_X_sub_C
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: rw [mul_comm, basis_eq_prod_sub_inv_mul_nodal_div hj]
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
s : Finset ι
v : ι → F
i : ι
r : ι → F
x : F
inst✝ : DecidableEq ι
j : ι
hj : j ∈ s
⊢ ↑C (r j) * Lagrange.basis s v j = ↑C (nodalWeight s v j) * (nodal s v / (X - ↑C (v j))) * ↑C (r j)
Theorem: Ideal.comap_of_equiv
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: simp [← RingEquiv.toRingHom_eq_coe, comap_comap]
state_before: R : Type u
S : Type v
F : Type ?u.1390279
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : RingHomClass F R S
f✝ : F
I✝ I : Ideal R
f : R ≃+* S
⊢ comap (↑f) (comap (↑(RingEquiv.symm f)) I) = I
Theorem: Subtype.coe_preimage_self
File: Mathlib/Data/Set/Image.lean

tactic: rw [← preimage_range, range_coe]
state_before: α : Type u_1
s : Set α
⊢ val ⁻¹' s = univ
Theorem: Multiset.fold_cons'_right
File: Mathlib/Data/Multiset/Fold.lean

tactic: rw [fold_eq_foldl, foldl_cons, ← fold_eq_foldl]
state_before: α : Type u_1
β : Type ?u.6065
op : α → α → α
hc : IsCommutative α op
ha : IsAssociative α op
b a : α
s : Multiset α
⊢ fold op b (a ::ₘ s) = fold op (op b a) s
Theorem: LocalizedModule.zero_add'
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: rw [← zero_mk s, mk_add_mk, smul_zero, zero_add, mk_eq]
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x : LocalizedModule S M
m : M
s : { x // x ∈ S }
⊢ 0 + mk m s = mk m s

tactic: exact ⟨1, by rw [one_smul, mul_smul, one_smul]⟩
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x : LocalizedModule S M
m : M
s : { x // x ∈ S }
⊢ ∃ u, u • s • s • m = u • (s * s) • m

tactic: rw [one_smul, mul_smul, one_smul]
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x : LocalizedModule S M
m : M
s : { x // x ∈ S }
⊢ 1 • s • s • m = 1 • (s * s) • m
Theorem: Equiv.comp_map
File: Mathlib/Control/Traversable/Equiv.lean

tactic: simp [Equiv.map]
state_before: t t' : Type u → Type u
eqv : (α : Type u) → t α ≃ t' α
inst✝¹ : Functor t
inst✝ : LawfulFunctor t
α β γ : Type u
g : α → β
h : β → γ
x : t' α
⊢ Equiv.map eqv (h ∘ g) x = Equiv.map eqv h (Equiv.map eqv g x)

tactic: apply comp_map
state_before: t t' : Type u → Type u
eqv : (α : Type u) → t α ≃ t' α
inst✝¹ : Functor t
inst✝ : LawfulFunctor t
α β γ : Type u
g : α → β
h : β → γ
x : t' α
⊢ (h ∘ g) <$> ↑(eqv α).symm x = h <$> g <$> ↑(eqv α).symm x