[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
J : Type w
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
inst✝ : HasFiniteLimits C
⊢ HasLimitsOfShape J C
[PROOFSTEP]
apply @hasLimitsOfShape_of_equivalence _ _ _ _ _ _ (FinCategory.equivAsType J) ?_
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
J : Type w
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
inst✝ : HasFiniteLimits C
⊢ HasLimitsOfShape (FinCategory.AsType J) C
[PROOFSTEP]
apply HasFiniteLimits.out
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
h : ∀ (J : Type w) {𝒥 : SmallCategory J}, FinCategory J → HasLimitsOfShape J C
J : Type
hJ : SmallCategory J
hhJ : FinCategory J
⊢ HasLimitsOfShape J C
[PROOFSTEP]
haveI := h (ULiftHom.{w} (ULift.{w} J)) <| @CategoryTheory.finCategoryUlift J hJ hhJ
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
h : ∀ (J : Type w) {𝒥 : SmallCategory J}, FinCategory J → HasLimitsOfShape J C
J : Type
hJ : SmallCategory J
hhJ : FinCategory J
this : HasLimitsOfShape (ULiftHom (ULift J)) C
⊢ HasLimitsOfShape J C
[PROOFSTEP]
have l : @Equivalence J (ULiftHom (ULift J)) hJ (@ULiftHom.category (ULift J) (@uliftCategory J hJ)) :=
  @ULiftHomULiftCategory.equiv J hJ
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
h : ∀ (J : Type w) {𝒥 : SmallCategory J}, FinCategory J → HasLimitsOfShape J C
J : Type
hJ : SmallCategory J
hhJ : FinCategory J
this : HasLimitsOfShape (ULiftHom (ULift J)) C
l : J ≌ ULiftHom (ULift J)
⊢ HasLimitsOfShape J C
[PROOFSTEP]
apply
  @hasLimitsOfShape_of_equivalence (ULiftHom (ULift J)) (@ULiftHom.category (ULift J) (@uliftCategory J hJ)) C _ J hJ
    (@Equivalence.symm J hJ (ULiftHom (ULift J)) (@ULiftHom.category (ULift J) (@uliftCategory J hJ)) l)
    _
      /- Porting note: tried to factor out (@instCategoryULiftHom (ULift J) (@uliftCategory J hJ)
          but when doing that would then find the instance and say it was not definitionally equal to
          the provided one (the same thing factored out) -/
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
J : Type w
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
inst✝ : HasFiniteColimits C
⊢ HasColimitsOfShape J C
[PROOFSTEP]
refine @hasColimitsOfShape_of_equivalence _ _ _ _ _ _ (FinCategory.equivAsType J) ?_
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
J : Type w
inst✝² : SmallCategory J
inst✝¹ : FinCategory J
inst✝ : HasFiniteColimits C
⊢ HasColimitsOfShape (FinCategory.AsType J) C
[PROOFSTEP]
apply HasFiniteColimits.out
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
h : ∀ (J : Type w) {𝒥 : SmallCategory J}, FinCategory J → HasColimitsOfShape J C
J : Type
hJ : SmallCategory J
hhJ : FinCategory J
⊢ HasColimitsOfShape J C
[PROOFSTEP]
haveI := h (ULiftHom.{w} (ULift.{w} J)) <| @CategoryTheory.finCategoryUlift J hJ hhJ
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
h : ∀ (J : Type w) {𝒥 : SmallCategory J}, FinCategory J → HasColimitsOfShape J C
J : Type
hJ : SmallCategory J
hhJ : FinCategory J
this : HasColimitsOfShape (ULiftHom (ULift J)) C
⊢ HasColimitsOfShape J C
[PROOFSTEP]
have l : @Equivalence J (ULiftHom (ULift J)) hJ (@ULiftHom.category (ULift J) (@uliftCategory J hJ)) :=
  @ULiftHomULiftCategory.equiv J hJ
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
h : ∀ (J : Type w) {𝒥 : SmallCategory J}, FinCategory J → HasColimitsOfShape J C
J : Type
hJ : SmallCategory J
hhJ : FinCategory J
this : HasColimitsOfShape (ULiftHom (ULift J)) C
l : J ≌ ULiftHom (ULift J)
⊢ HasColimitsOfShape J C
[PROOFSTEP]
apply
  @hasColimitsOfShape_of_equivalence (ULiftHom (ULift J)) (@ULiftHom.category (ULift J) (@uliftCategory J hJ)) C _ J hJ
    (@Equivalence.symm J hJ (ULiftHom (ULift J)) (@ULiftHom.category (ULift J) (@uliftCategory J hJ)) l) _
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
x : WalkingParallelPair
⊢ x ∈ List.toFinset [zero, one]
[PROOFSTEP]
cases x
[GOAL]
case zero
C : Type u
inst✝ : Category.{v, u} C
⊢ zero ∈ List.toFinset [zero, one]
[PROOFSTEP]
simp
[GOAL]
case one
C : Type u
inst✝ : Category.{v, u} C
⊢ one ∈ List.toFinset [zero, one]
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
j j' : WalkingParallelPair
⊢ ∀ (x : WalkingParallelPairHom j j'),
    x ∈
      WalkingParallelPair.recOn j
        (WalkingParallelPair.recOn j' (List.toFinset [WalkingParallelPairHom.id zero]) (List.toFinset [left, right]))
        (WalkingParallelPair.recOn j' ∅ (List.toFinset [WalkingParallelPairHom.id one]))
[PROOFSTEP]
rintro (_ | _)
[GOAL]
case left
C : Type u
inst✝ : Category.{v, u} C
⊢ left ∈
    WalkingParallelPair.recOn zero
      (WalkingParallelPair.recOn one (List.toFinset [WalkingParallelPairHom.id zero]) (List.toFinset [left, right]))
      (WalkingParallelPair.recOn one ∅ (List.toFinset [WalkingParallelPairHom.id one]))
[PROOFSTEP]
simp
[GOAL]
case right
C : Type u
inst✝ : Category.{v, u} C
⊢ right ∈
    WalkingParallelPair.recOn zero
      (WalkingParallelPair.recOn one (List.toFinset [WalkingParallelPairHom.id zero]) (List.toFinset [left, right]))
      (WalkingParallelPair.recOn one ∅ (List.toFinset [WalkingParallelPairHom.id one]))
[PROOFSTEP]
simp
[GOAL]
case id
C : Type u
inst✝ : Category.{v, u} C
j : WalkingParallelPair
⊢ WalkingParallelPairHom.id j ∈
    WalkingParallelPair.recOn j
      (WalkingParallelPair.recOn j (List.toFinset [WalkingParallelPairHom.id zero]) (List.toFinset [left, right]))
      (WalkingParallelPair.recOn j ∅ (List.toFinset [WalkingParallelPairHom.id one]))
[PROOFSTEP]
simp
[GOAL]
case id
C : Type u
inst✝ : Category.{v, u} C
j : WalkingParallelPair
⊢ 𝟙 j ∈
    WalkingParallelPair.rec (WalkingParallelPair.rec {𝟙 zero} {left, right} j) (WalkingParallelPair.rec ∅ {𝟙 one} j) j
[PROOFSTEP]
cases j
[GOAL]
case id.zero
C : Type u
inst✝ : Category.{v, u} C
⊢ 𝟙 zero ∈
    WalkingParallelPair.rec (WalkingParallelPair.rec {𝟙 zero} {left, right} zero)
      (WalkingParallelPair.rec ∅ {𝟙 one} zero) zero
[PROOFSTEP]
simp
[GOAL]
case id.one
C : Type u
inst✝ : Category.{v, u} C
⊢ 𝟙 one ∈
    WalkingParallelPair.rec (WalkingParallelPair.rec {𝟙 zero} {left, right} one) (WalkingParallelPair.rec ∅ {𝟙 one} one)
      one
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasFiniteLimits C
⊢ HasEqualizers C
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasFiniteColimits C
⊢ HasCoequalizers C
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
J : Type v
inst✝ : Fintype J
⊢ Fintype (WidePullbackShape J)
[PROOFSTEP]
rw [WidePullbackShape]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
J : Type v
inst✝ : Fintype J
⊢ Fintype (Option J)
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
J : Type v
j j' : WidePullbackShape J
⊢ Finset (j ⟶ j')
[PROOFSTEP]
cases' j' with j'
[GOAL]
case none
C : Type u
inst✝ : Category.{v, u} C
J : Type v
j : WidePullbackShape J
⊢ Finset (j ⟶ none)
[PROOFSTEP]
cases' j with j
[GOAL]
case none.none
C : Type u
inst✝ : Category.{v, u} C
J : Type v
⊢ Finset (none ⟶ none)
[PROOFSTEP]
exact {Hom.id none}
[GOAL]
case none.some
C : Type u
inst✝ : Category.{v, u} C
J : Type v
j : J
⊢ Finset (some j ⟶ none)
[PROOFSTEP]
exact {Hom.term j}
[GOAL]
case some
C : Type u
inst✝ : Category.{v, u} C
J : Type v
j : WidePullbackShape J
j' : J
⊢ Finset (j ⟶ some j')
[PROOFSTEP]
by_cases some j' = j
[GOAL]
case some
C : Type u
inst✝ : Category.{v, u} C
J : Type v
j : WidePullbackShape J
j' : J
⊢ Finset (j ⟶ some j')
[PROOFSTEP]
by_cases some j' = j
[GOAL]
case pos
C : Type u
inst✝ : Category.{v, u} C
J : Type v
j : WidePullbackShape J
j' : J
h : some j' = j
⊢ Finset (j ⟶ some j')
[PROOFSTEP]
rw [h]
[GOAL]
case pos
C : Type u
inst✝ : Category.{v, u} C
J : Type v
j : WidePullbackShape J
j' : J
h : some j' = j
⊢ Finset (j ⟶ j)
[PROOFSTEP]
exact {Hom.id j}
[GOAL]
case neg
C : Type u
inst✝ : Category.{v, u} C
J : Type v
j : WidePullbackShape J
j' : J
h : ¬some j' = j
⊢ Finset (j ⟶ some j')
[PROOFSTEP]
exact ∅
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
J : Type v
j j' : WidePullbackShape J
⊢ ∀ (x : j ⟶ j'),
    x ∈
      Option.casesOn (motive := fun t => j' = t → Finset (j ⟶ j')) j'
        (fun h =>
          (_ : none = j') ▸
            Option.casesOn (motive := fun t => j = t → Finset (j ⟶ none)) j (fun h => (_ : none = j) ▸ {Hom.id none})
              (fun j_1 h => (_ : some j_1 = j) ▸ {Hom.term j_1}) (_ : j = j))
        (fun j'_1 h =>
          (_ : some j'_1 = j') ▸
            if h : some j'_1 = j then Eq.mpr (_ : Finset (j ⟶ some j'_1) = Finset (j ⟶ j)) {Hom.id j} else ∅)
        (_ : j' = j')
[PROOFSTEP]
rintro (_ | _)
[GOAL]
case id
C : Type u
inst✝ : Category.{v, u} C
J : Type v
j : WidePullbackShape J
⊢ Hom.id j ∈
    Option.casesOn (motive := fun t => j = t → Finset (j ⟶ j)) j
      (fun h =>
        (_ : none = j) ▸
          Option.casesOn (motive := fun t => j = t → Finset (j ⟶ none)) j (fun h => (_ : none = j) ▸ {Hom.id none})
            (fun j_1 h => (_ : some j_1 = j) ▸ {Hom.term j_1}) (_ : j = j))
      (fun j' h =>
        (_ : some j' = j) ▸
          if h : some j' = j then Eq.mpr (_ : Finset (j ⟶ some j') = Finset (j ⟶ j)) {Hom.id j} else ∅)
      (_ : j = j)
[PROOFSTEP]
cases j
[GOAL]
case id.none
C : Type u
inst✝ : Category.{v, u} C
J : Type v
⊢ Hom.id none ∈
    Option.casesOn (motive := fun t => none = t → Finset (none ⟶ none)) none
      (fun h =>
        (_ : none = none) ▸
          Option.casesOn (motive := fun t => none = t → Finset (none ⟶ none)) none
            (fun h => (_ : none = none) ▸ {Hom.id none}) (fun j h => (_ : some j = none) ▸ {Hom.term j})
            (_ : none = none))
      (fun j' h =>
        (_ : some j' = none) ▸
          if h : some j' = none then Eq.mpr (_ : Finset (none ⟶ some j') = Finset (none ⟶ none)) {Hom.id none} else ∅)
      (_ : none = none)
[PROOFSTEP]
simp
[GOAL]
case id.some
C : Type u
inst✝ : Category.{v, u} C
J : Type v
val✝ : J
⊢ Hom.id (some val✝) ∈
    Option.casesOn (motive := fun t => some val✝ = t → Finset (some val✝ ⟶ some val✝)) (some val✝)
      (fun h =>
        (_ : none = some val✝) ▸
          Option.casesOn (motive := fun t => some val✝ = t → Finset (some val✝ ⟶ none)) (some val✝)
            (fun h => (_ : none = some val✝) ▸ {Hom.id none}) (fun j h => (_ : some j = some val✝) ▸ {Hom.term j})
            (_ : some val✝ = some val✝))
      (fun j' h =>
        (_ : some j' = some val✝) ▸
          if h : some j' = some val✝ then
            Eq.mpr (_ : Finset (some val✝ ⟶ some j') = Finset (some val✝ ⟶ some val✝)) {Hom.id (some val✝)}
          else ∅)
      (_ : some val✝ = some val✝)
[PROOFSTEP]
simp
[GOAL]
case term
C : Type u
inst✝ : Category.{v, u} C
J : Type v
j✝ : J
⊢ Hom.term j✝ ∈
    Option.casesOn (motive := fun t => none = t → Finset (some j✝ ⟶ none)) none
      (fun h =>
        (_ : none = none) ▸
          Option.casesOn (motive := fun t => some j✝ = t → Finset (some j✝ ⟶ none)) (some j✝)
            (fun h => (_ : none = some j✝) ▸ {Hom.id none}) (fun j h => (_ : some j = some j✝) ▸ {Hom.term j})
            (_ : some j✝ = some j✝))
      (fun j' h =>
        (_ : some j' = none) ▸
          if h : some j' = some j✝ then
            Eq.mpr (_ : Finset (some j✝ ⟶ some j') = Finset (some j✝ ⟶ some j✝)) {Hom.id (some j✝)}
          else ∅)
      (_ : none = none)
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
J : Type v
inst✝ : Fintype J
⊢ Fintype (WidePushoutShape J)
[PROOFSTEP]
rw [WidePushoutShape]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
J : Type v
inst✝ : Fintype J
⊢ Fintype (Option J)
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
J : Type v
j j' : WidePushoutShape J
⊢ Finset (j ⟶ j')
[PROOFSTEP]
cases' j with j
[GOAL]
case none
C : Type u
inst✝ : Category.{v, u} C
J : Type v
j' : WidePushoutShape J
⊢ Finset (none ⟶ j')
[PROOFSTEP]
cases' j' with j'
[GOAL]
case none.none
C : Type u
inst✝ : Category.{v, u} C
J : Type v
⊢ Finset (none ⟶ none)
[PROOFSTEP]
exact {Hom.id none}
[GOAL]
case none.some
C : Type u
inst✝ : Category.{v, u} C
J : Type v
j' : J
⊢ Finset (none ⟶ some j')
[PROOFSTEP]
exact {Hom.init j'}
[GOAL]
case some
C : Type u
inst✝ : Category.{v, u} C
J : Type v
j' : WidePushoutShape J
j : J
⊢ Finset (some j ⟶ j')
[PROOFSTEP]
by_cases some j = j'
[GOAL]
case some
C : Type u
inst✝ : Category.{v, u} C
J : Type v
j' : WidePushoutShape J
j : J
⊢ Finset (some j ⟶ j')
[PROOFSTEP]
by_cases some j = j'
[GOAL]
case pos
C : Type u
inst✝ : Category.{v, u} C
J : Type v
j' : WidePushoutShape J
j : J
h : some j = j'
⊢ Finset (some j ⟶ j')
[PROOFSTEP]
rw [h]
[GOAL]
case pos
C : Type u
inst✝ : Category.{v, u} C
J : Type v
j' : WidePushoutShape J
j : J
h : some j = j'
⊢ Finset (j' ⟶ j')
[PROOFSTEP]
exact {Hom.id j'}
[GOAL]
case neg
C : Type u
inst✝ : Category.{v, u} C
J : Type v
j' : WidePushoutShape J
j : J
h : ¬some j = j'
⊢ Finset (some j ⟶ j')
[PROOFSTEP]
exact ∅
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
J : Type v
j j' : WidePushoutShape J
⊢ ∀ (x : j ⟶ j'),
    x ∈
      Option.casesOn (motive := fun t => j = t → Finset (j ⟶ j')) j
        (fun h =>
          (_ : none = j) ▸
            Option.casesOn (motive := fun t => j' = t → Finset (none ⟶ j')) j'
              (fun h => (_ : none = j') ▸ {Hom.id none}) (fun j'_1 h => (_ : some j'_1 = j') ▸ {Hom.init j'_1})
              (_ : j' = j'))
        (fun j_1 h =>
          (_ : some j_1 = j) ▸
            if h : some j_1 = j' then Eq.mpr (_ : Finset (some j_1 ⟶ j') = Finset (j' ⟶ j')) {Hom.id j'} else ∅)
        (_ : j = j)
[PROOFSTEP]
rintro (_ | _)
[GOAL]
case id
C : Type u
inst✝ : Category.{v, u} C
J : Type v
j : WidePushoutShape J
⊢ Hom.id j ∈
    Option.casesOn (motive := fun t => j = t → Finset (j ⟶ j)) j
      (fun h =>
        (_ : none = j) ▸
          Option.casesOn (motive := fun t => j = t → Finset (none ⟶ j)) j (fun h => (_ : none = j) ▸ {Hom.id none})
            (fun j' h => (_ : some j' = j) ▸ {Hom.init j'}) (_ : j = j))
      (fun j_1 h =>
        (_ : some j_1 = j) ▸
          if h : some j_1 = j then Eq.mpr (_ : Finset (some j_1 ⟶ j) = Finset (j ⟶ j)) {Hom.id j} else ∅)
      (_ : j = j)
[PROOFSTEP]
cases j
[GOAL]
case id.none
C : Type u
inst✝ : Category.{v, u} C
J : Type v
⊢ Hom.id none ∈
    Option.casesOn (motive := fun t => none = t → Finset (none ⟶ none)) none
      (fun h =>
        (_ : none = none) ▸
          Option.casesOn (motive := fun t => none = t → Finset (none ⟶ none)) none
            (fun h => (_ : none = none) ▸ {Hom.id none}) (fun j' h => (_ : some j' = none) ▸ {Hom.init j'})
            (_ : none = none))
      (fun j h =>
        (_ : some j = none) ▸
          if h : some j = none then Eq.mpr (_ : Finset (some j ⟶ none) = Finset (none ⟶ none)) {Hom.id none} else ∅)
      (_ : none = none)
[PROOFSTEP]
simp
[GOAL]
case id.some
C : Type u
inst✝ : Category.{v, u} C
J : Type v
val✝ : J
⊢ Hom.id (some val✝) ∈
    Option.casesOn (motive := fun t => some val✝ = t → Finset (some val✝ ⟶ some val✝)) (some val✝)
      (fun h =>
        (_ : none = some val✝) ▸
          Option.casesOn (motive := fun t => some val✝ = t → Finset (none ⟶ some val✝)) (some val✝)
            (fun h => (_ : none = some val✝) ▸ {Hom.id none}) (fun j' h => (_ : some j' = some val✝) ▸ {Hom.init j'})
            (_ : some val✝ = some val✝))
      (fun j h =>
        (_ : some j = some val✝) ▸
          if h : some j = some val✝ then
            Eq.mpr (_ : Finset (some j ⟶ some val✝) = Finset (some val✝ ⟶ some val✝)) {Hom.id (some val✝)}
          else ∅)
      (_ : some val✝ = some val✝)
[PROOFSTEP]
simp
[GOAL]
case init
C : Type u
inst✝ : Category.{v, u} C
J : Type v
j✝ : J
⊢ Hom.init j✝ ∈
    Option.casesOn (motive := fun t => none = t → Finset (none ⟶ some j✝)) none
      (fun h =>
        (_ : none = none) ▸
          Option.casesOn (motive := fun t => some j✝ = t → Finset (none ⟶ some j✝)) (some j✝)
            (fun h => (_ : none = some j✝) ▸ {Hom.id none}) (fun j' h => (_ : some j' = some j✝) ▸ {Hom.init j'})
            (_ : some j✝ = some j✝))
      (fun j h =>
        (_ : some j = none) ▸
          if h : some j = some j✝ then
            Eq.mpr (_ : Finset (some j ⟶ some j✝) = Finset (some j✝ ⟶ some j✝)) {Hom.id (some j✝)}
          else ∅)
      (_ : none = none)
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
J✝ : Type v
J : Type
inst✝¹ : Finite J
inst✝ : HasFiniteWidePullbacks C
⊢ HasLimitsOfShape (WidePullbackShape J) C
[PROOFSTEP]
cases nonempty_fintype J
[GOAL]
case intro
C : Type u
inst✝² : Category.{v, u} C
J✝ : Type v
J : Type
inst✝¹ : Finite J
inst✝ : HasFiniteWidePullbacks C
val✝ : Fintype J
⊢ HasLimitsOfShape (WidePullbackShape J) C
[PROOFSTEP]
haveI := @HasFiniteWidePullbacks.out C _ _ J
[GOAL]
case intro
C : Type u
inst✝² : Category.{v, u} C
J✝ : Type v
J : Type
inst✝¹ : Finite J
inst✝ : HasFiniteWidePullbacks C
val✝ : Fintype J
this : ∀ [inst : Fintype J], HasLimitsOfShape (WidePullbackShape J) C
⊢ HasLimitsOfShape (WidePullbackShape J) C
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
J✝ : Type v
J : Type
inst✝¹ : Finite J
inst✝ : HasFiniteWidePushouts C
⊢ HasColimitsOfShape (WidePushoutShape J) C
[PROOFSTEP]
cases nonempty_fintype J
[GOAL]
case intro
C : Type u
inst✝² : Category.{v, u} C
J✝ : Type v
J : Type
inst✝¹ : Finite J
inst✝ : HasFiniteWidePushouts C
val✝ : Fintype J
⊢ HasColimitsOfShape (WidePushoutShape J) C
[PROOFSTEP]
haveI := @HasFiniteWidePushouts.out C _ _ J
[GOAL]
case intro
C : Type u
inst✝² : Category.{v, u} C
J✝ : Type v
J : Type
inst✝¹ : Finite J
inst✝ : HasFiniteWidePushouts C
val✝ : Fintype J
this : ∀ [inst : Fintype J], HasColimitsOfShape (WidePushoutShape J) C
⊢ HasColimitsOfShape (WidePushoutShape J) C
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
J : Type v
x : WalkingPair
⊢ x ∈ {WalkingPair.left, WalkingPair.right}
[PROOFSTEP]
cases x
[GOAL]
case left
C : Type u
inst✝ : Category.{v, u} C
J : Type v
⊢ WalkingPair.left ∈ {WalkingPair.left, WalkingPair.right}
[PROOFSTEP]
simp
[GOAL]
case right
C : Type u
inst✝ : Category.{v, u} C
J : Type v
⊢ WalkingPair.right ∈ {WalkingPair.left, WalkingPair.right}
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
J : Type v
inst✝ : HasFiniteWidePullbacks C
⊢ HasPullbacks C
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
J : Type v
inst✝ : HasFiniteWidePushouts C
⊢ HasPushouts C
[PROOFSTEP]
infer_instance


[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
X : C
⊢ (λ_ (F.obj X)).inv ≫ (F.ε ⊗ 𝟙 (F.obj X)) ≫ μ F (𝟙_ C) X = F.map (λ_ X).inv
[PROOFSTEP]
rw [Iso.inv_comp_eq, F.left_unitality, Category.assoc, Category.assoc, ← F.toFunctor.map_comp, Iso.hom_inv_id,
  F.toFunctor.map_id, comp_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
X : C
⊢ (ρ_ (F.obj X)).inv ≫ (𝟙 (F.obj X) ⊗ F.ε) ≫ μ F X (𝟙_ C) = F.map (ρ_ X).inv
[PROOFSTEP]
rw [Iso.inv_comp_eq, F.right_unitality, Category.assoc, Category.assoc, ← F.toFunctor.map_comp, Iso.hom_inv_id,
  F.toFunctor.map_id, comp_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
X Y Z : C
⊢ (𝟙 (F.obj X) ⊗ μ F Y Z) ≫ μ F X (Y ⊗ Z) ≫ F.map (α_ X Y Z).inv =
    (α_ (F.obj X) (F.obj Y) (F.obj Z)).inv ≫ (μ F X Y ⊗ 𝟙 (F.obj Z)) ≫ μ F (X ⊗ Y) Z
[PROOFSTEP]
rw [Iso.eq_inv_comp, ← F.associativity_assoc, ← F.toFunctor.map_comp, Iso.hom_inv_id, F.toFunctor.map_id, comp_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X Y X' Y' : C
f : X ⟶ Y
g : X' ⟶ Y'
⊢ F.map (f ⊗ g) =
    inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X X') ≫
      (F.map f ⊗ F.map g) ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor Y Y'
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
⊢ F.map (λ_ X).hom =
    inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ C) X) ≫ (inv F.ε ⊗ 𝟙 (F.obj X)) ≫ (λ_ (F.obj X)).hom
[PROOFSTEP]
simp only [LaxMonoidalFunctor.left_unitality]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
⊢ F.map (λ_ X).hom =
    inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ C) X) ≫
      (inv F.ε ⊗ 𝟙 (F.obj X)) ≫
        (F.ε ⊗ 𝟙 (F.obj X)) ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ C) X ≫ F.map (λ_ X).hom
[PROOFSTEP]
slice_rhs 2 3 =>
  rw [← comp_tensor_id]
  simp
[GOAL]
case a.a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| (inv F.ε ⊗ 𝟙 (F.obj X)) ≫ (F.ε ⊗ 𝟙 (F.obj X))
case a.a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ C) X
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| F.map (λ_ X).hom
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ C) X)
[PROOFSTEP]
  rw [← comp_tensor_id]
  simp
[GOAL]
case a.a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| (inv F.ε ⊗ 𝟙 (F.obj X)) ≫ (F.ε ⊗ 𝟙 (F.obj X))
case a.a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ C) X
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| F.map (λ_ X).hom
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ C) X)
[PROOFSTEP]
  rw [← comp_tensor_id]
  simp
[GOAL]
case a.a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| (inv F.ε ⊗ 𝟙 (F.obj X)) ≫ (F.ε ⊗ 𝟙 (F.obj X))
case a.a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ C) X
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| F.map (λ_ X).hom
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ C) X)
[PROOFSTEP]
rw [← comp_tensor_id]
[GOAL]
case a.a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| inv F.ε ≫ F.ε ⊗ 𝟙 (F.obj X)
case a.a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ C) X
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| F.map (λ_ X).hom
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ C) X)
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
⊢ F.map (λ_ X).hom =
    inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ C) X) ≫
      (𝟙 (F.obj (𝟙_ C) ⊗ F.obj X) ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ C) X) ≫ F.map (λ_ X).hom
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
⊢ F.map (ρ_ X).hom =
    inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X (𝟙_ C)) ≫ (𝟙 (F.obj X) ⊗ inv F.ε) ≫ (ρ_ (F.obj X)).hom
[PROOFSTEP]
simp only [LaxMonoidalFunctor.right_unitality]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
⊢ F.map (ρ_ X).hom =
    inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X (𝟙_ C)) ≫
      (𝟙 (F.obj X) ⊗ inv F.ε) ≫
        (𝟙 (F.obj X) ⊗ F.ε) ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X (𝟙_ C) ≫ F.map (ρ_ X).hom
[PROOFSTEP]
slice_rhs 2 3 =>
  rw [← id_tensor_comp]
  simp
[GOAL]
case a.a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| (𝟙 (F.obj X) ⊗ inv F.ε) ≫ (𝟙 (F.obj X) ⊗ F.ε)
case a.a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X (𝟙_ C)
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| F.map (ρ_ X).hom
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X (𝟙_ C))
[PROOFSTEP]
  rw [← id_tensor_comp]
  simp
[GOAL]
case a.a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| (𝟙 (F.obj X) ⊗ inv F.ε) ≫ (𝟙 (F.obj X) ⊗ F.ε)
case a.a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X (𝟙_ C)
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| F.map (ρ_ X).hom
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X (𝟙_ C))
[PROOFSTEP]
  rw [← id_tensor_comp]
  simp
[GOAL]
case a.a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| (𝟙 (F.obj X) ⊗ inv F.ε) ≫ (𝟙 (F.obj X) ⊗ F.ε)
case a.a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X (𝟙_ C)
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| F.map (ρ_ X).hom
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X (𝟙_ C))
[PROOFSTEP]
rw [← id_tensor_comp]
[GOAL]
case a.a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| 𝟙 (F.obj X) ⊗ inv F.ε ≫ F.ε
case a.a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X (𝟙_ C)
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| F.map (ρ_ X).hom
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
| inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X (𝟙_ C))
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X : C
⊢ F.map (ρ_ X).hom =
    inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X (𝟙_ C)) ≫
      (𝟙 (F.obj X ⊗ F.obj (𝟙_ C)) ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X (𝟙_ C)) ≫ F.map (ρ_ X).hom
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
⊢ (X : C × C) → (Functor.prod F.toFunctor F.toFunctor ⋙ tensor D).obj X ≅ (tensor C ⋙ F.toFunctor).obj X
[PROOFSTEP]
intros
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X✝ : C × C
⊢ (Functor.prod F.toFunctor F.toFunctor ⋙ tensor D).obj X✝ ≅ (tensor C ⋙ F.toFunctor).obj X✝
[PROOFSTEP]
apply F.μIso
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
⊢ ∀ {X Y : C × C} (f : X ⟶ Y),
    (Functor.prod F.toFunctor F.toFunctor ⋙ tensor D).map f ≫ (μIso F Y.fst Y.snd).hom =
      (μIso F X.fst X.snd).hom ≫ (tensor C ⋙ F.toFunctor).map f
[PROOFSTEP]
intros
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X✝ Y✝ : C × C
f✝ : X✝ ⟶ Y✝
⊢ (Functor.prod F.toFunctor F.toFunctor ⋙ tensor D).map f✝ ≫ (μIso F Y✝.fst Y✝.snd).hom =
    (μIso F X✝.fst X✝.snd).hom ≫ (tensor C ⋙ F.toFunctor).map f✝
[PROOFSTEP]
apply F.toLaxMonoidalFunctor.μ_natural
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X Y Z : C
f : Y ⟶ Z
⊢ (F.toFunctor ⋙ tensorLeft (F.obj X)).map f ≫ ((fun Y => μIso F X Y) Z).hom =
    ((fun Y => μIso F X Y) Y).hom ≫ (tensorLeft X ⋙ F.toFunctor).map f
[PROOFSTEP]
convert F.μ_natural (𝟙 X) f using 2
[GOAL]
case h.e'_2.h.h.e'_6.h
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X Y Z : C
f : Y ⟶ Z
e_1✝ :
  ((F.toFunctor ⋙ tensorLeft (F.obj X)).obj Y ⟶ (tensorLeft X ⋙ F.toFunctor).obj Z) =
    (F.obj X ⊗ F.obj Y ⟶ F.obj (X ⊗ Z))
e_3✝ : (F.toFunctor ⋙ tensorLeft (F.obj X)).obj Y = F.obj X ⊗ F.obj Y
e_4✝ : (F.toFunctor ⋙ tensorLeft (F.obj X)).obj Z = F.obj X ⊗ F.obj Z
⊢ (F.toFunctor ⋙ tensorLeft (F.obj X)).map f = F.map (𝟙 X) ⊗ F.map f
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X Y Z : C
f : Y ⟶ Z
⊢ (F.toFunctor ⋙ tensorRight (F.obj X)).map f ≫ ((fun Y => μIso F Y X) Z).hom =
    ((fun Y => μIso F Y X) Y).hom ≫ (tensorRight X ⋙ F.toFunctor).map f
[PROOFSTEP]
convert F.μ_natural f (𝟙 X) using 2
[GOAL]
case h.e'_2.h.h.e'_6.h
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : MonoidalFunctor C D
X Y Z : C
f : Y ⟶ Z
e_1✝ :
  ((F.toFunctor ⋙ tensorRight (F.obj X)).obj Y ⟶ (tensorRight X ⋙ F.toFunctor).obj Z) =
    (F.obj Y ⊗ F.obj X ⟶ F.obj (Z ⊗ X))
e_3✝ : (F.toFunctor ⋙ tensorRight (F.obj X)).obj Y = F.obj Y ⊗ F.obj X
e_4✝ : (F.toFunctor ⋙ tensorRight (F.obj X)).obj Z = F.obj Z ⊗ F.obj X
⊢ (F.toFunctor ⋙ tensorRight (F.obj X)).map f = F.map f ⊗ F.map (𝟙 X)
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
x✝³ x✝² x✝¹ x✝ : C
f : x✝³ ⟶ x✝²
g : x✝¹ ⟶ x✝
⊢ ((Functor.mk src✝.toPrefunctor).map f ⊗ (Functor.mk src✝.toPrefunctor).map g) ≫
      (fun X Y => μ G (F.obj X) (F.obj Y) ≫ G.map (μ F X Y)) x✝² x✝ =
    (fun X Y => μ G (F.obj X) (F.obj Y) ≫ G.map (μ F X Y)) x✝³ x✝¹ ≫ (Functor.mk src✝.toPrefunctor).map (f ⊗ g)
[PROOFSTEP]
simp only [Functor.comp_map, assoc]
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
x✝³ x✝² x✝¹ x✝ : C
f : x✝³ ⟶ x✝²
g : x✝¹ ⟶ x✝
⊢ (G.map (F.map f) ⊗ G.map (F.map g)) ≫ μ G (F.obj x✝²) (F.obj x✝) ≫ G.map (μ F x✝² x✝) =
    μ G (F.obj x✝³) (F.obj x✝¹) ≫ G.map (μ F x✝³ x✝¹) ≫ G.map (F.map (f ⊗ g))
[PROOFSTEP]
rw [← Category.assoc, LaxMonoidalFunctor.μ_natural, Category.assoc, ← map_comp, ← map_comp, ←
  LaxMonoidalFunctor.μ_natural]
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
⊢ ((fun X Y => μ G (F.obj X) (F.obj Y) ≫ G.map (μ F X Y)) X Y ⊗ 𝟙 ((Functor.mk src✝.toPrefunctor).obj Z)) ≫
      (fun X Y => μ G (F.obj X) (F.obj Y) ≫ G.map (μ F X Y)) (X ⊗ Y) Z ≫
        (Functor.mk src✝.toPrefunctor).map (α_ X Y Z).hom =
    (α_ ((Functor.mk src✝.toPrefunctor).obj X) ((Functor.mk src✝.toPrefunctor).obj Y)
          ((Functor.mk src✝.toPrefunctor).obj Z)).hom ≫
      (𝟙 ((Functor.mk src✝.toPrefunctor).obj X) ⊗ (fun X Y => μ G (F.obj X) (F.obj Y) ≫ G.map (μ F X Y)) Y Z) ≫
        (fun X Y => μ G (F.obj X) (F.obj Y) ≫ G.map (μ F X Y)) X (Y ⊗ Z)
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
⊢ (μ G (F.obj X) (F.obj Y) ≫ G.map (μ F X Y) ⊗ 𝟙 (G.obj (F.obj Z))) ≫
      (μ G (F.obj (X ⊗ Y)) (F.obj Z) ≫ G.map (μ F (X ⊗ Y) Z)) ≫ G.map (F.map (α_ X Y Z).hom) =
    (α_ (G.obj (F.obj X)) (G.obj (F.obj Y)) (G.obj (F.obj Z))).hom ≫
      (𝟙 (G.obj (F.obj X)) ⊗ μ G (F.obj Y) (F.obj Z) ≫ G.map (μ F Y Z)) ≫
        μ G (F.obj X) (F.obj (Y ⊗ Z)) ≫ G.map (μ F X (Y ⊗ Z))
[PROOFSTEP]
rw [id_tensor_comp]
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
⊢ (μ G (F.obj X) (F.obj Y) ≫ G.map (μ F X Y) ⊗ 𝟙 (G.obj (F.obj Z))) ≫
      (μ G (F.obj (X ⊗ Y)) (F.obj Z) ≫ G.map (μ F (X ⊗ Y) Z)) ≫ G.map (F.map (α_ X Y Z).hom) =
    (α_ (G.obj (F.obj X)) (G.obj (F.obj Y)) (G.obj (F.obj Z))).hom ≫
      ((𝟙 (G.obj (F.obj X)) ⊗ μ G (F.obj Y) (F.obj Z)) ≫ (𝟙 (G.obj (F.obj X)) ⊗ G.map (μ F Y Z))) ≫
        μ G (F.obj X) (F.obj (Y ⊗ Z)) ≫ G.map (μ F X (Y ⊗ Z))
[PROOFSTEP]
slice_rhs 3 4 => rw [← G.toFunctor.map_id, G.μ_natural]
[GOAL]
case a.a.a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| (𝟙 (G.obj (F.obj X)) ⊗ G.map (μ F Y Z)) ≫ μ G (F.obj X) (F.obj (Y ⊗ Z))
case a.a.a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| G.map (μ F X (Y ⊗ Z))
case a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| (α_ (G.obj (F.obj X)) (G.obj (F.obj Y)) (G.obj (F.obj Z))).hom
case a.a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| 𝟙 (G.obj (F.obj X)) ⊗ μ G (F.obj Y) (F.obj Z)
[PROOFSTEP]
rw [← G.toFunctor.map_id, G.μ_natural]
[GOAL]
case a.a.a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| (𝟙 (G.obj (F.obj X)) ⊗ G.map (μ F Y Z)) ≫ μ G (F.obj X) (F.obj (Y ⊗ Z))
case a.a.a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| G.map (μ F X (Y ⊗ Z))
case a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| (α_ (G.obj (F.obj X)) (G.obj (F.obj Y)) (G.obj (F.obj Z))).hom
case a.a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| 𝟙 (G.obj (F.obj X)) ⊗ μ G (F.obj Y) (F.obj Z)
[PROOFSTEP]
rw [← G.toFunctor.map_id, G.μ_natural]
[GOAL]
case a.a.a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| (𝟙 (G.obj (F.obj X)) ⊗ G.map (μ F Y Z)) ≫ μ G (F.obj X) (F.obj (Y ⊗ Z))
case a.a.a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| G.map (μ F X (Y ⊗ Z))
case a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| (α_ (G.obj (F.obj X)) (G.obj (F.obj Y)) (G.obj (F.obj Z))).hom
case a.a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| 𝟙 (G.obj (F.obj X)) ⊗ μ G (F.obj Y) (F.obj Z)
[PROOFSTEP]
rw [← G.toFunctor.map_id, G.μ_natural]
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
⊢ (μ G (F.obj X) (F.obj Y) ≫ G.map (μ F X Y) ⊗ 𝟙 (G.obj (F.obj Z))) ≫
      (μ G (F.obj (X ⊗ Y)) (F.obj Z) ≫ G.map (μ F (X ⊗ Y) Z)) ≫ G.map (F.map (α_ X Y Z).hom) =
    (α_ (G.obj (F.obj X)) (G.obj (F.obj Y)) (G.obj (F.obj Z))).hom ≫
      (𝟙 (G.obj (F.obj X)) ⊗ μ G (F.obj Y) (F.obj Z)) ≫
        (μ G (F.obj X) (F.obj Y ⊗ F.obj Z) ≫ G.map (𝟙 (F.obj X) ⊗ μ F Y Z)) ≫ G.map (μ F X (Y ⊗ Z))
[PROOFSTEP]
slice_rhs 1 3 => rw [← G.associativity]
[GOAL]
case a.a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| (α_ (G.obj (F.obj X)) (G.obj (F.obj Y)) (G.obj (F.obj Z))).hom ≫
    (𝟙 (G.obj (F.obj X)) ⊗ μ G (F.obj Y) (F.obj Z)) ≫ μ G (F.obj X) (F.obj Y ⊗ F.obj Z)
case a.a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| G.map (𝟙 (F.obj X) ⊗ μ F Y Z)
case a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| G.map (μ F X (Y ⊗ Z))
[PROOFSTEP]
rw [← G.associativity]
[GOAL]
case a.a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| (α_ (G.obj (F.obj X)) (G.obj (F.obj Y)) (G.obj (F.obj Z))).hom ≫
    (𝟙 (G.obj (F.obj X)) ⊗ μ G (F.obj Y) (F.obj Z)) ≫ μ G (F.obj X) (F.obj Y ⊗ F.obj Z)
case a.a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| G.map (𝟙 (F.obj X) ⊗ μ F Y Z)
case a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| G.map (μ F X (Y ⊗ Z))
[PROOFSTEP]
rw [← G.associativity]
[GOAL]
case a.a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| (α_ (G.obj (F.obj X)) (G.obj (F.obj Y)) (G.obj (F.obj Z))).hom ≫
    (𝟙 (G.obj (F.obj X)) ⊗ μ G (F.obj Y) (F.obj Z)) ≫ μ G (F.obj X) (F.obj Y ⊗ F.obj Z)
case a.a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| G.map (𝟙 (F.obj X) ⊗ μ F Y Z)
case a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| G.map (μ F X (Y ⊗ Z))
[PROOFSTEP]
rw [← G.associativity]
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
⊢ (μ G (F.obj X) (F.obj Y) ≫ G.map (μ F X Y) ⊗ 𝟙 (G.obj (F.obj Z))) ≫
      (μ G (F.obj (X ⊗ Y)) (F.obj Z) ≫ G.map (μ F (X ⊗ Y) Z)) ≫ G.map (F.map (α_ X Y Z).hom) =
    (((μ G (F.obj X) (F.obj Y) ⊗ 𝟙 (G.obj (F.obj Z))) ≫
          μ G (F.obj X ⊗ F.obj Y) (F.obj Z) ≫ G.map (α_ (F.obj X) (F.obj Y) (F.obj Z)).hom) ≫
        G.map (𝟙 (F.obj X) ⊗ μ F Y Z)) ≫
      G.map (μ F X (Y ⊗ Z))
[PROOFSTEP]
rw [comp_tensor_id]
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
⊢ ((μ G (F.obj X) (F.obj Y) ⊗ 𝟙 (G.obj (F.obj Z))) ≫ (G.map (μ F X Y) ⊗ 𝟙 (G.obj (F.obj Z)))) ≫
      (μ G (F.obj (X ⊗ Y)) (F.obj Z) ≫ G.map (μ F (X ⊗ Y) Z)) ≫ G.map (F.map (α_ X Y Z).hom) =
    (((μ G (F.obj X) (F.obj Y) ⊗ 𝟙 (G.obj (F.obj Z))) ≫
          μ G (F.obj X ⊗ F.obj Y) (F.obj Z) ≫ G.map (α_ (F.obj X) (F.obj Y) (F.obj Z)).hom) ≫
        G.map (𝟙 (F.obj X) ⊗ μ F Y Z)) ≫
      G.map (μ F X (Y ⊗ Z))
[PROOFSTEP]
slice_lhs 2 3 => rw [← G.toFunctor.map_id, G.μ_natural]
[GOAL]
case a.a.a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| (G.map (μ F X Y) ⊗ 𝟙 (G.obj (F.obj Z))) ≫ μ G (F.obj (X ⊗ Y)) (F.obj Z)
case a.a.a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| G.map (μ F (X ⊗ Y) Z)
case a.a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| G.map (F.map (α_ X Y Z).hom)
case a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| μ G (F.obj X) (F.obj Y) ⊗ 𝟙 (G.obj (F.obj Z))
[PROOFSTEP]
rw [← G.toFunctor.map_id, G.μ_natural]
[GOAL]
case a.a.a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| (G.map (μ F X Y) ⊗ 𝟙 (G.obj (F.obj Z))) ≫ μ G (F.obj (X ⊗ Y)) (F.obj Z)
case a.a.a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| G.map (μ F (X ⊗ Y) Z)
case a.a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| G.map (F.map (α_ X Y Z).hom)
case a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| μ G (F.obj X) (F.obj Y) ⊗ 𝟙 (G.obj (F.obj Z))
[PROOFSTEP]
rw [← G.toFunctor.map_id, G.μ_natural]
[GOAL]
case a.a.a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| (G.map (μ F X Y) ⊗ 𝟙 (G.obj (F.obj Z))) ≫ μ G (F.obj (X ⊗ Y)) (F.obj Z)
case a.a.a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| G.map (μ F (X ⊗ Y) Z)
case a.a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| G.map (F.map (α_ X Y Z).hom)
case a
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
| μ G (F.obj X) (F.obj Y) ⊗ 𝟙 (G.obj (F.obj Z))
[PROOFSTEP]
rw [← G.toFunctor.map_id, G.μ_natural]
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X Y Z : C
⊢ (μ G (F.obj X) (F.obj Y) ⊗ 𝟙 (G.obj (F.obj Z))) ≫
      ((μ G (F.obj X ⊗ F.obj Y) (F.obj Z) ≫ G.map (μ F X Y ⊗ 𝟙 (F.obj Z))) ≫ G.map (μ F (X ⊗ Y) Z)) ≫
        G.map (F.map (α_ X Y Z).hom) =
    (((μ G (F.obj X) (F.obj Y) ⊗ 𝟙 (G.obj (F.obj Z))) ≫
          μ G (F.obj X ⊗ F.obj Y) (F.obj Z) ≫ G.map (α_ (F.obj X) (F.obj Y) (F.obj Z)).hom) ≫
        G.map (𝟙 (F.obj X) ⊗ μ F Y Z)) ≫
      G.map (μ F X (Y ⊗ Z))
[PROOFSTEP]
rw [Category.assoc, Category.assoc, Category.assoc, Category.assoc, Category.assoc, ← G.toFunctor.map_comp, ←
  G.toFunctor.map_comp, ← G.toFunctor.map_comp, ← G.toFunctor.map_comp, F.associativity]
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X : C
⊢ (λ_ ((Functor.mk src✝.toPrefunctor).obj X)).hom =
    (G.ε ≫ G.map F.ε ⊗ 𝟙 ((Functor.mk src✝.toPrefunctor).obj X)) ≫
      (fun X Y => μ G (F.obj X) (F.obj Y) ≫ G.map (μ F X Y)) (𝟙_ C) X ≫ (Functor.mk src✝.toPrefunctor).map (λ_ X).hom
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X : C
⊢ (λ_ (G.obj (F.obj X))).hom =
    (G.ε ≫ G.map F.ε ⊗ 𝟙 (G.obj (F.obj X))) ≫
      (μ G (F.obj (𝟙_ C)) (F.obj X) ≫ G.map (μ F (𝟙_ C) X)) ≫ G.map (F.map (λ_ X).hom)
[PROOFSTEP]
rw [G.left_unitality, comp_tensor_id, Category.assoc, Category.assoc]
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X : C
⊢ (G.ε ⊗ 𝟙 (G.obj (F.obj X))) ≫ μ G (𝟙_ D) (F.obj X) ≫ G.map (λ_ (F.obj X)).hom =
    (G.ε ⊗ 𝟙 (G.obj (F.obj X))) ≫
      (G.map F.ε ⊗ 𝟙 (G.obj (F.obj X))) ≫ μ G (F.obj (𝟙_ C)) (F.obj X) ≫ G.map (μ F (𝟙_ C) X) ≫ G.map (F.map (λ_ X).hom)
[PROOFSTEP]
apply congr_arg
[GOAL]
case h
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X : C
⊢ μ G (𝟙_ D) (F.obj X) ≫ G.map (λ_ (F.obj X)).hom =
    (G.map F.ε ⊗ 𝟙 (G.obj (F.obj X))) ≫ μ G (F.obj (𝟙_ C)) (F.obj X) ≫ G.map (μ F (𝟙_ C) X) ≫ G.map (F.map (λ_ X).hom)
[PROOFSTEP]
rw [F.left_unitality, map_comp, ← NatTrans.id_app, ← Category.assoc, ← LaxMonoidalFunctor.μ_natural, NatTrans.id_app,
  map_id, ← Category.assoc, map_comp]
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X : C
⊢ (ρ_ ((Functor.mk src✝.toPrefunctor).obj X)).hom =
    (𝟙 ((Functor.mk src✝.toPrefunctor).obj X) ⊗ G.ε ≫ G.map F.ε) ≫
      (fun X Y => μ G (F.obj X) (F.obj Y) ≫ G.map (μ F X Y)) X (𝟙_ C) ≫ (Functor.mk src✝.toPrefunctor).map (ρ_ X).hom
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X : C
⊢ (ρ_ (G.obj (F.obj X))).hom =
    (𝟙 (G.obj (F.obj X)) ⊗ G.ε ≫ G.map F.ε) ≫
      (μ G (F.obj X) (F.obj (𝟙_ C)) ≫ G.map (μ F X (𝟙_ C))) ≫ G.map (F.map (ρ_ X).hom)
[PROOFSTEP]
rw [G.right_unitality, id_tensor_comp, Category.assoc, Category.assoc]
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X : C
⊢ (𝟙 (G.obj (F.obj X)) ⊗ G.ε) ≫ μ G (F.obj X) (𝟙_ D) ≫ G.map (ρ_ (F.obj X)).hom =
    (𝟙 (G.obj (F.obj X)) ⊗ G.ε) ≫
      (𝟙 (G.obj (F.obj X)) ⊗ G.map F.ε) ≫ μ G (F.obj X) (F.obj (𝟙_ C)) ≫ G.map (μ F X (𝟙_ C)) ≫ G.map (F.map (ρ_ X).hom)
[PROOFSTEP]
apply congr_arg
[GOAL]
case h
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor D E
src✝ : C ⥤ E := F.toFunctor ⋙ G.toFunctor
X : C
⊢ μ G (F.obj X) (𝟙_ D) ≫ G.map (ρ_ (F.obj X)).hom =
    (𝟙 (G.obj (F.obj X)) ⊗ G.map F.ε) ≫ μ G (F.obj X) (F.obj (𝟙_ C)) ≫ G.map (μ F X (𝟙_ C)) ≫ G.map (F.map (ρ_ X).hom)
[PROOFSTEP]
rw [F.right_unitality, map_comp, ← NatTrans.id_app, ← Category.assoc, ← LaxMonoidalFunctor.μ_natural, NatTrans.id_app,
  map_id, ← Category.assoc, map_comp]
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor C E
⊢ (prod' F G).ε = (F.ε, G.ε)
[PROOFSTEP]
dsimp [prod']
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor C E
⊢ (F.ε ≫ F.map (𝟙 (𝟙_ C)), G.ε ≫ G.map (𝟙 (𝟙_ C))) = (F.ε, G.ε)
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor C E
X Y : C
⊢ μ (prod' F G) X Y = (μ F X Y, μ G X Y)
[PROOFSTEP]
dsimp [prod']
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : LaxMonoidalFunctor C D
G : LaxMonoidalFunctor C E
X Y : C
⊢ (μ F X Y ≫ F.map (𝟙 (X ⊗ Y)), μ G X Y ≫ G.map (𝟙 (X ⊗ Y))) = (μ F X Y, μ G X Y)
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : MonoidalFunctor C D
G : MonoidalFunctor D E
src✝ : LaxMonoidalFunctor C E := F.toLaxMonoidalFunctor ⊗⋙ G.toLaxMonoidalFunctor
⊢ IsIso (LaxMonoidalFunctor.mk src✝.toFunctor src✝.ε src✝.μ).ε
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : MonoidalFunctor C D
G : MonoidalFunctor D E
src✝ : LaxMonoidalFunctor C E := F.toLaxMonoidalFunctor ⊗⋙ G.toLaxMonoidalFunctor
⊢ IsIso (G.ε ≫ G.map F.ε)
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : MonoidalFunctor C D
G : MonoidalFunctor D E
src✝ : LaxMonoidalFunctor C E := F.toLaxMonoidalFunctor ⊗⋙ G.toLaxMonoidalFunctor
⊢ ∀ (X Y : C), IsIso (LaxMonoidalFunctor.μ (LaxMonoidalFunctor.mk src✝.toFunctor src✝.ε src✝.μ) X Y)
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : MonoidalFunctor C D
G : MonoidalFunctor D E
src✝ : LaxMonoidalFunctor C E := F.toLaxMonoidalFunctor ⊗⋙ G.toLaxMonoidalFunctor
⊢ ∀ (X Y : C),
    IsIso
      (LaxMonoidalFunctor.μ G.toLaxMonoidalFunctor (F.obj X) (F.obj Y) ≫
        G.map (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor X Y))
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : MonoidalFunctor C D
G : D ⥤ C
h : F.toFunctor ⊣ G
X Y X' Y' : D
f : X ⟶ Y
g : X' ⟶ Y'
⊢ (G.map f ⊗ G.map g) ≫
      (fun X Y =>
          ↑(Adjunction.homEquiv h (G.obj X ⊗ G.obj Y) (X ⊗ Y))
            (inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj X) (G.obj Y)) ≫
              (NatTrans.app h.counit X ⊗ NatTrans.app h.counit Y)))
        Y Y' =
    (fun X Y =>
          ↑(Adjunction.homEquiv h (G.obj X ⊗ G.obj Y) (X ⊗ Y))
            (inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj X) (G.obj Y)) ≫
              (NatTrans.app h.counit X ⊗ NatTrans.app h.counit Y)))
        X X' ≫
      G.map (f ⊗ g)
[PROOFSTEP]
rw [← h.homEquiv_naturality_left, ← h.homEquiv_naturality_right, Equiv.apply_eq_iff_eq, assoc, IsIso.eq_inv_comp, ←
  F.toLaxMonoidalFunctor.μ_natural_assoc, IsIso.hom_inv_id_assoc, ← tensor_comp, Adjunction.counit_naturality,
  Adjunction.counit_naturality, tensor_comp]
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : MonoidalFunctor C D
G : D ⥤ C
h : F.toFunctor ⊣ G
X Y Z : D
⊢ ((fun X Y =>
            ↑(Adjunction.homEquiv h (G.obj X ⊗ G.obj Y) (X ⊗ Y))
              (inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj X) (G.obj Y)) ≫
                (NatTrans.app h.counit X ⊗ NatTrans.app h.counit Y)))
          X Y ⊗
        𝟙 (G.obj Z)) ≫
      (fun X Y =>
            ↑(Adjunction.homEquiv h (G.obj X ⊗ G.obj Y) (X ⊗ Y))
              (inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj X) (G.obj Y)) ≫
                (NatTrans.app h.counit X ⊗ NatTrans.app h.counit Y)))
          (X ⊗ Y) Z ≫
        G.map (α_ X Y Z).hom =
    (α_ (G.obj X) (G.obj Y) (G.obj Z)).hom ≫
      (𝟙 (G.obj X) ⊗
          (fun X Y =>
              ↑(Adjunction.homEquiv h (G.obj X ⊗ G.obj Y) (X ⊗ Y))
                (inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj X) (G.obj Y)) ≫
                  (NatTrans.app h.counit X ⊗ NatTrans.app h.counit Y)))
            Y Z) ≫
        (fun X Y =>
            ↑(Adjunction.homEquiv h (G.obj X ⊗ G.obj Y) (X ⊗ Y))
              (inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj X) (G.obj Y)) ≫
                (NatTrans.app h.counit X ⊗ NatTrans.app h.counit Y)))
          X (Y ⊗ Z)
[PROOFSTEP]
dsimp only
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : MonoidalFunctor C D
G : D ⥤ C
h : F.toFunctor ⊣ G
X Y Z : D
⊢ (↑(Adjunction.homEquiv h (G.obj X ⊗ G.obj Y) (X ⊗ Y))
          (inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj X) (G.obj Y)) ≫
            (NatTrans.app h.counit X ⊗ NatTrans.app h.counit Y)) ⊗
        𝟙 (G.obj Z)) ≫
      ↑(Adjunction.homEquiv h (G.obj (X ⊗ Y) ⊗ G.obj Z) ((X ⊗ Y) ⊗ Z))
          (inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj (X ⊗ Y)) (G.obj Z)) ≫
            (NatTrans.app h.counit (X ⊗ Y) ⊗ NatTrans.app h.counit Z)) ≫
        G.map (α_ X Y Z).hom =
    (α_ (G.obj X) (G.obj Y) (G.obj Z)).hom ≫
      (𝟙 (G.obj X) ⊗
          ↑(Adjunction.homEquiv h (G.obj Y ⊗ G.obj Z) (Y ⊗ Z))
            (inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj Y) (G.obj Z)) ≫
              (NatTrans.app h.counit Y ⊗ NatTrans.app h.counit Z))) ≫
        ↑(Adjunction.homEquiv h (G.obj X ⊗ G.obj (Y ⊗ Z)) (X ⊗ Y ⊗ Z))
          (inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj X) (G.obj (Y ⊗ Z))) ≫
            (NatTrans.app h.counit X ⊗ NatTrans.app h.counit (Y ⊗ Z)))
