l3lab/ntp-mathlib huggingface dataset:
theorem implicitFunction_hasStrictFDerivAt (g'inv : G →L[𝕜] E)
    (hg'inv : φ.rightDeriv.comp g'inv = ContinuousLinearMap.id 𝕜 G)
    (hg'invf : φ.leftDeriv.comp g'inv = 0) :
    HasStrictFDerivAt (φ.implicitFunction (φ.leftFun φ.pt)) g'inv (φ.rightFun φ.pt) := by
  have := φ.hasStrictFDerivAt.to_localInverse
  simp only [prodFun] at this
  convert this.comp (φ.rightFun φ.pt) ((hasStrictFDerivAt_const _ _).prod (hasStrictFDerivAt_id _))
  -- porting note: added parentheses to help `simp`
  

Proof state:
case h.e'_10
𝕜 : Type u_1
inst✝⁹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : CompleteSpace E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : CompleteSpace F
G : Type u_4
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
inst✝ : CompleteSpace G
φ : ImplicitFunctionData 𝕜 E F G
g'inv : G →L[𝕜] E
hg'inv : ContinuousLinearMap.comp φ.rightDeriv g'inv = ContinuousLinearMap.id 𝕜 G
hg'invf : ContinuousLinearMap.comp φ.leftDeriv g'inv = 0
this :
  HasStrictFDerivAt
    (HasStrictFDerivAt.localInverse (prodFun φ)
      (ContinuousLinearMap.equivProdOfSurjectiveOfIsCompl φ.leftDeriv φ.rightDeriv (_ : range φ.leftDeriv = ⊤)
        (_ : range φ.rightDeriv = ⊤) (_ : IsCompl (LinearMap.ker φ.leftDeriv) (LinearMap.ker φ.rightDeriv)))
      φ.pt
      (_ :
        HasStrictFDerivAt (prodFun φ)
          (↑(ContinuousLinearMap.equivProdOfSurjectiveOfIsCompl φ.leftDeriv φ.rightDeriv (_ : range φ.leftDeriv = ⊤)
              (_ : range φ.rightDeriv = ⊤) (_ : IsCompl (LinearMap.ker φ.leftDeriv) (LinearMap.ker φ.rightDeriv))))
          φ.pt))
    ↑(ContinuousLinearEquiv.symm
        (ContinuousLinearMap.equivProdOfSurjectiveOfIsCompl φ.leftDeriv φ.rightDeriv (_ : range φ.leftDeriv = ⊤)
          (_ : range φ.rightDeriv = ⊤) (_ : IsCompl (LinearMap.ker φ.leftDeriv) (LinearMap.ker φ.rightDeriv))))
    (leftFun φ φ.pt, rightFun φ φ.pt)
⊢ g'inv =
    ContinuousLinearMap.comp
      (↑(ContinuousLinearEquiv.symm
          (ContinuousLinearMap.equivProdOfSurjectiveOfIsCompl φ.leftDeriv φ.rightDeriv (_ : range φ.leftDeriv = ⊤)
            (_ : range φ.rightDeriv = ⊤) (_ : IsCompl (LinearMap.ker φ.leftDeriv) (LinearMap.ker φ.rightDeriv)))))
      (ContinuousLinearMap.prod 0 (ContinuousLinearMap.id 𝕜 G))

Next tactic:
simp only [ContinuousLinearMap.ext_iff, (ContinuousLinearMap.comp_apply)] at hg'inv hg'invf ⊢
theorem implicitFunction_hasStrictFDerivAt (g'inv : G →L[𝕜] E)
    (hg'inv : φ.rightDeriv.comp g'inv = ContinuousLinearMap.id 𝕜 G)
    (hg'invf : φ.leftDeriv.comp g'inv = 0) :
    HasStrictFDerivAt (φ.implicitFunction (φ.leftFun φ.pt)) g'inv (φ.rightFun φ.pt) := by
  have := φ.hasStrictFDerivAt.to_localInverse
  simp only [prodFun] at this
  convert this.comp (φ.rightFun φ.pt) ((hasStrictFDerivAt_const _ _).prod (hasStrictFDerivAt_id _))
  -- porting note: added parentheses to help `simp`
  simp only [ContinuousLinearMap.ext_iff, (ContinuousLinearMap.comp_apply)] at hg'inv hg'invf ⊢
  -- porting note: was `simp [ContinuousLinearEquiv.eq_symm_apply]`;
  -- both `simp` and `rw` fail here, `erw` works
  

Proof state:
case h.e'_10
𝕜 : Type u_1
inst✝⁹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : CompleteSpace E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : CompleteSpace F
G : Type u_4
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
inst✝ : CompleteSpace G
φ : ImplicitFunctionData 𝕜 E F G
g'inv : G →L[𝕜] E
this :
  HasStrictFDerivAt
    (HasStrictFDerivAt.localInverse (prodFun φ)
      (ContinuousLinearMap.equivProdOfSurjectiveOfIsCompl φ.leftDeriv φ.rightDeriv (_ : range φ.leftDeriv = ⊤)
        (_ : range φ.rightDeriv = ⊤) (_ : IsCompl (LinearMap.ker φ.leftDeriv) (LinearMap.ker φ.rightDeriv)))
      φ.pt
      (_ :
        HasStrictFDerivAt (prodFun φ)
          (↑(ContinuousLinearMap.equivProdOfSurjectiveOfIsCompl φ.leftDeriv φ.rightDeriv (_ : range φ.leftDeriv = ⊤)
              (_ : range φ.rightDeriv = ⊤) (_ : IsCompl (LinearMap.ker φ.leftDeriv) (LinearMap.ker φ.rightDeriv))))
          φ.pt))
    ↑(ContinuousLinearEquiv.symm
        (ContinuousLinearMap.equivProdOfSurjectiveOfIsCompl φ.leftDeriv φ.rightDeriv (_ : range φ.leftDeriv = ⊤)
          (_ : range φ.rightDeriv = ⊤) (_ : IsCompl (LinearMap.ker φ.leftDeriv) (LinearMap.ker φ.rightDeriv))))
    (leftFun φ φ.pt, rightFun φ φ.pt)
hg'inv : ∀ (x : G), φ.rightDeriv (g'inv x) = (ContinuousLinearMap.id 𝕜 G) x
hg'invf : ∀ (x : G), φ.leftDeriv (g'inv x) = 0 x
⊢ ∀ (x : G),
    g'inv x =
      ↑(ContinuousLinearEquiv.symm
            (ContinuousLinearMap.equivProdOfSurjectiveOfIsCompl φ.leftDeriv φ.rightDeriv (_ : range φ.leftDeriv = ⊤)
              (_ : range φ.rightDeriv = ⊤) (_ : IsCompl (LinearMap.ker φ.leftDeriv) (LinearMap.ker φ.rightDeriv))))
        ((ContinuousLinearMap.prod 0 (ContinuousLinearMap.id 𝕜 G)) x)

