tasksource/leandojo huggingface dataset:
Theorem: Polynomial.content_C_mul
File: Mathlib/RingTheory/Polynomial/Content.lean

tactic: by_cases h0 : r = 0
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
r : R
p : R[X]
⊢ content (↑C r * p) = ↑normalize r * content p

tactic: rw [content]
state_before: case neg
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
r : R
p : R[X]
h0 : ¬r = 0
⊢ content (↑C r * p) = ↑normalize r * content p

tactic: rw [content]
state_before: case neg
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
r : R
p : R[X]
h0 : ¬r = 0
⊢ Finset.gcd (support (↑C r * p)) (coeff (↑C r * p)) = ↑normalize r * content p

tactic: rw [← Finset.gcd_mul_left]
state_before: case neg
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
r : R
p : R[X]
h0 : ¬r = 0
⊢ Finset.gcd (support (↑C r * p)) (coeff (↑C r * p)) = ↑normalize r * Finset.gcd (support p) (coeff p)

tactic: refine' congr (congr rfl _) _ <;> ext <;> simp [h0, mem_support_iff]
state_before: case neg
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
r : R
p : R[X]
h0 : ¬r = 0
⊢ Finset.gcd (support (↑C r * p)) (coeff (↑C r * p)) = Finset.gcd (support p) fun x => r * coeff p x

tactic: simp [h0]
state_before: case pos
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
r : R
p : R[X]
h0 : r = 0
⊢ content (↑C r * p) = ↑normalize r * content p
Theorem: Nat.add_choose_eq
File: Mathlib/Data/Nat/Choose/Vandermonde.lean

tactic: calc
  (m + n).choose k = ((X + 1) ^ (m + n)).coeff k := by rw [coeff_X_add_one_pow, Nat.cast_id]
  _ = ((X + 1) ^ m * (X + 1) ^ n).coeff k := by rw [pow_add]
  _ = ∑ ij : ℕ × ℕ in antidiagonal k, m.choose ij.1 * n.choose ij.2 := by
    rw [coeff_mul, Finset.sum_congr rfl]
    simp only [coeff_X_add_one_pow, Nat.cast_id, eq_self_iff_true, imp_true_iff]
state_before: m n k : ℕ
⊢ choose (m + n) k = ∑ ij in antidiagonal k, choose m ij.fst * choose n ij.snd

tactic: rw [coeff_X_add_one_pow, Nat.cast_id]
state_before: m n k : ℕ
⊢ choose (m + n) k = coeff ((X + 1) ^ (m + n)) k

tactic: rw [pow_add]
state_before: m n k : ℕ
⊢ coeff ((X + 1) ^ (m + n)) k = coeff ((X + 1) ^ m * (X + 1) ^ n) k

tactic: rw [coeff_mul, Finset.sum_congr rfl]
state_before: m n k : ℕ
⊢ coeff ((X + 1) ^ m * (X + 1) ^ n) k = ∑ ij in antidiagonal k, choose m ij.fst * choose n ij.snd

tactic: simp only [coeff_X_add_one_pow, Nat.cast_id, eq_self_iff_true, imp_true_iff]
state_before: m n k : ℕ
⊢ ∀ (x : ℕ × ℕ),
    x ∈ antidiagonal k → coeff ((X + 1) ^ m) x.fst * coeff ((X + 1) ^ n) x.snd = choose m x.fst * choose n x.snd
Theorem: HasFDerivAt.eventually_ne
File: Mathlib/Analysis/Calculus/FDeriv/Equiv.lean

tactic: simpa only [compl_eq_univ_diff] using (hasFDerivWithinAt_univ.2 h).eventually_ne 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.470827
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.470922
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 : HasFDerivAt f f' x
hf' : ∃ C, ∀ (z : E), ‖z‖ ≤ C * ‖↑f' z‖
⊢ ∀ᶠ (z : E) in 𝓝[{x}ᶜ] x, f z ≠ f x
Theorem: add_mul_self_eq
File: Mathlib/Algebra/Ring/Defs.lean

