tasksource/leandojo huggingface dataset:
Theorem: InnerProductGeometry.angle_sub_lt_pi_div_two_of_inner_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [← neg_eq_zero, ← inner_neg_right] at h
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : x ≠ 0
⊢ angle x (x - y) < π / 2

tactic: rw [sub_eq_add_neg]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x (-y) = 0
h0 : x ≠ 0
⊢ angle x (x - y) < π / 2

tactic: exact angle_add_lt_pi_div_two_of_inner_eq_zero h h0
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x (-y) = 0
h0 : x ≠ 0
⊢ angle x (x + -y) < π / 2
Theorem: SimpleGraph.le_minDegree_of_forall_le_degree
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: rcases G.exists_minimal_degree_vertex with ⟨v, hv⟩
state_before: ι : Sort ?u.291752
𝕜 : Type ?u.291755
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Nonempty V
k : ℕ
h : ∀ (v : V), k ≤ degree G v
⊢ k ≤ minDegree G

tactic: rw [hv]
state_before: case intro
ι : Sort ?u.291752
𝕜 : Type ?u.291755
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w : V
e : Sym2 V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Nonempty V
k : ℕ
h : ∀ (v : V), k ≤ degree G v
v : V
hv : minDegree G = degree G v
⊢ k ≤ minDegree G

tactic: apply h
state_before: case intro
ι : Sort ?u.291752
𝕜 : Type ?u.291755
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w : V
e : Sym2 V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Nonempty V
k : ℕ
h : ∀ (v : V), k ≤ degree G v
v : V
hv : minDegree G = degree G v
⊢ k ≤ degree G v
Theorem: CategoryTheory.Limits.hasCoequalizer_of_common_section
File: Mathlib/CategoryTheory/Limits/Shapes/Reflexive.lean

tactic: letI := IsReflexivePair.mk' r rf rg
state_before: C : Type u
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
A✝ B✝ : C
f✝ g✝ : A✝ ⟶ B✝
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
inst✝ : HasReflexiveCoequalizers C
A B : C
f g : A ⟶ B
r : B ⟶ A
rf : r ≫ f = 𝟙 B
rg : r ≫ g = 𝟙 B
⊢ HasCoequalizer f g

tactic: infer_instance
state_before: C : Type u
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
A✝ B✝ : C
f✝ g✝ : A✝ ⟶ B✝
F : C ⥤ D
G : D ⥤ C
adj : F ⊣ G
inst✝ : HasReflexiveCoequalizers C
A B : C
f g : A ⟶ B
r : B ⟶ A
rf : r ≫ f = 𝟙 B
rg : r ≫ g = 𝟙 B
this : IsReflexivePair f g := IsReflexivePair.mk' r rf rg
⊢ HasCoequalizer f g
Theorem: List.zipWith_distrib_tail
File: Mathlib/Data/List/Zip.lean

tactic: simp_rw [← drop_one, zipWith_distrib_drop]
state_before: α : Type u
β : Type u_2
γ : Type u_1
δ : Type ?u.233403
ε : Type ?u.233406
f : α → β → γ
l : List α
l' : List β
n : ℕ
⊢ tail (zipWith f l l') = zipWith f (tail l) (tail l')
Theorem: NNReal.indicator_summable
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: refine' NNReal.summable_of_le (fun a => le_trans (le_of_eq (s.indicator_apply f a)) _) hf
state_before: α : Type u_1
β : Type ?u.317811
γ : Type ?u.317814
f : α → ℝ≥0
hf : Summable f
s : Set α
⊢ Summable (indicator s f)

tactic: split_ifs
state_before: α : Type u_1
β : Type ?u.317811
γ : Type ?u.317814
f : α → ℝ≥0
hf : Summable f
s : Set α
a : α
⊢ (if a ∈ s then f a else 0) ≤ f a

tactic: exact le_refl (f a)
state_before: case inl
α : Type u_1
β : Type ?u.317811
γ : Type ?u.317814
f : α → ℝ≥0
hf : Summable f
s : Set α
a : α
h✝ : a ∈ s
⊢ f a ≤ f a

