Module: Mathlib.CategoryTheory.GlueData

Goal state before:
pp: case h₀
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData' C
i j : D.J
hij : ¬i = j
⊢ ((if hij : i = j then
          (pullbackSymmetry (D.f' i j) (D.f' i i)).hom ≫
            pullback.map (D.f' i i) (D.f' i j) (D.f' j i) (D.f' j i) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯ ⋯
        else
          if hik : i = i then
            have this := ⋯;
            pullback.fst (D.f' i j) (D.f' i i) ≫
              eqToHom ⋯ ≫ D.t i j hij ≫ eqToHom ⋯ ≫ inv (pullback.snd (D.f' j i) (D.f' j i))
          else
            if hjk : j = i then
              have this := ⋯;
              pullback.fst (D.f' i j) (D.f' i i) ≫
                eqToHom ⋯ ≫ D.t i j hij ≫ eqToHom ⋯ ≫ inv (pullback.snd (D.f' j i) (D.f' j i))
            else
              pullback.map (D.f' i j) (D.f' i i) (D.f i j hij) (D.f i i hik) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯ ⋯ ≫
                D.t' i j i hij hik hjk ≫
                  pullback.map (D.f j i hjk) (D.f j i ⋯) (D.f' j i) (D.f' j i) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯
                    ⋯) ≫
        (if hij : j = i then
            (pullbackSymmetry (D.f' j i) (D.f' j i)).hom ≫
              pullback.map (D.f' j i) (D.f' j i) (D.f' i i) (D.f' i j) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯ ⋯
          else
            if hik : j = i then
              have this := ⋯;
              pullback.fst (D.f' j i) (D.f' j i) ≫
                eqToHom ⋯ ≫ D.t j i hij ≫ eqToHom ⋯ ≫ inv (pullback.snd (D.f' i i) (D.f' i j))
            else
              if hjk : i = i then
                have this := ⋯;
                pullback.fst (D.f' j i) (D.f' j i) ≫
                  eqToHom ⋯ ≫ D.t j i hij ≫ eqToHom ⋯ ≫ inv (pullback.snd (D.f' i i) (D.f' i j))
              else
                pullback.map (D.f' j i) (D.f' j i) (D.f j i hij) (D.f j i hik) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯ ⋯ ≫
                  D.t' j i i hij hik hjk ≫
                    pullback.map (D.f i i hjk) (D.f i j ⋯) (D.f' i i) (D.f' i j) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯
                      ⋯) ≫
          if hij : i = i then
            (pullbackSymmetry (D.f' i i) (D.f' i j)).hom ≫
              pullback.map (D.f' i j) (D.f' i i) (D.f' i j) (D.f' i i) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯ ⋯
          else
            if hik : i = j then
              have this := ⋯;
              pullback.fst (D.f' i i) (D.f' i j) ≫
                eqToHom ⋯ ≫ D.t i i hij ≫ eqToHom ⋯ ≫ inv (pullback.snd (D.f' i j) (D.f' i i))
            else
              if hjk : i = j then
                have this := ⋯;
                pullback.fst (D.f' i i) (D.f' i j) ≫
                  eqToHom ⋯ ≫ D.t i i hij ≫ eqToHom ⋯ ≫ inv (pullback.snd (D.f' i j) (D.f' i i))
              else
                pullback.map (D.f' i i) (D.f' i j) (D.f i i hij) (D.f i j hik) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯ ⋯ ≫
                  D.t' i i j hij hik hjk ≫
                    pullback.map (D.f i j hjk) (D.f i i ⋯) (D.f' i j) (D.f' i i) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯
                      ⋯) ≫
      pullback.fst (D.f' i j) (D.f' i i) =
    𝟙 (pullback (D.f' i j) (D.f' i i)) ≫ pullback.fst (D.f' i j) (D.f' i i)

