File: Mathlib/Geometry/Manifold/ContMDiff/Basic.lean

full_name: ContMDiffWithinAt.comp
code: /-- The composition of `C^n` functions within domains at points is `C^n`. -/
theorem ContMDiffWithinAt.comp {t : Set M'} {g : M' → M''} (x : M)
    (hg : ContMDiffWithinAt I' I'' n g t (f x)) (hf : ContMDiffWithinAt I I' n f s x)
    (st : MapsTo f s t) : ContMDiffWithinAt I I'' n (g ∘ f) s x 
goal: ContMDiffWithinAt I I'' n (g ∘ f) s x

full_name: ContMDiffWithinAt.comp_of_eq
code: /-- See note [comp_of_eq lemmas] -/
theorem ContMDiffWithinAt.comp_of_eq {t : Set M'} {g : M' → M''} {x : M} {y : M'}
    (hg : ContMDiffWithinAt I' I'' n g t y) (hf : ContMDiffWithinAt I I' n f s x)
    (st : MapsTo f s t) (hx : f x = y) : ContMDiffWithinAt I I'' n (g ∘ f) s x 
goal: ContMDiffWithinAt I I'' n (g ∘ f) s x

full_name: SmoothWithinAt.comp
code: /-- The composition of `C^∞` functions within domains at points is `C^∞`. -/
nonrec theorem SmoothWithinAt.comp {t : Set M'} {g : M' → M''} (x : M)
    (hg : SmoothWithinAt I' I'' g t (f x)) (hf : SmoothWithinAt I I' f s x) (st : MapsTo f s t) :
    SmoothWithinAt I I'' (g ∘ f) s x 
goal: SmoothWithinAt I I'' (g ∘ f) s x

full_name: ContMDiffOn.comp
code: /-- The composition of `C^n` functions on domains is `C^n`. -/
theorem ContMDiffOn.comp {t : Set M'} {g : M' → M''} (hg : ContMDiffOn I' I'' n g t)
    (hf : ContMDiffOn I I' n f s) (st : s ⊆ f ⁻¹' t) : ContMDiffOn I I'' n (g ∘ f) s 
goal: ContMDiffOn I I'' n (g ∘ f) s

full_name: SmoothOn.comp
code: /-- The composition of `C^∞` functions on domains is `C^∞`. -/
nonrec theorem SmoothOn.comp {t : Set M'} {g : M' → M''} (hg : SmoothOn I' I'' g t)
    (hf : SmoothOn I I' f s) (st : s ⊆ f ⁻¹' t) : SmoothOn I I'' (g ∘ f) s 
goal: SmoothOn I I'' (g ∘ f) s

full_name: ContMDiffOn.comp'
code: /-- The composition of `C^n` functions on domains is `C^n`. -/
theorem ContMDiffOn.comp' {t : Set M'} {g : M' → M''} (hg : ContMDiffOn I' I'' n g t)
    (hf : ContMDiffOn I I' n f s) : ContMDiffOn I I'' n (g ∘ f) (s ∩ f ⁻¹' t) 
goal: ContMDiffOn I I'' n (g ∘ f) (s ∩ f ⁻¹' t)

full_name: SmoothOn.comp'
code: /-- The composition of `C^∞` functions is `C^∞`. -/
nonrec theorem SmoothOn.comp' {t : Set M'} {g : M' → M''} (hg : SmoothOn I' I'' g t)
    (hf : SmoothOn I I' f s) : SmoothOn I I'' (g ∘ f) (s ∩ f ⁻¹' t) 
goal: SmoothOn I I'' (g ∘ f) (s ∩ f ⁻¹' t)

full_name: ContMDiff.comp
code: /-- The composition of `C^n` functions is `C^n`. -/
theorem ContMDiff.comp {g : M' → M''} (hg : ContMDiff I' I'' n g) (hf : ContMDiff I I' n f) :
    ContMDiff I I'' n (g ∘ f) 
goal: ContMDiff I I'' n (g ∘ f)

full_name: Smooth.comp
code: /-- The composition of `C^∞` functions is `C^∞`. -/
nonrec theorem Smooth.comp {g : M' → M''} (hg : Smooth I' I'' g) (hf : Smooth I I' f) :
    Smooth I I'' (g ∘ f) 
goal: Smooth I I'' (g ∘ f)

full_name: ContMDiffWithinAt.comp'
code: /-- The composition of `C^n` functions within domains at points is `C^n`. -/
theorem ContMDiffWithinAt.comp' {t : Set M'} {g : M' → M''} (x : M)
    (hg : ContMDiffWithinAt I' I'' n g t (f x)) (hf : ContMDiffWithinAt I I' n f s x) :
    ContMDiffWithinAt I I'' n (g ∘ f) (s ∩ f ⁻¹' t) x 
goal: ContMDiffWithinAt I I'' n (g ∘ f) (s ∩ f ⁻¹' t) x

full_name: SmoothWithinAt.comp'
code: /-- The composition of `C^∞` functions within domains at points is `C^∞`. -/
nonrec theorem SmoothWithinAt.comp' {t : Set M'} {g : M' → M''} (x : M)
    (hg : SmoothWithinAt I' I'' g t (f x)) (hf : SmoothWithinAt I I' f s x) :
    SmoothWithinAt I I'' (g ∘ f) (s ∩ f ⁻¹' t) x 
goal: SmoothWithinAt I I'' (g ∘ f) (s ∩ f ⁻¹' t) x

full_name: ContMDiffAt.comp_contMDiffWithinAt
code: /-- `g ∘ f` is `C^n` within `s` at `x` if `g` is `C^n` at `f x` and
`f` is `C^n` within `s` at `x`. -/
theorem ContMDiffAt.comp_contMDiffWithinAt {g : M' → M''} (x : M)
    (hg : ContMDiffAt I' I'' n g (f x)) (hf : ContMDiffWithinAt I I' n f s x) :
    ContMDiffWithinAt I I'' n (g ∘ f) s x 
goal: ContMDiffWithinAt I I'' n (g ∘ f) s x

full_name: SmoothAt.comp_smoothWithinAt
code: /-- `g ∘ f` is `C^∞` within `s` at `x` if `g` is `C^∞` at `f x` and
`f` is `C^∞` within `s` at `x`. -/
theorem SmoothAt.comp_smoothWithinAt {g : M' → M''} (x : M) (hg : SmoothAt I' I'' g (f x))
    (hf : SmoothWithinAt I I' f s x) : SmoothWithinAt I I'' (g ∘ f) s x 
goal: SmoothWithinAt I I'' (g ∘ f) s x

full_name: ContMDiffAt.comp
code: /-- The composition of `C^n` functions at points is `C^n`. -/
nonrec theorem ContMDiffAt.comp {g : M' → M''} (x : M) (hg : ContMDiffAt I' I'' n g (f x))
    (hf : ContMDiffAt I I' n f x) : ContMDiffAt I I'' n (g ∘ f) x 
goal: ContMDiffAt I I'' n (g ∘ f) x

full_name: ContMDiffAt.comp_of_eq
code: /-- See note [comp_of_eq lemmas] -/
theorem ContMDiffAt.comp_of_eq {g : M' → M''} {x : M} {y : M'} (hg : ContMDiffAt I' I'' n g y)
    (hf : ContMDiffAt I I' n f x) (hx : f x = y) : ContMDiffAt I I'' n (g ∘ f) x 
goal: ContMDiffAt I I'' n (g ∘ f) x

full_name: SmoothAt.comp
code: /-- The composition of `C^∞` functions at points is `C^∞`. -/
nonrec theorem SmoothAt.comp {g : M' → M''} (x : M) (hg : SmoothAt I' I'' g (f x))
    (hf : SmoothAt I I' f x) : SmoothAt I I'' (g ∘ f) x 
goal: SmoothAt I I'' (g ∘ f) x

full_name: ContMDiff.comp_contMDiffOn
code: theorem ContMDiff.comp_contMDiffOn {f : M → M'} {g : M' → M''} {s : Set M}
    (hg : ContMDiff I' I'' n g) (hf : ContMDiffOn I I' n f s) : ContMDiffOn I I'' n (g ∘ f) s 
goal: ContMDiffOn I I'' n (g ∘ f) s

full_name: Smooth.comp_smoothOn
code: theorem Smooth.comp_smoothOn {f : M → M'} {g : M' → M''} {s : Set M} (hg : Smooth I' I'' g)
    (hf : SmoothOn I I' f s) : SmoothOn I I'' (g ∘ f) s 
goal: SmoothOn I I'' (g ∘ f) s

full_name: ContMDiffOn.comp_contMDiff
code: theorem ContMDiffOn.comp_contMDiff {t : Set M'} {g : M' → M''} (hg : ContMDiffOn I' I'' n g t)
    (hf : ContMDiff I I' n f) (ht : ∀ x, f x ∈ t) : ContMDiff I I'' n (g ∘ f) 
goal: ContMDiff I I'' n (g ∘ f)

full_name: SmoothOn.comp_smooth
code: theorem SmoothOn.comp_smooth {t : Set M'} {g : M' → M''} (hg : SmoothOn I' I'' g t)
    (hf : Smooth I I' f) (ht : ∀ x, f x ∈ t) : Smooth I I'' (g ∘ f) 
goal: Smooth I I'' (g ∘ f)

full_name: contMDiff_id
code: theorem contMDiff_id : ContMDiff I I n (id : M → M) 
goal: ContMDiff I I n id

full_name: smooth_id
code: theorem smooth_id : Smooth I I (id : M → M) 
goal: Smooth I I id

full_name: contMDiffOn_id
code: theorem contMDiffOn_id : ContMDiffOn I I n (id : M → M) s 
goal: ContMDiffOn I I n id s

full_name: smoothOn_id
code: theorem smoothOn_id : SmoothOn I I (id : M → M) s 
goal: SmoothOn I I id s

full_name: contMDiffAt_id
code: theorem contMDiffAt_id : ContMDiffAt I I n (id : M → M) x 
goal: ContMDiffAt I I n id x

full_name: smoothAt_id
code: theorem smoothAt_id : SmoothAt I I (id : M → M) x 
goal: SmoothAt I I id x

full_name: contMDiffWithinAt_id
code: theorem contMDiffWithinAt_id : ContMDiffWithinAt I I n (id : M → M) s x 
goal: ContMDiffWithinAt I I n id s x

full_name: smoothWithinAt_id
code: theorem smoothWithinAt_id : SmoothWithinAt I I (id : M → M) s x 
goal: SmoothWithinAt I I id s x

full_name: contMDiff_const
code: theorem contMDiff_const : ContMDiff I I' n fun _ : M => c 
goal: ContMDiff I I' n fun x => c

full_name: contMDiff_zero
code: @[to_additive]
theorem contMDiff_one [One M'] : ContMDiff I I' n (1 : M → M') 
goal: ContMDiff I I' n 0

full_name: contMDiff_one
code: @[to_additive]
theorem contMDiff_one [One M'] : ContMDiff I I' n (1 : M → M') 
goal: ContMDiff I I' n 1

full_name: smooth_const
code: theorem smooth_const : Smooth I I' fun _ : M => c 
goal: Smooth I I' fun x => c

full_name: smooth_one
code: @[to_additive]
theorem smooth_one [One M'] : Smooth I I' (1 : M → M') 
goal: Smooth I I' 1

full_name: smooth_zero
code: @[to_additive]
theorem smooth_one [One M'] : Smooth I I' (1 : M → M') 
goal: Smooth I I' 0

full_name: contMDiffOn_const
code: theorem contMDiffOn_const : ContMDiffOn I I' n (fun _ : M => c) s 
goal: ContMDiffOn I I' n (fun x => c) s

full_name: contMDiffOn_one
code: @[to_additive]
theorem contMDiffOn_one [One M'] : ContMDiffOn I I' n (1 : M → M') s 
goal: ContMDiffOn I I' n 1 s

full_name: contMDiffOn_zero
code: @[to_additive]
theorem contMDiffOn_one [One M'] : ContMDiffOn I I' n (1 : M → M') s 
goal: ContMDiffOn I I' n 0 s

full_name: smoothOn_const
code: theorem smoothOn_const : SmoothOn I I' (fun _ : M => c) s 
goal: SmoothOn I I' (fun x => c) s

full_name: smoothOn_zero
code: @[to_additive]
theorem smoothOn_one [One M'] : SmoothOn I I' (1 : M → M') s 
goal: SmoothOn I I' 0 s

full_name: smoothOn_one
code: @[to_additive]
theorem smoothOn_one [One M'] : SmoothOn I I' (1 : M → M') s 
goal: SmoothOn I I' 1 s

full_name: contMDiffAt_const
code: theorem contMDiffAt_const : ContMDiffAt I I' n (fun _ : M => c) x 
goal: ContMDiffAt I I' n (fun x => c) x

full_name: contMDiffAt_zero
code: @[to_additive]
theorem contMDiffAt_one [One M'] : ContMDiffAt I I' n (1 : M → M') x 
goal: ContMDiffAt I I' n 0 x

full_name: contMDiffAt_one
code: @[to_additive]
theorem contMDiffAt_one [One M'] : ContMDiffAt I I' n (1 : M → M') x 
goal: ContMDiffAt I I' n 1 x

full_name: smoothAt_const
code: theorem smoothAt_const : SmoothAt I I' (fun _ : M => c) x 
goal: SmoothAt I I' (fun x => c) x

full_name: smoothAt_zero
code: @[to_additive]
theorem smoothAt_one [One M'] : SmoothAt I I' (1 : M → M') x 
goal: SmoothAt I I' 0 x

full_name: smoothAt_one
code: @[to_additive]
theorem smoothAt_one [One M'] : SmoothAt I I' (1 : M → M') x 
goal: SmoothAt I I' 1 x

full_name: contMDiffWithinAt_const
code: theorem contMDiffWithinAt_const : ContMDiffWithinAt I I' n (fun _ : M => c) s x 
goal: ContMDiffWithinAt I I' n (fun x => c) s x

full_name: contMDiffWithinAt_zero
code: @[to_additive]
theorem contMDiffWithinAt_one [One M'] : ContMDiffWithinAt I I' n (1 : M → M') s x 
goal: ContMDiffWithinAt I I' n 0 s x

full_name: contMDiffWithinAt_one
code: @[to_additive]
theorem contMDiffWithinAt_one [One M'] : ContMDiffWithinAt I I' n (1 : M → M') s x 
goal: ContMDiffWithinAt I I' n 1 s x

full_name: smoothWithinAt_const
code: theorem smoothWithinAt_const : SmoothWithinAt I I' (fun _ : M => c) s x 
goal: SmoothWithinAt I I' (fun x => c) s x

full_name: smoothWithinAt_one
code: @[to_additive]
theorem smoothWithinAt_one [One M'] : SmoothWithinAt I I' (1 : M → M') s x 
goal: SmoothWithinAt I I' 1 s x

full_name: smoothWithinAt_zero
code: @[to_additive]
theorem smoothWithinAt_one [One M'] : SmoothWithinAt I I' (1 : M → M') s x 
goal: SmoothWithinAt I I' 0 s x

full_name: contMDiff_of_tsupport
code: /-- `f` is continuously differentiable if it is cont. differentiable at
each `x ∈ mulTSupport f`. -/
@[to_additive "`f` is continuously differentiable if it is continuously
differentiable at each `x ∈ tsupport f`."]
theorem contMDiff_of_mulTSupport [One M'] {f : M → M'}
    (hf : ∀ x ∈ mulTSupport f, ContMDiffAt I I' n f x) : ContMDiff I I' n f 
goal: ContMDiff I I' n f

full_name: contMDiff_of_mulTSupport
code: /-- `f` is continuously differentiable if it is cont. differentiable at
each `x ∈ mulTSupport f`. -/
@[to_additive "`f` is continuously differentiable if it is continuously
differentiable at each `x ∈ tsupport f`."]
theorem contMDiff_of_mulTSupport [One M'] {f : M → M'}
    (hf : ∀ x ∈ mulTSupport f, ContMDiffAt I I' n f x) : ContMDiff I I' n f 
goal: ContMDiff I I' n f

full_name: contMDiffWithinAt_of_not_mem_mulTSupport
code: @[to_additive contMDiffWithinAt_of_not_mem]
theorem contMDiffWithinAt_of_not_mem_mulTSupport {f : M → M'} [One M'] {x : M}
    (hx : x ∉ mulTSupport f) (n : ℕ∞) (s : Set M) : ContMDiffWithinAt I I' n f s x 
goal: ContMDiffWithinAt I I' n f s x

full_name: contMDiffWithinAt_of_not_mem
code: @[to_additive contMDiffWithinAt_of_not_mem]
theorem contMDiffWithinAt_of_not_mem_mulTSupport {f : M → M'} [One M'] {x : M}
    (hx : x ∉ mulTSupport f) (n : ℕ∞) (s : Set M) : ContMDiffWithinAt I I' n f s x 
goal: ContMDiffWithinAt I I' n f s x

full_name: contMDiffAt_of_not_mem_mulTSupport
code: /-- `f` is continuously differentiable at each point outside of its `mulTSupport`. -/
@[to_additive contMDiffAt_of_not_mem]
theorem contMDiffAt_of_not_mem_mulTSupport {f : M → M'} [One M'] {x : M}
    (hx : x ∉ mulTSupport f) (n : ℕ∞) : ContMDiffAt I I' n f x 
goal: ContMDiffAt I I' n f x

full_name: contMDiffAt_of_not_mem
code: /-- `f` is continuously differentiable at each point outside of its `mulTSupport`. -/
@[to_additive contMDiffAt_of_not_mem]
theorem contMDiffAt_of_not_mem_mulTSupport {f : M → M'} [One M'] {x : M}
    (hx : x ∉ mulTSupport f) (n : ℕ∞) : ContMDiffAt I I' n f x 
goal: ContMDiffAt I I' n f x

full_name: contMdiffAt_subtype_iff
code: theorem contMdiffAt_subtype_iff {n : ℕ∞} {U : Opens M} {f : M → M'} {x : U} :
    ContMDiffAt I I' n (fun x : U ↦ f x) x ↔ ContMDiffAt I I' n f x 
goal: ContMDiffAt I I' n (fun x => f ↑x) x ↔ ContMDiffAt I I' n f ↑x

full_name: contMDiff_subtype_val
code: theorem contMDiff_subtype_val {n : ℕ∞} {U : Opens M} : ContMDiff I I n (Subtype.val : U → M) 
goal: ContMDiff I I n Subtype.val

full_name: ContMDiff.extend_one
code: @[to_additive]
theorem ContMDiff.extend_one [T2Space M] [One M'] {n : ℕ∞} {U : Opens M} {f : U → M'}
    (supp : HasCompactMulSupport f) (diff : ContMDiff I I' n f) :
    ContMDiff I I' n (Subtype.val.extend f 1) 
goal: ContMDiff I I' n (Function.extend Subtype.val f 1)

full_name: ContMDiff.extend_zero
code: @[to_additive]
theorem ContMDiff.extend_one [T2Space M] [One M'] {n : ℕ∞} {U : Opens M} {f : U → M'}
    (supp : HasCompactMulSupport f) (diff : ContMDiff I I' n f) :
    ContMDiff I I' n (Subtype.val.extend f 1) 
goal: ContMDiff I I' n (Function.extend Subtype.val f 0)

full_name: contMDiff_inclusion
code: theorem contMDiff_inclusion {n : ℕ∞} {U V : Opens M} (h : U ≤ V) :
    ContMDiff I I n (Set.inclusion h : U → V) 
goal: ContMDiff I I n (Set.inclusion h)

full_name: smooth_subtype_iff
code: theorem smooth_subtype_iff {U : Opens M} {f : M → M'} {x : U} :
    SmoothAt I I' (fun x : U ↦ f x) x ↔ SmoothAt I I' f x 
goal: SmoothAt I I' (fun x => f ↑x) x ↔ SmoothAt I I' f ↑x

full_name: smooth_subtype_val
code: theorem smooth_subtype_val {U : Opens M} : Smooth I I (Subtype.val : U → M) 
goal: Smooth I I Subtype.val

full_name: Smooth.extend_zero
code: @[to_additive]
theorem Smooth.extend_one [T2Space M] [One M'] {U : Opens M} {f : U → M'}
    (supp : HasCompactMulSupport f) (diff : Smooth I I' f) : Smooth I I' (Subtype.val.extend f 1) 
goal: Smooth I I' (Function.extend Subtype.val f 0)

full_name: Smooth.extend_one
code: @[to_additive]
theorem Smooth.extend_one [T2Space M] [One M'] {U : Opens M} {f : U → M'}
    (supp : HasCompactMulSupport f) (diff : Smooth I I' f) : Smooth I I' (Subtype.val.extend f 1) 
goal: Smooth I I' (Function.extend Subtype.val f 1)

full_name: smooth_inclusion
code: theorem smooth_inclusion {U V : Opens M} (h : U ≤ V) : Smooth I I (Set.inclusion h : U → V) 
goal: Smooth I I (Set.inclusion h)

full_name: contMDiff_openEmbedding
code: /-- If the `ChartedSpace` structure on a manifold `M` is given by an open embedding `e : M → H`,
then `e` is smooth. -/
lemma contMDiff_openEmbedding :
    haveI := h.singletonChartedSpace; ContMDiff I I n e 
goal: ContMDiff I I n e

full_name: contMDiffOn_openEmbedding_symm
code: /-- If the `ChartedSpace` structure on a manifold `M` is given by an open embedding `e : M → H`,
then the inverse of `e` is smooth. -/
lemma contMDiffOn_openEmbedding_symm :
    haveI := h.singletonChartedSpace; ContMDiffOn I I
      n (OpenEmbedding.toPartialHomeomorph e h).symm (range e) 
goal: ContMDiffOn I I n (↑(OpenEmbedding.toPartialHomeomorph e h).symm) (Set.range e)

full_name: ContMDiff.of_comp_openEmbedding
code: /-- Let `M'` be a manifold whose chart structure is given by an open embedding `e'` into its model
space `H'`. Then the smoothness of `e' ∘ f : M → H'` implies the smoothness of `f`.

This is useful, for example, when `e' ∘ f = g ∘ e` for smooth maps `e : M → X` and `g : X → H'`. -/
lemma ContMDiff.of_comp_openEmbedding {f : M → M'} (hf : ContMDiff I I' n (e' ∘ f)) :
    haveI := h'.singletonChartedSpace; ContMDiff I I' n f 
goal: ContMDiff I I' n f