case inr
α : Type u_1
β : Type ?u.317811
γ : Type ?u.317814
f : α → ℝ≥0
hf : Summable f
s : Set α
a : α
h✝ : ¬a ∈ s
⊢ 0 ≤ f a

tactic: exact zero_le_coe
state_before: case inr
α : Type u_1
β : Type ?u.317811
γ : Type ?u.317814
f : α → ℝ≥0
hf : Summable f
s : Set α
a : α
h✝ : ¬a ∈ s
⊢ 0 ≤ f a
Theorem: PSet.func_mem
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: cases x
state_before: x : PSet
i : Type x
⊢ Func x i ∈ x

tactic: apply Mem.mk
state_before: case mk
α✝ : Type u_1
A✝ : α✝ → PSet
i : Type (mk α✝ A✝)
⊢ Func (mk α✝ A✝) i ∈ mk α✝ A✝
Theorem: List.get_of_append
File: Std/Data/List/Lemmas.lean

tactic: rw [← get?_eq_get, eq, get?_append_right (h ▸ Nat.le_refl _), h, Nat.sub_self]
state_before: α : Type u_1
l₁ : List α
a : α
l₂ : List α
n : Nat
l : List α
eq : l = l₁ ++ a :: l₂
h : length l₁ = n
⊢ some (get l { val := n, isLt := (_ : n < length l) }) = some a

tactic: rfl
state_before: α : Type u_1
l₁ : List α
a : α
l₂ : List α
n : Nat
l : List α
eq : l = l₁ ++ a :: l₂
h : length l₁ = n
⊢ get? (a :: l₂) 0 = some a
Theorem: Real.rpow_eq_nhds_of_neg
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

tactic: suffices : ∀ᶠ x : ℝ × ℝ in 𝓝 p, x.1 < 0
state_before: p : ℝ × ℝ
hp_fst : p.fst < 0
⊢ (fun x => x.fst ^ x.snd) =ᶠ[𝓝 p] fun x => exp (log x.fst * x.snd) * cos (x.snd * π)

tactic: exact
  this.mono fun x hx => by
    dsimp only
    rw [rpow_def_of_neg hx]
state_before: p : ℝ × ℝ
hp_fst : p.fst < 0
this : ∀ᶠ (x : ℝ × ℝ) in 𝓝 p, x.fst < 0
⊢ (fun x => x.fst ^ x.snd) =ᶠ[𝓝 p] fun x => exp (log x.fst * x.snd) * cos (x.snd * π)

case this
p : ℝ × ℝ
hp_fst : p.fst < 0
⊢ ∀ᶠ (x : ℝ × ℝ) in 𝓝 p, x.fst < 0

tactic: exact IsOpen.eventually_mem (isOpen_lt continuous_fst continuous_const) hp_fst
state_before: case this
p : ℝ × ℝ
hp_fst : p.fst < 0
⊢ ∀ᶠ (x : ℝ × ℝ) in 𝓝 p, x.fst < 0

tactic: dsimp only
state_before: p : ℝ × ℝ
hp_fst : p.fst < 0
this : ∀ᶠ (x : ℝ × ℝ) in 𝓝 p, x.fst < 0
x : ℝ × ℝ
hx : x.fst < 0
⊢ (fun x => x.fst ^ x.snd) x = (fun x => exp (log x.fst * x.snd) * cos (x.snd * π)) x

tactic: rw [rpow_def_of_neg hx]
state_before: p : ℝ × ℝ
hp_fst : p.fst < 0
this : ∀ᶠ (x : ℝ × ℝ) in 𝓝 p, x.fst < 0
x : ℝ × ℝ
hx : x.fst < 0
⊢ x.fst ^ x.snd = exp (log x.fst * x.snd) * cos (x.snd * π)
Theorem: isCompact_range
File: Mathlib/Topology/SubsetProperties.lean

