tasksource/leandojo huggingface dataset:
Theorem: Function.Semiconj.surjOn_image
File: Mathlib/Data/Set/Function.lean

tactic: rintro y ⟨x, hxt, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.111397
ι : Sort ?u.111400
π : α → Type ?u.111405
fa : α → α
fb : β → β
f : α → β
g : β → γ
s t : Set α
h : Semiconj f fa fb
ha : SurjOn fa s t
⊢ SurjOn fb (f '' s) (f '' t)

tactic: rcases ha hxt with ⟨x, hxs, rfl⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.111397
ι : Sort ?u.111400
π : α → Type ?u.111405
fa : α → α
fb : β → β
f : α → β
g : β → γ
s t : Set α
h : Semiconj f fa fb
ha : SurjOn fa s t
x : α
hxt : x ∈ t
⊢ f x ∈ fb '' (f '' s)

tactic: rw [h x]
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.111397
ι : Sort ?u.111400
π : α → Type ?u.111405
fa : α → α
fb : β → β
f : α → β
g : β → γ
s t : Set α
h : Semiconj f fa fb
ha : SurjOn fa s t
x : α
hxs : x ∈ s
hxt : fa x ∈ t
⊢ f (fa x) ∈ fb '' (f '' s)

tactic: exact mem_image_of_mem _ (mem_image_of_mem _ hxs)
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.111397
ι : Sort ?u.111400
π : α → Type ?u.111405
fa : α → α
fb : β → β
f : α → β
g : β → γ
s t : Set α
h : Semiconj f fa fb
ha : SurjOn fa s t
x : α
hxs : x ∈ s
hxt : fa x ∈ t
⊢ fb (f x) ∈ fb '' (f '' s)
Theorem: Filter.Realizer.ne_bot_iff
File: Mathlib/Data/Analysis/Filter.lean

tactic: rw [not_iff_comm, ← le_bot_iff, F.le_iff Realizer.bot, not_forall]
state_before: α : Type u_1
β : Type ?u.55845
σ : Type ?u.55848
τ : Type ?u.55851
f : Filter α
F : Realizer f
⊢ f ≠ ⊥ ↔ ∀ (a : F.σ), Set.Nonempty (CFilter.f F.F a)

tactic: simp only [Set.not_nonempty_iff_eq_empty]
state_before: α : Type u_1
β : Type ?u.55845
σ : Type ?u.55848
τ : Type ?u.55851
f : Filter α
F : Realizer f
⊢ (∃ x, ¬Set.Nonempty (CFilter.f F.F x)) ↔ ∀ (b : Realizer.bot.σ), ∃ a, CFilter.f F.F a ≤ CFilter.f Realizer.bot.F b

tactic: exact ⟨fun ⟨x, e⟩ _ ↦ ⟨x, le_of_eq e⟩, fun h ↦
  let ⟨x, h⟩ := h ()
  ⟨x, le_bot_iff.1 h⟩⟩
state_before: α : Type u_1
β : Type ?u.55845
σ : Type ?u.55848
τ : Type ?u.55851
f : Filter α
F : Realizer f
⊢ (∃ x, CFilter.f F.F x = ∅) ↔ ∀ (b : Realizer.bot.σ), ∃ a, CFilter.f F.F a ≤ CFilter.f Realizer.bot.F b
Theorem: Nat.WithBot.add_eq_three_iff
File: Mathlib/Data/Nat/WithBot.lean

tactic: rcases n, m with ⟨_ | _, _ | _⟩
state_before: n m : WithBot ℕ
⊢ n + m = 3 ↔ n = 0 ∧ m = 3 ∨ n = 1 ∧ m = 2 ∨ n = 2 ∧ m = 1 ∨ n = 3 ∧ m = 0

tactic: any_goals refine' ⟨fun h => Option.noConfusion h, fun h => _⟩; aesop
state_before: case none.none

⊢ none + none = 3 ↔ none = 0 ∧ none = 3 ∨ none = 1 ∧ none = 2 ∨ none = 2 ∧ none = 1 ∨ none = 3 ∧ none = 0

case none.some
val✝ : ℕ
⊢ none + some val✝ = 3 ↔
    none = 0 ∧ some val✝ = 3 ∨ none = 1 ∧ some val✝ = 2 ∨ none = 2 ∧ some val✝ = 1 ∨ none = 3 ∧ some val✝ = 0

