ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Analysis/Convex/StrictConvexBetween.lean

full_name: Sbtw.dist_lt_max_dist
code: theorem Sbtw.dist_lt_max_dist (p : P) {p₁ p₂ p₃ : P} (h : Sbtw ℝ p₁ p₂ p₃) :
    dist p₂ p < max (dist p₁ p) (dist p₃ p) 
goal: dist p₂ p < max (dist p₁ p) (dist p₃ p)

full_name: Wbtw.dist_le_max_dist
code: theorem Wbtw.dist_le_max_dist (p : P) {p₁ p₂ p₃ : P} (h : Wbtw ℝ p₁ p₂ p₃) :
    dist p₂ p ≤ max (dist p₁ p) (dist p₃ p) 
goal: dist p₂ p ≤ max (dist p₁ p) (dist p₃ p)

full_name: Collinear.wbtw_of_dist_eq_of_dist_le
code: /-- Given three collinear points, two (not equal) with distance `r` from `p` and one with
distance at most `r` from `p`, the third point is weakly between the other two points. -/
theorem Collinear.wbtw_of_dist_eq_of_dist_le {p p₁ p₂ p₃ : P} {r : ℝ}
    (h : Collinear ℝ ({p₁, p₂, p₃} : Set P)) (hp₁ : dist p₁ p = r) (hp₂ : dist p₂ p ≤ r)
    (hp₃ : dist p₃ p = r) (hp₁p₃ : p₁ ≠ p₃) : Wbtw ℝ p₁ p₂ p₃ 
goal: Wbtw ℝ p₁ p₂ p₃

full_name: Collinear.sbtw_of_dist_eq_of_dist_lt
code: /-- Given three collinear points, two (not equal) with distance `r` from `p` and one with
distance less than `r` from `p`, the third point is strictly between the other two points. -/
theorem Collinear.sbtw_of_dist_eq_of_dist_lt {p p₁ p₂ p₃ : P} {r : ℝ}
    (h : Collinear ℝ ({p₁, p₂, p₃} : Set P)) (hp₁ : dist p₁ p = r) (hp₂ : dist p₂ p < r)
    (hp₃ : dist p₃ p = r) (hp₁p₃ : p₁ ≠ p₃) : Sbtw ℝ p₁ p₂ p₃ 
goal: Sbtw ℝ p₁ p₂ p₃

full_name: dist_add_dist_eq_iff
code: /-- In a strictly convex space, the triangle inequality turns into an equality if and only if the
middle point belongs to the segment joining two other points. -/
lemma dist_add_dist_eq_iff : dist a b + dist b c = dist a c ↔ Wbtw ℝ a b c 
goal: dist a b + dist b c = dist a c ↔ Wbtw ℝ a b c

full_name: eq_lineMap_of_dist_eq_mul_of_dist_eq_mul
code: lemma eq_lineMap_of_dist_eq_mul_of_dist_eq_mul (hxy : dist x y = r * dist x z)
    (hyz : dist y z = (1 - r) * dist x z) : y = AffineMap.lineMap x z r 
goal: y = (AffineMap.lineMap x z) r

full_name: eq_midpoint_of_dist_eq_half
code: lemma eq_midpoint_of_dist_eq_half (hx : dist x y = dist x z / 2) (hy : dist y z = dist x z / 2) :
    y = midpoint ℝ x z 
goal: y = midpoint ℝ x z

full_name: Isometry.affineIsometryOfStrictConvexSpace
code: /-- An isometry of `NormedAddTorsor`s for real normed spaces, strictly convex in the case of the
codomain, is an affine isometry.  Unlike Mazur-Ulam, this does not require the isometry to be
surjective. -/
noncomputable def affineIsometryOfStrictConvexSpace (hi : Isometry f) : PF →ᵃⁱ[ℝ] PE 
goal: PF →ᵃⁱ[ℝ] PE

full_name: Isometry.coe_affineIsometryOfStrictConvexSpace
code: @[simp] lemma coe_affineIsometryOfStrictConvexSpace (hi : Isometry f) :
    ⇑hi.affineIsometryOfStrictConvexSpace = f 
goal: ⇑hi.affineIsometryOfStrictConvexSpace = f

full_name: Isometry.affineIsometryOfStrictConvexSpace_apply
code: @[simp] lemma affineIsometryOfStrictConvexSpace_apply (hi : Isometry f) (p : PF) :
    hi.affineIsometryOfStrictConvexSpace p = f p 
goal: hi.affineIsometryOfStrictConvexSpace p = f p
File: Mathlib/Analysis/Convex/Cone/Closure.lean