tactic: rw [← image_univ]
state_before: α : Type u
β : Type v
ι : Type ?u.90314
π : ι → Type ?u.90319
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
s t : Set α
inst✝ : CompactSpace α
f : α → β
hf : Continuous f
⊢ IsCompact (range f)

tactic: exact isCompact_univ.image hf
state_before: α : Type u
β : Type v
ι : Type ?u.90314
π : ι → Type ?u.90319
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
s t : Set α
inst✝ : CompactSpace α
f : α → β
hf : Continuous f
⊢ IsCompact (f '' univ)
Theorem: StarSubalgebra.mem_bot
File: Mathlib/Algebra/Star/Subalgebra.lean

tactic: rw [← mem_toSubalgebra, bot_toSubalgebra, Algebra.mem_bot]
state_before: F : Type ?u.702130
R : Type u_2
A : Type u_1
B : Type ?u.702139
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
inst✝⁵ : StarRing A
inst✝⁴ : StarModule R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : StarRing B
inst✝ : StarModule R B
x : A
⊢ x ∈ ⊥ ↔ x ∈ Set.range ↑(algebraMap R A)
Theorem: FreeAddMonoid.count_of
File: Mathlib/Algebra/FreeMonoid/Count.lean

tactic: simp [Pi.single, Function.update, count, countp, List.countp, List.countp.go,
  Bool.beq_eq_decide_eq]
state_before: α : Type u_1
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidableEq α
x y : α
⊢ ↑(count x) (of y) = Pi.single x 1 y
Theorem: List.isEmpty_iff_eq_nil
File: Mathlib/Data/List/Basic.lean

tactic: cases l <;> simp [isEmpty]
state_before: ι : Type ?u.27737
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
⊢ isEmpty l = true ↔ l = []
Theorem: nhdsWithin_le_nhds
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [← nhdsWithin_univ]
state_before: α : Type u_1
β : Type ?u.11749
γ : Type ?u.11752
δ : Type ?u.11755
inst✝ : TopologicalSpace α
a : α
s : Set α
⊢ 𝓝[s] a ≤ 𝓝 a

tactic: apply nhdsWithin_le_of_mem
state_before: α : Type u_1
β : Type ?u.11749
γ : Type ?u.11752
δ : Type ?u.11755
inst✝ : TopologicalSpace α
a : α
s : Set α
⊢ 𝓝[s] a ≤ 𝓝[univ] a

tactic: exact univ_mem
state_before: case h
α : Type u_1
β : Type ?u.11749
γ : Type ?u.11752
δ : Type ?u.11755
inst✝ : TopologicalSpace α
a : α
s : Set α
⊢ univ ∈ 𝓝[s] a
Theorem: Seminorm.closedBall_eq_emptyset
File: Mathlib/Analysis/Seminorm.lean

tactic: ext
state_before: R : Type ?u.1158991
R' : Type ?u.1158994
𝕜 : Type u_1
𝕜₂ : Type ?u.1159000
𝕜₃ : Type ?u.1159003
𝕝 : Type ?u.1159006
E : Type u_2
E₂ : Type ?u.1159012
E₃ : Type ?u.1159015
F : Type ?u.1159018
G : Type ?u.1159021
ι : Type ?u.1159024
inst✝⁶ : SeminormedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : SeminormedRing 𝕜₂
inst✝² : AddCommGroup E₂
inst✝¹ : Module 𝕜₂ E₂
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝ : RingHomIsometric σ₁₂
p✝ p : Seminorm 𝕜 E
x : E
r : ℝ
hr : r < 0
⊢ closedBall p x r = ∅