[PROOFSTEP]
rw [← h.homEquiv_naturality_right, ← h.homEquiv_naturality_left, ← h.homEquiv_naturality_left, ←
  h.homEquiv_naturality_left, Equiv.apply_eq_iff_eq, ←
  cancel_epi (F.toLaxMonoidalFunctor.μ (G.obj X ⊗ G.obj Y) (G.obj Z)), ←
  cancel_epi (F.toLaxMonoidalFunctor.μ (G.obj X) (G.obj Y) ⊗ 𝟙 (F.obj (G.obj Z))),
  F.toLaxMonoidalFunctor.associativity_assoc (G.obj X) (G.obj Y) (G.obj Z), ← F.toLaxMonoidalFunctor.μ_natural_assoc,
  assoc, IsIso.hom_inv_id_assoc, ← F.toLaxMonoidalFunctor.μ_natural_assoc, IsIso.hom_inv_id_assoc, ← tensor_comp, ←
  tensor_comp, id_comp, Functor.map_id, Functor.map_id, id_comp, ← tensor_comp_assoc, ← tensor_comp_assoc, id_comp,
  id_comp, h.homEquiv_unit, h.homEquiv_unit, Functor.map_comp, assoc, assoc, h.counit_naturality,
  h.left_triangle_components_assoc, Functor.map_comp, assoc, h.counit_naturality, h.left_triangle_components_assoc]
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : MonoidalFunctor C D
G : D ⥤ C
h : F.toFunctor ⊣ G
X Y Z : D
⊢ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj X) (G.obj Y) ≫
          inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj X) (G.obj Y)) ≫
            (NatTrans.app h.counit X ⊗ NatTrans.app h.counit Y) ⊗
        NatTrans.app h.counit Z) ≫
      (α_ X Y Z).hom =
    (α_ (F.obj (G.obj X)) (F.obj (G.obj Y)) (F.obj (G.obj Z))).hom ≫
      (NatTrans.app h.counit X ⊗
        LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj Y) (G.obj Z) ≫
          inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj Y) (G.obj Z)) ≫
            (NatTrans.app h.counit Y ⊗ NatTrans.app h.counit Z))
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : MonoidalFunctor C D
G : D ⥤ C
h : F.toFunctor ⊣ G
X : D
⊢ (λ_ (G.obj X)).hom =
    (↑(Adjunction.homEquiv h (𝟙_ C) (𝟙_ D)) (inv F.ε) ⊗ 𝟙 (G.obj X)) ≫
      (fun X Y =>
            ↑(Adjunction.homEquiv h (G.obj X ⊗ G.obj Y) (X ⊗ Y))
              (inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj X) (G.obj Y)) ≫
                (NatTrans.app h.counit X ⊗ NatTrans.app h.counit Y)))
          (𝟙_ D) X ≫
        G.map (λ_ X).hom
