tasksource/leandojo huggingface dataset:
Theorem: second_derivative_symmetric_of_eventually
File: Mathlib/Analysis/Calculus/FDerivSymmetric.lean

tactic: rcases Metric.mem_nhds_iff.1 hf with ⟨ε, εpos, hε⟩
state_before: E : Type u_1
F : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
s : Set E
s_conv : Convex ℝ s
f✝ : E → F
f'✝ : E → E →L[ℝ] F
f''✝ : E →L[ℝ] E →L[ℝ] F
hf✝ : ∀ (x : E), x ∈ interior s → HasFDerivAt f✝ (f'✝ x) x
x : E
xs : x ∈ s
hx✝ : HasFDerivWithinAt f'✝ f''✝ (interior s) x
f : E → F
f' : E → E →L[ℝ] F
f'' : E →L[ℝ] E →L[ℝ] F
hf : ∀ᶠ (y : E) in 𝓝 x, HasFDerivAt f (f' y) y
hx : HasFDerivAt f' f'' x
v w : E
⊢ ↑(↑f'' v) w = ↑(↑f'' w) v

tactic: have A : (interior (Metric.ball x ε)).Nonempty := by
  rwa [Metric.isOpen_ball.interior_eq, Metric.nonempty_ball]
state_before: case intro.intro
E : Type u_1
F : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
s : Set E
s_conv : Convex ℝ s
f✝ : E → F
f'✝ : E → E →L[ℝ] F
f''✝ : E →L[ℝ] E →L[ℝ] F
hf✝ : ∀ (x : E), x ∈ interior s → HasFDerivAt f✝ (f'✝ x) x
x : E
xs : x ∈ s
hx✝ : HasFDerivWithinAt f'✝ f''✝ (interior s) x
f : E → F
f' : E → E →L[ℝ] F
f'' : E →L[ℝ] E →L[ℝ] F
hf : ∀ᶠ (y : E) in 𝓝 x, HasFDerivAt f (f' y) y
hx : HasFDerivAt f' f'' x
v w : E
ε : ℝ
εpos : ε > 0
hε : Metric.ball x ε ⊆ {x | (fun y => HasFDerivAt f (f' y) y) x}
⊢ ↑(↑f'' v) w = ↑(↑f'' w) v

tactic: exact
  Convex.second_derivative_within_at_symmetric (convex_ball x ε) A
    (fun y hy => hε (interior_subset hy)) (Metric.mem_ball_self εpos) hx.hasFDerivWithinAt v w
state_before: case intro.intro
E : Type u_1
F : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
s : Set E
s_conv : Convex ℝ s
f✝ : E → F
f'✝ : E → E →L[ℝ] F
f''✝ : E →L[ℝ] E →L[ℝ] F
hf✝ : ∀ (x : E), x ∈ interior s → HasFDerivAt f✝ (f'✝ x) x
x : E
xs : x ∈ s
hx✝ : HasFDerivWithinAt f'✝ f''✝ (interior s) x
f : E → F
f' : E → E →L[ℝ] F
f'' : E →L[ℝ] E →L[ℝ] F
hf : ∀ᶠ (y : E) in 𝓝 x, HasFDerivAt f (f' y) y
hx : HasFDerivAt f' f'' x
v w : E
ε : ℝ
εpos : ε > 0
hε : Metric.ball x ε ⊆ {x | (fun y => HasFDerivAt f (f' y) y) x}
A : Set.Nonempty (interior (Metric.ball x ε))
⊢ ↑(↑f'' v) w = ↑(↑f'' w) v

tactic: rwa [Metric.isOpen_ball.interior_eq, Metric.nonempty_ball]
state_before: E : Type u_1
F : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
s : Set E
s_conv : Convex ℝ s
f✝ : E → F
f'✝ : E → E →L[ℝ] F
f''✝ : E →L[ℝ] E →L[ℝ] F
hf✝ : ∀ (x : E), x ∈ interior s → HasFDerivAt f✝ (f'✝ x) x
x : E
xs : x ∈ s
hx✝ : HasFDerivWithinAt f'✝ f''✝ (interior s) x
f : E → F
f' : E → E →L[ℝ] F
f'' : E →L[ℝ] E →L[ℝ] F
hf : ∀ᶠ (y : E) in 𝓝 x, HasFDerivAt f (f' y) y
hx : HasFDerivAt f' f'' x
v w : E
ε : ℝ
εpos : ε > 0
hε : Metric.ball x ε ⊆ {x | (fun y => HasFDerivAt f (f' y) y) x}
⊢ Set.Nonempty (interior (Metric.ball x ε))
Theorem: Filter.comap_cocompact_le
File: Mathlib/Topology/SubsetProperties.lean

tactic: rw [(Filter.hasBasis_cocompact.comap f).le_basis_iff Filter.hasBasis_cocompact]
state_before: α : Type u
β : Type v
ι : Type ?u.89720
π : ι → Type ?u.89725
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
f : α → β
hf : Continuous f
⊢ comap f (cocompact β) ≤ cocompact α

tactic: intro t ht
state_before: α : Type u
β : Type v
ι : Type ?u.89720
π : ι → Type ?u.89725
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
f : α → β
hf : Continuous f
⊢ ∀ (i' : Set α), IsCompact i' → ∃ i, IsCompact i ∧ f ⁻¹' iᶜ ⊆ i'ᶜ

tactic: refine' ⟨f '' t, ht.image hf, _⟩
state_before: α : Type u
β : Type v
ι : Type ?u.89720
π : ι → Type ?u.89725
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t✝ : Set α
f : α → β
hf : Continuous f
t : Set α
ht : IsCompact t
⊢ ∃ i, IsCompact i ∧ f ⁻¹' iᶜ ⊆ tᶜ

tactic: simpa using t.subset_preimage_image f
state_before: α : Type u
β : Type v
ι : Type ?u.89720
π : ι → Type ?u.89725
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t✝ : Set α
f : α → β
hf : Continuous f
t : Set α
ht : IsCompact t
⊢ f ⁻¹' (f '' t)ᶜ ⊆ tᶜ
Theorem: Polynomial.tendsto_atTop_iff_leadingCoeff_nonneg
File: Mathlib/Analysis/SpecialFunctions/Polynomials.lean

tactic: refine' ⟨fun h => _, fun h => tendsto_atTop_of_leadingCoeff_nonneg P h.1 h.2⟩
state_before: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
⊢ Tendsto (fun x => eval x P) atTop atTop ↔ 0 < degree P ∧ 0 ≤ leadingCoeff P

tactic: have : Tendsto (fun x => P.leadingCoeff * x ^ P.natDegree) atTop atTop :=
  (isEquivalent_atTop_lead P).tendsto_atTop h
state_before: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
h : Tendsto (fun x => eval x P) atTop atTop
⊢ 0 < degree P ∧ 0 ≤ leadingCoeff P

tactic: rw [tendsto_const_mul_pow_atTop_iff, ← pos_iff_ne_zero, natDegree_pos_iff_degree_pos] at this
state_before: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
h : Tendsto (fun x => eval x P) atTop atTop
this : Tendsto (fun x => leadingCoeff P * x ^ natDegree P) atTop atTop
⊢ 0 < degree P ∧ 0 ≤ leadingCoeff P

tactic: exact ⟨this.1, this.2.le⟩
state_before: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
h : Tendsto (fun x => eval x P) atTop atTop
this : 0 < degree P ∧ 0 < leadingCoeff P
⊢ 0 < degree P ∧ 0 ≤ leadingCoeff P
Theorem: FractionalIdeal.mapEquiv_refl
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: simp
state_before: R : Type u_2
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_1
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
P' : Type ?u.654570
inst✝³ : CommRing P'
inst✝² : Algebra R P'
loc' : IsLocalization S P'
P'' : Type ?u.655023
inst✝¹ : CommRing P''
inst✝ : Algebra R P''
loc'' : IsLocalization S P''
I J : FractionalIdeal S P
g : P →ₐ[R] P'
x : FractionalIdeal S P
⊢ ↑(mapEquiv AlgEquiv.refl) x = ↑(RingEquiv.refl (FractionalIdeal S P)) x
Theorem: Real.logb_rpow
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [logb, div_eq_iff, log_rpow b_pos]
state_before: b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
⊢ logb b (b ^ x) = x

tactic: exact log_b_ne_zero b_pos b_ne_one
state_before: b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
⊢ log b ≠ 0
Theorem: String.Iterator.ValidFor.next
File: Std/Data/String/Lemmas.lean

tactic: cases h.out'
state_before: l : List Char
c : Char
r : List Char
it : Iterator
h : ValidFor l (c :: r) it
⊢ ValidFor (c :: l) r (Iterator.next it)

tactic: simp only [Iterator.next, next_of_valid l.reverse c r]
state_before: case refl
l : List Char
c : Char
r : List Char
h : ValidFor l (c :: r) { s := { data := List.reverse l ++ c :: r }, i := { byteIdx := utf8Len (List.reverse l) } }
⊢ ValidFor (c :: l) r
    (Iterator.next { s := { data := List.reverse l ++ c :: r }, i := { byteIdx := utf8Len (List.reverse l) } })

tactic: rw [← List.reverseAux_eq, utf8Len_reverse]
state_before: case refl
l : List Char
c : Char
r : List Char
h : ValidFor l (c :: r) { s := { data := List.reverse l ++ c :: r }, i := { byteIdx := utf8Len (List.reverse l) } }
⊢ ValidFor (c :: l) r
    { s := { data := List.reverse l ++ c :: r }, i := { byteIdx := utf8Len (List.reverse l) + csize c } }

tactic: constructor
state_before: case refl
l : List Char
c : Char
r : List Char
h : ValidFor l (c :: r) { s := { data := List.reverse l ++ c :: r }, i := { byteIdx := utf8Len (List.reverse l) } }
⊢ ValidFor (c :: l) r { s := { data := List.reverseAux l (c :: r) }, i := { byteIdx := utf8Len l + csize c } }
Theorem: String.Iterator.hasNext_cons_addChar
File: Mathlib/Data/String/Basic.lean

tactic: simp [hasNext, Nat.add_lt_add_iff_lt_right]
state_before: c : Char
cs : List Char
i : Pos
⊢ hasNext { s := { data := c :: cs }, i := i + c } = hasNext { s := { data := cs }, i := i }
Theorem: SubMulAction.stabilizer_of_subMul
File: Mathlib/GroupTheory/GroupAction/SubMulAction.lean

tactic: rw [← Subgroup.toSubmonoid_eq]
state_before: S : Type u'
T : Type u''
R : Type u
M : Type v
inst✝¹ : Group R
inst✝ : MulAction R M
p : SubMulAction R M
m : { x // x ∈ p }
⊢ MulAction.stabilizer R m = MulAction.stabilizer R ↑m

tactic: exact stabilizer_of_subMul.submonoid m
state_before: S : Type u'
T : Type u''
R : Type u
M : Type v
inst✝¹ : Group R
inst✝ : MulAction R M
p : SubMulAction R M
m : { x // x ∈ p }
⊢ (MulAction.stabilizer R m).toSubmonoid = (MulAction.stabilizer R ↑m).toSubmonoid
Theorem: Filter.SupHom.apply_blimsup_le
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp only [blimsup_eq_iInf_biSup, Function.comp]
state_before: α : Type u_2
β : Type u_3
γ : Type u_1
ι : Type ?u.152425
inst✝¹ : CompleteLattice α
f g✝ : Filter β
p q : β → Prop
u v : β → α
inst✝ : CompleteLattice γ
g : sSupHom α γ
⊢ ↑g (blimsup u f p) ≤ blimsup (↑g ∘ u) f p

tactic: refine' ((OrderHomClass.mono g).map_iInf₂_le _).trans _
state_before: α : Type u_2
β : Type u_3
γ : Type u_1
ι : Type ?u.152425
inst✝¹ : CompleteLattice α
f g✝ : Filter β
p q : β → Prop
u v : β → α
inst✝ : CompleteLattice γ
g : sSupHom α γ
⊢ ↑g (⨅ (s : Set β) (_ : s ∈ f), ⨆ (b : β) (_ : p b ∧ b ∈ s), u b) ≤
    ⨅ (s : Set β) (_ : s ∈ f), ⨆ (b : β) (_ : p b ∧ b ∈ s), ↑g (u b)

tactic: simp only [_root_.map_iSup, le_refl]
state_before: α : Type u_2
β : Type u_3
γ : Type u_1
ι : Type ?u.152425
inst✝¹ : CompleteLattice α
f g✝ : Filter β
p q : β → Prop
u v : β → α
inst✝ : CompleteLattice γ
g : sSupHom α γ
⊢ (⨅ (i : Set β) (_ : i ∈ f), ↑g (⨆ (b : β) (_ : p b ∧ b ∈ i), u b)) ≤
    ⨅ (s : Set β) (_ : s ∈ f), ⨆ (b : β) (_ : p b ∧ b ∈ s), ↑g (u b)
Theorem: Finset.prod_range_add
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: induction' m with m hm
state_before: ι : Type ?u.441582
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
f : ℕ → β
n m : ℕ
⊢ ∏ x in range (n + m), f x = (∏ x in range n, f x) * ∏ x in range m, f (n + x)

tactic: simp
state_before: case zero
ι : Type ?u.441582
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
f : ℕ → β
n : ℕ
⊢ ∏ x in range (n + Nat.zero), f x = (∏ x in range n, f x) * ∏ x in range Nat.zero, f (n + x)

tactic: erw [Nat.add_succ, prod_range_succ, prod_range_succ, hm, mul_assoc]
state_before: case succ
ι : Type ?u.441582
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
f : ℕ → β
n m : ℕ
hm : ∏ x in range (n + m), f x = (∏ x in range n, f x) * ∏ x in range m, f (n + x)
⊢ ∏ x in range (n + Nat.succ m), f x = (∏ x in range n, f x) * ∏ x in range (Nat.succ m), f (n + x)
Theorem: isCoveringMap_iff_isCoveringMapOn_univ
File: Mathlib/Topology/Covering.lean

tactic: simp only [IsCoveringMap, IsCoveringMapOn, Set.mem_univ, forall_true_left]
state_before: E : Type u_1
X : Type u_2
inst✝¹ : TopologicalSpace E
inst✝ : TopologicalSpace X
f : E → X
s : Set X
⊢ IsCoveringMap f ↔ IsCoveringMapOn f Set.univ
Theorem: Affine.Simplex.span_eq_top
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

tactic: rw [AffineIndependent.affineSpan_eq_top_iff_card_eq_finrank_add_one T.Independent,
  Fintype.card_fin, hrank]
state_before: k : Type u_1
V : Type u_2
P : Type ?u.206684
ι : Type ?u.206687
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : FiniteDimensional k V
n : ℕ
T : Simplex k V n
hrank : finrank k V = n
⊢ affineSpan k (Set.range T.points) = ⊤
Theorem: Computation.liftRel_think_right
File: Mathlib/Data/Seq/Computation.lean

tactic: rw [← LiftRel.swap R, ← LiftRel.swap R]
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
ca : Computation α
cb : Computation β
⊢ LiftRel R ca (think cb) ↔ LiftRel R ca cb

tactic: apply liftRel_think_left
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
ca : Computation α
cb : Computation β
⊢ LiftRel (swap R) (think cb) ca ↔ LiftRel (swap R) cb ca
Theorem: Finite.injective_iff_bijective
File: Mathlib/Data/Fintype/Card.lean

tactic: simp [Bijective, injective_iff_surjective]
state_before: α : Type u_1
β : Type ?u.27086
γ : Type ?u.27089
inst✝ : Finite α
f : α → α
⊢ Injective f ↔ Bijective f
Theorem: Polynomial.separable_prod_X_sub_C_iff
File: Mathlib/FieldTheory/Separable.lean

tactic: simp_rw [mem_univ, true_imp_iff, Function.Injective]
state_before: F : Type u
inst✝² : Field F
K : Type v
inst✝¹ : Field K
ι : Type u_1
inst✝ : Fintype ι
f : ι → F
⊢ (∀ (x : ι), x ∈ univ → ∀ (y : ι), y ∈ univ → f x = f y → x = y) ↔ Function.Injective f
Theorem: MeasureTheory.FiniteMeasure.mass_zero_iff
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

tactic: refine' ⟨fun μ_mass => _, fun hμ => by simp only [hμ, zero_mass]⟩
state_before: Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ : FiniteMeasure Ω
⊢ mass μ = 0 ↔ μ = 0

tactic: apply toMeasure_injective
state_before: Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ : FiniteMeasure Ω
μ_mass : mass μ = 0
⊢ μ = 0

tactic: apply Measure.measure_univ_eq_zero.mp
state_before: case a
Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ : FiniteMeasure Ω
μ_mass : mass μ = 0
⊢ ↑μ = ↑0

tactic: rwa [← ennreal_mass, ENNReal.coe_eq_zero]
state_before: case a
Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ : FiniteMeasure Ω
μ_mass : mass μ = 0
⊢ ↑↑↑μ univ = 0

tactic: simp only [hμ, zero_mass]
state_before: Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ : FiniteMeasure Ω
hμ : μ = 0
⊢ mass μ = 0
Theorem: List.diff_cons
File: Std/Data/List/Lemmas.lean

tactic: simp [List.diff]
state_before: α : Type u_1
inst✝ : DecidableEq α
l₁ l₂ : List α
a : α
⊢ List.diff l₁ (a :: l₂) = List.diff (List.erase l₁ a) l₂

tactic: split <;> simp [*, erase_of_not_mem]
state_before: α : Type u_1
inst✝ : DecidableEq α
l₁ l₂ : List α
a : α
⊢ (if a ∈ l₁ then List.diff (List.erase l₁ a) l₂ else List.diff l₁ l₂) = List.diff (List.erase l₁ a) l₂
Theorem: pure_id_seq
File: src/lean/Init/Control/Lawful.lean

tactic: simp [pure_seq]
state_before: f : Type u_1 → Type u_2
α : Type u_1
inst✝¹ : Applicative f
inst✝ : LawfulApplicative f
x : f α
⊢ (Seq.seq (pure id) fun x_1 => x) = x
Theorem: CauSeq.of_near
File: Mathlib/Data/Real/CauSeq.lean

tactic: cases' hi _ le_rfl with h₁ h₂
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f : ℕ → β
g : CauSeq β abv
h : ∀ (ε : α), ε > 0 → ∃ i, ∀ (j : ℕ), j ≥ i → abv (f j - ↑g j) < ε
ε : α
ε0 : ε > 0
i : ℕ
hi : ∀ (j : ℕ), j ≥ i → abv (f j - ↑g j) < ε / 2 / 2 ∧ ∀ (k : ℕ), k ≥ j → abv (↑g k - ↑g j) < ε / 2
j : ℕ
ij : j ≥ i
⊢ abv (f j - f i) < ε

tactic: rw [abv_sub abv] at h₁
state_before: case intro
α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f : ℕ → β
g : CauSeq β abv
h : ∀ (ε : α), ε > 0 → ∃ i, ∀ (j : ℕ), j ≥ i → abv (f j - ↑g j) < ε
ε : α
ε0 : ε > 0
i : ℕ
hi : ∀ (j : ℕ), j ≥ i → abv (f j - ↑g j) < ε / 2 / 2 ∧ ∀ (k : ℕ), k ≥ j → abv (↑g k - ↑g j) < ε / 2
j : ℕ
ij : j ≥ i
h₁ : abv (f i - ↑g i) < ε / 2 / 2
h₂ : ∀ (k : ℕ), k ≥ i → abv (↑g k - ↑g i) < ε / 2
⊢ abv (f j - f i) < ε

tactic: have := lt_of_le_of_lt (abv_add abv _ _) (add_lt_add (hi _ ij).1 h₁)
state_before: case intro
α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f : ℕ → β
g : CauSeq β abv
h : ∀ (ε : α), ε > 0 → ∃ i, ∀ (j : ℕ), j ≥ i → abv (f j - ↑g j) < ε
ε : α
ε0 : ε > 0
i : ℕ
hi : ∀ (j : ℕ), j ≥ i → abv (f j - ↑g j) < ε / 2 / 2 ∧ ∀ (k : ℕ), k ≥ j → abv (↑g k - ↑g j) < ε / 2
j : ℕ
ij : j ≥ i
h₁ : abv (↑g i - f i) < ε / 2 / 2
h₂ : ∀ (k : ℕ), k ≥ i → abv (↑g k - ↑g i) < ε / 2
⊢ abv (f j - f i) < ε

tactic: have := lt_of_le_of_lt (abv_add abv _ _) (add_lt_add this (h₂ _ ij))
state_before: case intro
α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f : ℕ → β
g : CauSeq β abv
h : ∀ (ε : α), ε > 0 → ∃ i, ∀ (j : ℕ), j ≥ i → abv (f j - ↑g j) < ε
ε : α
ε0 : ε > 0
i : ℕ
hi : ∀ (j : ℕ), j ≥ i → abv (f j - ↑g j) < ε / 2 / 2 ∧ ∀ (k : ℕ), k ≥ j → abv (↑g k - ↑g j) < ε / 2
j : ℕ
ij : j ≥ i
h₁ : abv (↑g i - f i) < ε / 2 / 2
h₂ : ∀ (k : ℕ), k ≥ i → abv (↑g k - ↑g i) < ε / 2
this : abv (f j - ↑g j + (↑g i - f i)) < ε / 2 / 2 + ε / 2 / 2
⊢ abv (f j - f i) < ε

tactic: rwa [add_halves, add_halves, add_right_comm, sub_add_sub_cancel, sub_add_sub_cancel] at this
state_before: case intro
α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f : ℕ → β
g : CauSeq β abv
h : ∀ (ε : α), ε > 0 → ∃ i, ∀ (j : ℕ), j ≥ i → abv (f j - ↑g j) < ε
ε : α
ε0 : ε > 0
i : ℕ
hi : ∀ (j : ℕ), j ≥ i → abv (f j - ↑g j) < ε / 2 / 2 ∧ ∀ (k : ℕ), k ≥ j → abv (↑g k - ↑g j) < ε / 2
j : ℕ
ij : j ≥ i
h₁ : abv (↑g i - f i) < ε / 2 / 2
h₂ : ∀ (k : ℕ), k ≥ i → abv (↑g k - ↑g i) < ε / 2
this✝ : abv (f j - ↑g j + (↑g i - f i)) < ε / 2 / 2 + ε / 2 / 2
this : abv (f j - ↑g j + (↑g i - f i) + (↑g j - ↑g i)) < ε / 2 / 2 + ε / 2 / 2 + ε / 2
⊢ abv (f j - f i) < ε
Theorem: Pell.strictMono_x
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: have : xn a1 m ≤ xn a1 n :=
  Or.elim (lt_or_eq_of_le <| Nat.le_of_succ_le_succ h) (fun hl => le_of_lt <| strictMono_x hl)
    fun e => by rw [e]
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : m < n + 1
⊢ xn a1 m < xn a1 (n + 1)

tactic: simp
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : m < n + 1
this : xn a1 m ≤ xn a1 n
⊢ xn a1 m < xn a1 (n + 1)

tactic: refine' lt_of_lt_of_le (lt_of_le_of_lt this _) (Nat.le_add_right _ _)
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : m < n + 1
this : xn a1 m ≤ xn a1 n
⊢ xn a1 m < xn a1 n * a + Pell.d a1 * yn a1 n

tactic: have t := Nat.mul_lt_mul_of_pos_left a1 (x_pos a1 n)
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : m < n + 1
this : xn a1 m ≤ xn a1 n
⊢ xn a1 n < xn a1 n * a

tactic: rwa [mul_one] at t
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : m < n + 1
this : xn a1 m ≤ xn a1 n
t : xn a1 n * 1 < xn a1 n * a
⊢ xn a1 n < xn a1 n * a

tactic: rw [e]
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : m < n + 1
e : m = n
⊢ xn a1 m ≤ xn a1 n
Theorem: Matrix.dotProduct_vecMul_hadamard
File: Mathlib/Data/Matrix/Hadamard.lean

tactic: rw [← sum_hadamard_eq, Finset.sum_comm]
state_before: α : Type u_3
β : Type ?u.28934
γ : Type ?u.28937
m : Type u_1
n : Type u_2
R : Type ?u.28946
A B C : Matrix m n α
inst✝⁶ : Fintype m
inst✝⁵ : Fintype n
inst✝⁴ : Semiring α
inst✝³ : Semiring R
inst✝² : Module R α
inst✝¹ : DecidableEq m
inst✝ : DecidableEq n
v : m → α
w : n → α
⊢ vecMul v (A ⊙ B) ⬝ᵥ w = trace (diagonal v ⬝ A ⬝ (B ⬝ diagonal w)ᵀ)

tactic: simp [dotProduct, vecMul, Finset.sum_mul, mul_assoc]
state_before: α : Type u_3
β : Type ?u.28934
γ : Type ?u.28937
m : Type u_1
n : Type u_2
R : Type ?u.28946
A B C : Matrix m n α
inst✝⁶ : Fintype m
inst✝⁵ : Fintype n
inst✝⁴ : Semiring α
inst✝³ : Semiring R
inst✝² : Module R α
inst✝¹ : DecidableEq m
inst✝ : DecidableEq n
v : m → α
w : n → α
⊢ vecMul v (A ⊙ B) ⬝ᵥ w = ∑ y : n, ∑ x : m, ((diagonal v ⬝ A) ⊙ (B ⬝ diagonal w)) x y
Theorem: Prod.segment_subset
File: Mathlib/Analysis/Convex/Segment.lean

tactic: rintro z ⟨a, b, ha, hb, hab, hz⟩
state_before: 𝕜 : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.301724
ι : Type ?u.301727
π : ι → Type ?u.301732
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E × F
⊢ [x-[𝕜]y] ⊆ [x.fst-[𝕜]y.fst] ×ˢ [x.snd-[𝕜]y.snd]

tactic: exact ⟨⟨a, b, ha, hb, hab, congr_arg Prod.fst hz⟩, a, b, ha, hb, hab, congr_arg Prod.snd hz⟩
state_before: case intro.intro.intro.intro.intro
𝕜 : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.301724
ι : Type ?u.301727
π : ι → Type ?u.301732
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y z : E × F
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
hz : a • x + b • y = z
⊢ z ∈ [x.fst-[𝕜]y.fst] ×ˢ [x.snd-[𝕜]y.snd]
Theorem: TopologicalSpace.isTopologicalBasis_opens
File: Mathlib/Topology/Bases.lean

tactic: tauto
state_before: α : Type u
t : TopologicalSpace α
⊢ ∀ (u : Set α), u ∈ {U | IsOpen U} → IsOpen u

tactic: tauto
state_before: α : Type u
t : TopologicalSpace α
⊢ ∀ (a : α) (u : Set α), a ∈ u → IsOpen u → ∃ v, v ∈ {U | IsOpen U} ∧ a ∈ v ∧ v ⊆ u
Theorem: EuclideanGeometry.tan_angle_mul_dist_of_angle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [angle, ← inner_eq_zero_iff_angle_eq_pi_div_two, real_inner_comm, ← neg_eq_zero, ←
  inner_neg_left, neg_vsub_eq_vsub_rev] at h
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ∠ p₁ p₂ p₃ = π / 2
h0 : p₁ = p₂ ∨ p₃ ≠ p₂
⊢ Real.tan (∠ p₂ p₃ p₁) * dist p₃ p₂ = dist p₁ p₂

tactic: rw [ne_comm, ← @vsub_ne_zero V, ← @vsub_eq_zero_iff_eq V, or_comm] at h0
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : inner (p₂ -ᵥ p₃) (p₁ -ᵥ p₂) = 0
h0 : p₁ = p₂ ∨ p₃ ≠ p₂
⊢ Real.tan (∠ p₂ p₃ p₁) * dist p₃ p₂ = dist p₁ p₂

tactic: rw [angle, dist_eq_norm_vsub V p₁ p₂, dist_eq_norm_vsub' V p₃ p₂, ← vsub_add_vsub_cancel p₁ p₂ p₃,
  add_comm, tan_angle_add_mul_norm_of_inner_eq_zero h h0]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : inner (p₂ -ᵥ p₃) (p₁ -ᵥ p₂) = 0
h0 : p₂ -ᵥ p₃ ≠ 0 ∨ p₁ -ᵥ p₂ = 0
⊢ Real.tan (∠ p₂ p₃ p₁) * dist p₃ p₂ = dist p₁ p₂
Theorem: PowerSeries.coeff_one_X
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [coeff_X, if_pos rfl]
state_before: R : Type u_1
inst✝ : Semiring R
⊢ ↑(coeff R 1) X = 1
Theorem: iSup_inf_of_monotone
File: Mathlib/Order/CompleteBooleanAlgebra.lean

tactic: refine' (le_iSup_inf_iSup f g).antisymm _
state_before: α : Type u
β : Type v
ι✝ : Sort w
κ : ι✝ → Sort ?u.12298
inst✝² : Frame α
s t : Set α
a b : α
ι : Type u_1
inst✝¹ : Preorder ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
f g : ι → α
hf : Monotone f
hg : Monotone g
⊢ (⨆ (i : ι), f i ⊓ g i) = (⨆ (i : ι), f i) ⊓ ⨆ (i : ι), g i

tactic: rw [iSup_inf_iSup]
state_before: α : Type u
β : Type v
ι✝ : Sort w
κ : ι✝ → Sort ?u.12298
inst✝² : Frame α
s t : Set α
a b : α
ι : Type u_1
inst✝¹ : Preorder ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
f g : ι → α
hf : Monotone f
hg : Monotone g
⊢ ((⨆ (i : ι), f i) ⊓ ⨆ (i : ι), g i) ≤ ⨆ (i : ι), f i ⊓ g i

tactic: refine' iSup_mono' fun i => _
state_before: α : Type u
β : Type v
ι✝ : Sort w
κ : ι✝ → Sort ?u.12298
inst✝² : Frame α
s t : Set α
a b : α
ι : Type u_1
inst✝¹ : Preorder ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
f g : ι → α
hf : Monotone f
hg : Monotone g
⊢ (⨆ (i : ι × ι), f i.fst ⊓ g i.snd) ≤ ⨆ (i : ι), f i ⊓ g i

tactic: exact ⟨j, inf_le_inf (hf h₁) (hg h₂)⟩
state_before: case intro.intro
α : Type u
β : Type v
ι✝ : Sort w
κ : ι✝ → Sort ?u.12298
inst✝² : Frame α
s t : Set α
a b : α
ι : Type u_1
inst✝¹ : Preorder ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
f g : ι → α
hf : Monotone f
hg : Monotone g
i : ι × ι
j : ι
h₁ : i.fst ≤ j
h₂ : i.snd ≤ j
⊢ ∃ i', f i.fst ⊓ g i.snd ≤ f i' ⊓ g i'
Theorem: Polynomial.aeval_eq_sum_range'
File: Mathlib/Data/Polynomial/AlgebraMap.lean

tactic: simp_rw [Algebra.smul_def]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
A' : Type ?u.1288464
B' : Type ?u.1288467
a b : R
n✝ : ℕ
inst✝⁸ : CommSemiring A'
inst✝⁷ : Semiring B'
inst✝⁶ : CommSemiring R
p✝ q : R[X]
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
B : Type ?u.1288680
inst✝³ : Semiring B
inst✝² : Algebra R B
x✝ : A
inst✝¹ : Semiring S
f : R →+* S
inst✝ : Algebra R S
p : R[X]
n : ℕ
hn : natDegree p < n
x : S
⊢ ↑(aeval x) p = ∑ i in range n, coeff p i • x ^ i

tactic: exact eval₂_eq_sum_range' (algebraMap R S) hn x
state_before: R : Type u
S : Type v
T : Type w
A : Type z
A' : Type ?u.1288464
B' : Type ?u.1288467
a b : R
n✝ : ℕ
inst✝⁸ : CommSemiring A'
inst✝⁷ : Semiring B'
inst✝⁶ : CommSemiring R
p✝ q : R[X]
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
B : Type ?u.1288680
inst✝³ : Semiring B
inst✝² : Algebra R B
x✝ : A
inst✝¹ : Semiring S
f : R →+* S
inst✝ : Algebra R S
p : R[X]
n : ℕ
hn : natDegree p < n
x : S
⊢ ↑(aeval x) p = ∑ x_1 in range n, ↑(algebraMap R S) (coeff p x_1) * x ^ x_1