File: Mathlib/Analysis/Calculus/FDeriv/Prod.lean

full_name: HasStrictFDerivAt.prod
code: protected theorem HasStrictFDerivAt.prod (hf₁ : HasStrictFDerivAt f₁ f₁' x)
    (hf₂ : HasStrictFDerivAt f₂ f₂' x) :
    HasStrictFDerivAt (fun x => (f₁ x, f₂ x)) (f₁'.prod f₂') x 
goal: HasStrictFDerivAt (fun x => (f₁ x, f₂ x)) (f₁'.prod f₂') x

full_name: HasFDerivAtFilter.prod
code: theorem HasFDerivAtFilter.prod (hf₁ : HasFDerivAtFilter f₁ f₁' x L)
    (hf₂ : HasFDerivAtFilter f₂ f₂' x L) :
    HasFDerivAtFilter (fun x => (f₁ x, f₂ x)) (f₁'.prod f₂') x L 
goal: HasFDerivAtFilter (fun x => (f₁ x, f₂ x)) (f₁'.prod f₂') x L

full_name: HasFDerivWithinAt.prod
code: @[fun_prop]
nonrec theorem HasFDerivWithinAt.prod (hf₁ : HasFDerivWithinAt f₁ f₁' s x)
    (hf₂ : HasFDerivWithinAt f₂ f₂' s x) :
    HasFDerivWithinAt (fun x => (f₁ x, f₂ x)) (f₁'.prod f₂') s x 
goal: HasFDerivWithinAt (fun x => (f₁ x, f₂ x)) (f₁'.prod f₂') s x

full_name: HasFDerivAt.prod
code: @[fun_prop]
nonrec theorem HasFDerivAt.prod (hf₁ : HasFDerivAt f₁ f₁' x) (hf₂ : HasFDerivAt f₂ f₂' x) :
    HasFDerivAt (fun x => (f₁ x, f₂ x)) (f₁'.prod f₂') x 
goal: HasFDerivAt (fun x => (f₁ x, f₂ x)) (f₁'.prod f₂') x

full_name: hasFDerivAt_prod_mk_left
code: @[fun_prop]
theorem hasFDerivAt_prod_mk_left (e₀ : E) (f₀ : F) :
    HasFDerivAt (fun e : E => (e, f₀)) (inl 𝕜 E F) e₀ 
goal: HasFDerivAt (fun e => (e, f₀)) (ContinuousLinearMap.inl 𝕜 E F) e₀

full_name: hasFDerivAt_prod_mk_right
code: @[fun_prop]
theorem hasFDerivAt_prod_mk_right (e₀ : E) (f₀ : F) :
    HasFDerivAt (fun f : F => (e₀, f)) (inr 𝕜 E F) f₀ 
goal: HasFDerivAt (fun f => (e₀, f)) (ContinuousLinearMap.inr 𝕜 E F) f₀

full_name: DifferentiableWithinAt.prod
code: @[fun_prop]
theorem DifferentiableWithinAt.prod (hf₁ : DifferentiableWithinAt 𝕜 f₁ s x)
    (hf₂ : DifferentiableWithinAt 𝕜 f₂ s x) :
    DifferentiableWithinAt 𝕜 (fun x : E => (f₁ x, f₂ x)) s x 
goal: DifferentiableWithinAt 𝕜 (fun x => (f₁ x, f₂ x)) s x

full_name: DifferentiableAt.prod
code: @[simp, fun_prop]
theorem DifferentiableAt.prod (hf₁ : DifferentiableAt 𝕜 f₁ x) (hf₂ : DifferentiableAt 𝕜 f₂ x) :
    DifferentiableAt 𝕜 (fun x : E => (f₁ x, f₂ x)) x 
goal: DifferentiableAt 𝕜 (fun x => (f₁ x, f₂ x)) x

full_name: DifferentiableOn.prod
code: @[fun_prop]
theorem DifferentiableOn.prod (hf₁ : DifferentiableOn 𝕜 f₁ s) (hf₂ : DifferentiableOn 𝕜 f₂ s) :
    DifferentiableOn 𝕜 (fun x : E => (f₁ x, f₂ x)) s 
goal: DifferentiableOn 𝕜 (fun x => (f₁ x, f₂ x)) s

full_name: Differentiable.prod
code: @[simp, fun_prop]
theorem Differentiable.prod (hf₁ : Differentiable 𝕜 f₁) (hf₂ : Differentiable 𝕜 f₂) :
    Differentiable 𝕜 fun x : E => (f₁ x, f₂ x) 
goal: Differentiable 𝕜 fun x => (f₁ x, f₂ x)

full_name: DifferentiableAt.fderiv_prod
code: theorem DifferentiableAt.fderiv_prod (hf₁ : DifferentiableAt 𝕜 f₁ x)
    (hf₂ : DifferentiableAt 𝕜 f₂ x) :
    fderiv 𝕜 (fun x : E => (f₁ x, f₂ x)) x = (fderiv 𝕜 f₁ x).prod (fderiv 𝕜 f₂ x) 
goal: fderiv 𝕜 (fun x => (f₁ x, f₂ x)) x = (fderiv 𝕜 f₁ x).prod (fderiv 𝕜 f₂ x)

full_name: DifferentiableWithinAt.fderivWithin_prod
code: theorem DifferentiableWithinAt.fderivWithin_prod (hf₁ : DifferentiableWithinAt 𝕜 f₁ s x)
    (hf₂ : DifferentiableWithinAt 𝕜 f₂ s x) (hxs : UniqueDiffWithinAt 𝕜 s x) :
    fderivWithin 𝕜 (fun x : E => (f₁ x, f₂ x)) s x =
      (fderivWithin 𝕜 f₁ s x).prod (fderivWithin 𝕜 f₂ s x) 
goal: fderivWithin 𝕜 (fun x => (f₁ x, f₂ x)) s x = (fderivWithin 𝕜 f₁ s x).prod (fderivWithin 𝕜 f₂ s x)

full_name: hasStrictFDerivAt_fst
code: @[fun_prop]
theorem hasStrictFDerivAt_fst : HasStrictFDerivAt (@Prod.fst E F) (fst 𝕜 E F) p 
goal: HasStrictFDerivAt Prod.fst (ContinuousLinearMap.fst 𝕜 E F) p

full_name: HasStrictFDerivAt.fst
code: @[fun_prop]
protected theorem HasStrictFDerivAt.fst (h : HasStrictFDerivAt f₂ f₂' x) :
    HasStrictFDerivAt (fun x => (f₂ x).1) ((fst 𝕜 F G).comp f₂') x 
goal: HasStrictFDerivAt (fun x => (f₂ x).1) ((ContinuousLinearMap.fst 𝕜 F G).comp f₂') x

full_name: hasFDerivAtFilter_fst
code: theorem hasFDerivAtFilter_fst {L : Filter (E × F)} :
    HasFDerivAtFilter (@Prod.fst E F) (fst 𝕜 E F) p L 
goal: HasFDerivAtFilter Prod.fst (ContinuousLinearMap.fst 𝕜 E F) p L

full_name: HasFDerivAtFilter.fst
code: protected theorem HasFDerivAtFilter.fst (h : HasFDerivAtFilter f₂ f₂' x L) :
    HasFDerivAtFilter (fun x => (f₂ x).1) ((fst 𝕜 F G).comp f₂') x L 
goal: HasFDerivAtFilter (fun x => (f₂ x).1) ((ContinuousLinearMap.fst 𝕜 F G).comp f₂') x L

full_name: hasFDerivAt_fst
code: @[fun_prop]
theorem hasFDerivAt_fst : HasFDerivAt (@Prod.fst E F) (fst 𝕜 E F) p 
goal: HasFDerivAt Prod.fst (ContinuousLinearMap.fst 𝕜 E F) p

full_name: HasFDerivAt.fst
code: @[fun_prop]
protected nonrec theorem HasFDerivAt.fst (h : HasFDerivAt f₂ f₂' x) :
    HasFDerivAt (fun x => (f₂ x).1) ((fst 𝕜 F G).comp f₂') x 
goal: HasFDerivAt (fun x => (f₂ x).1) ((ContinuousLinearMap.fst 𝕜 F G).comp f₂') x

full_name: hasFDerivWithinAt_fst
code: @[fun_prop]
theorem hasFDerivWithinAt_fst {s : Set (E × F)} :
    HasFDerivWithinAt (@Prod.fst E F) (fst 𝕜 E F) s p 
goal: HasFDerivWithinAt Prod.fst (ContinuousLinearMap.fst 𝕜 E F) s p

full_name: HasFDerivWithinAt.fst
code: @[fun_prop]
protected nonrec theorem HasFDerivWithinAt.fst (h : HasFDerivWithinAt f₂ f₂' s x) :
    HasFDerivWithinAt (fun x => (f₂ x).1) ((fst 𝕜 F G).comp f₂') s x 
goal: HasFDerivWithinAt (fun x => (f₂ x).1) ((ContinuousLinearMap.fst 𝕜 F G).comp f₂') s x

full_name: differentiableAt_fst
code: @[fun_prop]
theorem differentiableAt_fst : DifferentiableAt 𝕜 Prod.fst p 
goal: DifferentiableAt 𝕜 Prod.fst p

full_name: DifferentiableAt.fst
code: @[simp, fun_prop]
protected theorem DifferentiableAt.fst (h : DifferentiableAt 𝕜 f₂ x) :
    DifferentiableAt 𝕜 (fun x => (f₂ x).1) x 
goal: DifferentiableAt 𝕜 (fun x => (f₂ x).1) x

full_name: differentiable_fst
code: @[fun_prop]
theorem differentiable_fst : Differentiable 𝕜 (Prod.fst : E × F → E) 
goal: Differentiable 𝕜 Prod.fst

full_name: Differentiable.fst
code: @[simp, fun_prop]
protected theorem Differentiable.fst (h : Differentiable 𝕜 f₂) :
    Differentiable 𝕜 fun x => (f₂ x).1 
goal: Differentiable 𝕜 fun x => (f₂ x).1

full_name: differentiableWithinAt_fst
code: @[fun_prop]
theorem differentiableWithinAt_fst {s : Set (E × F)} : DifferentiableWithinAt 𝕜 Prod.fst s p 
goal: DifferentiableWithinAt 𝕜 Prod.fst s p

full_name: DifferentiableWithinAt.fst
code: @[fun_prop]
protected theorem DifferentiableWithinAt.fst (h : DifferentiableWithinAt 𝕜 f₂ s x) :
    DifferentiableWithinAt 𝕜 (fun x => (f₂ x).1) s x 
goal: DifferentiableWithinAt 𝕜 (fun x => (f₂ x).1) s x

full_name: differentiableOn_fst
code: @[fun_prop]
theorem differentiableOn_fst {s : Set (E × F)} : DifferentiableOn 𝕜 Prod.fst s 
goal: DifferentiableOn 𝕜 Prod.fst s

full_name: DifferentiableOn.fst
code: @[fun_prop]
protected theorem DifferentiableOn.fst (h : DifferentiableOn 𝕜 f₂ s) :
    DifferentiableOn 𝕜 (fun x => (f₂ x).1) s 
goal: DifferentiableOn 𝕜 (fun x => (f₂ x).1) s

full_name: fderiv_fst
code: theorem fderiv_fst : fderiv 𝕜 Prod.fst p = fst 𝕜 E F 
goal: fderiv 𝕜 Prod.fst p = ContinuousLinearMap.fst 𝕜 E F

full_name: fderiv.fst
code: theorem fderiv.fst (h : DifferentiableAt 𝕜 f₂ x) :
    fderiv 𝕜 (fun x => (f₂ x).1) x = (fst 𝕜 F G).comp (fderiv 𝕜 f₂ x) 
goal: fderiv 𝕜 (fun x => (f₂ x).1) x = (ContinuousLinearMap.fst 𝕜 F G).comp (fderiv 𝕜 f₂ x)

full_name: fderivWithin_fst
code: theorem fderivWithin_fst {s : Set (E × F)} (hs : UniqueDiffWithinAt 𝕜 s p) :
    fderivWithin 𝕜 Prod.fst s p = fst 𝕜 E F 
goal: fderivWithin 𝕜 Prod.fst s p = ContinuousLinearMap.fst 𝕜 E F

full_name: fderivWithin.fst
code: theorem fderivWithin.fst (hs : UniqueDiffWithinAt 𝕜 s x) (h : DifferentiableWithinAt 𝕜 f₂ s x) :
    fderivWithin 𝕜 (fun x => (f₂ x).1) s x = (fst 𝕜 F G).comp (fderivWithin 𝕜 f₂ s x) 
goal: fderivWithin 𝕜 (fun x => (f₂ x).1) s x = (ContinuousLinearMap.fst 𝕜 F G).comp (fderivWithin 𝕜 f₂ s x)

full_name: hasStrictFDerivAt_snd
code: @[fun_prop]
theorem hasStrictFDerivAt_snd : HasStrictFDerivAt (@Prod.snd E F) (snd 𝕜 E F) p 
goal: HasStrictFDerivAt Prod.snd (ContinuousLinearMap.snd 𝕜 E F) p

full_name: HasStrictFDerivAt.snd
code: @[fun_prop]
protected theorem HasStrictFDerivAt.snd (h : HasStrictFDerivAt f₂ f₂' x) :
    HasStrictFDerivAt (fun x => (f₂ x).2) ((snd 𝕜 F G).comp f₂') x 
goal: HasStrictFDerivAt (fun x => (f₂ x).2) ((ContinuousLinearMap.snd 𝕜 F G).comp f₂') x

full_name: hasFDerivAtFilter_snd
code: theorem hasFDerivAtFilter_snd {L : Filter (E × F)} :
    HasFDerivAtFilter (@Prod.snd E F) (snd 𝕜 E F) p L 
goal: HasFDerivAtFilter Prod.snd (ContinuousLinearMap.snd 𝕜 E F) p L

full_name: HasFDerivAtFilter.snd
code: protected theorem HasFDerivAtFilter.snd (h : HasFDerivAtFilter f₂ f₂' x L) :
    HasFDerivAtFilter (fun x => (f₂ x).2) ((snd 𝕜 F G).comp f₂') x L 
goal: HasFDerivAtFilter (fun x => (f₂ x).2) ((ContinuousLinearMap.snd 𝕜 F G).comp f₂') x L

full_name: hasFDerivAt_snd
code: @[fun_prop]
theorem hasFDerivAt_snd : HasFDerivAt (@Prod.snd E F) (snd 𝕜 E F) p 
goal: HasFDerivAt Prod.snd (ContinuousLinearMap.snd 𝕜 E F) p

full_name: HasFDerivAt.snd
code: @[fun_prop]
protected nonrec theorem HasFDerivAt.snd (h : HasFDerivAt f₂ f₂' x) :
    HasFDerivAt (fun x => (f₂ x).2) ((snd 𝕜 F G).comp f₂') x 
goal: HasFDerivAt (fun x => (f₂ x).2) ((ContinuousLinearMap.snd 𝕜 F G).comp f₂') x

full_name: hasFDerivWithinAt_snd
code: @[fun_prop]
theorem hasFDerivWithinAt_snd {s : Set (E × F)} :
    HasFDerivWithinAt (@Prod.snd E F) (snd 𝕜 E F) s p 
goal: HasFDerivWithinAt Prod.snd (ContinuousLinearMap.snd 𝕜 E F) s p

full_name: HasFDerivWithinAt.snd
code: @[fun_prop]
protected nonrec theorem HasFDerivWithinAt.snd (h : HasFDerivWithinAt f₂ f₂' s x) :
    HasFDerivWithinAt (fun x => (f₂ x).2) ((snd 𝕜 F G).comp f₂') s x 
goal: HasFDerivWithinAt (fun x => (f₂ x).2) ((ContinuousLinearMap.snd 𝕜 F G).comp f₂') s x

full_name: differentiableAt_snd
code: @[fun_prop]
theorem differentiableAt_snd : DifferentiableAt 𝕜 Prod.snd p 
goal: DifferentiableAt 𝕜 Prod.snd p

full_name: DifferentiableAt.snd
code: @[simp, fun_prop]
protected theorem DifferentiableAt.snd (h : DifferentiableAt 𝕜 f₂ x) :
    DifferentiableAt 𝕜 (fun x => (f₂ x).2) x 
goal: DifferentiableAt 𝕜 (fun x => (f₂ x).2) x

full_name: differentiable_snd
code: @[fun_prop]
theorem differentiable_snd : Differentiable 𝕜 (Prod.snd : E × F → F) 
goal: Differentiable 𝕜 Prod.snd

full_name: Differentiable.snd
code: @[simp, fun_prop]
protected theorem Differentiable.snd (h : Differentiable 𝕜 f₂) :
    Differentiable 𝕜 fun x => (f₂ x).2 
goal: Differentiable 𝕜 fun x => (f₂ x).2

full_name: differentiableWithinAt_snd
code: @[fun_prop]
theorem differentiableWithinAt_snd {s : Set (E × F)} : DifferentiableWithinAt 𝕜 Prod.snd s p 
goal: DifferentiableWithinAt 𝕜 Prod.snd s p

full_name: DifferentiableWithinAt.snd
code: @[fun_prop]
protected theorem DifferentiableWithinAt.snd (h : DifferentiableWithinAt 𝕜 f₂ s x) :
    DifferentiableWithinAt 𝕜 (fun x => (f₂ x).2) s x 
goal: DifferentiableWithinAt 𝕜 (fun x => (f₂ x).2) s x

full_name: differentiableOn_snd
code: @[fun_prop]
theorem differentiableOn_snd {s : Set (E × F)} : DifferentiableOn 𝕜 Prod.snd s 
goal: DifferentiableOn 𝕜 Prod.snd s

full_name: DifferentiableOn.snd
code: @[fun_prop]
protected theorem DifferentiableOn.snd (h : DifferentiableOn 𝕜 f₂ s) :
    DifferentiableOn 𝕜 (fun x => (f₂ x).2) s 
goal: DifferentiableOn 𝕜 (fun x => (f₂ x).2) s

full_name: fderiv_snd
code: theorem fderiv_snd : fderiv 𝕜 Prod.snd p = snd 𝕜 E F 
goal: fderiv 𝕜 Prod.snd p = ContinuousLinearMap.snd 𝕜 E F

full_name: fderiv.snd
code: theorem fderiv.snd (h : DifferentiableAt 𝕜 f₂ x) :
    fderiv 𝕜 (fun x => (f₂ x).2) x = (snd 𝕜 F G).comp (fderiv 𝕜 f₂ x) 
goal: fderiv 𝕜 (fun x => (f₂ x).2) x = (ContinuousLinearMap.snd 𝕜 F G).comp (fderiv 𝕜 f₂ x)

full_name: fderivWithin_snd
code: theorem fderivWithin_snd {s : Set (E × F)} (hs : UniqueDiffWithinAt 𝕜 s p) :
    fderivWithin 𝕜 Prod.snd s p = snd 𝕜 E F 
goal: fderivWithin 𝕜 Prod.snd s p = ContinuousLinearMap.snd 𝕜 E F

full_name: fderivWithin.snd
code: theorem fderivWithin.snd (hs : UniqueDiffWithinAt 𝕜 s x) (h : DifferentiableWithinAt 𝕜 f₂ s x) :
    fderivWithin 𝕜 (fun x => (f₂ x).2) s x = (snd 𝕜 F G).comp (fderivWithin 𝕜 f₂ s x) 
goal: fderivWithin 𝕜 (fun x => (f₂ x).2) s x = (ContinuousLinearMap.snd 𝕜 F G).comp (fderivWithin 𝕜 f₂ s x)

full_name: HasStrictFDerivAt.prodMap
code: @[fun_prop]
protected theorem HasStrictFDerivAt.prodMap (hf : HasStrictFDerivAt f f' p.1)
    (hf₂ : HasStrictFDerivAt f₂ f₂' p.2) : HasStrictFDerivAt (Prod.map f f₂) (f'.prodMap f₂') p 
goal: HasStrictFDerivAt (Prod.map f f₂) (f'.prodMap f₂') p

full_name: HasFDerivAt.prodMap
code: @[fun_prop]
protected theorem HasFDerivAt.prodMap (hf : HasFDerivAt f f' p.1) (hf₂ : HasFDerivAt f₂ f₂' p.2) :
    HasFDerivAt (Prod.map f f₂) (f'.prodMap f₂') p 
goal: HasFDerivAt (Prod.map f f₂) (f'.prodMap f₂') p

full_name: DifferentiableAt.prod_map
code: @[simp, fun_prop]
protected theorem DifferentiableAt.prod_map (hf : DifferentiableAt 𝕜 f p.1)
    (hf₂ : DifferentiableAt 𝕜 f₂ p.2) : DifferentiableAt 𝕜 (fun p : E × G => (f p.1, f₂ p.2)) p 
goal: DifferentiableAt 𝕜 (fun p => (f p.1, f₂ p.2)) p

full_name: hasStrictFDerivAt_pi'
code: @[simp]
theorem hasStrictFDerivAt_pi' :
    HasStrictFDerivAt Φ Φ' x ↔ ∀ i, HasStrictFDerivAt (fun x => Φ x i) ((proj i).comp Φ') x 
goal: HasStrictFDerivAt Φ Φ' x ↔ ∀ (i : ι), HasStrictFDerivAt (fun x => Φ x i) ((ContinuousLinearMap.proj i).comp Φ') x

full_name: hasStrictFDerivAt_pi''
code: @[fun_prop]
theorem hasStrictFDerivAt_pi'' (hφ : ∀ i, HasStrictFDerivAt (fun x => Φ x i) ((proj i).comp Φ') x) :
    HasStrictFDerivAt Φ Φ' x 
goal: HasStrictFDerivAt Φ Φ' x

full_name: hasStrictFDerivAt_apply
code: @[fun_prop]
theorem hasStrictFDerivAt_apply (i : ι) (f : ∀ i, F' i) :
    HasStrictFDerivAt (𝕜 := 𝕜) (fun f : ∀ i, F' i => f i) (proj i) f 
goal: HasStrictFDerivAt (fun f => f i) (ContinuousLinearMap.proj i) f

full_name: hasStrictFDerivAt_pi
code: @[simp 1100] -- Porting note: increased priority to make lint happy
theorem hasStrictFDerivAt_pi :
    HasStrictFDerivAt (fun x i => φ i x) (ContinuousLinearMap.pi φ') x ↔
      ∀ i, HasStrictFDerivAt (φ i) (φ' i) x 
goal: HasStrictFDerivAt (fun x i => φ i x) (ContinuousLinearMap.pi φ') x ↔ ∀ (i : ι), HasStrictFDerivAt (φ i) (φ' i) x

full_name: hasFDerivAtFilter_pi'
code: @[simp]
theorem hasFDerivAtFilter_pi' :
    HasFDerivAtFilter Φ Φ' x L ↔
      ∀ i, HasFDerivAtFilter (fun x => Φ x i) ((proj i).comp Φ') x L 
goal: HasFDerivAtFilter Φ Φ' x L ↔ ∀ (i : ι), HasFDerivAtFilter (fun x => Φ x i) ((ContinuousLinearMap.proj i).comp Φ') x L

full_name: hasFDerivAtFilter_pi
code: theorem hasFDerivAtFilter_pi :
    HasFDerivAtFilter (fun x i => φ i x) (ContinuousLinearMap.pi φ') x L ↔
      ∀ i, HasFDerivAtFilter (φ i) (φ' i) x L 
goal: HasFDerivAtFilter (fun x i => φ i x) (ContinuousLinearMap.pi φ') x L ↔ ∀ (i : ι), HasFDerivAtFilter (φ i) (φ' i) x L

full_name: hasFDerivAt_pi'
code: @[simp]
theorem hasFDerivAt_pi' :
    HasFDerivAt Φ Φ' x ↔ ∀ i, HasFDerivAt (fun x => Φ x i) ((proj i).comp Φ') x 
goal: HasFDerivAt Φ Φ' x ↔ ∀ (i : ι), HasFDerivAt (fun x => Φ x i) ((ContinuousLinearMap.proj i).comp Φ') x

full_name: hasFDerivAt_pi''
code: @[fun_prop]
theorem hasFDerivAt_pi'' (hφ : ∀ i, HasFDerivAt (fun x => Φ x i) ((proj i).comp Φ') x) :
    HasFDerivAt Φ Φ' x 
goal: HasFDerivAt Φ Φ' x

full_name: hasFDerivAt_apply
code: @[fun_prop]
theorem hasFDerivAt_apply (i : ι) (f : ∀ i, F' i) :
    HasFDerivAt (𝕜 := 𝕜) (fun f : ∀ i, F' i => f i) (proj i) f 
goal: HasFDerivAt (fun f => f i) (ContinuousLinearMap.proj i) f

full_name: hasFDerivAt_pi
code: theorem hasFDerivAt_pi :
    HasFDerivAt (fun x i => φ i x) (ContinuousLinearMap.pi φ') x ↔
      ∀ i, HasFDerivAt (φ i) (φ' i) x 
goal: HasFDerivAt (fun x i => φ i x) (ContinuousLinearMap.pi φ') x ↔ ∀ (i : ι), HasFDerivAt (φ i) (φ' i) x

full_name: hasFDerivWithinAt_pi'
code: @[simp]
theorem hasFDerivWithinAt_pi' :
    HasFDerivWithinAt Φ Φ' s x ↔ ∀ i, HasFDerivWithinAt (fun x => Φ x i) ((proj i).comp Φ') s x 
goal: HasFDerivWithinAt Φ Φ' s x ↔ ∀ (i : ι), HasFDerivWithinAt (fun x => Φ x i) ((ContinuousLinearMap.proj i).comp Φ') s x

full_name: hasFDerivWithinAt_pi''
code: @[fun_prop]
theorem hasFDerivWithinAt_pi''
    (hφ : ∀ i, HasFDerivWithinAt (fun x => Φ x i) ((proj i).comp Φ') s x) :
    HasFDerivWithinAt Φ Φ' s x 
goal: HasFDerivWithinAt Φ Φ' s x

full_name: hasFDerivWithinAt_apply
code: @[fun_prop]
theorem hasFDerivWithinAt_apply (i : ι) (f : ∀ i, F' i) (s' : Set (∀ i, F' i)) :
    HasFDerivWithinAt (𝕜 := 𝕜) (fun f : ∀ i, F' i => f i) (proj i) s' f 
goal: HasFDerivWithinAt (fun f => f i) (ContinuousLinearMap.proj i) s' f

full_name: hasFDerivWithinAt_pi
code: theorem hasFDerivWithinAt_pi :
    HasFDerivWithinAt (fun x i => φ i x) (ContinuousLinearMap.pi φ') s x ↔
      ∀ i, HasFDerivWithinAt (φ i) (φ' i) s x 
goal: HasFDerivWithinAt (fun x i => φ i x) (ContinuousLinearMap.pi φ') s x ↔ ∀ (i : ι), HasFDerivWithinAt (φ i) (φ' i) s x

full_name: differentiableWithinAt_pi
code: @[simp]
theorem differentiableWithinAt_pi :
    DifferentiableWithinAt 𝕜 Φ s x ↔ ∀ i, DifferentiableWithinAt 𝕜 (fun x => Φ x i) s x 
goal: DifferentiableWithinAt 𝕜 Φ s x ↔ ∀ (i : ι), DifferentiableWithinAt 𝕜 (fun x => Φ x i) s x

full_name: differentiableWithinAt_pi''
code: @[fun_prop]
theorem differentiableWithinAt_pi'' (hφ : ∀ i, DifferentiableWithinAt 𝕜 (fun x => Φ x i) s x) :
    DifferentiableWithinAt 𝕜 Φ s x 
goal: DifferentiableWithinAt 𝕜 Φ s x

full_name: differentiableWithinAt_apply
code: @[fun_prop]
theorem differentiableWithinAt_apply (i : ι) (f : ∀ i, F' i) (s' : Set (∀ i, F' i)) :
    DifferentiableWithinAt (𝕜 := 𝕜) (fun f : ∀ i, F' i => f i) s' f 
goal: DifferentiableWithinAt 𝕜 (fun f => f i) s' f

full_name: differentiableAt_pi
code: @[simp]
theorem differentiableAt_pi : DifferentiableAt 𝕜 Φ x ↔ ∀ i, DifferentiableAt 𝕜 (fun x => Φ x i) x 
goal: DifferentiableAt 𝕜 Φ x ↔ ∀ (i : ι), DifferentiableAt 𝕜 (fun x => Φ x i) x

full_name: differentiableAt_pi''
code: @[fun_prop]
theorem differentiableAt_pi'' (hφ : ∀ i, DifferentiableAt 𝕜 (fun x => Φ x i) x) :
    DifferentiableAt 𝕜 Φ x 
goal: DifferentiableAt 𝕜 Φ x

full_name: differentiableAt_apply
code: @[fun_prop]
theorem differentiableAt_apply (i : ι) (f : ∀ i, F' i) :
    DifferentiableAt (𝕜 := 𝕜) (fun f : ∀ i, F' i => f i) f 
goal: DifferentiableAt 𝕜 (fun f => f i) f

full_name: differentiableOn_pi
code: theorem differentiableOn_pi : DifferentiableOn 𝕜 Φ s ↔ ∀ i, DifferentiableOn 𝕜 (fun x => Φ x i) s 
goal: DifferentiableOn 𝕜 Φ s ↔ ∀ (i : ι), DifferentiableOn 𝕜 (fun x => Φ x i) s

full_name: differentiableOn_pi''
code: @[fun_prop]
theorem differentiableOn_pi'' (hφ : ∀ i, DifferentiableOn 𝕜 (fun x => Φ x i) s) :
    DifferentiableOn 𝕜 Φ s 
goal: DifferentiableOn 𝕜 Φ s

full_name: differentiableOn_apply
code: @[fun_prop]
theorem differentiableOn_apply (i : ι) (s' : Set (∀ i, F' i)) :
    DifferentiableOn (𝕜 := 𝕜) (fun f : ∀ i, F' i => f i) s' 
goal: DifferentiableOn 𝕜 (fun f => f i) s'

full_name: differentiable_pi
code: theorem differentiable_pi : Differentiable 𝕜 Φ ↔ ∀ i, Differentiable 𝕜 fun x => Φ x i 
goal: Differentiable 𝕜 Φ ↔ ∀ (i : ι), Differentiable 𝕜 fun x => Φ x i

full_name: differentiable_pi''
code: @[fun_prop]
theorem differentiable_pi'' (hφ : ∀ i, Differentiable 𝕜 fun x => Φ x i) :
    Differentiable 𝕜 Φ 
goal: Differentiable 𝕜 Φ

full_name: differentiable_apply
code: @[fun_prop]
theorem differentiable_apply (i : ι) :
    Differentiable (𝕜 := 𝕜) (fun f : ∀ i, F' i => f i) 
goal: Differentiable 𝕜 fun f => f i

full_name: fderivWithin_pi
code: theorem fderivWithin_pi (h : ∀ i, DifferentiableWithinAt 𝕜 (φ i) s x)
    (hs : UniqueDiffWithinAt 𝕜 s x) :
    fderivWithin 𝕜 (fun x i => φ i x) s x = pi fun i => fderivWithin 𝕜 (φ i) s x 
goal: fderivWithin 𝕜 (fun x i => φ i x) s x = ContinuousLinearMap.pi fun i => fderivWithin 𝕜 (φ i) s x

full_name: fderiv_pi
code: theorem fderiv_pi (h : ∀ i, DifferentiableAt 𝕜 (φ i) x) :
    fderiv 𝕜 (fun x i => φ i x) x = pi fun i => fderiv 𝕜 (φ i) x 
goal: fderiv 𝕜 (fun x i => φ i x) x = ContinuousLinearMap.pi fun i => fderiv 𝕜 (φ i) x