tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.obj_μ_zero_app
File: Mathlib/CategoryTheory/Monoidal/End.lean

tactic: rw [← obj_ε_inv_app_assoc, ← Functor.map_comp]
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m₁ m₂ : M
X : C
⊢ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ M) m₂).app ((F.obj m₁).obj X) ≫
      (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₁ (𝟙_ M ⊗ m₂)).app X ≫
        (F.map (α_ m₁ (𝟙_ M) m₂).inv).app X ≫ (MonoidalFunctor.μIso F (m₁ ⊗ 𝟙_ M) m₂).inv.app X =
    (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ M) m₂).app ((F.obj m₁).obj X) ≫
      (F.map (λ_ m₂).hom).app ((F.obj m₁).obj X) ≫ (F.obj m₂).map ((F.map (ρ_ m₁).inv).app X)

tactic: congr
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m₁ m₂ : M
X : C
⊢ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ M) m₂).app ((F.obj m₁).obj X) ≫
      (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₁ (𝟙_ M ⊗ m₂)).app X ≫
        (F.map (α_ m₁ (𝟙_ M) m₂).inv).app X ≫ (MonoidalFunctor.μIso F (m₁ ⊗ 𝟙_ M) m₂).inv.app X =
    (F.obj m₂).map ((MonoidalFunctor.εIso F).inv.app ((F.obj m₁).obj X) ≫ (F.map (ρ_ m₁).inv).app X)

tactic: simp
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m₁ m₂ : M
X : C
⊢ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ M) m₂).app ((F.obj m₁).obj X) ≫
      (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m₁ (𝟙_ M ⊗ m₂)).app X ≫
        (F.map (α_ m₁ (𝟙_ M) m₂).inv).app X ≫ (MonoidalFunctor.μIso F (m₁ ⊗ 𝟙_ M) m₂).inv.app X =
    (F.obj m₂).map ((MonoidalFunctor.εIso F).inv.app ((F.obj m₁).obj X) ≫ (F.map (ρ_ m₁).inv).app X)
Theorem: CategoryTheory.Adjunction.homEquiv_naturality_left
File: Mathlib/CategoryTheory/Adjunction/Basic.lean