full_name: ConvexCone.closure
code: /-- The closure of a convex cone inside a topological space as a convex cone. This
construction is mainly used for defining maps between proper cones. -/
protected def closure (K : ConvexCone 𝕜 E) : ConvexCone 𝕜 E 
goal: ConvexCone 𝕜 E

full_name: ConvexCone.coe_closure
code: @[simp, norm_cast]
theorem coe_closure (K : ConvexCone 𝕜 E) : (K.closure : Set E) = closure K 
goal: ↑K.closure = closure ↑K

full_name: ConvexCone.mem_closure
code: @[simp]
protected theorem mem_closure {K : ConvexCone 𝕜 E} {a : E} :
    a ∈ K.closure ↔ a ∈ closure (K : Set E) 
goal: a ∈ K.closure ↔ a ∈ closure ↑K

full_name: ConvexCone.closure_eq
code: @[simp]
theorem closure_eq {K L : ConvexCone 𝕜 E} : K.closure = L ↔ closure (K : Set E) = L 
goal: K.closure = L ↔ closure ↑K = ↑L

full_name: PointedCone.toConvexCone_closure_pointed
code: lemma toConvexCone_closure_pointed (K : PointedCone 𝕜 E) : (K : ConvexCone 𝕜 E).closure.Pointed 
goal: (↑K).closure.Pointed

full_name: PointedCone.closure
code: /-- The closure of a pointed cone inside a topological space as a pointed cone. This
construction is mainly used for defining maps between proper cones. -/
protected def closure (K : PointedCone 𝕜 E) : PointedCone 𝕜 E 
goal: PointedCone 𝕜 E

full_name: PointedCone.coe_closure
code: @[simp, norm_cast]
theorem coe_closure (K : PointedCone 𝕜 E) : (K.closure : Set E) = closure K 
goal: ↑K.closure = closure ↑K

full_name: PointedCone.mem_closure
code: @[simp]
protected theorem mem_closure {K : PointedCone 𝕜 E} {a : E} :
    a ∈ K.closure ↔ a ∈ closure (K : Set E) 
goal: a ∈ K.closure ↔ a ∈ closure ↑K

full_name: PointedCone.closure_eq
code: @[simp]
theorem closure_eq {K L : PointedCone 𝕜 E} : K.closure = L ↔ closure (K : Set E) = L 
goal: K.closure = L ↔ closure ↑K = ↑L
File: Mathlib/Analysis/Convex/Measure.lean

full_name: Convex.addHaar_frontier
code: /-- Haar measure of the frontier of a convex set is zero. -/
theorem addHaar_frontier (hs : Convex ℝ s) : μ (frontier s) = 0 
goal: μ (frontier s) = 0

full_name: Convex.nullMeasurableSet
code: /-- A convex set in a finite dimensional real vector space is null measurable with respect to an
additive Haar measure on this space. -/
protected theorem nullMeasurableSet (hs : Convex ℝ s) : NullMeasurableSet s μ 
goal: MeasureTheory.NullMeasurableSet s μ
File: Mathlib/Analysis/Convex/Cone/Extension.lean

full_name: RieszExtension.step
code: /-- Induction step in M. Riesz extension theorem. Given a convex cone `s` in a vector space `E`,
a partially defined linear map `f : f.domain → ℝ`, assume that `f` is nonnegative on `f.domain ∩ p`
and `p + s = E`. If `f` is not defined on the whole `E`, then we can extend it to a larger
submodule without breaking the non-negativity condition. -/
theorem step (nonneg : ∀ x : f.domain, (x : E) ∈ s → 0 ≤ f x)
    (dense : ∀ y, ∃ x : f.domain, (x : E) + y ∈ s) (hdom : f.domain ≠ ⊤) :
    ∃ g, f < g ∧ ∀ x : g.domain, (x : E) ∈ s → 0 ≤ g x 
goal: ∃ g, f < g ∧ ∀ (x : ↥g.domain), ↑x ∈ s → 0 ≤ ↑g x

full_name: RieszExtension.exists_top
code: theorem exists_top (p : E →ₗ.[ℝ] ℝ) (hp_nonneg : ∀ x : p.domain, (x : E) ∈ s → 0 ≤ p x)
    (hp_dense : ∀ y, ∃ x : p.domain, (x : E) + y ∈ s) :
    ∃ q ≥ p, q.domain = ⊤ ∧ ∀ x : q.domain, (x : E) ∈ s → 0 ≤ q x 