Next tactic:
intro x
theorem implicitFunction_hasStrictFDerivAt (g'inv : G →L[𝕜] E)
    (hg'inv : φ.rightDeriv.comp g'inv = ContinuousLinearMap.id 𝕜 G)
    (hg'invf : φ.leftDeriv.comp g'inv = 0) :
    HasStrictFDerivAt (φ.implicitFunction (φ.leftFun φ.pt)) g'inv (φ.rightFun φ.pt) := by
  have := φ.hasStrictFDerivAt.to_localInverse
  simp only [prodFun] at this
  convert this.comp (φ.rightFun φ.pt) ((hasStrictFDerivAt_const _ _).prod (hasStrictFDerivAt_id _))
  -- porting note: added parentheses to help `simp`
  simp only [ContinuousLinearMap.ext_iff, (ContinuousLinearMap.comp_apply)] at hg'inv hg'invf ⊢
  -- porting note: was `simp [ContinuousLinearEquiv.eq_symm_apply]`;
  -- both `simp` and `rw` fail here, `erw` works
  intro x
  

Proof state:
case h.e'_10
𝕜 : Type u_1
inst✝⁹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : CompleteSpace E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : CompleteSpace F
G : Type u_4
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
inst✝ : CompleteSpace G
φ : ImplicitFunctionData 𝕜 E F G
g'inv : G →L[𝕜] E
this :
  HasStrictFDerivAt
    (HasStrictFDerivAt.localInverse (prodFun φ)
      (ContinuousLinearMap.equivProdOfSurjectiveOfIsCompl φ.leftDeriv φ.rightDeriv (_ : range φ.leftDeriv = ⊤)
        (_ : range φ.rightDeriv = ⊤) (_ : IsCompl (LinearMap.ker φ.leftDeriv) (LinearMap.ker φ.rightDeriv)))
      φ.pt
      (_ :
        HasStrictFDerivAt (prodFun φ)
          (↑(ContinuousLinearMap.equivProdOfSurjectiveOfIsCompl φ.leftDeriv φ.rightDeriv (_ : range φ.leftDeriv = ⊤)
              (_ : range φ.rightDeriv = ⊤) (_ : IsCompl (LinearMap.ker φ.leftDeriv) (LinearMap.ker φ.rightDeriv))))
          φ.pt))
    ↑(ContinuousLinearEquiv.symm
        (ContinuousLinearMap.equivProdOfSurjectiveOfIsCompl φ.leftDeriv φ.rightDeriv (_ : range φ.leftDeriv = ⊤)
          (_ : range φ.rightDeriv = ⊤) (_ : IsCompl (LinearMap.ker φ.leftDeriv) (LinearMap.ker φ.rightDeriv))))
    (leftFun φ φ.pt, rightFun φ φ.pt)
hg'inv : ∀ (x : G), φ.rightDeriv (g'inv x) = (ContinuousLinearMap.id 𝕜 G) x
hg'invf : ∀ (x : G), φ.leftDeriv (g'inv x) = 0 x
x : G
⊢ g'inv x =
    ↑(ContinuousLinearEquiv.symm
          (ContinuousLinearMap.equivProdOfSurjectiveOfIsCompl φ.leftDeriv φ.rightDeriv (_ : range φ.leftDeriv = ⊤)
            (_ : range φ.rightDeriv = ⊤) (_ : IsCompl (LinearMap.ker φ.leftDeriv) (LinearMap.ker φ.rightDeriv))))
      ((ContinuousLinearMap.prod 0 (ContinuousLinearMap.id 𝕜 G)) x)

