tasksource/leandojo huggingface dataset:
Theorem: Complex.IsExpCmpFilter.of_isBigO_im_re_pow
File: Mathlib/Analysis/SpecialFunctions/CompareExp.lean

tactic: norm_cast at hr
state_before: l : Filter ℂ
hre : Tendsto re l atTop
n : ℕ
hr : im =O[l] fun z => z.re ^ ↑n
⊢ im =O[l] fun z => z.re ^ ↑n

tactic: simpa only [Real.rpow_nat_cast]
state_before: l : Filter ℂ
hre : Tendsto re l atTop
n : ℕ
hr : im =O[l] fun z => z.re ^ n
⊢ im =O[l] fun z => z.re ^ ↑n
Theorem: Filter.comap_snd_neBot_iff
File: Mathlib/Order/Filter/Basic.lean

tactic: cases' isEmpty_or_nonempty α with hα hα
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.268461
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
⊢ NeBot (comap Prod.snd f) ↔ Nonempty α ∧ NeBot f

tactic: rw [filter_eq_bot_of_isEmpty (f.comap _), ← not_iff_not]
state_before: case inl
α : Type u
β : Type v
γ : Type w
δ : Type ?u.268461
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
hα : IsEmpty α
⊢ NeBot (comap Prod.snd f) ↔ Nonempty α ∧ NeBot f

tactic: simp
state_before: case inl
α : Type u
β : Type v
γ : Type w
δ : Type ?u.268461
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
hα : IsEmpty α
⊢ ¬NeBot ⊥ ↔ ¬(Nonempty α ∧ NeBot f)

tactic: simp [comap_neBot_iff_frequently, hα]
state_before: case inr
α : Type u
β : Type v
γ : Type w
δ : Type ?u.268461
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
hα : Nonempty α
⊢ NeBot (comap Prod.snd f) ↔ Nonempty α ∧ NeBot f
Theorem: List.ofFn_fin_append
File: Mathlib/Data/List/OfFn.lean

tactic: simp_rw [ofFn_add, Fin.append_left, Fin.append_right]
state_before: α : Type u
m n : ℕ
a : Fin m → α
b : Fin n → α
⊢ ofFn (Fin.append a b) = ofFn a ++ ofFn b
Theorem: Multiset.foldr_induction'
File: Mathlib/Data/Multiset/Basic.lean

tactic: revert s
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.132443
f : α → β → β
H : LeftCommutative f
x : β
q : α → Prop
p : β → Prop
s : Multiset α
hpqf : ∀ (a : α) (b : β), q a → p b → p (f a b)
px : p x
q_s : ∀ (a : α), a ∈ s → q a
⊢ p (foldr f H x s)

tactic: refine' Multiset.induction (by simp [px]) _
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.132443
f : α → β → β
H : LeftCommutative f
x : β
q : α → Prop
p : β → Prop
hpqf : ∀ (a : α) (b : β), q a → p b → p (f a b)
px : p x
⊢ ∀ (s : Multiset α), (∀ (a : α), a ∈ s → q a) → p (foldr f H x s)

tactic: intro a s hs hsa
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.132443
f : α → β → β
H : LeftCommutative f
x : β
q : α → Prop
p : β → Prop
hpqf : ∀ (a : α) (b : β), q a → p b → p (f a b)
px : p x
⊢ ∀ ⦃a : α⦄ {s : Multiset α},
    ((∀ (a : α), a ∈ s → q a) → p (foldr f H x s)) → (∀ (a_2 : α), a_2 ∈ a ::ₘ s → q a_2) → p (foldr f H x (a ::ₘ s))

tactic: rw [foldr_cons]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.132443
f : α → β → β
H : LeftCommutative f
x : β
q : α → Prop
p : β → Prop
hpqf : ∀ (a : α) (b : β), q a → p b → p (f a b)
px : p x
a : α
s : Multiset α
hs : (∀ (a : α), a ∈ s → q a) → p (foldr f H x s)
hsa : ∀ (a_1 : α), a_1 ∈ a ::ₘ s → q a_1
⊢ p (foldr f H x (a ::ₘ s))

