File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

full_name: Manifold.«_aux_Mathlib_Geometry_Manifold_SmoothManifoldWithCorners___macroRules_Manifold_term∞_1»
code: /-- The extended natural number `∞` -/
scoped[Manifold] notation "∞" => (⊤ : ℕ∞)
goal: Lean.Macro

full_name: ModelWithCorners.source_eq
code: /-- A structure containing informations on the way a space `H` embeds in a
model vector space `E` over the field `𝕜`. This is all what is needed to
define a smooth manifold with model space `H`, and model vector space `E`.
-/
@[ext] -- Porting note(#5171): was nolint has_nonempty_instance
structure ModelWithCorners (𝕜 : Type*) [NontriviallyNormedField 𝕜] (E : Type*)
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] (H : Type*) [TopologicalSpace H] extends
    PartialEquiv H E where
  source_eq : source = univ
  unique_diff' : UniqueDiffOn 𝕜 toPartialEquiv.target
  continuous_toFun : Continuous toFun := by continuity
  continuous_invFun : Continuous invFun := by continuity
goal: self.source = Set.univ

full_name: ModelWithCorners.unique_diff'
code: /-- A structure containing informations on the way a space `H` embeds in a
model vector space `E` over the field `𝕜`. This is all what is needed to
define a smooth manifold with model space `H`, and model vector space `E`.
-/
@[ext] -- Porting note(#5171): was nolint has_nonempty_instance
structure ModelWithCorners (𝕜 : Type*) [NontriviallyNormedField 𝕜] (E : Type*)
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] (H : Type*) [TopologicalSpace H] extends
    PartialEquiv H E where
  source_eq : source = univ
  unique_diff' : UniqueDiffOn 𝕜 toPartialEquiv.target
  continuous_toFun : Continuous toFun := by continuity
  continuous_invFun : Continuous invFun := by continuity
goal: UniqueDiffOn 𝕜 self.target

full_name: ModelWithCorners
code: /-- A structure containing informations on the way a space `H` embeds in a
model vector space `E` over the field `𝕜`. This is all what is needed to
define a smooth manifold with model space `H`, and model vector space `E`.
-/
@[ext] -- Porting note(#5171): was nolint has_nonempty_instance
structure ModelWithCorners (𝕜 : Type*) [NontriviallyNormedField 𝕜] (E : Type*)
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] (H : Type*) [TopologicalSpace H] extends
    PartialEquiv H E where
  source_eq : source = univ
  unique_diff' : UniqueDiffOn 𝕜 toPartialEquiv.target
  continuous_toFun : Continuous toFun := by continuity
  continuous_invFun : Continuous invFun := by continuity
goal: Type (max u_2 u_3)

full_name: ModelWithCorners.continuous_toFun
code: /-- A structure containing informations on the way a space `H` embeds in a
model vector space `E` over the field `𝕜`. This is all what is needed to
define a smooth manifold with model space `H`, and model vector space `E`.
-/
@[ext] -- Porting note(#5171): was nolint has_nonempty_instance
structure ModelWithCorners (𝕜 : Type*) [NontriviallyNormedField 𝕜] (E : Type*)
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] (H : Type*) [TopologicalSpace H] extends
    PartialEquiv H E where
  source_eq : source = univ
  unique_diff' : UniqueDiffOn 𝕜 toPartialEquiv.target
  continuous_toFun : Continuous toFun := by continuity
  continuous_invFun : Continuous invFun := by continuity
goal: Continuous ↑self.toPartialEquiv

full_name: ModelWithCorners.continuous_invFun
code: /-- A structure containing informations on the way a space `H` embeds in a
model vector space `E` over the field `𝕜`. This is all what is needed to
define a smooth manifold with model space `H`, and model vector space `E`.
-/
@[ext] -- Porting note(#5171): was nolint has_nonempty_instance
structure ModelWithCorners (𝕜 : Type*) [NontriviallyNormedField 𝕜] (E : Type*)
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] (H : Type*) [TopologicalSpace H] extends
    PartialEquiv H E where
  source_eq : source = univ
  unique_diff' : UniqueDiffOn 𝕜 toPartialEquiv.target
  continuous_toFun : Continuous toFun := by continuity
  continuous_invFun : Continuous invFun := by continuity
goal: Continuous self.invFun

full_name: modelWithCornersSelf
code: /-- A vector space is a model with corners. -/
def modelWithCornersSelf (𝕜 : Type*) [NontriviallyNormedField 𝕜] (E : Type*)
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] : ModelWithCorners 𝕜 E E 
goal: ModelWithCorners 𝕜 E E

full_name: Manifold._aux_Mathlib_Geometry_Manifold_SmoothManifoldWithCorners___unexpand_modelWithCornersSelf_1
code: @[inherit_doc] scoped[Manifold] notation "𝓘(" 𝕜 ", " E ")" => modelWithCornersSelf 𝕜 E
goal: Lean.PrettyPrinter.Unexpander

full_name: Manifold.«_aux_Mathlib_Geometry_Manifold_SmoothManifoldWithCorners___macroRules_Manifold_term𝓘(_,_)_1»
code: @[inherit_doc] scoped[Manifold] notation "𝓘(" 𝕜 ", " E ")" => modelWithCornersSelf 𝕜 E
goal: Lean.Macro

full_name: Manifold.«_aux_Mathlib_Geometry_Manifold_SmoothManifoldWithCorners___macroRules_Manifold_term𝓘(_)_1»
code: /-- A normed field is a model with corners. -/
scoped[Manifold] notation "𝓘(" 𝕜 ")" => modelWithCornersSelf 𝕜 𝕜
goal: Lean.Macro

full_name: ModelWithCorners.toFun'
code: /-- Coercion of a model with corners to a function. We don't use `e.toFun` because it is actually
`e.toPartialEquiv.toFun`, so `simp` will apply lemmas about `toPartialEquiv`. While we may want to
switch to this behavior later, doing it mid-port will break a lot of proofs. -/
@[coe] def toFun' (e : ModelWithCorners 𝕜 E H) : H → E 
goal: H → E

full_name: ModelWithCorners.instCoeFunForall
code: instance : CoeFun (ModelWithCorners 𝕜 E H) fun _ => H → E 
goal: CoeFun (ModelWithCorners 𝕜 E H) fun x => H → E

full_name: ModelWithCorners.symm
code: /-- The inverse to a model with corners, only registered as a `PartialEquiv`. -/
protected def symm : PartialEquiv E H 
goal: PartialEquiv E H

full_name: ModelWithCorners.Simps.apply
code: /-- See Note [custom simps projection]. We need to specify this projection explicitly in this case,
  because it is a composition of multiple projections. -/
def Simps.apply (𝕜 : Type*) [NontriviallyNormedField 𝕜] (E : Type*) [NormedAddCommGroup E]
    [NormedSpace 𝕜 E] (H : Type*) [TopologicalSpace H] (I : ModelWithCorners 𝕜 E H) : H → E 
goal: H → E

full_name: ModelWithCorners.Simps.symm_apply
code: /-- See Note [custom simps projection] -/
def Simps.symm_apply (𝕜 : Type*) [NontriviallyNormedField 𝕜] (E : Type*) [NormedAddCommGroup E]
    [NormedSpace 𝕜 E] (H : Type*) [TopologicalSpace H] (I : ModelWithCorners 𝕜 E H) : E → H 
goal: E → H

full_name: ModelWithCorners.toPartialEquiv_coe
code: @[simp, mfld_simps]
theorem toPartialEquiv_coe : (I.toPartialEquiv : H → E) = I 
goal: ↑I.toPartialEquiv = ↑I

full_name: ModelWithCorners.mk_coe
code: @[simp, mfld_simps]
theorem mk_coe (e : PartialEquiv H E) (a b c d) :
    ((ModelWithCorners.mk e a b c d : ModelWithCorners 𝕜 E H) : H → E) = (e : H → E) 