tactic: simp only [two_mul, add_mul, mul_add, add_assoc, mul_comm b]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : CommSemiring α
a✝ b✝ c a b : α
⊢ (a + b) * (a + b) = a * a + 2 * a * b + b * b
Theorem: Rat.cast_nonpos
File: Mathlib/Data/Rat/Cast.lean

tactic: norm_cast
state_before: F : Type ?u.58977
ι : Type ?u.58980
α : Type ?u.58983
β : Type ?u.58986
K : Type u_1
inst✝ : LinearOrderedField K
n : ℚ
⊢ ↑n ≤ 0 ↔ n ≤ 0
Theorem: Ordering.ite_eq_eq_distrib
File: Mathlib/Init/Data/Ordering/Lemmas.lean

tactic: by_cases c <;> simp [*]
state_before: c : Prop
inst✝ : Decidable c
a b : Ordering
⊢ ((if c then a else b) = eq) = if c then a = eq else b = eq
Theorem: isClosed_innerDualCone
File: Mathlib/Analysis/Convex/Cone/Dual.lean

tactic: rw [innerDualCone_eq_iInter_innerDualCone_singleton]
state_before: 𝕜 : Type ?u.21666
E : Type ?u.21669
F : Type ?u.21672
G : Type ?u.21675
H : Type u_1
inst✝¹ : NormedAddCommGroup H
inst✝ : InnerProductSpace ℝ H
s t : Set H
⊢ IsClosed ↑(innerDualCone s)

tactic: apply isClosed_iInter
state_before: 𝕜 : Type ?u.21666
E : Type ?u.21669
F : Type ?u.21672
G : Type ?u.21675
H : Type u_1
inst✝¹ : NormedAddCommGroup H
inst✝ : InnerProductSpace ℝ H
s t : Set H
⊢ IsClosed (⋂ (i : ↑s), ↑(innerDualCone {↑i}))

tactic: intro x
state_before: case h
𝕜 : Type ?u.21666
E : Type ?u.21669
F : Type ?u.21672
G : Type ?u.21675
H : Type u_1
inst✝¹ : NormedAddCommGroup H
inst✝ : InnerProductSpace ℝ H
s t : Set H
⊢ ∀ (i : ↑s), IsClosed ↑(innerDualCone {↑i})

tactic: have h : ({↑x} : Set H).innerDualCone = (inner x : H → ℝ) ⁻¹' Set.Ici 0 := by
  rw [innerDualCone_singleton, ConvexCone.coe_comap, ConvexCone.coe_positive, innerₛₗ_apply_coe]
state_before: case h
𝕜 : Type ?u.21666
E : Type ?u.21669
F : Type ?u.21672
G : Type ?u.21675
H : Type u_1
inst✝¹ : NormedAddCommGroup H
inst✝ : InnerProductSpace ℝ H
s t : Set H
x : ↑s
⊢ IsClosed ↑(innerDualCone {↑x})

tactic: rw [h]
state_before: case h
𝕜 : Type ?u.21666
E : Type ?u.21669
F : Type ?u.21672
G : Type ?u.21675
H : Type u_1
inst✝¹ : NormedAddCommGroup H
inst✝ : InnerProductSpace ℝ H
s t : Set H
x : ↑s
h : ↑(innerDualCone {↑x}) = inner ↑x ⁻¹' Ici 0
⊢ IsClosed ↑(innerDualCone {↑x})