tactic: rw [Seminorm.mem_closedBall, Set.mem_empty_iff_false, iff_false_iff, not_le]
state_before: case h
R : Type ?u.1158991
R' : Type ?u.1158994
𝕜 : Type u_1
𝕜₂ : Type ?u.1159000
𝕜₃ : Type ?u.1159003
𝕝 : Type ?u.1159006
E : Type u_2
E₂ : Type ?u.1159012
E₃ : Type ?u.1159015
F : Type ?u.1159018
G : Type ?u.1159021
ι : Type ?u.1159024
inst✝⁶ : SeminormedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : SeminormedRing 𝕜₂
inst✝² : AddCommGroup E₂
inst✝¹ : Module 𝕜₂ E₂
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝ : RingHomIsometric σ₁₂
p✝ p : Seminorm 𝕜 E
x : E
r : ℝ
hr : r < 0
x✝ : E
⊢ x✝ ∈ closedBall p x r ↔ x✝ ∈ ∅

tactic: exact hr.trans_le (map_nonneg _ _)
state_before: case h
R : Type ?u.1158991
R' : Type ?u.1158994
𝕜 : Type u_1
𝕜₂ : Type ?u.1159000
𝕜₃ : Type ?u.1159003
𝕝 : Type ?u.1159006
E : Type u_2
E₂ : Type ?u.1159012
E₃ : Type ?u.1159015
F : Type ?u.1159018
G : Type ?u.1159021
ι : Type ?u.1159024
inst✝⁶ : SeminormedRing 𝕜
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module 𝕜 E
inst✝³ : SeminormedRing 𝕜₂
inst✝² : AddCommGroup E₂
inst✝¹ : Module 𝕜₂ E₂
σ₁₂ : 𝕜 →+* 𝕜₂
inst✝ : RingHomIsometric σ₁₂
p✝ p : Seminorm 𝕜 E
x : E
r : ℝ
hr : r < 0
x✝ : E
⊢ r < ↑p (x✝ - x)
Theorem: Polynomial.IsRoot.map
File: Mathlib/Data/Polynomial/Eval.lean

tactic: rw [IsRoot, eval_map, eval₂_hom, h.eq_zero, f.map_zero]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f✝ f : R →+* S
x : R
p : R[X]
h : IsRoot p x
⊢ IsRoot (Polynomial.map f p) (↑f x)
Theorem: Rat.add_mul
File: Mathlib/Data/Rat/Defs.lean

tactic: simp [h₁, h₂, h₃, mul_ne_zero]
state_before: a b c : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
n₃ : ℤ
d₃ : ℕ
h₃ : d₃ ≠ 0
⊢ (n₁ /. ↑d₁ + n₂ /. ↑d₂) * (n₃ /. ↑d₃) = n₁ /. ↑d₁ * (n₃ /. ↑d₃) + n₂ /. ↑d₂ * (n₃ /. ↑d₃)

tactic: rw [←  divInt_mul_right (Int.coe_nat_ne_zero.2 h₃), add_mul, add_mul]
state_before: a b c : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
n₃ : ℤ
d₃ : ℕ
h₃ : d₃ ≠ 0
⊢ (n₁ * ↑d₂ + n₂ * ↑d₁) * n₃ /. (↑d₁ * ↑d₂ * ↑d₃) =
    (n₁ * n₃ * (↑d₂ * ↑d₃) + n₂ * n₃ * (↑d₁ * ↑d₃)) /. (↑d₁ * ↑d₃ * (↑d₂ * ↑d₃))

tactic: ac_rfl
state_before: a b c : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
n₃ : ℤ
d₃ : ℕ
h₃ : d₃ ≠ 0
⊢ (n₁ * ↑d₂ * n₃ * ↑d₃ + n₂ * ↑d₁ * n₃ * ↑d₃) /. (↑d₁ * ↑d₂ * ↑d₃ * ↑d₃) =
    (n₁ * n₃ * (↑d₂ * ↑d₃) + n₂ * n₃ * (↑d₁ * ↑d₃)) /. (↑d₁ * ↑d₃ * (↑d₂ * ↑d₃))
Theorem: Euclidean.closure_ball
File: Mathlib/Analysis/InnerProductSpace/EuclideanDist.lean