goal: ∃ q ≥ p, q.domain = ⊤ ∧ ∀ (x : ↥q.domain), ↑x ∈ s → 0 ≤ ↑q x

full_name: riesz_extension
code: /-- M. **Riesz extension theorem**: given a convex cone `s` in a vector space `E`, a submodule `p`,
and a linear `f : p → ℝ`, assume that `f` is nonnegative on `p ∩ s` and `p + s = E`. Then
there exists a globally defined linear function `g : E → ℝ` that agrees with `f` on `p`,
and is nonnegative on `s`. -/
theorem riesz_extension (s : ConvexCone ℝ E) (f : E →ₗ.[ℝ] ℝ)
    (nonneg : ∀ x : f.domain, (x : E) ∈ s → 0 ≤ f x)
    (dense : ∀ y, ∃ x : f.domain, (x : E) + y ∈ s) :
    ∃ g : E →ₗ[ℝ] ℝ, (∀ x : f.domain, g x = f x) ∧ ∀ x ∈ s, 0 ≤ g x 
goal: ∃ g, (∀ (x : ↥f.domain), g ↑x = ↑f x) ∧ ∀ x ∈ s, 0 ≤ g x

full_name: exists_extension_of_le_sublinear
code: /-- **Hahn-Banach theorem**: if `N : E → ℝ` is a sublinear map, `f` is a linear map
defined on a subspace of `E`, and `f x ≤ N x` for all `x` in the domain of `f`,
then `f` can be extended to the whole space to a linear map `g` such that `g x ≤ N x`
for all `x`. -/
theorem exists_extension_of_le_sublinear (f : E →ₗ.[ℝ] ℝ) (N : E → ℝ)
    (N_hom : ∀ c : ℝ, 0 < c → ∀ x, N (c • x) = c * N x) (N_add : ∀ x y, N (x + y) ≤ N x + N y)
    (hf : ∀ x : f.domain, f x ≤ N x) :
    ∃ g : E →ₗ[ℝ] ℝ, (∀ x : f.domain, g x = f x) ∧ ∀ x, g x ≤ N x 
goal: ∃ g, (∀ (x : ↥f.domain), g ↑x = ↑f x) ∧ ∀ (x : E), g x ≤ N x
File: Mathlib/Analysis/Convex/Extrema.lean

full_name: IsMinOn.of_isLocalMinOn_of_convexOn_Icc
code: /-- Helper lemma for the more general case: `IsMinOn.of_isLocalMinOn_of_convexOn`.
-/
theorem IsMinOn.of_isLocalMinOn_of_convexOn_Icc {f : ℝ → β} {a b : ℝ} (a_lt_b : a < b)
    (h_local_min : IsLocalMinOn f (Icc a b) a) (h_conv : ConvexOn ℝ (Icc a b) f) :
    IsMinOn f (Icc a b) a 
goal: IsMinOn f (Set.Icc a b) a

full_name: IsMinOn.of_isLocalMinOn_of_convexOn
code: /-- A local minimum of a convex function is a global minimum, restricted to a set `s`.
-/
theorem IsMinOn.of_isLocalMinOn_of_convexOn {f : E → β} {a : E} (a_in_s : a ∈ s)
    (h_localmin : IsLocalMinOn f s a) (h_conv : ConvexOn ℝ s f) : IsMinOn f s a 
goal: IsMinOn f s a

full_name: IsMaxOn.of_isLocalMaxOn_of_concaveOn
code: /-- A local maximum of a concave function is a global maximum, restricted to a set `s`. -/
theorem IsMaxOn.of_isLocalMaxOn_of_concaveOn {f : E → β} {a : E} (a_in_s : a ∈ s)
    (h_localmax : IsLocalMaxOn f s a) (h_conc : ConcaveOn ℝ s f) : IsMaxOn f s a 
goal: IsMaxOn f s a

full_name: IsMinOn.of_isLocalMin_of_convex_univ
code: /-- A local minimum of a convex function is a global minimum. -/
theorem IsMinOn.of_isLocalMin_of_convex_univ {f : E → β} {a : E} (h_local_min : IsLocalMin f a)
    (h_conv : ConvexOn ℝ univ f) : ∀ x, f a ≤ f x 
goal: f a ≤ f x

full_name: IsMaxOn.of_isLocalMax_of_convex_univ
code: /-- A local maximum of a concave function is a global maximum. -/
theorem IsMaxOn.of_isLocalMax_of_convex_univ {f : E → β} {a : E} (h_local_max : IsLocalMax f a)
    (h_conc : ConcaveOn ℝ univ f) : ∀ x, f x ≤ f a 
