tasksource/leandojo huggingface dataset:
Theorem: NormedSpace.Dual.dual_norm_topology_le_weak_dual_topology
File: Mathlib/Analysis/NormedSpace/WeakDual.lean

tactic: convert (@toWeakDual_continuous _ _ _ _ (by assumption)).le_induced
state_before: 𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
⊢ UniformSpace.toTopologicalSpace ≤ WeakDual.instTopologicalSpace

tactic: exact induced_id.symm
state_before: case h.e'_4
𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
⊢ WeakDual.instTopologicalSpace = TopologicalSpace.induced (fun x' => ↑toWeakDual x') WeakDual.instTopologicalSpace

tactic: assumption
state_before: 𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
⊢ NormedSpace 𝕜 E
Theorem: UpperSet.one_mul
File: Mathlib/Algebra/Order/UpperLower.lean

tactic: rw [← smul_eq_mul, ← Set.iUnion_smul_set]
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s✝ t : Set α
a : α
s : UpperSet α
⊢ Set.Ici 1 * ↑s ⊆ ↑s

tactic: exact Set.iUnion₂_subset fun _ ↦ s.upper.smul_subset
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s✝ t : Set α
a : α
s : UpperSet α
⊢ (⋃ (a : α) (_ : a ∈ Set.Ici 1), a • ↑s) ⊆ ↑s
Theorem: Int.ofNat_isUnit
File: Mathlib/Data/Int/Units.lean

tactic: simp [isUnit_iff_natAbs_eq]
state_before: n : ℕ
⊢ IsUnit ↑n ↔ IsUnit n
Theorem: List.lookupAll_sublist
File: Mathlib/Data/List/Sigma.lean

tactic: simp
state_before: α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
⊢ map (Sigma.mk a) (lookupAll a []) <+ []

tactic: by_cases h : a = a'
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b' : β a'
l : List (Sigma β)
⊢ map (Sigma.mk a) (lookupAll a ({ fst := a', snd := b' } :: l)) <+ { fst := a', snd := b' } :: l

tactic: subst h
state_before: case pos
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b' : β a'
l : List (Sigma β)
h : a = a'
⊢ map (Sigma.mk a) (lookupAll a ({ fst := a', snd := b' } :: l)) <+ { fst := a', snd := b' } :: l

