tasksource/leandojo huggingface dataset:
Theorem: Prod.image_mk_segment_left
File: Mathlib/Analysis/Convex/Segment.lean

tactic: ext ⟨x', y'⟩
state_before: 𝕜 : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.309296
ι : Type ?u.309299
π : ι → Type ?u.309304
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x₁ x₂ : E
y : F
⊢ (fun x => (x, y)) '' [x₁-[𝕜]x₂] = [(x₁, y)-[𝕜](x₂, y)]

tactic: simp_rw [Set.mem_image, segment, Set.mem_setOf, Prod.smul_mk, Prod.mk_add_mk, Prod.mk.inj_iff, ←
  exists_and_right, @exists_comm E, exists_eq_left']
state_before: case h.mk
𝕜 : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.309296
ι : Type ?u.309299
π : ι → Type ?u.309304
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x₁ x₂ : E
y : F
x' : E
y' : F
⊢ (x', y') ∈ (fun x => (x, y)) '' [x₁-[𝕜]x₂] ↔ (x', y') ∈ [(x₁, y)-[𝕜](x₂, y)]

tactic: refine' exists₅_congr fun a b ha hb hab => _
state_before: case h.mk
𝕜 : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.309296
ι : Type ?u.309299
π : ι → Type ?u.309304
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x₁ x₂ : E
y : F
x' : E
y' : F
⊢ (∃ b b_1 h h h, b • x₁ + b_1 • x₂ = x' ∧ y = y') ↔ ∃ a b h h h, a • x₁ + b • x₂ = x' ∧ a • y + b • y = y'

tactic: rw [Convex.combo_self hab]
state_before: case h.mk
𝕜 : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.309296
ι : Type ?u.309299
π : ι → Type ?u.309304
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x₁ x₂ : E
y : F
x' : E
y' : F
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • x₁ + b • x₂ = x' ∧ y = y' ↔ a • x₁ + b • x₂ = x' ∧ a • y + b • y = y'
Theorem: CategoryTheory.Paths.lift_toPath
File: Mathlib/CategoryTheory/PathCategory.lean

tactic: dsimp [Quiver.Hom.toPath, lift]
state_before: V : Type u₁
inst✝¹ : Quiver V
C : Type u_1
inst✝ : Category C
φ : V ⥤q C
X Y : V
f : X ⟶ Y
⊢ (lift φ).map (Quiver.Hom.toPath f) = φ.map f

tactic: simp
state_before: V : Type u₁
inst✝¹ : Quiver V
C : Type u_1
inst✝ : Category C
φ : V ⥤q C
X Y : V
f : X ⟶ Y
⊢ 𝟙 (φ.obj X) ≫ φ.map f = φ.map f
Theorem: LieIdeal.bot_of_map_eq_bot
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: rw [← f.ker_eq_bot] at h₁
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'
I : LieIdeal R L
h₁ : Function.Injective ↑f
h₂ : map f I = ⊥
⊢ I = ⊥

tactic: change comap f ⊥ = ⊥ at h₁
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'
I : LieIdeal R L
h₁ : LieHom.ker f = ⊥
h₂ : map f I = ⊥
⊢ I = ⊥

tactic: rw [eq_bot_iff, map_le_iff_le_comap, h₁] at h₂
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'
I : LieIdeal R L
h₂ : map f I = ⊥
h₁ : comap f ⊥ = ⊥
⊢ I = ⊥

tactic: rw [eq_bot_iff]
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'
I : LieIdeal R L
h₂ : I ≤ ⊥
h₁ : comap f ⊥ = ⊥
⊢ I = ⊥

tactic: exact h₂
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'
I : LieIdeal R L
h₂ : I ≤ ⊥
h₁ : comap f ⊥ = ⊥
⊢ I ≤ ⊥
Theorem: intervalIntegrable_iff_integrable_Icc_of_le
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: rw [intervalIntegrable_iff_integrable_Ioc_of_le hab, integrableOn_Icc_iff_integrableOn_Ioc]
state_before: ι : Type ?u.695028
𝕜 : Type ?u.695031
E : Type u_1
F : Type ?u.695037
A : Type ?u.695040
inst✝¹ : NormedAddCommGroup E
f✝ : ℝ → E
a✝ b✝ : ℝ
μ✝ : MeasureTheory.Measure ℝ
f : ℝ → E
a b : ℝ
hab : a ≤ b
μ : MeasureTheory.Measure ℝ
inst✝ : NoAtoms μ
⊢ IntervalIntegrable f μ a b ↔ IntegrableOn f (Icc a b)
Theorem: CategoryTheory.Limits.limit.post_π
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: erw [IsLimit.fac]
state_before: J : Type u₁
inst✝⁵ : Category J
K : Type u₂
inst✝⁴ : Category K
C : Type u
inst✝³ : Category C
F : J ⥤ C
D : Type u'
inst✝² : Category D
inst✝¹ : HasLimit F
G : C ⥤ D
inst✝ : HasLimit (F ⋙ G)
j : J
⊢ post F G ≫ π (F ⋙ G) j = G.map (π F j)

tactic: rfl
state_before: J : Type u₁
inst✝⁵ : Category J
K : Type u₂
inst✝⁴ : Category K
C : Type u
inst✝³ : Category C
F : J ⥤ C
D : Type u'
inst✝² : Category D
inst✝¹ : HasLimit F
G : C ⥤ D
inst✝ : HasLimit (F ⋙ G)
j : J
⊢ (G.mapCone (cone F)).π.app j = G.map (π F j)
Theorem: Ordinal.left_le_opow
File: Mathlib/SetTheory/Ordinal/Exponential.lean

tactic: nth_rw 1 [← opow_one a]
state_before: a b : Ordinal
b1 : 0 < b
⊢ a ≤ a ^ b

tactic: cases' le_or_gt a 1 with a1 a1
state_before: a b : Ordinal
b1 : 0 < b
⊢ a ^ 1 ≤ a ^ b

tactic: rwa [opow_le_opow_iff_right a1, one_le_iff_pos]
state_before: case inr
a b : Ordinal
b1 : 0 < b
a1 : a > 1
⊢ a ^ 1 ≤ a ^ b

tactic: cases' lt_or_eq_of_le a1 with a0 a1
state_before: case inl
a b : Ordinal
b1 : 0 < b
a1 : a ≤ 1
⊢ a ^ 1 ≤ a ^ b

tactic: rw [a1, one_opow, one_opow]
state_before: case inl.inr
a b : Ordinal
b1 : 0 < b
a1✝ : a ≤ 1
a1 : a = 1
⊢ a ^ 1 ≤ a ^ b

tactic: rw [lt_one_iff_zero] at a0
state_before: case inl.inl
a b : Ordinal
b1 : 0 < b
a1 : a ≤ 1
a0 : a < 1
⊢ a ^ 1 ≤ a ^ b

tactic: rw [a0, zero_opow Ordinal.one_ne_zero]
state_before: case inl.inl
a b : Ordinal
b1 : 0 < b
a1 : a ≤ 1
a0 : a = 0
⊢ a ^ 1 ≤ a ^ b

tactic: exact Ordinal.zero_le _
state_before: case inl.inl
a b : Ordinal
b1 : 0 < b
a1 : a ≤ 1
a0 : a = 0
⊢ 0 ≤ 0 ^ b
Theorem: List.pairwise_middle
File: Mathlib/Data/List/Pairwise.lean

tactic: rw [← append_assoc, pairwise_append, @pairwise_append _ _ ([a] ++ l₁), pairwise_append_comm s]
state_before: α : Type u_1
β : Type ?u.10097
R S T : α → α → Prop
a✝ : α
l : List α
s : Symmetric R
a : α
l₁ l₂ : List α
⊢ Pairwise R (l₁ ++ ([a] ++ l₂)) ↔ Pairwise R ([a] ++ l₁ ++ l₂)

tactic: simp only [mem_append, or_comm]
state_before: α : Type u_1
β : Type ?u.10097
R S T : α → α → Prop
a✝ : α
l : List α
s : Symmetric R
a : α
l₁ l₂ : List α
⊢ (Pairwise R ([a] ++ l₁) ∧ Pairwise R l₂ ∧ ∀ (a_1 : α), a_1 ∈ l₁ ++ [a] → ∀ (b : α), b ∈ l₂ → R a_1 b) ↔
    Pairwise R ([a] ++ l₁) ∧ Pairwise R l₂ ∧ ∀ (a_1 : α), a_1 ∈ [a] ++ l₁ → ∀ (b : α), b ∈ l₂ → R a_1 b
Theorem: Nat.mod_two_of_bodd
File: Mathlib/Init/Data/Nat/Bitwise.lean

tactic: have := congr_arg bodd (mod_add_div n 2)
state_before: n : ℕ
⊢ n % 2 = bif bodd n then 1 else 0

tactic: simp [not] at this
state_before: n : ℕ
this : bodd (n % 2 + 2 * (n / 2)) = bodd n
⊢ n % 2 = bif bodd n then 1 else 0

tactic: have _ : ∀ b, and false b = false := by
  intro b
  cases b <;> rfl
state_before: n : ℕ
this : bodd (n % 2) = bodd n
⊢ n % 2 = bif bodd n then 1 else 0

tactic: have _ : ∀ b, bxor b false = b := by
  intro b
  cases b <;> rfl
state_before: n : ℕ
this : bodd (n % 2) = bodd n
x✝ : ∀ (b : Bool), (false && b) = false
⊢ n % 2 = bif bodd n then 1 else 0

tactic: rw [← this]
state_before: n : ℕ
this : bodd (n % 2) = bodd n
x✝¹ : ∀ (b : Bool), (false && b) = false
x✝ : ∀ (b : Bool), bxor b false = b
⊢ n % 2 = bif bodd n then 1 else 0

tactic: cases' mod_two_eq_zero_or_one n with h h <;> rw [h] <;> rfl
state_before: n : ℕ
this : bodd (n % 2) = bodd n
x✝¹ : ∀ (b : Bool), (false && b) = false
x✝ : ∀ (b : Bool), bxor b false = b
⊢ n % 2 = bif bodd (n % 2) then 1 else 0

tactic: intro b
state_before: n : ℕ
this : bodd (n % 2) = bodd n
⊢ ∀ (b : Bool), (false && b) = false

tactic: cases b <;> rfl
state_before: n : ℕ
this : bodd (n % 2) = bodd n
b : Bool
⊢ (false && b) = false

tactic: intro b
state_before: n : ℕ
this : bodd (n % 2) = bodd n
x✝ : ∀ (b : Bool), (false && b) = false
⊢ ∀ (b : Bool), bxor b false = b

tactic: cases b <;> rfl
state_before: n : ℕ
this : bodd (n % 2) = bodd n
x✝ : ∀ (b : Bool), (false && b) = false
b : Bool
⊢ bxor b false = b
Theorem: Zsqrtd.hom_ext
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: ext ⟨x_re, x_im⟩
state_before: R : Type
inst✝ : Ring R
d : ℤ
f g : ℤ√d →+* R
h : ↑f sqrtd = ↑g sqrtd
⊢ f = g

tactic: simp [decompose, h]
state_before: case a.mk
R : Type
inst✝ : Ring R
d : ℤ
f g : ℤ√d →+* R
h : ↑f sqrtd = ↑g sqrtd
x_re x_im : ℤ
⊢ ↑f { re := x_re, im := x_im } = ↑g { re := x_re, im := x_im }
Theorem: Metric.cthickening_empty
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: simp only [cthickening, ENNReal.ofReal_ne_top, setOf_false, infEdist_empty, top_le_iff]
state_before: ι : Sort ?u.100122
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x : α
δ : ℝ
⊢ cthickening δ ∅ = ∅
Theorem: Set.iSup_iInf_of_monotone
File: Mathlib/Data/Set/Finite.lean

tactic: simpa only [iInf_univ] using finite_univ.iSup_biInf_of_monotone fun i _ => hf i
state_before: α✝ : Type u
β : Type v
ι✝ : Sort w
γ : Type x
ι : Type u_1
ι' : Type u_2
α : Type u_3
inst✝⁴ : Finite ι
inst✝³ : Preorder ι'
inst✝² : Nonempty ι'
inst✝¹ : IsDirected ι' fun x x_1 => x ≤ x_1
inst✝ : Order.Frame α
f : ι → ι' → α
hf : ∀ (i : ι), Monotone (f i)
⊢ (⨆ (j : ι'), ⨅ (i : ι), f i j) = ⨅ (i : ι), ⨆ (j : ι'), f i j
Theorem: infEdist_cthickening
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: obtain hδ | hδ := le_or_lt δ 0
state_before: 𝕜 : Type ?u.228492
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x✝ y z : E
δ✝ ε δ : ℝ
s : Set E
x : E
⊢ infEdist x (cthickening δ s) = infEdist x s - ENNReal.ofReal δ

tactic: rw [cthickening_of_nonpos hδ, infEdist_closure, ofReal_of_nonpos hδ, tsub_zero]
state_before: case inl
𝕜 : Type ?u.228492
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x✝ y z : E
δ✝ ε δ : ℝ
s : Set E
x : E
hδ : δ ≤ 0
⊢ infEdist x (cthickening δ s) = infEdist x s - ENNReal.ofReal δ

tactic: rw [← closure_thickening hδ, infEdist_closure, infEdist_thickening hδ]
state_before: case inr
𝕜 : Type ?u.228492
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x✝ y z : E
δ✝ ε δ : ℝ
s : Set E
x : E
hδ : 0 < δ
⊢ infEdist x (cthickening δ s) = infEdist x s - ENNReal.ofReal δ
Theorem: CategoryTheory.Subobject.ofMkLEMk_comp
File: Mathlib/CategoryTheory/Subobject/Basic.lean

tactic: simp [ofMkLEMk]
state_before: C : Type u₁
inst✝³ : Category C
X Y Z : C
D : Type u₂
inst✝² : Category D
B A₁ A₂ : C
f : A₁ ⟶ B
g : A₂ ⟶ B
inst✝¹ : Mono f
inst✝ : Mono g
h : mk f ≤ mk g
⊢ ofMkLEMk f g h ≫ g = f
Theorem: inv_mul_lt_iff
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [inv_eq_one_div, mul_comm, ← div_eq_mul_one_div]
state_before: ι : Type ?u.35615
α : Type u_1
β : Type ?u.35621
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h : 0 < b
⊢ b⁻¹ * a < c ↔ a < b * c

tactic: exact div_lt_iff' h
state_before: ι : Type ?u.35615
α : Type u_1
β : Type ?u.35621
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h : 0 < b
⊢ a / b < c ↔ a < b * c
Theorem: bernoulli'_zero
File: Mathlib/NumberTheory/Bernoulli.lean

tactic: rw [bernoulli'_def]
state_before: A : Type ?u.180461
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
⊢ bernoulli' 0 = 1

tactic: norm_num
state_before: A : Type ?u.180461
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
⊢ 1 - ∑ k in range 0, ↑(Nat.choose 0 k) / (↑0 - ↑k + 1) * bernoulli' k = 1
Theorem: TendstoUniformlyOnFilter.comp
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: rw [tendstoUniformlyOnFilter_iff_tendsto] at h ⊢
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g✝ : ι → α
h : TendstoUniformlyOnFilter F f p p'
g : γ → α
⊢ TendstoUniformlyOnFilter (fun n => F n ∘ g) (f ∘ g) p (comap g p')

tactic: exact h.comp (tendsto_id.prod_map tendsto_comap)
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g✝ : ι → α
h : Tendsto (fun q => (f q.snd, F q.fst q.snd)) (p ×ˢ p') (𝓤 β)
g : γ → α
⊢ Tendsto (fun q => ((f ∘ g) q.snd, (F q.fst ∘ g) q.snd)) (p ×ˢ comap g p') (𝓤 β)
Theorem: div_self_mul_self
File: Mathlib/Algebra/GroupWithZero/Basic.lean

tactic: rw [div_eq_mul_inv, mul_inv_mul_self a]
state_before: α : Type ?u.25853
M₀ : Type ?u.25856
G₀ : Type u_1
M₀' : Type ?u.25862
G₀' : Type ?u.25865
F : Type ?u.25868
F' : Type ?u.25871
inst✝ : GroupWithZero G₀
a✝ b c a : G₀
⊢ a / a * a = a
Theorem: Nat.bodd_eq_bits_head
File: Mathlib/Data/Nat/Bits.lean

tactic: induction' n using Nat.binaryRec' with b n h _
state_before: n✝ n : ℕ
⊢ bodd n = List.headI (bits n)

tactic: simp [bodd_bit, bits_append_bit _ _ h]
state_before: case f
n✝ : ℕ
b : Bool
n : ℕ
h : n = 0 → b = true
a✝ : bodd n = List.headI (bits n)
⊢ bodd (bit b n) = List.headI (bits (bit b n))

tactic: simp
state_before: case z
n : ℕ
⊢ bodd 0 = List.headI (bits 0)
Theorem: padicValRat.of_int
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: simp [padicValRat]
state_before: p : ℕ
z : ℤ
⊢ padicValRat p ↑z = ↑(padicValInt p z)
Theorem: CauSeq.sup_equiv_sup
File: Mathlib/Data/Real/CauSeq.lean

tactic: intro ε ε0
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a₁ b₁ a₂ b₂ : CauSeq α abs
ha : a₁ ≈ a₂
hb : b₁ ≈ b₂
⊢ a₁ ⊔ b₁ ≈ a₂ ⊔ b₂

tactic: obtain ⟨ai, hai⟩ := ha ε ε0
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a₁ b₁ a₂ b₂ : CauSeq α abs
ha : a₁ ≈ a₂
hb : b₁ ≈ b₂
ε : α
ε0 : ε > 0
⊢ ∃ i, ∀ (j : ℕ), j ≥ i → abs (↑(a₁ ⊔ b₁ - a₂ ⊔ b₂) j) < ε

tactic: obtain ⟨bi, hbi⟩ := hb ε ε0
state_before: case intro
α : Type u_1
inst✝ : LinearOrderedField α
a₁ b₁ a₂ b₂ : CauSeq α abs
ha : a₁ ≈ a₂
hb : b₁ ≈ b₂
ε : α
ε0 : ε > 0
ai : ℕ
hai : ∀ (j : ℕ), j ≥ ai → abs (↑(a₁ - a₂) j) < ε
⊢ ∃ i, ∀ (j : ℕ), j ≥ i → abs (↑(a₁ ⊔ b₁ - a₂ ⊔ b₂) j) < ε

tactic: exact
  ⟨ai ⊔ bi, fun i hi =>
    (abs_max_sub_max_le_max (a₁ i) (b₁ i) (a₂ i) (b₂ i)).trans_lt
      (max_lt (hai i (sup_le_iff.mp hi).1) (hbi i (sup_le_iff.mp hi).2))⟩
state_before: case intro.intro
α : Type u_1
inst✝ : LinearOrderedField α
a₁ b₁ a₂ b₂ : CauSeq α abs
ha : a₁ ≈ a₂
hb : b₁ ≈ b₂
ε : α
ε0 : ε > 0
ai : ℕ
hai : ∀ (j : ℕ), j ≥ ai → abs (↑(a₁ - a₂) j) < ε
bi : ℕ
hbi : ∀ (j : ℕ), j ≥ bi → abs (↑(b₁ - b₂) j) < ε
⊢ ∃ i, ∀ (j : ℕ), j ≥ i → abs (↑(a₁ ⊔ b₁ - a₂ ⊔ b₂) j) < ε
Theorem: List.Func.sub_nil
File: Mathlib/Data/List/Func.lean

tactic: rw [sub, @pointwise_nil _ _ _ ⟨0⟩ ⟨0⟩]
state_before: α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
inst✝ : AddGroup α
as : List α
⊢ sub as [] = as

tactic: apply Eq.trans _ (map_id as)
state_before: α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
inst✝ : AddGroup α
as : List α
⊢ map (fun a => Sub.sub a default) as = as

tactic: congr with x
state_before: α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
inst✝ : AddGroup α
as : List α
⊢ map (fun a => Sub.sub a default) as = map id as

tactic: exact sub_zero x
state_before: case e_f.h
α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
inst✝ : AddGroup α
as : List α
x : α
⊢ Sub.sub x default = id x
Theorem: Fin.coe_castPred_lt_iff
File: Mathlib/Data/Fin/Basic.lean

tactic: rcases i.le_last.eq_or_lt with (rfl | H)
state_before: n m : ℕ
i : Fin (n + 2)
⊢ ↑(castPred i) < ↑i ↔ i = last (n + 1)

tactic: simp
state_before: case inl
n m : ℕ
⊢ ↑(castPred (last (n + 1))) < ↑(last (n + 1)) ↔ last (n + 1) = last (n + 1)

tactic: simp only [_root_.ne_of_lt H]
state_before: case inr
n m : ℕ
i : Fin (n + 2)
H : i < last (n + 1)
⊢ ↑(castPred i) < ↑i ↔ i = last (n + 1)

tactic: rw [← castSucc_castPred H]
state_before: case inr
n m : ℕ
i : Fin (n + 2)
H : i < last (n + 1)
⊢ ↑(castPred i) < ↑i ↔ False

tactic: simp
state_before: case inr
n m : ℕ
i : Fin (n + 2)
H : i < last (n + 1)
⊢ ↑(castPred (↑castSucc (castPred i))) < ↑(↑castSucc (castPred i)) ↔ False
Theorem: ENNReal.top_div
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp [div_eq_mul_inv, top_mul']
state_before: α : Type ?u.273458
β : Type ?u.273461
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ ⊤ / a = if a = ⊤ then 0 else ⊤
Theorem: Basis.addHaar_self
File: Mathlib/MeasureTheory/Measure/Haar/OfBasis.lean

tactic: rw [Basis.addHaar]
state_before: ι : Type u_1
ι' : Type ?u.277564
E : Type u_2
F : Type ?u.277570
inst✝⁷ : Fintype ι
inst✝⁶ : Fintype ι'
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ E
inst✝² : NormedSpace ℝ F
inst✝¹ : MeasurableSpace E
inst✝ : BorelSpace E
b : Basis ι ℝ E
⊢ ↑↑(addHaar b) ↑(parallelepiped b) = 1

tactic: exact addHaarMeasure_self
state_before: ι : Type u_1
ι' : Type ?u.277564
E : Type u_2
F : Type ?u.277570
inst✝⁷ : Fintype ι
inst✝⁶ : Fintype ι'
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ E
inst✝² : NormedSpace ℝ F
inst✝¹ : MeasurableSpace E
inst✝ : BorelSpace E
b : Basis ι ℝ E
⊢ ↑↑(addHaarMeasure (parallelepiped b)) ↑(parallelepiped b) = 1
Theorem: Option.map_eq_none'
File: Std/Data/Option/Lemmas.lean

tactic: cases x <;> simp only [map_none', map_some', eq_self_iff_true]
state_before: α✝¹ : Type u_1
x : Option α✝¹
α✝ : Type u_2
f : α✝¹ → α✝
⊢ Option.map f x = none ↔ x = none
Theorem: iInf_singleton
File: Mathlib/Order/CompleteLattice.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
β₂ : Type ?u.140189
γ : Type ?u.140192
ι : Sort ?u.140195
ι' : Sort ?u.140198
κ : ι → Sort ?u.140203
κ' : ι' → Sort ?u.140208
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b✝ : α
f : β → α
b : β
⊢ (⨅ (x : β) (_ : x ∈ {b}), f x) = f b
Theorem: Polynomial.degree_divByMonic_lt
File: Mathlib/Data/Polynomial/Div.lean

tactic: haveI := Nontrivial.of_polynomial_ne hp0
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p✝ q✝ p q : R[X]
hq : Monic q
hp0 : p ≠ 0
h0q : 0 < degree q
hpq : degree p < degree q
⊢ degree (p /ₘ q) < degree p

tactic: rw [(divByMonic_eq_zero_iff hq).2 hpq, degree_eq_natDegree hp0]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p✝ q✝ p q : R[X]
hq : Monic q
hp0 : p ≠ 0
h0q : 0 < degree q
hpq : degree p < degree q
this : Nontrivial R
⊢ degree (p /ₘ q) < degree p

tactic: exact WithBot.bot_lt_coe _
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p✝ q✝ p q : R[X]
hq : Monic q
hp0 : p ≠ 0
h0q : 0 < degree q
hpq : degree p < degree q
this : Nontrivial R
⊢ degree 0 < ↑(natDegree p)

tactic: haveI := Nontrivial.of_polynomial_ne hp0
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p✝ q✝ p q : R[X]
hq : Monic q
hp0 : p ≠ 0
h0q : 0 < degree q
hpq : ¬degree p < degree q
⊢ degree (p /ₘ q) < degree p

tactic: rw [← degree_add_divByMonic hq (not_lt.1 hpq), degree_eq_natDegree hq.ne_zero,
  degree_eq_natDegree (mt (divByMonic_eq_zero_iff hq).1 hpq)]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p✝ q✝ p q : R[X]
hq : Monic q
hp0 : p ≠ 0
h0q : 0 < degree q
hpq : ¬degree p < degree q
this : Nontrivial R
⊢ degree (p /ₘ q) < degree p

tactic: exact
  WithBot.coe_lt_coe.2
    (Nat.lt_add_of_pos_left (WithBot.coe_lt_coe.1 <|
      by simpa [Nat.cast_withBot, degree_eq_natDegree hq.ne_zero] using h0q))
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p✝ q✝ p q : R[X]
hq : Monic q
hp0 : p ≠ 0
h0q : 0 < degree q
hpq : ¬degree p < degree q
this : Nontrivial R
⊢ ↑(natDegree (p /ₘ q)) < ↑(natDegree q) + ↑(natDegree (p /ₘ q))

tactic: simpa [Nat.cast_withBot, degree_eq_natDegree hq.ne_zero] using h0q
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p✝ q✝ p q : R[X]
hq : Monic q
hp0 : p ≠ 0
h0q : 0 < degree q
hpq : ¬degree p < degree q
this : Nontrivial R
⊢ ↑0 < ↑↑(natDegree q)
Theorem: ball_normSeminorm
File: Mathlib/Analysis/Seminorm.lean

tactic: ext (x r y)
state_before: R : Type ?u.1449022
R' : Type ?u.1449025
𝕜 : Type u_2
𝕜₂ : Type ?u.1449031
𝕜₃ : Type ?u.1449034
𝕝 : Type ?u.1449037
E : Type u_1
E₂ : Type ?u.1449043
E₃ : Type ?u.1449046
F : Type ?u.1449049
G : Type ?u.1449052
ι : Type ?u.1449055
inst✝² : NormedField 𝕜
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
r : ℝ
⊢ Seminorm.ball (normSeminorm 𝕜 E) = Metric.ball

tactic: simp only [Seminorm.mem_ball, Metric.mem_ball, coe_normSeminorm, dist_eq_norm]
state_before: case h.h.h
R : Type ?u.1449022
R' : Type ?u.1449025
𝕜 : Type u_2
𝕜₂ : Type ?u.1449031
𝕜₃ : Type ?u.1449034
𝕝 : Type ?u.1449037
E : Type u_1
E₂ : Type ?u.1449043
E₃ : Type ?u.1449046
F : Type ?u.1449049
G : Type ?u.1449052
ι : Type ?u.1449055
inst✝² : NormedField 𝕜
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
r✝ : ℝ
x : E
r : ℝ
y : E
⊢ y ∈ Seminorm.ball (normSeminorm 𝕜 E) x r ↔ y ∈ Metric.ball x r
Theorem: set_smul_mem_nhds_zero_iff
File: Mathlib/Topology/Algebra/ConstMulAction.lean

tactic: refine' Iff.trans _ (set_smul_mem_nhds_smul_iff hc)
state_before: M : Type ?u.171187
α : Type u_1
β : Type ?u.171193
Γ : Type ?u.171196
inst✝⁷ : Group Γ
T : Type ?u.171202
inst✝⁶ : TopologicalSpace T
inst✝⁵ : MulAction Γ T
G₀ : Type u_2
inst✝⁴ : GroupWithZero G₀
inst✝³ : AddMonoid α
inst✝² : DistribMulAction G₀ α
inst✝¹ : TopologicalSpace α
inst✝ : ContinuousConstSMul G₀ α
s : Set α
c : G₀
hc : c ≠ 0
⊢ c • s ∈ 𝓝 0 ↔ s ∈ 𝓝 0

tactic: rw [smul_zero]
state_before: M : Type ?u.171187
α : Type u_1
β : Type ?u.171193
Γ : Type ?u.171196
inst✝⁷ : Group Γ
T : Type ?u.171202
inst✝⁶ : TopologicalSpace T
inst✝⁵ : MulAction Γ T
G₀ : Type u_2
inst✝⁴ : GroupWithZero G₀
inst✝³ : AddMonoid α
inst✝² : DistribMulAction G₀ α
inst✝¹ : TopologicalSpace α
inst✝ : ContinuousConstSMul G₀ α
s : Set α
c : G₀
hc : c ≠ 0
⊢ c • s ∈ 𝓝 0 ↔ c • s ∈ 𝓝 (c • 0)
Theorem: Nat.lt_floor_add_one
File: Mathlib/Algebra/Order/Floor.lean

tactic: simpa using lt_succ_floor a
state_before: F : Type ?u.23549
α : Type u_1
β : Type ?u.23555
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a : α
⊢ a < ↑⌊a⌋₊ + 1
Theorem: Multiset.mem_sort
File: Mathlib/Data/Multiset/Sort.lean

tactic: rw [← mem_coe, sort_eq]
state_before: α : Type u_1
r : α → α → Prop
inst✝³ : DecidableRel r
inst✝² : IsTrans α r
inst✝¹ : IsAntisymm α r
inst✝ : IsTotal α r
s : Multiset α
a : α
⊢ a ∈ sort r s ↔ a ∈ s
Theorem: Orthonormal.tsum_inner_products_le
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: refine' tsum_le_of_sum_le' _ fun s => hv.sum_inner_products_le x
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.3500272
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_3
x : E
v : ι → E
hv : Orthonormal 𝕜 v
⊢ (∑' (i : ι), ‖inner (v i) x‖ ^ 2) ≤ ‖x‖ ^ 2

tactic: simp only [norm_nonneg, pow_nonneg]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.3500272
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_3
x : E
v : ι → E
hv : Orthonormal 𝕜 v
⊢ 0 ≤ ‖x‖ ^ 2