goal: f x ≤ f a
File: Mathlib/Analysis/Convex/Caratheodory.lean

full_name: Caratheodory.mem_convexHull_erase
code: /-- If `x` is in the convex hull of some finset `t` whose elements are not affine-independent,
then it is in the convex hull of a strict subset of `t`. -/
theorem mem_convexHull_erase [DecidableEq E] {t : Finset E} (h : ¬AffineIndependent 𝕜 ((↑) : t → E))
    {x : E} (m : x ∈ convexHull 𝕜 (↑t : Set E)) :
    ∃ y : (↑t : Set E), x ∈ convexHull 𝕜 (↑(t.erase y) : Set E) 
goal: ∃ y, x ∈ (convexHull 𝕜) ↑(t.erase ↑y)

full_name: Caratheodory.minCardFinsetOfMemConvexHull
code: /-- Given a point `x` in the convex hull of a set `s`, this is a finite subset of `s` of minimum
cardinality, whose convex hull contains `x`. -/
noncomputable def minCardFinsetOfMemConvexHull : Finset E 
goal: Finset E

full_name: Caratheodory.minCardFinsetOfMemConvexHull_subseteq
code: theorem minCardFinsetOfMemConvexHull_subseteq : ↑(minCardFinsetOfMemConvexHull hx) ⊆ s 
goal: ↑(Caratheodory.minCardFinsetOfMemConvexHull hx) ⊆ s

full_name: Caratheodory.mem_minCardFinsetOfMemConvexHull
code: theorem mem_minCardFinsetOfMemConvexHull :
    x ∈ convexHull 𝕜 (minCardFinsetOfMemConvexHull hx : Set E) 
goal: x ∈ (convexHull 𝕜) ↑(Caratheodory.minCardFinsetOfMemConvexHull hx)

full_name: Caratheodory.minCardFinsetOfMemConvexHull_nonempty
code: theorem minCardFinsetOfMemConvexHull_nonempty : (minCardFinsetOfMemConvexHull hx).Nonempty 
goal: (Caratheodory.minCardFinsetOfMemConvexHull hx).Nonempty

full_name: Caratheodory.minCardFinsetOfMemConvexHull_card_le_card
code: theorem minCardFinsetOfMemConvexHull_card_le_card {t : Finset E} (ht₁ : ↑t ⊆ s)
    (ht₂ : x ∈ convexHull 𝕜 (t : Set E)) : (minCardFinsetOfMemConvexHull hx).card ≤ t.card 
goal: (Caratheodory.minCardFinsetOfMemConvexHull hx).card ≤ t.card

full_name: Caratheodory.affineIndependent_minCardFinsetOfMemConvexHull
code: theorem affineIndependent_minCardFinsetOfMemConvexHull :
    AffineIndependent 𝕜 ((↑) : minCardFinsetOfMemConvexHull hx → E) 
goal: AffineIndependent 𝕜 Subtype.val

full_name: convexHull_eq_union
code: /-- **Carathéodory's convexity theorem** -/
theorem convexHull_eq_union : convexHull 𝕜 s =
    ⋃ (t : Finset E) (hss : ↑t ⊆ s) (hai : AffineIndependent 𝕜 ((↑) : t → E)), convexHull 𝕜 ↑t 
goal: (convexHull 𝕜) s = ⋃ t, ⋃ (_ : ↑t ⊆ s), ⋃ (_ : AffineIndependent 𝕜 Subtype.val), (convexHull 𝕜) ↑t

full_name: eq_pos_convex_span_of_mem_convexHull
code: /-- A more explicit version of `convexHull_eq_union`. -/
theorem eq_pos_convex_span_of_mem_convexHull {x : E} (hx : x ∈ convexHull 𝕜 s) :
    ∃ (ι : Sort (u + 1)) (_ : Fintype ι),
      ∃ (z : ι → E) (w : ι → 𝕜), Set.range z ⊆ s ∧ AffineIndependent 𝕜 z ∧ (∀ i, 0 < w i) ∧
        ∑ i, w i = 1 ∧ ∑ i, w i • z i = x 
goal: ∃ ι x_1 z w, Set.range z ⊆ s ∧ AffineIndependent 𝕜 z ∧ (∀ (i : ι), 0 < w i) ∧ ∑ i : ι, w i = 1 ∧ ∑ i : ι, w i • z i = x
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/ComplexDeriv.lean

full_name: Complex.hasStrictDerivAt_tan
code: theorem hasStrictDerivAt_tan {x : ℂ} (h : cos x ≠ 0) : HasStrictDerivAt tan (1 / cos x ^ 2) x 
goal: HasStrictDerivAt Complex.tan (1 / Complex.cos x ^ 2) x

