l3lab/ntp-mathlib huggingface dataset:
/-- The natural equivalence `(E × E₂) × E₃ ≃ E × (E₂ × E₃)` is a linear isometry. -/
def prodAssoc [Module R E₂] [Module R E₃] : (E × E₂) × E₃ ≃ₗᵢ[R] E × E₂ × E₃ :=
  { Equiv.prodAssoc E E₂ E₃ with
    toFun := Equiv.prodAssoc E E₂ E₃
    invFun := (Equiv.prodAssoc E E₂ E₃).symm
    map_add' := by simp
    map_smul' := by simp
    norm_map' := by
      rintro ⟨⟨e, f⟩, g⟩
      

Proof state:
case mk.mk
R : Type u_1
R₂ : Type u_2
R₃ : Type u_3
R₄ : Type u_4
E : Type u_5
E₂ : Type u_6
E₃ : Type u_7
E₄ : Type u_8
F : Type u_9
𝓕 : Type u_10
inst✝³⁶ : Semiring R
inst✝³⁵ : Semiring R₂
inst✝³⁴ : Semiring R₃
inst✝³³ : Semiring R₄
σ₁₂ : R →+* R₂
σ₂₁ : R₂ →+* R
σ₁₃ : R →+* R₃
σ₃₁ : R₃ →+* R
σ₁₄ : R →+* R₄
σ₄₁ : R₄ →+* R
σ₂₃ : R₂ →+* R₃
σ₃₂ : R₃ →+* R₂
σ₂₄ : R₂ →+* R₄
σ₄₂ : R₄ →+* R₂
σ₃₄ : R₃ →+* R₄
σ₄₃ : R₄ →+* R₃
inst✝³² : RingHomInvPair σ₁₂ σ₂₁
inst✝³¹ : RingHomInvPair σ₂₁ σ₁₂
inst✝³⁰ : RingHomInvPair σ₁₃ σ₃₁
inst✝²⁹ : RingHomInvPair σ₃₁ σ₁₃
inst✝²⁸ : RingHomInvPair σ₂₃ σ₃₂
inst✝²⁷ : RingHomInvPair σ₃₂ σ₂₃
inst✝²⁶ : RingHomInvPair σ₁₄ σ₄₁
inst✝²⁵ : RingHomInvPair σ₄₁ σ₁₄
inst✝²⁴ : RingHomInvPair σ₂₄ σ₄₂
inst✝²³ : RingHomInvPair σ₄₂ σ₂₄
inst✝²² : RingHomInvPair σ₃₄ σ₄₃
inst✝²¹ : RingHomInvPair σ₄₃ σ₃₄
inst✝²⁰ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹⁹ : RingHomCompTriple σ₁₂ σ₂₄ σ₁₄
inst✝¹⁸ : RingHomCompTriple σ₂₃ σ₃₄ σ₂₄
inst✝¹⁷ : RingHomCompTriple σ₁₃ σ₃₄ σ₁₄
inst✝¹⁶ : RingHomCompTriple σ₃₂ σ₂₁ σ₃₁
inst✝¹⁵ : RingHomCompTriple σ₄₂ σ₂₁ σ₄₁
inst✝¹⁴ : RingHomCompTriple σ₄₃ σ₃₂ σ₄₂
inst✝¹³ : RingHomCompTriple σ₄₃ σ₃₁ σ₄₁
inst✝¹² : SeminormedAddCommGroup E
inst✝¹¹ : SeminormedAddCommGroup E₂
inst✝¹⁰ : SeminormedAddCommGroup E₃
inst✝⁹ : SeminormedAddCommGroup E₄
inst✝⁸ : Module R E
inst✝⁷ : Module R₂ E₂
inst✝⁶ : Module R₃ E₃
inst✝⁵ : Module R₄ E₄
inst✝⁴ : NormedAddCommGroup F
inst✝³ : Module R F
e✝ : E ≃ₛₗᵢ[σ₁₂] E₂
α : Type u_11
inst✝² : TopologicalSpace α
inst✝¹ : Module R E₂
inst✝ : Module R E₃
src✝ : (E × E₂) × E₃ ≃ E × E₂ × E₃ := Equiv.prodAssoc E E₂ E₃
g : E₃
e : E
f : E₂
⊢ ‖{
          toLinearMap :=
            {
              toAddHom :=
                { toFun := ⇑(Equiv.prodAssoc E E₂ E₃),
                  map_add' :=
                    (_ :
                      ∀ (a a_1 : (E × E₂) × E₃),
                        (a.1.1 + a_1.1.1, a.1.2 + a_1.1.2, a.2 + a_1.2) =
                          (a.1.1 + a_1.1.1, a.1.2 + a_1.1.2, a.2 + a_1.2)) },
              map_smul' :=
                (_ :
                  ∀ (a : R) (a_1 : (E × E₂) × E₃),
                    (a • a_1.1.1, a • a_1.1.2, a • a_1.2) = (a • a_1.1.1, a • a_1.1.2, a • a_1.2)) },
          invFun := ⇑(Equiv.prodAssoc E E₂ E₃).symm, left_inv := (_ : LeftInverse src✝.invFun src✝.toFun),
          right_inv := (_ : Function.RightInverse src✝.invFun src✝.toFun) }
        ((e, f), g)‖ =
    ‖((e, f), g)‖

Next tactic:
simp only [LinearEquiv.coe_mk, Equiv.prodAssoc_apply, Prod.norm_def, max_assoc]
@[simp]
theorem ofEq_rfl : ofEq p p rfl = LinearIsometryEquiv.refl R' p := by 

Proof state:
R : Type u_1
R₂ : Type u_2
R₃ : Type u_3
R₄ : Type u_4
E : Type u_5
E₂ : Type u_6
E₃ : Type u_7
E₄ : Type u_8
F : Type u_9
𝓕 : Type u_10
inst✝³⁶ : Semiring R
inst✝³⁵ : Semiring R₂
inst✝³⁴ : Semiring R₃
inst✝³³ : Semiring R₄
σ₁₂ : R →+* R₂
σ₂₁ : R₂ →+* R
σ₁₃ : R →+* R₃
σ₃₁ : R₃ →+* R
σ₁₄ : R →+* R₄
σ₄₁ : R₄ →+* R
σ₂₃ : R₂ →+* R₃
σ₃₂ : R₃ →+* R₂
σ₂₄ : R₂ →+* R₄
σ₄₂ : R₄ →+* R₂
σ₃₄ : R₃ →+* R₄
σ₄₃ : R₄ →+* R₃
inst✝³² : RingHomInvPair σ₁₂ σ₂₁
inst✝³¹ : RingHomInvPair σ₂₁ σ₁₂
inst✝³⁰ : RingHomInvPair σ₁₃ σ₃₁
inst✝²⁹ : RingHomInvPair σ₃₁ σ₁₃
inst✝²⁸ : RingHomInvPair σ₂₃ σ₃₂
inst✝²⁷ : RingHomInvPair σ₃₂ σ₂₃
inst✝²⁶ : RingHomInvPair σ₁₄ σ₄₁
inst✝²⁵ : RingHomInvPair σ₄₁ σ₁₄
inst✝²⁴ : RingHomInvPair σ₂₄ σ₄₂
inst✝²³ : RingHomInvPair σ₄₂ σ₂₄
inst✝²² : RingHomInvPair σ₃₄ σ₄₃
inst✝²¹ : RingHomInvPair σ₄₃ σ₃₄
inst✝²⁰ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹⁹ : RingHomCompTriple σ₁₂ σ₂₄ σ₁₄
inst✝¹⁸ : RingHomCompTriple σ₂₃ σ₃₄ σ₂₄
inst✝¹⁷ : RingHomCompTriple σ₁₃ σ₃₄ σ₁₄
inst✝¹⁶ : RingHomCompTriple σ₃₂ σ₂₁ σ₃₁
inst✝¹⁵ : RingHomCompTriple σ₄₂ σ₂₁ σ₄₁
inst✝¹⁴ : RingHomCompTriple σ₄₃ σ₃₂ σ₄₂
inst✝¹³ : RingHomCompTriple σ₄₃ σ₃₁ σ₄₁
inst✝¹² : SeminormedAddCommGroup E
inst✝¹¹ : SeminormedAddCommGroup E₂
inst✝¹⁰ : SeminormedAddCommGroup E₃
inst✝⁹ : SeminormedAddCommGroup E₄
inst✝⁸ : Module R E
inst✝⁷ : Module R₂ E₂
inst✝⁶ : Module R₃ E₃
inst✝⁵ : Module R₄ E₄
inst✝⁴ : NormedAddCommGroup F
inst✝³ : Module R F
e : E ≃ₛₗᵢ[σ₁₂] E₂
α : Type u_11
inst✝² : TopologicalSpace α
R' : Type u_12
inst✝¹ : Ring R'
inst✝ : Module R' E
p q : Submodule R' E
⊢ ofEq p p (_ : p = p) = refl R' ↥p

Next tactic:
funext
@[simp]
theorem ofEq_rfl : ofEq p p rfl = LinearIsometryEquiv.refl R' p := by funext; 

Proof state:
R : Type u_1
R₂ : Type u_2
R₃ : Type u_3
R₄ : Type u_4
E : Type u_5
E₂ : Type u_6
E₃ : Type u_7
E₄ : Type u_8
F : Type u_9
𝓕 : Type u_10
inst✝³⁶ : Semiring R
inst✝³⁵ : Semiring R₂
inst✝³⁴ : Semiring R₃
inst✝³³ : Semiring R₄
σ₁₂ : R →+* R₂
σ₂₁ : R₂ →+* R
σ₁₃ : R →+* R₃
σ₃₁ : R₃ →+* R
σ₁₄ : R →+* R₄
σ₄₁ : R₄ →+* R
σ₂₃ : R₂ →+* R₃
σ₃₂ : R₃ →+* R₂
σ₂₄ : R₂ →+* R₄
σ₄₂ : R₄ →+* R₂
σ₃₄ : R₃ →+* R₄
σ₄₃ : R₄ →+* R₃
inst✝³² : RingHomInvPair σ₁₂ σ₂₁
inst✝³¹ : RingHomInvPair σ₂₁ σ₁₂
inst✝³⁰ : RingHomInvPair σ₁₃ σ₃₁
inst✝²⁹ : RingHomInvPair σ₃₁ σ₁₃
inst✝²⁸ : RingHomInvPair σ₂₃ σ₃₂
inst✝²⁷ : RingHomInvPair σ₃₂ σ₂₃
inst✝²⁶ : RingHomInvPair σ₁₄ σ₄₁
inst✝²⁵ : RingHomInvPair σ₄₁ σ₁₄
inst✝²⁴ : RingHomInvPair σ₂₄ σ₄₂
inst✝²³ : RingHomInvPair σ₄₂ σ₂₄
inst✝²² : RingHomInvPair σ₃₄ σ₄₃
inst✝²¹ : RingHomInvPair σ₄₃ σ₃₄
inst✝²⁰ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝¹⁹ : RingHomCompTriple σ₁₂ σ₂₄ σ₁₄
inst✝¹⁸ : RingHomCompTriple σ₂₃ σ₃₄ σ₂₄
inst✝¹⁷ : RingHomCompTriple σ₁₃ σ₃₄ σ₁₄
inst✝¹⁶ : RingHomCompTriple σ₃₂ σ₂₁ σ₃₁
inst✝¹⁵ : RingHomCompTriple σ₄₂ σ₂₁ σ₄₁
inst✝¹⁴ : RingHomCompTriple σ₄₃ σ₃₂ σ₄₂
inst✝¹³ : RingHomCompTriple σ₄₃ σ₃₁ σ₄₁
inst✝¹² : SeminormedAddCommGroup E
inst✝¹¹ : SeminormedAddCommGroup E₂
inst✝¹⁰ : SeminormedAddCommGroup E₃
inst✝⁹ : SeminormedAddCommGroup E₄
inst✝⁸ : Module R E
inst✝⁷ : Module R₂ E₂
inst✝⁶ : Module R₃ E₃
inst✝⁵ : Module R₄ E₄
inst✝⁴ : NormedAddCommGroup F
inst✝³ : Module R F
e : E ≃ₛₗᵢ[σ₁₂] E₂
α : Type u_11
inst✝² : TopologicalSpace α
R' : Type u_12
inst✝¹ : Ring R'
inst✝ : Module R' E
p q : Submodule R' E
⊢ ofEq p p (_ : p = p) = refl R' ↥p

Next tactic:
rfl
@[simp]
theorem eqToHom_left (X Y : Comma L R) (H : X = Y) :
    CommaMorphism.left (eqToHom H) = eqToHom (by 

Proof state:
A : Type u₁
inst✝² : Category.{v₁, u₁} A
B : Type u₂
inst✝¹ : Category.{v₂, u₂} B
T : Type u₃
inst✝ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
X Y : Comma L R
H : X = Y
⊢ X.left = Y.left

Next tactic:
cases H
@[simp]
theorem eqToHom_left (X Y : Comma L R) (H : X = Y) :
    CommaMorphism.left (eqToHom H) = eqToHom (by cases H; 

Proof state:
case refl
A : Type u₁
inst✝² : Category.{v₁, u₁} A
B : Type u₂
inst✝¹ : Category.{v₂, u₂} B
T : Type u₃
inst✝ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
X : Comma L R
⊢ X.left = X.left

Next tactic:
rfl
@[simp]
theorem eqToHom_left (X Y : Comma L R) (H : X = Y) :
    CommaMorphism.left (eqToHom H) = eqToHom (by cases H; rfl) := by
  

Proof state:
A : Type u₁
inst✝² : Category.{v₁, u₁} A
B : Type u₂
inst✝¹ : Category.{v₂, u₂} B
T : Type u₃
inst✝ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
X Y : Comma L R
H : X = Y
⊢ (eqToHom H).left = eqToHom (_ : X.left = Y.left)

Next tactic:
cases H
@[simp]
theorem eqToHom_left (X Y : Comma L R) (H : X = Y) :
    CommaMorphism.left (eqToHom H) = eqToHom (by cases H; rfl) := by
  cases H
  

Proof state:
case refl
A : Type u₁
inst✝² : Category.{v₁, u₁} A
B : Type u₂
inst✝¹ : Category.{v₂, u₂} B
T : Type u₃
inst✝ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
X : Comma L R
⊢ (eqToHom (_ : X = X)).left = eqToHom (_ : X.left = X.left)

Next tactic:
rfl
@[simp]
theorem eqToHom_right (X Y : Comma L R) (H : X = Y) :
    CommaMorphism.right (eqToHom H) = eqToHom (by 

Proof state:
A : Type u₁
inst✝² : Category.{v₁, u₁} A
B : Type u₂
inst✝¹ : Category.{v₂, u₂} B
T : Type u₃
inst✝ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
X Y : Comma L R
H : X = Y
⊢ X.right = Y.right

Next tactic:
cases H
@[simp]
theorem eqToHom_right (X Y : Comma L R) (H : X = Y) :
    CommaMorphism.right (eqToHom H) = eqToHom (by cases H; 

Proof state:
case refl
A : Type u₁
inst✝² : Category.{v₁, u₁} A
B : Type u₂
inst✝¹ : Category.{v₂, u₂} B
T : Type u₃
inst✝ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
X : Comma L R
⊢ X.right = X.right

Next tactic:
rfl
@[simp]
theorem eqToHom_right (X Y : Comma L R) (H : X = Y) :
    CommaMorphism.right (eqToHom H) = eqToHom (by cases H; rfl) := by
  

Proof state:
A : Type u₁
inst✝² : Category.{v₁, u₁} A
B : Type u₂
inst✝¹ : Category.{v₂, u₂} B
T : Type u₃
inst✝ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
X Y : Comma L R
H : X = Y
⊢ (eqToHom H).right = eqToHom (_ : X.right = Y.right)

Next tactic:
cases H
@[simp]
theorem eqToHom_right (X Y : Comma L R) (H : X = Y) :
    CommaMorphism.right (eqToHom H) = eqToHom (by cases H; rfl) := by
  cases H
  

Proof state:
case refl
A : Type u₁
inst✝² : Category.{v₁, u₁} A
B : Type u₂
inst✝¹ : Category.{v₂, u₂} B
T : Type u₃
inst✝ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
X : Comma L R
⊢ (eqToHom (_ : X = X)).right = eqToHom (_ : X.right = X.right)

Next tactic:
rfl
/-- Construct an isomorphism in the comma category given isomorphisms of the objects whose forward
directions give a commutative square.
-/
@[simps]
def isoMk {X Y : Comma L₁ R₁} (l : X.left ≅ Y.left) (r : X.right ≅ Y.right)
    (h : L₁.map l.hom ≫ Y.hom = X.hom ≫ R₁.map r.hom := by aesop_cat) : X ≅ Y where
  hom :=
    { left := l.hom
      right := r.hom
      w := h }
  inv :=
    { left := l.inv
      right := r.inv
      w := by
        

Proof state:
A : Type u₁
inst✝² : Category.{v₁, u₁} A
B : Type u₂
inst✝¹ : Category.{v₂, u₂} B
T : Type u₃
inst✝ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
L₁ L₂ L₃ : A ⥤ T
R₁ R₂ R₃ : B ⥤ T
X Y : Comma L₁ R₁
l : X.left ≅ Y.left
r : X.right ≅ Y.right
h : autoParam (L₁.map l.hom ≫ Y.hom = X.hom ≫ R₁.map r.hom) _auto✝
⊢ L₁.map l.inv ≫ X.hom = Y.hom ≫ R₁.map r.inv

Next tactic:
rw [← L₁.mapIso_inv l, Iso.inv_comp_eq, L₁.mapIso_hom, ← Category.assoc, h,
          Category.assoc, ← R₁.map_comp]
/-- Construct an isomorphism in the comma category given isomorphisms of the objects whose forward
directions give a commutative square.
-/
@[simps]
def isoMk {X Y : Comma L₁ R₁} (l : X.left ≅ Y.left) (r : X.right ≅ Y.right)
    (h : L₁.map l.hom ≫ Y.hom = X.hom ≫ R₁.map r.hom := by aesop_cat) : X ≅ Y where
  hom :=
    { left := l.hom
      right := r.hom
      w := h }
  inv :=
    { left := l.inv
      right := r.inv
      w := by
        rw [← L₁.mapIso_inv l, Iso.inv_comp_eq, L₁.mapIso_hom, ← Category.assoc, h,
          Category.assoc, ← R₁.map_comp]
        

Proof state:
A : Type u₁
inst✝² : Category.{v₁, u₁} A
B : Type u₂
inst✝¹ : Category.{v₂, u₂} B
T : Type u₃
inst✝ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
L₁ L₂ L₃ : A ⥤ T
R₁ R₂ R₃ : B ⥤ T
X Y : Comma L₁ R₁
l : X.left ≅ Y.left
r : X.right ≅ Y.right
h : autoParam (L₁.map l.hom ≫ Y.hom = X.hom ≫ R₁.map r.hom) _auto✝
⊢ X.hom = X.hom ≫ R₁.map (r.hom ≫ r.inv)

Next tactic:
simp
/-- Two equal natural transformations `L₁ ⟶ L₂` yield naturally isomorphic functors
    `Comma L₁ R ⥤ Comma L₂ R`. -/
@[simps!]
def mapLeftEq (l l' : L₁ ⟶ L₂) (h : l = l') : mapLeft R l ≅ mapLeft R l' :=
  NatIso.ofComponents (fun X => isoMk (Iso.refl _) (Iso.refl _) (by 

Proof state:
A : Type u₁
inst✝² : Category.{v₁, u₁} A
B : Type u₂
inst✝¹ : Category.{v₂, u₂} B
T : Type u₃
inst✝ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
L₁ L₂ L₃ : A ⥤ T
R₁ R₂ R₃ : B ⥤ T
l l' : L₁ ⟶ L₂
h : l = l'
X : Comma L₂ R
⊢ L₁.map (Iso.refl ((mapLeft R l).obj X).left).hom ≫ ((mapLeft R l').obj X).hom =
    ((mapLeft R l).obj X).hom ≫ R.map (Iso.refl ((mapLeft R l).obj X).right).hom

Next tactic:
aesop_cat
/-- Two equal natural transformations `L₁ ⟶ L₂` yield naturally isomorphic functors
    `Comma L₁ R ⥤ Comma L₂ R`. -/
@[simps!]
def mapLeftEq (l l' : L₁ ⟶ L₂) (h : l = l') : mapLeft R l ≅ mapLeft R l' :=
  NatIso.ofComponents (fun X => isoMk (Iso.refl _) (Iso.refl _) (by aesop_cat)) (by 

Proof state:
A : Type u₁
inst✝² : Category.{v₁, u₁} A
B : Type u₂
inst✝¹ : Category.{v₂, u₂} B
T : Type u₃
inst✝ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
L₁ L₂ L₃ : A ⥤ T
R₁ R₂ R₃ : B ⥤ T
l l' : L₁ ⟶ L₂
h : l = l'
⊢ ∀ {X Y : Comma L₂ R} (f : X ⟶ Y),
    (mapLeft R l).map f ≫
        ((fun X => isoMk (Iso.refl ((mapLeft R l).obj X).left) (Iso.refl ((mapLeft R l).obj X).right)) Y).hom =
      ((fun X => isoMk (Iso.refl ((mapLeft R l).obj X).left) (Iso.refl ((mapLeft R l).obj X).right)) X).hom ≫
        (mapLeft R l').map f

Next tactic:
aesop_cat
/-- Two equal natural transformations `R₁ ⟶ R₂` yield naturally isomorphic functors
    `Comma L R₁ ⥤ Comma L R₂`. -/
@[simps!]
def mapRightEq (r r' : R₁ ⟶ R₂) (h : r = r') : mapRight L r ≅ mapRight L r' :=
  NatIso.ofComponents (fun X => isoMk (Iso.refl _) (Iso.refl _) (by 

Proof state:
A : Type u₁
inst✝² : Category.{v₁, u₁} A
B : Type u₂
inst✝¹ : Category.{v₂, u₂} B
T : Type u₃
inst✝ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
L₁ L₂ L₃ : A ⥤ T
R₁ R₂ R₃ : B ⥤ T
r r' : R₁ ⟶ R₂
h : r = r'
X : Comma L R₁
⊢ L.map (Iso.refl ((mapRight L r).obj X).left).hom ≫ ((mapRight L r').obj X).hom =
    ((mapRight L r).obj X).hom ≫ R₂.map (Iso.refl ((mapRight L r).obj X).right).hom

Next tactic:
aesop_cat
/-- Two equal natural transformations `R₁ ⟶ R₂` yield naturally isomorphic functors
    `Comma L R₁ ⥤ Comma L R₂`. -/
@[simps!]
def mapRightEq (r r' : R₁ ⟶ R₂) (h : r = r') : mapRight L r ≅ mapRight L r' :=
  NatIso.ofComponents (fun X => isoMk (Iso.refl _) (Iso.refl _) (by aesop_cat)) (by 

Proof state:
A : Type u₁
inst✝² : Category.{v₁, u₁} A
B : Type u₂
inst✝¹ : Category.{v₂, u₂} B
T : Type u₃
inst✝ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
L₁ L₂ L₃ : A ⥤ T
R₁ R₂ R₃ : B ⥤ T
r r' : R₁ ⟶ R₂
h : r = r'
⊢ ∀ {X Y : Comma L R₁} (f : X ⟶ Y),
    (mapRight L r).map f ≫
        ((fun X => isoMk (Iso.refl ((mapRight L r).obj X).left) (Iso.refl ((mapRight L r).obj X).right)) Y).hom =
      ((fun X => isoMk (Iso.refl ((mapRight L r).obj X).left) (Iso.refl ((mapRight L r).obj X).right)) X).hom ≫
        (mapRight L r').map f

Next tactic:
aesop_cat
/-- The functor `(F ⋙ L, R) ⥤ (L, R)` -/
@[simps]
def preLeft (F : C ⥤ A) (L : A ⥤ T) (R : B ⥤ T) : Comma (F ⋙ L) R ⥤ Comma L R where
  obj X :=
    { left := F.obj X.left
      right := X.right
      hom := X.hom }
  map f :=
    { left := F.map f.left
      right := f.right
      w := by 

Proof state:
A : Type u₁
inst✝⁴ : Category.{v₁, u₁} A
B : Type u₂
inst✝³ : Category.{v₂, u₂} B
T : Type u₃
inst✝² : Category.{v₃, u₃} T
L✝ : A ⥤ T
R✝ : B ⥤ T
C : Type u₄
inst✝¹ : Category.{v₄, u₄} C
D : Type u₅
inst✝ : Category.{v₅, u₅} D
F : C ⥤ A
L : A ⥤ T
R : B ⥤ T
X✝ Y✝ : Comma (F ⋙ L) R
f : X✝ ⟶ Y✝
⊢ L.map (F.map f.left) ≫ ((fun X => { left := F.obj X.left, right := X.right, hom := X.hom }) Y✝).hom =
    ((fun X => { left := F.obj X.left, right := X.right, hom := X.hom }) X✝).hom ≫ R.map f.right

Next tactic:
simpa using f.w
instance (F : C ⥤ A) (L : A ⥤ T) (R : B ⥤ T) [Faithful F] : Faithful (preLeft F L R) where
  map_injective {X Y} f g h := hom_ext _ _ (F.map_injective (congrArg CommaMorphism.left h))
    (by 

Proof state:
A : Type u₁
inst✝⁵ : Category.{v₁, u₁} A
B : Type u₂
inst✝⁴ : Category.{v₂, u₂} B
T : Type u₃
inst✝³ : Category.{v₃, u₃} T
L✝ : A ⥤ T
R✝ : B ⥤ T
C : Type u₄
inst✝² : Category.{v₄, u₄} C
D : Type u₅
inst✝¹ : Category.{v₅, u₅} D
F : C ⥤ A
L : A ⥤ T
R : B ⥤ T
inst✝ : Faithful F
X Y : Comma (F ⋙ L) R
f g : X ⟶ Y
h : (preLeft F L R).map f = (preLeft F L R).map g
⊢ f.right = g.right

Next tactic:
apply congrArg CommaMorphism.right h
instance (F : C ⥤ A) (L : A ⥤ T) (R : B ⥤ T) [Full F] : Full (preLeft F L R) where
  preimage {X Y} f := CommaMorphism.mk (F.preimage f.left) f.right (by 

Proof state:
A : Type u₁
inst✝⁵ : Category.{v₁, u₁} A
B : Type u₂
inst✝⁴ : Category.{v₂, u₂} B
T : Type u₃
inst✝³ : Category.{v₃, u₃} T
L✝ : A ⥤ T
R✝ : B ⥤ T
C : Type u₄
inst✝² : Category.{v₄, u₄} C
D : Type u₅
inst✝¹ : Category.{v₅, u₅} D
F : C ⥤ A
L : A ⥤ T
R : B ⥤ T
inst✝ : Full F
X Y : Comma (F ⋙ L) R
f : (preLeft F L R).obj X ⟶ (preLeft F L R).obj Y
⊢ (F ⋙ L).map (F.preimage f.left) ≫ Y.hom = X.hom ≫ R.map f.right

Next tactic:
simpa using f.w
instance (F : C ⥤ A) (L : A ⥤ T) (R : B ⥤ T) [EssSurj F] : EssSurj (preLeft F L R) where
  mem_essImage Y :=
    ⟨Comma.mk (F.objPreimage Y.left) Y.right ((L.mapIso (F.objObjPreimageIso _)).hom ≫ Y.hom),
     ⟨isoMk (F.objObjPreimageIso _) (Iso.refl _) (by 

Proof state:
A : Type u₁
inst✝⁵ : Category.{v₁, u₁} A
B : Type u₂
inst✝⁴ : Category.{v₂, u₂} B
T : Type u₃
inst✝³ : Category.{v₃, u₃} T
L✝ : A ⥤ T
R✝ : B ⥤ T
C : Type u₄
inst✝² : Category.{v₄, u₄} C
D : Type u₅
inst✝¹ : Category.{v₅, u₅} D
F : C ⥤ A
L : A ⥤ T
R : B ⥤ T
inst✝ : EssSurj F
Y : Comma L R
⊢ L.map (Functor.objObjPreimageIso F Y.left).hom ≫ Y.hom =
    ((preLeft F L R).obj
          { left := Functor.objPreimage F Y.left, right := Y.right,
            hom := (L.mapIso (Functor.objObjPreimageIso F Y.left)).hom ≫ Y.hom }).hom ≫
      R.map
        (Iso.refl
            ((preLeft F L R).obj
                { left := Functor.objPreimage F Y.left, right := Y.right,
                  hom := (L.mapIso (Functor.objObjPreimageIso F Y.left)).hom ≫ Y.hom }).right).hom

Next tactic:
simp
instance (L : A ⥤ T) (F : C ⥤ B) (R : B ⥤ T) [Faithful F] : Faithful (preRight L F R) where
  map_injective {X Y } f g h := hom_ext _ _ (by 

Proof state:
A : Type u₁
inst✝⁵ : Category.{v₁, u₁} A
B : Type u₂
inst✝⁴ : Category.{v₂, u₂} B
T : Type u₃
inst✝³ : Category.{v₃, u₃} T
L✝ : A ⥤ T
R✝ : B ⥤ T
C : Type u₄
inst✝² : Category.{v₄, u₄} C
D : Type u₅
inst✝¹ : Category.{v₅, u₅} D
L : A ⥤ T
F : C ⥤ B
R : B ⥤ T
inst✝ : Faithful F
X Y : Comma L (F ⋙ R)
f g : X ⟶ Y
h : (preRight L F R).map f = (preRight L F R).map g
⊢ f.left = g.left

Next tactic:
apply congrArg CommaMorphism.left h
instance (L : A ⥤ T) (F : C ⥤ B) (R : B ⥤ T) [Full F] : Full (preRight L F R) where
  preimage {X Y} f := CommaMorphism.mk f.left (F.preimage f.right) (by 

Proof state:
A : Type u₁
inst✝⁵ : Category.{v₁, u₁} A
B : Type u₂
inst✝⁴ : Category.{v₂, u₂} B
T : Type u₃
inst✝³ : Category.{v₃, u₃} T
L✝ : A ⥤ T
R✝ : B ⥤ T
C : Type u₄
inst✝² : Category.{v₄, u₄} C
D : Type u₅
inst✝¹ : Category.{v₅, u₅} D
L : A ⥤ T
F : C ⥤ B
R : B ⥤ T
inst✝ : Full F
X Y : Comma L (F ⋙ R)
f : (preRight L F R).obj X ⟶ (preRight L F R).obj Y
⊢ L.map f.left ≫ Y.hom = X.hom ≫ (F ⋙ R).map (F.preimage f.right)

Next tactic:
simpa using f.w
instance (L : A ⥤ T) (F : C ⥤ B) (R : B ⥤ T) [EssSurj F] : EssSurj (preRight L F R) where
  mem_essImage Y :=
    ⟨Comma.mk Y.left (F.objPreimage Y.right) (Y.hom ≫ (R.mapIso (F.objObjPreimageIso _)).inv),
     ⟨isoMk (Iso.refl _) (F.objObjPreimageIso _) (by 

Proof state:
A : Type u₁
inst✝⁵ : Category.{v₁, u₁} A
B : Type u₂
inst✝⁴ : Category.{v₂, u₂} B
T : Type u₃
inst✝³ : Category.{v₃, u₃} T
L✝ : A ⥤ T
R✝ : B ⥤ T
C : Type u₄
inst✝² : Category.{v₄, u₄} C
D : Type u₅
inst✝¹ : Category.{v₅, u₅} D
L : A ⥤ T
F : C ⥤ B
R : B ⥤ T
inst✝ : EssSurj F
Y : Comma L R
⊢ L.map
        (Iso.refl
            ((preRight L F R).obj
                { left := Y.left, right := Functor.objPreimage F Y.right,
                  hom := Y.hom ≫ (R.mapIso (Functor.objObjPreimageIso F Y.right)).inv }).left).hom ≫
      Y.hom =
    ((preRight L F R).obj
          { left := Y.left, right := Functor.objPreimage F Y.right,
            hom := Y.hom ≫ (R.mapIso (Functor.objObjPreimageIso F Y.right)).inv }).hom ≫
      R.map (Functor.objObjPreimageIso F Y.right).hom

Next tactic:
simp [← R.map_comp]
/-- The functor `(L, R) ⥤ (L ⋙ F, R ⋙ F)` -/
@[simps]
def post (L : A ⥤ T) (R : B ⥤ T) (F : T ⥤ C) : Comma L R ⥤ Comma (L ⋙ F) (R ⋙ F) where
  obj X :=
    { left := X.left
      right := X.right
      hom := F.map X.hom }
  map f :=
    { left := f.left
      right := f.right
      w := by 

Proof state:
A : Type u₁
inst✝⁴ : Category.{v₁, u₁} A
B : Type u₂
inst✝³ : Category.{v₂, u₂} B
T : Type u₃
inst✝² : Category.{v₃, u₃} T
L✝ : A ⥤ T
R✝ : B ⥤ T
C : Type u₄
inst✝¹ : Category.{v₄, u₄} C
D : Type u₅
inst✝ : Category.{v₅, u₅} D
L : A ⥤ T
R : B ⥤ T
F : T ⥤ C
X✝ Y✝ : Comma L R
f : X✝ ⟶ Y✝
⊢ (L ⋙ F).map f.left ≫ ((fun X => { left := X.left, right := X.right, hom := F.map X.hom }) Y✝).hom =
    ((fun X => { left := X.left, right := X.right, hom := F.map X.hom }) X✝).hom ≫ (R ⋙ F).map f.right

Next tactic:
simp only [Functor.comp_map, ← F.map_comp, f.w]
nonrec theorem HasDerivAtFilter.add (hf : HasDerivAtFilter f f' x L)
    (hg : HasDerivAtFilter g g' x L) : HasDerivAtFilter (fun y => f y + g y) (f' + g') x L := by
  

Proof state:
𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
hf : HasDerivAtFilter f f' x L
hg : HasDerivAtFilter g g' x L
⊢ HasDerivAtFilter (fun y => f y + g y) (f' + g') x L

Next tactic:
simpa using (hf.add hg).hasDerivAtFilter
nonrec theorem HasStrictDerivAt.add (hf : HasStrictDerivAt f f' x) (hg : HasStrictDerivAt g g' x) :
    HasStrictDerivAt (fun y => f y + g y) (f' + g') x := by 

Proof state:
𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
hf : HasStrictDerivAt f f' x
hg : HasStrictDerivAt g g' x
⊢ HasStrictDerivAt (fun y => f y + g y) (f' + g') x

Next tactic:
simpa using (hf.add hg).hasStrictDerivAt
theorem derivWithin_add_const (hxs : UniqueDiffWithinAt 𝕜 s x) (c : F) :
    derivWithin (fun y => f y + c) s x = derivWithin f s x := by
  

Proof state:
𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
hxs : UniqueDiffWithinAt 𝕜 s x
c : F
⊢ derivWithin (fun y => f y + c) s x = derivWithin f s x

Next tactic:
simp only [derivWithin, fderivWithin_add_const hxs]
theorem deriv_add_const (c : F) : deriv (fun y => f y + c) x = deriv f x := by
  

Proof state:
𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
c : F
⊢ deriv (fun y => f y + c) x = deriv f x

Next tactic:
simp only [deriv, fderiv_add_const]
theorem derivWithin_const_add (hxs : UniqueDiffWithinAt 𝕜 s x) (c : F) :
    derivWithin (fun y => c + f y) s x = derivWithin f s x := by
  

Proof state:
𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
hxs : UniqueDiffWithinAt 𝕜 s x
c : F
⊢ derivWithin (fun y => c + f y) s x = derivWithin f s x

Next tactic:
simp only [derivWithin, fderivWithin_const_add hxs]
theorem deriv_const_add (c : F) : deriv (fun y => c + f y) x = deriv f x := by
  

Proof state:
𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
c : F
⊢ deriv (fun y => c + f y) x = deriv f x

Next tactic:
simp only [deriv, fderiv_const_add]
theorem HasDerivAtFilter.sum (h : ∀ i ∈ u, HasDerivAtFilter (A i) (A' i) x L) :
    HasDerivAtFilter (fun y => ∑ i in u, A i y) (∑ i in u, A' i) x L := by
  

Proof state:
𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
ι : Type u_1
u : Finset ι
A : ι → 𝕜 → F
A' : ι → F
h : ∀ i ∈ u, HasDerivAtFilter (A i) (A' i) x L
⊢ HasDerivAtFilter (fun y => ∑ i in u, A i y) (∑ i in u, A' i) x L

Next tactic:
simpa [ContinuousLinearMap.sum_apply] using (HasFDerivAtFilter.sum h).hasDerivAtFilter