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

full_name: ContMDiffWithinAt.prod_mk
code: theorem ContMDiffWithinAt.prod_mk {f : M → M'} {g : M → N'} (hf : ContMDiffWithinAt I I' n f s x)
    (hg : ContMDiffWithinAt I J' n g s x) :
    ContMDiffWithinAt I (I'.prod J') n (fun x => (f x, g x)) s x 
goal: ContMDiffWithinAt I (I'.prod J') n (fun x => (f x, g x)) s x

full_name: ContMDiffWithinAt.prod_mk_space
code: theorem ContMDiffWithinAt.prod_mk_space {f : M → E'} {g : M → F'}
    (hf : ContMDiffWithinAt I 𝓘(𝕜, E') n f s x) (hg : ContMDiffWithinAt I 𝓘(𝕜, F') n g s x) :
    ContMDiffWithinAt I 𝓘(𝕜, E' × F') n (fun x => (f x, g x)) s x 
goal: ContMDiffWithinAt I 𝓘(𝕜, E' × F') n (fun x => (f x, g x)) s x

full_name: ContMDiffAt.prod_mk
code: nonrec theorem ContMDiffAt.prod_mk {f : M → M'} {g : M → N'} (hf : ContMDiffAt I I' n f x)
    (hg : ContMDiffAt I J' n g x) : ContMDiffAt I (I'.prod J') n (fun x => (f x, g x)) x 
goal: ContMDiffAt I (I'.prod J') n (fun x => (f x, g x)) x

full_name: ContMDiffAt.prod_mk_space
code: nonrec theorem ContMDiffAt.prod_mk_space {f : M → E'} {g : M → F'}
    (hf : ContMDiffAt I 𝓘(𝕜, E') n f x) (hg : ContMDiffAt I 𝓘(𝕜, F') n g x) :
    ContMDiffAt I 𝓘(𝕜, E' × F') n (fun x => (f x, g x)) x 
goal: ContMDiffAt I 𝓘(𝕜, E' × F') n (fun x => (f x, g x)) x

full_name: ContMDiffOn.prod_mk
code: theorem ContMDiffOn.prod_mk {f : M → M'} {g : M → N'} (hf : ContMDiffOn I I' n f s)
    (hg : ContMDiffOn I J' n g s) : ContMDiffOn I (I'.prod J') n (fun x => (f x, g x)) s 
goal: ContMDiffOn I (I'.prod J') n (fun x => (f x, g x)) s

full_name: ContMDiffOn.prod_mk_space
code: theorem ContMDiffOn.prod_mk_space {f : M → E'} {g : M → F'} (hf : ContMDiffOn I 𝓘(𝕜, E') n f s)
    (hg : ContMDiffOn I 𝓘(𝕜, F') n g s) : ContMDiffOn I 𝓘(𝕜, E' × F') n (fun x => (f x, g x)) s 
goal: ContMDiffOn I 𝓘(𝕜, E' × F') n (fun x => (f x, g x)) s

full_name: ContMDiff.prod_mk
code: nonrec theorem ContMDiff.prod_mk {f : M → M'} {g : M → N'} (hf : ContMDiff I I' n f)
    (hg : ContMDiff I J' n g) : ContMDiff I (I'.prod J') n fun x => (f x, g x) 
goal: ContMDiff I (I'.prod J') n fun x => (f x, g x)

full_name: ContMDiff.prod_mk_space
code: theorem ContMDiff.prod_mk_space {f : M → E'} {g : M → F'} (hf : ContMDiff I 𝓘(𝕜, E') n f)
    (hg : ContMDiff I 𝓘(𝕜, F') n g) : ContMDiff I 𝓘(𝕜, E' × F') n fun x => (f x, g x) 
goal: ContMDiff I 𝓘(𝕜, E' × F') n fun x => (f x, g x)

full_name: SmoothWithinAt.prod_mk
code: nonrec theorem SmoothWithinAt.prod_mk {f : M → M'} {g : M → N'} (hf : SmoothWithinAt I I' f s x)
    (hg : SmoothWithinAt I J' g s x) : SmoothWithinAt I (I'.prod J') (fun x => (f x, g x)) s x 
goal: SmoothWithinAt I (I'.prod J') (fun x => (f x, g x)) s x

full_name: SmoothWithinAt.prod_mk_space
code: nonrec theorem SmoothWithinAt.prod_mk_space {f : M → E'} {g : M → F'}
    (hf : SmoothWithinAt I 𝓘(𝕜, E') f s x) (hg : SmoothWithinAt I 𝓘(𝕜, F') g s x) :
    SmoothWithinAt I 𝓘(𝕜, E' × F') (fun x => (f x, g x)) s x 
goal: SmoothWithinAt I 𝓘(𝕜, E' × F') (fun x => (f x, g x)) s x

full_name: SmoothAt.prod_mk
code: nonrec theorem SmoothAt.prod_mk {f : M → M'} {g : M → N'} (hf : SmoothAt I I' f x)
    (hg : SmoothAt I J' g x) : SmoothAt I (I'.prod J') (fun x => (f x, g x)) x 
goal: SmoothAt I (I'.prod J') (fun x => (f x, g x)) x

full_name: SmoothAt.prod_mk_space
code: nonrec theorem SmoothAt.prod_mk_space {f : M → E'} {g : M → F'} (hf : SmoothAt I 𝓘(𝕜, E') f x)
    (hg : SmoothAt I 𝓘(𝕜, F') g x) : SmoothAt I 𝓘(𝕜, E' × F') (fun x => (f x, g x)) x 
goal: SmoothAt I 𝓘(𝕜, E' × F') (fun x => (f x, g x)) x

full_name: SmoothOn.prod_mk
code: nonrec theorem SmoothOn.prod_mk {f : M → M'} {g : M → N'} (hf : SmoothOn I I' f s)
    (hg : SmoothOn I J' g s) : SmoothOn I (I'.prod J') (fun x => (f x, g x)) s 
goal: SmoothOn I (I'.prod J') (fun x => (f x, g x)) s

full_name: SmoothOn.prod_mk_space
code: nonrec theorem SmoothOn.prod_mk_space {f : M → E'} {g : M → F'} (hf : SmoothOn I 𝓘(𝕜, E') f s)
    (hg : SmoothOn I 𝓘(𝕜, F') g s) : SmoothOn I 𝓘(𝕜, E' × F') (fun x => (f x, g x)) s 
goal: SmoothOn I 𝓘(𝕜, E' × F') (fun x => (f x, g x)) s

full_name: Smooth.prod_mk
code: nonrec theorem Smooth.prod_mk {f : M → M'} {g : M → N'} (hf : Smooth I I' f) (hg : Smooth I J' g) :
    Smooth I (I'.prod J') fun x => (f x, g x) 
goal: Smooth I (I'.prod J') fun x => (f x, g x)

full_name: Smooth.prod_mk_space
code: nonrec theorem Smooth.prod_mk_space {f : M → E'} {g : M → F'} (hf : Smooth I 𝓘(𝕜, E') f)
    (hg : Smooth I 𝓘(𝕜, F') g) : Smooth I 𝓘(𝕜, E' × F') fun x => (f x, g x) 
goal: Smooth I 𝓘(𝕜, E' × F') fun x => (f x, g x)

full_name: contMDiffWithinAt_fst
code: theorem contMDiffWithinAt_fst {s : Set (M × N)} {p : M × N} :
    ContMDiffWithinAt (I.prod J) I n Prod.fst s p 
goal: ContMDiffWithinAt (I.prod J) I n Prod.fst s p

full_name: ContMDiffWithinAt.fst
code: theorem ContMDiffWithinAt.fst {f : N → M × M'} {s : Set N} {x : N}
    (hf : ContMDiffWithinAt J (I.prod I') n f s x) :
    ContMDiffWithinAt J I n (fun x => (f x).1) s x 
goal: ContMDiffWithinAt J I n (fun x => (f x).1) s x

full_name: contMDiffAt_fst
code: theorem contMDiffAt_fst {p : M × N} : ContMDiffAt (I.prod J) I n Prod.fst p 
goal: ContMDiffAt (I.prod J) I n Prod.fst p

full_name: contMDiffOn_fst
code: theorem contMDiffOn_fst {s : Set (M × N)} : ContMDiffOn (I.prod J) I n Prod.fst s 
goal: ContMDiffOn (I.prod J) I n Prod.fst s

full_name: contMDiff_fst
code: theorem contMDiff_fst : ContMDiff (I.prod J) I n (@Prod.fst M N) 
goal: ContMDiff (I.prod J) I n Prod.fst

full_name: smoothWithinAt_fst
code: theorem smoothWithinAt_fst {s : Set (M × N)} {p : M × N} :
    SmoothWithinAt (I.prod J) I Prod.fst s p 
goal: SmoothWithinAt (I.prod J) I Prod.fst s p

full_name: smoothAt_fst
code: theorem smoothAt_fst {p : M × N} : SmoothAt (I.prod J) I Prod.fst p 
goal: SmoothAt (I.prod J) I Prod.fst p

full_name: smoothOn_fst
code: theorem smoothOn_fst {s : Set (M × N)} : SmoothOn (I.prod J) I Prod.fst s 
goal: SmoothOn (I.prod J) I Prod.fst s

full_name: smooth_fst
code: theorem smooth_fst : Smooth (I.prod J) I (@Prod.fst M N) 
goal: Smooth (I.prod J) I Prod.fst

full_name: ContMDiffAt.fst
code: theorem ContMDiffAt.fst {f : N → M × M'} {x : N} (hf : ContMDiffAt J (I.prod I') n f x) :
    ContMDiffAt J I n (fun x => (f x).1) x 
goal: ContMDiffAt J I n (fun x => (f x).1) x

full_name: ContMDiff.fst
code: theorem ContMDiff.fst {f : N → M × M'} (hf : ContMDiff J (I.prod I') n f) :
    ContMDiff J I n fun x => (f x).1 
goal: ContMDiff J I n fun x => (f x).1

full_name: SmoothAt.fst
code: theorem SmoothAt.fst {f : N → M × M'} {x : N} (hf : SmoothAt J (I.prod I') f x) :
    SmoothAt J I (fun x => (f x).1) x 
goal: SmoothAt J I (fun x => (f x).1) x

full_name: Smooth.fst
code: theorem Smooth.fst {f : N → M × M'} (hf : Smooth J (I.prod I') f) : Smooth J I fun x => (f x).1 
goal: Smooth J I fun x => (f x).1

full_name: contMDiffWithinAt_snd
code: theorem contMDiffWithinAt_snd {s : Set (M × N)} {p : M × N} :
    ContMDiffWithinAt (I.prod J) J n Prod.snd s p 
goal: ContMDiffWithinAt (I.prod J) J n Prod.snd s p

full_name: ContMDiffWithinAt.snd
code: theorem ContMDiffWithinAt.snd {f : N → M × M'} {s : Set N} {x : N}
    (hf : ContMDiffWithinAt J (I.prod I') n f s x) :
    ContMDiffWithinAt J I' n (fun x => (f x).2) s x 
goal: ContMDiffWithinAt J I' n (fun x => (f x).2) s x

full_name: contMDiffAt_snd
code: theorem contMDiffAt_snd {p : M × N} : ContMDiffAt (I.prod J) J n Prod.snd p 
goal: ContMDiffAt (I.prod J) J n Prod.snd p

full_name: contMDiffOn_snd
code: theorem contMDiffOn_snd {s : Set (M × N)} : ContMDiffOn (I.prod J) J n Prod.snd s 
goal: ContMDiffOn (I.prod J) J n Prod.snd s

full_name: contMDiff_snd
code: theorem contMDiff_snd : ContMDiff (I.prod J) J n (@Prod.snd M N) 
goal: ContMDiff (I.prod J) J n Prod.snd

full_name: smoothWithinAt_snd
code: theorem smoothWithinAt_snd {s : Set (M × N)} {p : M × N} :
    SmoothWithinAt (I.prod J) J Prod.snd s p 
goal: SmoothWithinAt (I.prod J) J Prod.snd s p

full_name: smoothAt_snd
code: theorem smoothAt_snd {p : M × N} : SmoothAt (I.prod J) J Prod.snd p 
goal: SmoothAt (I.prod J) J Prod.snd p

full_name: smoothOn_snd
code: theorem smoothOn_snd {s : Set (M × N)} : SmoothOn (I.prod J) J Prod.snd s 
goal: SmoothOn (I.prod J) J Prod.snd s

full_name: smooth_snd
code: theorem smooth_snd : Smooth (I.prod J) J (@Prod.snd M N) 
goal: Smooth (I.prod J) J Prod.snd

full_name: ContMDiffAt.snd
code: theorem ContMDiffAt.snd {f : N → M × M'} {x : N} (hf : ContMDiffAt J (I.prod I') n f x) :
    ContMDiffAt J I' n (fun x => (f x).2) x 
goal: ContMDiffAt J I' n (fun x => (f x).2) x

full_name: ContMDiff.snd
code: theorem ContMDiff.snd {f : N → M × M'} (hf : ContMDiff J (I.prod I') n f) :
    ContMDiff J I' n fun x => (f x).2 
goal: ContMDiff J I' n fun x => (f x).2

full_name: SmoothAt.snd
code: theorem SmoothAt.snd {f : N → M × M'} {x : N} (hf : SmoothAt J (I.prod I') f x) :
    SmoothAt J I' (fun x => (f x).2) x 
goal: SmoothAt J I' (fun x => (f x).2) x

full_name: Smooth.snd
code: theorem Smooth.snd {f : N → M × M'} (hf : Smooth J (I.prod I') f) : Smooth J I' fun x => (f x).2 
goal: Smooth J I' fun x => (f x).2

full_name: contMDiffWithinAt_prod_iff
code: theorem contMDiffWithinAt_prod_iff (f : M → M' × N') {s : Set M} {x : M} :
    ContMDiffWithinAt I (I'.prod J') n f s x ↔
      ContMDiffWithinAt I I' n (Prod.fst ∘ f) s x ∧ ContMDiffWithinAt I J' n (Prod.snd ∘ f) s x 
goal: ContMDiffWithinAt I (I'.prod J') n f s x ↔
  ContMDiffWithinAt I I' n (Prod.fst ∘ f) s x ∧ ContMDiffWithinAt I J' n (Prod.snd ∘ f) s x

full_name: contMDiffAt_prod_iff
code: theorem contMDiffAt_prod_iff (f : M → M' × N') {x : M} :
    ContMDiffAt I (I'.prod J') n f x ↔
      ContMDiffAt I I' n (Prod.fst ∘ f) x ∧ ContMDiffAt I J' n (Prod.snd ∘ f) x 
goal: ContMDiffAt I (I'.prod J') n f x ↔ ContMDiffAt I I' n (Prod.fst ∘ f) x ∧ ContMDiffAt I J' n (Prod.snd ∘ f) x

full_name: contMDiff_prod_iff
code: theorem contMDiff_prod_iff (f : M → M' × N') :
    ContMDiff I (I'.prod J') n f ↔
      ContMDiff I I' n (Prod.fst ∘ f) ∧ ContMDiff I J' n (Prod.snd ∘ f) 
goal: ContMDiff I (I'.prod J') n f ↔ ContMDiff I I' n (Prod.fst ∘ f) ∧ ContMDiff I J' n (Prod.snd ∘ f)

full_name: smoothAt_prod_iff
code: theorem smoothAt_prod_iff (f : M → M' × N') {x : M} :
    SmoothAt I (I'.prod J') f x ↔ SmoothAt I I' (Prod.fst ∘ f) x ∧ SmoothAt I J' (Prod.snd ∘ f) x 
goal: SmoothAt I (I'.prod J') f x ↔ SmoothAt I I' (Prod.fst ∘ f) x ∧ SmoothAt I J' (Prod.snd ∘ f) x

full_name: smooth_prod_iff
code: theorem smooth_prod_iff (f : M → M' × N') :
    Smooth I (I'.prod J') f ↔ Smooth I I' (Prod.fst ∘ f) ∧ Smooth I J' (Prod.snd ∘ f) 
goal: Smooth I (I'.prod J') f ↔ Smooth I I' (Prod.fst ∘ f) ∧ Smooth I J' (Prod.snd ∘ f)

full_name: smooth_prod_assoc
code: theorem smooth_prod_assoc :
    Smooth ((I.prod I').prod J) (I.prod (I'.prod J)) fun x : (M × M') × N => (x.1.1, x.1.2, x.2) 
goal: Smooth ((I.prod I').prod J) (I.prod (I'.prod J)) fun x => (x.1.1, x.1.2, x.2)

full_name: ContMDiffWithinAt.prod_map'
code: /-- The product map of two `C^n` functions within a set at a point is `C^n`
within the product set at the product point. -/
theorem ContMDiffWithinAt.prod_map' {p : M × N} (hf : ContMDiffWithinAt I I' n f s p.1)
    (hg : ContMDiffWithinAt J J' n g r p.2) :
    ContMDiffWithinAt (I.prod J) (I'.prod J') n (Prod.map f g) (s ×ˢ r) p 
goal: ContMDiffWithinAt (I.prod J) (I'.prod J') n (Prod.map f g) (s ×ˢ r) p

full_name: ContMDiffWithinAt.prod_map
code: theorem ContMDiffWithinAt.prod_map (hf : ContMDiffWithinAt I I' n f s x)
    (hg : ContMDiffWithinAt J J' n g r y) :
    ContMDiffWithinAt (I.prod J) (I'.prod J') n (Prod.map f g) (s ×ˢ r) (x, y) 
goal: ContMDiffWithinAt (I.prod J) (I'.prod J') n (Prod.map f g) (s ×ˢ r) (x, y)

full_name: ContMDiffAt.prod_map
code: theorem ContMDiffAt.prod_map (hf : ContMDiffAt I I' n f x) (hg : ContMDiffAt J J' n g y) :
    ContMDiffAt (I.prod J) (I'.prod J') n (Prod.map f g) (x, y) 
goal: ContMDiffAt (I.prod J) (I'.prod J') n (Prod.map f g) (x, y)

full_name: ContMDiffAt.prod_map'
code: theorem ContMDiffAt.prod_map' {p : M × N} (hf : ContMDiffAt I I' n f p.1)
    (hg : ContMDiffAt J J' n g p.2) : ContMDiffAt (I.prod J) (I'.prod J') n (Prod.map f g) p 
goal: ContMDiffAt (I.prod J) (I'.prod J') n (Prod.map f g) p

full_name: ContMDiffOn.prod_map
code: theorem ContMDiffOn.prod_map (hf : ContMDiffOn I I' n f s) (hg : ContMDiffOn J J' n g r) :
    ContMDiffOn (I.prod J) (I'.prod J') n (Prod.map f g) (s ×ˢ r) 
goal: ContMDiffOn (I.prod J) (I'.prod J') n (Prod.map f g) (s ×ˢ r)

full_name: ContMDiff.prod_map
code: theorem ContMDiff.prod_map (hf : ContMDiff I I' n f) (hg : ContMDiff J J' n g) :
    ContMDiff (I.prod J) (I'.prod J') n (Prod.map f g) 
goal: ContMDiff (I.prod J) (I'.prod J') n (Prod.map f g)

full_name: SmoothWithinAt.prod_map
code: nonrec theorem SmoothWithinAt.prod_map (hf : SmoothWithinAt I I' f s x)
    (hg : SmoothWithinAt J J' g r y) :
    SmoothWithinAt (I.prod J) (I'.prod J') (Prod.map f g) (s ×ˢ r) (x, y) 
goal: SmoothWithinAt (I.prod J) (I'.prod J') (Prod.map f g) (s ×ˢ r) (x, y)

full_name: SmoothAt.prod_map
code: nonrec theorem SmoothAt.prod_map (hf : SmoothAt I I' f x) (hg : SmoothAt J J' g y) :
    SmoothAt (I.prod J) (I'.prod J') (Prod.map f g) (x, y) 
goal: SmoothAt (I.prod J) (I'.prod J') (Prod.map f g) (x, y)

full_name: SmoothOn.prod_map
code: nonrec theorem SmoothOn.prod_map (hf : SmoothOn I I' f s) (hg : SmoothOn J J' g r) :
    SmoothOn (I.prod J) (I'.prod J') (Prod.map f g) (s ×ˢ r) 
goal: SmoothOn (I.prod J) (I'.prod J') (Prod.map f g) (s ×ˢ r)

full_name: Smooth.prod_map
code: nonrec theorem Smooth.prod_map (hf : Smooth I I' f) (hg : Smooth J J' g) :
    Smooth (I.prod J) (I'.prod J') (Prod.map f g) 
goal: Smooth (I.prod J) (I'.prod J') (Prod.map f g)

full_name: contMDiffWithinAt_pi_space
code: theorem contMDiffWithinAt_pi_space :
    ContMDiffWithinAt I 𝓘(𝕜, ∀ i, Fi i) n φ s x ↔
      ∀ i, ContMDiffWithinAt I 𝓘(𝕜, Fi i) n (fun x => φ x i) s x 
goal: ContMDiffWithinAt I 𝓘(𝕜, (i : ι) → Fi i) n φ s x ↔ ∀ (i : ι), ContMDiffWithinAt I 𝓘(𝕜, Fi i) n (fun x => φ x i) s x

full_name: contMDiffOn_pi_space
code: theorem contMDiffOn_pi_space :
    ContMDiffOn I 𝓘(𝕜, ∀ i, Fi i) n φ s ↔ ∀ i, ContMDiffOn I 𝓘(𝕜, Fi i) n (fun x => φ x i) s 
goal: ContMDiffOn I 𝓘(𝕜, (i : ι) → Fi i) n φ s ↔ ∀ (i : ι), ContMDiffOn I 𝓘(𝕜, Fi i) n (fun x => φ x i) s

full_name: contMDiffAt_pi_space
code: theorem contMDiffAt_pi_space :
    ContMDiffAt I 𝓘(𝕜, ∀ i, Fi i) n φ x ↔ ∀ i, ContMDiffAt I 𝓘(𝕜, Fi i) n (fun x => φ x i) x 
goal: ContMDiffAt I 𝓘(𝕜, (i : ι) → Fi i) n φ x ↔ ∀ (i : ι), ContMDiffAt I 𝓘(𝕜, Fi i) n (fun x => φ x i) x

full_name: contMDiff_pi_space
code: theorem contMDiff_pi_space :
    ContMDiff I 𝓘(𝕜, ∀ i, Fi i) n φ ↔ ∀ i, ContMDiff I 𝓘(𝕜, Fi i) n fun x => φ x i 
goal: ContMDiff I 𝓘(𝕜, (i : ι) → Fi i) n φ ↔ ∀ (i : ι), ContMDiff I 𝓘(𝕜, Fi i) n fun x => φ x i

full_name: smoothWithinAt_pi_space
code: theorem smoothWithinAt_pi_space :
    SmoothWithinAt I 𝓘(𝕜, ∀ i, Fi i) φ s x ↔
      ∀ i, SmoothWithinAt I 𝓘(𝕜, Fi i) (fun x => φ x i) s x 
goal: SmoothWithinAt I 𝓘(𝕜, (i : ι) → Fi i) φ s x ↔ ∀ (i : ι), SmoothWithinAt I 𝓘(𝕜, Fi i) (fun x => φ x i) s x

full_name: smoothOn_pi_space
code: theorem smoothOn_pi_space :
    SmoothOn I 𝓘(𝕜, ∀ i, Fi i) φ s ↔ ∀ i, SmoothOn I 𝓘(𝕜, Fi i) (fun x => φ x i) s 
goal: SmoothOn I 𝓘(𝕜, (i : ι) → Fi i) φ s ↔ ∀ (i : ι), SmoothOn I 𝓘(𝕜, Fi i) (fun x => φ x i) s

full_name: smoothAt_pi_space
code: theorem smoothAt_pi_space :
    SmoothAt I 𝓘(𝕜, ∀ i, Fi i) φ x ↔ ∀ i, SmoothAt I 𝓘(𝕜, Fi i) (fun x => φ x i) x 
goal: SmoothAt I 𝓘(𝕜, (i : ι) → Fi i) φ x ↔ ∀ (i : ι), SmoothAt I 𝓘(𝕜, Fi i) (fun x => φ x i) x

full_name: smooth_pi_space
code: theorem smooth_pi_space : Smooth I 𝓘(𝕜, ∀ i, Fi i) φ ↔ ∀ i, Smooth I 𝓘(𝕜, Fi i) fun x => φ x i 
goal: Smooth I 𝓘(𝕜, (i : ι) → Fi i) φ ↔ ∀ (i : ι), Smooth I 𝓘(𝕜, Fi i) fun x => φ x i