[PROOFSTEP]
rw [← h.homEquiv_naturality_right, ← h.homEquiv_naturality_left, ← Equiv.symm_apply_eq, h.homEquiv_counit,
  F.map_leftUnitor, h.homEquiv_unit, assoc, assoc, assoc, F.map_tensor, assoc, assoc, IsIso.hom_inv_id_assoc, ←
  tensor_comp_assoc, Functor.map_id, id_comp, Functor.map_comp, assoc, h.counit_naturality,
  h.left_triangle_components_assoc, ← leftUnitor_naturality, ← tensor_comp_assoc, id_comp, comp_id]
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : MonoidalFunctor C D
G : D ⥤ C
h : F.toFunctor ⊣ G
X : D
⊢ inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ C) (G.obj X)) ≫
      (inv F.ε ⊗ NatTrans.app h.counit X) ≫ (λ_ ((𝟭 D).obj X)).hom =
    inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (𝟙_ C) (G.obj X)) ≫
      (inv F.ε ⊗ NatTrans.app h.counit X) ≫ (λ_ X).hom
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : MonoidalFunctor C D
G : D ⥤ C
h : F.toFunctor ⊣ G
X : D
⊢ (ρ_ (G.obj X)).hom =
    (𝟙 (G.obj X) ⊗ ↑(Adjunction.homEquiv h (𝟙_ C) (𝟙_ D)) (inv F.ε)) ≫
      (fun X Y =>
            ↑(Adjunction.homEquiv h (G.obj X ⊗ G.obj Y) (X ⊗ Y))
              (inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj X) (G.obj Y)) ≫
                (NatTrans.app h.counit X ⊗ NatTrans.app h.counit Y)))
          X (𝟙_ D) ≫
        G.map (ρ_ X).hom