tactic: have hps : ∀ x : α, x ∈ s → q x := fun x hxs => hsa x (mem_cons_of_mem hxs)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.132443
f : α → β → β
H : LeftCommutative f
x : β
q : α → Prop
p : β → Prop
hpqf : ∀ (a : α) (b : β), q a → p b → p (f a b)
px : p x
a : α
s : Multiset α
hs : (∀ (a : α), a ∈ s → q a) → p (foldr f H x s)
hsa : ∀ (a_1 : α), a_1 ∈ a ::ₘ s → q a_1
⊢ p (f a (foldr f H x s))

tactic: exact hpqf a (foldr f H x s) (hsa a (mem_cons_self a s)) (hs hps)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.132443
f : α → β → β
H : LeftCommutative f
x : β
q : α → Prop
p : β → Prop
hpqf : ∀ (a : α) (b : β), q a → p b → p (f a b)
px : p x
a : α
s : Multiset α
hs : (∀ (a : α), a ∈ s → q a) → p (foldr f H x s)
hsa : ∀ (a_1 : α), a_1 ∈ a ::ₘ s → q a_1
hps : ∀ (x : α), x ∈ s → q x
⊢ p (f a (foldr f H x s))

tactic: simp [px]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.132443
f : α → β → β
H : LeftCommutative f
x : β
q : α → Prop
p : β → Prop
hpqf : ∀ (a : α) (b : β), q a → p b → p (f a b)
px : p x
⊢ (∀ (a : α), a ∈ 0 → q a) → p (foldr f H x 0)
Theorem: not_fermat_42
File: Mathlib/NumberTheory/Fermat4.lean

tactic: intro h
state_before: a b c : ℤ
ha : a ≠ 0
hb : b ≠ 0
⊢ a ^ 4 + b ^ 4 ≠ c ^ 2

tactic: obtain ⟨a0, b0, c0, ⟨hf, h2, hp⟩⟩ :=
  Fermat42.exists_pos_odd_minimal (And.intro ha (And.intro hb h))
state_before: a b c : ℤ
ha : a ≠ 0
hb : b ≠ 0
h : a ^ 4 + b ^ 4 = c ^ 2
⊢ False

tactic: apply Fermat42.not_minimal hf h2 hp
state_before: case intro.intro.intro.intro.intro
a b c : ℤ
ha : a ≠ 0
hb : b ≠ 0
h : a ^ 4 + b ^ 4 = c ^ 2
a0 b0 c0 : ℤ
hf : Fermat42.Minimal a0 b0 c0
h2 : a0 % 2 = 1
hp : 0 < c0
⊢ False
Theorem: Finset.coe_map
File: Mathlib/Data/Finset/Image.lean

tactic: simp only [mem_coe, mem_map, Set.mem_image, implies_true]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.9518
f✝ : α ↪ β
s✝ : Finset α
f : α ↪ β
s : Finset α
⊢ ∀ (x : β), x ∈ ↑(map f s) ↔ x ∈ ↑f '' ↑s
Theorem: RightDerivMeasurableAux.b_mem_nhdsWithin_Ioi
File: Mathlib/Analysis/Calculus/FDerivMeasurable.lean

tactic: obtain ⟨L, LK, hL₁, hL₂⟩ : ∃ L : F, L ∈ K ∧ x ∈ A f L r ε ∧ x ∈ A f L s ε := by
  simpa only [B, mem_iUnion, mem_inter_iff, exists_prop] using hx
state_before: F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K✝ K : Set F
r s ε x : ℝ
hx : x ∈ B f K r s ε
⊢ B f K r s ε ∈ 𝓝[Ioi x] x

tactic: filter_upwards [a_mem_nhdsWithin_Ioi hL₁, a_mem_nhdsWithin_Ioi hL₂]with y hy₁ hy₂
state_before: case intro.intro.intro
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K✝ K : Set F
r s ε x : ℝ
hx : x ∈ B f K r s ε
L : F
LK : L ∈ K
hL₁ : x ∈ A f L r ε
hL₂ : x ∈ A f L s ε
⊢ B f K r s ε ∈ 𝓝[Ioi x] x

