tasksource/leandojo huggingface dataset:
Theorem: Metric.tendstoLocallyUniformlyOn_iff
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: refine' ⟨fun H ε hε => H _ (dist_mem_uniformity hε), fun H u hu x hx => _⟩
state_before: α : Type u
β : Type v
X : Type ?u.79667
ι✝ : Type ?u.79670
inst✝¹ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s✝ : Set α
ι : Type u_1
inst✝ : TopologicalSpace β
F : ι → β → α
f : β → α
p : Filter ι
s : Set β
⊢ TendstoLocallyUniformlyOn F f p s ↔
    ∀ (ε : ℝ), ε > 0 → ∀ (x : β), x ∈ s → ∃ t, t ∈ 𝓝[s] x ∧ ∀ᶠ (n : ι) in p, ∀ (y : β), y ∈ t → dist (f y) (F n y) < ε

tactic: rcases mem_uniformity_dist.1 hu with ⟨ε, εpos, hε⟩
state_before: α : Type u
β : Type v
X : Type ?u.79667
ι✝ : Type ?u.79670
inst✝¹ : PseudoMetricSpace α
x✝ y z : α
δ ε ε₁ ε₂ : ℝ
s✝ : Set α
ι : Type u_1
inst✝ : TopologicalSpace β
F : ι → β → α
f : β → α
p : Filter ι
s : Set β
H : ∀ (ε : ℝ), ε > 0 → ∀ (x : β), x ∈ s → ∃ t, t ∈ 𝓝[s] x ∧ ∀ᶠ (n : ι) in p, ∀ (y : β), y ∈ t → dist (f y) (F n y) < ε
u : Set (α × α)
hu : u ∈ 𝓤 α
x : β
hx : x ∈ s
⊢ ∃ t, t ∈ 𝓝[s] x ∧ ∀ᶠ (n : ι) in p, ∀ (y : β), y ∈ t → (f y, F n y) ∈ u

tactic: rcases H ε εpos x hx with ⟨t, ht, Ht⟩
state_before: case intro.intro
α : Type u
β : Type v
X : Type ?u.79667
ι✝ : Type ?u.79670
inst✝¹ : PseudoMetricSpace α
x✝ y z : α
δ ε✝ ε₁ ε₂ : ℝ
s✝ : Set α
ι : Type u_1
inst✝ : TopologicalSpace β
F : ι → β → α
f : β → α
p : Filter ι
s : Set β
H : ∀ (ε : ℝ), ε > 0 → ∀ (x : β), x ∈ s → ∃ t, t ∈ 𝓝[s] x ∧ ∀ᶠ (n : ι) in p, ∀ (y : β), y ∈ t → dist (f y) (F n y) < ε
u : Set (α × α)
hu : u ∈ 𝓤 α
x : β
hx : x ∈ s
ε : ℝ
εpos : ε > 0
hε : ∀ {a b : α}, dist a b < ε → (a, b) ∈ u
⊢ ∃ t, t ∈ 𝓝[s] x ∧ ∀ᶠ (n : ι) in p, ∀ (y : β), y ∈ t → (f y, F n y) ∈ u

tactic: exact ⟨t, ht, Ht.mono fun n hs x hx => hε (hs x hx)⟩
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
X : Type ?u.79667
ι✝ : Type ?u.79670
inst✝¹ : PseudoMetricSpace α
x✝ y z : α
δ ε✝ ε₁ ε₂ : ℝ
s✝ : Set α
ι : Type u_1
inst✝ : TopologicalSpace β
F : ι → β → α
f : β → α
p : Filter ι
s : Set β
H : ∀ (ε : ℝ), ε > 0 → ∀ (x : β), x ∈ s → ∃ t, t ∈ 𝓝[s] x ∧ ∀ᶠ (n : ι) in p, ∀ (y : β), y ∈ t → dist (f y) (F n y) < ε
u : Set (α × α)
hu : u ∈ 𝓤 α
x : β
hx : x ∈ s
ε : ℝ
εpos : ε > 0
hε : ∀ {a b : α}, dist a b < ε → (a, b) ∈ u
t : Set β
ht : t ∈ 𝓝[s] x
Ht : ∀ᶠ (n : ι) in p, ∀ (y : β), y ∈ t → dist (f y) (F n y) < ε
⊢ ∃ t, t ∈ 𝓝[s] x ∧ ∀ᶠ (n : ι) in p, ∀ (y : β), y ∈ t → (f y, F n y) ∈ u
Theorem: coe_nat_mem
File: Mathlib/RingTheory/Subsemiring/Basic.lean