[PROOFSTEP]
rw [← h.homEquiv_naturality_right, ← h.homEquiv_naturality_left, ← Equiv.symm_apply_eq, h.homEquiv_counit,
  F.map_rightUnitor, assoc, assoc, ← rightUnitor_naturality, ← tensor_comp_assoc, comp_id, id_comp, h.homEquiv_unit,
  F.map_tensor, assoc, assoc, assoc, IsIso.hom_inv_id_assoc, Functor.map_comp, Functor.map_id, ← tensor_comp_assoc,
  assoc, h.counit_naturality, h.left_triangle_components_assoc, id_comp]
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : MonoidalCategory D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : MonoidalCategory E
F : MonoidalFunctor C D
G : D ⥤ C
h : F.toFunctor ⊣ G
X : D
⊢ inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj X) (𝟙_ C)) ≫
      (NatTrans.app h.counit X ⊗ inv F.ε) ≫ (ρ_ ((𝟭 D).obj X)).hom =
    inv (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor (G.obj X) (𝟙_ C)) ≫
      (NatTrans.app h.counit X ⊗ inv F.ε) ≫ (ρ_ X).hom
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : MonoidalCategory C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
inst✝³ : MonoidalCategory D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
inst✝¹ : MonoidalCategory E
F : MonoidalFunctor C D
inst✝ : IsEquivalence F.toFunctor
⊢ IsIso (monoidalAdjoint F (Equivalence.toAdjunction (asEquivalence F.toLaxMonoidalFunctor.1))).ε
[PROOFSTEP]
dsimp [Equivalence.toAdjunction]
[GOAL]
C : Type u₁
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : MonoidalCategory C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
inst✝³ : MonoidalCategory D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
inst✝¹ : MonoidalCategory E
F : MonoidalFunctor C D
inst✝ : IsEquivalence F.toFunctor
⊢ IsIso
    (NatTrans.app (Equivalence.unit (asEquivalence F.toLaxMonoidalFunctor.1)) (𝟙_ C) ≫
      (Functor.inv F.toLaxMonoidalFunctor.1).map (inv F.ε))
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u₁
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : MonoidalCategory C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
inst✝³ : MonoidalCategory D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
inst✝¹ : MonoidalCategory E
F : MonoidalFunctor C D
inst✝ : IsEquivalence F.toFunctor
X Y : D
⊢ IsIso
    (LaxMonoidalFunctor.μ (monoidalAdjoint F (Equivalence.toAdjunction (asEquivalence F.toLaxMonoidalFunctor.1))) X Y)
