[GOAL]
α β : FinBddDistLatCat
e : ↑α.toBddDistLatCat.toDistLatCat ≃o ↑β.toBddDistLatCat.toDistLatCat
⊢ ((let src :=
        {
          toSupHom :=
            { toFun := ↑e, map_sup' := (_ : ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
          map_inf' := (_ : ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) };
      {
        toLatticeHom :=
          {
            toSupHom :=
              { toFun := ↑e,
                map_sup' :=
                  (_ :
                    ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat),
                      SupHom.toFun
                          {
                              toSupHom :=
                                { toFun := ↑e,
                                  map_sup' :=
                                    (_ : ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
                              map_inf' :=
                                (_ : ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) }.toSupHom
                          (a ⊔ b) =
                        SupHom.toFun
                            {
                                toSupHom :=
                                  { toFun := ↑e,
                                    map_sup' :=
                                      (_ : ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
                                map_inf' :=
                                  (_ : ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) }.toSupHom
                            a ⊔
                          SupHom.toFun
                            {
                                toSupHom :=
                                  { toFun := ↑e,
                                    map_sup' :=
                                      (_ : ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
                                map_inf' :=
                                  (_ : ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) }.toSupHom
                            b) },
            map_inf' :=
              (_ :
                ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat),
                  SupHom.toFun src.toSupHom (a ⊓ b) = SupHom.toFun src.toSupHom a ⊓ SupHom.toFun src.toSupHom b) },
        map_top' := (_ : ↑e ⊤ = ⊤), map_bot' := (_ : ↑e ⊥ = ⊥) }) ≫
      let src :=
        {
          toSupHom :=
            { toFun := ↑(OrderIso.symm e),
              map_sup' :=
                (_ :
                  ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                    ↑(OrderIso.symm e) (a ⊔ b) = ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
          map_inf' :=
            (_ :
              ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                ↑(OrderIso.symm e) (a ⊓ b) = ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) };
      {
        toLatticeHom :=
          {
            toSupHom :=
              { toFun := ↑(OrderIso.symm e),
                map_sup' :=
                  (_ :
                    ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                      SupHom.toFun
                          {
                              toSupHom :=
                                { toFun := ↑(OrderIso.symm e),
                                  map_sup' :=
                                    (_ :
                                      ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                                        ↑(OrderIso.symm e) (a ⊔ b) = ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
                              map_inf' :=
                                (_ :
                                  ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                                    ↑(OrderIso.symm e) (a ⊓ b) = ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) }.toSupHom
                          (a ⊔ b) =
                        SupHom.toFun
                            {
                                toSupHom :=
                                  { toFun := ↑(OrderIso.symm e),
                                    map_sup' :=
                                      (_ :
                                        ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                                          ↑(OrderIso.symm e) (a ⊔ b) = ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
                                map_inf' :=
                                  (_ :
                                    ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                                      ↑(OrderIso.symm e) (a ⊓ b) =
                                        ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) }.toSupHom
                            a ⊔
                          SupHom.toFun
                            {
                                toSupHom :=
                                  { toFun := ↑(OrderIso.symm e),
                                    map_sup' :=
                                      (_ :
                                        ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                                          ↑(OrderIso.symm e) (a ⊔ b) = ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
                                map_inf' :=
                                  (_ :
                                    ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                                      ↑(OrderIso.symm e) (a ⊓ b) =
                                        ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) }.toSupHom
                            b) },
            map_inf' :=
              (_ :
                ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                  SupHom.toFun src.toSupHom (a ⊓ b) = SupHom.toFun src.toSupHom a ⊓ SupHom.toFun src.toSupHom b) },
        map_top' := (_ : ↑(OrderIso.symm e) ⊤ = ⊤), map_bot' := (_ : ↑(OrderIso.symm e) ⊥ = ⊥) }) =
    𝟙 α
[PROOFSTEP]
ext
[GOAL]
case w
α β : FinBddDistLatCat
e : ↑α.toBddDistLatCat.toDistLatCat ≃o ↑β.toBddDistLatCat.toDistLatCat
x✝ : (forget FinBddDistLatCat).obj α
⊢ ↑((let src :=
            {
              toSupHom :=
                { toFun := ↑e, map_sup' := (_ : ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
              map_inf' := (_ : ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) };
          {
            toLatticeHom :=
              {
                toSupHom :=
                  { toFun := ↑e,
                    map_sup' :=
                      (_ :
                        ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat),
                          SupHom.toFun
                              {
                                  toSupHom :=
                                    { toFun := ↑e,
                                      map_sup' :=
                                        (_ : ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
                                  map_inf' :=
                                    (_ : ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) }.toSupHom
                              (a ⊔ b) =
                            SupHom.toFun
                                {
                                    toSupHom :=
                                      { toFun := ↑e,
                                        map_sup' :=
                                          (_ : ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
                                    map_inf' :=
                                      (_ :
                                        ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) }.toSupHom
                                a ⊔
                              SupHom.toFun
                                {
                                    toSupHom :=
                                      { toFun := ↑e,
                                        map_sup' :=
                                          (_ : ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
                                    map_inf' :=
                                      (_ :
                                        ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) }.toSupHom
                                b) },
                map_inf' :=
                  (_ :
                    ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat),
                      SupHom.toFun src.toSupHom (a ⊓ b) = SupHom.toFun src.toSupHom a ⊓ SupHom.toFun src.toSupHom b) },
            map_top' := (_ : ↑e ⊤ = ⊤), map_bot' := (_ : ↑e ⊥ = ⊥) }) ≫
          let src :=
            {
              toSupHom :=
                { toFun := ↑(OrderIso.symm e),
                  map_sup' :=
                    (_ :
                      ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                        ↑(OrderIso.symm e) (a ⊔ b) = ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
              map_inf' :=
                (_ :
                  ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                    ↑(OrderIso.symm e) (a ⊓ b) = ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) };
          {
            toLatticeHom :=
              {
                toSupHom :=
                  { toFun := ↑(OrderIso.symm e),
                    map_sup' :=
                      (_ :
                        ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                          SupHom.toFun
                              {
                                  toSupHom :=
                                    { toFun := ↑(OrderIso.symm e),
                                      map_sup' :=
                                        (_ :
                                          ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                                            ↑(OrderIso.symm e) (a ⊔ b) = ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
                                  map_inf' :=
                                    (_ :
                                      ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                                        ↑(OrderIso.symm e) (a ⊓ b) =
                                          ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) }.toSupHom
                              (a ⊔ b) =
                            SupHom.toFun
                                {
                                    toSupHom :=
                                      { toFun := ↑(OrderIso.symm e),
                                        map_sup' :=
                                          (_ :
                                            ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                                              ↑(OrderIso.symm e) (a ⊔ b) =
                                                ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
                                    map_inf' :=
                                      (_ :
                                        ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                                          ↑(OrderIso.symm e) (a ⊓ b) =
                                            ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) }.toSupHom
                                a ⊔
                              SupHom.toFun
                                {
                                    toSupHom :=
                                      { toFun := ↑(OrderIso.symm e),
                                        map_sup' :=
                                          (_ :
                                            ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                                              ↑(OrderIso.symm e) (a ⊔ b) =
                                                ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
                                    map_inf' :=
                                      (_ :
                                        ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                                          ↑(OrderIso.symm e) (a ⊓ b) =
                                            ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) }.toSupHom
                                b) },
                map_inf' :=
                  (_ :
                    ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                      SupHom.toFun src.toSupHom (a ⊓ b) = SupHom.toFun src.toSupHom a ⊓ SupHom.toFun src.toSupHom b) },
            map_top' := (_ : ↑(OrderIso.symm e) ⊤ = ⊤), map_bot' := (_ : ↑(OrderIso.symm e) ⊥ = ⊥) })
      x✝ =
    ↑(𝟙 α) x✝
[PROOFSTEP]
exact e.symm_apply_apply _
[GOAL]
α β : FinBddDistLatCat
e : ↑α.toBddDistLatCat.toDistLatCat ≃o ↑β.toBddDistLatCat.toDistLatCat
⊢ ((let src :=
        {
          toSupHom :=
            { toFun := ↑(OrderIso.symm e),
              map_sup' :=
                (_ :
                  ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                    ↑(OrderIso.symm e) (a ⊔ b) = ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
          map_inf' :=
            (_ :
              ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                ↑(OrderIso.symm e) (a ⊓ b) = ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) };
      {
        toLatticeHom :=
          {
            toSupHom :=
              { toFun := ↑(OrderIso.symm e),
                map_sup' :=
                  (_ :
                    ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                      SupHom.toFun
                          {
                              toSupHom :=
                                { toFun := ↑(OrderIso.symm e),
                                  map_sup' :=
                                    (_ :
                                      ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                                        ↑(OrderIso.symm e) (a ⊔ b) = ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
                              map_inf' :=
                                (_ :
                                  ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                                    ↑(OrderIso.symm e) (a ⊓ b) = ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) }.toSupHom
                          (a ⊔ b) =
                        SupHom.toFun
                            {
                                toSupHom :=
                                  { toFun := ↑(OrderIso.symm e),
                                    map_sup' :=
                                      (_ :
                                        ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                                          ↑(OrderIso.symm e) (a ⊔ b) = ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
                                map_inf' :=
                                  (_ :
                                    ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                                      ↑(OrderIso.symm e) (a ⊓ b) =
                                        ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) }.toSupHom
                            a ⊔
                          SupHom.toFun
                            {
                                toSupHom :=
                                  { toFun := ↑(OrderIso.symm e),
                                    map_sup' :=
                                      (_ :
                                        ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                                          ↑(OrderIso.symm e) (a ⊔ b) = ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
                                map_inf' :=
                                  (_ :
                                    ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                                      ↑(OrderIso.symm e) (a ⊓ b) =
                                        ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) }.toSupHom
                            b) },
            map_inf' :=
              (_ :
                ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                  SupHom.toFun src.toSupHom (a ⊓ b) = SupHom.toFun src.toSupHom a ⊓ SupHom.toFun src.toSupHom b) },
        map_top' := (_ : ↑(OrderIso.symm e) ⊤ = ⊤), map_bot' := (_ : ↑(OrderIso.symm e) ⊥ = ⊥) }) ≫
      let src :=
        {
          toSupHom :=
            { toFun := ↑e, map_sup' := (_ : ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
          map_inf' := (_ : ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) };
      {
        toLatticeHom :=
          {
            toSupHom :=
              { toFun := ↑e,
                map_sup' :=
                  (_ :
                    ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat),
                      SupHom.toFun
                          {
                              toSupHom :=
                                { toFun := ↑e,
                                  map_sup' :=
                                    (_ : ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
                              map_inf' :=
                                (_ : ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) }.toSupHom
                          (a ⊔ b) =
                        SupHom.toFun
                            {
                                toSupHom :=
                                  { toFun := ↑e,
                                    map_sup' :=
                                      (_ : ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
                                map_inf' :=
                                  (_ : ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) }.toSupHom
                            a ⊔
                          SupHom.toFun
                            {
                                toSupHom :=
                                  { toFun := ↑e,
                                    map_sup' :=
                                      (_ : ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
                                map_inf' :=
                                  (_ : ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) }.toSupHom
                            b) },
            map_inf' :=
              (_ :
                ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat),
                  SupHom.toFun src.toSupHom (a ⊓ b) = SupHom.toFun src.toSupHom a ⊓ SupHom.toFun src.toSupHom b) },
        map_top' := (_ : ↑e ⊤ = ⊤), map_bot' := (_ : ↑e ⊥ = ⊥) }) =
    𝟙 β
[PROOFSTEP]
ext
[GOAL]
case w
α β : FinBddDistLatCat
e : ↑α.toBddDistLatCat.toDistLatCat ≃o ↑β.toBddDistLatCat.toDistLatCat
x✝ : (forget FinBddDistLatCat).obj β
⊢ ↑((let src :=
            {
              toSupHom :=
                { toFun := ↑(OrderIso.symm e),
                  map_sup' :=
                    (_ :
                      ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                        ↑(OrderIso.symm e) (a ⊔ b) = ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
              map_inf' :=
                (_ :
                  ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                    ↑(OrderIso.symm e) (a ⊓ b) = ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) };
          {
            toLatticeHom :=
              {
                toSupHom :=
                  { toFun := ↑(OrderIso.symm e),
                    map_sup' :=
                      (_ :
                        ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                          SupHom.toFun
                              {
                                  toSupHom :=
                                    { toFun := ↑(OrderIso.symm e),
                                      map_sup' :=
                                        (_ :
                                          ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                                            ↑(OrderIso.symm e) (a ⊔ b) = ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
                                  map_inf' :=
                                    (_ :
                                      ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                                        ↑(OrderIso.symm e) (a ⊓ b) =
                                          ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) }.toSupHom
                              (a ⊔ b) =
                            SupHom.toFun
                                {
                                    toSupHom :=
                                      { toFun := ↑(OrderIso.symm e),
                                        map_sup' :=
                                          (_ :
                                            ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                                              ↑(OrderIso.symm e) (a ⊔ b) =
                                                ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
                                    map_inf' :=
                                      (_ :
                                        ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                                          ↑(OrderIso.symm e) (a ⊓ b) =
                                            ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) }.toSupHom
                                a ⊔
                              SupHom.toFun
                                {
                                    toSupHom :=
                                      { toFun := ↑(OrderIso.symm e),
                                        map_sup' :=
                                          (_ :
                                            ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                                              ↑(OrderIso.symm e) (a ⊔ b) =
                                                ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
                                    map_inf' :=
                                      (_ :
                                        ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                                          ↑(OrderIso.symm e) (a ⊓ b) =
                                            ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) }.toSupHom
                                b) },
                map_inf' :=
                  (_ :
                    ∀ (a b : ↑β.toBddDistLatCat.toDistLatCat),
                      SupHom.toFun src.toSupHom (a ⊓ b) = SupHom.toFun src.toSupHom a ⊓ SupHom.toFun src.toSupHom b) },
            map_top' := (_ : ↑(OrderIso.symm e) ⊤ = ⊤), map_bot' := (_ : ↑(OrderIso.symm e) ⊥ = ⊥) }) ≫
          let src :=
            {
              toSupHom :=
                { toFun := ↑e, map_sup' := (_ : ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
              map_inf' := (_ : ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) };
          {
            toLatticeHom :=
              {
                toSupHom :=
                  { toFun := ↑e,
                    map_sup' :=
                      (_ :
                        ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat),
                          SupHom.toFun
                              {
                                  toSupHom :=
                                    { toFun := ↑e,
                                      map_sup' :=
                                        (_ : ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
                                  map_inf' :=
                                    (_ : ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) }.toSupHom
                              (a ⊔ b) =
                            SupHom.toFun
                                {
                                    toSupHom :=
                                      { toFun := ↑e,
                                        map_sup' :=
                                          (_ : ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
                                    map_inf' :=
                                      (_ :
                                        ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) }.toSupHom
                                a ⊔
                              SupHom.toFun
                                {
                                    toSupHom :=
                                      { toFun := ↑e,
                                        map_sup' :=
                                          (_ : ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
                                    map_inf' :=
                                      (_ :
                                        ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) }.toSupHom
                                b) },
                map_inf' :=
                  (_ :
                    ∀ (a b : ↑α.toBddDistLatCat.toDistLatCat),
                      SupHom.toFun src.toSupHom (a ⊓ b) = SupHom.toFun src.toSupHom a ⊓ SupHom.toFun src.toSupHom b) },
            map_top' := (_ : ↑e ⊤ = ⊤), map_bot' := (_ : ↑e ⊥ = ⊥) })
      x✝ =
    ↑(𝟙 β) x✝
[PROOFSTEP]
exact e.apply_symm_apply _


[GOAL]
C : Type u
inst✝¹⁰ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁹ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁸ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁷ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁶ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝⁵ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝⁴ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝³ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝² : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P✝ P : Cᵒᵖ ⥤ D
inst✝¹ : (F : D ⥤ E) → (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ :
  (F : D ⥤ E) →
    (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
⊢ (whiskeringLeft Cᵒᵖ D E).obj (sheafify J P) ≅ (whiskeringLeft Cᵒᵖ D E).obj P ⋙ sheafification J E
[PROOFSTEP]
refine' J.plusFunctorWhiskerLeftIso _ ≪≫ _ ≪≫ Functor.associator _ _ _
[GOAL]
C : Type u
inst✝¹⁰ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁹ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁸ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁷ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁶ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝⁵ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝⁴ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝³ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝² : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P✝ P : Cᵒᵖ ⥤ D
inst✝¹ : (F : D ⥤ E) → (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ :
  (F : D ⥤ E) →
    (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
⊢ (whiskeringLeft Cᵒᵖ D E).obj (plusObj J P) ⋙ plusFunctor J E ≅
    ((whiskeringLeft Cᵒᵖ D E).obj P ⋙ plusFunctor J E) ⋙ plusFunctor J E
[PROOFSTEP]
refine' isoWhiskerRight _ _
[GOAL]
C : Type u
inst✝¹⁰ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁹ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁸ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁷ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁶ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝⁵ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝⁴ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝³ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝² : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P✝ P : Cᵒᵖ ⥤ D
inst✝¹ : (F : D ⥤ E) → (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ :
  (F : D ⥤ E) →
    (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
⊢ (whiskeringLeft Cᵒᵖ D E).obj (plusObj J P) ≅ (whiskeringLeft Cᵒᵖ D E).obj P ⋙ plusFunctor J E
[PROOFSTEP]
refine' J.plusFunctorWhiskerLeftIso _
[GOAL]
C : Type u
inst✝¹⁰ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁹ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁸ : Category.{max v u, w₂} E
F✝ : D ⥤ E
inst✝⁷ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁶ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝⁵ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝⁴ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝³ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F✝
inst✝² : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F✝
P✝ P : Cᵒᵖ ⥤ D
F : D ⥤ E
inst✝¹ : (F : D ⥤ E) → (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ :
  (F : D ⥤ E) →
    (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
⊢ NatTrans.app (sheafificationWhiskerLeftIso J P).hom F = (sheafifyCompIso J F P).hom
[PROOFSTEP]
dsimp [sheafificationWhiskerLeftIso, sheafifyCompIso]
[GOAL]
C : Type u
inst✝¹⁰ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁹ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁸ : Category.{max v u, w₂} E
F✝ : D ⥤ E
inst✝⁷ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁶ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝⁵ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝⁴ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝³ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F✝
inst✝² : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F✝
P✝ P : Cᵒᵖ ⥤ D
F : D ⥤ E
inst✝¹ : (F : D ⥤ E) → (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ :
  (F : D ⥤ E) →
    (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
⊢ (plusCompIso J F (plusObj J P)).hom ≫ plusMap J (plusCompIso J F P).hom ≫ 𝟙 (plusObj J (plusObj J (P ⋙ F))) =
    (plusCompIso J F (plusObj J P)).hom ≫ plusMap J (plusCompIso J F P).hom
[PROOFSTEP]
rw [Category.comp_id]
[GOAL]
C : Type u
inst✝¹⁰ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁹ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁸ : Category.{max v u, w₂} E
F✝ : D ⥤ E
inst✝⁷ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁶ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝⁵ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝⁴ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝³ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F✝
inst✝² : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F✝
P✝ P : Cᵒᵖ ⥤ D
F : D ⥤ E
inst✝¹ : (F : D ⥤ E) → (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ :
  (F : D ⥤ E) →
    (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
⊢ NatTrans.app (sheafificationWhiskerLeftIso J P).inv F = (sheafifyCompIso J F P).inv
[PROOFSTEP]
dsimp [sheafificationWhiskerLeftIso, sheafifyCompIso]
[GOAL]
C : Type u
inst✝¹⁰ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁹ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁸ : Category.{max v u, w₂} E
F✝ : D ⥤ E
inst✝⁷ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁶ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝⁵ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝⁴ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝³ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F✝
inst✝² : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F✝
P✝ P : Cᵒᵖ ⥤ D
F : D ⥤ E
inst✝¹ : (F : D ⥤ E) → (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ :
  (F : D ⥤ E) →
    (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
⊢ (𝟙 (plusObj J (plusObj J (P ⋙ F))) ≫ plusMap J (plusCompIso J F P).inv) ≫ (plusCompIso J F (plusObj J P)).inv =
    plusMap J (plusCompIso J F P).inv ≫ (plusCompIso J F (plusObj J P)).inv
[PROOFSTEP]
erw [Category.id_comp]
[GOAL]
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
⊢ sheafification J D ⋙ (whiskeringRight Cᵒᵖ D E).obj F ≅ (whiskeringRight Cᵒᵖ D E).obj F ⋙ sheafification J E
[PROOFSTEP]
refine' Functor.associator _ _ _ ≪≫ _
[GOAL]
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
⊢ plusFunctor J D ⋙ plusFunctor J D ⋙ (whiskeringRight Cᵒᵖ D E).obj F ≅
    (whiskeringRight Cᵒᵖ D E).obj F ⋙ sheafification J E
[PROOFSTEP]
refine' isoWhiskerLeft (J.plusFunctor D) (J.plusFunctorWhiskerRightIso _) ≪≫ _
[GOAL]
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
⊢ plusFunctor J D ⋙ (whiskeringRight Cᵒᵖ D E).obj F ⋙ plusFunctor J E ≅
    (whiskeringRight Cᵒᵖ D E).obj F ⋙ sheafification J E
[PROOFSTEP]
refine' _ ≪≫ Functor.associator _ _ _
[GOAL]
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
⊢ plusFunctor J D ⋙ (whiskeringRight Cᵒᵖ D E).obj F ⋙ plusFunctor J E ≅
    ((whiskeringRight Cᵒᵖ D E).obj F ⋙ plusFunctor J E) ⋙ plusFunctor J E
[PROOFSTEP]
refine' (Functor.associator _ _ _).symm ≪≫ _
[GOAL]
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
⊢ (plusFunctor J D ⋙ (whiskeringRight Cᵒᵖ D E).obj F) ⋙ plusFunctor J E ≅
    ((whiskeringRight Cᵒᵖ D E).obj F ⋙ plusFunctor J E) ⋙ plusFunctor J E
[PROOFSTEP]
exact isoWhiskerRight (J.plusFunctorWhiskerRightIso _) (J.plusFunctor E)
[GOAL]
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
⊢ NatTrans.app (sheafificationWhiskerRightIso J F).hom P = (sheafifyCompIso J F P).hom
[PROOFSTEP]
dsimp [sheafificationWhiskerRightIso, sheafifyCompIso]
[GOAL]
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
⊢ 𝟙 (plusObj J (plusObj J P) ⋙ F) ≫
      (plusCompIso J F (plusObj J P)).hom ≫
        (𝟙 (plusObj J (plusObj J P ⋙ F)) ≫ plusMap J (plusCompIso J F P).hom) ≫ 𝟙 (plusObj J (plusObj J (P ⋙ F))) =
    (plusCompIso J F (plusObj J P)).hom ≫ plusMap J (plusCompIso J F P).hom
[PROOFSTEP]
simp only [Category.id_comp, Category.comp_id]
[GOAL]
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
⊢ 𝟙 (plusObj J (plusObj J P) ⋙ F) ≫ (plusCompIso J F (plusObj J P)).hom ≫ plusMap J (plusCompIso J F P).hom =
    (plusCompIso J F (plusObj J P)).hom ≫ plusMap J (plusCompIso J F P).hom
[PROOFSTEP]
erw [Category.id_comp]
[GOAL]
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
⊢ NatTrans.app (sheafificationWhiskerRightIso J F).inv P = (sheafifyCompIso J F P).inv
[PROOFSTEP]
dsimp [sheafificationWhiskerRightIso, sheafifyCompIso]
[GOAL]
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
⊢ ((𝟙 (plusObj J (plusObj J (P ⋙ F))) ≫ plusMap J (plusCompIso J F P).inv ≫ 𝟙 (plusObj J (plusObj J P ⋙ F))) ≫
        (plusCompIso J F (plusObj J P)).inv) ≫
      𝟙 (plusObj J (plusObj J P) ⋙ F) =
    plusMap J (plusCompIso J F P).inv ≫ (plusCompIso J F (plusObj J P)).inv
[PROOFSTEP]
simp only [Category.id_comp, Category.comp_id]
[GOAL]
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
⊢ (𝟙 (plusObj J (plusObj J (P ⋙ F))) ≫ plusMap J (plusCompIso J F P).inv) ≫ (plusCompIso J F (plusObj J P)).inv =
    plusMap J (plusCompIso J F P).inv ≫ (plusCompIso J F (plusObj J P)).inv
[PROOFSTEP]
erw [Category.id_comp]
[GOAL]
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
⊢ whiskerRight (toSheafify J P) F ≫ (sheafifyCompIso J F P).hom = toSheafify J (P ⋙ F)
[PROOFSTEP]
dsimp [sheafifyCompIso]
[GOAL]
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
⊢ whiskerRight (toSheafify J P) F ≫ (plusCompIso J F (plusObj J P)).hom ≫ plusMap J (plusCompIso J F P).hom =
    toSheafify J (P ⋙ F)
[PROOFSTEP]
erw [whiskerRight_comp, Category.assoc]
[GOAL]
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
⊢ whiskerRight (toPlus J P) F ≫
      whiskerRight (plusMap J (toPlus J P)) F ≫
        (plusCompIso J F (plusObj J P)).hom ≫ plusMap J (plusCompIso J F P).hom =
    toSheafify J (P ⋙ F)
[PROOFSTEP]
slice_lhs 2 3 => rw [plusCompIso_whiskerRight]
[GOAL]
case a.a
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
| whiskerRight (plusMap J (toPlus J P)) F ≫ (plusCompIso J F (plusObj J P)).hom
case a.a
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
| plusMap J (plusCompIso J F P).hom
case a
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
| whiskerRight (toPlus J P) F
[PROOFSTEP]
rw [plusCompIso_whiskerRight]
[GOAL]
case a.a
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
| whiskerRight (plusMap J (toPlus J P)) F ≫ (plusCompIso J F (plusObj J P)).hom
case a.a
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
| plusMap J (plusCompIso J F P).hom
case a
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
| whiskerRight (toPlus J P) F
[PROOFSTEP]
rw [plusCompIso_whiskerRight]
[GOAL]
case a.a
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
| whiskerRight (plusMap J (toPlus J P)) F ≫ (plusCompIso J F (plusObj J P)).hom
case a.a
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
| plusMap J (plusCompIso J F P).hom
case a
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
| whiskerRight (toPlus J P) F
[PROOFSTEP]
rw [plusCompIso_whiskerRight]
[GOAL]
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
⊢ whiskerRight (toPlus J P) F ≫
      ((plusCompIso J F P).hom ≫ plusMap J (whiskerRight (toPlus J P) F)) ≫ plusMap J (plusCompIso J F P).hom =
    toSheafify J (P ⋙ F)
[PROOFSTEP]
rw [Category.assoc, ← J.plusMap_comp, whiskerRight_toPlus_comp_plusCompIso_hom, ← Category.assoc,
  whiskerRight_toPlus_comp_plusCompIso_hom]
[GOAL]
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
⊢ toPlus J (P ⋙ F) ≫ plusMap J (toPlus J (P ⋙ F)) = toSheafify J (P ⋙ F)
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
⊢ toSheafify J (P ⋙ F) ≫ (sheafifyCompIso J F P).inv = whiskerRight (toSheafify J P) F
[PROOFSTEP]
rw [Iso.comp_inv_eq]
[GOAL]
C : Type u
inst✝⁸ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝⁷ : Category.{max v u, w₁} D
E : Type w₂
inst✝⁶ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁵ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁴ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝³ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
⊢ toSheafify J (P ⋙ F) = whiskerRight (toSheafify J P) F ≫ (sheafifyCompIso J F P).hom
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝¹² : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝¹¹ : Category.{max v u, w₁} D
E : Type w₂
inst✝¹⁰ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁹ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁸ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝⁶ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝⁵ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝⁴ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
⊢ (sheafifyCompIso J F P).inv =
    sheafifyLift J (whiskerRight (toSheafify J P) F) (_ : Presheaf.IsSheaf J (sheafify J P ⋙ F))
[PROOFSTEP]
apply J.sheafifyLift_unique
[GOAL]
case a
C : Type u
inst✝¹² : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝¹¹ : Category.{max v u, w₁} D
E : Type w₂
inst✝¹⁰ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁹ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁸ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝⁶ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝⁵ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝⁴ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
⊢ toSheafify J (P ⋙ F) ≫ (sheafifyCompIso J F P).inv = whiskerRight (toSheafify J P) F
[PROOFSTEP]
rw [Iso.comp_inv_eq]
[GOAL]
case a
C : Type u
inst✝¹² : Category.{v, u} C
J : GrothendieckTopology C
D : Type w₁
inst✝¹¹ : Category.{max v u, w₁} D
E : Type w₂
inst✝¹⁰ : Category.{max v u, w₂} E
F : D ⥤ E
inst✝⁹ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) D
inst✝⁸ : ∀ (α β : Type (max v u)) (fst snd : β → α), HasLimitsOfShape (WalkingMulticospan fst snd) E
inst✝⁷ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝⁶ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ E
inst✝⁵ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ F
inst✝⁴ : (X : C) → (W : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index W P)) F
P : Cᵒᵖ ⥤ D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
⊢ toSheafify J (P ⋙ F) = whiskerRight (toSheafify J P) F ≫ (sheafifyCompIso J F P).hom
[PROOFSTEP]
simp