case some.none
val✝ : ℕ
⊢ some val✝ + none = 3 ↔
    some val✝ = 0 ∧ none = 3 ∨ some val✝ = 1 ∧ none = 2 ∨ some val✝ = 2 ∧ none = 1 ∨ some val✝ = 3 ∧ none = 0

case some.some
val✝¹ val✝ : ℕ
⊢ some val✝¹ + some val✝ = 3 ↔
    some val✝¹ = 0 ∧ some val✝ = 3 ∨
      some val✝¹ = 1 ∧ some val✝ = 2 ∨ some val✝¹ = 2 ∧ some val✝ = 1 ∨ some val✝¹ = 3 ∧ some val✝ = 0

tactic: repeat' erw [WithBot.coe_eq_coe]
state_before: case some.some
val✝¹ val✝ : ℕ
⊢ some val✝¹ + some val✝ = 3 ↔
    some val✝¹ = 0 ∧ some val✝ = 3 ∨
      some val✝¹ = 1 ∧ some val✝ = 2 ∨ some val✝¹ = 2 ∧ some val✝ = 1 ∨ some val✝¹ = 3 ∧ some val✝ = 0

tactic: exact Nat.add_eq_three_iff
state_before: case some.some
val✝¹ val✝ : ℕ
⊢ (fun x x_1 => x + x_1) val✝¹ val✝ = ↑3 ↔
    val✝¹ = 0 ∧ val✝ = ↑3 ∨ val✝¹ = 1 ∧ val✝ = ↑2 ∨ val✝¹ = ↑2 ∧ val✝ = 1 ∨ val✝¹ = ↑3 ∧ val✝ = 0

tactic: refine' ⟨fun h => Option.noConfusion h, fun h => _⟩
state_before: case some.some
val✝¹ val✝ : ℕ
⊢ some val✝¹ + some val✝ = 3 ↔
    some val✝¹ = 0 ∧ some val✝ = 3 ∨
      some val✝¹ = 1 ∧ some val✝ = 2 ∨ some val✝¹ = 2 ∧ some val✝ = 1 ∨ some val✝¹ = 3 ∧ some val✝ = 0

tactic: aesop
state_before: case some.none
val✝ : ℕ
h : some val✝ = 0 ∧ none = 3 ∨ some val✝ = 1 ∧ none = 2 ∨ some val✝ = 2 ∧ none = 1 ∨ some val✝ = 3 ∧ none = 0
⊢ some val✝ + none = 3

tactic: erw [WithBot.coe_eq_coe]
state_before: case some.some
val✝¹ val✝ : ℕ
⊢ (fun x x_1 => x + x_1) val✝¹ val✝ = ↑3 ↔
    val✝¹ = 0 ∧ val✝ = ↑3 ∨ val✝¹ = 1 ∧ val✝ = ↑2 ∨ val✝¹ = ↑2 ∧ val✝ = 1 ∨ val✝¹ = ↑3 ∧ val✝ = 0
Theorem: mem_image_univ_iff_mem_range
File: Mathlib/Data/Fintype/Basic.lean

tactic: simp
state_before: α✝ : Type ?u.141366
β✝ : Type ?u.141369
γ : Type ?u.141372
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : DecidableEq β
f : α → β
b : β
⊢ b ∈ image f univ ↔ b ∈ Set.range f
Theorem: le_compl_comm
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [le_compl_iff_disjoint_right, le_compl_iff_disjoint_left]
state_before: ι : Type ?u.157568
α : Type u_1
β : Type ?u.157574
inst✝ : HeytingAlgebra α
a b c : α
⊢ a ≤ bᶜ ↔ b ≤ aᶜ
Theorem: Convex.mapsTo_lineMap
File: Mathlib/Analysis/Convex/Basic.lean

