tasksource/leandojo huggingface dataset:
Theorem: List.map_congr
File: Mathlib/Data/List/Basic.lean

tactic: let ⟨h₁, h₂⟩ := forall_mem_cons.1 h
state_before: ι : Type ?u.130134
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f g : α → β
a : α
l : List α
h : ∀ (x : α), x ∈ a :: l → f x = g x
⊢ map f (a :: l) = map g (a :: l)

tactic: rw [map, map, h₁, map_congr h₂]
state_before: ι : Type ?u.130134
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f g : α → β
a : α
l : List α
h : ∀ (x : α), x ∈ a :: l → f x = g x
h₁ : f a = g a
h₂ : ∀ (x : α), x ∈ l → f x = g x
⊢ map f (a :: l) = map g (a :: l)
Theorem: Fin.one_succAbove_succ
File: Mathlib/Data/Fin/Basic.lean

tactic: have := succ_succAbove_succ 0 j
state_before: n✝ m n : ℕ
j : Fin n
⊢ ↑(succAbove 1) (succ j) = succ (succ j)

tactic: rwa [succ_zero_eq_one, zero_succAbove] at this
state_before: n✝ m n : ℕ
j : Fin n
this : ↑(succAbove (succ 0)) (succ j) = succ (↑(succAbove 0) j)
⊢ ↑(succAbove 1) (succ j) = succ (succ j)
Theorem: TFAE_mem_nhdsWithin_Iic
File: Mathlib/Topology/Order/Basic.lean