tactic: simp only [ne_eq, not_true, lookupAll_cons_eq, List.map]
state_before: case pos
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
b' : β a
⊢ map (Sigma.mk a) (lookupAll a ({ fst := a, snd := b' } :: l)) <+ { fst := a, snd := b' } :: l

tactic: exact (lookupAll_sublist a l).cons₂ _
state_before: case pos
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
b' : β a
⊢ { fst := a, snd := b' } :: map (Sigma.mk a) (lookupAll a l) <+ { fst := a, snd := b' } :: l

tactic: simp only [ne_eq, h, not_false_iff, lookupAll_cons_ne]
state_before: case neg
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b' : β a'
l : List (Sigma β)
h : ¬a = a'
⊢ map (Sigma.mk a) (lookupAll a ({ fst := a', snd := b' } :: l)) <+ { fst := a', snd := b' } :: l

tactic: exact (lookupAll_sublist a l).cons _
state_before: case neg
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b' : β a'
l : List (Sigma β)
h : ¬a = a'
⊢ map (Sigma.mk a) (lookupAll a l) <+ { fst := a', snd := b' } :: l
Theorem: Units.sub_divp
File: Mathlib/Algebra/Ring/Units.lean

tactic: simp only [divp, sub_mul, Units.mul_inv_cancel_right]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : Ring α
a✝ b✝ a b : α
u : αˣ
⊢ a - b /ₚ u = (a * ↑u - b) /ₚ u
Theorem: Matrix.transpose_zpow
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

tactic: rw [zpow_ofNat, zpow_ofNat, transpose_pow]
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
n : ℕ
⊢ (A ^ ↑n)ᵀ = Aᵀ ^ ↑n

tactic: rw [zpow_negSucc, zpow_negSucc, transpose_nonsing_inv, transpose_pow]
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
n : ℕ
⊢ (A ^ -[n+1])ᵀ = Aᵀ ^ -[n+1]
Theorem: nhds_basis_opens'
File: Mathlib/Topology/Basic.lean

tactic: convert nhds_basis_opens a using 2
state_before: α : Type u
β : Type v
ι : Sort w
a✝ : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
a : α
⊢ HasBasis (𝓝 a) (fun s => s ∈ 𝓝 a ∧ IsOpen s) fun x => x

tactic: exact and_congr_left_iff.2 IsOpen.mem_nhds_iff
state_before: case h.e'_4.h.a
α : Type u
β : Type v
ι : Sort w
a✝ : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
a : α
x✝ : Set α
⊢ x✝ ∈ 𝓝 a ∧ IsOpen x✝ ↔ a ∈ x✝ ∧ IsOpen x✝
Theorem: PGame.star_fuzzy_zero
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [lf_zero]
state_before: ⊢ star ⧏ 0

tactic: use default
state_before: ⊢ ∃ j, ∀ (i : LeftMoves (moveRight star j)), moveLeft (moveRight star j) i ⧏ 0

tactic: rintro ⟨⟩
state_before: ⊢ ∀ (i : LeftMoves (moveRight star default)), moveLeft (moveRight star default) i ⧏ 0

tactic: rw [zero_lf]
state_before: ⊢ 0 ⧏ star

tactic: use default
state_before: ⊢ ∃ i, ∀ (j : RightMoves (moveLeft star i)), 0 ⧏ moveRight (moveLeft star i) j

tactic: rintro ⟨⟩
state_before: ⊢ ∀ (j : RightMoves (moveLeft star default)), 0 ⧏ moveRight (moveLeft star default) j
Theorem: Asymptotics.isBigO_const_const_iff
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: rcases eq_or_ne c' 0 with (rfl | hc')
state_before: α : Type u_1
β : Type ?u.276396
E : Type ?u.276399
F : Type ?u.276402
G : Type ?u.276405
E' : Type ?u.276408
F' : Type ?u.276411
G' : Type ?u.276414
E'' : Type u_2
F'' : Type u_3
G'' : Type ?u.276423
R : Type ?u.276426
R' : Type ?u.276429
𝕜 : Type ?u.276432
𝕜' : Type ?u.276435
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 α
c : E''
c' : F''
l : Filter α
inst✝ : NeBot l
⊢ ((fun _x => c) =O[l] fun _x => c') ↔ c' = 0 → c = 0

tactic: simp [EventuallyEq]
state_before: case inl
α : Type u_1
β : Type ?u.276396
E : Type ?u.276399
F : Type ?u.276402
G : Type ?u.276405
E' : Type ?u.276408
F' : Type ?u.276411
G' : Type ?u.276414
E'' : Type u_2
F'' : Type u_3
G'' : Type ?u.276423
R : Type ?u.276426
R' : Type ?u.276429
𝕜 : Type ?u.276432
𝕜' : Type ?u.276435
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 α
c : E''
l : Filter α
inst✝ : NeBot l
⊢ ((fun _x => c) =O[l] fun _x => 0) ↔ 0 = 0 → c = 0

tactic: simp [hc', isBigO_const_const _ hc']
state_before: case inr
α : Type u_1
β : Type ?u.276396
E : Type ?u.276399
F : Type ?u.276402
G : Type ?u.276405
E' : Type ?u.276408
F' : Type ?u.276411
G' : Type ?u.276414
E'' : Type u_2
F'' : Type u_3
G'' : Type ?u.276423
R : Type ?u.276426
R' : Type ?u.276429
𝕜 : Type ?u.276432
𝕜' : Type ?u.276435
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 α
c : E''
c' : F''
l : Filter α
inst✝ : NeBot l
hc' : c' ≠ 0
⊢ ((fun _x => c) =O[l] fun _x => c') ↔ c' = 0 → c = 0
Theorem: Traversable.foldl_toList
File: Mathlib/Control/Fold.lean

tactic: rw [← FreeMonoid.toList_ofList (toList xs), ← foldl.unop_ofFreeMonoid]
state_before: α β γ : Type u
t : Type u → Type u
inst✝¹ : Traversable t
inst✝ : IsLawfulTraversable t
f : α → β → α
xs : t β
x : α
⊢ foldl f x xs = List.foldl f x (toList xs)

tactic: simp only [foldl, toList_spec, foldMap_hom_free, foldl.ofFreeMonoid_comp_of, Foldl.get,
  FreeMonoid.ofList_toList]
state_before: α β γ : Type u
t : Type u → Type u
inst✝¹ : Traversable t
inst✝ : IsLawfulTraversable t
f : α → β → α
xs : t β
x : α
⊢ foldl f x xs = unop (↑(Foldl.ofFreeMonoid f) (↑FreeMonoid.ofList (toList xs))) x
Theorem: MeasureTheory.SimpleFunc.integrable_approxOn
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

tactic: rw [← memℒp_one_iff_integrable] at hf hi₀⊢
state_before: α : Type ?u.939616
β : Type u_2
ι : Type ?u.939622
E : Type u_1
F : Type ?u.939628
𝕜 : Type ?u.939631
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace E
inst✝² : NormedAddCommGroup E
inst✝¹ : BorelSpace E
f : β → E
μ : Measure β
fmeas : Measurable f
hf : Integrable f
s : Set E
y₀ : E
h₀ : y₀ ∈ s
inst✝ : SeparableSpace ↑s
hi₀ : Integrable fun x => y₀
n : ℕ
⊢ Integrable ↑(approxOn f fmeas s y₀ h₀ n)

tactic: exact memℒp_approxOn fmeas hf h₀ hi₀ n
state_before: α : Type ?u.939616
β : Type u_2
ι : Type ?u.939622
E : Type u_1
F : Type ?u.939628
𝕜 : Type ?u.939631
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace E
inst✝² : NormedAddCommGroup E
inst✝¹ : BorelSpace E
f : β → E
μ : Measure β
fmeas : Measurable f
hf : Memℒp f 1
s : Set E
y₀ : E
h₀ : y₀ ∈ s
inst✝ : SeparableSpace ↑s
hi₀ : Memℒp (fun x => y₀) 1
n : ℕ
⊢ Memℒp (↑(approxOn f fmeas s y₀ h₀ n)) 1
Theorem: ENNReal.continuousOn_sub_left
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: rw [show (fun x => a - x) = (fun p : ℝ≥0∞ × ℝ≥0∞ => p.fst - p.snd) ∘ fun x => ⟨a, x⟩ by rfl]
state_before: α : Type ?u.110099
β : Type ?u.110102
γ : Type ?u.110105
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
a : ℝ≥0∞
⊢ ContinuousOn (fun x => a - x) {x | x ≠ ⊤}

tactic: apply ContinuousOn.comp continuousOn_sub (Continuous.continuousOn (Continuous.Prod.mk a))
state_before: α : Type ?u.110099
β : Type ?u.110102
γ : Type ?u.110105
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
a : ℝ≥0∞
⊢ ContinuousOn ((fun p => p.fst - p.snd) ∘ fun x => (a, x)) {x | x ≠ ⊤}

tactic: rintro _ h (_ | _)
state_before: α : Type ?u.110099
β : Type ?u.110102
γ : Type ?u.110105
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
a : ℝ≥0∞
⊢ MapsTo (fun b => (a, b)) {x | x ≠ ⊤} {p | p ≠ (⊤, ⊤)}

tactic: exact h none_eq_top
state_before: case refl
α : Type ?u.110099
β : Type ?u.110102
γ : Type ?u.110105
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
h : ⊤ ∈ {x | x ≠ ⊤}
⊢ False

tactic: rfl
state_before: α : Type ?u.110099
β : Type ?u.110102
γ : Type ?u.110105
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
a : ℝ≥0∞
⊢ (fun x => a - x) = (fun p => p.fst - p.snd) ∘ fun x => (a, x)
Theorem: not_dvd_index_sylow
File: Mathlib/GroupTheory/Sylow.lean

tactic: cases nonempty_fintype (Sylow p G)
state_before: p : ℕ
G : Type u_1
inst✝¹ : Group G
hp : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
hP : relindex (↑P) (normalizer ↑P) ≠ 0
⊢ ¬p ∣ index ↑P

tactic: rw [← relindex_mul_index le_normalizer, ← card_sylow_eq_index_normalizer]
state_before: case intro
p : ℕ
G : Type u_1
inst✝¹ : Group G
hp : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
hP : relindex (↑P) (normalizer ↑P) ≠ 0
val✝ : Fintype (Sylow p G)
⊢ ¬p ∣ index ↑P

tactic: haveI : (P.subtype le_normalizer : Subgroup (P : Subgroup G).normalizer).Normal :=
  Subgroup.normal_in_normalizer
state_before: case intro
p : ℕ
G : Type u_1
inst✝¹ : Group G
hp : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
hP : relindex (↑P) (normalizer ↑P) ≠ 0
val✝ : Fintype (Sylow p G)
⊢ ¬p ∣ relindex (↑P) (normalizer ↑P) * card (Sylow p G)

tactic: haveI : FiniteIndex ↑(P.subtype le_normalizer : Subgroup (P : Subgroup G).normalizer) := ⟨hP⟩
state_before: case intro
p : ℕ
G : Type u_1
inst✝¹ : Group G
hp : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
hP : relindex (↑P) (normalizer ↑P) ≠ 0
val✝ : Fintype (Sylow p G)
this : Normal ↑(Sylow.subtype P (_ : ↑P ≤ normalizer ↑P))
⊢ ¬p ∣ relindex (↑P) (normalizer ↑P) * card (Sylow p G)

tactic: replace hP := not_dvd_index_sylow' (P.subtype le_normalizer)
state_before: case intro
p : ℕ
G : Type u_1
inst✝¹ : Group G
hp : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
hP : relindex (↑P) (normalizer ↑P) ≠ 0
val✝ : Fintype (Sylow p G)
this✝ : Normal ↑(Sylow.subtype P (_ : ↑P ≤ normalizer ↑P))
this : FiniteIndex ↑(Sylow.subtype P (_ : ↑P ≤ normalizer ↑P))
⊢ ¬p ∣ relindex (↑P) (normalizer ↑P) * card (Sylow p G)

tactic: exact hp.1.not_dvd_mul hP (not_dvd_card_sylow p G)
state_before: case intro
p : ℕ
G : Type u_1
inst✝¹ : Group G
hp : Fact (Nat.Prime p)
inst✝ : Finite (Sylow p G)
P : Sylow p G
val✝ : Fintype (Sylow p G)
this✝ : Normal ↑(Sylow.subtype P (_ : ↑P ≤ normalizer ↑P))
this : FiniteIndex ↑(Sylow.subtype P (_ : ↑P ≤ normalizer ↑P))
hP : ¬p ∣ index ↑(Sylow.subtype P (_ : ↑P ≤ normalizer ↑P))
⊢ ¬p ∣ relindex (↑P) (normalizer ↑P) * card (Sylow p G)
Theorem: LowerSet.mem_map
File: Mathlib/Order/UpperLower/Basic.lean

tactic: rw [← f.symm_symm, ← symm_map, f.symm_symm]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.105727
ι : Sort ?u.105730
κ : ι → Sort ?u.105735
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f✝ : α ≃o β
s t : LowerSet α
a : α
b✝ : β
f : α ≃o β
b : β
⊢ b ∈ ↑(map f) s ↔ ↑(OrderIso.symm f) b ∈ s

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.105727
ι : Sort ?u.105730
κ : ι → Sort ?u.105735
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f✝ : α ≃o β
s t : LowerSet α
a : α
b✝ : β
f : α ≃o β
b : β
⊢ b ∈ ↑(OrderIso.symm (map (OrderIso.symm f))) s ↔ ↑(OrderIso.symm f) b ∈ s
Theorem: sSup_image2
File: Mathlib/Order/CompleteLattice.lean

tactic: rw [← image_prod, sSup_image, biSup_prod]
state_before: α : Type u_3
β : Type u_1
β₂ : Type ?u.175570
γ : Type u_2
ι : Sort ?u.175576
ι' : Sort ?u.175579
κ : ι → Sort ?u.175584
κ' : ι' → Sort ?u.175589
inst✝ : CompleteLattice α
f✝ g s✝ t✝ : ι → α
a b : α
f : β → γ → α
s : Set β
t : Set γ
⊢ sSup (image2 f s t) = ⨆ (a : β) (_ : a ∈ s) (b : γ) (_ : b ∈ t), f a b
Theorem: MvPolynomial.expand_one_apply
File: Mathlib/Data/MvPolynomial/Expand.lean

tactic: simp only [expand, pow_one, eval₂Hom_eq_bind₂, bind₂_C_left, RingHom.toMonoidHom_eq_coe,
  RingHom.coe_monoidHom_id, AlgHom.coe_mk, RingHom.coe_mk, MonoidHom.id_apply]
state_before: σ : Type u_1
τ : Type ?u.111976
R : Type u_2
S : Type ?u.111982
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : MvPolynomial σ R
⊢ ↑(expand 1) f = f
Theorem: Finset.eq_of_mem_uIcc_of_mem_uIcc
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: simp_rw [mem_uIcc]
state_before: ι : Type ?u.190771
α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ a ∈ [[b, c]] → b ∈ [[a, c]] → a = b

tactic: exact Set.eq_of_mem_uIcc_of_mem_uIcc
state_before: ι : Type ?u.190771
α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ b ⊓ c ≤ a ∧ a ≤ b ⊔ c → a ⊓ c ≤ b ∧ b ≤ a ⊔ c → a = b
Theorem: List.norm_prod_le
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.113892
γ : Type ?u.113895
ι : Type ?u.113898
inst✝¹ : SeminormedRing α
inst✝ : NormOneClass α
⊢ ‖prod []‖ ≤ prod (map norm [])
Theorem: div_eq_div_mul_div
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp [mul_left_comm c]
state_before: α : Type ?u.69162
β : Type ?u.69165
G : Type u_1
inst✝ : CommGroup G
a✝ b✝ c✝ d a b c : G
⊢ a / b = c / b * (a / c)
Theorem: QuaternionAlgebra.Basis.lift_one
File: Mathlib/Algebra/QuaternionBasis.lean

tactic: simp [lift]
state_before: R : Type u_2
A : Type u_1
B : Type ?u.70086
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
c₁ c₂ : R
q : Basis A c₁ c₂
⊢ lift q 1 = 1
Theorem: MeasureTheory.lintegral_coe_le_coe_iff_integral_le
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: rw [lintegral_coe_eq_integral f hfi, ENNReal.ofReal, ENNReal.coe_le_coe,
  Real.toNNReal_le_iff_le_coe]
state_before: α : Type u_1
E : Type ?u.1088155
F : Type ?u.1088158
𝕜 : Type ?u.1088161
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace ℝ E
inst✝⁸ : CompleteSpace E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : SMulCommClass ℝ 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
X : Type ?u.1090852
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
f : α → ℝ≥0
hfi : Integrable fun x => ↑(f x)
b : ℝ≥0
⊢ (∫⁻ (a : α), ↑(f a) ∂μ) ≤ ↑b ↔ (∫ (a : α), ↑(f a) ∂μ) ≤ ↑b
Theorem: FiberBundleCore.mem_source_at
File: Mathlib/Topology/FiberBundle/Basic.lean

tactic: rw [localTrivAt, mem_localTriv_source]
state_before: ι : Type u_3
B : Type u_1
F : Type u_2
X : Type ?u.46750
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
Z : FiberBundleCore ι B F
i : ι
b : B
a : F
⊢ { fst := b, snd := a } ∈ (localTrivAt Z b).toLocalHomeomorph.toLocalEquiv.source

tactic: exact Z.mem_baseSet_at b
state_before: ι : Type u_3
B : Type u_1
F : Type u_2
X : Type ?u.46750
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
Z : FiberBundleCore ι B F
i : ι
b : B
a : F
⊢ { fst := b, snd := a }.fst ∈ (localTriv Z (indexAt Z b)).baseSet
Theorem: Polynomial.leadingCoeff_pow'
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: simp
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.681610
⊢ leadingCoeff p ^ Nat.zero ≠ 0 → leadingCoeff (p ^ Nat.zero) = leadingCoeff p ^ Nat.zero

tactic: have h₁ : leadingCoeff p ^ n ≠ 0 := fun h₁ => h <| by rw [pow_succ, h₁, mul_zero]
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.681610
n : ℕ
ih : leadingCoeff p ^ n ≠ 0 → leadingCoeff (p ^ n) = leadingCoeff p ^ n
h : leadingCoeff p ^ Nat.succ n ≠ 0
⊢ leadingCoeff (p ^ Nat.succ n) = leadingCoeff p ^ Nat.succ n

tactic: have h₂ : leadingCoeff p * leadingCoeff (p ^ n) ≠ 0 := by rwa [pow_succ, ← ih h₁] at h
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.681610
n : ℕ
ih : leadingCoeff p ^ n ≠ 0 → leadingCoeff (p ^ n) = leadingCoeff p ^ n
h : leadingCoeff p ^ Nat.succ n ≠ 0
h₁ : leadingCoeff p ^ n ≠ 0
⊢ leadingCoeff (p ^ Nat.succ n) = leadingCoeff p ^ Nat.succ n

tactic: rw [pow_succ, pow_succ, leadingCoeff_mul' h₂, ih h₁]
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.681610
n : ℕ
ih : leadingCoeff p ^ n ≠ 0 → leadingCoeff (p ^ n) = leadingCoeff p ^ n
h : leadingCoeff p ^ Nat.succ n ≠ 0
h₁ : leadingCoeff p ^ n ≠ 0
h₂ : leadingCoeff p * leadingCoeff (p ^ n) ≠ 0
⊢ leadingCoeff (p ^ Nat.succ n) = leadingCoeff p ^ Nat.succ n

tactic: rw [pow_succ, h₁, mul_zero]
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.681610
n : ℕ
ih : leadingCoeff p ^ n ≠ 0 → leadingCoeff (p ^ n) = leadingCoeff p ^ n
h : leadingCoeff p ^ Nat.succ n ≠ 0
h₁ : leadingCoeff p ^ n = 0
⊢ leadingCoeff p ^ Nat.succ n = 0

tactic: rwa [pow_succ, ← ih h₁] at h
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.681610
n : ℕ
ih : leadingCoeff p ^ n ≠ 0 → leadingCoeff (p ^ n) = leadingCoeff p ^ n
h : leadingCoeff p ^ Nat.succ n ≠ 0
h₁ : leadingCoeff p ^ n ≠ 0
⊢ leadingCoeff p * leadingCoeff (p ^ n) ≠ 0
Theorem: dvd_abs
File: Mathlib/Algebra/Order/Ring/Abs.lean

tactic: cases' abs_choice b with h h <;> simp only [h, dvd_neg]
state_before: α : Type u_1
inst✝¹ : Ring α
inst✝ : LinearOrder α
a✝ b✝ a b : α
⊢ a ∣ abs b ↔ a ∣ b
Theorem: NormedAddGroupHom.incl_range
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: ext x
state_before: V : Type ?u.489284
W : Type ?u.489287
V₁ : Type u_1
V₂ : Type ?u.489293
V₃ : Type ?u.489296
inst✝⁴ : SeminormedAddCommGroup V
inst✝³ : SeminormedAddCommGroup W
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V₁ V₂
g : NormedAddGroupHom V₂ V₃
s : AddSubgroup V₁
⊢ range (incl s) = s

tactic: exact ⟨fun ⟨y, hy⟩ => by rw [← hy]; simp, fun hx => ⟨⟨x, hx⟩, by simp⟩⟩
state_before: case h
V : Type ?u.489284
W : Type ?u.489287
V₁ : Type u_1
V₂ : Type ?u.489293
V₃ : Type ?u.489296
inst✝⁴ : SeminormedAddCommGroup V
inst✝³ : SeminormedAddCommGroup W
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V₁ V₂
g : NormedAddGroupHom V₂ V₃
s : AddSubgroup V₁
x : V₁
⊢ x ∈ range (incl s) ↔ x ∈ s

tactic: rw [← hy]
state_before: V : Type ?u.489284
W : Type ?u.489287
V₁ : Type u_1
V₂ : Type ?u.489293
V₃ : Type ?u.489296
inst✝⁴ : SeminormedAddCommGroup V
inst✝³ : SeminormedAddCommGroup W
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V₁ V₂
g : NormedAddGroupHom V₂ V₃
s : AddSubgroup V₁
x : V₁
x✝ : x ∈ range (incl s)
y : { x // x ∈ s }
hy : ↑(toAddMonoidHom (incl s)) y = x
⊢ x ∈ s

tactic: simp
state_before: V : Type ?u.489284
W : Type ?u.489287
V₁ : Type u_1
V₂ : Type ?u.489293
V₃ : Type ?u.489296
inst✝⁴ : SeminormedAddCommGroup V
inst✝³ : SeminormedAddCommGroup W
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V₁ V₂
g : NormedAddGroupHom V₂ V₃
s : AddSubgroup V₁
x : V₁
x✝ : x ∈ range (incl s)
y : { x // x ∈ s }
hy : ↑(toAddMonoidHom (incl s)) y = x
⊢ ↑(toAddMonoidHom (incl s)) y ∈ s

tactic: simp
state_before: V : Type ?u.489284
W : Type ?u.489287
V₁ : Type u_1
V₂ : Type ?u.489293
V₃ : Type ?u.489296
inst✝⁴ : SeminormedAddCommGroup V
inst✝³ : SeminormedAddCommGroup W
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V₁ V₂
g : NormedAddGroupHom V₂ V₃
s : AddSubgroup V₁
x : V₁
hx : x ∈ s
⊢ ↑(toAddMonoidHom (incl s)) { val := x, property := hx } = x
Theorem: NNReal.lintegral_mul_le_Lp_mul_Lq
File: Mathlib/MeasureTheory/Integral/MeanInequalities.lean

tactic: simp_rw [Pi.mul_apply, ENNReal.coe_mul]
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
p q : ℝ
hpq : Real.IsConjugateExponent p q
f g : α → ℝ≥0
hf : AEMeasurable f
hg : AEMeasurable g
⊢ (∫⁻ (a : α), ↑((f * g) a) ∂μ) ≤ (∫⁻ (a : α), ↑(f a) ^ p ∂μ) ^ (1 / p) * (∫⁻ (a : α), ↑(g a) ^ q ∂μ) ^ (1 / q)

tactic: exact ENNReal.lintegral_mul_le_Lp_mul_Lq μ hpq hf.coe_nnreal_ennreal hg.coe_nnreal_ennreal
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
p q : ℝ
hpq : Real.IsConjugateExponent p q
f g : α → ℝ≥0
hf : AEMeasurable f
hg : AEMeasurable g
⊢ (∫⁻ (a : α), ↑(f a) * ↑(g a) ∂μ) ≤ (∫⁻ (a : α), ↑(f a) ^ p ∂μ) ^ (1 / p) * (∫⁻ (a : α), ↑(g a) ^ q ∂μ) ^ (1 / q)
Theorem: Real.tan_pi_div_four
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [tan_eq_sin_div_cos, cos_pi_div_four, sin_pi_div_four]
state_before: ⊢ tan (π / 4) = 1

tactic: have h : sqrt 2 / 2 > 0 := by cancel_denoms
state_before: ⊢ sqrt 2 / 2 / (sqrt 2 / 2) = 1

tactic: exact div_self (ne_of_gt h)
state_before: h : sqrt 2 / 2 > 0
⊢ sqrt 2 / 2 / (sqrt 2 / 2) = 1

tactic: cancel_denoms
state_before: ⊢ sqrt 2 / 2 > 0
Theorem: List.reduceOption_get?_iff
File: Mathlib/Data/List/Basic.lean

tactic: rw [← mem_iff_get?, ← mem_iff_get?, reduceOption_mem_iff]
state_before: ι : Type ?u.369711
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
l : List (Option α)
x : α
⊢ (∃ i, get? l i = some (some x)) ↔ ∃ i, get? (reduceOption l) i = some x