tactic: rw [← Equiv.eq_symm_apply]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
f : X' ⟶ X
g : F.obj X ⟶ Y
⊢ ↑(homEquiv adj X' Y) (F.map f ≫ g) = f ≫ ↑(homEquiv adj X Y) g

tactic: simp only [Equiv.symm_apply_apply,eq_self_iff_true,homEquiv_naturality_left_symm]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
X' X : C
Y Y' : D
f : X' ⟶ X
g : F.obj X ⟶ Y
⊢ F.map f ≫ g = ↑(homEquiv adj X' Y).symm (f ≫ ↑(homEquiv adj X Y) g)
Theorem: Pairwise.exists_mem_filter_basis_of_disjoint
File: Mathlib/Order/Filter/Bases.lean

tactic: rcases hd.exists_mem_filter_of_disjoint with ⟨t, htl, hd⟩
state_before: α : Type u_2
β : Type ?u.53092
γ : Type ?u.53095
ι✝ : Sort ?u.53098
ι' : Sort ?u.53101
l✝ l' : Filter α
p✝ : ι✝ → Prop
s✝ : ι✝ → Set α
t : Set α
i : ι✝
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
I : Type u_1
inst✝ : Finite I
l : I → Filter α
ι : I → Sort u_3
p : (i : I) → ι i → Prop
s : (i : I) → ι i → Set α
hd : Pairwise (Disjoint on l)
h : ∀ (i : I), HasBasis (l i) (p i) (s i)
⊢ ∃ ind, (∀ (i : I), p i (ind i)) ∧ Pairwise (Disjoint on fun i => s i (ind i))

tactic: choose ind hp ht using fun i => (h i).mem_iff.1 (htl i)
state_before: case intro.intro
α : Type u_2
β : Type ?u.53092
γ : Type ?u.53095
ι✝ : Sort ?u.53098
ι' : Sort ?u.53101
l✝ l' : Filter α
p✝ : ι✝ → Prop
s✝ : ι✝ → Set α
t✝ : Set α
i : ι✝
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
I : Type u_1
inst✝ : Finite I
l : I → Filter α
ι : I → Sort u_3
p : (i : I) → ι i → Prop
s : (i : I) → ι i → Set α
hd✝ : Pairwise (Disjoint on l)
h : ∀ (i : I), HasBasis (l i) (p i) (s i)
t : I → Set α
htl : ∀ (i : I), t i ∈ l i
hd : Pairwise (Disjoint on t)
⊢ ∃ ind, (∀ (i : I), p i (ind i)) ∧ Pairwise (Disjoint on fun i => s i (ind i))

tactic: exact ⟨ind, hp, hd.mono fun i j hij => hij.mono (ht _) (ht _)⟩
state_before: case intro.intro
α : Type u_2
β : Type ?u.53092
γ : Type ?u.53095
ι✝ : Sort ?u.53098
ι' : Sort ?u.53101
l✝ l' : Filter α
p✝ : ι✝ → Prop
s✝ : ι✝ → Set α
t✝ : Set α
i : ι✝
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
I : Type u_1
inst✝ : Finite I
l : I → Filter α
ι : I → Sort u_3
p : (i : I) → ι i → Prop
s : (i : I) → ι i → Set α
hd✝ : Pairwise (Disjoint on l)
h : ∀ (i : I), HasBasis (l i) (p i) (s i)
t : I → Set α
htl : ∀ (i : I), t i ∈ l i
hd : Pairwise (Disjoint on t)
ind : (i : I) → ι i
hp : ∀ (i : I), p i (ind i)
ht : ∀ (i : I), s i (ind i) ⊆ t i
⊢ ∃ ind, (∀ (i : I), p i (ind i)) ∧ Pairwise (Disjoint on fun i => s i (ind i))
Theorem: QuotientGroup.leftRel_eq
File: Mathlib/GroupTheory/Coset.lean

tactic: simp only [eq_iff_iff]
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
⊢ ∀ (a b : α), Setoid.r a b = (a⁻¹ * b ∈ s)

tactic: apply leftRel_apply
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
⊢ ∀ (a b : α), Setoid.r a b ↔ a⁻¹ * b ∈ s
Theorem: List.Sorted.rel_get_of_le
File: Mathlib/Data/List/Sort.lean

tactic: rcases hab.eq_or_lt with (rfl | hlt)
state_before: α : Type uu
r : α → α → Prop
a✝ : α
l✝ : List α
inst✝ : IsRefl α r
l : List α
h : Sorted r l
a b : Fin (length l)
hab : a ≤ b
⊢ r (get l a) (get l b)

tactic: exacts [refl _, h.rel_get_of_lt hlt]
state_before: case inl
α : Type uu
r : α → α → Prop
a✝ : α
l✝ : List α
inst✝ : IsRefl α r
l : List α
h : Sorted r l
a : Fin (length l)
hab : a ≤ a
⊢ r (get l a) (get l a)

case inr
α : Type uu
r : α → α → Prop
a✝ : α
l✝ : List α
inst✝ : IsRefl α r
l : List α
h : Sorted r l
a b : Fin (length l)
hab : a ≤ b
hlt : a < b
⊢ r (get l a) (get l b)
Theorem: LipschitzWith.min_const
File: Mathlib/Topology/MetricSpace/Lipschitz.lean

tactic: simpa only [max_eq_left (zero_le Kf)] using hf.min (LipschitzWith.const a)
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : PseudoEMetricSpace α
f g : α → ℝ
Kf Kg : ℝ≥0
hf : LipschitzWith Kf f
a : ℝ
⊢ LipschitzWith Kf fun x => min (f x) a
Theorem: Stream'.Seq.destruct_eq_nil
File: Mathlib/Data/Seq/Seq.lean

tactic: dsimp [destruct]
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
⊢ destruct s = none → s = nil

tactic: induction' f0 : get? s 0 <;> intro h
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
⊢ Option.map (fun a' => (a', tail s)) (get? s 0) = none → s = nil

tactic: apply Subtype.eq
state_before: case none
α : Type u
β : Type v
γ : Type w
s : Seq α
x✝ : Option α
f0✝ : get? s 0 = x✝
f0 : get? s 0 = none
h : Option.map (fun a' => (a', tail s)) none = none
⊢ s = nil