pp: case h₁
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData' C
i j : D.J
hij : ¬i = j
⊢ ((if hij : i = j then
          (pullbackSymmetry (D.f' i j) (D.f' i i)).hom ≫
            pullback.map (D.f' i i) (D.f' i j) (D.f' j i) (D.f' j i) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯ ⋯
        else
          if hik : i = i then
            have this := ⋯;
            pullback.fst (D.f' i j) (D.f' i i) ≫
              eqToHom ⋯ ≫ D.t i j hij ≫ eqToHom ⋯ ≫ inv (pullback.snd (D.f' j i) (D.f' j i))
          else
            if hjk : j = i then
              have this := ⋯;
              pullback.fst (D.f' i j) (D.f' i i) ≫
                eqToHom ⋯ ≫ D.t i j hij ≫ eqToHom ⋯ ≫ inv (pullback.snd (D.f' j i) (D.f' j i))
            else
              pullback.map (D.f' i j) (D.f' i i) (D.f i j hij) (D.f i i hik) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯ ⋯ ≫
                D.t' i j i hij hik hjk ≫
                  pullback.map (D.f j i hjk) (D.f j i ⋯) (D.f' j i) (D.f' j i) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯
                    ⋯) ≫
        (if hij : j = i then
            (pullbackSymmetry (D.f' j i) (D.f' j i)).hom ≫
              pullback.map (D.f' j i) (D.f' j i) (D.f' i i) (D.f' i j) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯ ⋯
          else
            if hik : j = i then
              have this := ⋯;
              pullback.fst (D.f' j i) (D.f' j i) ≫
                eqToHom ⋯ ≫ D.t j i hij ≫ eqToHom ⋯ ≫ inv (pullback.snd (D.f' i i) (D.f' i j))
            else
              if hjk : i = i then
                have this := ⋯;
                pullback.fst (D.f' j i) (D.f' j i) ≫
                  eqToHom ⋯ ≫ D.t j i hij ≫ eqToHom ⋯ ≫ inv (pullback.snd (D.f' i i) (D.f' i j))
              else
                pullback.map (D.f' j i) (D.f' j i) (D.f j i hij) (D.f j i hik) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯ ⋯ ≫
                  D.t' j i i hij hik hjk ≫
                    pullback.map (D.f i i hjk) (D.f i j ⋯) (D.f' i i) (D.f' i j) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯
                      ⋯) ≫
          if hij : i = i then
            (pullbackSymmetry (D.f' i i) (D.f' i j)).hom ≫
              pullback.map (D.f' i j) (D.f' i i) (D.f' i j) (D.f' i i) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯ ⋯
          else
            if hik : i = j then
              have this := ⋯;
              pullback.fst (D.f' i i) (D.f' i j) ≫
                eqToHom ⋯ ≫ D.t i i hij ≫ eqToHom ⋯ ≫ inv (pullback.snd (D.f' i j) (D.f' i i))
            else
              if hjk : i = j then
                have this := ⋯;
                pullback.fst (D.f' i i) (D.f' i j) ≫
                  eqToHom ⋯ ≫ D.t i i hij ≫ eqToHom ⋯ ≫ inv (pullback.snd (D.f' i j) (D.f' i i))
              else
                pullback.map (D.f' i i) (D.f' i j) (D.f i i hij) (D.f i j hik) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯ ⋯ ≫
                  D.t' i i j hij hik hjk ≫
                    pullback.map (D.f i j hjk) (D.f i i ⋯) (D.f' i j) (D.f' i i) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯
                      ⋯) ≫
      pullback.snd (D.f' i j) (D.f' i i) =
    𝟙 (pullback (D.f' i j) (D.f' i i)) ≫ pullback.snd (D.f' i j) (D.f' i i)

Tactic:
<;>

Goal state after:
case h₀
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData' C
i j : D.J
hij : ¬i = j
⊢ ((if hij : i = j then
          (pullbackSymmetry (D.f' i j) (D.f' i i)).hom ≫
            pullback.map (D.f' i i) (D.f' i j) (D.f' j i) (D.f' j i) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯ ⋯
        else
          if hik : i = i then
            have this := ⋯;
            pullback.fst (D.f' i j) (D.f' i i) ≫
              eqToHom ⋯ ≫ D.t i j hij ≫ eqToHom ⋯ ≫ inv (pullback.snd (D.f' j i) (D.f' j i))
          else
            if hjk : j = i then
              have this := ⋯;
              pullback.fst (D.f' i j) (D.f' i i) ≫
                eqToHom ⋯ ≫ D.t i j hij ≫ eqToHom ⋯ ≫ inv (pullback.snd (D.f' j i) (D.f' j i))
            else
              pullback.map (D.f' i j) (D.f' i i) (D.f i j hij) (D.f i i hik) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯ ⋯ ≫
                D.t' i j i hij hik hjk ≫
                  pullback.map (D.f j i hjk) (D.f j i ⋯) (D.f' j i) (D.f' j i) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯
                    ⋯) ≫
        (if hij : j = i then
            (pullbackSymmetry (D.f' j i) (D.f' j i)).hom ≫
              pullback.map (D.f' j i) (D.f' j i) (D.f' i i) (D.f' i j) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯ ⋯
          else
            if hik : j = i then
              have this := ⋯;
              pullback.fst (D.f' j i) (D.f' j i) ≫
                eqToHom ⋯ ≫ D.t j i hij ≫ eqToHom ⋯ ≫ inv (pullback.snd (D.f' i i) (D.f' i j))
            else
              if hjk : i = i then
                have this := ⋯;
                pullback.fst (D.f' j i) (D.f' j i) ≫
                  eqToHom ⋯ ≫ D.t j i hij ≫ eqToHom ⋯ ≫ inv (pullback.snd (D.f' i i) (D.f' i j))
              else
                pullback.map (D.f' j i) (D.f' j i) (D.f j i hij) (D.f j i hik) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯ ⋯ ≫
                  D.t' j i i hij hik hjk ≫
                    pullback.map (D.f i i hjk) (D.f i j ⋯) (D.f' i i) (D.f' i j) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯
                      ⋯) ≫
          if hij : i = i then
            (pullbackSymmetry (D.f' i i) (D.f' i j)).hom ≫
              pullback.map (D.f' i j) (D.f' i i) (D.f' i j) (D.f' i i) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯ ⋯
          else
            if hik : i = j then
              have this := ⋯;
              pullback.fst (D.f' i i) (D.f' i j) ≫
                eqToHom ⋯ ≫ D.t i i hij ≫ eqToHom ⋯ ≫ inv (pullback.snd (D.f' i j) (D.f' i i))
            else
              if hjk : i = j then
                have this := ⋯;
                pullback.fst (D.f' i i) (D.f' i j) ≫
                  eqToHom ⋯ ≫ D.t i i hij ≫ eqToHom ⋯ ≫ inv (pullback.snd (D.f' i j) (D.f' i i))
              else
                pullback.map (D.f' i i) (D.f' i j) (D.f i i hij) (D.f i j hik) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯ ⋯ ≫
                  D.t' i i j hij hik hjk ≫
                    pullback.map (D.f i j hjk) (D.f i i ⋯) (D.f' i j) (D.f' i i) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯
                      ⋯) ≫
      pullback.fst (D.f' i j) (D.f' i i) =
    𝟙 (pullback (D.f' i j) (D.f' i i)) ≫ pullback.fst (D.f' i j) (D.f' i i)