goal: ↑{ toPartialEquiv := e, source_eq := a, unique_diff' := b, continuous_toFun := c, continuous_invFun := d } = ↑e

full_name: ModelWithCorners.toPartialEquiv_coe_symm
code: @[simp, mfld_simps]
theorem toPartialEquiv_coe_symm : (I.toPartialEquiv.symm : E → H) = I.symm 
goal: ↑I.symm = ↑I.symm

full_name: ModelWithCorners.mk_symm
code: @[simp, mfld_simps]
theorem mk_symm (e : PartialEquiv H E) (a b c d) :
    (ModelWithCorners.mk e a b c d : ModelWithCorners 𝕜 E H).symm = e.symm 
goal: { toPartialEquiv := e, source_eq := a, unique_diff' := b, continuous_toFun := c, continuous_invFun := d }.symm = e.symm

full_name: ModelWithCorners.continuous
code: @[continuity]
protected theorem continuous : Continuous I 
goal: Continuous ↑I

full_name: ModelWithCorners.continuousAt
code: protected theorem continuousAt {x} : ContinuousAt I x 
goal: ContinuousAt (↑I) x

full_name: ModelWithCorners.continuousWithinAt
code: protected theorem continuousWithinAt {s x} : ContinuousWithinAt I s x 
goal: ContinuousWithinAt (↑I) s x

full_name: ModelWithCorners.continuous_symm
code: @[continuity]
theorem continuous_symm : Continuous I.symm 
goal: Continuous ↑I.symm

full_name: ModelWithCorners.continuousAt_symm
code: theorem continuousAt_symm {x} : ContinuousAt I.symm x 
goal: ContinuousAt (↑I.symm) x

full_name: ModelWithCorners.continuousWithinAt_symm
code: theorem continuousWithinAt_symm {s x} : ContinuousWithinAt I.symm s x 
goal: ContinuousWithinAt (↑I.symm) s x

full_name: ModelWithCorners.continuousOn_symm
code: theorem continuousOn_symm {s} : ContinuousOn I.symm s 
goal: ContinuousOn (↑I.symm) s

full_name: ModelWithCorners.target_eq
code: @[simp, mfld_simps]
theorem target_eq : I.target = range (I : H → E) 
goal: I.target = Set.range ↑I

full_name: ModelWithCorners.unique_diff
code: protected theorem unique_diff : UniqueDiffOn 𝕜 (range I) 
goal: UniqueDiffOn 𝕜 (Set.range ↑I)

full_name: ModelWithCorners.left_inv
code: @[simp, mfld_simps]
protected theorem left_inv (x : H) : I.symm (I x) = x 
goal: ↑I.symm (↑I x) = x

full_name: ModelWithCorners.leftInverse
code: protected theorem leftInverse : LeftInverse I.symm I 
goal: Function.LeftInverse ↑I.symm ↑I

full_name: ModelWithCorners.injective
code: theorem injective : Injective I 
goal: Function.Injective ↑I

full_name: ModelWithCorners.symm_comp_self
code: @[simp, mfld_simps]
theorem symm_comp_self : I.symm ∘ I = id 
goal: ↑I.symm ∘ ↑I = id

full_name: ModelWithCorners.rightInvOn
code: protected theorem rightInvOn : RightInvOn I.symm I (range I) 
goal: Set.RightInvOn (↑I.symm) (↑I) (Set.range ↑I)

full_name: ModelWithCorners.right_inv
code: @[simp, mfld_simps]
protected theorem right_inv {x : E} (hx : x ∈ range I) : I (I.symm x) = x 
goal: ↑I (↑I.symm x) = x

full_name: ModelWithCorners.preimage_image
code: theorem preimage_image (s : Set H) : I ⁻¹' (I '' s) = s 
goal: ↑I ⁻¹' (↑I '' s) = s

full_name: ModelWithCorners.image_eq
code: protected theorem image_eq (s : Set H) : I '' s = I.symm ⁻¹' s ∩ range I 
goal: ↑I '' s = ↑I.symm ⁻¹' s ∩ Set.range ↑I

full_name: ModelWithCorners.closedEmbedding
code: protected theorem closedEmbedding : ClosedEmbedding I 
goal: ClosedEmbedding ↑I

full_name: ModelWithCorners.isClosed_range
code: theorem isClosed_range : IsClosed (range I) 
goal: IsClosed (Set.range ↑I)

full_name: ModelWithCorners.map_nhds_eq
code: theorem map_nhds_eq (x : H) : map I (𝓝 x) = 𝓝[range I] I x 
goal: Filter.map (↑I) (𝓝 x) = 𝓝[Set.range ↑I] ↑I x

full_name: ModelWithCorners.map_nhdsWithin_eq
code: theorem map_nhdsWithin_eq (s : Set H) (x : H) : map I (𝓝[s] x) = 𝓝[I '' s] I x 
goal: Filter.map (↑I) (𝓝[s] x) = 𝓝[↑I '' s] ↑I x

full_name: ModelWithCorners.image_mem_nhdsWithin
code: theorem image_mem_nhdsWithin {x : H} {s : Set H} (hs : s ∈ 𝓝 x) : I '' s ∈ 𝓝[range I] I x 
goal: ↑I '' s ∈ 𝓝[Set.range ↑I] ↑I x

full_name: ModelWithCorners.symm_map_nhdsWithin_image
code: theorem symm_map_nhdsWithin_image {x : H} {s : Set H} : map I.symm (𝓝[I '' s] I x) = 𝓝[s] x 
goal: Filter.map (↑I.symm) (𝓝[↑I '' s] ↑I x) = 𝓝[s] x

full_name: ModelWithCorners.symm_map_nhdsWithin_range
code: theorem symm_map_nhdsWithin_range (x : H) : map I.symm (𝓝[range I] I x) = 𝓝 x 
goal: Filter.map (↑I.symm) (𝓝[Set.range ↑I] ↑I x) = 𝓝 x

full_name: ModelWithCorners.unique_diff_preimage
code: theorem unique_diff_preimage {s : Set H} (hs : IsOpen s) :
    UniqueDiffOn 𝕜 (I.symm ⁻¹' s ∩ range I) 
goal: UniqueDiffOn 𝕜 (↑I.symm ⁻¹' s ∩ Set.range ↑I)

full_name: ModelWithCorners.unique_diff_preimage_source
code: theorem unique_diff_preimage_source {β : Type*} [TopologicalSpace β] {e : PartialHomeomorph H β} :
    UniqueDiffOn 𝕜 (I.symm ⁻¹' e.source ∩ range I) 
goal: UniqueDiffOn 𝕜 (↑I.symm ⁻¹' e.source ∩ Set.range ↑I)

full_name: ModelWithCorners.unique_diff_at_image
code: theorem unique_diff_at_image {x : H} : UniqueDiffWithinAt 𝕜 (range I) (I x) 
goal: UniqueDiffWithinAt 𝕜 (Set.range ↑I) (↑I x)

full_name: ModelWithCorners.symm_continuousWithinAt_comp_right_iff
code: theorem symm_continuousWithinAt_comp_right_iff {X} [TopologicalSpace X] {f : H → X} {s : Set H}
    {x : H} :
    ContinuousWithinAt (f ∘ I.symm) (I.symm ⁻¹' s ∩ range I) (I x) ↔ ContinuousWithinAt f s x 
goal: ContinuousWithinAt (f ∘ ↑I.symm) (↑I.symm ⁻¹' s ∩ Set.range ↑I) (↑I x) ↔ ContinuousWithinAt f s x

full_name: ModelWithCorners.locallyCompactSpace
code: protected theorem locallyCompactSpace [LocallyCompactSpace E] (I : ModelWithCorners 𝕜 E H) :
    LocallyCompactSpace H 
goal: LocallyCompactSpace H

full_name: ModelWithCorners.secondCountableTopology
code: protected theorem secondCountableTopology [SecondCountableTopology E] (I : ModelWithCorners 𝕜 E H) :
    SecondCountableTopology H 
goal: SecondCountableTopology H

full_name: modelWithCornersSelf_partialEquiv
code: /-- In the trivial model with corners, the associated `PartialEquiv` is the identity. -/
@[simp, mfld_simps]
theorem modelWithCornersSelf_partialEquiv : 𝓘(𝕜, E).toPartialEquiv = PartialEquiv.refl E 
goal: 𝓘(𝕜, E).toPartialEquiv = PartialEquiv.refl E

full_name: modelWithCornersSelf_coe
code: @[simp, mfld_simps]
theorem modelWithCornersSelf_coe : (𝓘(𝕜, E) : E → E) = id 
goal: ↑𝓘(𝕜, E) = id

full_name: modelWithCornersSelf_coe_symm
code: @[simp, mfld_simps]
theorem modelWithCornersSelf_coe_symm : (𝓘(𝕜, E).symm : E → E) = id 
goal: ↑𝓘(𝕜, E).symm = id

full_name: ModelWithCorners.prod_target
code: /-- Given two model_with_corners `I` on `(E, H)` and `I'` on `(E', H')`, we define the model with
corners `I.prod I'` on `(E × E', ModelProd H H')`. This appears in particular for the manifold
structure on the tangent bundle to a manifold modelled on `(E, H)`: it will be modelled on
`(E × E, H × E)`. See note [Manifold type tags] for explanation about `ModelProd H H'`
vs `H × H'`. -/
@[simps (config := .lemmasOnly)]
def ModelWithCorners.prod {𝕜 : Type u} [NontriviallyNormedField 𝕜] {E : Type v}
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] {H : Type w} [TopologicalSpace H]
    (I : ModelWithCorners 𝕜 E H) {E' : Type v'} [NormedAddCommGroup E'] [NormedSpace 𝕜 E']
    {H' : Type w'} [TopologicalSpace H'] (I' : ModelWithCorners 𝕜 E' H') :
    ModelWithCorners 𝕜 (E × E') (ModelProd H H') 
goal: (I.prod I').target = (I.prod I'.toPartialEquiv).target

full_name: ModelWithCorners.prod_source
code: /-- Given two model_with_corners `I` on `(E, H)` and `I'` on `(E', H')`, we define the model with
corners `I.prod I'` on `(E × E', ModelProd H H')`. This appears in particular for the manifold
structure on the tangent bundle to a manifold modelled on `(E, H)`: it will be modelled on
`(E × E, H × E)`. See note [Manifold type tags] for explanation about `ModelProd H H'`
vs `H × H'`. -/
@[simps (config := .lemmasOnly)]
def ModelWithCorners.prod {𝕜 : Type u} [NontriviallyNormedField 𝕜] {E : Type v}
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] {H : Type w} [TopologicalSpace H]
    (I : ModelWithCorners 𝕜 E H) {E' : Type v'} [NormedAddCommGroup E'] [NormedSpace 𝕜 E']
    {H' : Type w'} [TopologicalSpace H'] (I' : ModelWithCorners 𝕜 E' H') :
    ModelWithCorners 𝕜 (E × E') (ModelProd H H') 
goal: (I.prod I').source = {x | x.1 ∈ I.source ∧ x.2 ∈ I'.source}

full_name: ModelWithCorners.prod_apply
code: /-- Given two model_with_corners `I` on `(E, H)` and `I'` on `(E', H')`, we define the model with
corners `I.prod I'` on `(E × E', ModelProd H H')`. This appears in particular for the manifold
structure on the tangent bundle to a manifold modelled on `(E, H)`: it will be modelled on
`(E × E, H × E)`. See note [Manifold type tags] for explanation about `ModelProd H H'`
vs `H × H'`. -/
@[simps (config := .lemmasOnly)]
def ModelWithCorners.prod {𝕜 : Type u} [NontriviallyNormedField 𝕜] {E : Type v}
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] {H : Type w} [TopologicalSpace H]
    (I : ModelWithCorners 𝕜 E H) {E' : Type v'} [NormedAddCommGroup E'] [NormedSpace 𝕜 E']
    {H' : Type w'} [TopologicalSpace H'] (I' : ModelWithCorners 𝕜 E' H') :
    ModelWithCorners 𝕜 (E × E') (ModelProd H H') 
goal: ↑(I.prod I') x = (↑I x.1, ↑I' x.2)

full_name: ModelWithCorners.prod_symm_apply
code: /-- Given two model_with_corners `I` on `(E, H)` and `I'` on `(E', H')`, we define the model with
corners `I.prod I'` on `(E × E', ModelProd H H')`. This appears in particular for the manifold
structure on the tangent bundle to a manifold modelled on `(E, H)`: it will be modelled on
`(E × E, H × E)`. See note [Manifold type tags] for explanation about `ModelProd H H'`
vs `H × H'`. -/
@[simps (config := .lemmasOnly)]
def ModelWithCorners.prod {𝕜 : Type u} [NontriviallyNormedField 𝕜] {E : Type v}
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] {H : Type w} [TopologicalSpace H]
    (I : ModelWithCorners 𝕜 E H) {E' : Type v'} [NormedAddCommGroup E'] [NormedSpace 𝕜 E']
    {H' : Type w'} [TopologicalSpace H'] (I' : ModelWithCorners 𝕜 E' H') :
    ModelWithCorners 𝕜 (E × E') (ModelProd H H') 
goal: ↑(I.prod I').symm x = (↑I.symm x.1, ↑I'.symm x.2)

full_name: ModelWithCorners.prod
code: /-- Given two model_with_corners `I` on `(E, H)` and `I'` on `(E', H')`, we define the model with
corners `I.prod I'` on `(E × E', ModelProd H H')`. This appears in particular for the manifold
structure on the tangent bundle to a manifold modelled on `(E, H)`: it will be modelled on
`(E × E, H × E)`. See note [Manifold type tags] for explanation about `ModelProd H H'`
vs `H × H'`. -/
@[simps (config := .lemmasOnly)]
def ModelWithCorners.prod {𝕜 : Type u} [NontriviallyNormedField 𝕜] {E : Type v}
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] {H : Type w} [TopologicalSpace H]
    (I : ModelWithCorners 𝕜 E H) {E' : Type v'} [NormedAddCommGroup E'] [NormedSpace 𝕜 E']
    {H' : Type w'} [TopologicalSpace H'] (I' : ModelWithCorners 𝕜 E' H') :
    ModelWithCorners 𝕜 (E × E') (ModelProd H H') 
goal: ModelWithCorners 𝕜 (E × E') (ModelProd H H')

full_name: ModelWithCorners.pi
code: /-- Given a finite family of `ModelWithCorners` `I i` on `(E i, H i)`, we define the model with
corners `pi I` on `(Π i, E i, ModelPi H)`. See note [Manifold type tags] for explanation about
`ModelPi H`. -/
def ModelWithCorners.pi {𝕜 : Type u} [NontriviallyNormedField 𝕜] {ι : Type v} [Fintype ι]
    {E : ι → Type w} [∀ i, NormedAddCommGroup (E i)] [∀ i, NormedSpace 𝕜 (E i)] {H : ι → Type u'}
    [∀ i, TopologicalSpace (H i)] (I : ∀ i, ModelWithCorners 𝕜 (E i) (H i)) :
    ModelWithCorners 𝕜 (∀ i, E i) (ModelPi H) 
goal: ModelWithCorners 𝕜 ((i : ι) → E i) (ModelPi H)

full_name: ModelWithCorners.tangent
code: /-- Special case of product model with corners, which is trivial on the second factor. This shows up
as the model to tangent bundles. -/
abbrev ModelWithCorners.tangent {𝕜 : Type u} [NontriviallyNormedField 𝕜] {E : Type v}
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] {H : Type w} [TopologicalSpace H]
    (I : ModelWithCorners 𝕜 E H) : ModelWithCorners 𝕜 (E × E) (ModelProd H E) 
goal: ModelWithCorners 𝕜 (E × E) (ModelProd H E)

full_name: modelWithCorners_prod_toPartialEquiv
code: @[simp, mfld_simps]
theorem modelWithCorners_prod_toPartialEquiv :
    (I.prod J).toPartialEquiv = I.toPartialEquiv.prod J.toPartialEquiv 
goal: (I.prod J).toPartialEquiv = I.prod J.toPartialEquiv

full_name: modelWithCorners_prod_coe
code: @[simp, mfld_simps]
theorem modelWithCorners_prod_coe (I : ModelWithCorners 𝕜 E H) (I' : ModelWithCorners 𝕜 E' H') :
    (I.prod I' : _ × _ → _ × _) = Prod.map I I' 
goal: ↑(I.prod I') = Prod.map ↑I ↑I'

full_name: modelWithCorners_prod_coe_symm
code: @[simp, mfld_simps]
theorem modelWithCorners_prod_coe_symm (I : ModelWithCorners 𝕜 E H)
    (I' : ModelWithCorners 𝕜 E' H') :
    ((I.prod I').symm : _ × _ → _ × _) = Prod.map I.symm I'.symm 
goal: ↑(I.prod I').symm = Prod.map ↑I.symm ↑I'.symm

full_name: modelWithCornersSelf_prod
code: theorem modelWithCornersSelf_prod : 𝓘(𝕜, E × F) = 𝓘(𝕜, E).prod 𝓘(𝕜, F) 
goal: 𝓘(𝕜, E × F) = 𝓘(𝕜, E).prod 𝓘(𝕜, F)

full_name: ModelWithCorners.range_prod
code: theorem ModelWithCorners.range_prod : range (I.prod J) = range I ×ˢ range J 
goal: Set.range ↑(I.prod J) = Set.range ↑I ×ˢ Set.range ↑J

full_name: ModelWithCorners.Boundaryless.range_eq_univ
code: /-- Property ensuring that the model with corners `I` defines manifolds without boundary. This
  differs from the more general `BoundarylessManifold`, which requires every point on the manifold
  to be an interior point.  -/
class ModelWithCorners.Boundaryless {𝕜 : Type*} [NontriviallyNormedField 𝕜] {E : Type*}
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] {H : Type*} [TopologicalSpace H]
    (I : ModelWithCorners 𝕜 E H) : Prop where
  range_eq_univ : range I = univ
goal: Set.range ↑I = Set.univ

full_name: ModelWithCorners.Boundaryless
code: /-- Property ensuring that the model with corners `I` defines manifolds without boundary. This
  differs from the more general `BoundarylessManifold`, which requires every point on the manifold
  to be an interior point.  -/
class ModelWithCorners.Boundaryless {𝕜 : Type*} [NontriviallyNormedField 𝕜] {E : Type*}
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] {H : Type*} [TopologicalSpace H]
    (I : ModelWithCorners 𝕜 E H) : Prop where
  range_eq_univ : range I = univ
goal: Prop

full_name: ModelWithCorners.range_eq_univ
code: theorem ModelWithCorners.range_eq_univ {𝕜 : Type*} [NontriviallyNormedField 𝕜] {E : Type*}
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] {H : Type*} [TopologicalSpace H]
    (I : ModelWithCorners 𝕜 E H) [I.Boundaryless] :
    range I = univ 
goal: Set.range ↑I = Set.univ

full_name: ModelWithCorners.toHomeomorph_symm_apply
code: /-- If `I` is a `ModelWithCorners.Boundaryless` model, then it is a homeomorphism. -/
@[simps (config := {simpRhs := true})]
def ModelWithCorners.toHomeomorph {𝕜 : Type*} [NontriviallyNormedField 𝕜] {E : Type*}
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] {H : Type*} [TopologicalSpace H]
    (I : ModelWithCorners 𝕜 E H) [I.Boundaryless] : H ≃ₜ E 
goal: ∀ (a : E), I.toHomeomorph.symm a = ↑I.symm a

full_name: ModelWithCorners.toHomeomorph_apply
code: /-- If `I` is a `ModelWithCorners.Boundaryless` model, then it is a homeomorphism. -/
@[simps (config := {simpRhs := true})]
def ModelWithCorners.toHomeomorph {𝕜 : Type*} [NontriviallyNormedField 𝕜] {E : Type*}
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] {H : Type*} [TopologicalSpace H]
    (I : ModelWithCorners 𝕜 E H) [I.Boundaryless] : H ≃ₜ E 
goal: ∀ (a : H), I.toHomeomorph a = ↑I a

full_name: ModelWithCorners.toHomeomorph
code: /-- If `I` is a `ModelWithCorners.Boundaryless` model, then it is a homeomorphism. -/
@[simps (config := {simpRhs := true})]
def ModelWithCorners.toHomeomorph {𝕜 : Type*} [NontriviallyNormedField 𝕜] {E : Type*}
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] {H : Type*} [TopologicalSpace H]
    (I : ModelWithCorners 𝕜 E H) [I.Boundaryless] : H ≃ₜ E 
goal: H ≃ₜ E

full_name: modelWithCornersSelf_boundaryless
code: /-- The trivial model with corners has no boundary -/
instance modelWithCornersSelf_boundaryless (𝕜 : Type*) [NontriviallyNormedField 𝕜] (E : Type*)
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] : (modelWithCornersSelf 𝕜 E).Boundaryless 
goal: 𝓘(𝕜, E).Boundaryless

full_name: ModelWithCorners.range_eq_univ_prod
code: /-- If two model with corners are boundaryless, their product also is -/
instance ModelWithCorners.range_eq_univ_prod {𝕜 : Type u} [NontriviallyNormedField 𝕜] {E : Type v}
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] {H : Type w} [TopologicalSpace H]
    (I : ModelWithCorners 𝕜 E H) [I.Boundaryless] {E' : Type v'} [NormedAddCommGroup E']
    [NormedSpace 𝕜 E'] {H' : Type w'} [TopologicalSpace H'] (I' : ModelWithCorners 𝕜 E' H')
    [I'.Boundaryless] : (I.prod I').Boundaryless 
goal: (I.prod I').Boundaryless

full_name: contDiffPregroupoid
code: /-- Given a model with corners `(E, H)`, we define the pregroupoid of `C^n` transformations of `H`
as the maps that are `C^n` when read in `E` through `I`. -/
def contDiffPregroupoid : Pregroupoid H 
goal: Pregroupoid H

full_name: contDiffGroupoid
code: /-- Given a model with corners `(E, H)`, we define the groupoid of invertible `C^n` transformations
  of `H` as the invertible maps that are `C^n` when read in `E` through `I`. -/
def contDiffGroupoid : StructureGroupoid H 
goal: StructureGroupoid H

full_name: contDiffGroupoid_le
code: /-- Inclusion of the groupoid of `C^n` local diffeos in the groupoid of `C^m` local diffeos when
`m ≤ n` -/
theorem contDiffGroupoid_le (h : m ≤ n) : contDiffGroupoid n I ≤ contDiffGroupoid m I 
goal: contDiffGroupoid n I ≤ contDiffGroupoid m I

full_name: contDiffGroupoid_zero_eq
code: /-- The groupoid of `0`-times continuously differentiable maps is just the groupoid of all
partial homeomorphisms -/
theorem contDiffGroupoid_zero_eq : contDiffGroupoid 0 I = continuousGroupoid H 
goal: contDiffGroupoid 0 I = continuousGroupoid H

full_name: ofSet_mem_contDiffGroupoid
code: /-- An identity partial homeomorphism belongs to the `C^n` groupoid. -/
theorem ofSet_mem_contDiffGroupoid {s : Set H} (hs : IsOpen s) :
    PartialHomeomorph.ofSet s hs ∈ contDiffGroupoid n I 
goal: PartialHomeomorph.ofSet s hs ∈ contDiffGroupoid n I

full_name: symm_trans_mem_contDiffGroupoid
code: /-- The composition of a partial homeomorphism from `H` to `M` and its inverse belongs to
the `C^n` groupoid. -/
theorem symm_trans_mem_contDiffGroupoid (e : PartialHomeomorph M H) :
    e.symm.trans e ∈ contDiffGroupoid n I 
goal: e.symm ≫ₕ e ∈ contDiffGroupoid n I

full_name: contDiffGroupoid_prod
code: /-- The product of two smooth partial homeomorphisms is smooth. -/
theorem contDiffGroupoid_prod {I : ModelWithCorners 𝕜 E H} {I' : ModelWithCorners 𝕜 E' H'}
    {e : PartialHomeomorph H H} {e' : PartialHomeomorph H' H'} (he : e ∈ contDiffGroupoid ⊤ I)
    (he' : e' ∈ contDiffGroupoid ⊤ I') : e.prod e' ∈ contDiffGroupoid ⊤ (I.prod I') 
goal: e.prod e' ∈ contDiffGroupoid ⊤ (I.prod I')

full_name: instClosedUnderRestrictionContDiffGroupoid
code: /-- The `C^n` groupoid is closed under restriction. -/
instance : ClosedUnderRestriction (contDiffGroupoid n I) 
goal: ClosedUnderRestriction (contDiffGroupoid n I)

full_name: SmoothManifoldWithCorners
code: /-- Typeclass defining smooth manifolds with corners with respect to a model with corners, over a
field `𝕜` and with infinite smoothness to simplify typeclass search and statements later on. -/
class SmoothManifoldWithCorners {𝕜 : Type*} [NontriviallyNormedField 𝕜] {E : Type*}
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] {H : Type*} [TopologicalSpace H]
    (I : ModelWithCorners 𝕜 E H) (M : Type*) [TopologicalSpace M] [ChartedSpace H M] extends
    HasGroupoid M (contDiffGroupoid ∞ I) : Prop
goal: Prop

full_name: SmoothManifoldWithCorners.mk'
code: theorem SmoothManifoldWithCorners.mk' {𝕜 : Type*} [NontriviallyNormedField 𝕜] {E : Type*}
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] {H : Type*} [TopologicalSpace H]
    (I : ModelWithCorners 𝕜 E H) (M : Type*) [TopologicalSpace M] [ChartedSpace H M]
    [gr : HasGroupoid M (contDiffGroupoid ∞ I)] : SmoothManifoldWithCorners I M 
goal: SmoothManifoldWithCorners I M

full_name: smoothManifoldWithCorners_of_contDiffOn
code: theorem smoothManifoldWithCorners_of_contDiffOn {𝕜 : Type*} [NontriviallyNormedField 𝕜]
    {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E] {H : Type*} [TopologicalSpace H]
    (I : ModelWithCorners 𝕜 E H) (M : Type*) [TopologicalSpace M] [ChartedSpace H M]
    (h : ∀ e e' : PartialHomeomorph M H, e ∈ atlas H M → e' ∈ atlas H M →
      ContDiffOn 𝕜 ⊤ (I ∘ e.symm ≫ₕ e' ∘ I.symm) (I.symm ⁻¹' (e.symm ≫ₕ e').source ∩ range I)) :
    SmoothManifoldWithCorners I M 
goal: SmoothManifoldWithCorners I M

full_name: model_space_smooth
code: /-- For any model with corners, the model space is a smooth manifold -/
instance model_space_smooth {𝕜 : Type*} [NontriviallyNormedField 𝕜] {E : Type*}
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] {H : Type*} [TopologicalSpace H]
    {I : ModelWithCorners 𝕜 E H} : SmoothManifoldWithCorners I H 
goal: SmoothManifoldWithCorners I H

full_name: SmoothManifoldWithCorners.maximalAtlas
code: /-- The maximal atlas of `M` for the smooth manifold with corners structure corresponding to the
model with corners `I`. -/
def maximalAtlas 
goal: Set (PartialHomeomorph M H)

full_name: SmoothManifoldWithCorners.subset_maximalAtlas
code: theorem subset_maximalAtlas [SmoothManifoldWithCorners I M] : atlas H M ⊆ maximalAtlas I M 
goal: atlas H M ⊆ SmoothManifoldWithCorners.maximalAtlas I M

full_name: SmoothManifoldWithCorners.chart_mem_maximalAtlas
code: theorem chart_mem_maximalAtlas [SmoothManifoldWithCorners I M] (x : M) :
    chartAt H x ∈ maximalAtlas I M 
goal: chartAt H x ∈ SmoothManifoldWithCorners.maximalAtlas I M

full_name: SmoothManifoldWithCorners.compatible_of_mem_maximalAtlas
code: theorem compatible_of_mem_maximalAtlas {e e' : PartialHomeomorph M H} (he : e ∈ maximalAtlas I M)
    (he' : e' ∈ maximalAtlas I M) : e.symm.trans e' ∈ contDiffGroupoid ∞ I 
goal: e.symm ≫ₕ e' ∈ contDiffGroupoid ⊤ I

full_name: SmoothManifoldWithCorners.empty
code: /-- The empty set is a smooth manifold w.r.t. any charted space and model. -/
instance empty [IsEmpty M] : SmoothManifoldWithCorners I M 
goal: SmoothManifoldWithCorners I M

full_name: SmoothManifoldWithCorners.prod
code: /-- The product of two smooth manifolds with corners is naturally a smooth manifold with corners. -/
instance prod {𝕜 : Type*} [NontriviallyNormedField 𝕜] {E : Type*} [NormedAddCommGroup E]
    [NormedSpace 𝕜 E] {E' : Type*} [NormedAddCommGroup E'] [NormedSpace 𝕜 E'] {H : Type*}
    [TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {H' : Type*} [TopologicalSpace H']
    {I' : ModelWithCorners 𝕜 E' H'} (M : Type*) [TopologicalSpace M] [ChartedSpace H M]
    [SmoothManifoldWithCorners I M] (M' : Type*) [TopologicalSpace M'] [ChartedSpace H' M']
    [SmoothManifoldWithCorners I' M'] : SmoothManifoldWithCorners (I.prod I') (M × M') 
goal: SmoothManifoldWithCorners (I.prod I') (M × M')

full_name: PartialHomeomorph.singleton_smoothManifoldWithCorners
code: theorem PartialHomeomorph.singleton_smoothManifoldWithCorners
    {𝕜 : Type*} [NontriviallyNormedField 𝕜] {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
    {H : Type*} [TopologicalSpace H] (I : ModelWithCorners 𝕜 E H)
    {M : Type*} [TopologicalSpace M] (e : PartialHomeomorph M H) (h : e.source = Set.univ) :
    @SmoothManifoldWithCorners 𝕜 _ E _ _ H _ I M _ (e.singletonChartedSpace h) 
goal: SmoothManifoldWithCorners I M

full_name: OpenEmbedding.singleton_smoothManifoldWithCorners
code: theorem OpenEmbedding.singleton_smoothManifoldWithCorners {𝕜 : Type*} [NontriviallyNormedField 𝕜]
    {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E] {H : Type*} [TopologicalSpace H]
    (I : ModelWithCorners 𝕜 E H) {M : Type*} [TopologicalSpace M] [Nonempty M] {f : M → H}
    (h : OpenEmbedding f) :
    @SmoothManifoldWithCorners 𝕜 _ E _ _ H _ I M _ h.singletonChartedSpace 
goal: SmoothManifoldWithCorners I M

full_name: TopologicalSpace.Opens.instSmoothManifoldWithCornersSubtypeMem
code: instance : SmoothManifoldWithCorners I s 
goal: SmoothManifoldWithCorners I ↥s

full_name: PartialHomeomorph.extend
code: /-- Given a chart `f` on a manifold with corners, `f.extend I` is the extended chart to the model
vector space. -/
@[simp, mfld_simps]
def extend : PartialEquiv M E 
goal: PartialEquiv M E

full_name: PartialHomeomorph.extend_coe
code: theorem extend_coe : ⇑(f.extend I) = I ∘ f 
goal: ↑(f.extend I) = ↑I ∘ ↑f

full_name: PartialHomeomorph.extend_coe_symm
code: theorem extend_coe_symm : ⇑(f.extend I).symm = f.symm ∘ I.symm 
goal: ↑(f.extend I).symm = ↑f.symm ∘ ↑I.symm

full_name: PartialHomeomorph.extend_source
code: theorem extend_source : (f.extend I).source = f.source 
goal: (f.extend I).source = f.source

full_name: PartialHomeomorph.isOpen_extend_source
code: theorem isOpen_extend_source : IsOpen (f.extend I).source 
goal: IsOpen (f.extend I).source

full_name: PartialHomeomorph.extend_target
code: theorem extend_target : (f.extend I).target = I.symm ⁻¹' f.target ∩ range I 
goal: (f.extend I).target = ↑I.symm ⁻¹' f.target ∩ Set.range ↑I

full_name: PartialHomeomorph.extend_target'
code: theorem extend_target' : (f.extend I).target = I '' f.target 
goal: (f.extend I).target = ↑I '' f.target

full_name: PartialHomeomorph.isOpen_extend_target
code: lemma isOpen_extend_target [I.Boundaryless] : IsOpen (f.extend I).target 
goal: IsOpen (f.extend I).target

full_name: PartialHomeomorph.mapsTo_extend
code: theorem mapsTo_extend (hs : s ⊆ f.source) :
    MapsTo (f.extend I) s ((f.extend I).symm ⁻¹' s ∩ range I) 
goal: Set.MapsTo (↑(f.extend I)) s (↑(f.extend I).symm ⁻¹' s ∩ Set.range ↑I)

full_name: PartialHomeomorph.extend_left_inv
code: theorem extend_left_inv {x : M} (hxf : x ∈ f.source) : (f.extend I).symm (f.extend I x) = x 
goal: ↑(f.extend I).symm (↑(f.extend I) x) = x

full_name: PartialHomeomorph.extend_left_inv'
code: /-- Variant of `f.extend_left_inv I`, stated in terms of images. -/
lemma extend_left_inv' (ht : t ⊆ f.source) : ((f.extend I).symm ∘ (f.extend I)) '' t = t 
goal: ↑(f.extend I).symm ∘ ↑(f.extend I) '' t = t

full_name: PartialHomeomorph.extend_source_mem_nhds
code: theorem extend_source_mem_nhds {x : M} (h : x ∈ f.source) : (f.extend I).source ∈ 𝓝 x 
goal: (f.extend I).source ∈ 𝓝 x

full_name: PartialHomeomorph.extend_source_mem_nhdsWithin
code: theorem extend_source_mem_nhdsWithin {x : M} (h : x ∈ f.source) : (f.extend I).source ∈ 𝓝[s] x 
goal: (f.extend I).source ∈ 𝓝[s] x

full_name: PartialHomeomorph.continuousOn_extend
code: theorem continuousOn_extend : ContinuousOn (f.extend I) (f.extend I).source 
goal: ContinuousOn (↑(f.extend I)) (f.extend I).source

full_name: PartialHomeomorph.continuousAt_extend
code: theorem continuousAt_extend {x : M} (h : x ∈ f.source) : ContinuousAt (f.extend I) x 
goal: ContinuousAt (↑(f.extend I)) x

full_name: PartialHomeomorph.map_extend_nhds
code: theorem map_extend_nhds {x : M} (hy : x ∈ f.source) :
    map (f.extend I) (𝓝 x) = 𝓝[range I] f.extend I x 
goal: Filter.map (↑(f.extend I)) (𝓝 x) = 𝓝[Set.range ↑I] ↑(f.extend I) x

full_name: PartialHomeomorph.map_extend_nhds_of_boundaryless
code: theorem map_extend_nhds_of_boundaryless [I.Boundaryless] {x : M} (hx : x ∈ f.source) :
    map (f.extend I) (𝓝 x) = 𝓝 (f.extend I x) 
goal: Filter.map (↑(f.extend I)) (𝓝 x) = 𝓝 (↑(f.extend I) x)

full_name: PartialHomeomorph.extend_target_mem_nhdsWithin
code: theorem extend_target_mem_nhdsWithin {y : M} (hy : y ∈ f.source) :
    (f.extend I).target ∈ 𝓝[range I] f.extend I y 
goal: (f.extend I).target ∈ 𝓝[Set.range ↑I] ↑(f.extend I) y

full_name: PartialHomeomorph.extend_image_nhd_mem_nhds_of_boundaryless
code: theorem extend_image_nhd_mem_nhds_of_boundaryless [I.Boundaryless] {x} (hx : x ∈ f.source)
    {s : Set M} (h : s ∈ 𝓝 x) : (f.extend I) '' s ∈ 𝓝 ((f.extend I) x) 
goal: ↑(f.extend I) '' s ∈ 𝓝 (↑(f.extend I) x)

full_name: PartialHomeomorph.extend_target_subset_range
code: theorem extend_target_subset_range : (f.extend I).target ⊆ range I 
goal: (f.extend I).target ⊆ Set.range ↑I

full_name: PartialHomeomorph.interior_extend_target_subset_interior_range
code: lemma interior_extend_target_subset_interior_range :
    interior (f.extend I).target ⊆ interior (range I) 
goal: interior (f.extend I).target ⊆ interior (Set.range ↑I)

full_name: PartialHomeomorph.mem_interior_extend_target
code: /-- If `y ∈ f.target` and `I y ∈ interior (range I)`,
  then `I y` is an interior point of `(I ∘ f).target`. -/
lemma mem_interior_extend_target {y : H} (hy : y ∈ f.target)
    (hy' : I y ∈ interior (range I)) : I y ∈ interior (f.extend I).target 
goal: ↑I y ∈ interior (f.extend I).target

full_name: PartialHomeomorph.nhdsWithin_extend_target_eq
code: theorem nhdsWithin_extend_target_eq {y : M} (hy : y ∈ f.source) :
    𝓝[(f.extend I).target] f.extend I y = 𝓝[range I] f.extend I y 
goal: 𝓝[(f.extend I).target] ↑(f.extend I) y = 𝓝[Set.range ↑I] ↑(f.extend I) y

full_name: PartialHomeomorph.continuousAt_extend_symm'
code: theorem continuousAt_extend_symm' {x : E} (h : x ∈ (f.extend I).target) :
    ContinuousAt (f.extend I).symm x 
goal: ContinuousAt (↑(f.extend I).symm) x

full_name: PartialHomeomorph.continuousAt_extend_symm
code: theorem continuousAt_extend_symm {x : M} (h : x ∈ f.source) :
    ContinuousAt (f.extend I).symm (f.extend I x) 
goal: ContinuousAt (↑(f.extend I).symm) (↑(f.extend I) x)

full_name: PartialHomeomorph.continuousOn_extend_symm
code: theorem continuousOn_extend_symm : ContinuousOn (f.extend I).symm (f.extend I).target 
goal: ContinuousOn (↑(f.extend I).symm) (f.extend I).target

full_name: PartialHomeomorph.extend_symm_continuousWithinAt_comp_right_iff
code: theorem extend_symm_continuousWithinAt_comp_right_iff {X} [TopologicalSpace X] {g : M → X}
    {s : Set M} {x : M} :
    ContinuousWithinAt (g ∘ (f.extend I).symm) ((f.extend I).symm ⁻¹' s ∩ range I) (f.extend I x) ↔
      ContinuousWithinAt (g ∘ f.symm) (f.symm ⁻¹' s) (f x) 
goal: ContinuousWithinAt (g ∘ ↑(f.extend I).symm) (↑(f.extend I).symm ⁻¹' s ∩ Set.range ↑I) (↑(f.extend I) x) ↔
  ContinuousWithinAt (g ∘ ↑f.symm) (↑f.symm ⁻¹' s) (↑f x)

full_name: PartialHomeomorph.isOpen_extend_preimage'
code: theorem isOpen_extend_preimage' {s : Set E} (hs : IsOpen s) :
    IsOpen ((f.extend I).source ∩ f.extend I ⁻¹' s) 
goal: IsOpen ((f.extend I).source ∩ ↑(f.extend I) ⁻¹' s)

full_name: PartialHomeomorph.isOpen_extend_preimage
code: theorem isOpen_extend_preimage {s : Set E} (hs : IsOpen s) :
    IsOpen (f.source ∩ f.extend I ⁻¹' s) 
goal: IsOpen (f.source ∩ ↑(f.extend I) ⁻¹' s)

full_name: PartialHomeomorph.map_extend_nhdsWithin_eq_image
code: theorem map_extend_nhdsWithin_eq_image {y : M} (hy : y ∈ f.source) :
    map (f.extend I) (𝓝[s] y) = 𝓝[f.extend I '' ((f.extend I).source ∩ s)] f.extend I y 
goal: Filter.map (↑(f.extend I)) (𝓝[s] y) = 𝓝[↑(f.extend I) '' ((f.extend I).source ∩ s)] ↑(f.extend I) y

full_name: PartialHomeomorph.map_extend_nhdsWithin_eq_image_of_subset
code: theorem map_extend_nhdsWithin_eq_image_of_subset {y : M} (hy : y ∈ f.source) (hs : s ⊆ f.source) :
    map (f.extend I) (𝓝[s] y) = 𝓝[f.extend I '' s] f.extend I y 
goal: Filter.map (↑(f.extend I)) (𝓝[s] y) = 𝓝[↑(f.extend I) '' s] ↑(f.extend I) y

full_name: PartialHomeomorph.map_extend_nhdsWithin
code: theorem map_extend_nhdsWithin {y : M} (hy : y ∈ f.source) :
    map (f.extend I) (𝓝[s] y) = 𝓝[(f.extend I).symm ⁻¹' s ∩ range I] f.extend I y 
goal: Filter.map (↑(f.extend I)) (𝓝[s] y) = 𝓝[↑(f.extend I).symm ⁻¹' s ∩ Set.range ↑I] ↑(f.extend I) y

full_name: PartialHomeomorph.map_extend_symm_nhdsWithin
code: theorem map_extend_symm_nhdsWithin {y : M} (hy : y ∈ f.source) :
    map (f.extend I).symm (𝓝[(f.extend I).symm ⁻¹' s ∩ range I] f.extend I y) = 𝓝[s] y 
goal: Filter.map (↑(f.extend I).symm) (𝓝[↑(f.extend I).symm ⁻¹' s ∩ Set.range ↑I] ↑(f.extend I) y) = 𝓝[s] y

full_name: PartialHomeomorph.map_extend_symm_nhdsWithin_range
code: theorem map_extend_symm_nhdsWithin_range {y : M} (hy : y ∈ f.source) :
    map (f.extend I).symm (𝓝[range I] f.extend I y) = 𝓝 y 
goal: Filter.map (↑(f.extend I).symm) (𝓝[Set.range ↑I] ↑(f.extend I) y) = 𝓝 y

full_name: PartialHomeomorph.tendsto_extend_comp_iff
code: theorem tendsto_extend_comp_iff {α : Type*} {l : Filter α} {g : α → M}
    (hg : ∀ᶠ z in l, g z ∈ f.source) {y : M} (hy : y ∈ f.source) :
    Tendsto (f.extend I ∘ g) l (𝓝 (f.extend I y)) ↔ Tendsto g l (𝓝 y) 
goal: Filter.Tendsto (↑(f.extend I) ∘ g) l (𝓝 (↑(f.extend I) y)) ↔ Filter.Tendsto g l (𝓝 y)

full_name: PartialHomeomorph.continuousWithinAt_writtenInExtend_iff
code: theorem continuousWithinAt_writtenInExtend_iff {f' : PartialHomeomorph M' H'} {g : M → M'} {y : M}
    (hy : y ∈ f.source) (hgy : g y ∈ f'.source) (hmaps : MapsTo g s f'.source) :
    ContinuousWithinAt (f'.extend I' ∘ g ∘ (f.extend I).symm)
      ((f.extend I).symm ⁻¹' s ∩ range I) (f.extend I y) ↔ ContinuousWithinAt g s y 
goal: ContinuousWithinAt (↑(f'.extend I') ∘ g ∘ ↑(f.extend I).symm) (↑(f.extend I).symm ⁻¹' s ∩ Set.range ↑I)
    (↑(f.extend I) y) ↔
  ContinuousWithinAt g s y

full_name: PartialHomeomorph.continuousOn_writtenInExtend_iff
code: /-- If `s ⊆ f.source` and `g x ∈ f'.source` whenever `x ∈ s`, then `g` is continuous on `s` if and
only if `g` written in charts `f.extend I` and `f'.extend I'` is continuous on `f.extend I '' s`. -/
theorem continuousOn_writtenInExtend_iff {f' : PartialHomeomorph M' H'} {g : M → M'}
    (hs : s ⊆ f.source) (hmaps : MapsTo g s f'.source) :
    ContinuousOn (f'.extend I' ∘ g ∘ (f.extend I).symm) (f.extend I '' s) ↔ ContinuousOn g s 
goal: ContinuousOn (↑(f'.extend I') ∘ g ∘ ↑(f.extend I).symm) (↑(f.extend I) '' s) ↔ ContinuousOn g s

full_name: PartialHomeomorph.extend_preimage_mem_nhdsWithin
code: /-- Technical lemma ensuring that the preimage under an extended chart of a neighborhood of a point
in the source is a neighborhood of the preimage, within a set. -/
theorem extend_preimage_mem_nhdsWithin {x : M} (h : x ∈ f.source) (ht : t ∈ 𝓝[s] x) :
    (f.extend I).symm ⁻¹' t ∈ 𝓝[(f.extend I).symm ⁻¹' s ∩ range I] f.extend I x 
goal: ↑(f.extend I).symm ⁻¹' t ∈ 𝓝[↑(f.extend I).symm ⁻¹' s ∩ Set.range ↑I] ↑(f.extend I) x

full_name: PartialHomeomorph.extend_preimage_mem_nhds
code: theorem extend_preimage_mem_nhds {x : M} (h : x ∈ f.source) (ht : t ∈ 𝓝 x) :
    (f.extend I).symm ⁻¹' t ∈ 𝓝 (f.extend I x) 
goal: ↑(f.extend I).symm ⁻¹' t ∈ 𝓝 (↑(f.extend I) x)

full_name: PartialHomeomorph.extend_preimage_inter_eq
code: /-- Technical lemma to rewrite suitably the preimage of an intersection under an extended chart, to
bring it into a convenient form to apply derivative lemmas. -/
theorem extend_preimage_inter_eq :
    (f.extend I).symm ⁻¹' (s ∩ t) ∩ range I =
      (f.extend I).symm ⁻¹' s ∩ range I ∩ (f.extend I).symm ⁻¹' t 
goal: ↑(f.extend I).symm ⁻¹' (s ∩ t) ∩ Set.range ↑I = ↑(f.extend I).symm ⁻¹' s ∩ Set.range ↑I ∩ ↑(f.extend I).symm ⁻¹' t

full_name: PartialHomeomorph.extend_symm_preimage_inter_range_eventuallyEq_aux
code: theorem extend_symm_preimage_inter_range_eventuallyEq_aux {s : Set M} {x : M} (hx : x ∈ f.source) :
    ((f.extend I).symm ⁻¹' s ∩ range I : Set _) =ᶠ[𝓝 (f.extend I x)]
      ((f.extend I).target ∩ (f.extend I).symm ⁻¹' s : Set _) 
goal: ↑(f.extend I).symm ⁻¹' s ∩ Set.range ↑I =ᶠ[𝓝 (↑(f.extend I) x)] (f.extend I).target ∩ ↑(f.extend I).symm ⁻¹' s

full_name: PartialHomeomorph.extend_symm_preimage_inter_range_eventuallyEq
code: theorem extend_symm_preimage_inter_range_eventuallyEq {s : Set M} {x : M} (hs : s ⊆ f.source)
    (hx : x ∈ f.source) :
    ((f.extend I).symm ⁻¹' s ∩ range I : Set _) =ᶠ[𝓝 (f.extend I x)] f.extend I '' s 
goal: ↑(f.extend I).symm ⁻¹' s ∩ Set.range ↑I =ᶠ[𝓝 (↑(f.extend I) x)] ↑(f.extend I) '' s

full_name: PartialHomeomorph.extend_coord_change_source
code: theorem extend_coord_change_source :
    ((f.extend I).symm ≫ f'.extend I).source = I '' (f.symm ≫ₕ f').source 
goal: ((f.extend I).symm ≫ f'.extend I).source = ↑I '' (f.symm ≫ₕ f').source

full_name: PartialHomeomorph.extend_image_source_inter
code: theorem extend_image_source_inter :
    f.extend I '' (f.source ∩ f'.source) = ((f.extend I).symm ≫ f'.extend I).source 
goal: ↑(f.extend I) '' (f.source ∩ f'.source) = ((f.extend I).symm ≫ f'.extend I).source

full_name: PartialHomeomorph.extend_coord_change_source_mem_nhdsWithin
code: theorem extend_coord_change_source_mem_nhdsWithin {x : E}
    (hx : x ∈ ((f.extend I).symm ≫ f'.extend I).source) :
    ((f.extend I).symm ≫ f'.extend I).source ∈ 𝓝[range I] x 
goal: ((f.extend I).symm ≫ f'.extend I).source ∈ 𝓝[Set.range ↑I] x

full_name: PartialHomeomorph.extend_coord_change_source_mem_nhdsWithin'
code: theorem extend_coord_change_source_mem_nhdsWithin' {x : M} (hxf : x ∈ f.source)
    (hxf' : x ∈ f'.source) :
    ((f.extend I).symm ≫ f'.extend I).source ∈ 𝓝[range I] f.extend I x 
goal: ((f.extend I).symm ≫ f'.extend I).source ∈ 𝓝[Set.range ↑I] ↑(f.extend I) x

full_name: PartialHomeomorph.contDiffOn_extend_coord_change
code: theorem contDiffOn_extend_coord_change [ChartedSpace H M] (hf : f ∈ maximalAtlas I M)
    (hf' : f' ∈ maximalAtlas I M) :
    ContDiffOn 𝕜 ⊤ (f.extend I ∘ (f'.extend I).symm) ((f'.extend I).symm ≫ f.extend I).source 
goal: ContDiffOn 𝕜 ⊤ (↑(f.extend I) ∘ ↑(f'.extend I).symm) ((f'.extend I).symm ≫ f.extend I).source

full_name: PartialHomeomorph.contDiffWithinAt_extend_coord_change
code: theorem contDiffWithinAt_extend_coord_change [ChartedSpace H M] (hf : f ∈ maximalAtlas I M)
    (hf' : f' ∈ maximalAtlas I M) {x : E} (hx : x ∈ ((f'.extend I).symm ≫ f.extend I).source) :
    ContDiffWithinAt 𝕜 ⊤ (f.extend I ∘ (f'.extend I).symm) (range I) x 
goal: ContDiffWithinAt 𝕜 ⊤ (↑(f.extend I) ∘ ↑(f'.extend I).symm) (Set.range ↑I) x

full_name: PartialHomeomorph.contDiffWithinAt_extend_coord_change'
code: theorem contDiffWithinAt_extend_coord_change' [ChartedSpace H M] (hf : f ∈ maximalAtlas I M)
    (hf' : f' ∈ maximalAtlas I M) {x : M} (hxf : x ∈ f.source) (hxf' : x ∈ f'.source) :
    ContDiffWithinAt 𝕜 ⊤ (f.extend I ∘ (f'.extend I).symm) (range I) (f'.extend I x) 
goal: ContDiffWithinAt 𝕜 ⊤ (↑(f.extend I) ∘ ↑(f'.extend I).symm) (Set.range ↑I) (↑(f'.extend I) x)

full_name: extChartAt
code: /-- The preferred extended chart on a manifold with corners around a point `x`, from a neighborhood
of `x` to the model vector space. -/
@[simp, mfld_simps]
def extChartAt (x : M) : PartialEquiv M E 
goal: PartialEquiv M E

full_name: extChartAt_coe
code: theorem extChartAt_coe (x : M) : ⇑(extChartAt I x) = I ∘ chartAt H x 
goal: ↑(extChartAt I x) = ↑I ∘ ↑(chartAt H x)

full_name: extChartAt_coe_symm
code: theorem extChartAt_coe_symm (x : M) : ⇑(extChartAt I x).symm = (chartAt H x).symm ∘ I.symm 
goal: ↑(extChartAt I x).symm = ↑(chartAt H x).symm ∘ ↑I.symm

full_name: extChartAt_source
code: theorem extChartAt_source (x : M) : (extChartAt I x).source = (chartAt H x).source 
goal: (extChartAt I x).source = (chartAt H x).source

full_name: isOpen_extChartAt_source
code: theorem isOpen_extChartAt_source (x : M) : IsOpen (extChartAt I x).source 
goal: IsOpen (extChartAt I x).source

full_name: mem_extChartAt_source
code: theorem mem_extChartAt_source (x : M) : x ∈ (extChartAt I x).source 
goal: x ∈ (extChartAt I x).source

full_name: mem_extChartAt_target
code: theorem mem_extChartAt_target (x : M) : extChartAt I x x ∈ (extChartAt I x).target 
goal: ↑(extChartAt I x) x ∈ (extChartAt I x).target

full_name: extChartAt_target
code: theorem extChartAt_target (x : M) :
    (extChartAt I x).target = I.symm ⁻¹' (chartAt H x).target ∩ range I 
goal: (extChartAt I x).target = ↑I.symm ⁻¹' (chartAt H x).target ∩ Set.range ↑I

full_name: uniqueDiffOn_extChartAt_target
code: theorem uniqueDiffOn_extChartAt_target (x : M) : UniqueDiffOn 𝕜 (extChartAt I x).target 
goal: UniqueDiffOn 𝕜 (extChartAt I x).target

full_name: uniqueDiffWithinAt_extChartAt_target
code: theorem uniqueDiffWithinAt_extChartAt_target (x : M) :
    UniqueDiffWithinAt 𝕜 (extChartAt I x).target (extChartAt I x x) 
goal: UniqueDiffWithinAt 𝕜 (extChartAt I x).target (↑(extChartAt I x) x)

full_name: extChartAt_to_inv
code: theorem extChartAt_to_inv (x : M) : (extChartAt I x).symm ((extChartAt I x) x) = x 
goal: ↑(extChartAt I x).symm (↑(extChartAt I x) x) = x

full_name: mapsTo_extChartAt
code: theorem mapsTo_extChartAt {x : M} (hs : s ⊆ (chartAt H x).source) :
    MapsTo (extChartAt I x) s ((extChartAt I x).symm ⁻¹' s ∩ range I) 
goal: Set.MapsTo (↑(extChartAt I x)) s (↑(extChartAt I x).symm ⁻¹' s ∩ Set.range ↑I)

full_name: extChartAt_source_mem_nhds'
code: theorem extChartAt_source_mem_nhds' {x x' : M} (h : x' ∈ (extChartAt I x).source) :
    (extChartAt I x).source ∈ 𝓝 x' 
goal: (extChartAt I x).source ∈ 𝓝 x'

full_name: extChartAt_source_mem_nhds
code: theorem extChartAt_source_mem_nhds (x : M) : (extChartAt I x).source ∈ 𝓝 x 
goal: (extChartAt I x).source ∈ 𝓝 x

full_name: extChartAt_source_mem_nhdsWithin'
code: theorem extChartAt_source_mem_nhdsWithin' {x x' : M} (h : x' ∈ (extChartAt I x).source) :
    (extChartAt I x).source ∈ 𝓝[s] x' 
goal: (extChartAt I x).source ∈ 𝓝[s] x'

full_name: extChartAt_source_mem_nhdsWithin
code: theorem extChartAt_source_mem_nhdsWithin (x : M) : (extChartAt I x).source ∈ 𝓝[s] x 
goal: (extChartAt I x).source ∈ 𝓝[s] x

full_name: continuousOn_extChartAt
code: theorem continuousOn_extChartAt (x : M) : ContinuousOn (extChartAt I x) (extChartAt I x).source 
goal: ContinuousOn (↑(extChartAt I x)) (extChartAt I x).source

full_name: continuousAt_extChartAt'
code: theorem continuousAt_extChartAt' {x x' : M} (h : x' ∈ (extChartAt I x).source) :
    ContinuousAt (extChartAt I x) x' 
goal: ContinuousAt (↑(extChartAt I x)) x'

full_name: continuousAt_extChartAt
code: theorem continuousAt_extChartAt (x : M) : ContinuousAt (extChartAt I x) x 
goal: ContinuousAt (↑(extChartAt I x)) x

full_name: map_extChartAt_nhds'
code: theorem map_extChartAt_nhds' {x y : M} (hy : y ∈ (extChartAt I x).source) :
    map (extChartAt I x) (𝓝 y) = 𝓝[range I] extChartAt I x y 
goal: Filter.map (↑(extChartAt I x)) (𝓝 y) = 𝓝[Set.range ↑I] ↑(extChartAt I x) y

full_name: map_extChartAt_nhds
code: theorem map_extChartAt_nhds (x : M) : map (extChartAt I x) (𝓝 x) = 𝓝[range I] extChartAt I x x 
goal: Filter.map (↑(extChartAt I x)) (𝓝 x) = 𝓝[Set.range ↑I] ↑(extChartAt I x) x

full_name: map_extChartAt_nhds_of_boundaryless
code: theorem map_extChartAt_nhds_of_boundaryless [I.Boundaryless] (x : M) :
    map (extChartAt I x) (𝓝 x) = 𝓝 (extChartAt I x x) 
goal: Filter.map (↑(extChartAt I x)) (𝓝 x) = 𝓝 (↑(extChartAt I x) x)

full_name: extChartAt_image_nhd_mem_nhds_of_boundaryless
code: theorem extChartAt_image_nhd_mem_nhds_of_boundaryless [I.Boundaryless]
    {x : M} (hx : s ∈ 𝓝 x) : extChartAt I x '' s ∈ 𝓝 (extChartAt I x x) 
goal: ↑(extChartAt I x) '' s ∈ 𝓝 (↑(extChartAt I x) x)

full_name: extChartAt_target_mem_nhdsWithin'
code: theorem extChartAt_target_mem_nhdsWithin' {x y : M} (hy : y ∈ (extChartAt I x).source) :
    (extChartAt I x).target ∈ 𝓝[range I] extChartAt I x y 
goal: (extChartAt I x).target ∈ 𝓝[Set.range ↑I] ↑(extChartAt I x) y

full_name: extChartAt_target_mem_nhdsWithin
code: theorem extChartAt_target_mem_nhdsWithin (x : M) :
    (extChartAt I x).target ∈ 𝓝[range I] extChartAt I x x 
goal: (extChartAt I x).target ∈ 𝓝[Set.range ↑I] ↑(extChartAt I x) x

full_name: isOpen_extChartAt_target
code: /-- If we're boundaryless, `extChartAt` has open target -/
theorem isOpen_extChartAt_target [I.Boundaryless] (x : M) : IsOpen (extChartAt I x).target 
goal: IsOpen (extChartAt I x).target

full_name: extChartAt_target_mem_nhds
code: /-- If we're boundaryless, `(extChartAt I x).target` is a neighborhood of the key point -/
theorem extChartAt_target_mem_nhds [I.Boundaryless] (x : M) :
    (extChartAt I x).target ∈ 𝓝 (extChartAt I x x) 
goal: (extChartAt I x).target ∈ 𝓝 (↑(extChartAt I x) x)

full_name: extChartAt_target_mem_nhds'
code: /-- If we're boundaryless, `(extChartAt I x).target` is a neighborhood of any of its points -/
theorem extChartAt_target_mem_nhds' [I.Boundaryless] {x : M} {y : E}
    (m : y ∈ (extChartAt I x).target) : (extChartAt I x).target ∈ 𝓝 y 
goal: (extChartAt I x).target ∈ 𝓝 y

full_name: extChartAt_target_subset_range
code: theorem extChartAt_target_subset_range (x : M) : (extChartAt I x).target ⊆ range I 
goal: (extChartAt I x).target ⊆ Set.range ↑I

full_name: nhdsWithin_extChartAt_target_eq'
code: theorem nhdsWithin_extChartAt_target_eq' {x y : M} (hy : y ∈ (extChartAt I x).source) :
    𝓝[(extChartAt I x).target] extChartAt I x y = 𝓝[range I] extChartAt I x y 
goal: 𝓝[(extChartAt I x).target] ↑(extChartAt I x) y = 𝓝[Set.range ↑I] ↑(extChartAt I x) y

full_name: nhdsWithin_extChartAt_target_eq
code: theorem nhdsWithin_extChartAt_target_eq (x : M) :
    𝓝[(extChartAt I x).target] (extChartAt I x) x = 𝓝[range I] (extChartAt I x) x 
goal: 𝓝[(extChartAt I x).target] ↑(extChartAt I x) x = 𝓝[Set.range ↑I] ↑(extChartAt I x) x

full_name: continuousAt_extChartAt_symm''
code: theorem continuousAt_extChartAt_symm'' {x : M} {y : E} (h : y ∈ (extChartAt I x).target) :
    ContinuousAt (extChartAt I x).symm y 
goal: ContinuousAt (↑(extChartAt I x).symm) y

full_name: continuousAt_extChartAt_symm'
code: theorem continuousAt_extChartAt_symm' {x x' : M} (h : x' ∈ (extChartAt I x).source) :
    ContinuousAt (extChartAt I x).symm (extChartAt I x x') 
goal: ContinuousAt (↑(extChartAt I x).symm) (↑(extChartAt I x) x')

full_name: continuousAt_extChartAt_symm
code: theorem continuousAt_extChartAt_symm (x : M) :
    ContinuousAt (extChartAt I x).symm ((extChartAt I x) x) 
goal: ContinuousAt (↑(extChartAt I x).symm) (↑(extChartAt I x) x)

full_name: continuousOn_extChartAt_symm
code: theorem continuousOn_extChartAt_symm (x : M) :
    ContinuousOn (extChartAt I x).symm (extChartAt I x).target 
goal: ContinuousOn (↑(extChartAt I x).symm) (extChartAt I x).target

full_name: isOpen_extChartAt_preimage'
code: theorem isOpen_extChartAt_preimage' (x : M) {s : Set E} (hs : IsOpen s) :
    IsOpen ((extChartAt I x).source ∩ extChartAt I x ⁻¹' s) 
goal: IsOpen ((extChartAt I x).source ∩ ↑(extChartAt I x) ⁻¹' s)

full_name: isOpen_extChartAt_preimage
code: theorem isOpen_extChartAt_preimage (x : M) {s : Set E} (hs : IsOpen s) :
    IsOpen ((chartAt H x).source ∩ extChartAt I x ⁻¹' s) 
goal: IsOpen ((chartAt H x).source ∩ ↑(extChartAt I x) ⁻¹' s)

full_name: map_extChartAt_nhdsWithin_eq_image'
code: theorem map_extChartAt_nhdsWithin_eq_image' {x y : M} (hy : y ∈ (extChartAt I x).source) :
    map (extChartAt I x) (𝓝[s] y) =
      𝓝[extChartAt I x '' ((extChartAt I x).source ∩ s)] extChartAt I x y 
goal: Filter.map (↑(extChartAt I x)) (𝓝[s] y) = 𝓝[↑(extChartAt I x) '' ((extChartAt I x).source ∩ s)] ↑(extChartAt I x) y

full_name: map_extChartAt_nhdsWithin_eq_image
code: theorem map_extChartAt_nhdsWithin_eq_image (x : M) :
    map (extChartAt I x) (𝓝[s] x) =
      𝓝[extChartAt I x '' ((extChartAt I x).source ∩ s)] extChartAt I x x 
goal: Filter.map (↑(extChartAt I x)) (𝓝[s] x) = 𝓝[↑(extChartAt I x) '' ((extChartAt I x).source ∩ s)] ↑(extChartAt I x) x

full_name: map_extChartAt_nhdsWithin'
code: theorem map_extChartAt_nhdsWithin' {x y : M} (hy : y ∈ (extChartAt I x).source) :
    map (extChartAt I x) (𝓝[s] y) = 𝓝[(extChartAt I x).symm ⁻¹' s ∩ range I] extChartAt I x y 
goal: Filter.map (↑(extChartAt I x)) (𝓝[s] y) = 𝓝[↑(extChartAt I x).symm ⁻¹' s ∩ Set.range ↑I] ↑(extChartAt I x) y

full_name: map_extChartAt_nhdsWithin
code: theorem map_extChartAt_nhdsWithin (x : M) :
    map (extChartAt I x) (𝓝[s] x) = 𝓝[(extChartAt I x).symm ⁻¹' s ∩ range I] extChartAt I x x 
goal: Filter.map (↑(extChartAt I x)) (𝓝[s] x) = 𝓝[↑(extChartAt I x).symm ⁻¹' s ∩ Set.range ↑I] ↑(extChartAt I x) x

full_name: map_extChartAt_symm_nhdsWithin'
code: theorem map_extChartAt_symm_nhdsWithin' {x y : M} (hy : y ∈ (extChartAt I x).source) :
    map (extChartAt I x).symm (𝓝[(extChartAt I x).symm ⁻¹' s ∩ range I] extChartAt I x y) =
      𝓝[s] y 
goal: Filter.map (↑(extChartAt I x).symm) (𝓝[↑(extChartAt I x).symm ⁻¹' s ∩ Set.range ↑I] ↑(extChartAt I x) y) = 𝓝[s] y

full_name: map_extChartAt_symm_nhdsWithin_range'
code: theorem map_extChartAt_symm_nhdsWithin_range' {x y : M} (hy : y ∈ (extChartAt I x).source) :
    map (extChartAt I x).symm (𝓝[range I] extChartAt I x y) = 𝓝 y 
goal: Filter.map (↑(extChartAt I x).symm) (𝓝[Set.range ↑I] ↑(extChartAt I x) y) = 𝓝 y

full_name: map_extChartAt_symm_nhdsWithin
code: theorem map_extChartAt_symm_nhdsWithin (x : M) :
    map (extChartAt I x).symm (𝓝[(extChartAt I x).symm ⁻¹' s ∩ range I] extChartAt I x x) =
      𝓝[s] x 
goal: Filter.map (↑(extChartAt I x).symm) (𝓝[↑(extChartAt I x).symm ⁻¹' s ∩ Set.range ↑I] ↑(extChartAt I x) x) = 𝓝[s] x

full_name: map_extChartAt_symm_nhdsWithin_range
code: theorem map_extChartAt_symm_nhdsWithin_range (x : M) :
    map (extChartAt I x).symm (𝓝[range I] extChartAt I x x) = 𝓝 x 
goal: Filter.map (↑(extChartAt I x).symm) (𝓝[Set.range ↑I] ↑(extChartAt I x) x) = 𝓝 x

full_name: extChartAt_preimage_mem_nhdsWithin'
code: /-- Technical lemma ensuring that the preimage under an extended chart of a neighborhood of a point
in the source is a neighborhood of the preimage, within a set. -/
theorem extChartAt_preimage_mem_nhdsWithin' {x x' : M} (h : x' ∈ (extChartAt I x).source)
    (ht : t ∈ 𝓝[s] x') :
    (extChartAt I x).symm ⁻¹' t ∈ 𝓝[(extChartAt I x).symm ⁻¹' s ∩ range I] (extChartAt I x) x' 
goal: ↑(extChartAt I x).symm ⁻¹' t ∈ 𝓝[↑(extChartAt I x).symm ⁻¹' s ∩ Set.range ↑I] ↑(extChartAt I x) x'

full_name: extChartAt_preimage_mem_nhdsWithin
code: /-- Technical lemma ensuring that the preimage under an extended chart of a neighborhood of the
base point is a neighborhood of the preimage, within a set. -/
theorem extChartAt_preimage_mem_nhdsWithin {x : M} (ht : t ∈ 𝓝[s] x) :
    (extChartAt I x).symm ⁻¹' t ∈ 𝓝[(extChartAt I x).symm ⁻¹' s ∩ range I] (extChartAt I x) x 
goal: ↑(extChartAt I x).symm ⁻¹' t ∈ 𝓝[↑(extChartAt I x).symm ⁻¹' s ∩ Set.range ↑I] ↑(extChartAt I x) x

full_name: extChartAt_preimage_mem_nhds'
code: theorem extChartAt_preimage_mem_nhds' {x x' : M} (h : x' ∈ (extChartAt I x).source)
    (ht : t ∈ 𝓝 x') : (extChartAt I x).symm ⁻¹' t ∈ 𝓝 (extChartAt I x x') 
goal: ↑(extChartAt I x).symm ⁻¹' t ∈ 𝓝 (↑(extChartAt I x) x')

full_name: extChartAt_preimage_mem_nhds
code: /-- Technical lemma ensuring that the preimage under an extended chart of a neighborhood of a point
is a neighborhood of the preimage. -/
theorem extChartAt_preimage_mem_nhds {x : M} (ht : t ∈ 𝓝 x) :
    (extChartAt I x).symm ⁻¹' t ∈ 𝓝 ((extChartAt I x) x) 
goal: ↑(extChartAt I x).symm ⁻¹' t ∈ 𝓝 (↑(extChartAt I x) x)

full_name: extChartAt_preimage_inter_eq
code: /-- Technical lemma to rewrite suitably the preimage of an intersection under an extended chart, to
bring it into a convenient form to apply derivative lemmas. -/
theorem extChartAt_preimage_inter_eq (x : M) :
    (extChartAt I x).symm ⁻¹' (s ∩ t) ∩ range I =
      (extChartAt I x).symm ⁻¹' s ∩ range I ∩ (extChartAt I x).symm ⁻¹' t 
goal: ↑(extChartAt I x).symm ⁻¹' (s ∩ t) ∩ Set.range ↑I =
  ↑(extChartAt I x).symm ⁻¹' s ∩ Set.range ↑I ∩ ↑(extChartAt I x).symm ⁻¹' t

full_name: ContinuousWithinAt.nhdsWithin_extChartAt_symm_preimage_inter_range
code: theorem ContinuousWithinAt.nhdsWithin_extChartAt_symm_preimage_inter_range
    {f : M → M'} {x : M} (hc : ContinuousWithinAt f s x) :
    𝓝[(extChartAt I x).symm ⁻¹' s ∩ range I] (extChartAt I x x) =
      𝓝[(extChartAt I x).target ∩
        (extChartAt I x).symm ⁻¹' (s ∩ f ⁻¹' (extChartAt I' (f x)).source)] (extChartAt I x x) 
goal: 𝓝[↑(extChartAt I x).symm ⁻¹' s ∩ Set.range ↑I] ↑(extChartAt I x) x =
  𝓝[(extChartAt I x).target ∩ ↑(extChartAt I x).symm ⁻¹' (s ∩ f ⁻¹' (extChartAt I' (f x)).source)] ↑(extChartAt I x) x

full_name: ext_coord_change_source
code: theorem ext_coord_change_source (x x' : M) :
    ((extChartAt I x').symm ≫ extChartAt I x).source =
      I '' ((chartAt H x').symm ≫ₕ chartAt H x).source 
goal: ((extChartAt I x').symm ≫ extChartAt I x).source = ↑I '' ((chartAt H x').symm ≫ₕ chartAt H x).source

full_name: contDiffOn_ext_coord_change
code: theorem contDiffOn_ext_coord_change [SmoothManifoldWithCorners I M] (x x' : M) :
    ContDiffOn 𝕜 ⊤ (extChartAt I x ∘ (extChartAt I x').symm)
      ((extChartAt I x').symm ≫ extChartAt I x).source 
goal: ContDiffOn 𝕜 ⊤ (↑(extChartAt I x) ∘ ↑(extChartAt I x').symm) ((extChartAt I x').symm ≫ extChartAt I x).source

full_name: contDiffWithinAt_ext_coord_change
code: theorem contDiffWithinAt_ext_coord_change [SmoothManifoldWithCorners I M] (x x' : M) {y : E}
    (hy : y ∈ ((extChartAt I x').symm ≫ extChartAt I x).source) :
    ContDiffWithinAt 𝕜 ⊤ (extChartAt I x ∘ (extChartAt I x').symm) (range I) y 
goal: ContDiffWithinAt 𝕜 ⊤ (↑(extChartAt I x) ∘ ↑(extChartAt I x').symm) (Set.range ↑I) y

full_name: writtenInExtChartAt
code: /-- Conjugating a function to write it in the preferred charts around `x`.
The manifold derivative of `f` will just be the derivative of this conjugated function. -/
@[simp, mfld_simps]
def writtenInExtChartAt (x : M) (f : M → M') : E → E' 
goal: E → E'

full_name: writtenInExtChartAt_chartAt
code: theorem writtenInExtChartAt_chartAt {x : M} {y : E} (h : y ∈ (extChartAt I x).target) :
    writtenInExtChartAt I I x (chartAt H x) y = y 
goal: writtenInExtChartAt I I x (↑(chartAt H x)) y = y

full_name: writtenInExtChartAt_chartAt_symm
code: theorem writtenInExtChartAt_chartAt_symm {x : M} {y : E} (h : y ∈ (extChartAt I x).target) :
    writtenInExtChartAt I I (chartAt H x x) (chartAt H x).symm y = y 
goal: writtenInExtChartAt I I (↑(chartAt H x) x) (↑(chartAt H x).symm) y = y

full_name: writtenInExtChartAt_extChartAt
code: theorem writtenInExtChartAt_extChartAt {x : M} {y : E} (h : y ∈ (extChartAt I x).target) :
    writtenInExtChartAt I 𝓘(𝕜, E) x (extChartAt I x) y = y 
goal: writtenInExtChartAt I 𝓘(𝕜, E) x (↑(extChartAt I x)) y = y

full_name: writtenInExtChartAt_extChartAt_symm
code: theorem writtenInExtChartAt_extChartAt_symm {x : M} {y : E} (h : y ∈ (extChartAt I x).target) :
    writtenInExtChartAt 𝓘(𝕜, E) I (extChartAt I x x) (extChartAt I x).symm y = y 
goal: writtenInExtChartAt 𝓘(𝕜, E) I (↑(extChartAt I x) x) (↑(extChartAt I x).symm) y = y

full_name: extChartAt_self_eq
code: theorem extChartAt_self_eq {x : H} : ⇑(extChartAt I x) = I 
goal: ↑(extChartAt I x) = ↑I

full_name: extChartAt_self_apply
code: theorem extChartAt_self_apply {x y : H} : extChartAt I x y = I y 
goal: ↑(extChartAt I x) y = ↑I y

full_name: extChartAt_model_space_eq_id
code: /-- In the case of the manifold structure on a vector space, the extended charts are just the
identity. -/
theorem extChartAt_model_space_eq_id (x : E) : extChartAt 𝓘(𝕜, E) x = PartialEquiv.refl E 
goal: extChartAt 𝓘(𝕜, E) x = PartialEquiv.refl E

full_name: ext_chart_model_space_apply
code: theorem ext_chart_model_space_apply {x y : E} : extChartAt 𝓘(𝕜, E) x y = y 
goal: ↑(extChartAt 𝓘(𝕜, E) x) y = y

full_name: extChartAt_prod
code: theorem extChartAt_prod (x : M × M') :
    extChartAt (I.prod I') x = (extChartAt I x.1).prod (extChartAt I' x.2) 
goal: extChartAt (I.prod I') x = (extChartAt I x.1).prod (extChartAt I' x.2)

full_name: extChartAt_comp
code: theorem extChartAt_comp [ChartedSpace H H'] (x : M') :
    (letI := ChartedSpace.comp H H' M'; extChartAt I x) =
      (chartAt H' x).toPartialEquiv ≫ extChartAt I (chartAt H' x x) 
goal: extChartAt I x = (chartAt H' x).toPartialEquiv ≫ extChartAt I (↑(chartAt H' x) x)

full_name: writtenInExtChartAt_chartAt_comp
code: theorem writtenInExtChartAt_chartAt_comp [ChartedSpace H H'] (x : M') {y}
    (hy : y ∈ letI := ChartedSpace.comp H H' M'; (extChartAt I x).target) :
    (letI := ChartedSpace.comp H H' M'; writtenInExtChartAt I I x (chartAt H' x) y) = y 
goal: writtenInExtChartAt I I x (↑(chartAt H' x)) y = y

full_name: writtenInExtChartAt_chartAt_symm_comp
code: theorem writtenInExtChartAt_chartAt_symm_comp [ChartedSpace H H'] (x : M') {y}
    (hy : y ∈ letI := ChartedSpace.comp H H' M'; (extChartAt I x).target) :
    ( letI := ChartedSpace.comp H H' M'
      writtenInExtChartAt I I (chartAt H' x x) (chartAt H' x).symm y) = y 
goal: writtenInExtChartAt I I (↑(chartAt H' x) x) (↑(chartAt H' x).symm) y = y

full_name: Manifold.locallyCompact_of_finiteDimensional
code: /-- A finite-dimensional manifold modelled on a locally compact field
  (such as ℝ, ℂ or the `p`-adic numbers) is locally compact. -/
lemma Manifold.locallyCompact_of_finiteDimensional [LocallyCompactSpace 𝕜]
    [FiniteDimensional 𝕜 E] : LocallyCompactSpace M 
goal: LocallyCompactSpace M