File: Mathlib/Geometry/Manifold/WhitneyEmbedding.lean

full_name: SmoothBumpCovering.embeddingPiTangent
code: /-- Smooth embedding of `M` into `(E × ℝ) ^ ι`. -/
def embeddingPiTangent : C^∞⟮I, M; 𝓘(ℝ, ι → E × ℝ), ι → E × ℝ⟯ 
goal: C^⊤⟮I, M; 𝓘(ℝ, ι → E × ℝ), ι → E × ℝ⟯

full_name: SmoothBumpCovering.embeddingPiTangent_coe
code: @[local simp]
theorem embeddingPiTangent_coe :
    ⇑f.embeddingPiTangent = fun x i => (f i x • extChartAt I (f.c i) x, f i x) 
goal: ⇑f.embeddingPiTangent = fun x i => (↑(f.toFun i) x • ↑(extChartAt I (f.c i)) x, ↑(f.toFun i) x)

full_name: SmoothBumpCovering.embeddingPiTangent_injOn
code: theorem embeddingPiTangent_injOn : InjOn f.embeddingPiTangent s 
goal: Set.InjOn (⇑f.embeddingPiTangent) s

full_name: SmoothBumpCovering.embeddingPiTangent_injective
code: theorem embeddingPiTangent_injective (f : SmoothBumpCovering ι I M) :
    Injective f.embeddingPiTangent 
goal: Function.Injective ⇑f.embeddingPiTangent

full_name: SmoothBumpCovering.comp_embeddingPiTangent_mfderiv
code: theorem comp_embeddingPiTangent_mfderiv (x : M) (hx : x ∈ s) :
    ((ContinuousLinearMap.fst ℝ E ℝ).comp
            (@ContinuousLinearMap.proj ℝ _ ι (fun _ => E × ℝ) _ _ (fun _ => inferInstance)
              (f.ind x hx))).comp
        (mfderiv I 𝓘(ℝ, ι → E × ℝ) f.embeddingPiTangent x) =
      mfderiv I I (chartAt H (f.c (f.ind x hx))) x 
goal: ((ContinuousLinearMap.fst ℝ E ℝ).comp (ContinuousLinearMap.proj (f.ind x hx))).comp
    (mfderiv I 𝓘(ℝ, ι → E × ℝ) (⇑f.embeddingPiTangent) x) =
  mfderiv I I (↑(chartAt H (f.c (f.ind x hx)))) x

full_name: SmoothBumpCovering.embeddingPiTangent_ker_mfderiv
code: theorem embeddingPiTangent_ker_mfderiv (x : M) (hx : x ∈ s) :
    LinearMap.ker (mfderiv I 𝓘(ℝ, ι → E × ℝ) f.embeddingPiTangent x) = ⊥ 
goal: LinearMap.ker (mfderiv I 𝓘(ℝ, ι → E × ℝ) (⇑f.embeddingPiTangent) x) = ⊥

full_name: SmoothBumpCovering.embeddingPiTangent_injective_mfderiv
code: theorem embeddingPiTangent_injective_mfderiv (x : M) (hx : x ∈ s) :
    Injective (mfderiv I 𝓘(ℝ, ι → E × ℝ) f.embeddingPiTangent x) 
goal: Function.Injective ⇑(mfderiv I 𝓘(ℝ, ι → E × ℝ) (⇑f.embeddingPiTangent) x)

full_name: SmoothBumpCovering.exists_immersion_euclidean
code: /-- Baby version of the **Whitney weak embedding theorem**: if `M` admits a finite covering by
supports of bump functions, then for some `n` it can be immersed into the `n`-dimensional
Euclidean space. -/
theorem exists_immersion_euclidean [Finite ι] (f : SmoothBumpCovering ι I M) :
    ∃ (n : ℕ) (e : M → EuclideanSpace ℝ (Fin n)),
      Smooth I (𝓡 n) e ∧ Injective e ∧ ∀ x : M, Injective (mfderiv I (𝓡 n) e x) 
goal: ∃ n e,
  Smooth I 𝓘(ℝ, EuclideanSpace ℝ (Fin n)) e ∧
    Function.Injective e ∧ ∀ (x : M), Function.Injective ⇑(mfderiv I 𝓘(ℝ, EuclideanSpace ℝ (Fin n)) e x)

full_name: exists_embedding_euclidean_of_compact
code: /-- Baby version of the Whitney weak embedding theorem: if `M` admits a finite covering by
supports of bump functions, then for some `n` it can be embedded into the `n`-dimensional
Euclidean space. -/
theorem exists_embedding_euclidean_of_compact [T2Space M] [CompactSpace M] :
    ∃ (n : ℕ) (e : M → EuclideanSpace ℝ (Fin n)),
      Smooth I (𝓡 n) e ∧ ClosedEmbedding e ∧ ∀ x : M, Injective (mfderiv I (𝓡 n) e x) 
goal: ∃ n e,
  Smooth I 𝓘(ℝ, EuclideanSpace ℝ (Fin n)) e ∧
    ClosedEmbedding e ∧ ∀ (x : M), Function.Injective ⇑(mfderiv I 𝓘(ℝ, EuclideanSpace ℝ (Fin n)) e x)