full_name: Complex.hasDerivAt_tan
code: theorem hasDerivAt_tan {x : ℂ} (h : cos x ≠ 0) : HasDerivAt tan (1 / cos x ^ 2) x 
goal: HasDerivAt Complex.tan (1 / Complex.cos x ^ 2) x

full_name: Complex.tendsto_abs_tan_of_cos_eq_zero
code: theorem tendsto_abs_tan_of_cos_eq_zero {x : ℂ} (hx : cos x = 0) :
    Tendsto (fun x => abs (tan x)) (𝓝[≠] x) atTop 
goal: Filter.Tendsto (fun x => Complex.abs (Complex.tan x)) (nhdsWithin x {x}ᶜ) Filter.atTop

full_name: Complex.tendsto_abs_tan_atTop
code: theorem tendsto_abs_tan_atTop (k : ℤ) :
    Tendsto (fun x => abs (tan x)) (𝓝[≠] ((2 * k + 1) * π / 2 : ℂ)) atTop 
goal: Filter.Tendsto (fun x => Complex.abs (Complex.tan x))
  (nhdsWithin ((2 * ↑k + 1) * ↑Real.pi / 2) {(2 * ↑k + 1) * ↑Real.pi / 2}ᶜ) Filter.atTop

full_name: Complex.continuousAt_tan
code: @[simp]
theorem continuousAt_tan {x : ℂ} : ContinuousAt tan x ↔ cos x ≠ 0 
goal: ContinuousAt Complex.tan x ↔ Complex.cos x ≠ 0

full_name: Complex.differentiableAt_tan
code: @[simp]
theorem differentiableAt_tan {x : ℂ} : DifferentiableAt ℂ tan x ↔ cos x ≠ 0 
goal: DifferentiableAt ℂ Complex.tan x ↔ Complex.cos x ≠ 0

full_name: Complex.deriv_tan
code: @[simp]
theorem deriv_tan (x : ℂ) : deriv tan x = 1 / cos x ^ 2 
goal: deriv Complex.tan x = 1 / Complex.cos x ^ 2

full_name: Complex.contDiffAt_tan
code: @[simp]
theorem contDiffAt_tan {x : ℂ} {n : ℕ∞} : ContDiffAt ℂ n tan x ↔ cos x ≠ 0 
goal: ContDiffAt ℂ n Complex.tan x ↔ Complex.cos x ≠ 0
File: Mathlib/Analysis/SpecialFunctions/ContinuousFunctionalCalculus/ExpLog.lean

full_name: NormedSpace.exp_continuousMap_eq
code: lemma NormedSpace.exp_continuousMap_eq (f : C(α, 𝕜)) :
    exp 𝕜 f = (⟨exp 𝕜 ∘ f, exp_continuous.comp f.continuous⟩ : C(α, 𝕜)) 
goal: NormedSpace.exp 𝕜 f = { toFun := NormedSpace.exp 𝕜 ∘ ⇑f, continuous_toFun := ⋯ }

full_name: CFC.exp_eq_normedSpace_exp
code: lemma exp_eq_normedSpace_exp {a : A} (ha : p a := by cfc_tac) :
    cfc (exp 𝕜 : 𝕜 → 𝕜) a = exp 𝕜 a 
goal: cfc (NormedSpace.exp 𝕜) a = NormedSpace.exp 𝕜 a

full_name: CFC.real_exp_eq_normedSpace_exp
code: lemma real_exp_eq_normedSpace_exp {a : A} (ha : p a := by cfc_tac) :
    cfc Real.exp a = exp ℝ a 
goal: cfc Real.exp a = NormedSpace.exp ℝ a

full_name: CFC.complex_exp_eq_normedSpace_exp
code: lemma complex_exp_eq_normedSpace_exp {a : A} (ha : p a := by cfc_tac) :
    cfc Complex.exp a = exp ℂ a 
goal: cfc Complex.exp a = NormedSpace.exp ℂ a

full_name: CFC.log
code: /-- The real logarithm, defined via the continuous functional calculus. This can be used on
matrices, operators on a Hilbert space, elements of a C⋆-algebra, etc. -/
noncomputable def log (a : A) : A 
goal: A

full_name: IsSelfAdjoint.log
code: @[simp]
protected lemma _root_.IsSelfAdjoint.log {a : A} : IsSelfAdjoint (log a) 
goal: IsSelfAdjoint (CFC.log a)