tactic: funext n
state_before: case none.a
α : Type u
β : Type v
γ : Type w
s : Seq α
x✝ : Option α
f0✝ : get? s 0 = x✝
f0 : get? s 0 = none
h : Option.map (fun a' => (a', tail s)) none = none
⊢ ↑s = ↑nil

tactic: induction' n with n IH
state_before: case none.a.h
α : Type u
β : Type v
γ : Type w
s : Seq α
x✝ : Option α
f0✝ : get? s 0 = x✝
f0 : get? s 0 = none
h : Option.map (fun a' => (a', tail s)) none = none
n : ℕ
⊢ ↑s n = ↑nil n

tactic: exacts [f0, s.2 IH]
state_before: case none.a.h.zero
α : Type u
β : Type v
γ : Type w
s : Seq α
x✝ : Option α
f0✝ : get? s 0 = x✝
f0 : get? s 0 = none
h : Option.map (fun a' => (a', tail s)) none = none
⊢ ↑s Nat.zero = ↑nil Nat.zero

case none.a.h.succ
α : Type u
β : Type v
γ : Type w
s : Seq α
x✝ : Option α
f0✝ : get? s 0 = x✝
f0 : get? s 0 = none
h : Option.map (fun a' => (a', tail s)) none = none
n : ℕ
IH : ↑s n = ↑nil n
⊢ ↑s (Nat.succ n) = ↑nil (Nat.succ n)

tactic: contradiction
state_before: case some
α : Type u
β : Type v
γ : Type w
s : Seq α
x✝ : Option α
f0✝ : get? s 0 = x✝
val✝ : α
f0 : get? s 0 = some val✝
h : Option.map (fun a' => (a', tail s)) (some val✝) = none
⊢ s = nil
Theorem: Finset.univ_nonempty_iff
File: Mathlib/Data/Fintype/Basic.lean

tactic: rw [← coe_nonempty, coe_univ, Set.nonempty_iff_univ_nonempty]
state_before: α : Type u_1
β : Type ?u.1860
γ : Type ?u.1863
inst✝ : Fintype α
s t : Finset α
⊢ Finset.Nonempty univ ↔ Nonempty α
Theorem: MeasureTheory.snormEssSup_measure_zero
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: simp [snormEssSup]
state_before: α : Type u_1
E : Type ?u.951145
F : Type u_2
G : Type ?u.951151
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
inst✝ : MeasurableSpace α
f : α → F
⊢ snormEssSup f 0 = 0
Theorem: Multiset.mem_Ioi
File: Mathlib/Order/LocallyFinite.lean

tactic: rw [Ioi, ← Finset.mem_def, Finset.mem_Ioi]
state_before: α : Type u_1
β : Type ?u.33793
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrderTop α
a x : α
⊢ x ∈ Ioi a ↔ a < x
Theorem: disjointed_le_id
File: Mathlib/Order/Disjointed.lean

tactic: rintro f n
state_before: α : Type u_1
β : Type ?u.1032
inst✝ : GeneralizedBooleanAlgebra α
⊢ disjointed ≤ id

tactic: cases n
state_before: α : Type u_1
β : Type ?u.1032
inst✝ : GeneralizedBooleanAlgebra α
f : ℕ → α
n : ℕ
⊢ disjointed f n ≤ id f n