tactic: rw [← nsmul_one]
state_before: R : Type u
S : Type v
T : Type w
inst✝¹ : NonAssocSemiring R
M : Submonoid R
inst✝ : SetLike S R
hSR : SubsemiringClass S R
s : S
n : ℕ
⊢ ↑n ∈ s

tactic: exact nsmul_mem (one_mem _) _
state_before: R : Type u
S : Type v
T : Type w
inst✝¹ : NonAssocSemiring R
M : Submonoid R
inst✝ : SetLike S R
hSR : SubsemiringClass S R
s : S
n : ℕ
⊢ n • 1 ∈ s
Theorem: CategoryTheory.Sieve.functorPushforward_id
File: Mathlib/CategoryTheory/Sites/Sieves.lean

tactic: ext X
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
S R✝ : Sieve X
E : Type u₃
inst✝ : Category E
G : D ⥤ E
R : Sieve X
⊢ functorPushforward (𝟭 C) R = R

tactic: intro f
state_before: case h
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X✝ Y Z : C
f : Y ⟶ X✝
S R✝ : Sieve X✝
E : Type u₃
inst✝ : Category E
G : D ⥤ E
R : Sieve X✝
X : C
⊢ ∀ (f : X ⟶ (𝟭 C).obj X✝), (functorPushforward (𝟭 C) R).arrows f ↔ R.arrows f

tactic: constructor
state_before: case h
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X✝ Y Z : C
f✝ : Y ⟶ X✝
S R✝ : Sieve X✝
E : Type u₃
inst✝ : Category E
G : D ⥤ E
R : Sieve X✝
X : C
f : X ⟶ (𝟭 C).obj X✝
⊢ (functorPushforward (𝟭 C) R).arrows f ↔ R.arrows f

tactic: intro hf
state_before: case h.mp
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X✝ Y Z : C
f✝ : Y ⟶ X✝
S R✝ : Sieve X✝
E : Type u₃
inst✝ : Category E
G : D ⥤ E
R : Sieve X✝
X : C
f : X ⟶ (𝟭 C).obj X✝
⊢ (functorPushforward (𝟭 C) R).arrows f → R.arrows f

tactic: obtain ⟨X, g, h, hg, rfl⟩ := hf
state_before: case h.mp
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X✝ Y Z : C
f✝ : Y ⟶ X✝
S R✝ : Sieve X✝
E : Type u₃
inst✝ : Category E
G : D ⥤ E
R : Sieve X✝
X : C
f : X ⟶ (𝟭 C).obj X✝
hf : (functorPushforward (𝟭 C) R).arrows f
⊢ R.arrows f

tactic: exact R.downward_closed hg h
state_before: case h.mp.intro.intro.intro.intro
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X✝¹ Y Z : C
f : Y ⟶ X✝¹
S R✝ : Sieve X✝¹
E : Type u₃
inst✝ : Category E
G : D ⥤ E
R : Sieve X✝¹
X✝ X : C
g : X ⟶ X✝¹
h : X✝ ⟶ (𝟭 C).obj X
hg : R.arrows g
⊢ R.arrows (h ≫ (𝟭 C).map g)

tactic: intro hf
state_before: case h.mpr
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X✝ Y Z : C
f✝ : Y ⟶ X✝
S R✝ : Sieve X✝
E : Type u₃
inst✝ : Category E
G : D ⥤ E
R : Sieve X✝
X : C
f : X ⟶ (𝟭 C).obj X✝
⊢ R.arrows f → (functorPushforward (𝟭 C) R).arrows f