Next tactic:
erw [ContinuousLinearEquiv.eq_symm_apply]
theorem implicitFunction_hasStrictFDerivAt (g'inv : G →L[𝕜] E)
    (hg'inv : φ.rightDeriv.comp g'inv = ContinuousLinearMap.id 𝕜 G)
    (hg'invf : φ.leftDeriv.comp g'inv = 0) :
    HasStrictFDerivAt (φ.implicitFunction (φ.leftFun φ.pt)) g'inv (φ.rightFun φ.pt) := by
  have := φ.hasStrictFDerivAt.to_localInverse
  simp only [prodFun] at this
  convert this.comp (φ.rightFun φ.pt) ((hasStrictFDerivAt_const _ _).prod (hasStrictFDerivAt_id _))
  -- porting note: added parentheses to help `simp`
  simp only [ContinuousLinearMap.ext_iff, (ContinuousLinearMap.comp_apply)] at hg'inv hg'invf ⊢
  -- porting note: was `simp [ContinuousLinearEquiv.eq_symm_apply]`;
  -- both `simp` and `rw` fail here, `erw` works
  intro x
  erw [ContinuousLinearEquiv.eq_symm_apply]
  

Proof state:
case h.e'_10
𝕜 : Type u_1
inst✝⁹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : CompleteSpace E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : CompleteSpace F
G : Type u_4
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
inst✝ : CompleteSpace G
φ : ImplicitFunctionData 𝕜 E F G
g'inv : G →L[𝕜] E
this :
  HasStrictFDerivAt
    (HasStrictFDerivAt.localInverse (prodFun φ)
      (ContinuousLinearMap.equivProdOfSurjectiveOfIsCompl φ.leftDeriv φ.rightDeriv (_ : range φ.leftDeriv = ⊤)
        (_ : range φ.rightDeriv = ⊤) (_ : IsCompl (LinearMap.ker φ.leftDeriv) (LinearMap.ker φ.rightDeriv)))
      φ.pt
      (_ :
        HasStrictFDerivAt (prodFun φ)
          (↑(ContinuousLinearMap.equivProdOfSurjectiveOfIsCompl φ.leftDeriv φ.rightDeriv (_ : range φ.leftDeriv = ⊤)
              (_ : range φ.rightDeriv = ⊤) (_ : IsCompl (LinearMap.ker φ.leftDeriv) (LinearMap.ker φ.rightDeriv))))
          φ.pt))
    ↑(ContinuousLinearEquiv.symm
        (ContinuousLinearMap.equivProdOfSurjectiveOfIsCompl φ.leftDeriv φ.rightDeriv (_ : range φ.leftDeriv = ⊤)
          (_ : range φ.rightDeriv = ⊤) (_ : IsCompl (LinearMap.ker φ.leftDeriv) (LinearMap.ker φ.rightDeriv))))
    (leftFun φ φ.pt, rightFun φ φ.pt)
hg'inv : ∀ (x : G), φ.rightDeriv (g'inv x) = (ContinuousLinearMap.id 𝕜 G) x
hg'invf : ∀ (x : G), φ.leftDeriv (g'inv x) = 0 x
x : G
⊢ (ContinuousLinearMap.equivProdOfSurjectiveOfIsCompl φ.leftDeriv φ.rightDeriv (_ : range φ.leftDeriv = ⊤)
        (_ : range φ.rightDeriv = ⊤) (_ : IsCompl (LinearMap.ker φ.leftDeriv) (LinearMap.ker φ.rightDeriv)))
      (g'inv x) =
    (ContinuousLinearMap.prod 0 (ContinuousLinearMap.id 𝕜 G)) x

Next tactic:
simp [*]
@[simp]
theorem implicitToPartialHomeomorphOfComplemented_apply_ker (hf : HasStrictFDerivAt f f' a)
    (hf' : range f' = ⊤) (hker : (ker f').ClosedComplemented) (y : ker f') :
    hf.implicitToPartialHomeomorphOfComplemented f f' hf' hker (y + a) = (f (y + a), y) := by
  

Proof state:
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : CompleteSpace E
F : Type u_3
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : CompleteSpace F
f : E → F
f' : E →L[𝕜] F
a : E
hf : HasStrictFDerivAt f f' a
hf' : range f' = ⊤
hker : Submodule.ClosedComplemented (LinearMap.ker f')
y : ↥(LinearMap.ker f')
⊢ ↑(implicitToPartialHomeomorphOfComplemented f f' hf hf' hker) (↑y + a) = (f (↑y + a), y)

Next tactic:
simp only [implicitToPartialHomeomorphOfComplemented_apply, add_sub_cancel,
    Classical.choose_spec hker]
@[simp]
theorem implicitToPartialHomeomorphOfComplemented_self (hf : HasStrictFDerivAt f f' a)
    (hf' : range f' = ⊤) (hker : (ker f').ClosedComplemented) :
    hf.implicitToPartialHomeomorphOfComplemented f f' hf' hker a = (f a, 0) := by
  

Proof state:
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : CompleteSpace E
F : Type u_3
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : CompleteSpace F
f : E → F
f' : E →L[𝕜] F
a : E
hf : HasStrictFDerivAt f f' a
hf' : range f' = ⊤
hker : Submodule.ClosedComplemented (LinearMap.ker f')
⊢ ↑(implicitToPartialHomeomorphOfComplemented f f' hf hf' hker) a = (f a, 0)

Next tactic:
simp [hf.implicitToPartialHomeomorphOfComplemented_apply]
theorem mem_implicitToPartialHomeomorphOfComplemented_target (hf : HasStrictFDerivAt f f' a)
    (hf' : range f' = ⊤) (hker : (ker f').ClosedComplemented) :
    (f a, (0 : ker f')) ∈ (hf.implicitToPartialHomeomorphOfComplemented f f' hf' hker).target := by
  

Proof state:
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : CompleteSpace E
F : Type u_3
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : CompleteSpace F
f : E → F
f' : E →L[𝕜] F
a : E
hf : HasStrictFDerivAt f f' a
hf' : range f' = ⊤
hker : Submodule.ClosedComplemented (LinearMap.ker f')
⊢ (f a, 0) ∈ (implicitToPartialHomeomorphOfComplemented f f' hf hf' hker).toPartialEquiv.target

Next tactic:
simpa only [implicitToPartialHomeomorphOfComplemented_self] using
    (hf.implicitToPartialHomeomorphOfComplemented f f' hf' hker).map_source <|
      hf.mem_implicitToPartialHomeomorphOfComplemented_source hf' hker
@[simp]
theorem implicitFunctionOfComplemented_apply_image (hf : HasStrictFDerivAt f f' a)
    (hf' : range f' = ⊤) (hker : (ker f').ClosedComplemented) :
    hf.implicitFunctionOfComplemented f f' hf' hker (f a) 0 = a := by
  

Proof state:
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : CompleteSpace E
F : Type u_3
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : CompleteSpace F
f : E → F
f' : E →L[𝕜] F
a : E
hf : HasStrictFDerivAt f f' a
hf' : range f' = ⊤
hker : Submodule.ClosedComplemented (LinearMap.ker f')
⊢ implicitFunctionOfComplemented f f' hf hf' hker (f a) 0 = a

Next tactic:
simpa only [implicitToPartialHomeomorphOfComplemented_self] using
      (hf.implicitToPartialHomeomorphOfComplemented f f' hf' hker).left_inv
      (hf.mem_implicitToPartialHomeomorphOfComplemented_source hf' hker)
theorem to_implicitFunctionOfComplemented (hf : HasStrictFDerivAt f f' a) (hf' : range f' = ⊤)
    (hker : (ker f').ClosedComplemented) :
    HasStrictFDerivAt (hf.implicitFunctionOfComplemented f f' hf' hker (f a))
      (ker f').subtypeL 0 := by
  

Proof state:
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : CompleteSpace E
F : Type u_3
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : CompleteSpace F
f : E → F
f' : E →L[𝕜] F
a : E
hf : HasStrictFDerivAt f f' a
hf' : range f' = ⊤
hker : Submodule.ClosedComplemented (LinearMap.ker f')
⊢ HasStrictFDerivAt (implicitFunctionOfComplemented f f' hf hf' hker (f a)) (Submodule.subtypeL (LinearMap.ker f')) 0

Next tactic:
convert (implicitFunctionDataOfComplemented f f' hf hf' hker).implicitFunction_hasStrictFDerivAt
    (ker f').subtypeL _ _
theorem to_implicitFunctionOfComplemented (hf : HasStrictFDerivAt f f' a) (hf' : range f' = ⊤)
    (hker : (ker f').ClosedComplemented) :
    HasStrictFDerivAt (hf.implicitFunctionOfComplemented f f' hf' hker (f a))
      (ker f').subtypeL 0 := by
  convert (implicitFunctionDataOfComplemented f f' hf hf' hker).implicitFunction_hasStrictFDerivAt
    (ker f').subtypeL _ _
  

Proof state:
case h.e'_11
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : CompleteSpace E
F : Type u_3
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : CompleteSpace F
f : E → F
f' : E →L[𝕜] F
a : E
hf : HasStrictFDerivAt f f' a
hf' : range f' = ⊤
hker : Submodule.ClosedComplemented (LinearMap.ker f')
⊢ 0 =
    ImplicitFunctionData.rightFun (implicitFunctionDataOfComplemented f f' hf hf' hker)
      (implicitFunctionDataOfComplemented f f' hf hf' hker).pt
case convert_1
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : CompleteSpace E
F : Type u_3
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : CompleteSpace F
f : E → F
f' : E →L[𝕜] F
a : E
hf : HasStrictFDerivAt f f' a
hf' : range f' = ⊤
hker : Submodule.ClosedComplemented (LinearMap.ker f')
⊢ ContinuousLinearMap.comp (implicitFunctionDataOfComplemented f f' hf hf' hker).rightDeriv
      (Submodule.subtypeL (LinearMap.ker f')) =
    ContinuousLinearMap.id 𝕜 ↥(LinearMap.ker f')
case convert_2
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : CompleteSpace E
F : Type u_3
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : CompleteSpace F
f : E → F
f' : E →L[𝕜] F
a : E
hf : HasStrictFDerivAt f f' a
hf' : range f' = ⊤
hker : Submodule.ClosedComplemented (LinearMap.ker f')
⊢ ContinuousLinearMap.comp (implicitFunctionDataOfComplemented f f' hf hf' hker).leftDeriv
      (Submodule.subtypeL (LinearMap.ker f')) =
    0

Next tactic:
swap
theorem to_implicitFunctionOfComplemented (hf : HasStrictFDerivAt f f' a) (hf' : range f' = ⊤)
    (hker : (ker f').ClosedComplemented) :
    HasStrictFDerivAt (hf.implicitFunctionOfComplemented f f' hf' hker (f a))
      (ker f').subtypeL 0 := by
  convert (implicitFunctionDataOfComplemented f f' hf hf' hker).implicitFunction_hasStrictFDerivAt
    (ker f').subtypeL _ _
  swap
  · 

Proof state:
case convert_1
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : CompleteSpace E
F : Type u_3
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : CompleteSpace F
f : E → F
f' : E →L[𝕜] F
a : E
hf : HasStrictFDerivAt f f' a
hf' : range f' = ⊤
hker : Submodule.ClosedComplemented (LinearMap.ker f')
⊢ ContinuousLinearMap.comp (implicitFunctionDataOfComplemented f f' hf hf' hker).rightDeriv
      (Submodule.subtypeL (LinearMap.ker f')) =
    ContinuousLinearMap.id 𝕜 ↥(LinearMap.ker f')

Next tactic:
ext
theorem to_implicitFunctionOfComplemented (hf : HasStrictFDerivAt f f' a) (hf' : range f' = ⊤)
    (hker : (ker f').ClosedComplemented) :
    HasStrictFDerivAt (hf.implicitFunctionOfComplemented f f' hf' hker (f a))
      (ker f').subtypeL 0 := by
  convert (implicitFunctionDataOfComplemented f f' hf hf' hker).implicitFunction_hasStrictFDerivAt
    (ker f').subtypeL _ _
  swap
  · ext
    -- Porting note: added parentheses to help `simp`
    

Proof state:
case convert_1.h.a
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : CompleteSpace E
F : Type u_3
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : CompleteSpace F
f : E → F
f' : E →L[𝕜] F
a : E
hf : HasStrictFDerivAt f f' a
hf' : range f' = ⊤
hker : Submodule.ClosedComplemented (LinearMap.ker f')
x✝ : ↥(LinearMap.ker f')
⊢ ↑((ContinuousLinearMap.comp (implicitFunctionDataOfComplemented f f' hf hf' hker).rightDeriv
          (Submodule.subtypeL (LinearMap.ker f')))
        x✝) =
    ↑((ContinuousLinearMap.id 𝕜 ↥(LinearMap.ker f')) x✝)

Next tactic:
simp only [Classical.choose_spec hker, implicitFunctionDataOfComplemented,
      (ContinuousLinearMap.comp_apply), Submodule.coe_subtypeL', Submodule.coeSubtype,
      (ContinuousLinearMap.id_apply)]
theorem to_implicitFunctionOfComplemented (hf : HasStrictFDerivAt f f' a) (hf' : range f' = ⊤)
    (hker : (ker f').ClosedComplemented) :
    HasStrictFDerivAt (hf.implicitFunctionOfComplemented f f' hf' hker (f a))
      (ker f').subtypeL 0 := by
  convert (implicitFunctionDataOfComplemented f f' hf hf' hker).implicitFunction_hasStrictFDerivAt
    (ker f').subtypeL _ _
  swap
  · ext
    -- Porting note: added parentheses to help `simp`
    simp only [Classical.choose_spec hker, implicitFunctionDataOfComplemented,
      (ContinuousLinearMap.comp_apply), Submodule.coe_subtypeL', Submodule.coeSubtype,
      (ContinuousLinearMap.id_apply)]
  

Proof state:
case h.e'_11
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : CompleteSpace E
F : Type u_3
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : CompleteSpace F
f : E → F
f' : E →L[𝕜] F
a : E
hf : HasStrictFDerivAt f f' a
hf' : range f' = ⊤
hker : Submodule.ClosedComplemented (LinearMap.ker f')
⊢ 0 =
    ImplicitFunctionData.rightFun (implicitFunctionDataOfComplemented f f' hf hf' hker)
      (implicitFunctionDataOfComplemented f f' hf hf' hker).pt
case convert_2
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : CompleteSpace E
F : Type u_3
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : CompleteSpace F
f : E → F
f' : E →L[𝕜] F
a : E
hf : HasStrictFDerivAt f f' a
hf' : range f' = ⊤
hker : Submodule.ClosedComplemented (LinearMap.ker f')
⊢ ContinuousLinearMap.comp (implicitFunctionDataOfComplemented f f' hf hf' hker).leftDeriv
      (Submodule.subtypeL (LinearMap.ker f')) =
    0

Next tactic:
swap
theorem to_implicitFunctionOfComplemented (hf : HasStrictFDerivAt f f' a) (hf' : range f' = ⊤)
    (hker : (ker f').ClosedComplemented) :
    HasStrictFDerivAt (hf.implicitFunctionOfComplemented f f' hf' hker (f a))
      (ker f').subtypeL 0 := by
  convert (implicitFunctionDataOfComplemented f f' hf hf' hker).implicitFunction_hasStrictFDerivAt
    (ker f').subtypeL _ _
  swap
  · ext
    -- Porting note: added parentheses to help `simp`
    simp only [Classical.choose_spec hker, implicitFunctionDataOfComplemented,
      (ContinuousLinearMap.comp_apply), Submodule.coe_subtypeL', Submodule.coeSubtype,
      (ContinuousLinearMap.id_apply)]
  swap
  · 

Proof state:
case convert_2
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : CompleteSpace E
F : Type u_3
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : CompleteSpace F
f : E → F
f' : E →L[𝕜] F
a : E
hf : HasStrictFDerivAt f f' a
hf' : range f' = ⊤
hker : Submodule.ClosedComplemented (LinearMap.ker f')
⊢ ContinuousLinearMap.comp (implicitFunctionDataOfComplemented f f' hf hf' hker).leftDeriv
      (Submodule.subtypeL (LinearMap.ker f')) =
    0

Next tactic:
ext
theorem to_implicitFunctionOfComplemented (hf : HasStrictFDerivAt f f' a) (hf' : range f' = ⊤)
    (hker : (ker f').ClosedComplemented) :
    HasStrictFDerivAt (hf.implicitFunctionOfComplemented f f' hf' hker (f a))
      (ker f').subtypeL 0 := by
  convert (implicitFunctionDataOfComplemented f f' hf hf' hker).implicitFunction_hasStrictFDerivAt
    (ker f').subtypeL _ _
  swap
  · ext
    -- Porting note: added parentheses to help `simp`
    simp only [Classical.choose_spec hker, implicitFunctionDataOfComplemented,
      (ContinuousLinearMap.comp_apply), Submodule.coe_subtypeL', Submodule.coeSubtype,
      (ContinuousLinearMap.id_apply)]
  swap
  · ext
    -- Porting note: added parentheses to help `simp`
    

Proof state:
case convert_2.h
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : CompleteSpace E
F : Type u_3
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : CompleteSpace F
f : E → F
f' : E →L[𝕜] F
a : E
hf : HasStrictFDerivAt f f' a
hf' : range f' = ⊤
hker : Submodule.ClosedComplemented (LinearMap.ker f')
x✝ : ↥(LinearMap.ker f')
⊢ (ContinuousLinearMap.comp (implicitFunctionDataOfComplemented f f' hf hf' hker).leftDeriv
        (Submodule.subtypeL (LinearMap.ker f')))
      x✝ =
    0 x✝

Next tactic:
simp only [(ContinuousLinearMap.comp_apply), Submodule.coe_subtypeL', Submodule.coeSubtype,
      LinearMap.map_coe_ker, (ContinuousLinearMap.zero_apply)]