tactic: rfl
state_before: case zero
α : Type u_1
β : Type ?u.1032
inst✝ : GeneralizedBooleanAlgebra α
f : ℕ → α
⊢ disjointed f Nat.zero ≤ id f Nat.zero

tactic: exact sdiff_le
state_before: case succ
α : Type u_1
β : Type ?u.1032
inst✝ : GeneralizedBooleanAlgebra α
f : ℕ → α
n✝ : ℕ
⊢ disjointed f (Nat.succ n✝) ≤ id f (Nat.succ n✝)
Theorem: MeasureTheory.Measure.count_apply_eq_top
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: by_cases hs : s.Finite
state_before: α : Type u_1
β : Type ?u.378850
γ : Type ?u.378853
δ : Type ?u.378856
ι : Type ?u.378859
R : Type ?u.378862
R' : Type ?u.378865
m0 : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSingletonClass α
⊢ ↑↑count s = ⊤ ↔ Set.Infinite s

tactic: exact count_apply_eq_top' hs.measurableSet
state_before: case pos
α : Type u_1
β : Type ?u.378850
γ : Type ?u.378853
δ : Type ?u.378856
ι : Type ?u.378859
R : Type ?u.378862
R' : Type ?u.378865
m0 : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSingletonClass α
hs : Set.Finite s
⊢ ↑↑count s = ⊤ ↔ Set.Infinite s

tactic: change s.Infinite at hs
state_before: case neg
α : Type u_1
β : Type ?u.378850
γ : Type ?u.378853
δ : Type ?u.378856
ι : Type ?u.378859
R : Type ?u.378862
R' : Type ?u.378865
m0 : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSingletonClass α
hs : ¬Set.Finite s
⊢ ↑↑count s = ⊤ ↔ Set.Infinite s

tactic: simp [hs, count_apply_infinite]
state_before: case neg
α : Type u_1
β : Type ?u.378850
γ : Type ?u.378853
δ : Type ?u.378856
ι : Type ?u.378859
R : Type ?u.378862
R' : Type ?u.378865
m0 : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSingletonClass α
hs : Set.Infinite s
⊢ ↑↑count s = ⊤ ↔ Set.Infinite s
Theorem: Real.sinh_log
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: rw [sinh_eq, exp_neg, exp_log hx]
state_before: x✝ y x : ℝ
hx : 0 < x
⊢ sinh (log x) = (x - x⁻¹) / 2
Theorem: rank_range_add_rank_ker
File: Mathlib/LinearAlgebra/Dimension.lean