case h₁
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData' C
i j : D.J
hij : ¬i = j
⊢ ((if hij : i = j then
          (pullbackSymmetry (D.f' i j) (D.f' i i)).hom ≫
            pullback.map (D.f' i i) (D.f' i j) (D.f' j i) (D.f' j i) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯ ⋯
        else
          if hik : i = i then
            have this := ⋯;
            pullback.fst (D.f' i j) (D.f' i i) ≫
              eqToHom ⋯ ≫ D.t i j hij ≫ eqToHom ⋯ ≫ inv (pullback.snd (D.f' j i) (D.f' j i))
          else
            if hjk : j = i then
              have this := ⋯;
              pullback.fst (D.f' i j) (D.f' i i) ≫
                eqToHom ⋯ ≫ D.t i j hij ≫ eqToHom ⋯ ≫ inv (pullback.snd (D.f' j i) (D.f' j i))
            else
              pullback.map (D.f' i j) (D.f' i i) (D.f i j hij) (D.f i i hik) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯ ⋯ ≫
                D.t' i j i hij hik hjk ≫
                  pullback.map (D.f j i hjk) (D.f j i ⋯) (D.f' j i) (D.f' j i) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯
                    ⋯) ≫
        (if hij : j = i then
            (pullbackSymmetry (D.f' j i) (D.f' j i)).hom ≫
              pullback.map (D.f' j i) (D.f' j i) (D.f' i i) (D.f' i j) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯ ⋯
          else
            if hik : j = i then
              have this := ⋯;
              pullback.fst (D.f' j i) (D.f' j i) ≫
                eqToHom ⋯ ≫ D.t j i hij ≫ eqToHom ⋯ ≫ inv (pullback.snd (D.f' i i) (D.f' i j))
            else
              if hjk : i = i then
                have this := ⋯;
                pullback.fst (D.f' j i) (D.f' j i) ≫
                  eqToHom ⋯ ≫ D.t j i hij ≫ eqToHom ⋯ ≫ inv (pullback.snd (D.f' i i) (D.f' i j))
              else
                pullback.map (D.f' j i) (D.f' j i) (D.f j i hij) (D.f j i hik) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯ ⋯ ≫
                  D.t' j i i hij hik hjk ≫
                    pullback.map (D.f i i hjk) (D.f i j ⋯) (D.f' i i) (D.f' i j) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯
                      ⋯) ≫
          if hij : i = i then
            (pullbackSymmetry (D.f' i i) (D.f' i j)).hom ≫
              pullback.map (D.f' i j) (D.f' i i) (D.f' i j) (D.f' i i) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯ ⋯
          else
            if hik : i = j then
              have this := ⋯;
              pullback.fst (D.f' i i) (D.f' i j) ≫
                eqToHom ⋯ ≫ D.t i i hij ≫ eqToHom ⋯ ≫ inv (pullback.snd (D.f' i j) (D.f' i i))
            else
              if hjk : i = j then
                have this := ⋯;
                pullback.fst (D.f' i i) (D.f' i j) ≫
                  eqToHom ⋯ ≫ D.t i i hij ≫ eqToHom ⋯ ≫ inv (pullback.snd (D.f' i j) (D.f' i i))
              else
                pullback.map (D.f' i i) (D.f' i j) (D.f i i hij) (D.f i j hik) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯ ⋯ ≫
                  D.t' i i j hij hik hjk ≫
                    pullback.map (D.f i j hjk) (D.f i i ⋯) (D.f' i j) (D.f' i i) (eqToHom ⋯) (eqToHom ⋯) (eqToHom ⋯) ⋯
                      ⋯) ≫
      pullback.snd (D.f' i j) (D.f' i i) =
    𝟙 (pullback (D.f' i j) (D.f' i i)) ≫ pullback.snd (D.f' i j) (D.f' i i)