tactic: rw [ball_eq_preimage, ← toEuclidean.preimage_closure, closure_ball (toEuclidean x) h,
  closedBall_eq_preimage]
state_before: E : Type u_1
inst✝⁶ : AddCommGroup E
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalAddGroup E
inst✝³ : T2Space E
inst✝² : Module ℝ E
inst✝¹ : ContinuousSMul ℝ E
inst✝ : FiniteDimensional ℝ E
x : E
r : ℝ
h : r ≠ 0
⊢ closure (ball x r) = closedBall x r
Theorem: Fin.cycleRange_succAbove
File: Mathlib/GroupTheory/Perm/Fin.lean

tactic: cases' lt_or_ge (castSucc j) i with h h
state_before: n : ℕ
i : Fin (n + 1)
j : Fin n
⊢ ↑(cycleRange i) (↑(succAbove i) j) = succ j

tactic: rw [Fin.succAbove_below _ _ h, Fin.cycleRange_of_lt h, Fin.coeSucc_eq_succ]
state_before: case inl
n : ℕ
i : Fin (n + 1)
j : Fin n
h : ↑castSucc j < i
⊢ ↑(cycleRange i) (↑(succAbove i) j) = succ j

tactic: rw [Fin.succAbove_above _ _ h, Fin.cycleRange_of_gt (Fin.le_castSucc_iff.mp h)]
state_before: case inr
n : ℕ
i : Fin (n + 1)
j : Fin n
h : ↑castSucc j ≥ i
⊢ ↑(cycleRange i) (↑(succAbove i) j) = succ j
Theorem: SimpleGraph.Subgraph.induce_empty
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: ext <;> simp
state_before: ι : Sort ?u.260256
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : Subgraph G
s s' : Set V
⊢ induce G' ∅ = ⊥
Theorem: PicardLindelof.FunSpace.range_toContinuousMap
File: Mathlib/Analysis/ODE/PicardLindelof.lean

tactic: ext f
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
f : FunSpace v
⊢ range ↑toContinuousMap = {f | ↑f v.t₀ = v.x₀ ∧ LipschitzWith v.C ↑f}

tactic: constructor
state_before: case h
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
f✝ : FunSpace v
f : C(↑(Icc v.tMin v.tMax), E)
⊢ f ∈ range ↑toContinuousMap ↔ f ∈ {f | ↑f v.t₀ = v.x₀ ∧ LipschitzWith v.C ↑f}

tactic: rintro ⟨⟨f, hf₀, hf_lip⟩, rfl⟩
state_before: case h.mp
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
f✝ : FunSpace v
f : C(↑(Icc v.tMin v.tMax), E)
⊢ f ∈ range ↑toContinuousMap → f ∈ {f | ↑f v.t₀ = v.x₀ ∧ LipschitzWith v.C ↑f}

tactic: exact ⟨hf₀, hf_lip⟩
state_before: case h.mp.intro.mk
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
f✝ : FunSpace v
f : ↑(Icc v.tMin v.tMax) → E
hf₀ : f v.t₀ = v.x₀
hf_lip : LipschitzWith v.C f
⊢ ↑toContinuousMap { toFun := f, map_t₀' := hf₀, lipschitz' := hf_lip } ∈ {f | ↑f v.t₀ = v.x₀ ∧ LipschitzWith v.C ↑f}

tactic: rcases f with ⟨f, hf⟩
state_before: case h.mpr
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
f✝ : FunSpace v
f : C(↑(Icc v.tMin v.tMax), E)
⊢ f ∈ {f | ↑f v.t₀ = v.x₀ ∧ LipschitzWith v.C ↑f} → f ∈ range ↑toContinuousMap

tactic: rintro ⟨hf₀, hf_lip⟩
state_before: case h.mpr.mk
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
f✝ : FunSpace v
f : ↑(Icc v.tMin v.tMax) → E
hf : Continuous f
⊢ ContinuousMap.mk f ∈ {f | ↑f v.t₀ = v.x₀ ∧ LipschitzWith v.C ↑f} → ContinuousMap.mk f ∈ range ↑toContinuousMap