tactic: exact ⟨X, f, 𝟙 _, hf, by simp⟩
state_before: case h.mpr
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X✝ Y Z : C
f✝ : Y ⟶ X✝
S R✝ : Sieve X✝
E : Type u₃
inst✝ : Category E
G : D ⥤ E
R : Sieve X✝
X : C
f : X ⟶ (𝟭 C).obj X✝
hf : R.arrows f
⊢ (functorPushforward (𝟭 C) R).arrows f

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X✝ Y Z : C
f✝ : Y ⟶ X✝
S R✝ : Sieve X✝
E : Type u₃
inst✝ : Category E
G : D ⥤ E
R : Sieve X✝
X : C
f : X ⟶ (𝟭 C).obj X✝
hf : R.arrows f
⊢ f = 𝟙 X ≫ (𝟭 C).map f
Theorem: PowerSeries.coeff_X_pow_mul
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [coeff_mul, Finset.sum_eq_single (n, d), coeff_X_pow, if_pos rfl, one_mul]
state_before: R : Type u_1
inst✝ : Semiring R
p : PowerSeries R
n d : ℕ
⊢ ↑(coeff R (d + n)) (X ^ n * p) = ↑(coeff R d) p

tactic: rintro ⟨i, j⟩ h1 h2
state_before: case h₀
R : Type u_1
inst✝ : Semiring R
p : PowerSeries R
n d : ℕ
⊢ ∀ (b : ℕ × ℕ), b ∈ Finset.Nat.antidiagonal (d + n) → b ≠ (n, d) → ↑(coeff R b.fst) (X ^ n) * ↑(coeff R b.snd) p = 0

tactic: rw [coeff_X_pow, if_neg, MulZeroClass.zero_mul]
state_before: case h₀.mk
R : Type u_1
inst✝ : Semiring R
p : PowerSeries R
n d i j : ℕ
h1 : (i, j) ∈ Finset.Nat.antidiagonal (d + n)
h2 : (i, j) ≠ (n, d)
⊢ ↑(coeff R (i, j).fst) (X ^ n) * ↑(coeff R (i, j).snd) p = 0

tactic: rintro rfl
state_before: case h₀.mk.hnc
R : Type u_1
inst✝ : Semiring R
p : PowerSeries R
n d i j : ℕ
h1 : (i, j) ∈ Finset.Nat.antidiagonal (d + n)
h2 : (i, j) ≠ (n, d)
⊢ ¬(i, j).fst = n

tactic: apply h2
state_before: case h₀.mk.hnc
R : Type u_1
inst✝ : Semiring R
p : PowerSeries R
d i j : ℕ
h1 : (i, j) ∈ Finset.Nat.antidiagonal (d + (i, j).fst)
h2 : (i, j) ≠ ((i, j).fst, d)
⊢ False

tactic: rw [Finset.Nat.mem_antidiagonal, add_comm, add_right_cancel_iff] at h1
state_before: case h₀.mk.hnc
R : Type u_1
inst✝ : Semiring R
p : PowerSeries R
d i j : ℕ
h1 : (i, j) ∈ Finset.Nat.antidiagonal (d + (i, j).fst)
h2 : (i, j) ≠ ((i, j).fst, d)
⊢ (i, j) = ((i, j).fst, d)

tactic: subst h1
state_before: case h₀.mk.hnc
R : Type u_1
inst✝ : Semiring R
p : PowerSeries R
d i j : ℕ
h1 : (i, j).snd = d
h2 : (i, j) ≠ ((i, j).fst, d)
⊢ (i, j) = ((i, j).fst, d)

tactic: rfl
state_before: case h₀.mk.hnc
R : Type u_1
inst✝ : Semiring R
p : PowerSeries R
i j : ℕ
h2 : (i, j) ≠ ((i, j).fst, (i, j).snd)
⊢ (i, j) = ((i, j).fst, (i, j).snd)

tactic: rw [add_comm]
state_before: case h₁
R : Type u_1
inst✝ : Semiring R
p : PowerSeries R
n d : ℕ
⊢ ¬(n, d) ∈ Finset.Nat.antidiagonal (d + n) → ↑(coeff R (n, d).fst) (X ^ n) * ↑(coeff R (n, d).snd) p = 0

tactic: exact fun h1 => (h1 (Finset.Nat.mem_antidiagonal.2 rfl)).elim
state_before: case h₁
R : Type u_1
inst✝ : Semiring R
p : PowerSeries R
n d : ℕ
⊢ ¬(n, d) ∈ Finset.Nat.antidiagonal (n + d) → ↑(coeff R (n, d).fst) (X ^ n) * ↑(coeff R (n, d).snd) p = 0
Theorem: Cardinal.lt_aleph0
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rcases lt_lift_iff.1 h with ⟨c, rfl, h'⟩
state_before: α β : Type u
c : Cardinal
h : c < ℵ₀
⊢ ∃ n, c = ↑n