full_name: CFC.log_exp
code: lemma log_exp (a : A) (ha : IsSelfAdjoint a := by cfc_tac) : log (NormedSpace.exp ℝ a) = a 
goal: CFC.log (NormedSpace.exp ℝ a) = a

full_name: CFC.exp_log
code: lemma exp_log (a : A) (ha₂ : ∀ x ∈ spectrum ℝ a, 0 < x) (ha₁ : IsSelfAdjoint a := by cfc_tac) :
    NormedSpace.exp ℝ (log a) = a 
goal: NormedSpace.exp ℝ (CFC.log a) = a

full_name: CFC.log_zero
code: @[simp] lemma log_zero : log (0 : A) = 0 
goal: CFC.log 0 = 0

full_name: CFC.log_one
code: @[simp] lemma log_one : log (1 : A) = 0 
goal: CFC.log 1 = 0

full_name: CFC.log_algebraMap
code: @[simp]
lemma log_algebraMap {r : ℝ} : log (algebraMap ℝ A r) = algebraMap ℝ A (Real.log r) 
goal: CFC.log ((algebraMap ℝ A) r) = (algebraMap ℝ A) (Real.log r)

full_name: CFC.log_smul
code: lemma log_smul {r : ℝ} (a : A) (ha₂ : ∀ x ∈ spectrum ℝ a, 0 < x) (hr : 0 < r)
    (ha₁ : IsSelfAdjoint a := by cfc_tac) :
    log (r • a) = algebraMap ℝ A (Real.log r) + log a 
goal: CFC.log (r • a) = (algebraMap ℝ A) (Real.log r) + CFC.log a

full_name: CFC.log_pow
code: lemma log_pow (n : ℕ) (a : A) (ha₂ : ∀ x ∈ spectrum ℝ a, 0 < x)
    (ha₁ : IsSelfAdjoint a := by cfc_tac) : log (a ^ n) = n • log a 
goal: CFC.log (a ^ n) = n • CFC.log a
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Chebyshev.lean

full_name: Polynomial.Chebyshev.aeval_T
code: @[simp]
theorem aeval_T (x : A) (n : ℤ) : aeval x (T R n) = (T A n).eval x 
goal: (Polynomial.aeval x) (Polynomial.Chebyshev.T R n) = Polynomial.eval x (Polynomial.Chebyshev.T A n)

full_name: Polynomial.Chebyshev.aeval_U
code: @[simp]
theorem aeval_U (x : A) (n : ℤ) : aeval x (U R n) = (U A n).eval x 
goal: (Polynomial.aeval x) (Polynomial.Chebyshev.U R n) = Polynomial.eval x (Polynomial.Chebyshev.U A n)

full_name: Polynomial.Chebyshev.algebraMap_eval_T
code: @[simp]
theorem algebraMap_eval_T (x : R) (n : ℤ) :
    algebraMap R A ((T R n).eval x) = (T A n).eval (algebraMap R A x) 
goal: (algebraMap R A) (Polynomial.eval x (Polynomial.Chebyshev.T R n)) =
  Polynomial.eval ((algebraMap R A) x) (Polynomial.Chebyshev.T A n)

full_name: Polynomial.Chebyshev.algebraMap_eval_U
code: @[simp]
theorem algebraMap_eval_U (x : R) (n : ℤ) :
    algebraMap R A ((U R n).eval x) = (U A n).eval (algebraMap R A x) 
goal: (algebraMap R A) (Polynomial.eval x (Polynomial.Chebyshev.U R n)) =
  Polynomial.eval ((algebraMap R A) x) (Polynomial.Chebyshev.U A n)

full_name: Polynomial.Chebyshev.complex_ofReal_eval_T
code: @[simp, norm_cast]
theorem complex_ofReal_eval_T : ∀ (x : ℝ) n, (((T ℝ n).eval x : ℝ) : ℂ) = (T ℂ n).eval (x : ℂ) 
goal: ↑(Polynomial.eval x (Polynomial.Chebyshev.T ℝ n)) = Polynomial.eval (↑x) (Polynomial.Chebyshev.T ℂ n)

full_name: Polynomial.Chebyshev.complex_ofReal_eval_U
code: @[simp, norm_cast]
theorem complex_ofReal_eval_U : ∀ (x : ℝ) n, (((U ℝ n).eval x : ℝ) : ℂ) = (U ℂ n).eval (x : ℂ) 
goal: ↑(Polynomial.eval x (Polynomial.Chebyshev.U ℝ n)) = Polynomial.eval (↑x) (Polynomial.Chebyshev.U ℂ n)