tactic: exact ⟨⟨f, hf₀, hf_lip⟩, rfl⟩
state_before: case h.mpr.mk.intro
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
f✝ : FunSpace v
f : ↑(Icc v.tMin v.tMax) → E
hf : Continuous f
hf₀ : ↑(ContinuousMap.mk f) v.t₀ = v.x₀
hf_lip : LipschitzWith v.C ↑(ContinuousMap.mk f)
⊢ ContinuousMap.mk f ∈ range ↑toContinuousMap
Theorem: Submodule.Quotient.equiv_refl
File: Mathlib/LinearAlgebra/Quotient.lean

tactic: simpa using hf
state_before: R : Type ?u.474547
M : Type ?u.474550
r : R
x y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' P Q : Submodule R M
hf : map (↑(LinearEquiv.refl R M)) P = Q
⊢ P = Q
Theorem: Fin.le_insertNth_iff
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: simp [Pi.le_def, forall_iff_succAbove i]
state_before: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
inst✝ : (i : Fin (n + 1)) → Preorder (α i)
i : Fin (n + 1)
x : α i
p : (j : Fin n) → α (↑(succAbove i) j)
q : (j : Fin (n + 1)) → α j
⊢ q ≤ insertNth i x p ↔ q i ≤ x ∧ (fun j => q (↑(succAbove i) j)) ≤ p
Theorem: Filter.Tendsto.atBot_mul_atBot
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: have : Tendsto (fun x => -f x * -g x) l atTop :=
  (tendsto_neg_atBot_atTop.comp hf).atTop_mul_atTop (tendsto_neg_atBot_atTop.comp hg)
state_before: ι : Type ?u.198322
ι' : Type ?u.198325
α : Type u_2
β : Type u_1
γ : Type ?u.198334
inst✝ : StrictOrderedRing α
l : Filter β
f g : β → α
hf : Tendsto f l atBot
hg : Tendsto g l atBot
⊢ Tendsto (fun x => f x * g x) l atTop

tactic: simpa only [neg_mul_neg] using this
state_before: ι : Type ?u.198322
ι' : Type ?u.198325
α : Type u_2
β : Type u_1
γ : Type ?u.198334
inst✝ : StrictOrderedRing α
l : Filter β
f g : β → α
hf : Tendsto f l atBot
hg : Tendsto g l atBot
this : Tendsto (fun x => -f x * -g x) l atTop
⊢ Tendsto (fun x => f x * g x) l atTop
Theorem: MeasureTheory.integrableOn_image_iff_integrableOn_abs_deriv_smul
File: Mathlib/MeasureTheory/Function/Jacobian.lean