tactic: simp only [B, mem_iUnion, mem_inter_iff, exists_prop]
state_before: case h
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K✝ K : Set F
r s ε x : ℝ
hx : x ∈ B f K r s ε
L : F
LK : L ∈ K
hL₁ : x ∈ A f L r ε
hL₂ : x ∈ A f L s ε
y : ℝ
hy₁ : y ∈ A f L r ε
hy₂ : y ∈ A f L s ε
⊢ y ∈ B f K r s ε

tactic: exact ⟨L, LK, hy₁, hy₂⟩
state_before: case h
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K✝ K : Set F
r s ε x : ℝ
hx : x ∈ B f K r s ε
L : F
LK : L ∈ K
hL₁ : x ∈ A f L r ε
hL₂ : x ∈ A f L s ε
y : ℝ
hy₁ : y ∈ A f L r ε
hy₂ : y ∈ A f L s ε
⊢ ∃ i, i ∈ K ∧ y ∈ A f i r ε ∧ y ∈ A f i s ε

tactic: simpa only [B, mem_iUnion, mem_inter_iff, exists_prop] using hx
state_before: F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K✝ K : Set F
r s ε x : ℝ
hx : x ∈ B f K r s ε
⊢ ∃ L, L ∈ K ∧ x ∈ A f L r ε ∧ x ∈ A f L s ε
Theorem: LocalHomeomorph.extend_source
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: rw [extend, LocalEquiv.trans_source, I.source_eq, preimage_univ, inter_univ]
state_before: 𝕜 : Type u_3
E : Type u_2
M : Type u_1
H : Type u_4
E' : Type ?u.128317
M' : Type ?u.128320
H' : Type ?u.128323
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x : M
s t : Set M
⊢ (extend f I).source = f.source
Theorem: Nat.multiplicity_eq_card_pow_dvd
File: Mathlib/Data/Nat/Multiplicity.lean

tactic: simp
state_before: m n b : ℕ
hm : m ≠ 1
hn : 0 < n
hb : log m n < b
⊢ multiplicity m n = ↑(card (Ico 1 (Part.get (multiplicity m n) (_ : multiplicity.Finite m n) + 1)))

tactic: rw [mem_filter, mem_Ico, mem_Ico, lt_succ_iff, ← @PartENat.coe_le_coe i,
  PartENat.natCast_get, ← pow_dvd_iff_le_multiplicity, and_right_comm]
state_before: m n b : ℕ
hm : m ≠ 1
hn : 0 < n
hb : log m n < b
i : ℕ
⊢ i ∈ Ico 1 (Part.get (multiplicity m n) (_ : multiplicity.Finite m n) + 1) ↔ i ∈ filter (fun i => m ^ i ∣ n) (Ico 1 b)

tactic: refine' (and_iff_left_of_imp fun h => lt_of_le_of_lt _ hb).symm
state_before: m n b : ℕ
hm : m ≠ 1
hn : 0 < n
hb : log m n < b
i : ℕ
⊢ 1 ≤ i ∧ m ^ i ∣ n ↔ (1 ≤ i ∧ m ^ i ∣ n) ∧ i < b

tactic: cases' m with m
state_before: m n b : ℕ
hm : m ≠ 1
hn : 0 < n
hb : log m n < b
i : ℕ
h : 1 ≤ i ∧ m ^ i ∣ n
⊢ i ≤ log m n

tactic: exact le_log_of_pow_le (one_lt_iff_ne_zero_and_ne_one.2 ⟨m.succ_ne_zero, hm⟩)
    (le_of_dvd hn h.2)
state_before: case succ
n b : ℕ
hn : 0 < n
i m : ℕ
hm : succ m ≠ 1
hb : log (succ m) n < b
h : 1 ≤ i ∧ succ m ^ i ∣ n
⊢ i ≤ log (succ m) n

tactic: rw [zero_eq, zero_pow, zero_dvd_iff] at h
state_before: case zero
n b : ℕ
hn : 0 < n
i : ℕ
hm : zero ≠ 1
hb : log zero n < b
h : 1 ≤ i ∧ zero ^ i ∣ n
⊢ i ≤ log zero n