full_name: Polynomial.Chebyshev.T_complex_cos
code: /-- The `n`-th Chebyshev polynomial of the first kind evaluates on `cos θ` to the
value `cos (n * θ)`. -/
@[simp]
theorem T_complex_cos (n : ℤ) : (T ℂ n).eval (cos θ) = cos (n * θ) 
goal: Polynomial.eval (Complex.cos θ) (Polynomial.Chebyshev.T ℂ n) = Complex.cos (↑n * θ)

full_name: Polynomial.Chebyshev.U_complex_cos
code: /-- The `n`-th Chebyshev polynomial of the second kind evaluates on `cos θ` to the
value `sin ((n + 1) * θ) / sin θ`. -/
@[simp]
theorem U_complex_cos (n : ℤ) : (U ℂ n).eval (cos θ) * sin θ = sin ((n + 1) * θ) 
goal: Polynomial.eval (Complex.cos θ) (Polynomial.Chebyshev.U ℂ n) * Complex.sin θ = Complex.sin ((↑n + 1) * θ)

full_name: Polynomial.Chebyshev.T_real_cos
code: /-- The `n`-th Chebyshev polynomial of the first kind evaluates on `cos θ` to the
value `cos (n * θ)`. -/
@[simp]
theorem T_real_cos : (T ℝ n).eval (cos θ) = cos (n * θ) 
goal: Polynomial.eval (Real.cos θ) (Polynomial.Chebyshev.T ℝ n) = Real.cos (↑n * θ)

full_name: Polynomial.Chebyshev.U_real_cos
code: /-- The `n`-th Chebyshev polynomial of the second kind evaluates on `cos θ` to the
value `sin ((n + 1) * θ) / sin θ`. -/
@[simp]
theorem U_real_cos : (U ℝ n).eval (cos θ) * sin θ = sin ((n + 1) * θ) 
goal: Polynomial.eval (Real.cos θ) (Polynomial.Chebyshev.U ℝ n) * Real.sin θ = Real.sin ((↑n + 1) * θ)
File: Mathlib/Analysis/SpecialFunctions/PolynomialExp.lean

full_name: Polynomial.tendsto_div_exp_atTop
code: theorem tendsto_div_exp_atTop (p : ℝ[X]) : Tendsto (fun x ↦ p.eval x / exp x) atTop (𝓝 0) 
goal: Filter.Tendsto (fun x => Polynomial.eval x p / rexp x) Filter.atTop (𝓝 0)
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Cotangent.lean

full_name: Complex.cot_eq_exp_ratio
code: lemma Complex.cot_eq_exp_ratio (z : ℂ) :
    cot z = (Complex.exp (2 * I * z) + 1) / (I * (1 - Complex.exp (2 * I * z))) 
goal: z.cot = (cexp (2 * Complex.I * z) + 1) / (Complex.I * (1 - cexp (2 * Complex.I * z)))

full_name: Complex.cot_pi_eq_exp_ratio
code: lemma Complex.cot_pi_eq_exp_ratio (z : ℂ) :
    cot (π * z) = (Complex.exp (2 * π * I * z) + 1) / (I * (1 - Complex.exp (2 * π * I * z))) 
goal: (↑π * z).cot = (cexp (2 * ↑π * Complex.I * z) + 1) / (Complex.I * (1 - cexp (2 * ↑π * Complex.I * z)))

full_name: pi_mul_cot_pi_q_exp
code: theorem pi_mul_cot_pi_q_exp (z : ℍ) :
    π * cot (π * z) = π * I - 2 * π * I * ∑' n : ℕ, Complex.exp (2 * π * I * z) ^ n 
goal: ↑π * (↑π * ↑z).cot = ↑π * Complex.I - 2 * ↑π * Complex.I * ∑' (n : ℕ), cexp (2 * ↑π * Complex.I * ↑z) ^ n
File: Mathlib/Analysis/SpecialFunctions/Log/ERealExp.lean

full_name: EReal.exp
code: /-- Exponential as a function from `EReal` to `ℝ≥0∞`. -/
noncomputable
def exp : EReal → ℝ≥0∞
  
goal: EReal → ENNReal

full_name: EReal.exp_bot
code: @[simp] lemma exp_bot : exp ⊥ = 0 
goal: ⊥.exp = 0

full_name: EReal.exp_zero
code: @[simp] lemma exp_zero : exp 0 = 1 
goal: EReal.exp 0 = 1

full_name: EReal.exp_top
code: @[simp] lemma exp_top : exp ⊤ = ∞ 
goal: ⊤.exp = ⊤