tactic: simpa only [det_one_smulRight] using
  integrableOn_image_iff_integrableOn_abs_det_fderiv_smul volume hs
    (fun x hx => (hf' x hx).hasFDerivWithinAt) hf g
state_before: E : Type ?u.1050897
F : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : FiniteDimensional ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
s✝ : Set E
f✝ : E → E
f'✝ : E → E →L[ℝ] E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : IsAddHaarMeasure μ
s : Set ℝ
f f' : ℝ → ℝ
hs : MeasurableSet s
hf' : ∀ (x : ℝ), x ∈ s → HasDerivWithinAt f (f' x) s x
hf : InjOn f s
g : ℝ → F
⊢ IntegrableOn g (f '' s) ↔ IntegrableOn (fun x => abs (f' x) • g (f x)) s
Theorem: LieHom.mem_ker
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: simp only [ker_coeSubmodule, LinearMap.mem_ker, coe_toLinearMap]
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
x : L
⊢ x ∈ ↑(ker f) ↔ ↑f x = 0
Theorem: MvPolynomial.IsSymmetric.map
File: Mathlib/RingTheory/MvPolynomial/Symmetric.lean

tactic: rw [← map_rename, hφ]
state_before: σ : Type u_1
R : Type u_2
τ : Type ?u.44691
S : Type u_3
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
φ ψ : MvPolynomial σ R
hφ : IsSymmetric φ
f : R →+* S
e : Perm σ
⊢ ↑(rename ↑e) (↑(MvPolynomial.map f) φ) = ↑(MvPolynomial.map f) φ
Theorem: Cardinal.exists_aleph
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rw [aleph, Ordinal.add_sub_cancel_of_le, aleph'_alephIdx]
state_before: c : Cardinal
h : ℵ₀ ≤ c
⊢ c = aleph (alephIdx c - ω)

tactic: rwa [← aleph0_le_aleph', aleph'_alephIdx]
state_before: c : Cardinal
h : ℵ₀ ≤ c
⊢ ω ≤ alephIdx c
Theorem: Array.sizeOf_get_lt
File: src/lean/Init/Data/Array/Mem.lean

tactic: cases as
state_before: α : Type u_1
inst✝ : SizeOf α
as : Array α
i : Fin (size as)
⊢ sizeOf (get as i) < sizeOf as

tactic: rename_i as
state_before: case mk
α : Type u_1
inst✝ : SizeOf α
data✝ : List α
i : Fin (size { data := data✝ })
⊢ sizeOf (get { data := data✝ } i) < sizeOf { data := data✝ }

tactic: simp [get]
state_before: case mk
α : Type u_1
inst✝ : SizeOf α
as : List α
i : Fin (size { data := as })
⊢ sizeOf (get { data := as } i) < sizeOf { data := as }

tactic: have ih := List.sizeOf_get_lt as i
state_before: case mk
α : Type u_1
inst✝ : SizeOf α
as : List α
i : Fin (size { data := as })
⊢ sizeOf (List.get as i) < 1 + sizeOf as

tactic: exact Nat.lt_trans ih (by simp_arith)
state_before: case mk
α : Type u_1
inst✝ : SizeOf α
as : List α
i : Fin (size { data := as })
ih : sizeOf (List.get as i) < sizeOf as
⊢ sizeOf (List.get as i) < 1 + sizeOf as

tactic: simp_arith
state_before: α : Type u_1
inst✝ : SizeOf α
as : List α
i : Fin (size { data := as })
ih : sizeOf (List.get as i) < sizeOf as
⊢ sizeOf as < 1 + sizeOf as
Theorem: Ordinal.pred_eq_iff_not_succ'
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simpa using pred_eq_iff_not_succ
state_before: α : Type ?u.82530
β : Type ?u.82533
γ : Type ?u.82536
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
⊢ pred o = o ↔ ∀ (a : Ordinal), o ≠ succ a
Theorem: MeasureTheory.IsProbabilityMeasure.ne_zero
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp [measure_univ]
state_before: α : Type u_1
β : Type ?u.652108
γ : Type ?u.652111
δ : Type ?u.652114
ι : Type ?u.652117
R : Type ?u.652120
R' : Type ?u.652123
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
μ : Measure α
inst✝ : IsProbabilityMeasure μ
⊢ ¬↑↑μ univ = 0
Theorem: MeasureTheory.tendstoInMeasure_iff_norm
File: Mathlib/MeasureTheory/Function/ConvergenceInMeasure.lean

tactic: simp_rw [TendstoInMeasure, dist_eq_norm]
state_before: α : Type u_3
ι : Type u_2
E : Type u_1
m : MeasurableSpace α
μ : Measure α
inst✝ : SeminormedAddCommGroup E
l : Filter ι
f : ι → α → E
g : α → E
⊢ TendstoInMeasure μ f l g ↔ ∀ (ε : ℝ), 0 < ε → Tendsto (fun i => ↑↑μ {x | ε ≤ ‖f i x - g x‖}) l (𝓝 0)
Theorem: Compactum.le_nhds_of_str_eq
File: Mathlib/Topology/Category/Compactum.lean

tactic: rwa [h]
state_before: X : Compactum
F : Ultrafilter X.A
x : X.A
h : str X F = x
s : Set X.A
hx : x ∈ s
hs : IsOpen s
⊢ str X F ∈ s
Theorem: Int.negSucc_mul_negOfNat
File: Std/Data/Int/Lemmas.lean

tactic: cases n <;> rfl
state_before: m n : Nat
⊢ -[m+1] * negOfNat n = ofNat (succ m * n)
Theorem: hasFPowerSeriesAt_iff'
File: Mathlib/Analysis/Analytic/Basic.lean

tactic: rw [← map_add_left_nhds_zero, eventually_map, hasFPowerSeriesAt_iff]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2404405
G : Type ?u.2404408
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p : FormalMultilinearSeries 𝕜 𝕜 E
f : 𝕜 → E
z₀ : 𝕜
⊢ HasFPowerSeriesAt f p z₀ ↔ ∀ᶠ (z : 𝕜) in 𝓝 z₀, HasSum (fun n => (z - z₀) ^ n • coeff p n) (f z)

tactic: simp_rw [add_sub_cancel']
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2404405
G : Type ?u.2404408
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p : FormalMultilinearSeries 𝕜 𝕜 E
f : 𝕜 → E
z₀ : 𝕜
⊢ (∀ᶠ (z : 𝕜) in 𝓝 0, HasSum (fun n => z ^ n • coeff p n) (f (z₀ + z))) ↔
    ∀ᶠ (a : 𝕜) in 𝓝 0,
      HasSum (fun n => ((fun x x_1 => x + x_1) z₀ a - z₀) ^ n • coeff p n) (f ((fun x x_1 => x + x_1) z₀ a))
Theorem: ContinuousMultilinearMap.op_norm_zero
File: Mathlib/Analysis/NormedSpace/Multilinear.lean

tactic: simp
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
c : 𝕜
f g : ContinuousMultilinearMap 𝕜 E G
m✝ m : (i : ι) → E i
⊢ ‖↑0 m‖ ≤ 0 * ∏ i : ι, ‖m i‖
Theorem: isCauSeq_geo_series_const
File: Mathlib/Data/Complex/Exponential.lean

tactic: have : IsCauSeq abs fun m => a * ∑ n in range m, (x ^ n) :=
  (CauSeq.const abs a *
    (show CauSeq α abs from ⟨fun n => ∑ m in range n, x ^ m, isCauSeq_geo_series x hx1⟩)).2
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : Archimedean α
a x : α
hx1 : abs' x < 1
⊢ IsCauSeq abs' fun m => ∑ n in range m, a * x ^ n

tactic: simpa [mul_sum] using this
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : Archimedean α
a x : α
hx1 : abs' x < 1
this : IsCauSeq abs' fun m => a * ∑ n in range m, x ^ n
⊢ IsCauSeq abs' fun m => ∑ n in range m, a * x ^ n
Theorem: AffineSubspace.card_pos_of_affineSpan_eq_top
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: obtain ⟨-, ⟨i, -⟩⟩ := nonempty_of_affineSpan_eq_top k V P h
state_before: k : Type u_3
V : Type u_4
P : Type u_2
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
p₁ p₂ : P
ι : Type u_1
inst✝ : Fintype ι
p : ι → P
h : affineSpan k (range p) = ⊤
⊢ 0 < Fintype.card ι

tactic: exact Fintype.card_pos_iff.mpr ⟨i⟩
state_before: case intro.intro
k : Type u_3
V : Type u_4
P : Type u_2
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
p₁ p₂ : P
ι : Type u_1
inst✝ : Fintype ι
p : ι → P
h : affineSpan k (range p) = ⊤
i : ι
⊢ 0 < Fintype.card ι
Theorem: Nat.Prime.factorization_pos_of_dvd
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: rwa [← factors_count_eq, count_pos, mem_factors_iff_dvd hn hp]
state_before: n p : ℕ
hp : Prime p
hn : n ≠ 0
h : p ∣ n
⊢ 0 < ↑(factorization n) p