tactic: simpa only [exists_prop, OrderDual.exists, dual_Ici, dual_Ioc, dual_Icc, dual_Ico] using
  TFAE_mem_nhdsWithin_Ici h.dual (ofDual ⁻¹' s)
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a b : α
h : a < b
s : Set α
⊢ TFAE
    [s ∈ 𝓝[Iic b] b, s ∈ 𝓝[Icc a b] b, s ∈ 𝓝[Ioc a b] b, ∃ l, l ∈ Ico a b ∧ Ioc l b ⊆ s, ∃ l, l ∈ Iio b ∧ Ioc l b ⊆ s]
Theorem: top_himp
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [le_himp_iff, inf_top_eq]
state_before: ι : Type ?u.29794
α : Type u_1
β : Type ?u.29800
inst✝ : GeneralizedHeytingAlgebra α
a b✝ c d b : α
⊢ b ≤ ⊤ ⇨ a ↔ b ≤ a
Theorem: Multiset.mem_disjSum
File: Mathlib/Data/Multiset/Sum.lean

tactic: simp_rw [disjSum, mem_add, mem_map]
state_before: α : Type u_1
β : Type u_2
s : Multiset α
t : Multiset β
s₁ s₂ : Multiset α
t₁ t₂ : Multiset β
a : α
b : β
x : α ⊕ β
⊢ x ∈ disjSum s t ↔ (∃ a, a ∈ s ∧ inl a = x) ∨ ∃ b, b ∈ t ∧ inr b = x
Theorem: Real.le_def'
File: Mathlib/Data/Real/Basic.lean

tactic: rw [le_def]
state_before: x✝ y✝ x y : ℝ
⊢ Real.le x y ↔ x < y ∨ x = y
Theorem: CategoryTheory.Limits.IsZero.iff_id_eq_zero
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

tactic: rw [← id_comp f, ← id_comp (0: X ⟶ Y), h, zero_comp, zero_comp]
state_before: C : Type u
inst✝² : Category C
D : Type u'
inst✝¹ : Category D
inst✝ : HasZeroMorphisms C
X : C
h : 𝟙 X = 0
Y : C
f : X ⟶ Y
⊢ f = default

tactic: simp only
state_before: C : Type u
inst✝² : Category C
D : Type u'
inst✝¹ : Category D
inst✝ : HasZeroMorphisms C
X : C
h : 𝟙 X = 0
Y : C
f : X ⟶ Y
⊢ 0 = default

tactic: rw [← comp_id f, ← comp_id (0 : Y ⟶  X), h, comp_zero, comp_zero]
state_before: C : Type u
inst✝² : Category C
D : Type u'
inst✝¹ : Category D
inst✝ : HasZeroMorphisms C
X : C
h : 𝟙 X = 0
Y : C
f : Y ⟶ X
⊢ f = default

tactic: simp only
state_before: C : Type u
inst✝² : Category C
D : Type u'
inst✝¹ : Category D
inst✝ : HasZeroMorphisms C
X : C
h : 𝟙 X = 0
Y : C
f : Y ⟶ X
⊢ 0 = default
Theorem: MeasureTheory.AEEqFun.comp_toGerm
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

tactic: simp
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.444612
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
g : β → γ
hg : Continuous g
f✝ : α →ₘ[μ] β
f : α → β
x✝ : AEStronglyMeasurable f μ
⊢ toGerm (comp g hg (mk f x✝)) = Germ.map g (toGerm (mk f x✝))
Theorem: pow_sub_of_lt
File: Mathlib/Algebra/GroupWithZero/Power.lean

tactic: obtain rfl | ha := eq_or_ne a 0
state_before: G₀ : Type u_1
inst✝ : GroupWithZero G₀
a✝ : G₀
m✝ n✝ : ℕ
a : G₀
m n : ℕ
h : n < m
⊢ a ^ (m - n) = a ^ m * (a ^ n)⁻¹

tactic: rw [zero_pow (tsub_pos_of_lt h), zero_pow (n.zero_le.trans_lt h), zero_mul]
state_before: case inl
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a : G₀
m✝ n✝ m n : ℕ
h : n < m
⊢ 0 ^ (m - n) = 0 ^ m * (0 ^ n)⁻¹

tactic: exact pow_sub₀ _ ha h.le
state_before: case inr
G₀ : Type u_1
inst✝ : GroupWithZero G₀
a✝ : G₀
m✝ n✝ : ℕ
a : G₀
m n : ℕ
h : n < m
ha : a ≠ 0
⊢ a ^ (m - n) = a ^ m * (a ^ n)⁻¹
Theorem: Filter.HasBasis.uniformity_of_nhds_one
File: Mathlib/Topology/Algebra/UniformGroup.lean

tactic: rw [uniformity_eq_comap_nhds_one]
state_before: α : Type u_2
β : Type ?u.173356
inst✝² : UniformSpace α
inst✝¹ : Group α
inst✝ : UniformGroup α
ι : Sort u_1
p : ι → Prop
U : ι → Set α
h : HasBasis (𝓝 1) p U
⊢ HasBasis (𝓤 α) p fun i => {x | x.snd / x.fst ∈ U i}

tactic: exact h.comap _
state_before: α : Type u_2
β : Type ?u.173356
inst✝² : UniformSpace α
inst✝¹ : Group α
inst✝ : UniformGroup α
ι : Sort u_1
p : ι → Prop
U : ι → Set α
h : HasBasis (𝓝 1) p U
⊢ HasBasis (Filter.comap (fun x => x.snd / x.fst) (𝓝 1)) p fun i => {x | x.snd / x.fst ∈ U i}
Theorem: Matrix.diagonal_smul
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext i j
state_before: l : Type ?u.54869
m : Type ?u.54872
n : Type u_2
o : Type ?u.54878
m' : o → Type ?u.54883
n' : o → Type ?u.54888
R : Type u_1
S : Type ?u.54894
α : Type v
β : Type w
γ : Type ?u.54901
inst✝³ : DecidableEq n
inst✝² : Monoid R
inst✝¹ : AddMonoid α
inst✝ : DistribMulAction R α
r : R
d : n → α
⊢ diagonal (r • d) = r • diagonal d

tactic: by_cases h : i = j <;>
simp [h]
state_before: case a.h
l : Type ?u.54869
m : Type ?u.54872
n : Type u_2
o : Type ?u.54878
m' : o → Type ?u.54883
n' : o → Type ?u.54888
R : Type u_1
S : Type ?u.54894
α : Type v
β : Type w
γ : Type ?u.54901
inst✝³ : DecidableEq n
inst✝² : Monoid R
inst✝¹ : AddMonoid α
inst✝ : DistribMulAction R α
r : R
d : n → α
i j : n
⊢ diagonal (r • d) i j = (r • diagonal d) i j
Theorem: Real.log_b_ne_zero
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: have b_ne_zero : b ≠ 0
state_before: b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
⊢ log b ≠ 0

tactic: linarith
state_before: case b_ne_zero
b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
⊢ b ≠ 0

b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
b_ne_zero : b ≠ 0
⊢ log b ≠ 0

tactic: have b_ne_minus_one : b ≠ -1
state_before: b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
b_ne_zero : b ≠ 0
⊢ log b ≠ 0

tactic: linarith
state_before: case b_ne_minus_one
b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
b_ne_zero : b ≠ 0
⊢ b ≠ -1

b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
b_ne_zero : b ≠ 0
b_ne_minus_one : b ≠ -1
⊢ log b ≠ 0

tactic: simp [b_ne_one, b_ne_zero, b_ne_minus_one]
state_before: b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
b_ne_zero : b ≠ 0
b_ne_minus_one : b ≠ -1
⊢ log b ≠ 0
Theorem: Dfinsupp.neLocus_comm
File: Mathlib/Data/Dfinsupp/NeLocus.lean

tactic: simp_rw [neLocus, Finset.union_comm, ne_comm]
state_before: α : Type u_1
N : α → Type u_2
inst✝² : DecidableEq α
inst✝¹ : (a : α) → DecidableEq (N a)
inst✝ : (a : α) → Zero (N a)
f g : Π₀ (a : α), N a
⊢ neLocus f g = neLocus g f
Theorem: spectrum.map_polynomial_aeval_of_nonempty
File: Mathlib/FieldTheory/IsAlgClosed/Spectrum.lean

tactic: nontriviality A
state_before: 𝕜 : Type u
A : Type v
inst✝³ : Field 𝕜
inst✝² : Ring A
inst✝¹ : Algebra 𝕜 A
inst✝ : IsAlgClosed 𝕜
a : A
p : 𝕜[X]
hnon : Set.Nonempty (σ a)
⊢ σ (↑(aeval a) p) = (fun k => eval k p) '' σ a

tactic: refine' Or.elim (le_or_gt (degree p) 0) (fun h => _) (map_polynomial_aeval_of_degree_pos a p)
state_before: 𝕜 : Type u
A : Type v
inst✝³ : Field 𝕜
inst✝² : Ring A
inst✝¹ : Algebra 𝕜 A
inst✝ : IsAlgClosed 𝕜
a : A
p : 𝕜[X]
hnon : Set.Nonempty (σ a)
✝ : Nontrivial A
⊢ σ (↑(aeval a) p) = (fun k => eval k p) '' σ a

tactic: rw [eq_C_of_degree_le_zero h]
state_before: 𝕜 : Type u
A : Type v
inst✝³ : Field 𝕜
inst✝² : Ring A
inst✝¹ : Algebra 𝕜 A
inst✝ : IsAlgClosed 𝕜
a : A
p : 𝕜[X]
hnon : Set.Nonempty (σ a)
✝ : Nontrivial A
h : degree p ≤ 0
⊢ σ (↑(aeval a) p) = (fun k => eval k p) '' σ a

tactic: simp only [Set.image_congr, eval_C, aeval_C, scalar_eq, Set.Nonempty.image_const hnon]
state_before: 𝕜 : Type u
A : Type v
inst✝³ : Field 𝕜
inst✝² : Ring A
inst✝¹ : Algebra 𝕜 A
inst✝ : IsAlgClosed 𝕜
a : A
p : 𝕜[X]
hnon : Set.Nonempty (σ a)
✝ : Nontrivial A
h : degree p ≤ 0
⊢ σ (↑(aeval a) (↑C (coeff p 0))) = (fun k => eval k (↑C (coeff p 0))) '' σ a
Theorem: exists_dist_le_lt
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: refine' (exists_dist_eq x z (div_nonneg hε.le <| add_nonneg hε.le hδ)
  (div_nonneg hδ <| add_nonneg hε.le hδ) <| by
    rw [← add_div, div_self (add_pos_of_pos_of_nonneg hε hδ).ne']).imp
  fun y hy => _
state_before: 𝕜 : Type ?u.210210
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y z : E
δ ε : ℝ
hδ : 0 ≤ δ
hε : 0 < ε
h : dist x z < ε + δ
⊢ ∃ y, dist x y ≤ δ ∧ dist y z < ε

tactic: rw [hy.1, hy.2, div_mul_comm, div_mul_comm ε]
state_before: 𝕜 : Type ?u.210210
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y✝ z : E
δ ε : ℝ
hδ : 0 ≤ δ
hε : 0 < ε
h : dist x z < ε + δ
y : E
hy : dist x y = δ / (ε + δ) * dist x z ∧ dist y z = ε / (ε + δ) * dist x z
⊢ dist x y ≤ δ ∧ dist y z < ε

tactic: rw [← div_lt_one (add_pos_of_pos_of_nonneg hε hδ)] at h
state_before: 𝕜 : Type ?u.210210
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y✝ z : E
δ ε : ℝ
hδ : 0 ≤ δ
hε : 0 < ε
h : dist x z < ε + δ
y : E
hy : dist x y = δ / (ε + δ) * dist x z ∧ dist y z = ε / (ε + δ) * dist x z
⊢ dist x z / (ε + δ) * δ ≤ δ ∧ dist x z / (ε + δ) * ε < ε

tactic: exact ⟨mul_le_of_le_one_left hδ h.le, mul_lt_of_lt_one_left hε h⟩
state_before: 𝕜 : Type ?u.210210
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y✝ z : E
δ ε : ℝ
hδ : 0 ≤ δ
hε : 0 < ε
h : dist x z / (ε + δ) < 1
y : E
hy : dist x y = δ / (ε + δ) * dist x z ∧ dist y z = ε / (ε + δ) * dist x z
⊢ dist x z / (ε + δ) * δ ≤ δ ∧ dist x z / (ε + δ) * ε < ε

tactic: rw [← add_div, div_self (add_pos_of_pos_of_nonneg hε hδ).ne']
state_before: 𝕜 : Type ?u.210210
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y z : E
δ ε : ℝ
hδ : 0 ≤ δ
hε : 0 < ε
h : dist x z < ε + δ
⊢ ε / (ε + δ) + δ / (ε + δ) = 1
Theorem: Int.add_one_le_ceil_iff
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← lt_ceil, add_one_le_iff]
state_before: F : Type ?u.209172
α : Type u_1
β : Type ?u.209178
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ z + 1 ≤ ⌈a⌉ ↔ ↑z < a
Theorem: inv_nonneg
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: simp only [le_iff_eq_or_lt, inv_pos, zero_eq_inv]
state_before: ι : Type ?u.5703
α : Type u_1
β : Type ?u.5709
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
⊢ 0 ≤ a⁻¹ ↔ 0 ≤ a
Theorem: Equiv.Perm.pow_eq_on_of_mem_support
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: induction' k with k hk
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : ∀ (x : α), x ∈ support f ∩ support g → ↑f x = ↑g x
k : ℕ
⊢ ∀ (x : α), x ∈ support f ∩ support g → ↑(f ^ k) x = ↑(g ^ k) x

tactic: simp
state_before: case zero
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : ∀ (x : α), x ∈ support f ∩ support g → ↑f x = ↑g x
⊢ ∀ (x : α), x ∈ support f ∩ support g → ↑(f ^ Nat.zero) x = ↑(g ^ Nat.zero) x

tactic: intro x hx
state_before: case succ
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : ∀ (x : α), x ∈ support f ∩ support g → ↑f x = ↑g x
k : ℕ
hk : ∀ (x : α), x ∈ support f ∩ support g → ↑(f ^ k) x = ↑(g ^ k) x
⊢ ∀ (x : α), x ∈ support f ∩ support g → ↑(f ^ Nat.succ k) x = ↑(g ^ Nat.succ k) x

tactic: rw [pow_succ', mul_apply, pow_succ', mul_apply, h _ hx, hk]
state_before: case succ
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : ∀ (x : α), x ∈ support f ∩ support g → ↑f x = ↑g x
k : ℕ
hk : ∀ (x : α), x ∈ support f ∩ support g → ↑(f ^ k) x = ↑(g ^ k) x
x : α
hx : x ∈ support f ∩ support g
⊢ ↑(f ^ Nat.succ k) x = ↑(g ^ Nat.succ k) x

tactic: rwa [mem_inter, apply_mem_support, ← h _ hx, apply_mem_support, ← mem_inter]
state_before: case succ.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
h : ∀ (x : α), x ∈ support f ∩ support g → ↑f x = ↑g x
k : ℕ
hk : ∀ (x : α), x ∈ support f ∩ support g → ↑(f ^ k) x = ↑(g ^ k) x
x : α
hx : x ∈ support f ∩ support g
⊢ ↑g x ∈ support f ∩ support g
Theorem: Associates.prod_eq_one_iff
File: Mathlib/Algebra/BigOperators/Associated.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.37103
γ : Type ?u.37106
δ : Type ?u.37109
inst✝ : CommMonoid α
p : Multiset (Associates α)
⊢ Multiset.prod 0 = 1 ↔ ∀ (a : Associates α), a ∈ 0 → a = 1

tactic: simp (config := { contextual := true }) [mul_eq_one_iff, or_imp, forall_and]
state_before: α : Type u_1
β : Type ?u.37103
γ : Type ?u.37106
δ : Type ?u.37109
inst✝ : CommMonoid α
p : Multiset (Associates α)
⊢ ∀ ⦃a : Associates α⦄ {s : Multiset (Associates α)},
    (Multiset.prod s = 1 ↔ ∀ (a : Associates α), a ∈ s → a = 1) →
      (Multiset.prod (a ::ₘ s) = 1 ↔ ∀ (a_2 : Associates α), a_2 ∈ a ::ₘ s → a_2 = 1)
Theorem: Submodule.comap_fst
File: Mathlib/LinearAlgebra/Prod.lean

tactic: ext ⟨x, y⟩
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.298370
M₆ : Type ?u.298373
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ comap (fst R M M₂) p = prod p ⊤

tactic: simp
state_before: case h.mk
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.298370
M₆ : Type ?u.298373
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
x : M
y : M₂
⊢ (x, y) ∈ comap (fst R M M₂) p ↔ (x, y) ∈ prod p ⊤
Theorem: List.prod_toFinset
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: simp
state_before: ι : Type ?u.887074
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
M : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommMonoid M
f : α → M
x✝ : Nodup []
⊢ Finset.prod (toFinset []) f = prod (map f [])

tactic: let ⟨not_mem, hl⟩ := List.nodup_cons.mp hl
state_before: ι : Type ?u.887074
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
M : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommMonoid M
f : α → M
a : α
l : List α
hl : Nodup (a :: l)
⊢ Finset.prod (toFinset (a :: l)) f = prod (map f (a :: l))

tactic: simp [Finset.prod_insert (mt List.mem_toFinset.mp not_mem), prod_toFinset _ hl]
state_before: ι : Type ?u.887074
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
M : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommMonoid M
f : α → M
a : α
l : List α
hl✝ : Nodup (a :: l)
not_mem : ¬a ∈ l
hl : Nodup l
⊢ Finset.prod (toFinset (a :: l)) f = prod (map f (a :: l))
Theorem: Asymptotics.IsBigO.exists_mem_basis
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simpa only [isBigOWith_iff, hb.eventually_iff, exists_prop] using h
state_before: α : Type u_2
β : Type ?u.44090
E : Type u_3
F : Type ?u.44096
G : Type ?u.44099
E' : Type ?u.44102
F' : Type u_4
G' : Type ?u.44108
E'' : Type ?u.44111
F'' : Type ?u.44114
G'' : Type ?u.44117
R : Type ?u.44120
R' : Type ?u.44123
𝕜 : Type ?u.44126
𝕜' : Type ?u.44129
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c✝ c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
ι : Sort u_1
p : ι → Prop
s : ι → Set α
h✝ : f =O[l] g'
hb : HasBasis l p s
c : ℝ
_hc : 0 < c
h : IsBigOWith c l f g'
⊢ ∃ i _hi, ∀ (x : α), x ∈ s i → ‖f x‖ ≤ c * ‖g' x‖
Theorem: Nat.div_div_eq_div_mul
File: Std/Data/Nat/Lemmas.lean

tactic: cases eq_zero_or_pos k with
| inl k0 => rw [k0, Nat.mul_zero, Nat.div_zero, Nat.div_zero] | inr kpos => ?_
state_before: m n k : Nat
⊢ m / n / k = m / (n * k)

tactic: cases eq_zero_or_pos n with
| inl n0 => rw [n0, Nat.zero_mul, Nat.div_zero, Nat.zero_div] | inr npos => ?_
state_before: case inr
m n k : Nat
kpos : k > 0
⊢ m / n / k = m / (n * k)

tactic: apply Nat.le_antisymm
state_before: case inr.inr
m n k : Nat
kpos : k > 0
npos : n > 0
⊢ m / n / k = m / (n * k)

tactic: rw [k0, Nat.mul_zero, Nat.div_zero, Nat.div_zero]
state_before: case inl
m n k : Nat
k0 : k = 0
⊢ m / n / k = m / (n * k)

tactic: rw [n0, Nat.zero_mul, Nat.div_zero, Nat.zero_div]
state_before: case inr.inl
m n k : Nat
kpos : k > 0
n0 : n = 0
⊢ m / n / k = m / (n * k)

tactic: apply (le_div_iff_mul_le (Nat.mul_pos npos kpos)).2
state_before: case inr.inr.h₁
m n k : Nat
kpos : k > 0
npos : n > 0
⊢ m / n / k ≤ m / (n * k)

tactic: rw [Nat.mul_comm n k, ← Nat.mul_assoc]
state_before: case inr.inr.h₁
m n k : Nat
kpos : k > 0
npos : n > 0
⊢ m / n / k * (n * k) ≤ m

tactic: apply (le_div_iff_mul_le npos).1
state_before: case inr.inr.h₁
m n k : Nat
kpos : k > 0
npos : n > 0
⊢ m / n / k * k * n ≤ m

tactic: apply (le_div_iff_mul_le kpos).1
state_before: case inr.inr.h₁
m n k : Nat
kpos : k > 0
npos : n > 0
⊢ m / n / k * k ≤ m / n

tactic: (apply Nat.le_refl)
state_before: case inr.inr.h₁
m n k : Nat
kpos : k > 0
npos : n > 0
⊢ m / n / k ≤ m / n / k

tactic: apply Nat.le_refl
state_before: case inr.inr.h₁
m n k : Nat
kpos : k > 0
npos : n > 0
⊢ m / n / k ≤ m / n / k

tactic: apply (le_div_iff_mul_le kpos).2
state_before: case inr.inr.h₂
m n k : Nat
kpos : k > 0
npos : n > 0
⊢ m / (n * k) ≤ m / n / k

tactic: apply (le_div_iff_mul_le npos).2
state_before: case inr.inr.h₂
m n k : Nat
kpos : k > 0
npos : n > 0
⊢ m / (n * k) * k ≤ m / n

tactic: rw [Nat.mul_assoc, Nat.mul_comm n k]
state_before: case inr.inr.h₂
m n k : Nat
kpos : k > 0
npos : n > 0
⊢ m / (n * k) * k * n ≤ m

tactic: apply (le_div_iff_mul_le (Nat.mul_pos kpos npos)).1
state_before: case inr.inr.h₂
m n k : Nat
kpos : k > 0
npos : n > 0
⊢ m / (k * n) * (k * n) ≤ m

tactic: apply Nat.le_refl
state_before: case inr.inr.h₂
m n k : Nat
kpos : k > 0
npos : n > 0
⊢ m / (k * n) ≤ m / (k * n)
Theorem: TendstoUniformlyOnFilter.congr
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: refine' fun u hu => ((hf u hu).and hff').mono fun n h => _
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
F' : ι → α → β
hf : TendstoUniformlyOnFilter F f p p'
hff' : ∀ᶠ (n : ι × α) in p ×ˢ p', F n.fst n.snd = F' n.fst n.snd
⊢ TendstoUniformlyOnFilter F' f p p'

tactic: rw [← h.right]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
F' : ι → α → β
hf : TendstoUniformlyOnFilter F f p p'
hff' : ∀ᶠ (n : ι × α) in p ×ˢ p', F n.fst n.snd = F' n.fst n.snd
u : Set (β × β)
hu : u ∈ 𝓤 β
n : ι × α
h : (f n.snd, F n.fst n.snd) ∈ u ∧ F n.fst n.snd = F' n.fst n.snd
⊢ (f n.snd, F' n.fst n.snd) ∈ u

tactic: exact h.left
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
F' : ι → α → β
hf : TendstoUniformlyOnFilter F f p p'
hff' : ∀ᶠ (n : ι × α) in p ×ˢ p', F n.fst n.snd = F' n.fst n.snd
u : Set (β × β)
hu : u ∈ 𝓤 β
n : ι × α
h : (f n.snd, F n.fst n.snd) ∈ u ∧ F n.fst n.snd = F' n.fst n.snd
⊢ (f n.snd, F n.fst n.snd) ∈ u
Theorem: isClosed_iff_coe_preimage_of_iSup_eq_top
File: Mathlib/Topology/LocalAtTarget.lean

tactic: simpa using isOpen_iff_coe_preimage_of_iSup_eq_top hU (sᶜ)
state_before: α : Type ?u.18470
β : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
s✝ : Set β
ι : Type ?u.18489
U : ι → Opens β
hU : iSup U = ⊤
s : Set β
⊢ IsClosed s ↔ ∀ (i : ι), IsClosed (Subtype.val ⁻¹' s)
Theorem: PowerBasis.quotientEquivQuotientMinpolyMap_apply_mk
File: Mathlib/RingTheory/AdjoinRoot.lean

tactic: rw [PowerBasis.quotientEquivQuotientMinpolyMap, AlgEquiv.trans_apply, AlgEquiv.ofRingEquiv_apply,
  quotientEquiv_mk, AlgEquiv.coe_ringEquiv', AdjoinRoot.equiv'_symm_apply, PowerBasis.lift_aeval,
  AdjoinRoot.aeval_eq, AdjoinRoot.quotEquivQuotMap_apply_mk]
state_before: R : Type u
S : Type v
K : Type w
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
pb : PowerBasis R S
I : Ideal R
g : R[X]
⊢ ↑(quotientEquivQuotientMinpolyMap pb I) (↑(Ideal.Quotient.mk (Ideal.map (algebraMap R S) I)) (↑(aeval pb.gen) g)) =
    ↑(Ideal.Quotient.mk (span {Polynomial.map (Ideal.Quotient.mk I) (minpoly R pb.gen)}))
      (Polynomial.map (Ideal.Quotient.mk I) g)
Theorem: IsLUB.insert
File: Mathlib/Order/Bounds/Basic.lean

tactic: rw [insert_eq]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s✝ t : Set α
a✝ b✝ : α
inst✝ : SemilatticeSup γ
a b : γ
s : Set γ
hs : IsLUB s b
⊢ IsLUB (Insert.insert a s) (a ⊔ b)

tactic: exact isLUB_singleton.union hs
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s✝ t : Set α
a✝ b✝ : α
inst✝ : SemilatticeSup γ
a b : γ
s : Set γ
hs : IsLUB s b
⊢ IsLUB ({a} ∪ s) (a ⊔ b)
Theorem: List.chain'_pair
File: Mathlib/Data/List/Chain.lean

tactic: simp only [chain'_singleton, chain'_cons, and_true_iff]
state_before: α : Type u
β : Type v
R r : α → α → Prop
l l₁ l₂ : List α
a b x y : α
⊢ Chain' R [x, y] ↔ R x y
Theorem: NormedAddGroupHom.ker.incl_comp_lift
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: ext
state_before: V : Type ?u.485294
W : Type ?u.485297
V₁ : Type u_1
V₂ : Type u_3
V₃ : Type u_2
inst✝⁴ : SeminormedAddCommGroup V
inst✝³ : SeminormedAddCommGroup W
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V₁ V₂
g : NormedAddGroupHom V₂ V₃
h : NormedAddGroupHom.comp g f = 0
⊢ NormedAddGroupHom.comp (incl (ker g)) (lift f g h) = f

tactic: rfl
state_before: case H
V : Type ?u.485294
W : Type ?u.485297
V₁ : Type u_1
V₂ : Type u_3
V₃ : Type u_2
inst✝⁴ : SeminormedAddCommGroup V
inst✝³ : SeminormedAddCommGroup W
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V₁ V₂
g : NormedAddGroupHom V₂ V₃
h : NormedAddGroupHom.comp g f = 0
x✝ : V₁
⊢ ↑(NormedAddGroupHom.comp (incl (ker g)) (lift f g h)) x✝ = ↑f x✝
Theorem: toIcoDiv_zsmul_sub_self
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [toIcoMod, neg_sub]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoDiv hp a b • p - b = -toIcoMod hp a b
Theorem: YoungDiagram.pos_of_mem_rowLens
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

tactic: rw [rowLens, List.mem_map] at hx
state_before: μ : YoungDiagram
x : ℕ
hx : x ∈ rowLens μ
⊢ 0 < x

tactic: obtain ⟨i, hi, rfl : μ.rowLen i = x⟩ := hx
state_before: μ : YoungDiagram
x : ℕ
hx : ∃ a, a ∈ List.range (colLen μ 0) ∧ rowLen μ a = x
⊢ 0 < x

tactic: rwa [List.mem_range, ← mem_iff_lt_colLen, mem_iff_lt_rowLen] at hi
state_before: case intro.intro
μ : YoungDiagram
i : ℕ
hi : i ∈ List.range (colLen μ 0)
⊢ 0 < rowLen μ i
Theorem: inv_mul_eq_of_eq_mul
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp [h]
state_before: α : Type ?u.50703
β : Type ?u.50706
G : Type u_1
inst✝ : Group G
a b c d : G
h : b = a * c
⊢ a⁻¹ * b = c