tactic: exacts [(hn.ne' h.2).elim, h.1]
state_before: case zero
n b : ℕ
hn : 0 < n
i : ℕ
hm : zero ≠ 1
hb : log zero n < b
h : 1 ≤ i ∧ n = 0
⊢ i ≤ log zero n

case zero
n b : ℕ
hn : 0 < n
i : ℕ
hm : zero ≠ 1
hb : log zero n < b
h : 1 ≤ i ∧ 0 ^ i ∣ n
⊢ 0 < i
Theorem: Set.mapsTo_image
File: Mathlib/Data/Set/Function.lean

tactic: rw [mapsTo']
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.22310
ι : Sort ?u.22313
π : α → Type ?u.22318
s✝ s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
f : α → β
s : Set α
⊢ MapsTo f s (f '' s)
Theorem: MeasureTheory.essSup_trim
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: simp_rw [essSup]
state_before: α : Type u_1
E : Type ?u.3171975
F : Type ?u.3171978
G : Type ?u.3171981
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hm : m ≤ m0
f : α → ℝ≥0∞
hf : Measurable f
⊢ essSup f (Measure.trim ν hm) = essSup f ν

tactic: exact limsup_trim hm hf
state_before: α : Type u_1
E : Type ?u.3171975
F : Type ?u.3171978
G : Type ?u.3171981
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hm : m ≤ m0
f : α → ℝ≥0∞
hf : Measurable f
⊢ limsup f (Measure.ae (Measure.trim ν hm)) = limsup f (Measure.ae ν)
Theorem: AddCommGroup.nsmul_add_modEq
File: Mathlib/Algebra/ModEq.lean

tactic: simp [← sub_sub]
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n✝ : ℕ
z : ℤ
n : ℕ
⊢ a - (n • p + a) = -↑n • p
Theorem: Matrix.col_mulVec
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.1216213
m : Type u_2
n : Type u_1
o : Type ?u.1216222
m' : o → Type ?u.1216227
n' : o → Type ?u.1216232
R : Type ?u.1216235
S : Type ?u.1216238
α : Type v
β : Type w
γ : Type ?u.1216245
inst✝¹ : Fintype n
inst✝ : NonUnitalNonAssocSemiring α
M : Matrix m n α
v : n → α
⊢ col (mulVec M v) = M ⬝ col v

tactic: rfl
state_before: case a.h
l : Type ?u.1216213
m : Type u_2
n : Type u_1
o : Type ?u.1216222
m' : o → Type ?u.1216227
n' : o → Type ?u.1216232
R : Type ?u.1216235
S : Type ?u.1216238
α : Type v
β : Type w
γ : Type ?u.1216245
inst✝¹ : Fintype n
inst✝ : NonUnitalNonAssocSemiring α
M : Matrix m n α
v : n → α
i✝ : m
x✝ : Unit
⊢ col (mulVec M v) i✝ x✝ = (M ⬝ col v) i✝ x✝
Theorem: Metric.Sigma.fst_eq_of_dist_lt_one
File: Mathlib/Topology/MetricSpace/Gluing.lean

tactic: cases x
state_before: ι : Type u_1
E : ι → Type u_2
inst✝ : (i : ι) → MetricSpace (E i)
x y : (i : ι) × E i
h : dist x y < 1
⊢ x.fst = y.fst

tactic: cases y
state_before: case mk
ι : Type u_1
E : ι → Type u_2
inst✝ : (i : ι) → MetricSpace (E i)
y : (i : ι) × E i
fst✝ : ι
snd✝ : E fst✝
h : dist { fst := fst✝, snd := snd✝ } y < 1
⊢ { fst := fst✝, snd := snd✝ }.fst = y.fst

tactic: contrapose! h
state_before: case mk.mk
ι : Type u_1
E : ι → Type u_2
inst✝ : (i : ι) → MetricSpace (E i)
fst✝¹ : ι
snd✝¹ : E fst✝¹
fst✝ : ι
snd✝ : E fst✝
h : dist { fst := fst✝¹, snd := snd✝¹ } { fst := fst✝, snd := snd✝ } < 1
⊢ { fst := fst✝¹, snd := snd✝¹ }.fst = { fst := fst✝, snd := snd✝ }.fst

tactic: apply one_le_dist_of_ne h
state_before: case mk.mk
ι : Type u_1
E : ι → Type u_2
inst✝ : (i : ι) → MetricSpace (E i)
fst✝¹ : ι
snd✝¹ : E fst✝¹
fst✝ : ι
snd✝ : E fst✝
h : fst✝¹ ≠ fst✝
⊢ 1 ≤ dist { fst := fst✝¹, snd := snd✝¹ } { fst := fst✝, snd := snd✝ }
Theorem: Complex.tanh_zero
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [tanh]
state_before: x y : ℂ
⊢ tanh 0 = 0
Theorem: Finset.Ioc_subset_Icc_self
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [← coe_subset, coe_Ioc, coe_Icc]
state_before: ι : Type ?u.24849
α : Type u_1
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ Ioc a b ⊆ Icc a b

tactic: exact Set.Ioc_subset_Icc_self
state_before: ι : Type ?u.24849
α : Type u_1
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ Set.Ioc a b ⊆ Set.Icc a b
Theorem: Array.getElem_ofFn
File: Std/Data/Array/Lemmas.lean

tactic: simp
state_before: n : Nat
α : Type u_1
f : Fin n → α
i : Nat
h : i < size (ofFn f)
⊢ 0 ≤ n

tactic: simp
state_before: n : Nat
α : Type u_1
f : Fin n → α
i : Nat
h : i < size (ofFn f)
⊢ 0 = size (mkEmpty n)
Theorem: ModularGroup.T_inv_mul_apply_one
File: Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean

tactic: simpa using T_pow_mul_apply_one (-1) g
state_before: g : SL(2, ℤ)
⊢ ↑(T⁻¹ * g) 1 = ↑g 1
Theorem: RatFunc.laurent_laurent
File: Mathlib/FieldTheory/Laurent.lean

tactic: induction f using RatFunc.induction_on
state_before: R : Type u
inst✝ : CommRing R
hdomain : IsDomain R
r s : R
p q : R[X]
f : RatFunc R
⊢ ↑(laurent r) (↑(laurent s) f) = ↑(laurent (r + s)) f

tactic: simp_rw [laurent_div, taylor_taylor]
state_before: case f
R : Type u
inst✝ : CommRing R
hdomain : IsDomain R
r s : R
p q : R[X]
f : RatFunc R
p✝ q✝ : R[X]
hq✝ : q✝ ≠ 0
⊢ ↑(laurent r) (↑(laurent s) (↑(algebraMap R[X] (RatFunc R)) p✝ / ↑(algebraMap R[X] (RatFunc R)) q✝)) =
    ↑(laurent (r + s)) (↑(algebraMap R[X] (RatFunc R)) p✝ / ↑(algebraMap R[X] (RatFunc R)) q✝)
Theorem: MeasureTheory.snorm_lt_top_iff_lintegral_rpow_nnnorm_lt_top
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: intro h
state_before: α : Type u_1
E : Type ?u.831489
F : Type u_2
G : Type ?u.831495
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
⊢ (∫⁻ (a : α), ↑‖f a‖₊ ^ ENNReal.toReal p ∂μ) < ⊤ → snorm f p μ < ⊤

tactic: have hp' := ENNReal.toReal_pos hp_ne_zero hp_ne_top
state_before: α : Type u_1
E : Type ?u.831489
F : Type u_2
G : Type ?u.831495
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
h : (∫⁻ (a : α), ↑‖f a‖₊ ^ ENNReal.toReal p ∂μ) < ⊤
⊢ snorm f p μ < ⊤

tactic: have : 0 < 1 / p.toReal := div_pos zero_lt_one hp'
state_before: α : Type u_1
E : Type ?u.831489
F : Type u_2
G : Type ?u.831495
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
h : (∫⁻ (a : α), ↑‖f a‖₊ ^ ENNReal.toReal p ∂μ) < ⊤
hp' : 0 < ENNReal.toReal p
⊢ snorm f p μ < ⊤

tactic: simpa [snorm_eq_lintegral_rpow_nnnorm hp_ne_zero hp_ne_top] using
  ENNReal.rpow_lt_top_of_nonneg (le_of_lt this) (ne_of_lt h)
state_before: α : Type u_1
E : Type ?u.831489
F : Type u_2
G : Type ?u.831495
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
h : (∫⁻ (a : α), ↑‖f a‖₊ ^ ENNReal.toReal p ∂μ) < ⊤
hp' : 0 < ENNReal.toReal p
this : 0 < 1 / ENNReal.toReal p
⊢ snorm f p μ < ⊤
Theorem: isOpen_sInter
File: Mathlib/Topology/Basic.lean

tactic: rw [sInter_empty]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set (Set α)
hs : Set.Finite s
x✝ : ∀ (t : Set α), t ∈ ∅ → IsOpen t
⊢ IsOpen (⋂₀ ∅)

tactic: exact isOpen_univ
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set (Set α)
hs : Set.Finite s
x✝ : ∀ (t : Set α), t ∈ ∅ → IsOpen t
⊢ IsOpen univ

tactic: simp only [sInter_insert, ball_insert_iff] at h ⊢
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝¹ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set (Set α)
hs : Set.Finite s
a✝ : Set α
s✝ : Set (Set α)
x✝¹ : ¬a✝ ∈ s✝
x✝ : Set.Finite s✝
ih : (∀ (t : Set α), t ∈ s✝ → IsOpen t) → IsOpen (⋂₀ s✝)
h : ∀ (t : Set α), t ∈ insert a✝ s✝ → IsOpen t
⊢ IsOpen (⋂₀ insert a✝ s✝)

tactic: exact h.1.inter (ih h.2)
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝¹ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set (Set α)
hs : Set.Finite s
a✝ : Set α
s✝ : Set (Set α)
x✝¹ : ¬a✝ ∈ s✝
x✝ : Set.Finite s✝
ih : (∀ (t : Set α), t ∈ s✝ → IsOpen t) → IsOpen (⋂₀ s✝)
h : IsOpen a✝ ∧ ∀ (x : Set α), x ∈ s✝ → IsOpen x
⊢ IsOpen (a✝ ∩ ⋂₀ s✝)
Theorem: Ico_subset_closure_interior
File: Mathlib/Topology/Order/Basic.lean

tactic: simpa only [dual_Ioc] using Ioc_subset_closure_interior (OrderDual.toDual b) (OrderDual.toDual a)
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
⊢ Ico a b ⊆ closure (interior (Ico a b))
Theorem: Submodule.coe_torsion_eq_annihilator_ne_bot
File: Mathlib/Algebra/Module/Torsion.lean

tactic: ext x
state_before: R : Type u_2
M : Type u_1
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : NoZeroDivisors R
inst✝ : Nontrivial R
⊢ ↑(torsion R M) = {x | annihilator (span R {x}) ≠ ⊥}

tactic: simp_rw [Submodule.ne_bot_iff, mem_annihilator, mem_span_singleton]
state_before: case h
R : Type u_2
M : Type u_1
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : NoZeroDivisors R
inst✝ : Nontrivial R
x : M
⊢ x ∈ ↑(torsion R M) ↔ x ∈ {x | annihilator (span R {x}) ≠ ⊥}

tactic: exact
  ⟨fun ⟨a, hax⟩ =>
    ⟨a, fun _ ⟨b, hb⟩ => by rw [← hb, smul_comm, ← Submonoid.smul_def, hax, smul_zero],
      nonZeroDivisors.coe_ne_zero _⟩,
    fun ⟨a, hax, ha⟩ => ⟨⟨_, mem_nonZeroDivisors_of_ne_zero ha⟩, hax x ⟨1, one_smul _ _⟩⟩⟩
state_before: case h
R : Type u_2
M : Type u_1
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : NoZeroDivisors R
inst✝ : Nontrivial R
x : M
⊢ x ∈ ↑(torsion R M) ↔ x ∈ {x | ∃ x_1, (∀ (n : M), (∃ a, a • x = n) → x_1 • n = 0) ∧ x_1 ≠ 0}

tactic: rw [← hb, smul_comm, ← Submonoid.smul_def, hax, smul_zero]
state_before: R : Type u_2
M : Type u_1
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : NoZeroDivisors R
inst✝ : Nontrivial R
x : M
x✝² : x ∈ ↑(torsion R M)
a : { x // x ∈ R⁰ }
hax : a • x = 0
x✝¹ : M
x✝ : ∃ a, a • x = x✝¹
b : R
hb : b • x = x✝¹
⊢ ↑a • x✝¹ = 0
Theorem: Finset.disjUnion_singleton
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [disjUnion_comm, singleton_disjUnion]
state_before: α : Type u_1
β : Type ?u.99903
γ : Type ?u.99906
s : Finset α
a : α
h : _root_.Disjoint s {a}
⊢ disjUnion s {a} h = cons a s (_ : ¬a ∈ s)
Theorem: Nat.sub_mod_eq_zero_of_mod_eq
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: rw [← Nat.mod_add_div m k, ← Nat.mod_add_div n k, ← h, tsub_add_eq_tsub_tsub,
  @add_tsub_cancel_left, ← mul_tsub k, Nat.mul_mod_right]
state_before: m n k l : ℕ
h : m % k = n % k
⊢ (m - n) % k = 0
Theorem: AddValuation.map_add'
File: Mathlib/RingTheory/Valuation/Basic.lean

tactic: intro x y
state_before: K : Type ?u.4087485
F : Type ?u.4087488
R : Type u_2
inst✝³ : DivisionRing K
Γ₀ : Type u_1
Γ'₀ : Type ?u.4087500
inst✝² : Ring R
inst✝¹ : LinearOrderedAddCommMonoidWithTop Γ₀
inst✝ : LinearOrderedAddCommMonoidWithTop Γ'₀
v : AddValuation R Γ₀
x y z : R
⊢ ∀ (x y : R), ↑v x ≤ ↑v (x + y) ∨ ↑v y ≤ ↑v (x + y)

tactic: rw [← @min_le_iff _ _ (v x) (v y) (v (x+y)), ← ge_iff_le]
state_before: K : Type ?u.4087485
F : Type ?u.4087488
R : Type u_2
inst✝³ : DivisionRing K
Γ₀ : Type u_1
Γ'₀ : Type ?u.4087500
inst✝² : Ring R
inst✝¹ : LinearOrderedAddCommMonoidWithTop Γ₀
inst✝ : LinearOrderedAddCommMonoidWithTop Γ'₀
v : AddValuation R Γ₀
x✝ y✝ z x y : R
⊢ ↑v x ≤ ↑v (x + y) ∨ ↑v y ≤ ↑v (x + y)

tactic: apply map_add
state_before: K : Type ?u.4087485
F : Type ?u.4087488
R : Type u_2
inst✝³ : DivisionRing K
Γ₀ : Type u_1
Γ'₀ : Type ?u.4087500
inst✝² : Ring R
inst✝¹ : LinearOrderedAddCommMonoidWithTop Γ₀
inst✝ : LinearOrderedAddCommMonoidWithTop Γ'₀
v : AddValuation R Γ₀
x✝ y✝ z x y : R
⊢ ↑v (x + y) ≥ min (↑v x) (↑v y)
Theorem: Finsupp.equivFunOnFinite_symm_single
File: Mathlib/Data/Finsupp/Defs.lean

tactic: rw [← equivFunOnFinite_single, Equiv.symm_apply_apply]
state_before: α : Type u_1
β : Type ?u.140404
γ : Type ?u.140407
ι : Type ?u.140410
M : Type u_2
M' : Type ?u.140416
N : Type ?u.140419
P : Type ?u.140422
G : Type ?u.140425
H : Type ?u.140428
R : Type ?u.140431
S : Type ?u.140434
inst✝² : Zero M
a a' : α
b : M
inst✝¹ : DecidableEq α
inst✝ : Finite α
x : α
m : M
⊢ ↑equivFunOnFinite.symm (Pi.single x m) = single x m
Theorem: Matrix.kroneckerMap_reindex
File: Mathlib/Data/Matrix/Kronecker.lean

tactic: ext (⟨i, i'⟩⟨j, j'⟩)
state_before: R : Type ?u.19536
α : Type u_9
α' : Type ?u.19542
β : Type u_10
β' : Type ?u.19548
γ : Type u_11
γ' : Type ?u.19554
l : Type u_1
m : Type u_3
n : Type u_5
p : Type u_7
q : Type ?u.19569
r : Type ?u.19572
l' : Type u_2
m' : Type u_4
n' : Type u_6
p' : Type u_8
f : α → β → γ
el : l ≃ l'
em : m ≃ m'
en : n ≃ n'
ep : p ≃ p'
M : Matrix l m α
N : Matrix n p β
⊢ kroneckerMap f (↑(reindex el em) M) (↑(reindex en ep) N) =
    ↑(reindex (Equiv.prodCongr el en) (Equiv.prodCongr em ep)) (kroneckerMap f M N)

tactic: rfl
state_before: case a.mk.h.mk
R : Type ?u.19536
α : Type u_9
α' : Type ?u.19542
β : Type u_10
β' : Type ?u.19548
γ : Type u_11
γ' : Type ?u.19554
l : Type u_1
m : Type u_3
n : Type u_5
p : Type u_7
q : Type ?u.19569
r : Type ?u.19572
l' : Type u_2
m' : Type u_4
n' : Type u_6
p' : Type u_8
f : α → β → γ
el : l ≃ l'
em : m ≃ m'
en : n ≃ n'
ep : p ≃ p'
M : Matrix l m α
N : Matrix n p β
i : l'
i' : n'
j : m'
j' : p'
⊢ kroneckerMap f (↑(reindex el em) M) (↑(reindex en ep) N) (i, i') (j, j') =
    ↑(reindex (Equiv.prodCongr el en) (Equiv.prodCongr em ep)) (kroneckerMap f M N) (i, i') (j, j')
Theorem: inf_sdiff_self_left
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [inf_comm, inf_sdiff_self_right]
state_before: α : Type u
β : Type ?u.8145
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ y \ x ⊓ x = ⊥
Theorem: List.pwFilter_eq_self
File: Mathlib/Data/List/Pairwise.lean

tactic: induction' l with x l IH
state_before: α : Type u_1
β : Type ?u.52180
R S T : α → α → Prop
a : α
l✝ : List α
inst✝ : DecidableRel R
l : List α
p : Pairwise R l
⊢ pwFilter R l = l

tactic: cases' pairwise_cons.1 p with al p
state_before: case cons
α : Type u_1
β : Type ?u.52180
R S T : α → α → Prop
a : α
l✝¹ : List α
inst✝ : DecidableRel R
l✝ : List α
p✝ : Pairwise R l✝
x : α
l : List α
IH : Pairwise R l → pwFilter R l = l
p : Pairwise R (x :: l)
⊢ pwFilter R (x :: l) = x :: l

tactic: rw [pwFilter_cons_of_pos (BAll.imp_left (pwFilter_subset l) al), IH p]
state_before: case cons.intro
α : Type u_1
β : Type ?u.52180
R S T : α → α → Prop
a : α
l✝¹ : List α
inst✝ : DecidableRel R
l✝ : List α
p✝¹ : Pairwise R l✝
x : α
l : List α
IH : Pairwise R l → pwFilter R l = l
p✝ : Pairwise R (x :: l)
al : ∀ (a' : α), a' ∈ l → R x a'
p : Pairwise R l
⊢ pwFilter R (x :: l) = x :: l

tactic: rfl
state_before: case nil
α : Type u_1
β : Type ?u.52180
R S T : α → α → Prop
a : α
l✝ : List α
inst✝ : DecidableRel R
l : List α
p✝ : Pairwise R l
p : Pairwise R []
⊢ pwFilter R [] = []
Theorem: Nat.pos_of_floor_pos
File: Mathlib/Algebra/Order/Floor.lean

tactic: rwa [floor_of_nonpos ha] at h
state_before: F : Type ?u.32136
α : Type u_1
β : Type ?u.32142
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n : ℕ
h : 0 < ⌊a⌋₊
ha : a ≤ 0
⊢ 0 < 0
Theorem: Vector.not_mem_map_zero
File: Mathlib/Data/Vector/Mem.lean

tactic: simpa only [Vector.eq_nil v, Vector.map_nil, Vector.toList_nil] using List.not_mem_nil b
state_before: α : Type u_1
β : Type u_2
n : ℕ
a a' : α
b : β
v : Vector α 0
f : α → β
⊢ ¬b ∈ toList (map f v)