tactic: exact isClosed_Ici.preimage (continuous_const.inner continuous_id')
state_before: case h
𝕜 : Type ?u.21666
E : Type ?u.21669
F : Type ?u.21672
G : Type ?u.21675
H : Type u_1
inst✝¹ : NormedAddCommGroup H
inst✝ : InnerProductSpace ℝ H
s t : Set H
x : ↑s
h : ↑(innerDualCone {↑x}) = inner ↑x ⁻¹' Ici 0
⊢ IsClosed (inner ↑x ⁻¹' Ici 0)

tactic: rw [innerDualCone_singleton, ConvexCone.coe_comap, ConvexCone.coe_positive, innerₛₗ_apply_coe]
state_before: 𝕜 : Type ?u.21666
E : Type ?u.21669
F : Type ?u.21672
G : Type ?u.21675
H : Type u_1
inst✝¹ : NormedAddCommGroup H
inst✝ : InnerProductSpace ℝ H
s t : Set H
x : ↑s
⊢ ↑(innerDualCone {↑x}) = inner ↑x ⁻¹' Ici 0
Theorem: LipschitzWith.uncurry
File: Mathlib/Topology/MetricSpace/Lipschitz.lean

tactic: rintro ⟨a₁, b₁⟩ ⟨a₂, b₂⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f✝ : α → β
x y : α
r : ℝ≥0∞
f : α → β → γ
Kα Kβ : ℝ≥0
hα : ∀ (b : β), LipschitzWith Kα fun a => f a b
hβ : ∀ (a : α), LipschitzWith Kβ (f a)
⊢ LipschitzWith (Kα + Kβ) (uncurry f)

tactic: simp only [Function.uncurry, ENNReal.coe_add, add_mul]
state_before: case mk.mk
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f✝ : α → β
x y : α
r : ℝ≥0∞
f : α → β → γ
Kα Kβ : ℝ≥0
hα : ∀ (b : β), LipschitzWith Kα fun a => f a b
hβ : ∀ (a : α), LipschitzWith Kβ (f a)
a₁ : α
b₁ : β
a₂ : α
b₂ : β
⊢ edist (uncurry f (a₁, b₁)) (uncurry f (a₂, b₂)) ≤ ↑(Kα + Kβ) * edist (a₁, b₁) (a₂, b₂)

tactic: apply le_trans (edist_triangle _ (f a₂ b₁) _)
state_before: case mk.mk
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f✝ : α → β
x y : α
r : ℝ≥0∞
f : α → β → γ
Kα Kβ : ℝ≥0
hα : ∀ (b : β), LipschitzWith Kα fun a => f a b
hβ : ∀ (a : α), LipschitzWith Kβ (f a)
a₁ : α
b₁ : β
a₂ : α
b₂ : β
⊢ edist (f a₁ b₁) (f a₂ b₂) ≤ ↑Kα * edist (a₁, b₁) (a₂, b₂) + ↑Kβ * edist (a₁, b₁) (a₂, b₂)

tactic: exact
  add_le_add (le_trans (hα _ _ _) <| ENNReal.mul_left_mono <| le_max_left _ _)
    (le_trans (hβ _ _ _) <| ENNReal.mul_left_mono <| le_max_right _ _)
state_before: case mk.mk
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f✝ : α → β
x y : α
r : ℝ≥0∞
f : α → β → γ
Kα Kβ : ℝ≥0
hα : ∀ (b : β), LipschitzWith Kα fun a => f a b
hβ : ∀ (a : α), LipschitzWith Kβ (f a)
a₁ : α
b₁ : β
a₂ : α
b₂ : β
⊢ edist (f a₁ b₁) (f a₂ b₁) + edist (f a₂ b₁) (f a₂ b₂) ≤ ↑Kα * edist (a₁, b₁) (a₂, b₂) + ↑Kβ * edist (a₁, b₁) (a₂, b₂)
Theorem: Lagrange.eval_interpolate_not_at_node'
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: rw [← div_one (eval x (interpolate s v r)), ← @eval_one _ _ x, ← interpolate_one hvs hs,
  eval_interpolate_not_at_node r hx, eval_interpolate_not_at_node 1 hx]
state_before: F : Type u_2
inst✝¹ : Field F
ι : Type u_1
s : Finset ι
v : ι → F
i : ι
r : ι → F
x : F
inst✝ : DecidableEq ι
hvs : Set.InjOn v ↑s
hs : Finset.Nonempty s
hx : ∀ (i : ι), i ∈ s → x ≠ v i
⊢ eval x (↑(interpolate s v) r) =
    (∑ i in s, nodalWeight s v i * (x - v i)⁻¹ * r i) / ∑ i in s, nodalWeight s v i * (x - v i)⁻¹

tactic: simp only [mul_div_mul_left _ _ (eval_nodal_not_at_node hx), Pi.one_apply, mul_one]
state_before: F : Type u_2
inst✝¹ : Field F
ι : Type u_1
s : Finset ι
v : ι → F
i : ι
r : ι → F
x : F
inst✝ : DecidableEq ι
hvs : Set.InjOn v ↑s
hs : Finset.Nonempty s
hx : ∀ (i : ι), i ∈ s → x ≠ v i
⊢ (eval x (nodal s fun i => v i) * ∑ i in s, nodalWeight s (fun i => v i) i * (x - v i)⁻¹ * r i) /
      (eval x (nodal s fun i => v i) * ∑ i in s, nodalWeight s (fun i => v i) i * (x - v i)⁻¹ * OfNat.ofNat 1 i) =
    (∑ i in s, nodalWeight s v i * (x - v i)⁻¹ * r i) / ∑ i in s, nodalWeight s v i * (x - v i)⁻¹
Theorem: sup_sdiff_inf
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [sup_comm, sup_inf_sdiff]
state_before: α : Type u
β : Type ?u.725
w x✝ y✝ z : α
inst✝ : GeneralizedBooleanAlgebra α
x y : α
⊢ x \ y ⊔ x ⊓ y = x
Theorem: InnerProductGeometry.tan_angle_add_mul_norm_of_inner_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [tan_angle_add_of_inner_eq_zero h]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : x ≠ 0 ∨ y = 0
⊢ Real.tan (angle x (x + y)) * ‖x‖ = ‖y‖

tactic: rcases h0 with (h0 | h0) <;> simp [h0]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : x ≠ 0 ∨ y = 0
⊢ ‖y‖ / ‖x‖ * ‖x‖ = ‖y‖
Theorem: convex_stdSimplex
File: Mathlib/Analysis/Convex/Basic.lean

tactic: refine' fun f hf g hg a b ha hb hab => ⟨fun x => _, _⟩
state_before: 𝕜 : Type u_1
E : Type ?u.291143
F : Type ?u.291146
β : Type ?u.291149
ι : Type u_2
inst✝¹ : OrderedSemiring 𝕜
inst✝ : Fintype ι
⊢ Convex 𝕜 (stdSimplex 𝕜 ι)

tactic: apply_rules [add_nonneg, mul_nonneg, hf.1, hg.1]
state_before: case refine'_1
𝕜 : Type u_1
E : Type ?u.291143
F : Type ?u.291146
β : Type ?u.291149
ι : Type u_2
inst✝¹ : OrderedSemiring 𝕜
inst✝ : Fintype ι
f : ι → 𝕜
hf : f ∈ stdSimplex 𝕜 ι
g : ι → 𝕜
hg : g ∈ stdSimplex 𝕜 ι
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
x : ι
⊢ 0 ≤ (a • f + b • g) x

tactic: erw [Finset.sum_add_distrib]
state_before: case refine'_2
𝕜 : Type u_1
E : Type ?u.291143
F : Type ?u.291146
β : Type ?u.291149
ι : Type u_2
inst✝¹ : OrderedSemiring 𝕜
inst✝ : Fintype ι
f : ι → 𝕜
hf : f ∈ stdSimplex 𝕜 ι
g : ι → 𝕜
hg : g ∈ stdSimplex 𝕜 ι
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ ∑ x : ι, (a • f + b • g) x = 1

tactic: simp only [Pi.smul_apply]
state_before: case refine'_2
𝕜 : Type u_1
E : Type ?u.291143
F : Type ?u.291146
β : Type ?u.291149
ι : Type u_2
inst✝¹ : OrderedSemiring 𝕜
inst✝ : Fintype ι
f : ι → 𝕜
hf : f ∈ stdSimplex 𝕜 ι
g : ι → 𝕜
hg : g ∈ stdSimplex 𝕜 ι
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ ∑ x : ι, (a • f) x + ∑ x : ι, (b • g) x = 1

tactic: rw [← Finset.smul_sum, ← Finset.smul_sum, hf.2, hg.2, smul_eq_mul,
  smul_eq_mul, mul_one, mul_one]
state_before: case refine'_2
𝕜 : Type u_1
E : Type ?u.291143
F : Type ?u.291146
β : Type ?u.291149
ι : Type u_2
inst✝¹ : OrderedSemiring 𝕜
inst✝ : Fintype ι
f : ι → 𝕜
hf : f ∈ stdSimplex 𝕜 ι
g : ι → 𝕜
hg : g ∈ stdSimplex 𝕜 ι
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ ∑ x : ι, a • f x + ∑ x : ι, b • g x = 1

tactic: exact hab
state_before: case refine'_2
𝕜 : Type u_1
E : Type ?u.291143
F : Type ?u.291146
β : Type ?u.291149
ι : Type u_2
inst✝¹ : OrderedSemiring 𝕜
inst✝ : Fintype ι
f : ι → 𝕜
hf : f ∈ stdSimplex 𝕜 ι
g : ι → 𝕜
hg : g ∈ stdSimplex 𝕜 ι
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a + b = 1
Theorem: Matrix.lieConj_apply
File: Mathlib/Algebra/Lie/Matrix.lean

tactic: simp [LinearEquiv.conj_apply, Matrix.lieConj, LinearMap.toMatrix'_comp,
  LinearMap.toMatrix'_toLin']
state_before: R : Type u
inst✝² : CommRing R
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
P A : Matrix n n R
h : Invertible P
⊢ ↑(lieConj P h) A = P ⬝ A ⬝ P⁻¹
Theorem: Int.add_le_add_left
File: Std/Data/Int/Lemmas.lean

tactic: rw [Int.add_assoc, hn]
state_before: a b : Int
h : a ≤ b
c : Int
n : Nat
hn : a + ↑n = b
⊢ c + a + ↑n = c + b
Theorem: Complex.cos_int_mul_two_pi_add_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simpa only [cos_zero] using (cos_periodic.int_mul n).add_antiperiod_eq cos_antiperiodic
state_before: n : ℤ
⊢ cos (↑n * (2 * ↑π) + ↑π) = -1
Theorem: LieAlgebra.derivedSeriesOfIdeal_add_le_add
File: Mathlib/Algebra/Lie/Solvable.lean

tactic: let D₁ : LieIdeal R L →o LieIdeal R L :=
  { toFun := fun I => ⁅I, I⁆
    monotone' := fun I J h => LieSubmodule.mono_lie I J I J h h }
state_before: R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J✝ : LieIdeal R L
f : L' →ₗ⁅R⁆ L
J : LieIdeal R L
k l : ℕ
⊢ D (k + l) (I + J) ≤ D k I + D l J

tactic: have h₁ : ∀ I J : LieIdeal R L, D₁ (I ⊔ J) ≤ D₁ I ⊔ J := by
  simp [LieSubmodule.lie_le_right, LieSubmodule.lie_le_left, le_sup_of_le_right]
state_before: R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J✝ : LieIdeal R L
f : L' →ₗ⁅R⁆ L
J : LieIdeal R L
k l : ℕ
D₁ : LieIdeal R L →o LieIdeal R L :=
  { toFun := fun I => ⁅I, I⁆, monotone' := (_ : ∀ (I J : LieIdeal R L), I ≤ J → ⁅I, I⁆ ≤ ⁅J, J⁆) }
⊢ D (k + l) (I + J) ≤ D k I + D l J

tactic: rw [← D₁.iterate_sup_le_sup_iff] at h₁
state_before: R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J✝ : LieIdeal R L
f : L' →ₗ⁅R⁆ L
J : LieIdeal R L
k l : ℕ
D₁ : LieIdeal R L →o LieIdeal R L :=
  { toFun := fun I => ⁅I, I⁆, monotone' := (_ : ∀ (I J : LieIdeal R L), I ≤ J → ⁅I, I⁆ ≤ ⁅J, J⁆) }
h₁ : ∀ (I J : LieIdeal R L), ↑D₁ (I ⊔ J) ≤ ↑D₁ I ⊔ J
⊢ D (k + l) (I + J) ≤ D k I + D l J

tactic: exact h₁ k l I J
state_before: R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J✝ : LieIdeal R L
f : L' →ₗ⁅R⁆ L
J : LieIdeal R L
k l : ℕ
D₁ : LieIdeal R L →o LieIdeal R L :=
  { toFun := fun I => ⁅I, I⁆, monotone' := (_ : ∀ (I J : LieIdeal R L), I ≤ J → ⁅I, I⁆ ≤ ⁅J, J⁆) }
h₁ : ∀ (n₁ n₂ : ℕ) (a₁ a₂ : LieIdeal R L), (↑D₁^[n₁ + n₂]) (a₁ ⊔ a₂) ≤ (↑D₁^[n₁]) a₁ ⊔ (↑D₁^[n₂]) a₂
⊢ D (k + l) (I + J) ≤ D k I + D l J

tactic: simp [LieSubmodule.lie_le_right, LieSubmodule.lie_le_left, le_sup_of_le_right]
state_before: R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J✝ : LieIdeal R L
f : L' →ₗ⁅R⁆ L
J : LieIdeal R L
k l : ℕ
D₁ : LieIdeal R L →o LieIdeal R L :=
  { toFun := fun I => ⁅I, I⁆, monotone' := (_ : ∀ (I J : LieIdeal R L), I ≤ J → ⁅I, I⁆ ≤ ⁅J, J⁆) }
⊢ ∀ (I J : LieIdeal R L), ↑D₁ (I ⊔ J) ≤ ↑D₁ I ⊔ J
Theorem: setOf_liouville_eq_irrational_inter_iInter_iUnion
File: Mathlib/NumberTheory/Liouville/Residual.lean

tactic: refine Subset.antisymm ?_ ?_
state_before: ⊢ {x | Liouville x} = {x | Irrational x} ∩ ⋂ (n : ℕ), ⋃ (a : ℤ) (b : ℤ) (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n)

tactic: refine subset_inter (fun x hx => hx.irrational) ?_
state_before: case refine_1

⊢ {x | Liouville x} ⊆ {x | Irrational x} ∩ ⋂ (n : ℕ), ⋃ (a : ℤ) (b : ℤ) (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n)

tactic: rw [setOf_liouville_eq_iInter_iUnion]
state_before: case refine_1

⊢ {x | Liouville x} ⊆ ⋂ (n : ℕ), ⋃ (a : ℤ) (b : ℤ) (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n)

tactic: exact iInter_mono fun n => iUnion₂_mono fun a b => iUnion_mono fun _hb => diff_subset _ _
state_before: case refine_1

⊢ (⋂ (n : ℕ), ⋃ (a : ℤ) (b : ℤ) (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n) \ {↑a / ↑b}) ⊆
    ⋂ (n : ℕ), ⋃ (a : ℤ) (b : ℤ) (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n)

tactic: simp only [inter_iInter, inter_iUnion, setOf_liouville_eq_iInter_iUnion]
state_before: case refine_2

⊢ ({x | Irrational x} ∩ ⋂ (n : ℕ), ⋃ (a : ℤ) (b : ℤ) (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n)) ⊆ {x | Liouville x}

tactic: refine iInter_mono fun n => iUnion₂_mono fun a b => iUnion_mono fun hb => ?_
state_before: case refine_2

⊢ (⋂ (i : ℕ), ⋃ (i_1 : ℤ) (i_2 : ℤ) (_ : 1 < i_2), {x | Irrational x} ∩ ball (↑i_1 / ↑i_2) (1 / ↑i_2 ^ i)) ⊆
    ⋂ (n : ℕ), ⋃ (a : ℤ) (b : ℤ) (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n) \ {↑a / ↑b}

tactic: rw [inter_comm]
state_before: case refine_2
n : ℕ
a b : ℤ
hb : 1 < b
⊢ {x | Irrational x} ∩ ball (↑a / ↑b) (1 / ↑b ^ n) ⊆ ball (↑a / ↑b) (1 / ↑b ^ n) \ {↑a / ↑b}

tactic: exact diff_subset_diff Subset.rfl (singleton_subset_iff.2 ⟨a / b, by norm_cast⟩)
state_before: case refine_2
n : ℕ
a b : ℤ
hb : 1 < b
⊢ ball (↑a / ↑b) (1 / ↑b ^ n) ∩ {x | Irrational x} ⊆ ball (↑a / ↑b) (1 / ↑b ^ n) \ {↑a / ↑b}

tactic: norm_cast
state_before: n : ℕ
a b : ℤ
hb : 1 < b
⊢ ↑(↑a / ↑b) = ↑a / ↑b
Theorem: Prod.image_mk_openSegment_right
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.359680
ι : Type ?u.359683
π : ι → Type ?u.359688
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x : E
y₁ y₂ : F
⊢ (fun y => (x, y)) '' openSegment 𝕜 y₁ y₂ = openSegment 𝕜 (x, y₁) (x, y₂)

tactic: simp_rw [Set.mem_image, openSegment, Set.mem_setOf, Prod.smul_mk, Prod.mk_add_mk, Prod.mk.inj_iff,
  ← exists_and_right, @exists_comm F, exists_eq_left']
state_before: case h.mk
𝕜 : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.359680
ι : Type ?u.359683
π : ι → Type ?u.359688
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x : E
y₁ y₂ : F
x' : E
y' : F
⊢ (x', y') ∈ (fun y => (x, y)) '' openSegment 𝕜 y₁ y₂ ↔ (x', y') ∈ openSegment 𝕜 (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.359680
ι : Type ?u.359683
π : ι → Type ?u.359688
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x : E
y₁ y₂ : F
x' : E
y' : F
⊢ (∃ b b_1 h h h, x = x' ∧ b • y₁ + b_1 • 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.359680
ι : Type ?u.359683
π : ι → Type ?u.359688
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x : E
y₁ y₂ : F
x' : E
y' : F
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ x = x' ∧ a • y₁ + b • y₂ = y' ↔ a • x + b • x = x' ∧ a • y₁ + b • y₂ = y'
Theorem: Polynomial.root_X_sub_C
File: Mathlib/Data/Polynomial/Eval.lean

tactic: rw [IsRoot.def, eval_sub, eval_X, eval_C, sub_eq_zero, eq_comm]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Ring R
p q r : R[X]
⊢ IsRoot (X - ↑C a) b ↔ a = b
Theorem: Filter.comap_surjective_eq_bot
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [comap_eq_bot_iff_compl_range, hm.range_eq, compl_univ, empty_mem_iff_bot]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.264531
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
m : α → β
hm : Surjective m
⊢ comap m f = ⊥ ↔ f = ⊥
Theorem: List.Nodup.pairwise_of_forall_ne
File: Mathlib/Data/List/Nodup.lean

tactic: classical
  refine' pairwise_of_reflexive_on_dupl_of_forall_ne _ h
  intro x hx
  rw [nodup_iff_count_le_one] at hl
  exact absurd (hl x) hx.not_le
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r✝ : α → α → Prop
a b : α
l : List α
r : α → α → Prop
hl : Nodup l
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b
⊢ Pairwise r l

tactic: refine' pairwise_of_reflexive_on_dupl_of_forall_ne _ h
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r✝ : α → α → Prop
a b : α
l : List α
r : α → α → Prop
hl : Nodup l
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b
⊢ Pairwise r l

tactic: intro x hx
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r✝ : α → α → Prop
a b : α
l : List α
r : α → α → Prop
hl : Nodup l
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b
⊢ ∀ (a : α), 1 < count a l → r a a

tactic: rw [nodup_iff_count_le_one] at hl
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r✝ : α → α → Prop
a b : α
l : List α
r : α → α → Prop
hl : Nodup l
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b
x : α
hx : 1 < count x l
⊢ r x x

tactic: exact absurd (hl x) hx.not_le
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r✝ : α → α → Prop
a b : α
l : List α
r : α → α → Prop
hl✝ : Nodup l
hl : ∀ (a : α), count a l ≤ 1
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b
x : α
hx : 1 < count x l
⊢ r x x
Theorem: Seminorm.uniformContinuous_of_continuousAt_zero
File: Mathlib/Analysis/Seminorm.lean

tactic: have hp : Filter.Tendsto p (𝓝 0) (𝓝 0) := map_zero p ▸ hp
state_before: R : Type ?u.1398634
R' : Type ?u.1398637
𝕜 : Type ?u.1398640
𝕜₂ : Type ?u.1398643
𝕜₃ : Type ?u.1398646
𝕝 : Type u_2
E : Type u_1
E₂ : Type ?u.1398655
E₃ : Type ?u.1398658
F : Type ?u.1398661
G : Type ?u.1398664
ι : Type ?u.1398667
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : SeminormedRing 𝕝
inst✝⁴ : AddCommGroup E
inst✝³ : Module 𝕜 E
inst✝² : Module 𝕝 E
inst✝¹ : UniformSpace E
inst✝ : UniformAddGroup E
p : Seminorm 𝕝 E
hp : ContinuousAt (↑p) 0
⊢ UniformContinuous ↑p

tactic: rw [UniformContinuous, uniformity_eq_comap_nhds_zero_swapped,
  Metric.uniformity_eq_comap_nhds_zero, Filter.tendsto_comap_iff]
state_before: R : Type ?u.1398634
R' : Type ?u.1398637
𝕜 : Type ?u.1398640
𝕜₂ : Type ?u.1398643
𝕜₃ : Type ?u.1398646
𝕝 : Type u_2
E : Type u_1
E₂ : Type ?u.1398655
E₃ : Type ?u.1398658
F : Type ?u.1398661
G : Type ?u.1398664
ι : Type ?u.1398667
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : SeminormedRing 𝕝
inst✝⁴ : AddCommGroup E
inst✝³ : Module 𝕜 E
inst✝² : Module 𝕝 E
inst✝¹ : UniformSpace E
inst✝ : UniformAddGroup E
p : Seminorm 𝕝 E
hp✝ : ContinuousAt (↑p) 0
hp : Filter.Tendsto (↑p) (𝓝 0) (𝓝 0)
⊢ UniformContinuous ↑p

tactic: exact
  tendsto_of_tendsto_of_tendsto_of_le_of_le tendsto_const_nhds (hp.comp Filter.tendsto_comap)
    (fun xy => dist_nonneg) fun xy => p.norm_sub_map_le_sub _ _
state_before: R : Type ?u.1398634
R' : Type ?u.1398637
𝕜 : Type ?u.1398640
𝕜₂ : Type ?u.1398643
𝕜₃ : Type ?u.1398646
𝕝 : Type u_2
E : Type u_1
E₂ : Type ?u.1398655
E₃ : Type ?u.1398658
F : Type ?u.1398661
G : Type ?u.1398664
ι : Type ?u.1398667
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : SeminormedRing 𝕝
inst✝⁴ : AddCommGroup E
inst✝³ : Module 𝕜 E
inst✝² : Module 𝕝 E
inst✝¹ : UniformSpace E
inst✝ : UniformAddGroup E
p : Seminorm 𝕝 E
hp✝ : ContinuousAt (↑p) 0
hp : Filter.Tendsto (↑p) (𝓝 0) (𝓝 0)
⊢ Filter.Tendsto ((fun p => dist p.fst p.snd) ∘ fun x => (↑p x.fst, ↑p x.snd))
    (Filter.comap (fun x => x.fst - x.snd) (𝓝 0)) (𝓝 0)