tactic: rcases le_mk_iff_exists_set.1 h'.1 with ⟨S, rfl⟩
state_before: case intro.intro
α β : Type u
c : Cardinal
h' : c < (#ℕ)
h : lift c < ℵ₀
⊢ ∃ n, lift c = ↑n

tactic: suffices S.Finite by
  lift S to Finset ℕ using this
  simp
state_before: case intro.intro.intro
α β : Type u
S : Set ℕ
h' : (#↑S) < (#ℕ)
h : lift (#↑S) < ℵ₀
⊢ ∃ n, lift (#↑S) = ↑n

tactic: contrapose! h'
state_before: case intro.intro.intro
α β : Type u
S : Set ℕ
h' : (#↑S) < (#ℕ)
h : lift (#↑S) < ℵ₀
⊢ Set.Finite S

tactic: haveI := Infinite.to_subtype h'
state_before: case intro.intro.intro
α β : Type u
S : Set ℕ
h : lift (#↑S) < ℵ₀
h' : ¬Set.Finite S
⊢ (#ℕ) ≤ (#↑S)

tactic: exact ⟨Infinite.natEmbedding S⟩
state_before: case intro.intro.intro
α β : Type u
S : Set ℕ
h : lift (#↑S) < ℵ₀
h' : ¬Set.Finite S
this : Infinite ↑S
⊢ (#ℕ) ≤ (#↑S)

tactic: lift S to Finset ℕ using this
state_before: α β : Type u
S : Set ℕ
h' : (#↑S) < (#ℕ)
h : lift (#↑S) < ℵ₀
this : Set.Finite S
⊢ ∃ n, lift (#↑S) = ↑n

tactic: simp
state_before: case intro
α β : Type u
S : Finset ℕ
h' : (#↑↑S) < (#ℕ)
h : lift (#↑↑S) < ℵ₀
⊢ ∃ n, lift (#↑↑S) = ↑n
Theorem: mem_selfAdjointMatricesSubmodule'
File: Mathlib/LinearAlgebra/Matrix/BilinearForm.lean

tactic: simp only [mem_selfAdjointMatricesSubmodule]
state_before: R : Type ?u.2697796
M : Type ?u.2697799
inst✝¹⁶ : Semiring R
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : Module R M
R₁ : Type ?u.2697835
M₁ : Type ?u.2697838
inst✝¹³ : Ring R₁
inst✝¹² : AddCommGroup M₁
inst✝¹¹ : Module R₁ M₁
R₂ : Type ?u.2698447
M₂ : Type ?u.2698450
inst✝¹⁰ : CommSemiring R₂
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : Module R₂ M₂
R₃ : Type u_1
M₃ : Type ?u.2698640
inst✝⁷ : CommRing R₃
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : Module R₃ M₃
V : Type ?u.2699228
K : Type ?u.2699231
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_2
inst✝¹ : Fintype n
b : Basis n R₃ M₃
J J₃ A A' : Matrix n n R₃
inst✝ : DecidableEq n
⊢ A ∈ selfAdjointMatricesSubmodule J ↔ Matrix.IsSelfAdjoint J A
Theorem: Set.Finite.dependent_image
File: Mathlib/Data/Set/Finite.lean

tactic: cases hs
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
hs : Set.Finite s
F : (i : α) → i ∈ s → β
⊢ Set.Finite {y | ∃ x hx, y = F x hx}

tactic: simpa [range, eq_comm] using finite_range fun x : s => F x x.2
state_before: case intro
α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
F : (i : α) → i ∈ s → β
a✝ : Fintype ↑s
⊢ Set.Finite {y | ∃ x hx, y = F x hx}
Theorem: LinearMap.IsProj.codRestrict_apply_cod
File: Mathlib/LinearAlgebra/Projection.lean

tactic: ext
state_before: R : Type ?u.438555
inst✝⁹ : Ring R
E : Type ?u.438561
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type ?u.439120
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type ?u.439636
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type u_1
inst✝² : Semiring S
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
f : M →ₗ[S] M
h : IsProj m f
x : { x // x ∈ m }
⊢ ↑(codRestrict h) ↑x = x

tactic: rw [codRestrict_apply]
state_before: case a
R : Type ?u.438555
inst✝⁹ : Ring R
E : Type ?u.438561
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type ?u.439120
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type ?u.439636
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type u_1
inst✝² : Semiring S
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
f : M →ₗ[S] M
h : IsProj m f
x : { x // x ∈ m }
⊢ ↑(↑(codRestrict h) ↑x) = ↑x

tactic: exact h.map_id x x.2
state_before: case a
R : Type ?u.438555
inst✝⁹ : Ring R
E : Type ?u.438561
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type ?u.439120
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type ?u.439636
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type u_1
inst✝² : Semiring S
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
f : M →ₗ[S] M
h : IsProj m f
x : { x // x ∈ m }
⊢ ↑f ↑x = ↑x
Theorem: IsStrongAntichain.image
File: Mathlib/Order/Antichain.lean

tactic: rintro _ ⟨a, ha, rfl⟩ _ ⟨b, hb, rfl⟩ hab c
state_before: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
r' : β → β → Prop
s t : Set α
a b : α
hs : IsStrongAntichain r s
f : α → β
hf : Surjective f
h : ∀ (a b : α), r' (f a) (f b) → r a b
⊢ IsStrongAntichain r' (f '' s)

tactic: obtain ⟨c, rfl⟩ := hf c
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
r' : β → β → Prop
s t : Set α
a✝ b✝ : α
hs : IsStrongAntichain r s
f : α → β
hf : Surjective f
h : ∀ (a b : α), r' (f a) (f b) → r a b
a : α
ha : a ∈ s
b : α
hb : b ∈ s
hab : f a ≠ f b
c : β
⊢ ¬r' (f a) c ∨ ¬r' (f b) c

tactic: exact (hs ha hb (ne_of_apply_ne _ hab) _).imp (mt <| h _ _) (mt <| h _ _)
state_before: case intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
r' : β → β → Prop
s t : Set α
a✝ b✝ : α
hs : IsStrongAntichain r s
f : α → β
hf : Surjective f
h : ∀ (a b : α), r' (f a) (f b) → r a b
a : α
ha : a ∈ s
b : α
hb : b ∈ s
hab : f a ≠ f b
c : α
⊢ ¬r' (f a) (f c) ∨ ¬r' (f b) (f c)
Theorem: split_by_characteristic
File: Mathlib/Algebra/CharP/MixedCharZero.lean

tactic: by_cases p = 0
state_before: case intro
R : Type u_1
inst✝ : CommRing R
P : Prop
h_pos : ∀ (p : ℕ), p ≠ 0 → CharP R p → P
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
p : ℕ
p_charP : CharP R p
⊢ P

tactic: rw [h] at p_charP
state_before: case pos
R : Type u_1
inst✝ : CommRing R
P : Prop
h_pos : ∀ (p : ℕ), p ≠ 0 → CharP R p → P
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
p : ℕ
p_charP : CharP R p
h : p = 0
⊢ P

tactic: haveI h0 : CharZero R := CharP.charP_to_charZero R
state_before: case pos
R : Type u_1
inst✝ : CommRing R
P : Prop
h_pos : ∀ (p : ℕ), p ≠ 0 → CharP R p → P
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
p : ℕ
p_charP : CharP R 0
h : p = 0
⊢ P

tactic: exact split_equalCharZero_mixedCharZero R h_equal h_mixed
state_before: case pos
R : Type u_1
inst✝ : CommRing R
P : Prop
h_pos : ∀ (p : ℕ), p ≠ 0 → CharP R p → P
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
p : ℕ
p_charP : CharP R 0
h : p = 0
h0 : CharZero R
⊢ P

tactic: exact h_pos p h p_charP
state_before: case neg
R : Type u_1
inst✝ : CommRing R
P : Prop
h_pos : ∀ (p : ℕ), p ≠ 0 → CharP R p → P
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
p : ℕ
p_charP : CharP R p
h : ¬p = 0
⊢ P
Theorem: Real.log_div_self_antitoneOn
File: Mathlib/Analysis/SpecialFunctions/Log/Monotone.lean

tactic: simp only [AntitoneOn, mem_setOf_eq]
state_before: x y : ℝ
⊢ AntitoneOn (fun x => log x / x) {x | exp 1 ≤ x}

tactic: intro x hex y hey hxy
state_before: x y : ℝ
⊢ ∀ ⦃a : ℝ⦄, exp 1 ≤ a → ∀ ⦃b : ℝ⦄, exp 1 ≤ b → a ≤ b → log b / b ≤ log a / a

tactic: have x_pos : 0 < x := (exp_pos 1).trans_le hex
state_before: x✝ y✝ x : ℝ
hex : exp 1 ≤ x
y : ℝ
hey : exp 1 ≤ y
hxy : x ≤ y
⊢ log y / y ≤ log x / x

tactic: have y_pos : 0 < y := (exp_pos 1).trans_le hey
state_before: x✝ y✝ x : ℝ
hex : exp 1 ≤ x
y : ℝ
hey : exp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
⊢ log y / y ≤ log x / x

tactic: have hlogx : 1 ≤ log x := by rwa [le_log_iff_exp_le x_pos]
state_before: x✝ y✝ x : ℝ
hex : exp 1 ≤ x
y : ℝ
hey : exp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
⊢ log y / y ≤ log x / x

tactic: have hyx : 0 ≤ y / x - 1 := by rwa [le_sub_iff_add_le, le_div_iff x_pos, zero_add, one_mul]
state_before: x✝ y✝ x : ℝ
hex : exp 1 ≤ x
y : ℝ
hey : exp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
hlogx : 1 ≤ log x
⊢ log y / y ≤ log x / x

tactic: rw [div_le_iff y_pos, ← sub_le_sub_iff_right (log x)]
state_before: x✝ y✝ x : ℝ
hex : exp 1 ≤ x
y : ℝ
hey : exp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
hlogx : 1 ≤ log x
hyx : 0 ≤ y / x - 1
⊢ log y / y ≤ log x / x

tactic: calc
  log y - log x = log (y / x) := by rw [log_div y_pos.ne' x_pos.ne']
  _ ≤ y / x - 1 := (log_le_sub_one_of_pos (div_pos y_pos x_pos))
  _ ≤ log x * (y / x - 1) := (le_mul_of_one_le_left hyx hlogx)
  _ = log x / x * y - log x := by ring
state_before: x✝ y✝ x : ℝ
hex : exp 1 ≤ x
y : ℝ
hey : exp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
hlogx : 1 ≤ log x
hyx : 0 ≤ y / x - 1
⊢ log y - log x ≤ log x / x * y - log x

tactic: rwa [le_log_iff_exp_le x_pos]
state_before: x✝ y✝ x : ℝ
hex : exp 1 ≤ x
y : ℝ
hey : exp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
⊢ 1 ≤ log x

tactic: rwa [le_sub_iff_add_le, le_div_iff x_pos, zero_add, one_mul]
state_before: x✝ y✝ x : ℝ
hex : exp 1 ≤ x
y : ℝ
hey : exp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
hlogx : 1 ≤ log x
⊢ 0 ≤ y / x - 1

tactic: rw [log_div y_pos.ne' x_pos.ne']
state_before: x✝ y✝ x : ℝ
hex : exp 1 ≤ x
y : ℝ
hey : exp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
hlogx : 1 ≤ log x
hyx : 0 ≤ y / x - 1
⊢ log y - log x = log (y / x)

tactic: ring
state_before: x✝ y✝ x : ℝ
hex : exp 1 ≤ x
y : ℝ
hey : exp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
hlogx : 1 ≤ log x
hyx : 0 ≤ y / x - 1
⊢ log x * (y / x - 1) = log x / x * y - log x
Theorem: Matrix.circulant_single
File: Mathlib/LinearAlgebra/Matrix/Circulant.lean

tactic: ext (i j)
state_before: α : Type u_2
β : Type ?u.43737
m : Type ?u.43740
n✝ : Type ?u.43743
R : Type ?u.43746
n : Type u_1
inst✝³ : Semiring α
inst✝² : DecidableEq n
inst✝¹ : AddGroup n
inst✝ : Fintype n
a : α
⊢ circulant (Pi.single 0 a) = ↑(scalar n) a

tactic: simp [Pi.single_apply, one_apply, sub_eq_zero]
state_before: case a.h
α : Type u_2
β : Type ?u.43737
m : Type ?u.43740
n✝ : Type ?u.43743
R : Type ?u.43746
n : Type u_1
inst✝³ : Semiring α
inst✝² : DecidableEq n
inst✝¹ : AddGroup n
inst✝ : Fintype n
a : α
i j : n
⊢ circulant (Pi.single 0 a) i j = ↑(scalar n) a i j
Theorem: hasFDerivAt_iff_isLittleO_nhds_zero
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: rw [HasFDerivAt, HasFDerivAtFilter, ← map_add_left_nhds_zero x, isLittleO_map]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.123977
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.124072
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
⊢ HasFDerivAt f f' x ↔ (fun h => f (x + h) - f x - ↑f' h) =o[𝓝 0] fun h => h
Theorem: Nat.even_add
File: Mathlib/Data/Nat/Parity.lean

tactic: cases' mod_two_eq_zero_or_one m with h₁ h₁ <;> cases' mod_two_eq_zero_or_one n with h₂ h₂ <;>
  simp [even_iff, h₁, h₂, Nat.add_mod]
state_before: m n : ℕ
⊢ Even (m + n) ↔ (Even m ↔ Even n)
Theorem: Finset.filter_ge_eq_Iic
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: ext
state_before: ι : Type ?u.69349
α : Type u_1
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrderBot α
a : α
inst✝¹ : Fintype α
inst✝ : DecidablePred fun x => x ≤ a
⊢ filter (fun x => x ≤ a) univ = Iic a

tactic: simp
state_before: case a
ι : Type ?u.69349
α : Type u_1
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrderBot α
a : α
inst✝¹ : Fintype α
inst✝ : DecidablePred fun x => x ≤ a
a✝ : α
⊢ a✝ ∈ filter (fun x => x ≤ a) univ ↔ a✝ ∈ Iic a
Theorem: DifferentiableWithinAt.mono
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: rcases h with ⟨f', hf'⟩
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.296026
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.296121
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : DifferentiableWithinAt 𝕜 f t x
st : s ⊆ t
⊢ DifferentiableWithinAt 𝕜 f s x

tactic: exact ⟨f', hf'.mono st⟩
state_before: case intro
𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.296026
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.296121
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
st : s ⊆ t
f' : E →L[𝕜] F
hf' : HasFDerivWithinAt f f' t x
⊢ DifferentiableWithinAt 𝕜 f s x
Theorem: FiniteDimensional.exists_relation_sum_zero_pos_coefficient_of_rank_succ_lt_card
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: obtain ⟨f, sum, total, nonzero⟩ := exists_nontrivial_relation_sum_zero_of_rank_succ_lt_card h
state_before: K : Type u
V : Type v
inst✝⁸ : DivisionRing K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
V₂ : Type v'
inst✝⁵ : AddCommGroup V₂
inst✝⁴ : Module K V₂
L : Type u_1
inst✝³ : LinearOrderedField L
W : Type v
inst✝² : AddCommGroup W
inst✝¹ : Module L W
inst✝ : FiniteDimensional L W
t : Finset W
h : finrank L W + 1 < card t
⊢ ∃ f, ∑ e in t, f e • e = 0 ∧ ∑ e in t, f e = 0 ∧ ∃ x, x ∈ t ∧ 0 < f x

tactic: exact ⟨f, sum, total, exists_pos_of_sum_zero_of_exists_nonzero f total nonzero⟩
state_before: case intro.intro.intro
K : Type u
V : Type v
inst✝⁸ : DivisionRing K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
V₂ : Type v'
inst✝⁵ : AddCommGroup V₂
inst✝⁴ : Module K V₂
L : Type u_1
inst✝³ : LinearOrderedField L
W : Type v
inst✝² : AddCommGroup W
inst✝¹ : Module L W
inst✝ : FiniteDimensional L W
t : Finset W
h : finrank L W + 1 < card t
f : W → L
sum : ∑ e in t, f e • e = 0
total : ∑ e in t, f e = 0
nonzero : ∃ x, x ∈ t ∧ f x ≠ 0
⊢ ∃ f, ∑ e in t, f e • e = 0 ∧ ∑ e in t, f e = 0 ∧ ∃ x, x ∈ t ∧ 0 < f x
Theorem: sum_geometric_two_le
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: have : ∀ i, 0 ≤ (1 / (2 : ℝ)) ^ i := by
  intro i
  apply pow_nonneg
  norm_num
state_before: α : Type ?u.79820
β : Type ?u.79823
ι : Type ?u.79826
n : ℕ
⊢ ∑ i in Finset.range n, (1 / 2) ^ i ≤ 2

tactic: convert sum_le_tsum (range n) (fun i _ => this i) summable_geometric_two
state_before: α : Type ?u.79820
β : Type ?u.79823
ι : Type ?u.79826
n : ℕ
this : ∀ (i : ℕ), 0 ≤ (1 / 2) ^ i
⊢ ∑ i in Finset.range n, (1 / 2) ^ i ≤ 2

tactic: exact tsum_geometric_two.symm
state_before: case h.e'_4
α : Type ?u.79820
β : Type ?u.79823
ι : Type ?u.79826
n : ℕ
this : ∀ (i : ℕ), 0 ≤ (1 / 2) ^ i
⊢ 2 = ∑' (i : ℕ), (1 / 2) ^ i

tactic: intro i
state_before: α : Type ?u.79820
β : Type ?u.79823
ι : Type ?u.79826
n : ℕ
⊢ ∀ (i : ℕ), 0 ≤ (1 / 2) ^ i

tactic: apply pow_nonneg
state_before: α : Type ?u.79820
β : Type ?u.79823
ι : Type ?u.79826
n i : ℕ
⊢ 0 ≤ (1 / 2) ^ i

tactic: norm_num
state_before: case H
α : Type ?u.79820
β : Type ?u.79823
ι : Type ?u.79826
n i : ℕ
⊢ 0 ≤ 1 / 2
Theorem: continuousAt_zpow₀
File: Mathlib/Topology/Algebra/GroupWithZero.lean

tactic: cases' m with m m
state_before: α : Type ?u.63846
β : Type ?u.63849
G₀ : Type u_1
inst✝³ : GroupWithZero G₀
inst✝² : TopologicalSpace G₀
inst✝¹ : HasContinuousInv₀ G₀
inst✝ : ContinuousMul G₀
x : G₀
m : ℤ
h : x ≠ 0 ∨ 0 ≤ m
⊢ ContinuousAt (fun x => x ^ m) x

tactic: simpa only [Int.ofNat_eq_coe, zpow_coe_nat] using continuousAt_pow x m
state_before: case ofNat
α : Type ?u.63846
β : Type ?u.63849
G₀ : Type u_1
inst✝³ : GroupWithZero G₀
inst✝² : TopologicalSpace G₀
inst✝¹ : HasContinuousInv₀ G₀
inst✝ : ContinuousMul G₀
x : G₀
m : ℕ
h : x ≠ 0 ∨ 0 ≤ Int.ofNat m
⊢ ContinuousAt (fun x => x ^ Int.ofNat m) x

tactic: simp only [zpow_negSucc]
state_before: case negSucc
α : Type ?u.63846
β : Type ?u.63849
G₀ : Type u_1
inst✝³ : GroupWithZero G₀
inst✝² : TopologicalSpace G₀
inst✝¹ : HasContinuousInv₀ G₀
inst✝ : ContinuousMul G₀
x : G₀
m : ℕ
h : x ≠ 0 ∨ 0 ≤ Int.negSucc m
⊢ ContinuousAt (fun x => x ^ Int.negSucc m) x

tactic: have hx : x ≠ 0 := h.resolve_right (Int.negSucc_lt_zero m).not_le
state_before: case negSucc
α : Type ?u.63846
β : Type ?u.63849
G₀ : Type u_1
inst✝³ : GroupWithZero G₀
inst✝² : TopologicalSpace G₀
inst✝¹ : HasContinuousInv₀ G₀
inst✝ : ContinuousMul G₀
x : G₀
m : ℕ
h : x ≠ 0 ∨ 0 ≤ Int.negSucc m
⊢ ContinuousAt (fun x => (x ^ (m + 1))⁻¹) x

tactic: exact (continuousAt_pow x (m + 1)).inv₀ (pow_ne_zero _ hx)
state_before: case negSucc
α : Type ?u.63846
β : Type ?u.63849
G₀ : Type u_1
inst✝³ : GroupWithZero G₀
inst✝² : TopologicalSpace G₀
inst✝¹ : HasContinuousInv₀ G₀
inst✝ : ContinuousMul G₀
x : G₀
m : ℕ
h : x ≠ 0 ∨ 0 ≤ Int.negSucc m
hx : x ≠ 0
⊢ ContinuousAt (fun x => (x ^ (m + 1))⁻¹) x