tactic: haveI := fun p : Submodule K V => Classical.decEq (V ⧸ p)
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.580352
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V₁
inst✝ : Module K V₁
f : V →ₗ[K] V₁
⊢ Module.rank K { x // x ∈ LinearMap.range f } + Module.rank K { x // x ∈ LinearMap.ker f } = Module.rank K V

tactic: rw [← f.quotKerEquivRange.rank_eq, rank_quotient_add_rank]
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.580352
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V₁
inst✝ : Module K V₁
f : V →ₗ[K] V₁
this : (p : Submodule K V) → DecidableEq (V ⧸ p)
⊢ Module.rank K { x // x ∈ LinearMap.range f } + Module.rank K { x // x ∈ LinearMap.ker f } = Module.rank K V
Theorem: ContinuousAffineMap.to_continuousMap_injective
File: Mathlib/Topology/Algebra/ContinuousAffineMap.lean

tactic: ext a
state_before: R : Type u_1
V : Type u_2
W : Type u_3
P : Type u_4
Q : Type u_5
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module R V
inst✝⁵ : TopologicalSpace P
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup W
inst✝² : Module R W
inst✝¹ : TopologicalSpace Q
inst✝ : AddTorsor W Q
f g : P →A[R] Q
h : ContinuousMap.mk ↑f = ContinuousMap.mk ↑g
⊢ f = g

tactic: exact ContinuousMap.congr_fun h a
state_before: case h
R : Type u_1
V : Type u_2
W : Type u_3
P : Type u_4
Q : Type u_5
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module R V
inst✝⁵ : TopologicalSpace P
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup W
inst✝² : Module R W
inst✝¹ : TopologicalSpace Q
inst✝ : AddTorsor W Q
f g : P →A[R] Q
h : ContinuousMap.mk ↑f = ContinuousMap.mk ↑g
a : P
⊢ ↑f a = ↑g a
Theorem: Finset.image₂_curry
File: Mathlib/Data/Finset/NAry.lean

tactic: classical rw [← image₂_mk_eq_product, image_image₂]; dsimp [curry]
state_before: α : Type u_1
α' : Type ?u.65130
β : Type u_2
β' : Type ?u.65136
γ : Type u_3
γ' : Type ?u.65142
δ : Type ?u.65145
δ' : Type ?u.65148
ε : Type ?u.65151
ε' : Type ?u.65154
ζ : Type ?u.65157
ζ' : Type ?u.65160
ν : Type ?u.65163
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f✝ f' : α → β → γ
g g' : α → β → γ → δ
s✝ s' : Finset α
t✝ t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
f : α × β → γ
s : Finset α
t : Finset β
⊢ image₂ (curry f) s t = image f (s ×ˢ t)

tactic: rw [← image₂_mk_eq_product, image_image₂]
state_before: α : Type u_1
α' : Type ?u.65130
β : Type u_2
β' : Type ?u.65136
γ : Type u_3
γ' : Type ?u.65142
δ : Type ?u.65145
δ' : Type ?u.65148
ε : Type ?u.65151
ε' : Type ?u.65154
ζ : Type ?u.65157
ζ' : Type ?u.65160
ν : Type ?u.65163
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f✝ f' : α → β → γ
g g' : α → β → γ → δ
s✝ s' : Finset α
t✝ t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
f : α × β → γ
s : Finset α
t : Finset β
⊢ image₂ (curry f) s t = image f (s ×ˢ t)

tactic: dsimp [curry]
state_before: α : Type u_1
α' : Type ?u.65130
β : Type u_2
β' : Type ?u.65136
γ : Type u_3
γ' : Type ?u.65142
δ : Type ?u.65145
δ' : Type ?u.65148
ε : Type ?u.65151
ε' : Type ?u.65154
ζ : Type ?u.65157
ζ' : Type ?u.65160
ν : Type ?u.65163
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f✝ f' : α → β → γ
g g' : α → β → γ → δ
s✝ s' : Finset α
t✝ t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
f : α × β → γ
s : Finset α
t : Finset β
⊢ image₂ (curry f) s t = image₂ (fun a b => f (a, b)) s t
Theorem: Polynomial.expand_eval
File: Mathlib/Data/Polynomial/Expand.lean

tactic: refine' Polynomial.induction_on P (fun a => by simp) (fun f g hf hg => _) fun n a _ => by simp
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q p : ℕ
P : R[X]
r : R
⊢ eval r (↑(expand R p) P) = eval (r ^ p) P

tactic: rw [AlgHom.map_add, eval_add, eval_add, hf, hg]
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q p : ℕ
P : R[X]
r : R
f g : R[X]
hf : eval r (↑(expand R p) f) = eval (r ^ p) f
hg : eval r (↑(expand R p) g) = eval (r ^ p) g
⊢ eval r (↑(expand R p) (f + g)) = eval (r ^ p) (f + g)

tactic: simp
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q p : ℕ
P : R[X]
r a : R
⊢ eval r (↑(expand R p) (↑C a)) = eval (r ^ p) (↑C a)

tactic: simp
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q p : ℕ
P : R[X]
r : R
n : ℕ
a : R
x✝ : eval r (↑(expand R p) (↑C a * X ^ n)) = eval (r ^ p) (↑C a * X ^ n)
⊢ eval r (↑(expand R p) (↑C a * X ^ (n + 1))) = eval (r ^ p) (↑C a * X ^ (n + 1))
Theorem: lipschitzWith_circleMap
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

tactic: simp
state_before: E : Type ?u.27048
inst✝ : NormedAddCommGroup E
c : ℂ
R θ : ℝ
⊢ ↑‖deriv (circleMap c R) θ‖₊ ≤ ↑(↑Real.nnabs R)
Theorem: Equiv.Perm.isCycle_of_prime_order''
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: rw [← one_mul (Fintype.card α), ← h2, mul_lt_mul_right (orderOf_pos σ)]
state_before: α : Type u_1
inst✝ : Fintype α
σ : Perm α
h1 : Nat.Prime (Fintype.card α)
h2 : orderOf σ = Fintype.card α
⊢ Fintype.card α < 2 * orderOf σ

tactic: exact one_lt_two
state_before: α : Type u_1
inst✝ : Fintype α
σ : Perm α
h1 : Nat.Prime (Fintype.card α)
h2 : orderOf σ = Fintype.card α
⊢ 1 < 2
Theorem: IntermediateField.adjoin_int
File: Mathlib/FieldTheory/Adjoin.lean

tactic: refine' adjoin_simple_eq_bot_iff.mpr (coe_int_mem ⊥ n)
state_before: F : Type u_2
inst✝² : Field F
E : Type u_1
inst✝¹ : Field E
inst✝ : Algebra F E
α : E
S : Set E
n : ℤ
⊢ F⟮↑n⟯ = ⊥
Theorem: Nat.Linear.Poly.of_denote_eq_cancel
File: src/lean/Init/Data/Nat/Linear.lean

tactic: simp at h
state_before: ctx : Context
m₁ m₂ : Poly
h : denote_eq ctx (cancel m₁ m₂)
⊢ denote_eq ctx (m₁, m₂)

tactic: have := Poly.of_denote_eq_cancelAux (h := h)
state_before: ctx : Context
m₁ m₂ : Poly
h : denote_eq ctx (cancel m₁ m₂)
⊢ denote_eq ctx (m₁, m₂)

tactic: simp at this
state_before: ctx : Context
m₁ m₂ : Poly
h : denote_eq ctx (cancel m₁ m₂)
this : denote_eq ctx (List.reverse [] ++ m₁, List.reverse [] ++ m₂)
⊢ denote_eq ctx (m₁, m₂)

tactic: assumption
state_before: ctx : Context
m₁ m₂ : Poly
h : denote_eq ctx (cancel m₁ m₂)
this : denote_eq ctx (m₁, m₂)
⊢ denote_eq ctx (m₁, m₂)
Theorem: ManyOneDegree.add_le
File: Mathlib/Computability/Reduce.lean

tactic: induction d₁ using ManyOneDegree.ind_on
state_before: α : Type u
inst✝⁵ : Primcodable α
inst✝⁴ : Inhabited α
β : Type v
inst✝³ : Primcodable β
inst✝² : Inhabited β
γ : Type w
inst✝¹ : Primcodable γ
inst✝ : Inhabited γ
d₁ d₂ d₃ : ManyOneDegree
⊢ d₁ + d₂ ≤ d₃ ↔ d₁ ≤ d₃ ∧ d₂ ≤ d₃

tactic: induction d₂ using ManyOneDegree.ind_on
state_before: case h
α : Type u
inst✝⁵ : Primcodable α
inst✝⁴ : Inhabited α
β : Type v
inst✝³ : Primcodable β
inst✝² : Inhabited β
γ : Type w
inst✝¹ : Primcodable γ
inst✝ : Inhabited γ
d₂ d₃ : ManyOneDegree
p✝ : Set ℕ
⊢ of p✝ + d₂ ≤ d₃ ↔ of p✝ ≤ d₃ ∧ d₂ ≤ d₃

tactic: induction d₃ using ManyOneDegree.ind_on
state_before: case h.h
α : Type u
inst✝⁵ : Primcodable α
inst✝⁴ : Inhabited α
β : Type v
inst✝³ : Primcodable β
inst✝² : Inhabited β
γ : Type w
inst✝¹ : Primcodable γ
inst✝ : Inhabited γ
d₃ : ManyOneDegree
p✝¹ p✝ : Set ℕ
⊢ of p✝¹ + of p✝ ≤ d₃ ↔ of p✝¹ ≤ d₃ ∧ of p✝ ≤ d₃

tactic: simpa only [← add_of, of_le_of] using disjoin_le
state_before: case h.h.h
α : Type u
inst✝⁵ : Primcodable α
inst✝⁴ : Inhabited α
β : Type v
inst✝³ : Primcodable β
inst✝² : Inhabited β
γ : Type w
inst✝¹ : Primcodable γ
inst✝ : Inhabited γ
p✝² p✝¹ p✝ : Set ℕ
⊢ of p✝² + of p✝¹ ≤ of p✝ ↔ of p✝² ≤ of p✝ ∧ of p✝¹ ≤ of p✝
Theorem: HasFDerivAt.mul_const
File: Mathlib/Analysis/Calculus/FDeriv/Mul.lean

tactic: convert hc.mul_const' d
state_before: 𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type ?u.934607
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type ?u.934702
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
G' : Type ?u.934797
inst✝⁵ : NormedAddCommGroup G'
inst✝⁴ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
𝔸 : Type ?u.936932
𝔸' : Type u_3
inst✝³ : NormedRing 𝔸
inst✝² : NormedCommRing 𝔸'
inst✝¹ : NormedAlgebra 𝕜 𝔸
inst✝ : NormedAlgebra 𝕜 𝔸'
a b : E → 𝔸
a' b' : E →L[𝕜] 𝔸
c d✝ : E → 𝔸'
c' d' : E →L[𝕜] 𝔸'
hc : HasFDerivAt c c' x
d : 𝔸'
⊢ HasFDerivAt (fun y => c y * d) (d • c') x

tactic: ext z
state_before: case h.e'_10
𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type ?u.934607
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type ?u.934702
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
G' : Type ?u.934797
inst✝⁵ : NormedAddCommGroup G'
inst✝⁴ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
𝔸 : Type ?u.936932
𝔸' : Type u_3
inst✝³ : NormedRing 𝔸
inst✝² : NormedCommRing 𝔸'
inst✝¹ : NormedAlgebra 𝕜 𝔸
inst✝ : NormedAlgebra 𝕜 𝔸'
a b : E → 𝔸
a' b' : E →L[𝕜] 𝔸
c d✝ : E → 𝔸'
c' d' : E →L[𝕜] 𝔸'
hc : HasFDerivAt c c' x
d : 𝔸'
⊢ d • c' = smulRight c' d

tactic: apply mul_comm
state_before: case h.e'_10.h
𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type ?u.934607
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type ?u.934702
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
G' : Type ?u.934797
inst✝⁵ : NormedAddCommGroup G'
inst✝⁴ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
𝔸 : Type ?u.936932
𝔸' : Type u_3
inst✝³ : NormedRing 𝔸
inst✝² : NormedCommRing 𝔸'
inst✝¹ : NormedAlgebra 𝕜 𝔸
inst✝ : NormedAlgebra 𝕜 𝔸'
a b : E → 𝔸
a' b' : E →L[𝕜] 𝔸
c d✝ : E → 𝔸'
c' d' : E →L[𝕜] 𝔸'
hc : HasFDerivAt c c' x
d : 𝔸'
z : E
⊢ ↑(d • c') z = ↑(smulRight c' d) z
Theorem: IsUnit.liftRight_inv_mul
File: Mathlib/Algebra/Hom/Units.lean

tactic: intro
state_before: F : Type ?u.44210
G : Type ?u.44213
α : Type ?u.44216
M : Type u_1
N : Type u_2
inst✝¹ : Monoid M
inst✝ : Monoid N
f : M →* N
h : ∀ (x : M), IsUnit (↑f x)
x : M
⊢ ∀ (x : M), ↑(IsUnit.unit (_ : IsUnit (↑f x))) = ↑f x

tactic: rfl
state_before: F : Type ?u.44210
G : Type ?u.44213
α : Type ?u.44216
M : Type u_1
N : Type u_2
inst✝¹ : Monoid M
inst✝ : Monoid N
f : M →* N
h : ∀ (x : M), IsUnit (↑f x)
x x✝ : M
⊢ ↑(IsUnit.unit (_ : IsUnit (↑f x✝))) = ↑f x✝
Theorem: Filter.tendsto_mul_const_atBot_of_pos
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simpa only [mul_comm] using tendsto_const_mul_atBot_of_pos hr
state_before: ι : Type ?u.227494
ι' : Type ?u.227497
α : Type u_1
β : Type u_2
γ : Type ?u.227506
inst✝ : LinearOrderedField α
l : Filter β
f : β → α
r : α
hr : 0 < r
⊢ Tendsto (fun x => f x * r) l atBot ↔ Tendsto f l atBot
Theorem: Fin.snoc_comp_castSucc
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: rw [Function.comp_apply, snoc_castSucc]
state_before: m n✝ : ℕ
α✝ : Fin (n✝ + 1) → Type u
x : α✝ (last n✝)
q : (i : Fin (n✝ + 1)) → α✝ i
p : (i : Fin n✝) → α✝ (↑castSucc i)
i✝ : Fin n✝
y : α✝ (↑castSucc i✝)
z : α✝ (last n✝)
n : ℕ
α : Type u_1
a : α
f : Fin n → α
i : Fin n
⊢ (snoc f a ∘ ↑castSucc) i = f i
Theorem: Real.cos_add
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [cos_add]
state_before: x y : ℝ
⊢ ↑(cos (x + y)) = ↑(cos x * cos y - sin x * sin y)
Theorem: IsCoprime.of_add_mul_right_right
File: Mathlib/RingTheory/Coprime/Basic.lean

tactic: rw [mul_comm] at h
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
h : IsCoprime x (y + z * x)
⊢ IsCoprime x y

tactic: exact h.of_add_mul_left_right
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
h : IsCoprime x (y + x * z)
⊢ IsCoprime x y
Theorem: Turing.TM1to0.tr_eval
File: Mathlib/Computability/TuringMachine.lean

tactic: rw [Part.map_eq_map, Part.map_map, TM1.eval]
state_before: Γ : Type u_1
inst✝² : Inhabited Γ
Λ : Type u_2
inst✝¹ : Inhabited Λ
σ : Type u_3
inst✝ : Inhabited σ
M : Λ → Stmt₁
l : List Γ
⊢ Part.map (fun c => Tape.right₀ c.Tape)
      ((fun a => trCfg M a) <$> eval (TM1.step M) { l := some default, var := default, Tape := Tape.mk₁ l }) =
    TM1.eval M l

tactic: congr with ⟨⟩
state_before: Γ : Type u_1
inst✝² : Inhabited Γ
Λ : Type u_2
inst✝¹ : Inhabited Λ
σ : Type u_3
inst✝ : Inhabited σ
M : Λ → Stmt₁
l : List Γ
⊢ Part.map ((fun c => Tape.right₀ c.Tape) ∘ fun a => trCfg M a)
      (eval (TM1.step M) { l := some default, var := default, Tape := Tape.mk₁ l }) =
    Part.map (fun c => Tape.right₀ c.Tape) (eval (TM1.step M) (TM1.init l))
Theorem: Submonoid.isSubmonoid
File: Mathlib/Deprecated/Submonoid.lean

tactic: refine' ⟨S.2, S.1.2⟩
state_before: M : Type u_1
inst✝¹ : Monoid M
s : Set M
A : Type ?u.82313
inst✝ : AddMonoid A
t : Set A
S : Submonoid M
⊢ IsSubmonoid ↑S