tactic: simpa only [mapsTo', segment_eq_image_lineMap] using h.segment_subset hx hy
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.219178
β : Type ?u.219181
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t : Set E
h : Convex 𝕜 s
x y : E
hx : x ∈ s
hy : y ∈ s
⊢ MapsTo (↑(AffineMap.lineMap x y)) (Icc 0 1) s
Theorem: CategoryTheory.Bicategory.associator_inv_naturality_right
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
h h' : c ⟶ d
η : h ⟶ h'
⊢ f ◁ g ◁ η ≫ (α_ f g h').inv = (α_ f g h).inv ≫ (f ≫ g) ◁ η
Theorem: CategoryTheory.Subobject.factorThru_right
File: Mathlib/CategoryTheory/Subobject/FactorThru.lean

tactic: apply (cancel_mono P.arrow).mp
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
⊢ f ≫ factorThru P g h = factorThru P (f ≫ g) (_ : Factors P (f ≫ g))

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
g : Y ⟶ Z
h : Factors P g
⊢ (f ≫ factorThru P g h) ≫ arrow P = factorThru P (f ≫ g) (_ : Factors P (f ≫ g)) ≫ arrow P
Theorem: ContinuousLinearMap.op_norm_zero_iff
File: Mathlib/Analysis/NormedSpace/OperatorNorm.lean

tactic: rw [hn, MulZeroClass.zero_mul]
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type ?u.2592188
E : Type u_3
Eₗ : Type ?u.2592194
F : Type u_4
Fₗ : Type ?u.2592200
G : Type ?u.2592203
Gₗ : Type ?u.2592206
𝓕 : Type ?u.2592209
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedAddCommGroup Fₗ
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NontriviallyNormedField 𝕜₂
inst✝⁵ : NontriviallyNormedField 𝕜₃
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedSpace 𝕜₂ F
inst✝² : NormedSpace 𝕜₃ G
inst✝¹ : NormedSpace 𝕜 Fₗ
c : 𝕜
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
f g : E →SL[σ₁₂] F
x✝ y z : E
inst✝ : RingHomIsometric σ₁₂
hn : ‖f‖ = 0
x : E
⊢ ‖f‖ * ‖x‖ = 0

tactic: rintro rfl
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type ?u.2592188
E : Type u_3
Eₗ : Type ?u.2592194
F : Type u_4
Fₗ : Type ?u.2592200
G : Type ?u.2592203
Gₗ : Type ?u.2592206
𝓕 : Type ?u.2592209
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedAddCommGroup Fₗ
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NontriviallyNormedField 𝕜₂
inst✝⁵ : NontriviallyNormedField 𝕜₃
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedSpace 𝕜₂ F
inst✝² : NormedSpace 𝕜₃ G
inst✝¹ : NormedSpace 𝕜 Fₗ
c : 𝕜
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
f g : E →SL[σ₁₂] F
x y z : E
inst✝ : RingHomIsometric σ₁₂
⊢ f = 0 → ‖f‖ = 0

tactic: exact op_norm_zero
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type ?u.2592188
E : Type u_3
Eₗ : Type ?u.2592194
F : Type u_4
Fₗ : Type ?u.2592200
G : Type ?u.2592203
Gₗ : Type ?u.2592206
𝓕 : Type ?u.2592209
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedAddCommGroup Fₗ
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NontriviallyNormedField 𝕜₂
inst✝⁵ : NontriviallyNormedField 𝕜₃
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedSpace 𝕜₂ F
inst✝² : NormedSpace 𝕜₃ G
inst✝¹ : NormedSpace 𝕜 Fₗ
c : 𝕜
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
g : E →SL[σ₁₂] F
x y z : E
inst✝ : RingHomIsometric σ₁₂
⊢ ‖0‖ = 0
Theorem: CategoryTheory.Bicategory.pentagon_inv
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
h : c ⟶ d
i : d ⟶ e
⊢ inv (f ◁ (α_ g h i).inv ≫ (α_ f (g ≫ h) i).inv ≫ (α_ f g h).inv ▷ i) =
    inv ((α_ f g (h ≫ i)).inv ≫ (α_ (f ≫ g) h i).inv)
Theorem: Finset.mem_shadow_iff
File: Mathlib/Combinatorics/SetFamily/Shadow.lean

tactic: simp only [shadow, mem_sup, mem_image]
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
⊢ s ∈ (∂ ) 𝒜 ↔ ∃ t, t ∈ 𝒜 ∧ ∃ a, a ∈ t ∧ erase t a = s
Theorem: Function.extend_apply'
File: Mathlib/Logic/Function/Basic.lean

tactic: simp [Function.extend_def, hb]
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
g : α → γ
e' : β → γ
b : β
hb : ¬∃ a, f a = b
⊢ extend f g e' b = e' b
Theorem: Subring.exists_list_of_mem_closure
File: Mathlib/RingTheory/Subring/Basic.lean

tactic: simp [h]
state_before: R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
s : Set R
x✝ : R
h✝ : x✝ ∈ closure s
x : R
hx : x ∈ ↑(Submonoid.closure s)
l : List R
hl : ∀ (y : R), y ∈ l → y ∈ s
h : List.prod l = x
⊢ (∀ (t : List R), t ∈ [l] → ∀ (y : R), y ∈ t → y ∈ s ∨ y = -1) ∧ List.sum (List.map List.prod [l]) = x

tactic: clear_aux_decl
state_before: R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
s : Set R
x✝ : R
h✝ : x✝ ∈ closure s
x : R
hx : x ∈ ↑(Submonoid.closure s)
l : List R
hl : ∀ (y : R), y ∈ l → y ∈ s
h : List.prod l = x
⊢ ∀ (y : R), y ∈ l → y ∈ s ∨ y = -1

tactic: tauto
state_before: R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
s : Set R
x✝ : R
h✝ : x✝ ∈ closure s
x : R
hx : x ∈ ↑(Submonoid.closure s)
l : List R
hl : ∀ (y : R), y ∈ l → y ∈ s
h : List.prod l = x
⊢ ∀ (y : R), y ∈ l → y ∈ s ∨ y = -1

tactic: simp
state_before: R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
s : Set R
x : R
h : x ∈ closure s
⊢ (∀ (t : List R), t ∈ [] → ∀ (y : R), y ∈ t → y ∈ s ∨ y = -1) ∧ List.sum (List.map List.prod []) = 0

tactic: simp [hl2, hm2]
state_before: R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
s : Set R
x✝² : R
h : x✝² ∈ closure s
x y : R
x✝¹ :
  (fun x => ∃ L, (∀ (t : List R), t ∈ L → ∀ (y : R), y ∈ t → y ∈ s ∨ y = -1) ∧ List.sum (List.map List.prod L) = x) x
x✝ : (fun x => ∃ L, (∀ (t : List R), t ∈ L → ∀ (y : R), y ∈ t → y ∈ s ∨ y = -1) ∧ List.sum (List.map List.prod L) = x) y
l : List (List R)
hl1 : ∀ (t : List R), t ∈ l → ∀ (y : R), y ∈ t → y ∈ s ∨ y = -1
hl2 : List.sum (List.map List.prod l) = x
m : List (List R)
hm1 : ∀ (t : List R), t ∈ m → ∀ (y : R), y ∈ t → y ∈ s ∨ y = -1
hm2 : List.sum (List.map List.prod m) = y
⊢ List.sum (List.map List.prod (l ++ m)) = x + y

tactic: simp
state_before: R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
s : Set R
x✝¹ : R
h : x✝¹ ∈ closure s
x : R
x✝ : (fun x => ∃ L, (∀ (t : List R), t ∈ L → ∀ (y : R), y ∈ t → y ∈ s ∨ y = -1) ∧ List.sum (List.map List.prod L) = x) x
L : List (List R)
hL : (∀ (t : List R), t ∈ L → ∀ (y : R), y ∈ t → y ∈ s ∨ y = -1) ∧ List.sum (List.map List.prod L) = x
⊢ List.sum (List.map List.prod (List.map (List.cons (-1)) [])) = -List.sum (List.map List.prod [])

tactic: simp (config := { contextual := true }) [List.map_cons, add_comm]
state_before: R : Type u
S : Type v
T : Type w
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : Ring T
s : Set R
x✝¹ : R
h : x✝¹ ∈ closure s
x : R
x✝ : (fun x => ∃ L, (∀ (t : List R), t ∈ L → ∀ (y : R), y ∈ t → y ∈ s ∨ y = -1) ∧ List.sum (List.map List.prod L) = x) x
L : List (List R)
hL : (∀ (t : List R), t ∈ L → ∀ (y : R), y ∈ t → y ∈ s ∨ y = -1) ∧ List.sum (List.map List.prod L) = x
⊢ ∀ (head : List R) (tail : List (List R)),
    List.sum (List.map List.prod (List.map (List.cons (-1)) tail)) = -List.sum (List.map List.prod tail) →
      List.sum (List.map List.prod (List.map (List.cons (-1)) (head :: tail))) =
        -List.sum (List.map List.prod (head :: tail))
Theorem: norm_smul_of_nonneg
File: Mathlib/Analysis/NormedSpace/Basic.lean

tactic: rw [norm_smul, Real.norm_eq_abs, abs_of_nonneg ht]
state_before: α : Type ?u.12618
β : Type u_1
γ : Type ?u.12624
ι : Type ?u.12627
inst✝² : NormedField α
inst✝¹ : SeminormedAddCommGroup β
inst✝ : NormedSpace ℝ β
t : ℝ
ht : 0 ≤ t
x : β
⊢ ‖t • x‖ = t * ‖x‖
Theorem: LinearEquiv.closedEmbedding_of_injective
File: Mathlib/Analysis/NormedSpace/FiniteDimension.lean

tactic: haveI := f.finiteDimensional_range
state_before: 𝕜 : Type u
inst✝¹¹ : NontriviallyNormedField 𝕜
E : Type v
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type w
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
F' : Type x
inst✝⁶ : AddCommGroup F'
inst✝⁵ : Module 𝕜 F'
inst✝⁴ : TopologicalSpace F'
inst✝³ : TopologicalAddGroup F'
inst✝² : ContinuousSMul 𝕜 F'
inst✝¹ : CompleteSpace 𝕜
f : E →ₗ[𝕜] F
hf : LinearMap.ker f = ⊥
inst✝ : FiniteDimensional 𝕜 E
g : E ≃ₗ[𝕜] { x // x ∈ LinearMap.range f } := ofInjective f (_ : Function.Injective ↑f)
src✝ : Embedding (Subtype.val ∘ ↑(ContinuousLinearEquiv.toHomeomorph (toContinuousLinearEquiv g))) :=
  Embedding.comp embedding_subtype_val
    (Homeomorph.embedding (ContinuousLinearEquiv.toHomeomorph (toContinuousLinearEquiv g)))
⊢ IsClosed (range ↑f)

tactic: simpa [LinearMap.range_coe f] using f.range.closed_of_finiteDimensional
state_before: 𝕜 : Type u
inst✝¹¹ : NontriviallyNormedField 𝕜
E : Type v
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type w
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
F' : Type x
inst✝⁶ : AddCommGroup F'
inst✝⁵ : Module 𝕜 F'
inst✝⁴ : TopologicalSpace F'
inst✝³ : TopologicalAddGroup F'
inst✝² : ContinuousSMul 𝕜 F'
inst✝¹ : CompleteSpace 𝕜
f : E →ₗ[𝕜] F
hf : LinearMap.ker f = ⊥
inst✝ : FiniteDimensional 𝕜 E
g : E ≃ₗ[𝕜] { x // x ∈ LinearMap.range f } := ofInjective f (_ : Function.Injective ↑f)
src✝ : Embedding (Subtype.val ∘ ↑(ContinuousLinearEquiv.toHomeomorph (toContinuousLinearEquiv g))) :=
  Embedding.comp embedding_subtype_val
    (Homeomorph.embedding (ContinuousLinearEquiv.toHomeomorph (toContinuousLinearEquiv g)))
this : FiniteDimensional 𝕜 { x // x ∈ LinearMap.range f }
⊢ IsClosed (range ↑f)
Theorem: isLittleO_zpow_exp_pos_mul_atTop
File: Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean

tactic: simpa only [rpow_int_cast] using isLittleO_rpow_exp_pos_mul_atTop k hb
state_before: k : ℤ
b : ℝ
hb : 0 < b
⊢ (fun x => x ^ ↑k) =o[atTop] fun x => exp (b * x)
Theorem: HomologicalComplex.singleMapHomologicalComplex_inv_app_self
File: Mathlib/Algebra/Homology/Additive.lean

tactic: simp
state_before: ι : Type ?u.172926
V : Type u
inst✝⁶ : Category V
inst✝⁵ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h k : D ⟶ E
i : ι
inst✝⁴ : HasZeroObject V
W : Type ?u.173295
inst✝³ : Category W
inst✝² : Preadditive W
inst✝¹ : HasZeroObject W
F : V ⥤ W
inst✝ : Functor.Additive F
j : ι
X : V
⊢ HomologicalComplex.X ((F ⋙ single W c j).obj X) j =
    HomologicalComplex.X ((single V c j ⋙ Functor.mapHomologicalComplex F c).obj X) j

tactic: simp [singleMapHomologicalComplex]
state_before: ι : Type u_3
V : Type u
inst✝⁶ : Category V
inst✝⁵ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h k : D ⟶ E
i : ι
inst✝⁴ : HasZeroObject V
W : Type u_2
inst✝³ : Category W
inst✝² : Preadditive W
inst✝¹ : HasZeroObject W
F : V ⥤ W
inst✝ : Functor.Additive F
j : ι
X : V
⊢ Hom.f ((singleMapHomologicalComplex F c j).inv.app X) j =
    eqToHom (_ : (if j = j then F.obj X else 0) = F.obj (if j = j then X else 0))
Theorem: normalizerCondition_iff_only_full_group_self_normalizing
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: apply forall_congr'
state_before: G : Type u_1
G' : Type ?u.405590
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.405599
inst✝¹ : AddGroup A
H K : Subgroup G
N : Type ?u.405617
inst✝ : Group N
⊢ NormalizerCondition G ↔ ∀ (H : Subgroup G), normalizer H = H → H = ⊤

tactic: intro H
state_before: case h
G : Type u_1
G' : Type ?u.405590
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.405599
inst✝¹ : AddGroup A
H K : Subgroup G
N : Type ?u.405617
inst✝ : Group N
⊢ ∀ (a : Subgroup G), a < ⊤ → a < normalizer a ↔ normalizer a = a → a = ⊤

tactic: simp only [lt_iff_le_and_ne, le_normalizer, true_and_iff, le_top, Ne.def]
state_before: case h
G : Type u_1
G' : Type ?u.405590
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.405599
inst✝¹ : AddGroup A
H✝ K : Subgroup G
N : Type ?u.405617
inst✝ : Group N
H : Subgroup G
⊢ H < ⊤ → H < normalizer H ↔ normalizer H = H → H = ⊤

tactic: tauto
state_before: case h
G : Type u_1
G' : Type ?u.405590
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.405599
inst✝¹ : AddGroup A
H✝ K : Subgroup G
N : Type ?u.405617
inst✝ : Group N
H : Subgroup G
⊢ ¬H = ⊤ → ¬H = normalizer H ↔ normalizer H = H → H = ⊤
Theorem: Odd.not_two_dvd_nat
File: Mathlib/Data/Nat/Parity.lean

tactic: rwa [← even_iff_two_dvd, ← odd_iff_not_even]
state_before: m n : ℕ
h : Odd n
⊢ ¬2 ∣ n
Theorem: CategoryTheory.isCoseparator_iff_faithful_preadditiveYonedaObj
File: Mathlib/CategoryTheory/Preadditive/Generator.lean

tactic: rw [isCoseparator_iff_faithful_preadditiveYoneda, preadditiveYoneda_obj]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Preadditive C
G : C
⊢ IsCoseparator G ↔ Faithful (preadditiveYonedaObj G)

tactic: exact ⟨fun h => Faithful.of_comp _ (forget₂ _ AddCommGroupCat.{v}), fun h => Faithful.comp _ _⟩
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Preadditive C
G : C
⊢ Faithful (preadditiveYonedaObj G ⋙ forget₂ (ModuleCat (End G)) AddCommGroupCat) ↔ Faithful (preadditiveYonedaObj G)
Theorem: CategoryTheory.comp_eq_zero_of_exact
File: Mathlib/Algebra/Homology/Exact.lean

tactic: rw [← kernel.lift_ι _ _ hι, ← cokernel.π_desc _ _ hπ, Category.assoc,
  kernel_comp_cokernel_assoc _ _ h, zero_comp, comp_zero]
state_before: V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h✝ : C ⟶ D
inst✝² : HasZeroMorphisms V
inst✝¹ : HasEqualizers V
inst✝ : HasCokernels V
h : Exact f g
X Y : V
ι : X ⟶ B
hι : ι ≫ g = 0
π : B ⟶ Y
hπ : f ≫ π = 0
⊢ ι ≫ π = 0
Theorem: Set.insert_diff_singleton
File: Mathlib/Data/Set/Basic.lean

tactic: simp [insert_eq, union_diff_self, -union_singleton, -singleton_union]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a✝ b : α
s✝ s₁ s₂ t t₁ t₂ u : Set α
a : α
s : Set α
⊢ insert a (s \ {a}) = insert a s
Theorem: List.map_permutationsAux
File: Mathlib/Data/List/Permutation.lean

tactic: refine' permutationsAux.rec (by simp) _
state_before: α : Type u_1
β : Type u_2
f : α → β
⊢ ∀ (ts is : List α), map (map f) (permutationsAux ts is) = permutationsAux (map f ts) (map f is)

tactic: introv IH1 IH2
state_before: α : Type u_1
β : Type u_2
f : α → β
⊢ ∀ (t : α) (ts is : List α),
    map (map f) (permutationsAux ts (t :: is)) = permutationsAux (map f ts) (map f (t :: is)) →
      map (map f) (permutationsAux is []) = permutationsAux (map f is) (map f []) →
        map (map f) (permutationsAux (t :: ts) is) = permutationsAux (map f (t :: ts)) (map f is)

tactic: rw [map] at IH2
state_before: α : Type u_1
β : Type u_2
f : α → β
t : α
ts is : List α
IH1 : map (map f) (permutationsAux ts (t :: is)) = permutationsAux (map f ts) (map f (t :: is))
IH2 : map (map f) (permutationsAux is []) = permutationsAux (map f is) (map f [])
⊢ map (map f) (permutationsAux (t :: ts) is) = permutationsAux (map f (t :: ts)) (map f is)

tactic: simp only [foldr_permutationsAux2, map_append, map, map_map_permutationsAux2, permutations,
  bind_map, IH1, append_assoc, permutationsAux_cons, cons_bind, ← IH2, map_bind]
state_before: α : Type u_1
β : Type u_2
f : α → β
t : α
ts is : List α
IH1 : map (map f) (permutationsAux ts (t :: is)) = permutationsAux (map f ts) (map f (t :: is))
IH2 : map (map f) (permutationsAux is []) = permutationsAux (map f is) []
⊢ map (map f) (permutationsAux (t :: ts) is) = permutationsAux (map f (t :: ts)) (map f is)

tactic: simp
state_before: α : Type u_1
β : Type u_2
f : α → β
⊢ ∀ (is : List α), map (map f) (permutationsAux [] is) = permutationsAux (map f []) (map f is)
Theorem: TopologicalSpace.tendsto_nhds_generateFrom
File: Mathlib/Topology/Order.lean

tactic: rw [nhds_generateFrom]
state_before: α : Type u
β : Type u_1
m : α → β
f : Filter α
g : Set (Set β)
b : β
h : ∀ (s : Set β), s ∈ g → b ∈ s → m ⁻¹' s ∈ f
⊢ Tendsto m f (𝓝 b)

tactic: exact tendsto_iInf.2 fun s => tendsto_iInf.2 fun ⟨hbs, hsg⟩ => tendsto_principal.2 <| h s hsg hbs
state_before: α : Type u
β : Type u_1
m : α → β
f : Filter α
g : Set (Set β)
b : β
h : ∀ (s : Set β), s ∈ g → b ∈ s → m ⁻¹' s ∈ f
⊢ Tendsto m f (⨅ (s : Set β) (_ : s ∈ {s | b ∈ s ∧ s ∈ g}), 𝓟 s)
Theorem: MeasureTheory.lintegral_mul_right_eq_self
File: Mathlib/MeasureTheory/Group/Integration.lean

tactic: convert (lintegral_map_equiv f <| MeasurableEquiv.mulRight g).symm using 1
state_before: 𝕜 : Type ?u.26943
M : Type ?u.26946
α : Type ?u.26949
G : Type u_1
E : Type ?u.26955
F : Type ?u.26958
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : IsMulRightInvariant μ
f : G → ℝ≥0∞
g : G
⊢ (∫⁻ (x : G), f (x * g) ∂μ) = ∫⁻ (x : G), f x ∂μ

tactic: simp [map_mul_right_eq_self μ g]
state_before: case h.e'_3
𝕜 : Type ?u.26943
M : Type ?u.26946
α : Type ?u.26949
G : Type u_1
E : Type ?u.26955
F : Type ?u.26958
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : IsMulRightInvariant μ
f : G → ℝ≥0∞
g : G
⊢ (∫⁻ (x : G), f x ∂μ) = ∫⁻ (a : G), f a ∂map (↑(MeasurableEquiv.mulRight g)) μ
Theorem: FreeGroup.Red.Step.length
File: Mathlib/GroupTheory/FreeGroup.lean

tactic: rw [List.length_append, List.length_append]
state_before: α : Type u
L L₁ L₂ L₃ L₄ L1 L2 : List (α × Bool)
x : α
b : Bool
⊢ List.length (L1 ++ L2) + 2 = List.length (L1 ++ (x, b) :: (x, !b) :: L2)

tactic: rfl
state_before: α : Type u
L L₁ L₂ L₃ L₄ L1 L2 : List (α × Bool)
x : α
b : Bool
⊢ List.length L1 + List.length L2 + 2 = List.length L1 + List.length ((x, b) :: (x, !b) :: L2)
Theorem: Nat.log2_lt
File: Std/Data/Nat/Lemmas.lean

tactic: rw [← Nat.not_le, ← Nat.not_le, le_log2 h]
state_before: n k : Nat
h : n ≠ 0
⊢ log2 n < k ↔ n < 2 ^ k
Theorem: Fin.pred_lt_pred_iff
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [← succ_lt_succ_iff, succ_pred, succ_pred]
state_before: n✝ m n : ℕ
a b : Fin (Nat.succ n)
ha : a ≠ 0
hb : b ≠ 0
⊢ pred a ha < pred b hb ↔ a < b
Theorem: LiouvilleWith.irrational
File: Mathlib/NumberTheory/Liouville/LiouvilleWith.lean

tactic: rintro ⟨r, rfl⟩
state_before: p q x y : ℝ
r : ℚ
m : ℤ
n : ℕ
h : LiouvilleWith p x
hp : 1 < p
⊢ Irrational x

tactic: rcases eq_or_ne r 0 with (rfl | h0)
state_before: case intro
p q y : ℝ
r✝ : ℚ
m : ℤ
n : ℕ
hp : 1 < p
r : ℚ
h : LiouvilleWith p ↑r
⊢ False

tactic: refine h.ne_cast_int hp 0 ?_
state_before: case intro.inl
p q y : ℝ
r : ℚ
m : ℤ
n : ℕ
hp : 1 < p
h : LiouvilleWith p ↑0
⊢ False

tactic: rw [Rat.cast_zero, Int.cast_zero]
state_before: case intro.inl
p q y : ℝ
r : ℚ
m : ℤ
n : ℕ
hp : 1 < p
h : LiouvilleWith p ↑0
⊢ ↑0 = ↑0

tactic: refine (h.mul_rat (inv_ne_zero h0)).ne_cast_int hp 1 ?_
state_before: case intro.inr
p q y : ℝ
r✝ : ℚ
m : ℤ
n : ℕ
hp : 1 < p
r : ℚ
h : LiouvilleWith p ↑r
h0 : r ≠ 0
⊢ False

tactic: rw [Rat.cast_inv, mul_inv_cancel]
state_before: case intro.inr
p q y : ℝ
r✝ : ℚ
m : ℤ
n : ℕ
hp : 1 < p
r : ℚ
h : LiouvilleWith p ↑r
h0 : r ≠ 0
⊢ ↑r * ↑r⁻¹ = ↑1

tactic: exacts [Int.cast_one.symm, Rat.cast_ne_zero.mpr h0]
state_before: case intro.inr
p q y : ℝ
r✝ : ℚ
m : ℤ
n : ℕ
hp : 1 < p
r : ℚ
h : LiouvilleWith p ↑r
h0 : r ≠ 0
⊢ 1 = ↑1

case intro.inr
p q y : ℝ
r✝ : ℚ
m : ℤ
n : ℕ
hp : 1 < p
r : ℚ
h : LiouvilleWith p ↑r
h0 : r ≠ 0
⊢ ↑r ≠ 0