full_name: EReal.exp_coe
code: @[simp] lemma exp_coe (x : ℝ) : exp x = ENNReal.ofReal (Real.exp x) 
goal: (↑x).exp = ENNReal.ofReal (Real.exp x)

full_name: EReal.exp_eq_zero_iff
code: @[simp] lemma exp_eq_zero_iff {x : EReal} : exp x = 0 ↔ x = ⊥ 
goal: x.exp = 0 ↔ x = ⊥

full_name: EReal.exp_eq_top_iff
code: @[simp] lemma exp_eq_top_iff {x : EReal} : exp x = ∞ ↔ x = ⊤ 
goal: x.exp = ⊤ ↔ x = ⊤

full_name: EReal.exp_strictMono
code: lemma exp_strictMono : StrictMono exp 
goal: StrictMono EReal.exp

full_name: EReal.exp_monotone
code: lemma exp_monotone : Monotone exp 
goal: Monotone EReal.exp

full_name: EReal.exp_lt_exp_iff
code: @[simp] lemma exp_lt_exp_iff {a b : EReal} : exp a < exp b ↔ a < b 
goal: a.exp < b.exp ↔ a < b

full_name: EReal.zero_lt_exp_iff
code: @[simp] lemma zero_lt_exp_iff {a : EReal} : 0 < exp a ↔ ⊥ < a 
goal: 0 < a.exp ↔ ⊥ < a

full_name: EReal.exp_lt_top_iff
code: @[simp] lemma exp_lt_top_iff {a : EReal} : exp a < ⊤ ↔ a < ⊤ 
goal: a.exp < ⊤ ↔ a < ⊤

full_name: EReal.exp_lt_one_iff
code: @[simp] lemma exp_lt_one_iff {a : EReal} : exp a < 1 ↔ a < 0 
goal: a.exp < 1 ↔ a < 0

full_name: EReal.one_lt_exp_iff
code: @[simp] lemma one_lt_exp_iff {a : EReal} : 1 < exp a ↔ 0 < a 
goal: 1 < a.exp ↔ 0 < a

full_name: EReal.exp_le_exp_iff
code: @[simp] lemma exp_le_exp_iff {a b : EReal} : exp a ≤ exp b ↔ a ≤ b 
goal: a.exp ≤ b.exp ↔ a ≤ b

full_name: EReal.exp_le_one_iff
code: @[simp] lemma exp_le_one_iff {a : EReal} : exp a ≤ 1 ↔ a ≤ 0 
goal: a.exp ≤ 1 ↔ a ≤ 0

full_name: EReal.one_le_exp_iff
code: @[simp] lemma one_le_exp_iff {a : EReal} : 1 ≤ exp a ↔ 0 ≤ a 
goal: 1 ≤ a.exp ↔ 0 ≤ a

full_name: EReal.exp_neg
code: lemma exp_neg (x : EReal) : exp (-x) = (exp x)⁻¹ 
goal: (-x).exp = x.exp⁻¹

full_name: EReal.exp_add
code: lemma exp_add (x y : EReal) : exp (x + y) = exp x * exp y 
goal: (x + y).exp = x.exp * y.exp
File: Mathlib/Analysis/SpecialFunctions/Log/Monotone.lean

full_name: Real.log_mul_self_monotoneOn
code: theorem log_mul_self_monotoneOn : MonotoneOn (fun x : ℝ => log x * x) { x | 1 ≤ x } 
goal: MonotoneOn (fun x => Real.log x * x) {x | 1 ≤ x}

full_name: Real.log_div_self_antitoneOn
code: theorem log_div_self_antitoneOn : AntitoneOn (fun x : ℝ => log x / x) { x | exp 1 ≤ x } 
goal: AntitoneOn (fun x => Real.log x / x) {x | Real.exp 1 ≤ x}

full_name: Real.log_div_self_rpow_antitoneOn
code: theorem log_div_self_rpow_antitoneOn {a : ℝ} (ha : 0 < a) :
    AntitoneOn (fun x : ℝ => log x / x ^ a) { x | exp (1 / a) ≤ x } 
goal: AntitoneOn (fun x => Real.log x / x ^ a) {x | Real.exp (1 / a) ≤ x}

full_name: Real.log_div_sqrt_antitoneOn
code: theorem log_div_sqrt_antitoneOn : AntitoneOn (fun x : ℝ => log x / √x) { x | exp 2 ≤ x } 
goal: AntitoneOn (fun x => Real.log x / √x) {x | Real.exp 2 ≤ x}