[PROOFSTEP]
dsimp [Equivalence.toAdjunction]
[GOAL]
C : Type u₁
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : MonoidalCategory C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
inst✝³ : MonoidalCategory D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
inst✝¹ : MonoidalCategory E
F : MonoidalFunctor C D
inst✝ : IsEquivalence F.toFunctor
X Y : D
⊢ IsIso
    (NatTrans.app (Equivalence.unit (asEquivalence F.toLaxMonoidalFunctor.1))
        ((Functor.inv F.toLaxMonoidalFunctor.1).obj X ⊗ (Functor.inv F.toLaxMonoidalFunctor.1).obj Y) ≫
      (Functor.inv F.toLaxMonoidalFunctor.1).map
        (inv
            (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor ((Functor.inv F.toLaxMonoidalFunctor.1).obj X)
              ((Functor.inv F.toLaxMonoidalFunctor.1).obj Y)) ≫
          (NatTrans.app (Equivalence.counit (asEquivalence F.toLaxMonoidalFunctor.1)) X ⊗
            NatTrans.app (Equivalence.counit (asEquivalence F.toLaxMonoidalFunctor.1)) Y)))
[PROOFSTEP]
infer_instance


[GOAL]
R : Type u_1
inst✝ : Semiring R
r✝ : R
f✝ : R[X]
r c : R
f : R[X]
⊢ AddHom.toFun
      { toFun := fun f => comp f (X + ↑C r),
        map_add' := (_ : ∀ (f g : R[X]), comp (f + g) (X + ↑C r) = comp f (X + ↑C r) + comp g (X + ↑C r)) }
      (c • f) =
    ↑(RingHom.id R) c •
      AddHom.toFun
        { toFun := fun f => comp f (X + ↑C r),
          map_add' := (_ : ∀ (f g : R[X]), comp (f + g) (X + ↑C r) = comp f (X + ↑C r) + comp g (X + ↑C r)) }
        f
[PROOFSTEP]
simp only [smul_eq_C_mul, C_mul_comp, RingHom.id_apply]
[GOAL]
R : Type u_1
inst✝ : Semiring R
r : R
f : R[X]
⊢ ↑(taylor r) X = X + ↑C r
[PROOFSTEP]
simp only [taylor_apply, X_comp]
[GOAL]
R : Type u_1
inst✝ : Semiring R
r : R
f : R[X]
x : R
⊢ ↑(taylor r) (↑C x) = ↑C x
[PROOFSTEP]
simp only [taylor_apply, C_comp]
[GOAL]
R : Type u_1
inst✝ : Semiring R
r : R
f : R[X]
⊢ taylor 0 = LinearMap.id
[PROOFSTEP]
ext
[GOAL]
case h.h.a
R : Type u_1
inst✝ : Semiring R
r : R
f : R[X]
n✝¹ n✝ : ℕ
⊢ coeff (↑(LinearMap.comp (taylor 0) (monomial n✝¹)) 1) n✝ = coeff (↑(LinearMap.comp LinearMap.id (monomial n✝¹)) 1) n✝
[PROOFSTEP]
simp only [taylor_apply, add_zero, comp_X, _root_.map_zero, LinearMap.id_comp, Function.comp_apply, LinearMap.coe_comp]
[GOAL]
R : Type u_1
inst✝ : Semiring R
r : R
f✝ f : R[X]
⊢ ↑(taylor 0) f = f
[PROOFSTEP]
rw [taylor_zero', LinearMap.id_apply]
[GOAL]
R : Type u_1
inst✝ : Semiring R
r : R
f : R[X]
⊢ ↑(taylor r) 1 = ↑C 1
[PROOFSTEP]
rw [← C_1, taylor_C]
[GOAL]
R : Type u_1
inst✝ : Semiring R
r : R
f : R[X]
i : ℕ
k : R
⊢ ↑(taylor r) (↑(monomial i) k) = ↑C k * (X + ↑C r) ^ i
[PROOFSTEP]
simp [taylor_apply]
[GOAL]
R : Type u_1
inst✝ : Semiring R
r : R
f : R[X]
n : ℕ
⊢ ↑(LinearMap.comp (lcoeff R n) (taylor r)) f = ↑(LinearMap.comp (leval r) (hasseDeriv n)) f
[PROOFSTEP]
congr 1
[GOAL]
case e_a
R : Type u_1
inst✝ : Semiring R
r : R
f : R[X]
n : ℕ
⊢ LinearMap.comp (lcoeff R n) (taylor r) = LinearMap.comp (leval r) (hasseDeriv n)
[PROOFSTEP]
clear! f
[GOAL]
case e_a
R : Type u_1
inst✝ : Semiring R
r : R
n : ℕ
⊢ LinearMap.comp (lcoeff R n) (taylor r) = LinearMap.comp (leval r) (hasseDeriv n)
[PROOFSTEP]
ext i
[GOAL]
case e_a.h.h
R : Type u_1
inst✝ : Semiring R
r : R
n i : ℕ
⊢ ↑(LinearMap.comp (LinearMap.comp (lcoeff R n) (taylor r)) (monomial i)) 1 =
    ↑(LinearMap.comp (LinearMap.comp (leval r) (hasseDeriv n)) (monomial i)) 1
[PROOFSTEP]
simp only [leval_apply, mul_one, one_mul, eval_monomial, LinearMap.comp_apply, coeff_C_mul, hasseDeriv_monomial,
  taylor_apply, monomial_comp, C_1, (commute_X (C r)).add_pow i, LinearMap.map_sum]
[GOAL]
case e_a.h.h
R : Type u_1
inst✝ : Semiring R
r : R
n i : ℕ
⊢ (Finset.sum (Finset.range (i + 1)) fun x => ↑(lcoeff R n) (X ^ x * ↑C r ^ (i - x) * ↑(Nat.choose i x))) =
    ↑(Nat.choose i n) * r ^ (i - n)
[PROOFSTEP]
simp only [lcoeff_apply, ← C_eq_nat_cast, mul_assoc, ← C_pow, ← C_mul, coeff_mul_C, (Nat.cast_commute _ _).eq,
  coeff_X_pow, boole_mul, Finset.sum_ite_eq, Finset.mem_range]
[GOAL]
case e_a.h.h
R : Type u_1
inst✝ : Semiring R
r : R
n i : ℕ
⊢ (if n < i + 1 then r ^ (i - n) * ↑(Nat.choose i n) else 0) = r ^ (i - n) * ↑(Nat.choose i n)
[PROOFSTEP]
split_ifs with h
[GOAL]
case pos
R : Type u_1
inst✝ : Semiring R
r : R
n i : ℕ
h : n < i + 1
⊢ r ^ (i - n) * ↑(Nat.choose i n) = r ^ (i - n) * ↑(Nat.choose i n)
[PROOFSTEP]
rfl
[GOAL]
case neg
R : Type u_1
inst✝ : Semiring R
r : R
n i : ℕ
h : ¬n < i + 1
⊢ 0 = r ^ (i - n) * ↑(Nat.choose i n)
[PROOFSTEP]
push_neg at h
[GOAL]
case neg
R : Type u_1
inst✝ : Semiring R
r : R
n i : ℕ
h : i + 1 ≤ n
⊢ 0 = r ^ (i - n) * ↑(Nat.choose i n)
[PROOFSTEP]
rw [Nat.choose_eq_zero_of_lt h, Nat.cast_zero, mul_zero]
[GOAL]
R : Type u_1
inst✝ : Semiring R
r : R
f : R[X]
⊢ coeff (↑(taylor r) f) 0 = eval r f
[PROOFSTEP]
rw [taylor_coeff, hasseDeriv_zero, LinearMap.id_apply]
[GOAL]
R : Type u_1
inst✝ : Semiring R
r : R
f : R[X]
⊢ coeff (↑(taylor r) f) 1 = eval r (↑derivative f)
[PROOFSTEP]
rw [taylor_coeff, hasseDeriv_one]
[GOAL]
R : Type u_1
inst✝ : Semiring R
r✝ : R
f p : R[X]
r : R
⊢ natDegree (↑(taylor r) p) = natDegree p
[PROOFSTEP]
refine' map_natDegree_eq_natDegree _ _
[GOAL]
R : Type u_1
inst✝ : Semiring R
r✝ : R
f p : R[X]
r : R
⊢ ∀ (n : ℕ) (c : R), c ≠ 0 → natDegree (↑(taylor r) (↑(monomial n) c)) = n
[PROOFSTEP]
nontriviality R
[GOAL]
R : Type u_1
inst✝ : Semiring R
r✝ : R
f p : R[X]
r : R
✝ : Nontrivial R
⊢ ∀ (n : ℕ) (c : R), c ≠ 0 → natDegree (↑(taylor r) (↑(monomial n) c)) = n
[PROOFSTEP]
intro n c c0
[GOAL]
R : Type u_1
inst✝ : Semiring R
r✝ : R
f p : R[X]
r : R
✝ : Nontrivial R
n : ℕ
c : R
c0 : c ≠ 0
⊢ natDegree (↑(taylor r) (↑(monomial n) c)) = n
[PROOFSTEP]
simp [taylor_monomial, natDegree_C_mul_eq_of_mul_ne_zero, natDegree_pow_X_add_C, c0]
[GOAL]
R✝ : Type u_1
inst✝¹ : Semiring R✝
r✝ : R✝
f : R✝[X]
R : Type u_2
inst✝ : CommSemiring R
r : R
p q : R[X]
⊢ ↑(taylor r) (p * q) = ↑(taylor r) p * ↑(taylor r) q
[PROOFSTEP]
simp only [taylor_apply, mul_comp]
[GOAL]
R✝ : Type u_1
inst✝¹ : Semiring R✝
r✝ : R✝
f✝ : R✝[X]
R : Type u_2
inst✝ : CommSemiring R
f : R[X]
r s : R
⊢ ↑(taylor r) (↑(taylor s) f) = ↑(taylor (r + s)) f
[PROOFSTEP]
simp only [taylor_apply, comp_assoc, map_add, add_comp, X_comp, C_comp, C_add, add_assoc]
[GOAL]
R✝ : Type u_1
inst✝¹ : Semiring R✝
r✝ : R✝
f✝ : R✝[X]
R : Type u_2
inst✝ : CommSemiring R
r : R
f : R[X]
s : R
⊢ eval s (↑(taylor r) f) = eval (s + r) f
[PROOFSTEP]
simp only [taylor_apply, eval_comp, eval_C, eval_X, eval_add]
[GOAL]
R✝ : Type u_1
inst✝¹ : Semiring R✝
r✝ : R✝
f✝ : R✝[X]
R : Type u_2
inst✝ : CommRing R
r : R
f : R[X]
s : R
⊢ eval (s - r) (↑(taylor r) f) = eval s f
[PROOFSTEP]
rw [taylor_eval, sub_add_cancel]
[GOAL]
R✝ : Type u_1
inst✝¹ : Semiring R✝
r✝ : R✝
f : R✝[X]
R : Type u_2
inst✝ : CommRing R
r : R
⊢ Function.Injective ↑(taylor r)
[PROOFSTEP]
intro f g h
[GOAL]
R✝ : Type u_1
inst✝¹ : Semiring R✝
r✝ : R✝
f✝ : R✝[X]
R : Type u_2
inst✝ : CommRing R
r : R
f g : R[X]
h : ↑(taylor r) f = ↑(taylor r) g
⊢ f = g
[PROOFSTEP]
apply_fun taylor (-r) at h
[GOAL]
R✝ : Type u_1
inst✝¹ : Semiring R✝
r✝ : R✝
f✝ : R✝[X]
R : Type u_2
inst✝ : CommRing R
r : R
f g : R[X]
h : ↑(taylor (-r)) (↑(taylor r) f) = ↑(taylor (-r)) (↑(taylor r) g)
⊢ f = g
[PROOFSTEP]
simpa only [taylor_apply, comp_assoc, add_comp, X_comp, C_comp, C_neg, neg_add_cancel_right, comp_X] using h
[GOAL]
R✝ : Type u_1
inst✝¹ : Semiring R✝
r✝ : R✝
f✝ : R✝[X]
R : Type u_2
inst✝ : CommRing R
f : R[X]
r : R
h : ∀ (k : ℕ), eval r (↑(hasseDeriv k) f) = 0
⊢ f = 0
[PROOFSTEP]
apply taylor_injective r
[GOAL]
case a
R✝ : Type u_1
inst✝¹ : Semiring R✝
r✝ : R✝
f✝ : R✝[X]
R : Type u_2
inst✝ : CommRing R
f : R[X]
r : R
h : ∀ (k : ℕ), eval r (↑(hasseDeriv k) f) = 0
⊢ ↑(taylor r) f = ↑(taylor r) 0
[PROOFSTEP]
rw [LinearMap.map_zero]
[GOAL]
case a
R✝ : Type u_1
inst✝¹ : Semiring R✝
r✝ : R✝
f✝ : R✝[X]
R : Type u_2
inst✝ : CommRing R
f : R[X]
r : R
h : ∀ (k : ℕ), eval r (↑(hasseDeriv k) f) = 0
⊢ ↑(taylor r) f = 0
[PROOFSTEP]
ext k
[GOAL]
case a.a
R✝ : Type u_1
inst✝¹ : Semiring R✝
r✝ : R✝
f✝ : R✝[X]
R : Type u_2
inst✝ : CommRing R
f : R[X]
r : R
h : ∀ (k : ℕ), eval r (↑(hasseDeriv k) f) = 0
k : ℕ
⊢ coeff (↑(taylor r) f) k = coeff 0 k
[PROOFSTEP]
simp only [taylor_coeff, h, coeff_zero]
[GOAL]
R✝ : Type u_1
inst✝¹ : Semiring R✝
r✝ : R✝
f✝ : R✝[X]
R : Type u_2
inst✝ : CommRing R
f : R[X]
r : R
⊢ (sum (↑(taylor r) f) fun i a => ↑C a * (X - ↑C r) ^ i) = f
[PROOFSTEP]
rw [← comp_eq_sum_left, sub_eq_add_neg, ← C_neg, ← taylor_apply, taylor_taylor, neg_add_self, taylor_zero]