ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Analysis/RCLike/Lemmas.lean

full_name: Polynomial.ofReal_eval
code: theorem ofReal_eval (p : ℝ[X]) (x : ℝ) : (↑(p.eval x) : K) = aeval (↑x) p 
goal: ↑(Polynomial.eval x p) = (Polynomial.aeval ↑x) p

full_name: FiniteDimensional.rclike_to_real
code: /-- An `RCLike` field is finite-dimensional over `ℝ`, since it is spanned by `{1, I}`. -/
-- Porting note(#12094): removed nolint; dangerous_instance linter not ported yet
-- @[nolint dangerous_instance]
instance rclike_to_real : FiniteDimensional ℝ K 
goal: FiniteDimensional ℝ K

full_name: FiniteDimensional.proper_rclike
code: /-- A finite dimensional vector space over an `RCLike` is a proper metric space.

This is not an instance because it would cause a search for `FiniteDimensional ?x E` before
`RCLike ?x`. -/
theorem proper_rclike [FiniteDimensional K E] : ProperSpace E 
goal: ProperSpace E

full_name: FiniteDimensional.RCLike.properSpace_submodule
code: instance RCLike.properSpace_submodule (S : Submodule K E) [FiniteDimensional K S] :
    ProperSpace S 
goal: ProperSpace ↥S

full_name: RCLike.reCLM_norm
code: @[simp, rclike_simps]
theorem reCLM_norm : ‖(reCLM : K →L[ℝ] ℝ)‖ = 1 
goal: ‖RCLike.reCLM‖ = 1

full_name: RCLike.conjCLE_norm
code: @[simp, rclike_simps]
theorem conjCLE_norm : ‖(@conjCLE K _ : K →L[ℝ] K)‖ = 1 
goal: ‖↑RCLike.conjCLE‖ = 1

full_name: RCLike.ofRealCLM_norm
code: @[simp, rclike_simps]
theorem ofRealCLM_norm : ‖(ofRealCLM : ℝ →L[ℝ] K)‖ = 1 
goal: ‖RCLike.ofRealCLM‖ = 1

full_name: Polynomial.aeval_conj
code: lemma aeval_conj (p : ℝ[X]) (z : K) : aeval (conj z) p = conj (aeval z p) 
goal: (Polynomial.aeval ((starRingEnd K) z)) p = (starRingEnd K) ((Polynomial.aeval z) p)

full_name: Polynomial.aeval_ofReal
code: lemma aeval_ofReal (p : ℝ[X]) (x : ℝ) : aeval (RCLike.ofReal x : K) p = eval x p 
goal: (Polynomial.aeval ↑x) p = ↑(Polynomial.eval x p)
File: Mathlib/MeasureTheory/Group/GeometryOfNumbers.lean

full_name: MeasureTheory.exists_pair_mem_lattice_not_disjoint_vadd
code: /-- **Blichfeldt's Theorem**. If the volume of the set `s` is larger than the covolume of the
countable subgroup `L` of `E`, then there exist two distinct points `x, y ∈ L` such that `(x + s)`
and `(y + s)` are not disjoint. -/
theorem exists_pair_mem_lattice_not_disjoint_vadd [AddCommGroup L] [Countable L] [AddAction L E]
    [MeasurableSpace L] [MeasurableVAdd L E] [VAddInvariantMeasure L E μ]
    (fund : IsAddFundamentalDomain L F μ) (hS : NullMeasurableSet s μ) (h : μ F < μ s) :
    ∃ x y : L, x ≠ y ∧ ¬Disjoint (x +ᵥ s) (y +ᵥ s) 
goal: ∃ x y, x ≠ y ∧ ¬Disjoint (x +ᵥ s) (y +ᵥ s)

full_name: MeasureTheory.exists_ne_zero_mem_lattice_of_measure_mul_two_pow_lt_measure
code: /-- The **Minkowski Convex Body Theorem**. If `s` is a convex symmetric domain of `E` whose volume
is large enough compared to the covolume of a lattice `L` of `E`, then it contains a non-zero
lattice point of `L`.  -/
theorem exists_ne_zero_mem_lattice_of_measure_mul_two_pow_lt_measure [NormedAddCommGroup E]
    [NormedSpace ℝ E] [BorelSpace E] [FiniteDimensional ℝ E] [IsAddHaarMeasure μ]
    {L : AddSubgroup E} [Countable L] (fund : IsAddFundamentalDomain L F μ)
    (h_symm : ∀ x ∈ s, -x ∈ s) (h_conv : Convex ℝ s) (h : μ F * 2 ^ finrank ℝ E < μ s) :
    ∃ x ≠ 0, ((x : L) : E) ∈ s 
goal: ∃ x, x ≠ 0 ∧ ↑x ∈ s

full_name: MeasureTheory.exists_ne_zero_mem_lattice_of_measure_mul_two_pow_le_measure
code: /-- The **Minkowski Convex Body Theorem for compact domain**. If `s` is a convex compact symmetric
domain of `E` whose volume is large enough compared to the covolume of a lattice `L` of `E`, then it
contains a non-zero lattice point of `L`. Compared to
`exists_ne_zero_mem_lattice_of_measure_mul_two_pow_lt_measure`, this version requires in addition
that `s` is compact and `L` is discrete but provides a weaker inequality rather than a strict
inequality. -/
theorem exists_ne_zero_mem_lattice_of_measure_mul_two_pow_le_measure [NormedAddCommGroup E]
    [NormedSpace ℝ E] [BorelSpace E] [FiniteDimensional ℝ E] [Nontrivial E] [IsAddHaarMeasure μ]
    {L : AddSubgroup E} [Countable L] [DiscreteTopology L] (fund : IsAddFundamentalDomain L F μ)
    (h_symm : ∀ x ∈ s, -x ∈ s) (h_conv : Convex ℝ s) (h_cpt : IsCompact s)
    (h : μ F * 2 ^ finrank ℝ E ≤ μ s) :
    ∃ x ≠ 0, ((x : L) : E) ∈ s 
goal: ∃ x, x ≠ 0 ∧ ↑x ∈ s
File: Mathlib/Analysis/Analytic/RadiusLiminf.lean

full_name: FormalMultilinearSeries.radius_eq_liminf
code: /-- The radius of a formal multilinear series is equal to
$\liminf_{n\to\infty} \frac{1}{\sqrt[n]{‖p n‖}}$. The actual statement uses `ℝ≥0` and some
coercions. -/
theorem radius_eq_liminf :
    p.radius = liminf (fun n => (1 / (‖p n‖₊ ^ (1 / (n : ℝ)) : ℝ≥0) : ℝ≥0∞)) atTop 
goal: p.radius = Filter.liminf (fun n => 1 / ↑(‖p n‖₊ ^ (1 / ↑n))) Filter.atTop
File: Mathlib/Analysis/Analytic/Polynomial.lean

full_name: AnalyticAt.aeval_polynomial
code: theorem AnalyticAt.aeval_polynomial (hf : AnalyticAt 𝕜 f z) (p : A[X]) :
    AnalyticAt 𝕜 (fun x ↦ aeval (f x) p) z 
goal: AnalyticAt 𝕜 (fun x => (Polynomial.aeval (f x)) p) z

full_name: AnalyticOn.aeval_polynomial
code: theorem AnalyticOn.aeval_polynomial (hf : AnalyticOn 𝕜 f s) (p : A[X]) :
    AnalyticOn 𝕜 (fun x ↦ aeval (f x) p) s 
goal: AnalyticOn 𝕜 (fun x => (Polynomial.aeval (f x)) p) s

full_name: AnalyticOn.eval_polynomial
code: theorem AnalyticOn.eval_polynomial {A} [NormedCommRing A] [NormedAlgebra 𝕜 A] (p : A[X]) :
    AnalyticOn 𝕜 (eval · p) Set.univ 
goal: AnalyticOn 𝕜 (fun x => Polynomial.eval x p) Set.univ

full_name: AnalyticAt.aeval_mvPolynomial
code: theorem AnalyticAt.aeval_mvPolynomial (hf : ∀ i, AnalyticAt 𝕜 (f · i) z) (p : MvPolynomial σ A) :
    AnalyticAt 𝕜 (fun x ↦ aeval (f x) p) z 
goal: AnalyticAt 𝕜 (fun x => (MvPolynomial.aeval (f x)) p) z

full_name: AnalyticOn.aeval_mvPolynomial
code: theorem AnalyticOn.aeval_mvPolynomial (hf : ∀ i, AnalyticOn 𝕜 (f · i) s) (p : MvPolynomial σ A) :
    AnalyticOn 𝕜 (fun x ↦ aeval (f x) p) s 
goal: AnalyticOn 𝕜 (fun x => (MvPolynomial.aeval (f x)) p) s

full_name: AnalyticOn.eval_continuousLinearMap
code: theorem AnalyticOn.eval_continuousLinearMap (f : E →L[𝕜] σ → B) (p : MvPolynomial σ B) :
    AnalyticOn 𝕜 (fun x ↦ eval (f x) p) Set.univ 
goal: AnalyticOn 𝕜 (fun x => (MvPolynomial.eval (f x)) p) Set.univ

full_name: AnalyticOn.eval_continuousLinearMap'
code: theorem AnalyticOn.eval_continuousLinearMap' (f : σ → E →L[𝕜] B) (p : MvPolynomial σ B) :
    AnalyticOn 𝕜 (fun x ↦ eval (f · x) p) Set.univ 
goal: AnalyticOn 𝕜 (fun x => (MvPolynomial.eval fun x_1 => (f x_1) x) p) Set.univ

full_name: AnalyticOn.eval_linearMap
code: theorem AnalyticOn.eval_linearMap (f : E →ₗ[𝕜] σ → B) (p : MvPolynomial σ B) :
    AnalyticOn 𝕜 (fun x ↦ eval (f x) p) Set.univ 
goal: AnalyticOn 𝕜 (fun x => (MvPolynomial.eval (f x)) p) Set.univ

full_name: AnalyticOn.eval_linearMap'
code: theorem AnalyticOn.eval_linearMap' (f : σ → E →ₗ[𝕜] B) (p : MvPolynomial σ B) :
    AnalyticOn 𝕜 (fun x ↦ eval (f · x) p) Set.univ 
goal: AnalyticOn 𝕜 (fun x => (MvPolynomial.eval fun x_1 => (f x_1) x) p) Set.univ

full_name: AnalyticOn.eval_mvPolynomial
code: theorem AnalyticOn.eval_mvPolynomial [Fintype σ] (p : MvPolynomial σ 𝕜) :
    AnalyticOn 𝕜 (eval · p) Set.univ 
goal: AnalyticOn 𝕜 (fun x => (MvPolynomial.eval x) p) Set.univ
File: Mathlib/Analysis/Analytic/Uniqueness.lean

full_name: AnalyticOn.eqOn_zero_of_preconnected_of_eventuallyEq_zero_aux
code: /-- If an analytic function vanishes around a point, then it is uniformly zero along
a connected set. Superseded by `eqOn_zero_of_preconnected_of_locally_zero` which does not assume
completeness of the target space. -/
theorem eqOn_zero_of_preconnected_of_eventuallyEq_zero_aux [CompleteSpace F] {f : E → F} {U : Set E}
    (hf : AnalyticOn 𝕜 f U) (hU : IsPreconnected U) {z₀ : E} (h₀ : z₀ ∈ U) (hfz₀ : f =ᶠ[𝓝 z₀] 0) :
    EqOn f 0 U 
goal: Set.EqOn f 0 U

full_name: AnalyticOn.eqOn_zero_of_preconnected_of_eventuallyEq_zero
code: /-- The *identity principle* for analytic functions: If an analytic function vanishes in a whole
neighborhood of a point `z₀`, then it is uniformly zero along a connected set. For a one-dimensional
version assuming only that the function vanishes at some points arbitrarily close to `z₀`, see
`eqOn_zero_of_preconnected_of_frequently_eq_zero`. -/
theorem eqOn_zero_of_preconnected_of_eventuallyEq_zero {f : E → F} {U : Set E}
    (hf : AnalyticOn 𝕜 f U) (hU : IsPreconnected U) {z₀ : E} (h₀ : z₀ ∈ U) (hfz₀ : f =ᶠ[𝓝 z₀] 0) :
    EqOn f 0 U 
goal: Set.EqOn f 0 U

full_name: AnalyticOn.eqOn_of_preconnected_of_eventuallyEq
code: /-- The *identity principle* for analytic functions: If two analytic functions coincide in a whole
neighborhood of a point `z₀`, then they coincide globally along a connected set.
For a one-dimensional version assuming only that the functions coincide at some points
arbitrarily close to `z₀`, see `eqOn_of_preconnected_of_frequently_eq`. -/
theorem eqOn_of_preconnected_of_eventuallyEq {f g : E → F} {U : Set E} (hf : AnalyticOn 𝕜 f U)
    (hg : AnalyticOn 𝕜 g U) (hU : IsPreconnected U) {z₀ : E} (h₀ : z₀ ∈ U) (hfg : f =ᶠ[𝓝 z₀] g) :
    EqOn f g U 
goal: Set.EqOn f g U

full_name: AnalyticOn.eq_of_eventuallyEq
code: /-- The *identity principle* for analytic functions: If two analytic functions on a normed space
coincide in a neighborhood of a point `z₀`, then they coincide everywhere.
For a one-dimensional version assuming only that the functions coincide at some points
arbitrarily close to `z₀`, see `eq_of_frequently_eq`. -/
theorem eq_of_eventuallyEq {f g : E → F} [PreconnectedSpace E] (hf : AnalyticOn 𝕜 f univ)
    (hg : AnalyticOn 𝕜 g univ) {z₀ : E} (hfg : f =ᶠ[𝓝 z₀] g) : f = g 
goal: f = g
File: Mathlib/Analysis/InnerProductSpace/ProdL2.lean

full_name: WithLp.instProdInnerProductSpace
code: noncomputable instance instProdInnerProductSpace :
    InnerProductSpace 𝕜 (WithLp 2 (E × F)) 
goal: InnerProductSpace 𝕜 (WithLp 2 (E × F))

full_name: WithLp.prod_inner_apply
code: @[simp]
theorem prod_inner_apply (x y : WithLp 2 (E × F)) :
    inner (𝕜 := 𝕜) x y = inner x.fst y.fst + inner x.snd y.snd 
goal: ⟪x, y⟫_𝕜 = ⟪x.1, y.1⟫_𝕜 + ⟪x.2, y.2⟫_𝕜

full_name: OrthonormalBasis.prod
code: /-- The product of two orthonormal bases is a basis for the L2-product. -/
def prod (v : OrthonormalBasis ι₁ 𝕜 E) (w : OrthonormalBasis ι₂ 𝕜 F) :
    OrthonormalBasis (ι₁ ⊕ ι₂) 𝕜 (WithLp 2 (E × F)) 
goal: OrthonormalBasis (ι₁ ⊕ ι₂) 𝕜 (WithLp 2 (E × F))

full_name: OrthonormalBasis.prod_apply
code: @[simp] theorem prod_apply (v : OrthonormalBasis ι₁ 𝕜 E) (w : OrthonormalBasis ι₂ 𝕜 F) :
    ∀ i : ι₁ ⊕ ι₂, v.prod w i =
      Sum.elim ((LinearMap.inl 𝕜 E F) ∘ v) ((LinearMap.inr 𝕜 E F) ∘ w) i 
goal: (v.prod w) i = Sum.elim (⇑(LinearMap.inl 𝕜 E F) ∘ ⇑v) (⇑(LinearMap.inr 𝕜 E F) ∘ ⇑w) i
File: Mathlib/Analysis/InnerProductSpace/ConformalLinearMap.lean

full_name: isConformalMap_iff
code: /-- A map between two inner product spaces is a conformal map if and only if it preserves inner
products up to a scalar factor, i.e., there exists a positive `c : ℝ` such that
`⟪f u, f v⟫ = c * ⟪u, v⟫` for all `u`, `v`. -/
theorem isConformalMap_iff (f : E →L[ℝ] F) :
    IsConformalMap f ↔ ∃ c : ℝ, 0 < c ∧ ∀ u v : E, ⟪f u, f v⟫ = c * ⟪u, v⟫ 
goal: IsConformalMap f ↔ ∃ c, 0 < c ∧ ∀ (u v : E), ⟪f u, f v⟫_ℝ = c * ⟪u, v⟫_ℝ
File: Mathlib/MeasureTheory/Decomposition/UnsignedHahn.lean

full_name: MeasureTheory.hahn_decomposition
code: /-- **Hahn decomposition theorem** -/
theorem hahn_decomposition [IsFiniteMeasure μ] [IsFiniteMeasure ν] :
    ∃ s,
      MeasurableSet s ∧
        (∀ t, MeasurableSet t → t ⊆ s → ν t ≤ μ t) ∧ ∀ t, MeasurableSet t → t ⊆ sᶜ → μ t ≤ ν t 
goal: ∃ s,
  MeasurableSet s ∧
    (∀ (t : Set α), MeasurableSet t → t ⊆ s → ν t ≤ μ t) ∧ ∀ (t : Set α), MeasurableSet t → t ⊆ sᶜ → μ t ≤ ν t
File: Mathlib/Analysis/InnerProductSpace/LaxMilgram.lean

full_name: IsCoercive.«_aux_Mathlib_Analysis_InnerProductSpace_LaxMilgram___macroRules_IsCoercive_term_♯_1»
code: local postfix:1024 "♯" => @continuousLinearMapOfBilin ℝ V _ _ _ _
goal: Lean.Macro

full_name: IsCoercive.bounded_below
code: theorem bounded_below (coercive : IsCoercive B) : ∃ C, 0 < C ∧ ∀ v, C * ‖v‖ ≤ ‖B♯ v‖ 
goal: ∃ C, 0 < C ∧ ∀ (v : V), C * ‖v‖ ≤ ‖(InnerProductSpace.continuousLinearMapOfBilin B) v‖

full_name: IsCoercive.antilipschitz
code: theorem antilipschitz (coercive : IsCoercive B) : ∃ C : ℝ≥0, 0 < C ∧ AntilipschitzWith C B♯ 
goal: ∃ C, 0 < C ∧ AntilipschitzWith C ⇑(InnerProductSpace.continuousLinearMapOfBilin B)

full_name: IsCoercive.ker_eq_bot
code: theorem ker_eq_bot (coercive : IsCoercive B) : ker B♯ = ⊥ 
goal: LinearMap.ker (InnerProductSpace.continuousLinearMapOfBilin B) = ⊥

full_name: IsCoercive.isClosed_range
code: theorem isClosed_range (coercive : IsCoercive B) : IsClosed (range B♯ : Set V) 
goal: IsClosed ↑(LinearMap.range (InnerProductSpace.continuousLinearMapOfBilin B))

full_name: IsCoercive.range_eq_top
code: theorem range_eq_top (coercive : IsCoercive B) : range B♯ = ⊤ 
goal: LinearMap.range (InnerProductSpace.continuousLinearMapOfBilin B) = ⊤

full_name: IsCoercive.continuousLinearEquivOfBilin
code: /-- The Lax-Milgram equivalence of a coercive bounded bilinear operator:
for all `v : V`, `continuousLinearEquivOfBilin B v` is the unique element `V`
such that `continuousLinearEquivOfBilin B v, w⟫ = B v w`.
The Lax-Milgram theorem states that this is a continuous equivalence.
-/
def continuousLinearEquivOfBilin (coercive : IsCoercive B) : V ≃L[ℝ] V 
goal: V ≃L[ℝ] V

full_name: IsCoercive.continuousLinearEquivOfBilin_apply
code: @[simp]
theorem continuousLinearEquivOfBilin_apply (coercive : IsCoercive B) (v w : V) :
    ⟪coercive.continuousLinearEquivOfBilin v, w⟫_ℝ = B v w 
goal: ⟪coercive.continuousLinearEquivOfBilin v, w⟫_ℝ = (B v) w

full_name: IsCoercive.unique_continuousLinearEquivOfBilin
code: theorem unique_continuousLinearEquivOfBilin (coercive : IsCoercive B) {v f : V}
    (is_lax_milgram : ∀ w, ⟪f, w⟫_ℝ = B v w) : f = coercive.continuousLinearEquivOfBilin v 
goal: f = coercive.continuousLinearEquivOfBilin v
File: Mathlib/Analysis/InnerProductSpace/WeakOperatorTopology.lean

full_name: ContinuousLinearMapWOT.ext_inner
code: @[ext]
lemma ext_inner {A B : E →WOT[𝕜] F} (h : ∀ x y, ⟪y, A x⟫_𝕜 = ⟪y, B x⟫_𝕜) : A = B 
goal: A = B

full_name: ContinuousLinearMapWOT.ext_inner_iff
code: lemma ext_inner_iff {A B : E →WOT[𝕜] F} : A = B ↔ ∀ x y, ⟪y, A x⟫_𝕜 = ⟪y, B x⟫_𝕜 
goal: A = B ↔ ∀ (x : E) (y : F), ⟪y, A x⟫_𝕜 = ⟪y, B x⟫_𝕜

full_name: ContinuousLinearMapWOT.tendsto_iff_forall_inner_apply_tendsto
code: /-- The defining property of the weak operator topology: a function `f` tends to
`A : E →WOT[𝕜] F` along filter `l` iff `⟪y, (f a) x⟫` tends to `⟪y, A x⟫` along the same filter. -/
lemma tendsto_iff_forall_inner_apply_tendsto [CompleteSpace F] {α : Type*} {l : Filter α}
    {f : α → E →WOT[𝕜] F} {A : E →WOT[𝕜] F} :
    Tendsto f l (𝓝 A) ↔ ∀ x y, Tendsto (fun a => ⟪y, (f a) x⟫_𝕜) l (𝓝 ⟪y, A x⟫_𝕜) 
goal: Filter.Tendsto f l (𝓝 A) ↔ ∀ (x : E) (y : F), Filter.Tendsto (fun a => ⟪y, (f a) x⟫_𝕜) l (𝓝 ⟪y, A x⟫_𝕜)

full_name: ContinuousLinearMapWOT.le_nhds_iff_forall_inner_apply_le_nhds
code: lemma le_nhds_iff_forall_inner_apply_le_nhds [CompleteSpace F] {l : Filter (E →WOT[𝕜] F)}
    {A : E →WOT[𝕜] F} : l ≤ 𝓝 A ↔ ∀ x y, l.map (fun T => ⟪y, T x⟫_𝕜) ≤ 𝓝 (⟪y, A x⟫_𝕜) 
goal: l ≤ 𝓝 A ↔ ∀ (x : E) (y : F), Filter.map (fun T => ⟪y, T x⟫_𝕜) l ≤ 𝓝 ⟪y, A x⟫_𝕜
File: Mathlib/Analysis/InnerProductSpace/MeanErgodic.lean

full_name: LinearMap.tendsto_birkhoffAverage_of_ker_subset_closure
code: /-- **Von Neumann Mean Ergodic Theorem**, a version for a normed space.

Let `f : E → E` be a contracting linear self-map of a normed space.
Let `S` be the subspace of fixed points of `f`.
Let `g : E → S` be a continuous linear projection, `g|_S=id`.
If the range of `f - id` is dense in the kernel of `g`,
then for each `x`, the Birkhoff averages
```
birkhoffAverage 𝕜 f id N x = (N : 𝕜)⁻¹ • ∑ n ∈ Finset.range N, f^[n] x
```
converge to `g x` as `N → ∞`.

Usually, this fact is not formulated as a separate lemma.
I chose to do it in order to isolate parts of the proof that do not rely
on the inner product space structure.
-/
theorem LinearMap.tendsto_birkhoffAverage_of_ker_subset_closure [NormedSpace 𝕜 E]
    (f : E →ₗ[𝕜] E) (hf : LipschitzWith 1 f) (g : E →L[𝕜] LinearMap.eqLocus f 1)
    (hg_proj : ∀ x : LinearMap.eqLocus f 1, g x = x)
    (hg_ker : (LinearMap.ker g : Set E) ⊆ closure (LinearMap.range (f - 1))) (x : E) :
    Tendsto (birkhoffAverage 𝕜 f _root_.id · x) atTop (𝓝 (g x)) 
goal: Filter.Tendsto (fun x_1 => birkhoffAverage 𝕜 (⇑f) id x_1 x) Filter.atTop (𝓝 ↑(g x))

full_name: «_aux_Mathlib_Analysis_InnerProductSpace_MeanErgodic___macroRules_term⟪_,_⟫_1»
code: local notation "⟪" x ", " y "⟫" => @inner 𝕜 _ _ x y
goal: Lean.Macro

full_name: ContinuousLinearMap.tendsto_birkhoffAverage_orthogonalProjection
code: /-- **Von Neumann Mean Ergodic Theorem** for an operator in a Hilbert space.
For a contracting continuous linear self-map `f : E →L[𝕜] E` of a Hilbert space, `‖f‖ ≤ 1`,
the Birkhoff averages
```
birkhoffAverage 𝕜 f id N x = (N : 𝕜)⁻¹ • ∑ n ∈ Finset.range N, f^[n] x
```
converge to the orthogonal projection of `x` to the subspace of fixed points of `f`. -/
theorem ContinuousLinearMap.tendsto_birkhoffAverage_orthogonalProjection (f : E →L[𝕜] E)
    (hf : ‖f‖ ≤ 1) (x : E) :
    Tendsto (birkhoffAverage 𝕜 f _root_.id · x) atTop
      (𝓝 <| orthogonalProjection (LinearMap.eqLocus f 1) x) 
goal: Filter.Tendsto (fun x_1 => birkhoffAverage 𝕜 (⇑f) id x_1 x) Filter.atTop
  (𝓝 ↑((orthogonalProjection (LinearMap.eqLocus f 1)) x))
File: Mathlib/Analysis/SpecificLimits/RCLike.lean

full_name: RCLike.tendsto_inverse_atTop_nhds_zero_nat
code: theorem RCLike.tendsto_inverse_atTop_nhds_zero_nat :
    Tendsto (fun n : ℕ => (n : 𝕜)⁻¹) atTop (𝓝 0) 
goal: Filter.Tendsto (fun n => (↑n)⁻¹) Filter.atTop (𝓝 0)
File: Mathlib/Analysis/InnerProductSpace/NormPow.lean

full_name: hasFDerivAt_norm_rpow
code: theorem hasFDerivAt_norm_rpow (x : E) {p : ℝ} (hp : 1 < p) :
    HasFDerivAt (fun x : E ↦ ‖x‖ ^ p) ((p * ‖x‖ ^ (p - 2)) • innerSL ℝ x) x 
goal: HasFDerivAt (fun x => ‖x‖ ^ p) ((p * ‖x‖ ^ (p - 2)) • (innerSL ℝ) x) x

full_name: differentiable_norm_rpow
code: theorem differentiable_norm_rpow {p : ℝ} (hp : 1 < p) :
    Differentiable ℝ (fun x : E ↦ ‖x‖ ^ p) 
goal: Differentiable ℝ fun x => ‖x‖ ^ p

full_name: hasDerivAt_norm_rpow
code: theorem hasDerivAt_norm_rpow (x : ℝ) {p : ℝ} (hp : 1 < p) :
    HasDerivAt (fun x : ℝ ↦ ‖x‖ ^ p) (p * ‖x‖ ^ (p - 2) * x) x 
goal: HasDerivAt (fun x => ‖x‖ ^ p) (p * ‖x‖ ^ (p - 2) * x) x

full_name: hasDerivAt_abs_rpow
code: theorem hasDerivAt_abs_rpow (x : ℝ) {p : ℝ} (hp : 1 < p) :
    HasDerivAt (fun x : ℝ ↦ |x| ^ p) (p * |x| ^ (p - 2) * x) x 
goal: HasDerivAt (fun x => |x| ^ p) (p * |x| ^ (p - 2) * x) x

full_name: fderiv_norm_rpow
code: theorem fderiv_norm_rpow (x : E) {p : ℝ} (hp : 1 < p) :
    fderiv ℝ (fun x ↦ ‖x‖ ^ p) x = (p * ‖x‖ ^ (p - 2)) • innerSL ℝ x 
goal: fderiv ℝ (fun x => ‖x‖ ^ p) x = (p * ‖x‖ ^ (p - 2)) • (innerSL ℝ) x

full_name: Differentiable.fderiv_norm_rpow
code: theorem Differentiable.fderiv_norm_rpow {f : F → E} (hf : Differentiable ℝ f)
    {x : F} {p : ℝ} (hp : 1 < p) :
    fderiv ℝ (fun x ↦ ‖f x‖ ^ p) x =
    (p * ‖f x‖ ^ (p - 2)) • (innerSL ℝ (f x)).comp (fderiv ℝ f x) 
goal: fderiv ℝ (fun x => ‖f x‖ ^ p) x = (p * ‖f x‖ ^ (p - 2)) • ((innerSL ℝ) (f x)).comp (fderiv ℝ f x)

full_name: norm_fderiv_norm_rpow_le
code: theorem norm_fderiv_norm_rpow_le {f : F → E} (hf : Differentiable ℝ f) {x : F}
    {p : ℝ} (hp : 1 < p) :
    ‖fderiv ℝ (fun x ↦ ‖f x‖ ^ p) x‖ ≤ p * ‖f x‖ ^ (p - 1) * ‖fderiv ℝ f x‖ 
goal: ‖fderiv ℝ (fun x => ‖f x‖ ^ p) x‖ ≤ p * ‖f x‖ ^ (p - 1) * ‖fderiv ℝ f x‖

full_name: norm_fderiv_norm_id_rpow
code: theorem norm_fderiv_norm_id_rpow (x : E) {p : ℝ} (hp : 1 < p) :
    ‖fderiv ℝ (fun x ↦ ‖x‖ ^ p) x‖ = p * ‖x‖ ^ (p - 1) 
goal: ‖fderiv ℝ (fun x => ‖x‖ ^ p) x‖ = p * ‖x‖ ^ (p - 1)

full_name: nnnorm_fderiv_norm_rpow_le
code: theorem nnnorm_fderiv_norm_rpow_le {f : F → E} (hf : Differentiable ℝ f)
    {x : F} {p : ℝ≥0} (hp : 1 < p) :
    ‖fderiv ℝ (fun x ↦ ‖f x‖ ^ (p : ℝ)) x‖₊ ≤ p * ‖f x‖₊ ^ ((p : ℝ) - 1) * ‖fderiv ℝ f x‖₊ 
goal: ‖fderiv ℝ (fun x => ‖f x‖ ^ ↑p) x‖₊ ≤ p * ‖f x‖₊ ^ (↑p - 1) * ‖fderiv ℝ f x‖₊

full_name: contDiff_norm_rpow
code: theorem contDiff_norm_rpow {p : ℝ} (hp : 1 < p) : ContDiff ℝ 1 (fun x : E ↦ ‖x‖ ^ p) 
goal: ContDiff ℝ 1 fun x => ‖x‖ ^ p

full_name: ContDiff.norm_rpow
code: theorem ContDiff.norm_rpow {f : F → E} (hf : ContDiff ℝ 1 f) {p : ℝ} (hp : 1 < p) :
    ContDiff ℝ 1 (fun x ↦ ‖f x‖ ^ p) 
goal: ContDiff ℝ 1 fun x => ‖f x‖ ^ p

full_name: Differentiable.norm_rpow
code: theorem Differentiable.norm_rpow {f : F → E} (hf : Differentiable ℝ f) {p : ℝ} (hp : 1 < p) :
    Differentiable ℝ (fun x ↦ ‖f x‖ ^ p) 
goal: Differentiable ℝ fun x => ‖f x‖ ^ p
File: Mathlib/Analysis/Distribution/FourierSchwartz.lean

full_name: SchwartzMap.fourierTransformCLM
code: /-- The Fourier transform on a real inner product space, as a continuous linear map on the
Schwartz space. -/
noncomputable def fourierTransformCLM : 𝓢(V, E) →L[𝕜] 𝓢(V, E) 
goal: SchwartzMap V E →L[𝕜] SchwartzMap V E

full_name: SchwartzMap.fourierTransformCLM_apply
code: @[simp] lemma fourierTransformCLM_apply (f : 𝓢(V, E)) :
    fourierTransformCLM 𝕜 f = 𝓕 f 
goal: ⇑((SchwartzMap.fourierTransformCLM 𝕜) f) = 𝓕 ⇑f

full_name: SchwartzMap.fourierTransformCLE
code: /-- The Fourier transform on a real inner product space, as a continuous linear equiv on the
Schwartz space. -/
noncomputable def fourierTransformCLE : 𝓢(V, E) ≃L[𝕜] 𝓢(V, E) 
goal: SchwartzMap V E ≃L[𝕜] SchwartzMap V E

full_name: SchwartzMap.fourierTransformCLE_apply
code: @[simp] lemma fourierTransformCLE_apply (f : 𝓢(V, E)) :
    fourierTransformCLE 𝕜 f = 𝓕 f 
goal: ⇑((SchwartzMap.fourierTransformCLE 𝕜) f) = 𝓕 ⇑f

full_name: SchwartzMap.fourierTransformCLE_symm_apply
code: @[simp] lemma fourierTransformCLE_symm_apply (f : 𝓢(V, E)) :
    (fourierTransformCLE 𝕜).symm f = 𝓕⁻ f 
goal: ⇑((SchwartzMap.fourierTransformCLE 𝕜).symm f) = 𝓕⁻ ⇑f
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unitary.lean

full_name: unitary_iff_isStarNormal_and_spectrum_subset_circle
code: lemma unitary_iff_isStarNormal_and_spectrum_subset_circle {u : A} :
    u ∈ unitary A ↔ IsStarNormal u ∧ spectrum ℂ u ⊆ circle 
goal: u ∈ unitary A ↔ IsStarNormal u ∧ spectrum ℂ u ⊆ ↑circle

full_name: mem_unitary_of_spectrum_subset_circle
code: lemma mem_unitary_of_spectrum_subset_circle {u : A}
    [IsStarNormal u] (hu : spectrum ℂ u ⊆ circle) : u ∈ unitary A 
goal: u ∈ unitary A

full_name: spectrum_subset_circle_of_mem_unitary
code: lemma spectrum_subset_circle_of_mem_unitary {u : A} (hu : u ∈ unitary A) :
    spectrum ℂ u ⊆ circle 
goal: spectrum ℂ u ⊆ ↑circle
File: Mathlib/Analysis/CstarAlgebra/Exponential.lean

full_name: selfAdjoint.expUnitary_coe
code: /-- The map from the selfadjoint real subspace to the unitary group. This map only makes sense
over ℂ. -/
@[simps]
noncomputable def selfAdjoint.expUnitary (a : selfAdjoint A) : unitary A 
goal: ↑(selfAdjoint.expUnitary a) = NormedSpace.exp ℂ (Complex.I • ↑a)

full_name: selfAdjoint.expUnitary
code: /-- The map from the selfadjoint real subspace to the unitary group. This map only makes sense
over ℂ. -/
@[simps]
noncomputable def selfAdjoint.expUnitary (a : selfAdjoint A) : unitary A 
goal: ↥(unitary A)

full_name: Commute.expUnitary_add
code: theorem Commute.expUnitary_add {a b : selfAdjoint A} (h : Commute (a : A) (b : A)) :
    expUnitary (a + b) = expUnitary a * expUnitary b 
goal: selfAdjoint.expUnitary (a + b) = selfAdjoint.expUnitary a * selfAdjoint.expUnitary b

full_name: Commute.expUnitary
code: theorem Commute.expUnitary {a b : selfAdjoint A} (h : Commute (a : A) (b : A)) :
    Commute (expUnitary a) (expUnitary b) 
goal: Commute (selfAdjoint.expUnitary a) (selfAdjoint.expUnitary b)