Products.v

Require Import Basics.Equivalences Basics.Overture Basics.Tactics.[Loading ML file number_string_notation_plugin.cmxs (using legacy method) ... done]
Require Import Types.Bool Types.Prod Types.Forall.
Require Import WildCat.Bifunctor WildCat.Core WildCat.Equiv WildCat.EquivGpd
               WildCat.Forall WildCat.NatTrans WildCat.Opposite
               WildCat.Universe WildCat.Yoneda WildCat.ZeroGroupoid
               WildCat.Monoidal WildCat.MonoidalTwistConstruction
               WildCat.FunctorCat.

(** * Categories with products *)

Definition cat_prod_corec_inv {I A : Type} `{Is1Cat A}
  (prod : A) (x : I -> A) (z : A) (pr : forall i, prod $-> x i)
  : yon_0gpd prod z $-> prod_0gpd I (fun i => yon_0gpd (x i) z).I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
prod: A
x: I -> A
z: A
pr: forall i : I, prod $-> x i
yon_0gpd prod z $->
prod_0gpd I (fun i : I => yon_0gpd (x i) z)
Proof.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
prod: A
x: I -> A
z: A
pr: forall i : I, prod $-> x i
yon_0gpd prod z $->
prod_0gpd I (fun i : I => yon_0gpd (x i) z)
  snapply equiv_prod_0gpd_corec.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
prod: A
x: I -> A
z: A
pr: forall i : I, prod $-> x i
forall i : I,
yon_0gpd prod z $->
(fun i0 : I => yon_0gpd (x i0) z) i
  intros i.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
prod: A
x: I -> A
z: A
pr: forall i : I, prod $-> x i
i: I
yon_0gpd prod z $-> (fun i : I => yon_0gpd (x i) z) i
  exact (fmap (fun x => yon_0gpd x z) (pr i)).
Defined.

(* A product of an [I]-indexed family of objects of a category is an object of the category with an [I]-indexed family of projections such that the induced map is an equivalence. *)
Class Product (I : Type) {A : Type} `{Is1Cat A} {x : I -> A} := Build_Product' {
  cat_prod : A;
  cat_pr : forall i : I, cat_prod $-> x i;
  cat_isequiv_cat_prod_corec_inv
    :: forall z : A, CatIsEquiv (cat_prod_corec_inv cat_prod x z cat_pr);
}.

Arguments Product I {A _ _ _ _} x.
Arguments cat_prod I {A _ _ _ _} x {product} : rename.

(** A convenience wrapper for building products *)
Definition Build_Product (I : Type) {A : Type} `{Is1Cat A} {x : I -> A}
  (cat_prod : A) (cat_pr : forall i : I, cat_prod $-> x i)
  (cat_prod_corec : forall z : A,
    (forall i : I, z $-> x i) -> (z $-> cat_prod))
  (cat_prod_beta_pr : forall (z : A) (f : forall i, z $-> x i) (i : I),
    cat_pr i $o cat_prod_corec z f $== f i)
  (cat_prod_eta_pr : forall (z : A) (f g : z $-> cat_prod),
    (forall i : I, cat_pr i $o f $== cat_pr i $o g) -> f $== g)
  : Product I x.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x: I -> A
cat_prod: A
cat_pr: forall i : I, cat_prod $-> x i
cat_prod_corec: forall z : A,
(forall i : I, z $-> x i) ->
z $-> cat_prod
cat_prod_beta_pr: forall (z : A)
(f : forall i : I, z $-> x i)
(i : I),
cat_pr i $o cat_prod_corec z f $==
f i
cat_prod_eta_pr: forall (z : A)
(f g : z $-> cat_prod),
(forall i : I,
 cat_pr i $o f $== cat_pr i $o g) ->
f $== g
Product I x
Proof.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x: I -> A
cat_prod: A
cat_pr: forall i : I, cat_prod $-> x i
cat_prod_corec: forall z : A,
(forall i : I, z $-> x i) ->
z $-> cat_prod
cat_prod_beta_pr: forall (z : A)
(f : forall i : I, z $-> x i)
(i : I),
cat_pr i $o cat_prod_corec z f $==
f i
cat_prod_eta_pr: forall (z : A)
(f g : z $-> cat_prod),
(forall i : I,
 cat_pr i $o f $== cat_pr i $o g) ->
f $== g
Product I x
  snapply (Build_Product' I A _ _ _ _ _ cat_prod cat_pr).I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x: I -> A
cat_prod: A
cat_pr: forall i : I, cat_prod $-> x i
cat_prod_corec: forall z : A,
(forall i : I, z $-> x i) ->
z $-> cat_prod
cat_prod_beta_pr: forall (z : A)
(f : forall i : I, z $-> x i)
(i : I),
cat_pr i $o cat_prod_corec z f $==
f i
cat_prod_eta_pr: forall (z : A)
(f g : z $-> cat_prod),
(forall i : I,
 cat_pr i $o f $== cat_pr i $o g) ->
f $== g
forall z : A,
CatIsEquiv (cat_prod_corec_inv cat_prod x z cat_pr)
  intros z.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x: I -> A
cat_prod: A
cat_pr: forall i : I, cat_prod $-> x i
cat_prod_corec: forall z : A,
(forall i : I, z $-> x i) ->
z $-> cat_prod
cat_prod_beta_pr: forall (z : A)
(f : forall i : I, z $-> x i)
(i : I),
cat_pr i $o cat_prod_corec z f $==
f i
cat_prod_eta_pr: forall (z : A)
(f g : z $-> cat_prod),
(forall i : I,
 cat_pr i $o f $== cat_pr i $o g) ->
f $== g
z: A
CatIsEquiv (cat_prod_corec_inv cat_prod x z cat_pr)
  napply isequiv_0gpd_issurjinj.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x: I -> A
cat_prod: A
cat_pr: forall i : I, cat_prod $-> x i
cat_prod_corec: forall z : A,
(forall i : I, z $-> x i) ->
z $-> cat_prod
cat_prod_beta_pr: forall (z : A)
(f : forall i : I, z $-> x i)
(i : I),
cat_pr i $o cat_prod_corec z f $==
f i
cat_prod_eta_pr: forall (z : A)
(f g : z $-> cat_prod),
(forall i : I,
 cat_pr i $o f $== cat_pr i $o g) ->
f $== g
z: A
IsSurjInj (cat_prod_corec_inv cat_prod x z cat_pr)
  napply Build_IsSurjInj.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x: I -> A
cat_prod: A
cat_pr: forall i : I, cat_prod $-> x i
cat_prod_corec: forall z : A,
(forall i : I, z $-> x i) ->
z $-> cat_prod
cat_prod_beta_pr: forall (z : A)
(f : forall i : I, z $-> x i)
(i : I),
cat_pr i $o cat_prod_corec z f $==
f i
cat_prod_eta_pr: forall (z : A)
(f g : z $-> cat_prod),
(forall i : I,
 cat_pr i $o f $== cat_pr i $o g) ->
f $== g
z: A
SplEssSurj (cat_prod_corec_inv cat_prod x z cat_pr)
I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x: I -> A
cat_prod: A
cat_pr: forall i : I, cat_prod $-> x i
cat_prod_corec: forall z : A,
(forall i : I, z $-> x i) ->
z $-> cat_prod
cat_prod_beta_pr: forall (z : A)
(f : forall i : I, z $-> x i)
(i : I),
cat_pr i $o cat_prod_corec z f $==
f i
cat_prod_eta_pr: forall (z : A)
(f g : z $-> cat_prod),
(forall i : I,
 cat_pr i $o f $== cat_pr i $o g) ->
f $== g
z: A
forall
x0
 y : Graph.graph_carrier
       (zerogpd_graph (yon_0gpd cat_prod z)),
cat_prod_corec_inv cat_prod x z cat_pr x0 $==
cat_prod_corec_inv cat_prod x z cat_pr y -> 
x0 $== y
  -I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x: I -> A
cat_prod: A
cat_pr: forall i : I, cat_prod $-> x i
cat_prod_corec: forall z : A,
(forall i : I, z $-> x i) ->
z $-> cat_prod
cat_prod_beta_pr: forall (z : A)
(f : forall i : I, z $-> x i)
(i : I),
cat_pr i $o cat_prod_corec z f $==
f i
cat_prod_eta_pr: forall (z : A)
(f g : z $-> cat_prod),
(forall i : I,
 cat_pr i $o f $== cat_pr i $o g) ->
f $== g
z: A
SplEssSurj (cat_prod_corec_inv cat_prod x z cat_pr) intros f.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x: I -> A
cat_prod: A
cat_pr: forall i : I, cat_prod $-> x i
cat_prod_corec: forall z : A,
(forall i : I, z $-> x i) ->
z $-> cat_prod
cat_prod_beta_pr: forall (z : A)
(f : forall i : I, z $-> x i)
(i : I),
cat_pr i $o cat_prod_corec z f $==
f i
cat_prod_eta_pr: forall (z : A)
(f g : z $-> cat_prod),
(forall i : I,
 cat_pr i $o f $== cat_pr i $o g) ->
f $== g
z: A
f: Graph.graph_carrier
  (zerogpd_graph
     (prod_0gpd I (fun i : I => yon_0gpd (x i) z)))
{a
: Graph.graph_carrier
    (zerogpd_graph (yon_0gpd cat_prod z)) &
cat_prod_corec_inv cat_prod x z cat_pr a $== f}
    exists (cat_prod_corec z f).I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x: I -> A
cat_prod: A
cat_pr: forall i : I, cat_prod $-> x i
cat_prod_corec: forall z : A,
(forall i : I, z $-> x i) ->
z $-> cat_prod
cat_prod_beta_pr: forall (z : A)
(f : forall i : I, z $-> x i)
(i : I),
cat_pr i $o cat_prod_corec z f $==
f i
cat_prod_eta_pr: forall (z : A)
(f g : z $-> cat_prod),
(forall i : I,
 cat_pr i $o f $== cat_pr i $o g) ->
f $== g
z: A
f: Graph.graph_carrier
  (zerogpd_graph
     (prod_0gpd I (fun i : I => yon_0gpd (x i) z)))
cat_prod_corec_inv cat_prod x z cat_pr
  (cat_prod_corec z f) $== f
    intros i.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x: I -> A
cat_prod: A
cat_pr: forall i : I, cat_prod $-> x i
cat_prod_corec: forall z : A,
(forall i : I, z $-> x i) ->
z $-> cat_prod
cat_prod_beta_pr: forall (z : A)
(f : forall i : I, z $-> x i)
(i : I),
cat_pr i $o cat_prod_corec z f $==
f i
cat_prod_eta_pr: forall (z : A)
(f g : z $-> cat_prod),
(forall i : I,
 cat_pr i $o f $== cat_pr i $o g) ->
f $== g
z: A
f: Graph.graph_carrier
  (zerogpd_graph
     (prod_0gpd I (fun i : I => yon_0gpd (x i) z)))
i: I
cat_prod_corec_inv cat_prod x z cat_pr
  (cat_prod_corec z f) i $-> f i
    napply cat_prod_beta_pr.
  -I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x: I -> A
cat_prod: A
cat_pr: forall i : I, cat_prod $-> x i
cat_prod_corec: forall z : A,
(forall i : I, z $-> x i) ->
z $-> cat_prod
cat_prod_beta_pr: forall (z : A)
(f : forall i : I, z $-> x i)
(i : I),
cat_pr i $o cat_prod_corec z f $==
f i
cat_prod_eta_pr: forall (z : A)
(f g : z $-> cat_prod),
(forall i : I,
 cat_pr i $o f $== cat_pr i $o g) ->
f $== g
z: A
forall
x0
 y : Graph.graph_carrier
       (zerogpd_graph (yon_0gpd cat_prod z)),
cat_prod_corec_inv cat_prod x z cat_pr x0 $==
cat_prod_corec_inv cat_prod x z cat_pr y -> x0 $== y intros f g p.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x: I -> A
cat_prod: A
cat_pr: forall i : I, cat_prod $-> x i
cat_prod_corec: forall z : A,
(forall i : I, z $-> x i) ->
z $-> cat_prod
cat_prod_beta_pr: forall (z : A)
(f : forall i : I, z $-> x i)
(i : I),
cat_pr i $o cat_prod_corec z f $==
f i
cat_prod_eta_pr: forall (z : A)
(f g : z $-> cat_prod),
(forall i : I,
 cat_pr i $o f $== cat_pr i $o g) ->
f $== g
z: A
f, g: Graph.graph_carrier
  (zerogpd_graph (yon_0gpd cat_prod z))
p: cat_prod_corec_inv cat_prod x z cat_pr f $==
cat_prod_corec_inv cat_prod x z cat_pr g
f $== g
    by napply cat_prod_eta_pr.
Defined.

Section Lemmata.

  Context (I : Type) {A : Type} {x : I -> A} `{Product I _ x}.

  Definition cate_cat_prod_corec_inv {z : A}
    : (yon_0gpd (cat_prod I x) z) $<~> prod_0gpd I (fun i => yon_0gpd (x i) z)
    := Build_CatEquiv (cat_prod_corec_inv (cat_prod I x) x z cat_pr).

  Definition cate_cat_prod_corec {z : A}
    : prod_0gpd I (fun i => yon_0gpd (x i) z) $<~> (yon_0gpd (cat_prod I x) z)
    := cate_cat_prod_corec_inv^-1$.

  Definition cat_prod_corec {z : A}
    : (forall i, z $-> x i) -> (z $-> cat_prod I x).I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
z: A
(forall i : I, z $-> x i) -> z $-> cat_prod I x
  Proof.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
z: A
(forall i : I, z $-> x i) -> z $-> cat_prod I x
    apply cate_cat_prod_corec.
  Defined.

  (** Applying the [i]th projection after a tuple of maps gives the [ith] map. *)
  Lemma cat_prod_beta {z : A} (f : forall i, z $-> x i)
    : forall i, cat_pr i $o cat_prod_corec f $== f i.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
z: A
f: forall i : I, z $-> x i
forall i : I, cat_pr i $o cat_prod_corec f $== f i
  Proof.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
z: A
f: forall i : I, z $-> x i
forall i : I, cat_pr i $o cat_prod_corec f $== f i
    exact (cate_isretr cate_cat_prod_corec_inv f).
  Defined.

  (** The pairing map is the unique map that makes the following diagram commute. *)
  Lemma cat_prod_eta {z : A} (f : z $-> cat_prod I x)
    : cat_prod_corec (fun i => cat_pr i $o f) $== f.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
z: A
f: z $-> cat_prod I x
cat_prod_corec (fun i : I => cat_pr i $o f) $== f
  Proof.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
z: A
f: z $-> cat_prod I x
cat_prod_corec (fun i : I => cat_pr i $o f) $== f
    exact (cate_issect cate_cat_prod_corec_inv f).
  Defined.

  Local Instance is0functor_prod_0gpd_helper
    : Is0Functor (fun z : A^op => prod_0gpd I (fun i => yon_0gpd (x i) z)).I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
Is0Functor
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z))
  Proof.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
Is0Functor
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z))
    snapply Build_Is0Functor.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
forall a b : A^op,
(a $-> b) ->
(fun z : A^op =>
 prod_0gpd I (fun i : I => yon_0gpd (x i) z)) a $->
(fun z : A^op =>
 prod_0gpd I (fun i : I => yon_0gpd (x i) z)) b
    intros a b f.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
a, b: A^op
f: a $-> b
(fun z : A^op =>
 prod_0gpd I (fun i : I => yon_0gpd (x i) z)) a $->
(fun z : A^op =>
 prod_0gpd I (fun i : I => yon_0gpd (x i) z)) b
    snapply Build_Fun01.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
a, b: A^op
f: a $-> b
Graph.graph_carrier
  (zerogpd_graph
     ((fun z : A^op =>
       prod_0gpd I (fun i : I => yon_0gpd (x i) z)) a)) ->
Graph.graph_carrier
  (zerogpd_graph
     ((fun z : A^op =>
       prod_0gpd I (fun i : I => yon_0gpd (x i) z)) b))
I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
a, b: A^op
f: a $-> b
Is0Functor ?F
    -I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
a, b: A^op
f: a $-> b
Graph.graph_carrier
  (zerogpd_graph
     ((fun z : A^op =>
       prod_0gpd I (fun i : I => yon_0gpd (x i) z)) a)) ->
Graph.graph_carrier
  (zerogpd_graph
     ((fun z : A^op =>
       prod_0gpd I (fun i : I => yon_0gpd (x i) z)) b)) intros g i.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
a, b: A^op
f: a $-> b
g: Graph.graph_carrier
  (zerogpd_graph
     ((fun z : A^op =>
       prod_0gpd I (fun i : I => yon_0gpd (x i) z))
        a))
i: I
yon_0gpd (x i) b
      exact (f $o g i).
    -I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
a, b: A^op
f: a $-> b
Is0Functor
  (fun
     g : Graph.graph_carrier
           (zerogpd_graph
              ((fun z : A^op =>
                prod_0gpd I
                  (fun i : I => yon_0gpd (x i) z)) a))
   =>
   (fun i : I => f $o g i)
   :
   Graph.graph_carrier
     (zerogpd_graph
        ((fun z : A^op =>
          prod_0gpd I (fun i : I => yon_0gpd (x i) z))
           b))) snapply Build_Is0Functor.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
a, b: A^op
f: a $-> b
forall
a0
 b0 : Graph.graph_carrier
        (zerogpd_graph
           ((fun z : A^op =>
             prod_0gpd I
               (fun i : I => yon_0gpd (x i) z)) a)),
(a0 $-> b0) ->
(fun
   g : Graph.graph_carrier
         (zerogpd_graph
            ((fun z : A^op =>
              prod_0gpd I
                (fun i : I => yon_0gpd (x i) z)) a))
 =>
 (fun i : I => f $o g i)
 :
 Graph.graph_carrier
   (zerogpd_graph
      ((fun z : A^op =>
        prod_0gpd I (fun i : I => yon_0gpd (x i) z)) b)))
  a0 $->
(fun
   g : Graph.graph_carrier
         (zerogpd_graph
            ((fun z : A^op =>
              prod_0gpd I
                (fun i : I => yon_0gpd (x i) z)) a))
 =>
 (fun i : I => f $o g i)
 :
 Graph.graph_carrier
   (zerogpd_graph
      ((fun z : A^op =>
        prod_0gpd I (fun i : I => yon_0gpd (x i) z)) b)))
  b0
      intros g h p i.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
a, b: A^op
f: a $-> b
g, h: Graph.graph_carrier
  (zerogpd_graph
     ((fun z : A^op =>
       prod_0gpd I (fun i : I => yon_0gpd (x i) z))
        a))
p: g $-> h
i: I
f $o g i $-> f $o h i
      exact (f $@L p i).
  Defined.

  Local Instance is1functor_prod_0gpd_helper
    : Is1Functor (fun z : A^op => prod_0gpd I (fun i => yon_0gpd (x i) z)).I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
Is1Functor
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z))
  Proof.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
Is1Functor
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z))
    snapply Build_Is1Functor.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
forall (a b : A^op) (f g : a $-> b),
f $== g ->
fmap
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z)) f $==
fmap
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z)) g
I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
forall a : A^op,
fmap
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z)) 
  (Id a) $==
Id
  ((fun z : A^op =>
    prod_0gpd I (fun i : I => yon_0gpd (x i) z)) a)
I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
forall (a b c : A^op) (f : a $-> b) 
(g : b $-> c),
fmap
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z))
  (g $o f) $==
fmap
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z)) g $o
fmap
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z)) f
    -I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
forall (a b : A^op) (f g : a $-> b),
f $== g ->
fmap
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z)) f $==
fmap
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z)) g intros a b f g p r i.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
a, b: A^op
f, g: a $-> b
p: f $== g
r: Graph.graph_carrier
  (zerogpd_graph
     (prod_0gpd I (fun i : I => yon_0gpd (x i) a)))
i: I
fmap
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z)) f r i $->
fmap
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z)) g r i
      refine (_ $@L _).I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
a, b: A^op
f, g: a $-> b
p: f $== g
r: Graph.graph_carrier
  (zerogpd_graph
     (prod_0gpd I (fun i : I => yon_0gpd (x i) a)))
i: I
f $== g
      exact p.
    -I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
forall a : A^op,
fmap
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z)) (Id a) $==
Id
  ((fun z : A^op =>
    prod_0gpd I (fun i : I => yon_0gpd (x i) z)) a) intros a r i.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
a: A^op
r: Graph.graph_carrier
  (zerogpd_graph
     (prod_0gpd I (fun i : I => yon_0gpd (x i) a)))
i: I
fmap
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z)) (Id a)
  r i $->
Id (prod_0gpd I (fun i : I => yon_0gpd (x i) a)) r i
      napply cat_idl; exact _.
    -I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
forall (a b c : A^op) (f : a $-> b) (g : b $-> c),
fmap
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z))
  (g $o f) $==
fmap
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z)) g $o
fmap
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z)) f intros a b c f g r i.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
a, b, c: A^op
f: a $-> b
g: b $-> c
r: Graph.graph_carrier
  (zerogpd_graph
     (prod_0gpd I (fun i : I => yon_0gpd (x i) a)))
i: I
fmap
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z))
  (g $o f) r i $->
(fmap
   (fun z : A^op =>
    prod_0gpd I (fun i : I => yon_0gpd (x i) z)) g $o
 fmap
   (fun z : A^op =>
    prod_0gpd I (fun i : I => yon_0gpd (x i) z)) f) r
  i
      napply cat_assoc; exact _.
  Defined.

  Definition natequiv_cat_prod_corec_inv
    : NatEquiv (yon_0gpd (cat_prod I x))
      (fun z : A^op => prod_0gpd I (fun i => yon_0gpd (x i) z)).I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
NatEquiv (yon_0gpd (cat_prod I x))
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z))
  Proof.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
NatEquiv (yon_0gpd (cat_prod I x))
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z))
    snapply Build_NatEquiv.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
forall a : A^op,
yon_0gpd (cat_prod I x) a $<~>
(fun z : A^op =>
 prod_0gpd I (fun i : I => yon_0gpd (x i) z)) a
I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
Is1Natural (yon_0gpd (cat_prod I x))
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z))
  (fun a : A^op => ?e a)
    1: intro; exact cate_cat_prod_corec_inv.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
Is1Natural (yon_0gpd (cat_prod I x))
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z))
  (fun a : A^op =>
   (fun a0 : A^op => cate_cat_prod_corec_inv) a)
    exact (is1natural_yoneda_0gpd
      (cat_prod I x)
      (fun z => prod_0gpd I (fun i => yon_0gpd (x i) z))
      cat_pr).
  Defined.

  Lemma cat_prod_corec_eta {z : A} {f f' : forall i, z $-> x i}
    : (forall i, f i $== f' i) -> cat_prod_corec f $== cat_prod_corec f'.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
z: A
f, f': forall i : I, z $-> x i
(forall i : I, f i $== f' i) ->
cat_prod_corec f $== cat_prod_corec f'
  Proof.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
z: A
f, f': forall i : I, z $-> x i
(forall i : I, f i $== f' i) ->
cat_prod_corec f $== cat_prod_corec f'
    intros p.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
z: A
f, f': forall i : I, z $-> x i
p: forall i : I, f i $== f' i
cat_prod_corec f $== cat_prod_corec f'
    unfold cat_prod_corec.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
z: A
f, f': forall i : I, z $-> x i
p: forall i : I, f i $== f' i
cate_cat_prod_corec f $== cate_cat_prod_corec f'
    napply (moveL_equiv_V_0gpd cate_cat_prod_corec_inv).I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
z: A
f, f': forall i : I, z $-> x i
p: forall i : I, f i $== f' i
equiv_fun_0gpd cate_cat_prod_corec_inv
  (cate_cat_prod_corec f) $== f'
    nrefine (cate_isretr cate_cat_prod_corec_inv _ $@ _).I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
z: A
f, f': forall i : I, z $-> x i
p: forall i : I, f i $== f' i
Id (prod_0gpd I (fun i : I => yon_0gpd (x i) z)) f $==
f'
    exact p.
  Defined.

  Lemma cat_prod_pr_eta {z : A} {f f' : z $-> cat_prod I x}
    : (forall i, cat_pr i $o f $== cat_pr i $o f') -> f $== f'.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
z: A
f, f': z $-> cat_prod I x
(forall i : I, cat_pr i $o f $== cat_pr i $o f') ->
f $== f'
  Proof.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
z: A
f, f': z $-> cat_prod I x
(forall i : I, cat_pr i $o f $== cat_pr i $o f') ->
f $== f'
    intros p.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
z: A
f, f': z $-> cat_prod I x
p: forall i : I, cat_pr i $o f $== cat_pr i $o f'
f $== f'
    refine ((cat_prod_eta _)^$ $@ _ $@ cat_prod_eta _).I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
z: A
f, f': z $-> cat_prod I x
p: forall i : I, cat_pr i $o f $== cat_pr i $o f'
cat_prod_corec (fun i : I => cat_pr i $o f) $==
cat_prod_corec (fun i : I => cat_pr i $o f')
    by napply cat_prod_corec_eta.
  Defined.

End Lemmata.

(** *** Diagonal map *)

Definition cat_prod_diag {I : Type} {A : Type} (x : A)
  `{Product I _ (fun _ => x)}
  : x $-> cat_prod I (fun _ => x)
  := cat_prod_corec I (fun _ => Id x).

(** *** Uniqueness of products *)

Definition cate_cat_prod {I J : Type} (ie : I <~> J) {A : Type} `{HasEquivs A}
  (x : I -> A) `{!Product I x} (y : J -> A) `{!Product J y}
  (e : forall i : I, x i $<~> y (ie i))
  : cat_prod I x $<~> cat_prod J y.I, J: Type
ie: I <~> J
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
x: I -> A
Product0: Product I x
y: J -> A
Product1: Product J y
e: forall i : I, x i $<~> y (ie i)
cat_prod I x $<~> cat_prod J y
Proof.I, J: Type
ie: I <~> J
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
x: I -> A
Product0: Product I x
y: J -> A
Product1: Product J y
e: forall i : I, x i $<~> y (ie i)
cat_prod I x $<~> cat_prod J y
  napply yon_equiv_0gpd.I, J: Type
ie: I <~> J
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
x: I -> A
Product0: Product I x
y: J -> A
Product1: Product J y
e: forall i : I, x i $<~> y (ie i)
yon1_0gpd (cat_prod I x) $<~> yon1_0gpd (cat_prod J y)
  nrefine (natequiv_compose _ (natequiv_cat_prod_corec_inv _)).I, J: Type
ie: I <~> J
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
x: I -> A
Product0: Product I x
y: J -> A
Product1: Product J y
e: forall i : I, x i $<~> y (ie i)
NatEquiv
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z))
  (yon1_0gpd (cat_prod J y))
  nrefine (natequiv_compose
            (natequiv_inverse (natequiv_cat_prod_corec_inv _)) _).I, J: Type
ie: I <~> J
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
x: I -> A
Product0: Product I x
y: J -> A
Product1: Product J y
e: forall i : I, x i $<~> y (ie i)
NatEquiv
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z))
  (fun z : A^op =>
   prod_0gpd J (fun i : J => yon_0gpd (y i) z))
  snapply Build_NatEquiv.I, J: Type
ie: I <~> J
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
x: I -> A
Product0: Product I x
y: J -> A
Product1: Product J y
e: forall i : I, x i $<~> y (ie i)
forall a : A^op,
(fun z : A^op =>
 prod_0gpd I (fun i : I => yon_0gpd (x i) z)) a $<~>
(fun z : A^op =>
 prod_0gpd J (fun i : J => yon_0gpd (y i) z)) a
I, J: Type
ie: I <~> J
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
x: I -> A
Product0: Product I x
y: J -> A
Product1: Product J y
e: forall i : I, x i $<~> y (ie i)
Is1Natural
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z))
  (fun z : A^op =>
   prod_0gpd J (fun i : J => yon_0gpd (y i) z))
  (fun a : A^op => ?e a)
  -I, J: Type
ie: I <~> J
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
x: I -> A
Product0: Product I x
y: J -> A
Product1: Product J y
e: forall i : I, x i $<~> y (ie i)
forall a : A^op,
(fun z : A^op =>
 prod_0gpd I (fun i : I => yon_0gpd (x i) z)) a $<~>
(fun z : A^op =>
 prod_0gpd J (fun i : J => yon_0gpd (y i) z)) a intros z.I, J: Type
ie: I <~> J
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
x: I -> A
Product0: Product I x
y: J -> A
Product1: Product J y
e: forall i : I, x i $<~> y (ie i)
z: A^op
(fun z : A^op =>
 prod_0gpd I (fun i : I => yon_0gpd (x i) z)) z $<~>
(fun z : A^op =>
 prod_0gpd J (fun i : J => yon_0gpd (y i) z)) z
    napply (cate_prod_0gpd ie).I, J: Type
ie: I <~> J
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
x: I -> A
Product0: Product I x
y: J -> A
Product1: Product J y
e: forall i : I, x i $<~> y (ie i)
z: A^op
forall i : I,
yon_0gpd (x i) z $<~> yon_0gpd (y (ie i)) z
    intros i.I, J: Type
ie: I <~> J
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
x: I -> A
Product0: Product I x
y: J -> A
Product1: Product J y
e: forall i : I, x i $<~> y (ie i)
z: A^op
i: I
yon_0gpd (x i) z $<~> yon_0gpd (y (ie i)) z
    exact (natequiv_yon_equiv_0gpd (e i) _).
  -I, J: Type
ie: I <~> J
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
x: I -> A
Product0: Product I x
y: J -> A
Product1: Product J y
e: forall i : I, x i $<~> y (ie i)
Is1Natural
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z))
  (fun z : A^op =>
   prod_0gpd J (fun i : J => yon_0gpd (y i) z))
  (fun a : A^op =>
   (fun z : A^op =>
    cate_prod_0gpd ie (fun i : I => yon_0gpd (x i) z)
      (fun i : J => yon_0gpd (y i) z)
      (fun i : I => natequiv_yon_equiv_0gpd (e i) z))
     a) snapply Build_Is1Natural.I, J: Type
ie: I <~> J
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
x: I -> A
Product0: Product I x
y: J -> A
Product1: Product J y
e: forall i : I, x i $<~> y (ie i)
forall (a a' : A^op) (f : a $-> a'),
(fun a0 : A^op =>
 cate_fun
   ((fun z : A^op =>
     cate_prod_0gpd ie (fun i : I => yon_0gpd (x i) z)
       (fun i : J => yon_0gpd (y i) z)
       (fun i : I => natequiv_yon_equiv_0gpd (e i) z))
      a0)) a' $o
fmap
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z)) f $==
fmap
  (fun z : A^op =>
   prod_0gpd J (fun i : J => yon_0gpd (y i) z)) f $o
(fun a0 : A^op =>
 cate_fun
   ((fun z : A^op =>
     cate_prod_0gpd ie (fun i : I => yon_0gpd (x i) z)
       (fun i : J => yon_0gpd (y i) z)
       (fun i : I => natequiv_yon_equiv_0gpd (e i) z))
      a0)) a
    intros a b f g j.I, J: Type
ie: I <~> J
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
x: I -> A
Product0: Product I x
y: J -> A
Product1: Product J y
e: forall i : I, x i $<~> y (ie i)
a, b: A^op
f: a $-> b
g: Graph.graph_carrier
  (zerogpd_graph
     (prod_0gpd I (fun i : I => yon_0gpd (x i) a)))
j: J
(cate_prod_0gpd ie (fun i : I => yon_0gpd (x i) b)
   (fun i : J => yon_0gpd (y i) b)
   (fun i : I => natequiv_yon_equiv_0gpd (e i) b) $o
 fmap
   (fun z : A^op =>
    prod_0gpd I (fun i : I => yon_0gpd (x i) z)) f) g
  j $->
(fmap
   (fun z : A^op =>
    prod_0gpd J (fun i : J => yon_0gpd (y i) z)) f $o
 cate_prod_0gpd ie (fun i : I => yon_0gpd (x i) a)
   (fun i : J => yon_0gpd (y i) a)
   (fun i : I => natequiv_yon_equiv_0gpd (e i) a)) g j
    cbn.I, J: Type
ie: I <~> J
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
x: I -> A
Product0: Product I x
y: J -> A
Product1: Product J y
e: forall i : I, x i $<~> y (ie i)
a, b: A^op
f: a $-> b
g: Graph.graph_carrier
  (zerogpd_graph
     (prod_0gpd I (fun i : I => yon_0gpd (x i) a)))
j: J
transport (fun x : J => b $-> y x) (eisretr ie j)
  (cate_fun' (x (ie^-1 j)) (y (ie (ie^-1 j)))
     (e (ie^-1 j)) $o (g (ie^-1 j) $o f)) $->
transport (fun x : J => a $-> y x) (eisretr ie j)
  (cate_fun' (x (ie^-1 j)) (y (ie (ie^-1 j)))
     (e (ie^-1 j)) $o g (ie^-1 j)) $o f
    destruct (eisretr ie j).I, J: Type
ie: I <~> J
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
x: I -> A
Product0: Product I x
y: J -> A
Product1: Product J y
e: forall i : I, x i $<~> y (ie i)
a, b: A^op
f: a $-> b
g: Graph.graph_carrier
  (zerogpd_graph
     (prod_0gpd I (fun i : I => yon_0gpd (x i) a)))
j: J
transport (fun x : J => b $-> y x) 1
  (cate_fun' (x (ie^-1 j)) (y (ie (ie^-1 j)))
     (e (ie^-1 j)) $o (g (ie^-1 j) $o f)) $->
transport (fun x : J => a $-> y x) 1
  (cate_fun' (x (ie^-1 j)) (y (ie (ie^-1 j)))
     (e (ie^-1 j)) $o g (ie^-1 j)) $o f
    exact (cat_assoc_opp _ _ _).
Defined.

(** [I]-indexed products are unique no matter how they are constructed. *)
Definition cat_prod_unique {I A : Type} `{HasEquivs A}
  (x : I -> A) `{!Product I x} (y : I -> A) `{!Product I y}
  (e : forall i : I, x i $<~> y i)
  : cat_prod I x $<~> cat_prod I y.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
x: I -> A
Product0: Product I x
y: I -> A
Product1: Product I y
e: forall i : I, x i $<~> y i
cat_prod I x $<~> cat_prod I y
Proof.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
x: I -> A
Product0: Product I x
y: I -> A
Product1: Product I y
e: forall i : I, x i $<~> y i
cat_prod I x $<~> cat_prod I y
  exact (cate_cat_prod 1 x y e).
Defined.

(** *** Existence of products *)

Class HasProducts (I A : Type) `{Is1Cat A}
  := has_products :: forall x : I -> A, Product I x.

Class HasAllProducts (A : Type) `{Is1Cat A}
  := has_all_products :: forall I : Type, HasProducts I A.

(** *** Product functor *)

Instance is0functor_cat_prod (I : Type) (A : Type) `{HasProducts I A}
  : Is0Functor (fun x : I -> A => cat_prod I x).I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
Is0Functor (fun x : I -> A => cat_prod I x)
Proof.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
Is0Functor (fun x : I -> A => cat_prod I x)
  napply Build_Is0Functor.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
forall a b : I -> A,
(a $-> b) -> cat_prod I a $-> cat_prod I b
  intros x y f.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
x, y: I -> A
f: x $-> y
cat_prod I x $-> cat_prod I y
  exact (cat_prod_corec I (fun i => f i $o cat_pr i)).
Defined.

Instance is1functor_cat_prod (I : Type) (A : Type) `{HasProducts I A}
  : Is1Functor (fun x : I -> A => cat_prod I x).I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
Is1Functor (fun x : I -> A => cat_prod I x)
Proof.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
Is1Functor (fun x : I -> A => cat_prod I x)
  napply Build_Is1Functor.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
forall (a b : I -> A) (f g : a $-> b),
f $== g ->
fmap (fun x : I -> A => cat_prod I x) f $==
fmap (fun x : I -> A => cat_prod I x) g
I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
forall a : I -> A,
fmap (fun x : I -> A => cat_prod I x) (Id a) $==
Id (cat_prod I a)
I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
forall (a b c : I -> A) 
(f : a $-> b) (g : b $-> c),
fmap (fun x : I -> A => cat_prod I x) (g $o f) $==
fmap (fun x : I -> A => cat_prod I x) g $o
fmap (fun x : I -> A => cat_prod I x) f
  -I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
forall (a b : I -> A) (f g : a $-> b),
f $== g ->
fmap (fun x : I -> A => cat_prod I x) f $==
fmap (fun x : I -> A => cat_prod I x) g intros x y f g p.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
x, y: I -> A
f, g: x $-> y
p: f $== g
fmap (fun x : I -> A => cat_prod I x) f $==
fmap (fun x : I -> A => cat_prod I x) g
    exact (cat_prod_corec_eta I (fun i => p i $@R cat_pr i)).
  -I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
forall a : I -> A,
fmap (fun x : I -> A => cat_prod I x) (Id a) $==
Id (cat_prod I a) intros x.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
x: I -> A
fmap (fun x : I -> A => cat_prod I x) (Id x) $==
Id (cat_prod I x)
    nrefine (_ $@ (cat_prod_eta I (Id _))).I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
x: I -> A
fmap (fun x : I -> A => cat_prod I x) (Id x) $==
cat_prod_corec I
  (fun i : I => cat_pr i $o Id (cat_prod I x))
    exact (cat_prod_corec_eta I (fun i => cat_idl _ $@ (cat_idr _)^$)).
  -I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
forall (a b c : I -> A) (f : a $-> b) (g : b $-> c),
fmap (fun x : I -> A => cat_prod I x) (g $o f) $==
fmap (fun x : I -> A => cat_prod I x) g $o
fmap (fun x : I -> A => cat_prod I x) f intros x y z f g.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
x, y, z: I -> A
f: x $-> y
g: y $-> z
fmap (fun x : I -> A => cat_prod I x) (g $o f) $==
fmap (fun x : I -> A => cat_prod I x) g $o
fmap (fun x : I -> A => cat_prod I x) f
    napply cat_prod_pr_eta.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
x, y, z: I -> A
f: x $-> y
g: y $-> z
forall i : I,
cat_pr i $o
fmap (fun x : I -> A => cat_prod I x) (g $o f) $==
cat_pr i $o
(fmap (fun x : I -> A => cat_prod I x) g $o
 fmap (fun x : I -> A => cat_prod I x) f)
    intros i.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
x, y, z: I -> A
f: x $-> y
g: y $-> z
i: I
cat_pr i $o
fmap (fun x : I -> A => cat_prod I x) (g $o f) $==
cat_pr i $o
(fmap (fun x : I -> A => cat_prod I x) g $o
 fmap (fun x : I -> A => cat_prod I x) f)
    nrefine (cat_prod_beta _ _ _ $@ _).I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
x, y, z: I -> A
f: x $-> y
g: y $-> z
i: I
(g $o f) i $o cat_pr i $==
cat_pr i $o
(fmap (fun x : I -> A => cat_prod I x) g $o
 fmap (fun x : I -> A => cat_prod I x) f)
    nrefine (_ $@ cat_assoc _ _ _).I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
x, y, z: I -> A
f: x $-> y
g: y $-> z
i: I
(g $o f) i $o cat_pr i $==
cat_pr i $o fmap (fun x : I -> A => cat_prod I x) g $o
fmap (fun x : I -> A => cat_prod I x) f
    symmetry.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
x, y, z: I -> A
f: x $-> y
g: y $-> z
i: I
cat_pr i $o fmap (fun x : I -> A => cat_prod I x) g $o
fmap (fun x : I -> A => cat_prod I x) f $==
(g $o f) i $o cat_pr i
    nrefine (cat_prod_beta _ _ _ $@R _ $@ _).I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
x, y, z: I -> A
f: x $-> y
g: y $-> z
i: I
g i $o cat_pr i $o
fmap (fun x : I -> A => cat_prod I x) f $==
(g $o f) i $o cat_pr i
    nrefine (cat_assoc _ _ _ $@ _).I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
x, y, z: I -> A
f: x $-> y
g: y $-> z
i: I
g i $o
(cat_pr i $o fmap (fun x : I -> A => cat_prod I x) f) $==
(g $o f) i $o cat_pr i
    nrefine (_ $@L cat_prod_beta _ _ _ $@ _).I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
x, y, z: I -> A
f: x $-> y
g: y $-> z
i: I
g i $o (f i $o cat_pr i) $== (g $o f) i $o cat_pr i
    napply cat_assoc_opp.
Defined.

(** *** Categories with specific kinds of products *)

Definition isterminal_prodempty {A : Type} {z : A}
  `{Product Empty A (fun _ => z)}
  : IsTerminal (cat_prod Empty (fun _ => z)).A: Type
z: A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product Empty (fun _ : Empty => z)
IsTerminal (cat_prod Empty (fun _ : Empty => z))
Proof.A: Type
z: A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product Empty (fun _ : Empty => z)
IsTerminal (cat_prod Empty (fun _ : Empty => z))
  intros a.A: Type
z: A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product Empty (fun _ : Empty => z)
a: A
{f : a $-> cat_prod Empty (fun _ : Empty => z) &
forall g : a $-> cat_prod Empty (fun _ : Empty => z),
f $== g}
  snrefine (cat_prod_corec _ _; fun f => cat_prod_pr_eta _ _); intros [].
Defined.

(** *** Binary products *)

Class BinaryProduct {A : Type} `{Is1Cat A} (x y : A)
  := binary_product :: Product Bool (fun b => if b then x else y).

(** A category with binary products is a category with a binary product for each pair of objects. *)
Class HasBinaryProducts (A : Type) `{Is1Cat A}
  := has_binary_products :: forall x y : A, BinaryProduct x y.

Instance hasbinaryproducts_hasproductsbool {A : Type} `{HasProducts Bool A}
  : HasBinaryProducts A
  := fun x y => has_products (fun b : Bool => if b then x else y).

Section BinaryProducts.

  Context {A : Type} `{Is1Cat A} {x y : A} `{!BinaryProduct x y}.

  Definition cat_binprod' : A
    := cat_prod Bool (fun b : Bool => if b then x else y).

  Definition cat_pr1 : cat_binprod' $-> x := cat_pr true.

  Definition cat_pr2 : cat_binprod' $-> y := cat_pr false.

  Definition cat_binprod_corec {z : A} (f : z $-> x) (g : z $-> y)
    : z $-> cat_binprod'.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f: z $-> x
g: z $-> y
z $-> cat_binprod'
  Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f: z $-> x
g: z $-> y
z $-> cat_binprod'
    napply (cat_prod_corec Bool).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f: z $-> x
g: z $-> y
forall i : Bool, z $-> (if i then x else y)
    intros [|].A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f: z $-> x
g: z $-> y
z $-> x
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f: z $-> x
g: z $-> y
z $-> y
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f: z $-> x
g: z $-> y
z $-> x exact f.
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f: z $-> x
g: z $-> y
z $-> y exact g.
  Defined.

  Definition cat_binprod_beta_pr1 {z : A} (f : z $-> x) (g : z $-> y)
    : cat_pr1 $o cat_binprod_corec f g $== f
    := cat_prod_beta _ _ true.

  Definition cat_binprod_beta_pr2 {z : A} (f : z $-> x) (g : z $-> y)
    : cat_pr2 $o cat_binprod_corec f g $== g
    := cat_prod_beta _ _ false.

  Definition cat_binprod_eta {z : A} (f : z $-> cat_binprod')
    : cat_binprod_corec (cat_pr1 $o f) (cat_pr2 $o f) $== f.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f: z $-> cat_binprod'
cat_binprod_corec (cat_pr1 $o f) (cat_pr2 $o f) $== f
  Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f: z $-> cat_binprod'
cat_binprod_corec (cat_pr1 $o f) (cat_pr2 $o f) $== f
    unfold cat_binprod_corec.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f: z $-> cat_binprod'
cat_prod_corec Bool
  (fun i : Bool =>
   if i as b return (z $-> (if b then x else y))
   then cat_pr1 $o f
   else cat_pr2 $o f) $== f
    napply cat_prod_pr_eta.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f: z $-> cat_binprod'
forall i : Bool,
cat_pr i $o
cat_prod_corec Bool
  (fun i0 : Bool =>
   if i0 as b return (z $-> (if b then x else y))
   then cat_pr1 $o f
   else cat_pr2 $o f) $== cat_pr i $o f
    intros [|].A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f: z $-> cat_binprod'
cat_pr true $o
cat_prod_corec Bool
  (fun i : Bool =>
   if i as b return (z $-> (if b then x else y))
   then cat_pr1 $o f
   else cat_pr2 $o f) $== cat_pr true $o f
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f: z $-> cat_binprod'
cat_pr false $o
cat_prod_corec Bool
  (fun i : Bool =>
   if i as b return (z $-> (if b then x else y))
   then cat_pr1 $o f
   else cat_pr2 $o f) $== 
cat_pr false $o f
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f: z $-> cat_binprod'
cat_pr true $o
cat_prod_corec Bool
  (fun i : Bool =>
   if i as b return (z $-> (if b then x else y))
   then cat_pr1 $o f
   else cat_pr2 $o f) $== cat_pr true $o f exact (cat_binprod_beta_pr1 _ _).
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f: z $-> cat_binprod'
cat_pr false $o
cat_prod_corec Bool
  (fun i : Bool =>
   if i as b return (z $-> (if b then x else y))
   then cat_pr1 $o f
   else cat_pr2 $o f) $== cat_pr false $o f exact (cat_binprod_beta_pr2 _ _).
  Defined.

  Definition cat_binprod_eta_pr {z : A} (f g : z $-> cat_binprod')
    : cat_pr1 $o f $== cat_pr1 $o g -> cat_pr2 $o f $== cat_pr2 $o g -> f $== g.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f, g: z $-> cat_binprod'
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g -> f $== g
  Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f, g: z $-> cat_binprod'
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g -> f $== g
    intros p q.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f, g: z $-> cat_binprod'
p: cat_pr1 $o f $== cat_pr1 $o g
q: cat_pr2 $o f $== cat_pr2 $o g
f $== g
    rapply cat_prod_pr_eta.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f, g: z $-> cat_binprod'
p: cat_pr1 $o f $== cat_pr1 $o g
q: cat_pr2 $o f $== cat_pr2 $o g
forall i : Bool, cat_pr i $o f $== cat_pr i $o g
    intros [|].A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f, g: z $-> cat_binprod'
p: cat_pr1 $o f $== cat_pr1 $o g
q: cat_pr2 $o f $== cat_pr2 $o g
cat_pr true $o f $== cat_pr true $o g
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f, g: z $-> cat_binprod'
p: cat_pr1 $o f $== cat_pr1 $o g
q: cat_pr2 $o f $== cat_pr2 $o g
cat_pr false $o f $== cat_pr false $o g
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f, g: z $-> cat_binprod'
p: cat_pr1 $o f $== cat_pr1 $o g
q: cat_pr2 $o f $== cat_pr2 $o g
cat_pr true $o f $== cat_pr true $o g exact p.
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f, g: z $-> cat_binprod'
p: cat_pr1 $o f $== cat_pr1 $o g
q: cat_pr2 $o f $== cat_pr2 $o g
cat_pr false $o f $== cat_pr false $o g exact q.
  Defined.

  Definition cat_binprod_corec_eta {z : A} (f f' : z $-> x) (g g' : z $-> y)
    : f $== f' -> g $== g' -> cat_binprod_corec f g $== cat_binprod_corec f' g'.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f, f': z $-> x
g, g': z $-> y
f $== f' ->
g $== g' ->
cat_binprod_corec f g $== cat_binprod_corec f' g'
  Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f, f': z $-> x
g, g': z $-> y
f $== f' ->
g $== g' ->
cat_binprod_corec f g $== cat_binprod_corec f' g'
    intros p q.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f, f': z $-> x
g, g': z $-> y
p: f $== f'
q: g $== g'
cat_binprod_corec f g $== cat_binprod_corec f' g'
    rapply cat_prod_corec_eta.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f, f': z $-> x
g, g': z $-> y
p: f $== f'
q: g $== g'
forall i : Bool,
(if i as b return (z $-> (if b then x else y))
 then f
 else g) $==
(if i as b return (z $-> (if b then x else y))
 then f'
 else g')
    intros [|].A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f, f': z $-> x
g, g': z $-> y
p: f $== f'
q: g $== g'
f $== f'
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f, f': z $-> x
g, g': z $-> y
p: f $== f'
q: g $== g'
g $== g'
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f, f': z $-> x
g, g': z $-> y
p: f $== f'
q: g $== g'
f $== f' exact p.
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y: A
BinaryProduct0: BinaryProduct x y
z: A
f, f': z $-> x
g, g': z $-> y
p: f $== f'
q: g $== g'
g $== g' exact q.
  Defined.

End BinaryProducts.

Arguments cat_binprod' {A _ _ _ _} x y {_}.

(** A convenience wrapper for building binary products *)
Definition Build_BinaryProduct {A : Type} `{Is1Cat A} {x y : A}
  (cat_binprod' : A) (cat_pr1 : cat_binprod' $-> x) (cat_pr2 : cat_binprod' $-> y)
  (cat_binprod_corec : forall z : A, z $-> x -> z $-> y -> z $-> cat_binprod')
  (cat_binprod_beta_pr1 : forall (z : A) (f : z $-> x) (g : z $-> y),
    cat_pr1 $o cat_binprod_corec z f g $== f)
  (cat_binprod_beta_pr2 : forall (z : A) (f : z $-> x) (g : z $-> y),
    cat_pr2 $o cat_binprod_corec z f g $== g)
  (cat_binprod_eta_pr : forall (z : A) (f g : z $-> cat_binprod'),
    cat_pr1 $o f $== cat_pr1 $o g -> cat_pr2 $o f $== cat_pr2 $o g -> f $== g)
  : Product Bool (fun b => if b then x else y).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y, cat_binprod': A
cat_pr1: cat_binprod' $-> x
cat_pr2: cat_binprod' $-> y
cat_binprod_corec: forall z : A,
(z $-> x) ->
(z $-> y) -> z $-> cat_binprod'
cat_binprod_beta_pr1: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr1 $o
cat_binprod_corec z f g $== f
cat_binprod_beta_pr2: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr2 $o
cat_binprod_corec z f g $== g
cat_binprod_eta_pr: forall (z : A)
(f g : z $-> cat_binprod'),
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g ->
f $== g
Product Bool (fun b : Bool => if b then x else y)
Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y, cat_binprod': A
cat_pr1: cat_binprod' $-> x
cat_pr2: cat_binprod' $-> y
cat_binprod_corec: forall z : A,
(z $-> x) ->
(z $-> y) -> z $-> cat_binprod'
cat_binprod_beta_pr1: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr1 $o
cat_binprod_corec z f g $== f
cat_binprod_beta_pr2: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr2 $o
cat_binprod_corec z f g $== g
cat_binprod_eta_pr: forall (z : A)
(f g : z $-> cat_binprod'),
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g ->
f $== g
Product Bool (fun b : Bool => if b then x else y)
  snapply (Build_Product _ cat_binprod').A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y, cat_binprod': A
cat_pr1: cat_binprod' $-> x
cat_pr2: cat_binprod' $-> y
cat_binprod_corec: forall z : A,
(z $-> x) ->
(z $-> y) -> z $-> cat_binprod'
cat_binprod_beta_pr1: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr1 $o
cat_binprod_corec z f g $== f
cat_binprod_beta_pr2: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr2 $o
cat_binprod_corec z f g $== g
cat_binprod_eta_pr: forall (z : A)
(f g : z $-> cat_binprod'),
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g ->
f $== g
forall i : Bool,
cat_binprod' $->
(fun b : Bool => if b then x else y) i
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y, cat_binprod': A
cat_pr1: cat_binprod' $-> x
cat_pr2: cat_binprod' $-> y
cat_binprod_corec: forall z : A,
(z $-> x) ->
(z $-> y) -> z $-> cat_binprod'
cat_binprod_beta_pr1: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr1 $o
cat_binprod_corec z f g $== f
cat_binprod_beta_pr2: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr2 $o
cat_binprod_corec z f g $== g
cat_binprod_eta_pr: forall (z : A)
(f g : z $-> cat_binprod'),
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g ->
f $== g
forall z : A,
(forall i : Bool,
 z $-> (fun b : Bool => if b then x else y) i) ->
z $-> cat_binprod'
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y, cat_binprod': A
cat_pr1: cat_binprod' $-> x
cat_pr2: cat_binprod' $-> y
cat_binprod_corec: forall z : A,
(z $-> x) ->
(z $-> y) -> z $-> cat_binprod'
cat_binprod_beta_pr1: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr1 $o
cat_binprod_corec z f g $== f
cat_binprod_beta_pr2: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr2 $o
cat_binprod_corec z f g $== g
cat_binprod_eta_pr: forall (z : A)
(f g : z $-> cat_binprod'),
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g ->
f $== g
forall (z : A)
(f : forall i : Bool,
     z $-> (fun b : Bool => if b then x else y) i)
(i : Bool), ?cat_pr i $o ?cat_prod_corec z f $== f i
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y, cat_binprod': A
cat_pr1: cat_binprod' $-> x
cat_pr2: cat_binprod' $-> y
cat_binprod_corec: forall z : A,
(z $-> x) ->
(z $-> y) -> z $-> cat_binprod'
cat_binprod_beta_pr1: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr1 $o
cat_binprod_corec z f g $== f
cat_binprod_beta_pr2: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr2 $o
cat_binprod_corec z f g $== g
cat_binprod_eta_pr: forall (z : A)
(f g : z $-> cat_binprod'),
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g ->
f $== g
forall (z : A) (f g : z $-> cat_binprod'),
(forall i : Bool, ?cat_pr i $o f $== ?cat_pr i $o g) ->
f $== g
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y, cat_binprod': A
cat_pr1: cat_binprod' $-> x
cat_pr2: cat_binprod' $-> y
cat_binprod_corec: forall z : A,
(z $-> x) ->
(z $-> y) -> z $-> cat_binprod'
cat_binprod_beta_pr1: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr1 $o
cat_binprod_corec z f g $== f
cat_binprod_beta_pr2: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr2 $o
cat_binprod_corec z f g $== g
cat_binprod_eta_pr: forall (z : A)
(f g : z $-> cat_binprod'),
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g ->
f $== g
forall i : Bool,
cat_binprod' $->
(fun b : Bool => if b then x else y) i intros [|].A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y, cat_binprod': A
cat_pr1: cat_binprod' $-> x
cat_pr2: cat_binprod' $-> y
cat_binprod_corec: forall z : A,
(z $-> x) ->
(z $-> y) -> z $-> cat_binprod'
cat_binprod_beta_pr1: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr1 $o
cat_binprod_corec z f g $== f
cat_binprod_beta_pr2: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr2 $o
cat_binprod_corec z f g $== g
cat_binprod_eta_pr: forall (z : A)
(f g : z $-> cat_binprod'),
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g ->
f $== g
cat_binprod' $-> x
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y, cat_binprod': A
cat_pr1: cat_binprod' $-> x
cat_pr2: cat_binprod' $-> y
cat_binprod_corec: forall z : A,
(z $-> x) ->
(z $-> y) -> z $-> cat_binprod'
cat_binprod_beta_pr1: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr1 $o
cat_binprod_corec z f g $== f
cat_binprod_beta_pr2: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr2 $o
cat_binprod_corec z f g $== g
cat_binprod_eta_pr: forall (z : A)
(f g : z $-> cat_binprod'),
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g ->
f $== g
cat_binprod' $-> y
    +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y, cat_binprod': A
cat_pr1: cat_binprod' $-> x
cat_pr2: cat_binprod' $-> y
cat_binprod_corec: forall z : A,
(z $-> x) ->
(z $-> y) -> z $-> cat_binprod'
cat_binprod_beta_pr1: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr1 $o
cat_binprod_corec z f g $== f
cat_binprod_beta_pr2: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr2 $o
cat_binprod_corec z f g $== g
cat_binprod_eta_pr: forall (z : A)
(f g : z $-> cat_binprod'),
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g ->
f $== g
cat_binprod' $-> x exact cat_pr1.
    +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y, cat_binprod': A
cat_pr1: cat_binprod' $-> x
cat_pr2: cat_binprod' $-> y
cat_binprod_corec: forall z : A,
(z $-> x) ->
(z $-> y) -> z $-> cat_binprod'
cat_binprod_beta_pr1: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr1 $o
cat_binprod_corec z f g $== f
cat_binprod_beta_pr2: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr2 $o
cat_binprod_corec z f g $== g
cat_binprod_eta_pr: forall (z : A)
(f g : z $-> cat_binprod'),
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g ->
f $== g
cat_binprod' $-> y exact cat_pr2.
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y, cat_binprod': A
cat_pr1: cat_binprod' $-> x
cat_pr2: cat_binprod' $-> y
cat_binprod_corec: forall z : A,
(z $-> x) ->
(z $-> y) -> z $-> cat_binprod'
cat_binprod_beta_pr1: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr1 $o
cat_binprod_corec z f g $== f
cat_binprod_beta_pr2: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr2 $o
cat_binprod_corec z f g $== g
cat_binprod_eta_pr: forall (z : A)
(f g : z $-> cat_binprod'),
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g ->
f $== g
forall z : A,
(forall i : Bool,
 z $-> (fun b : Bool => if b then x else y) i) ->
z $-> cat_binprod' intros z f.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y, cat_binprod': A
cat_pr1: cat_binprod' $-> x
cat_pr2: cat_binprod' $-> y
cat_binprod_corec: forall z : A,
(z $-> x) ->
(z $-> y) -> z $-> cat_binprod'
cat_binprod_beta_pr1: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr1 $o
cat_binprod_corec z f g $== f
cat_binprod_beta_pr2: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr2 $o
cat_binprod_corec z f g $== g
cat_binprod_eta_pr: forall (z : A)
(f g : z $-> cat_binprod'),
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g ->
f $== g
z: A
f: forall i : Bool,
z $-> (fun b : Bool => if b then x else y) i
z $-> cat_binprod'
    napply cat_binprod_corec.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y, cat_binprod': A
cat_pr1: cat_binprod' $-> x
cat_pr2: cat_binprod' $-> y
cat_binprod_corec: forall z : A,
(z $-> x) ->
(z $-> y) -> z $-> cat_binprod'
cat_binprod_beta_pr1: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr1 $o
cat_binprod_corec z f g $== f
cat_binprod_beta_pr2: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr2 $o
cat_binprod_corec z f g $== g
cat_binprod_eta_pr: forall (z : A)
(f g : z $-> cat_binprod'),
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g ->
f $== g
z: A
f: forall i : Bool,
z $-> (fun b : Bool => if b then x else y) i
z $-> x
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y, cat_binprod': A
cat_pr1: cat_binprod' $-> x
cat_pr2: cat_binprod' $-> y
cat_binprod_corec: forall z : A,
(z $-> x) ->
(z $-> y) -> z $-> cat_binprod'
cat_binprod_beta_pr1: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr1 $o
cat_binprod_corec z f g $== f
cat_binprod_beta_pr2: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr2 $o
cat_binprod_corec z f g $== g
cat_binprod_eta_pr: forall (z : A)
(f g : z $-> cat_binprod'),
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g ->
f $== g
z: A
f: forall i : Bool,
z $-> (fun b : Bool => if b then x else y) i
z $-> y
    +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y, cat_binprod': A
cat_pr1: cat_binprod' $-> x
cat_pr2: cat_binprod' $-> y
cat_binprod_corec: forall z : A,
(z $-> x) ->
(z $-> y) -> z $-> cat_binprod'
cat_binprod_beta_pr1: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr1 $o
cat_binprod_corec z f g $== f
cat_binprod_beta_pr2: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr2 $o
cat_binprod_corec z f g $== g
cat_binprod_eta_pr: forall (z : A)
(f g : z $-> cat_binprod'),
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g ->
f $== g
z: A
f: forall i : Bool,
z $-> (fun b : Bool => if b then x else y) i
z $-> x exact (f true).
    +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y, cat_binprod': A
cat_pr1: cat_binprod' $-> x
cat_pr2: cat_binprod' $-> y
cat_binprod_corec: forall z : A,
(z $-> x) ->
(z $-> y) -> z $-> cat_binprod'
cat_binprod_beta_pr1: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr1 $o
cat_binprod_corec z f g $== f
cat_binprod_beta_pr2: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr2 $o
cat_binprod_corec z f g $== g
cat_binprod_eta_pr: forall (z : A)
(f g : z $-> cat_binprod'),
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g ->
f $== g
z: A
f: forall i : Bool,
z $-> (fun b : Bool => if b then x else y) i
z $-> y exact (f false).
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y, cat_binprod': A
cat_pr1: cat_binprod' $-> x
cat_pr2: cat_binprod' $-> y
cat_binprod_corec: forall z : A,
(z $-> x) ->
(z $-> y) -> z $-> cat_binprod'
cat_binprod_beta_pr1: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr1 $o
cat_binprod_corec z f g $== f
cat_binprod_beta_pr2: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr2 $o
cat_binprod_corec z f g $== g
cat_binprod_eta_pr: forall (z : A)
(f g : z $-> cat_binprod'),
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g ->
f $== g
forall (z : A)
(f : forall i : Bool,
     z $-> (fun b : Bool => if b then x else y) i)
(i : Bool),
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod' $-> (if b then x else y))
 then cat_pr1
 else cat_pr2) i $o
(fun (z0 : A)
   (f0 : forall i0 : Bool,
         z0 $->
         (fun b : Bool => if b then x else y) i0) =>
 cat_binprod_corec z0 (f0 true) (f0 false)) z f $==
f i intros z f [|].A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y, cat_binprod': A
cat_pr1: cat_binprod' $-> x
cat_pr2: cat_binprod' $-> y
cat_binprod_corec: forall z : A,
(z $-> x) ->
(z $-> y) -> z $-> cat_binprod'
cat_binprod_beta_pr1: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr1 $o
cat_binprod_corec z f g $== f
cat_binprod_beta_pr2: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr2 $o
cat_binprod_corec z f g $== g
cat_binprod_eta_pr: forall (z : A)
(f g : z $-> cat_binprod'),
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g ->
f $== g
z: A
f: forall i : Bool,
z $-> (fun b : Bool => if b then x else y) i
cat_pr1 $o cat_binprod_corec z (f true) (f false) $==
f true
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y, cat_binprod': A
cat_pr1: cat_binprod' $-> x
cat_pr2: cat_binprod' $-> y
cat_binprod_corec: forall z : A,
(z $-> x) ->
(z $-> y) -> z $-> cat_binprod'
cat_binprod_beta_pr1: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr1 $o
cat_binprod_corec z f g $== f
cat_binprod_beta_pr2: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr2 $o
cat_binprod_corec z f g $== g
cat_binprod_eta_pr: forall (z : A)
(f g : z $-> cat_binprod'),
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g ->
f $== g
z: A
f: forall i : Bool,
z $-> (fun b : Bool => if b then x else y) i
cat_pr2 $o cat_binprod_corec z (f true) (f false) $==
f false
    +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y, cat_binprod': A
cat_pr1: cat_binprod' $-> x
cat_pr2: cat_binprod' $-> y
cat_binprod_corec: forall z : A,
(z $-> x) ->
(z $-> y) -> z $-> cat_binprod'
cat_binprod_beta_pr1: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr1 $o
cat_binprod_corec z f g $== f
cat_binprod_beta_pr2: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr2 $o
cat_binprod_corec z f g $== g
cat_binprod_eta_pr: forall (z : A)
(f g : z $-> cat_binprod'),
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g ->
f $== g
z: A
f: forall i : Bool,
z $-> (fun b : Bool => if b then x else y) i
cat_pr1 $o cat_binprod_corec z (f true) (f false) $==
f true napply cat_binprod_beta_pr1.
    +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y, cat_binprod': A
cat_pr1: cat_binprod' $-> x
cat_pr2: cat_binprod' $-> y
cat_binprod_corec: forall z : A,
(z $-> x) ->
(z $-> y) -> z $-> cat_binprod'
cat_binprod_beta_pr1: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr1 $o
cat_binprod_corec z f g $== f
cat_binprod_beta_pr2: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr2 $o
cat_binprod_corec z f g $== g
cat_binprod_eta_pr: forall (z : A)
(f g : z $-> cat_binprod'),
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g ->
f $== g
z: A
f: forall i : Bool,
z $-> (fun b : Bool => if b then x else y) i
cat_pr2 $o cat_binprod_corec z (f true) (f false) $==
f false napply cat_binprod_beta_pr2.
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y, cat_binprod': A
cat_pr1: cat_binprod' $-> x
cat_pr2: cat_binprod' $-> y
cat_binprod_corec: forall z : A,
(z $-> x) ->
(z $-> y) -> z $-> cat_binprod'
cat_binprod_beta_pr1: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr1 $o
cat_binprod_corec z f g $== f
cat_binprod_beta_pr2: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr2 $o
cat_binprod_corec z f g $== g
cat_binprod_eta_pr: forall (z : A)
(f g : z $-> cat_binprod'),
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g ->
f $== g
forall (z : A) (f g : z $-> cat_binprod'),
(forall i : Bool,
 (fun i0 : Bool =>
  if i0 as b
   return (cat_binprod' $-> (if b then x else y))
  then cat_pr1
  else cat_pr2) i $o f $==
 (fun i0 : Bool =>
  if i0 as b
   return (cat_binprod' $-> (if b then x else y))
  then cat_pr1
  else cat_pr2) i $o g) -> f $== g intros z f g p.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y, cat_binprod': A
cat_pr1: cat_binprod' $-> x
cat_pr2: cat_binprod' $-> y
cat_binprod_corec: forall z : A,
(z $-> x) ->
(z $-> y) -> z $-> cat_binprod'
cat_binprod_beta_pr1: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr1 $o
cat_binprod_corec z f g $== f
cat_binprod_beta_pr2: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr2 $o
cat_binprod_corec z f g $== g
cat_binprod_eta_pr: forall (z : A)
(f g : z $-> cat_binprod'),
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g ->
f $== g
z: A
f, g: z $-> cat_binprod'
p: forall i : Bool,
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod' $-> (if b then x else y))
 then cat_pr1
 else cat_pr2) i $o f $==
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod' $-> (if b then x else y))
 then cat_pr1
 else cat_pr2) i $o g
f $== g
    napply cat_binprod_eta_pr.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y, cat_binprod': A
cat_pr1: cat_binprod' $-> x
cat_pr2: cat_binprod' $-> y
cat_binprod_corec: forall z : A,
(z $-> x) ->
(z $-> y) -> z $-> cat_binprod'
cat_binprod_beta_pr1: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr1 $o
cat_binprod_corec z f g $== f
cat_binprod_beta_pr2: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr2 $o
cat_binprod_corec z f g $== g
cat_binprod_eta_pr: forall (z : A)
(f g : z $-> cat_binprod'),
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g ->
f $== g
z: A
f, g: z $-> cat_binprod'
p: forall i : Bool,
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod' $-> (if b then x else y))
 then cat_pr1
 else cat_pr2) i $o f $==
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod' $-> (if b then x else y))
 then cat_pr1
 else cat_pr2) i $o g
cat_pr1 $o f $== cat_pr1 $o g
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y, cat_binprod': A
cat_pr1: cat_binprod' $-> x
cat_pr2: cat_binprod' $-> y
cat_binprod_corec: forall z : A,
(z $-> x) ->
(z $-> y) -> z $-> cat_binprod'
cat_binprod_beta_pr1: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr1 $o
cat_binprod_corec z f g $== f
cat_binprod_beta_pr2: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr2 $o
cat_binprod_corec z f g $== g
cat_binprod_eta_pr: forall (z : A)
(f g : z $-> cat_binprod'),
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g ->
f $== g
z: A
f, g: z $-> cat_binprod'
p: forall i : Bool,
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod' $-> (if b then x else y))
 then cat_pr1
 else cat_pr2) i $o f $==
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod' $-> (if b then x else y))
 then cat_pr1
 else cat_pr2) i $o g
cat_pr2 $o f $== cat_pr2 $o g
    +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y, cat_binprod': A
cat_pr1: cat_binprod' $-> x
cat_pr2: cat_binprod' $-> y
cat_binprod_corec: forall z : A,
(z $-> x) ->
(z $-> y) -> z $-> cat_binprod'
cat_binprod_beta_pr1: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr1 $o
cat_binprod_corec z f g $== f
cat_binprod_beta_pr2: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr2 $o
cat_binprod_corec z f g $== g
cat_binprod_eta_pr: forall (z : A)
(f g : z $-> cat_binprod'),
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g ->
f $== g
z: A
f, g: z $-> cat_binprod'
p: forall i : Bool,
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod' $-> (if b then x else y))
 then cat_pr1
 else cat_pr2) i $o f $==
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod' $-> (if b then x else y))
 then cat_pr1
 else cat_pr2) i $o g
cat_pr1 $o f $== cat_pr1 $o g exact (p true).
    +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x, y, cat_binprod': A
cat_pr1: cat_binprod' $-> x
cat_pr2: cat_binprod' $-> y
cat_binprod_corec: forall z : A,
(z $-> x) ->
(z $-> y) -> z $-> cat_binprod'
cat_binprod_beta_pr1: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr1 $o
cat_binprod_corec z f g $== f
cat_binprod_beta_pr2: forall (z : A) (f : z $-> x)
(g : z $-> y),
cat_pr2 $o
cat_binprod_corec z f g $== g
cat_binprod_eta_pr: forall (z : A)
(f g : z $-> cat_binprod'),
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g ->
f $== g
z: A
f, g: z $-> cat_binprod'
p: forall i : Bool,
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod' $-> (if b then x else y))
 then cat_pr1
 else cat_pr2) i $o f $==
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod' $-> (if b then x else y))
 then cat_pr1
 else cat_pr2) i $o g
cat_pr2 $o f $== cat_pr2 $o g exact (p false).
Defined.

Definition cat_binprod {A: Type} `{HasBinaryProducts A} x y := cat_binprod' x y.

Definition cat_binprod_eta_pr_x_xx {A : Type} `{HasBinaryProducts A} {w x y z : A}
  (f g : w $-> cat_binprod x (cat_binprod y z))
  : cat_pr1 $o f $== cat_pr1 $o g
  -> cat_pr1 $o cat_pr2 $o f $== cat_pr1 $o cat_pr2 $o g
  -> cat_pr2 $o cat_pr2 $o f $== cat_pr2 $o cat_pr2 $o g
  -> f $== g.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
w, x, y, z: A
f, g: w $-> cat_binprod x (cat_binprod y z)
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr1 $o cat_pr2 $o f $== cat_pr1 $o cat_pr2 $o g ->
cat_pr2 $o cat_pr2 $o f $== cat_pr2 $o cat_pr2 $o g ->
f $== g
Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
w, x, y, z: A
f, g: w $-> cat_binprod x (cat_binprod y z)
cat_pr1 $o f $== cat_pr1 $o g ->
cat_pr1 $o cat_pr2 $o f $== cat_pr1 $o cat_pr2 $o g ->
cat_pr2 $o cat_pr2 $o f $== cat_pr2 $o cat_pr2 $o g ->
f $== g
  intros p q r.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
w, x, y, z: A
f, g: w $-> cat_binprod x (cat_binprod y z)
p: cat_pr1 $o f $== cat_pr1 $o g
q: cat_pr1 $o cat_pr2 $o f $==
cat_pr1 $o cat_pr2 $o g
r: cat_pr2 $o cat_pr2 $o f $==
cat_pr2 $o cat_pr2 $o g
f $== g
  snapply cat_binprod_eta_pr.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
w, x, y, z: A
f, g: w $-> cat_binprod x (cat_binprod y z)
p: cat_pr1 $o f $== cat_pr1 $o g
q: cat_pr1 $o cat_pr2 $o f $==
cat_pr1 $o cat_pr2 $o g
r: cat_pr2 $o cat_pr2 $o f $==
cat_pr2 $o cat_pr2 $o g
cat_pr1 $o f $== cat_pr1 $o g
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
w, x, y, z: A
f, g: w $-> cat_binprod x (cat_binprod y z)
p: cat_pr1 $o f $== cat_pr1 $o g
q: cat_pr1 $o cat_pr2 $o f $==
cat_pr1 $o cat_pr2 $o g
r: cat_pr2 $o cat_pr2 $o f $==
cat_pr2 $o cat_pr2 $o g
cat_pr2 $o f $== cat_pr2 $o g
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
w, x, y, z: A
f, g: w $-> cat_binprod x (cat_binprod y z)
p: cat_pr1 $o f $== cat_pr1 $o g
q: cat_pr1 $o cat_pr2 $o f $==
cat_pr1 $o cat_pr2 $o g
r: cat_pr2 $o cat_pr2 $o f $==
cat_pr2 $o cat_pr2 $o g
cat_pr1 $o f $== cat_pr1 $o g exact p.
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
w, x, y, z: A
f, g: w $-> cat_binprod x (cat_binprod y z)
p: cat_pr1 $o f $== cat_pr1 $o g
q: cat_pr1 $o cat_pr2 $o f $==
cat_pr1 $o cat_pr2 $o g
r: cat_pr2 $o cat_pr2 $o f $==
cat_pr2 $o cat_pr2 $o g
cat_pr2 $o f $== cat_pr2 $o g snapply cat_binprod_eta_pr.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
w, x, y, z: A
f, g: w $-> cat_binprod x (cat_binprod y z)
p: cat_pr1 $o f $== cat_pr1 $o g
q: cat_pr1 $o cat_pr2 $o f $==
cat_pr1 $o cat_pr2 $o g
r: cat_pr2 $o cat_pr2 $o f $==
cat_pr2 $o cat_pr2 $o g
cat_pr1 $o (cat_pr2 $o f) $==
cat_pr1 $o (cat_pr2 $o g)
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
w, x, y, z: A
f, g: w $-> cat_binprod x (cat_binprod y z)
p: cat_pr1 $o f $== cat_pr1 $o g
q: cat_pr1 $o cat_pr2 $o f $==
cat_pr1 $o cat_pr2 $o g
r: cat_pr2 $o cat_pr2 $o f $==
cat_pr2 $o cat_pr2 $o g
cat_pr2 $o (cat_pr2 $o f) $==
cat_pr2 $o (cat_pr2 $o g)
    +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
w, x, y, z: A
f, g: w $-> cat_binprod x (cat_binprod y z)
p: cat_pr1 $o f $== cat_pr1 $o g
q: cat_pr1 $o cat_pr2 $o f $==
cat_pr1 $o cat_pr2 $o g
r: cat_pr2 $o cat_pr2 $o f $==
cat_pr2 $o cat_pr2 $o g
cat_pr1 $o (cat_pr2 $o f) $==
cat_pr1 $o (cat_pr2 $o g) exact (cat_assoc_opp _ _ _ $@ q $@ cat_assoc _ _ _).
    +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
w, x, y, z: A
f, g: w $-> cat_binprod x (cat_binprod y z)
p: cat_pr1 $o f $== cat_pr1 $o g
q: cat_pr1 $o cat_pr2 $o f $==
cat_pr1 $o cat_pr2 $o g
r: cat_pr2 $o cat_pr2 $o f $==
cat_pr2 $o cat_pr2 $o g
cat_pr2 $o (cat_pr2 $o f) $==
cat_pr2 $o (cat_pr2 $o g) exact (cat_assoc_opp _ _ _ $@ r $@ cat_assoc _ _ _).
Defined.

Definition cat_binprod_eta_pr_xx_x {A : Type} `{HasBinaryProducts A} {w x y z : A}
  (f g : w $-> cat_binprod (cat_binprod x y) z)
  : cat_pr1 $o cat_pr1 $o f $== cat_pr1 $o cat_pr1 $o g
  -> cat_pr2 $o cat_pr1 $o f $== cat_pr2 $o cat_pr1 $o g
  -> cat_pr2 $o f $== cat_pr2 $o g
  -> f $== g.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
w, x, y, z: A
f, g: w $-> cat_binprod (cat_binprod x y) z
cat_pr1 $o cat_pr1 $o f $== cat_pr1 $o cat_pr1 $o g ->
cat_pr2 $o cat_pr1 $o f $== cat_pr2 $o cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g -> f $== g
Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
w, x, y, z: A
f, g: w $-> cat_binprod (cat_binprod x y) z
cat_pr1 $o cat_pr1 $o f $== cat_pr1 $o cat_pr1 $o g ->
cat_pr2 $o cat_pr1 $o f $== cat_pr2 $o cat_pr1 $o g ->
cat_pr2 $o f $== cat_pr2 $o g -> f $== g
  intros p q r.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
w, x, y, z: A
f, g: w $-> cat_binprod (cat_binprod x y) z
p: cat_pr1 $o cat_pr1 $o f $==
cat_pr1 $o cat_pr1 $o g
q: cat_pr2 $o cat_pr1 $o f $==
cat_pr2 $o cat_pr1 $o g
r: cat_pr2 $o f $== cat_pr2 $o g
f $== g
  snapply cat_binprod_eta_pr.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
w, x, y, z: A
f, g: w $-> cat_binprod (cat_binprod x y) z
p: cat_pr1 $o cat_pr1 $o f $==
cat_pr1 $o cat_pr1 $o g
q: cat_pr2 $o cat_pr1 $o f $==
cat_pr2 $o cat_pr1 $o g
r: cat_pr2 $o f $== cat_pr2 $o g
cat_pr1 $o f $== cat_pr1 $o g
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
w, x, y, z: A
f, g: w $-> cat_binprod (cat_binprod x y) z
p: cat_pr1 $o cat_pr1 $o f $==
cat_pr1 $o cat_pr1 $o g
q: cat_pr2 $o cat_pr1 $o f $==
cat_pr2 $o cat_pr1 $o g
r: cat_pr2 $o f $== cat_pr2 $o g
cat_pr2 $o f $== cat_pr2 $o g
  2: exact r.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
w, x, y, z: A
f, g: w $-> cat_binprod (cat_binprod x y) z
p: cat_pr1 $o cat_pr1 $o f $==
cat_pr1 $o cat_pr1 $o g
q: cat_pr2 $o cat_pr1 $o f $==
cat_pr2 $o cat_pr1 $o g
r: cat_pr2 $o f $== cat_pr2 $o g
cat_pr1 $o f $== cat_pr1 $o g
  snapply cat_binprod_eta_pr.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
w, x, y, z: A
f, g: w $-> cat_binprod (cat_binprod x y) z
p: cat_pr1 $o cat_pr1 $o f $==
cat_pr1 $o cat_pr1 $o g
q: cat_pr2 $o cat_pr1 $o f $==
cat_pr2 $o cat_pr1 $o g
r: cat_pr2 $o f $== cat_pr2 $o g
cat_pr1 $o (cat_pr1 $o f) $==
cat_pr1 $o (cat_pr1 $o g)
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
w, x, y, z: A
f, g: w $-> cat_binprod (cat_binprod x y) z
p: cat_pr1 $o cat_pr1 $o f $==
cat_pr1 $o cat_pr1 $o g
q: cat_pr2 $o cat_pr1 $o f $==
cat_pr2 $o cat_pr1 $o g
r: cat_pr2 $o f $== cat_pr2 $o g
cat_pr2 $o (cat_pr1 $o f) $==
cat_pr2 $o (cat_pr1 $o g)
  1,2: refine (cat_assoc_opp _ _ _ $@ _ $@ cat_assoc _ _ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
w, x, y, z: A
f, g: w $-> cat_binprod (cat_binprod x y) z
p: cat_pr1 $o cat_pr1 $o f $==
cat_pr1 $o cat_pr1 $o g
q: cat_pr2 $o cat_pr1 $o f $==
cat_pr2 $o cat_pr1 $o g
r: cat_pr2 $o f $== cat_pr2 $o g
cat_pr1 $o cat_pr1 $o f $== cat_pr1 $o cat_pr1 $o g
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
w, x, y, z: A
f, g: w $-> cat_binprod (cat_binprod x y) z
p: cat_pr1 $o cat_pr1 $o f $==
cat_pr1 $o cat_pr1 $o g
q: cat_pr2 $o cat_pr1 $o f $==
cat_pr2 $o cat_pr1 $o g
r: cat_pr2 $o f $== cat_pr2 $o g
cat_pr2 $o cat_pr1 $o f $== cat_pr2 $o cat_pr1 $o g
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
w, x, y, z: A
f, g: w $-> cat_binprod (cat_binprod x y) z
p: cat_pr1 $o cat_pr1 $o f $==
cat_pr1 $o cat_pr1 $o g
q: cat_pr2 $o cat_pr1 $o f $==
cat_pr2 $o cat_pr1 $o g
r: cat_pr2 $o f $== cat_pr2 $o g
cat_pr1 $o cat_pr1 $o f $== cat_pr1 $o cat_pr1 $o g exact p.
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
w, x, y, z: A
f, g: w $-> cat_binprod (cat_binprod x y) z
p: cat_pr1 $o cat_pr1 $o f $==
cat_pr1 $o cat_pr1 $o g
q: cat_pr2 $o cat_pr1 $o f $==
cat_pr2 $o cat_pr1 $o g
r: cat_pr2 $o f $== cat_pr2 $o g
cat_pr2 $o cat_pr1 $o f $== cat_pr2 $o cat_pr1 $o g exact q.
Defined.

Definition cat_binprod_eta_pr_x_xx_id {A : Type} `{HasBinaryProducts A} {x y z : A}
  (f : cat_binprod x (cat_binprod y z) $-> cat_binprod x (cat_binprod y z))
  : cat_pr1 $o f $== cat_pr1
  -> cat_pr1 $o cat_pr2 $o f $== cat_pr1 $o cat_pr2
  -> cat_pr2 $o cat_pr2 $o f $== cat_pr2 $o cat_pr2
  -> f $== Id _.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x, y, z: A
f: cat_binprod x (cat_binprod y z) $->
cat_binprod x (cat_binprod y z)
cat_pr1 $o f $== cat_pr1 ->
cat_pr1 $o cat_pr2 $o f $== cat_pr1 $o cat_pr2 ->
cat_pr2 $o cat_pr2 $o f $== cat_pr2 $o cat_pr2 ->
f $== Id (cat_binprod x (cat_binprod y z))
Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x, y, z: A
f: cat_binprod x (cat_binprod y z) $->
cat_binprod x (cat_binprod y z)
cat_pr1 $o f $== cat_pr1 ->
cat_pr1 $o cat_pr2 $o f $== cat_pr1 $o cat_pr2 ->
cat_pr2 $o cat_pr2 $o f $== cat_pr2 $o cat_pr2 ->
f $== Id (cat_binprod x (cat_binprod y z))
  intros p q r.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x, y, z: A
f: cat_binprod x (cat_binprod y z) $->
cat_binprod x (cat_binprod y z)
p: cat_pr1 $o f $== cat_pr1
q: cat_pr1 $o cat_pr2 $o f $== cat_pr1 $o cat_pr2
r: cat_pr2 $o cat_pr2 $o f $== cat_pr2 $o cat_pr2
f $== Id (cat_binprod x (cat_binprod y z))
  snapply cat_binprod_eta_pr_x_xx.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x, y, z: A
f: cat_binprod x (cat_binprod y z) $->
cat_binprod x (cat_binprod y z)
p: cat_pr1 $o f $== cat_pr1
q: cat_pr1 $o cat_pr2 $o f $== cat_pr1 $o cat_pr2
r: cat_pr2 $o cat_pr2 $o f $== cat_pr2 $o cat_pr2
cat_pr1 $o f $==
cat_pr1 $o Id (cat_binprod x (cat_binprod y z))
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x, y, z: A
f: cat_binprod x (cat_binprod y z) $->
cat_binprod x (cat_binprod y z)
p: cat_pr1 $o f $== cat_pr1
q: cat_pr1 $o cat_pr2 $o f $== cat_pr1 $o cat_pr2
r: cat_pr2 $o cat_pr2 $o f $== cat_pr2 $o cat_pr2
cat_pr1 $o cat_pr2 $o f $==
cat_pr1 $o cat_pr2 $o
Id (cat_binprod x (cat_binprod y z))
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x, y, z: A
f: cat_binprod x (cat_binprod y z) $->
cat_binprod x (cat_binprod y z)
p: cat_pr1 $o f $== cat_pr1
q: cat_pr1 $o cat_pr2 $o f $== cat_pr1 $o cat_pr2
r: cat_pr2 $o cat_pr2 $o f $== cat_pr2 $o cat_pr2
cat_pr2 $o cat_pr2 $o f $==
cat_pr2 $o cat_pr2 $o
Id (cat_binprod x (cat_binprod y z))
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x, y, z: A
f: cat_binprod x (cat_binprod y z) $->
cat_binprod x (cat_binprod y z)
p: cat_pr1 $o f $== cat_pr1
q: cat_pr1 $o cat_pr2 $o f $== cat_pr1 $o cat_pr2
r: cat_pr2 $o cat_pr2 $o f $== cat_pr2 $o cat_pr2
cat_pr1 $o f $==
cat_pr1 $o Id (cat_binprod x (cat_binprod y z)) exact (p $@ (cat_idr _)^$).
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x, y, z: A
f: cat_binprod x (cat_binprod y z) $->
cat_binprod x (cat_binprod y z)
p: cat_pr1 $o f $== cat_pr1
q: cat_pr1 $o cat_pr2 $o f $== cat_pr1 $o cat_pr2
r: cat_pr2 $o cat_pr2 $o f $== cat_pr2 $o cat_pr2
cat_pr1 $o cat_pr2 $o f $==
cat_pr1 $o cat_pr2 $o
Id (cat_binprod x (cat_binprod y z)) exact (q $@ (cat_idr _)^$).
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x, y, z: A
f: cat_binprod x (cat_binprod y z) $->
cat_binprod x (cat_binprod y z)
p: cat_pr1 $o f $== cat_pr1
q: cat_pr1 $o cat_pr2 $o f $== cat_pr1 $o cat_pr2
r: cat_pr2 $o cat_pr2 $o f $== cat_pr2 $o cat_pr2
cat_pr2 $o cat_pr2 $o f $==
cat_pr2 $o cat_pr2 $o
Id (cat_binprod x (cat_binprod y z)) exact (r $@ (cat_idr _)^$).
Defined.

(** From binary products, all [Bool]-shaped products can be constructed. This should not be an instance to avoid a cycle with [hasbinaryproducts_hasproductsbool]. *)
Definition hasproductsbool_hasbinaryproducts {A : Type} `{HasBinaryProducts A}
  : HasProducts Bool A.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
HasProducts Bool A
Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
HasProducts Bool A
  intros x.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
Product Bool x
  snapply Build_Product.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
A
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
forall i : Bool, ?cat_prod $-> x i
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
forall z : A,
(forall i : Bool, z $-> x i) -> z $-> ?cat_prod
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
forall (z : A) (f : forall i : Bool, z $-> x i)
(i : Bool), ?cat_pr i $o ?cat_prod_corec z f $== f i
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
forall (z : A) (f g : z $-> ?cat_prod),
(forall i : Bool, ?cat_pr i $o f $== ?cat_pr i $o g) ->
f $== g
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
A exact (cat_binprod (x true) (x false)).
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
forall i : Bool,
cat_binprod (x true) (x false) $-> x i intros [|].A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
cat_binprod (x true) (x false) $-> x true
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
cat_binprod (x true) (x false) $-> x false
    +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
cat_binprod (x true) (x false) $-> x true exact cat_pr1.
    +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
cat_binprod (x true) (x false) $-> x false exact cat_pr2.
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
forall z : A,
(forall i : Bool, z $-> x i) ->
z $-> cat_binprod (x true) (x false) intros z f.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
z: A
f: forall i : Bool, z $-> x i
z $-> cat_binprod (x true) (x false)
    exact (cat_binprod_corec (f true) (f false)).
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
forall (z : A) (f : forall i : Bool, z $-> x i)
(i : Bool),
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod (x true) (x false) $-> x b)
 then cat_pr1
 else cat_pr2) i $o
(fun (z0 : A) (f0 : forall i0 : Bool, z0 $-> x i0) =>
 cat_binprod_corec (f0 true) (f0 false)) z f $== f i intros z f [|].A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
z: A
f: forall i : Bool, z $-> x i
cat_pr1 $o cat_binprod_corec (f true) (f false) $==
f true
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
z: A
f: forall i : Bool, z $-> x i
cat_pr2 $o cat_binprod_corec (f true) (f false) $==
f false
    +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
z: A
f: forall i : Bool, z $-> x i
cat_pr1 $o cat_binprod_corec (f true) (f false) $==
f true exact (cat_binprod_beta_pr1 (f true) (f false)).
    +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
z: A
f: forall i : Bool, z $-> x i
cat_pr2 $o cat_binprod_corec (f true) (f false) $==
f false exact (cat_binprod_beta_pr2 (f true) (f false)).
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
forall (z : A)
(f g : z $-> cat_binprod (x true) (x false)),
(forall i : Bool,
 (fun i0 : Bool =>
  if i0 as b
   return (cat_binprod (x true) (x false) $-> x b)
  then cat_pr1
  else cat_pr2) i $o f $==
 (fun i0 : Bool =>
  if i0 as b
   return (cat_binprod (x true) (x false) $-> x b)
  then cat_pr1
  else cat_pr2) i $o g) -> f $== g intros z f g p.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
z: A
f, g: z $-> cat_binprod (x true) (x false)
p: forall i : Bool,
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod (x true) (x false) $-> x b)
 then cat_pr1
 else cat_pr2) i $o f $==
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod (x true) (x false) $-> x b)
 then cat_pr1
 else cat_pr2) i $o g
f $== g
    napply cat_binprod_eta_pr.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
z: A
f, g: z $-> cat_binprod (x true) (x false)
p: forall i : Bool,
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod (x true) (x false) $-> x b)
 then cat_pr1
 else cat_pr2) i $o f $==
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod (x true) (x false) $-> x b)
 then cat_pr1
 else cat_pr2) i $o g
cat_pr1 $o f $== cat_pr1 $o g
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
z: A
f, g: z $-> cat_binprod (x true) (x false)
p: forall i : Bool,
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod (x true) (x false) $-> x b)
 then cat_pr1
 else cat_pr2) i $o f $==
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod (x true) (x false) $-> x b)
 then cat_pr1
 else cat_pr2) i $o g
cat_pr2 $o f $== cat_pr2 $o g
    +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
z: A
f, g: z $-> cat_binprod (x true) (x false)
p: forall i : Bool,
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod (x true) (x false) $-> x b)
 then cat_pr1
 else cat_pr2) i $o f $==
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod (x true) (x false) $-> x b)
 then cat_pr1
 else cat_pr2) i $o g
cat_pr1 $o f $== cat_pr1 $o g exact (p true).
    +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
z: A
f, g: z $-> cat_binprod (x true) (x false)
p: forall i : Bool,
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod (x true) (x false) $-> x b)
 then cat_pr1
 else cat_pr2) i $o f $==
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod (x true) (x false) $-> x b)
 then cat_pr1
 else cat_pr2) i $o g
cat_pr2 $o f $== cat_pr2 $o g exact (p false).
Defined.

(** *** Operations on indexed products *)

(** We can take the disjoint union of the index set of an indexed product if we have all binary products. This is useful for associating products in a canonical way. This leads to symmetry and associativity of binary products. *)

Definition cat_prod_index_sum {I J : Type} {A : Type} `{HasBinaryProducts A}
  (x : I -> A) (y : J -> A)
  : Product I x -> Product J y -> Product (I + J) (sum_ind _ x y).I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
Product I x ->
Product J y ->
Product (I + J) (sum_ind (fun _ : I + J => A) x y)
Proof.I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
Product I x ->
Product J y ->
Product (I + J) (sum_ind (fun _ : I + J => A) x y)
  intros p q.I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
Product (I + J) (sum_ind (fun _ : I + J => A) x y)
  snapply Build_Product.I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
A
I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
forall i : I + J,
?cat_prod $-> sum_ind (fun _ : I + J => A) x y i
I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
forall z : A,
(forall i : I + J,
 z $-> sum_ind (fun _ : I + J => A) x y i) ->
z $-> ?cat_prod
I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
forall (z : A)
(f : forall i : I + J,
     z $-> sum_ind (fun _ : I + J => A) x y i)
(i : I + J), ?cat_pr i $o ?cat_prod_corec z f $== f i
I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
forall (z : A) (f g : z $-> ?cat_prod),
(forall i : I + J, ?cat_pr i $o f $== ?cat_pr i $o g) ->
f $== g
  -I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
A exact (cat_binprod (cat_prod I x) (cat_prod J y)).
  -I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
forall i : I + J,
cat_binprod (cat_prod I x) (cat_prod J y) $->
sum_ind (fun _ : I + J => A) x y i intros [i | j].I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
i: I
cat_binprod (cat_prod I x) (cat_prod J y) $->
sum_ind (fun _ : I + J => A) x y (inl i)
I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
j: J
cat_binprod (cat_prod I x) (cat_prod J y) $->
sum_ind (fun _ : I + J => A) x y (inr j)
    +I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
i: I
cat_binprod (cat_prod I x) (cat_prod J y) $->
sum_ind (fun _ : I + J => A) x y (inl i) exact (cat_pr _ $o cat_pr1).
    +I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
j: J
cat_binprod (cat_prod I x) (cat_prod J y) $->
sum_ind (fun _ : I + J => A) x y (inr j) exact (cat_pr _ $o cat_pr2).
  -I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
forall z : A,
(forall i : I + J,
 z $-> sum_ind (fun _ : I + J => A) x y i) ->
z $-> cat_binprod (cat_prod I x) (cat_prod J y) intros z f.I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
z: A
f: forall i : I + J,
z $-> sum_ind (fun _ : I + J => A) x y i
z $-> cat_binprod (cat_prod I x) (cat_prod J y)
    napply cat_binprod_corec.I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
z: A
f: forall i : I + J,
z $-> sum_ind (fun _ : I + J => A) x y i
z $-> cat_prod I x
I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
z: A
f: forall i : I + J,
z $-> sum_ind (fun _ : I + J => A) x y i
z $-> cat_prod J y
    +I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
z: A
f: forall i : I + J,
z $-> sum_ind (fun _ : I + J => A) x y i
z $-> cat_prod I x napply cat_prod_corec.I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
z: A
f: forall i : I + J,
z $-> sum_ind (fun _ : I + J => A) x y i
forall i : I, z $-> x i
      exact (f o inl).
    +I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
z: A
f: forall i : I + J,
z $-> sum_ind (fun _ : I + J => A) x y i
z $-> cat_prod J y napply cat_prod_corec.I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
z: A
f: forall i : I + J,
z $-> sum_ind (fun _ : I + J => A) x y i
forall i : J, z $-> y i
      exact (f o inr).
  -I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
forall (z : A)
(f : forall i : I + J,
     z $-> sum_ind (fun _ : I + J => A) x y i)
(i : I + J),
(fun i0 : I + J =>
 match
   i0 as s
   return
     (cat_binprod (cat_prod I x) (cat_prod J y) $->
      sum_ind (fun _ : I + J => A) x y s)
 with
 | inl i1 => (fun i2 : I => cat_pr i2 $o cat_pr1) i1
 | inr j => (fun j0 : J => cat_pr j0 $o cat_pr2) j
 end) i $o
(fun (z0 : A)
   (f0 : forall i0 : I + J,
         z0 $-> sum_ind (fun _ : I + J => A) x y i0)
 =>
 cat_binprod_corec (cat_prod_corec I (f0 o inl))
   (cat_prod_corec J (f0 o inr))) z f $== f i intros z f [i | j].I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
z: A
f: forall i : I + J,
z $-> sum_ind (fun _ : I + J => A) x y i
i: I
cat_pr i $o cat_pr1 $o
cat_binprod_corec
  (cat_prod_corec I (fun x : I => f (inl x)))
  (cat_prod_corec J (fun x : J => f (inr x))) $==
f (inl i)
I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
z: A
f: forall i : I + J,
z $-> sum_ind (fun _ : I + J => A) x y i
j: J
cat_pr j $o cat_pr2 $o
cat_binprod_corec
  (cat_prod_corec I (fun x : I => f (inl x)))
  (cat_prod_corec J (fun x : J => f (inr x))) $==
f (inr j)
    +I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
z: A
f: forall i : I + J,
z $-> sum_ind (fun _ : I + J => A) x y i
i: I
cat_pr i $o cat_pr1 $o
cat_binprod_corec
  (cat_prod_corec I (fun x : I => f (inl x)))
  (cat_prod_corec J (fun x : J => f (inr x))) $==
f (inl i) nrefine (cat_assoc _ _ _ $@ _).I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
z: A
f: forall i : I + J,
z $-> sum_ind (fun _ : I + J => A) x y i
i: I
cat_pr i $o
(cat_pr1 $o
 cat_binprod_corec
   (cat_prod_corec I (fun x : I => f (inl x)))
   (cat_prod_corec J (fun x : J => f (inr x)))) $==
f (inl i)
      nrefine ((_ $@L cat_binprod_beta_pr1 _ _) $@ _).I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
z: A
f: forall i : I + J,
z $-> sum_ind (fun _ : I + J => A) x y i
i: I
cat_pr i $o cat_prod_corec I (fun x : I => f (inl x)) $==
f (inl i)
      rapply cat_prod_beta.
    +I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
z: A
f: forall i : I + J,
z $-> sum_ind (fun _ : I + J => A) x y i
j: J
cat_pr j $o cat_pr2 $o
cat_binprod_corec
  (cat_prod_corec I (fun x : I => f (inl x)))
  (cat_prod_corec J (fun x : J => f (inr x))) $==
f (inr j) nrefine (cat_assoc _ _ _ $@ _).I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
z: A
f: forall i : I + J,
z $-> sum_ind (fun _ : I + J => A) x y i
j: J
cat_pr j $o
(cat_pr2 $o
 cat_binprod_corec
   (cat_prod_corec I (fun x : I => f (inl x)))
   (cat_prod_corec J (fun x : J => f (inr x)))) $==
f (inr j)
      nrefine ((_ $@L cat_binprod_beta_pr2 _ _) $@ _).I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
z: A
f: forall i : I + J,
z $-> sum_ind (fun _ : I + J => A) x y i
j: J
cat_pr j $o cat_prod_corec J (fun x : J => f (inr x)) $==
f (inr j)
      rapply cat_prod_beta.
  -I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
forall (z : A)
(f
 g : z $-> cat_binprod (cat_prod I x) (cat_prod J y)),
(forall i : I + J,
 (fun i0 : I + J =>
  match
    i0 as s
    return
      (cat_binprod (cat_prod I x) (cat_prod J y) $->
       sum_ind (fun _ : I + J => A) x y s)
  with
  | inl i1 => (fun i2 : I => cat_pr i2 $o cat_pr1) i1
  | inr j => (fun j0 : J => cat_pr j0 $o cat_pr2) j
  end) i $o f $==
 (fun i0 : I + J =>
  match
    i0 as s
    return
      (cat_binprod (cat_prod I x) (cat_prod J y) $->
       sum_ind (fun _ : I + J => A) x y s)
  with
  | inl i1 => (fun i2 : I => cat_pr i2 $o cat_pr1) i1
  | inr j => (fun j0 : J => cat_pr j0 $o cat_pr2) j
  end) i $o g) -> f $== g intros z f g r.I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
z: A
f, g: z $-> cat_binprod (cat_prod I x) (cat_prod J y)
r: forall i : I + J,
(fun i0 : I + J =>
 match
   i0 as s
   return
     (cat_binprod (cat_prod I x) (cat_prod J y) $->
      sum_ind (fun _ : I + J => A) x y s)
 with
 | inl i1 =>
     (fun i2 : I => cat_pr i2 $o cat_pr1) i1
 | inr j => (fun j0 : J => cat_pr j0 $o cat_pr2) j
 end) i $o f $==
(fun i0 : I + J =>
 match
   i0 as s
   return
     (cat_binprod (cat_prod I x) (cat_prod J y) $->
      sum_ind (fun _ : I + J => A) x y s)
 with
 | inl i1 =>
     (fun i2 : I => cat_pr i2 $o cat_pr1) i1
 | inr j => (fun j0 : J => cat_pr j0 $o cat_pr2) j
 end) i $o g
f $== g
    rapply cat_binprod_eta_pr.I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
z: A
f, g: z $-> cat_binprod (cat_prod I x) (cat_prod J y)
r: forall i : I + J,
(fun i0 : I + J =>
 match
   i0 as s
   return
     (cat_binprod (cat_prod I x) (cat_prod J y) $->
      sum_ind (fun _ : I + J => A) x y s)
 with
 | inl i1 =>
     (fun i2 : I => cat_pr i2 $o cat_pr1) i1
 | inr j => (fun j0 : J => cat_pr j0 $o cat_pr2) j
 end) i $o f $==
(fun i0 : I + J =>
 match
   i0 as s
   return
     (cat_binprod (cat_prod I x) (cat_prod J y) $->
      sum_ind (fun _ : I + J => A) x y s)
 with
 | inl i1 =>
     (fun i2 : I => cat_pr i2 $o cat_pr1) i1
 | inr j => (fun j0 : J => cat_pr j0 $o cat_pr2) j
 end) i $o g
cat_pr1 $o f $== cat_pr1 $o g
I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
z: A
f, g: z $-> cat_binprod (cat_prod I x) (cat_prod J y)
r: forall i : I + J,
(fun i0 : I + J =>
 match
   i0 as s
   return
     (cat_binprod (cat_prod I x) (cat_prod J y) $->
      sum_ind (fun _ : I + J => A) x y s)
 with
 | inl i1 =>
     (fun i2 : I => cat_pr i2 $o cat_pr1) i1
 | inr j => (fun j0 : J => cat_pr j0 $o cat_pr2) j
 end) i $o f $==
(fun i0 : I + J =>
 match
   i0 as s
   return
     (cat_binprod (cat_prod I x) (cat_prod J y) $->
      sum_ind (fun _ : I + J => A) x y s)
 with
 | inl i1 =>
     (fun i2 : I => cat_pr i2 $o cat_pr1) i1
 | inr j => (fun j0 : J => cat_pr j0 $o cat_pr2) j
 end) i $o g
cat_pr2 $o f $== cat_pr2 $o g
    +I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
z: A
f, g: z $-> cat_binprod (cat_prod I x) (cat_prod J y)
r: forall i : I + J,
(fun i0 : I + J =>
 match
   i0 as s
   return
     (cat_binprod (cat_prod I x) (cat_prod J y) $->
      sum_ind (fun _ : I + J => A) x y s)
 with
 | inl i1 =>
     (fun i2 : I => cat_pr i2 $o cat_pr1) i1
 | inr j => (fun j0 : J => cat_pr j0 $o cat_pr2) j
 end) i $o f $==
(fun i0 : I + J =>
 match
   i0 as s
   return
     (cat_binprod (cat_prod I x) (cat_prod J y) $->
      sum_ind (fun _ : I + J => A) x y s)
 with
 | inl i1 =>
     (fun i2 : I => cat_pr i2 $o cat_pr1) i1
 | inr j => (fun j0 : J => cat_pr j0 $o cat_pr2) j
 end) i $o g
cat_pr1 $o f $== cat_pr1 $o g rapply  cat_prod_pr_eta.I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
z: A
f, g: z $-> cat_binprod (cat_prod I x) (cat_prod J y)
r: forall i : I + J,
(fun i0 : I + J =>
 match
   i0 as s
   return
     (cat_binprod (cat_prod I x) (cat_prod J y) $->
      sum_ind (fun _ : I + J => A) x y s)
 with
 | inl i1 =>
     (fun i2 : I => cat_pr i2 $o cat_pr1) i1
 | inr j => (fun j0 : J => cat_pr j0 $o cat_pr2) j
 end) i $o f $==
(fun i0 : I + J =>
 match
   i0 as s
   return
     (cat_binprod (cat_prod I x) (cat_prod J y) $->
      sum_ind (fun _ : I + J => A) x y s)
 with
 | inl i1 =>
     (fun i2 : I => cat_pr i2 $o cat_pr1) i1
 | inr j => (fun j0 : J => cat_pr j0 $o cat_pr2) j
 end) i $o g
forall i : I,
cat_pr i $o (cat_pr1 $o f) $==
cat_pr i $o (cat_pr1 $o g)
      intros i.I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
z: A
f, g: z $-> cat_binprod (cat_prod I x) (cat_prod J y)
r: forall i : I + J,
(fun i0 : I + J =>
 match
   i0 as s
   return
     (cat_binprod (cat_prod I x) (cat_prod J y) $->
      sum_ind (fun _ : I + J => A) x y s)
 with
 | inl i1 =>
     (fun i2 : I => cat_pr i2 $o cat_pr1) i1
 | inr j => (fun j0 : J => cat_pr j0 $o cat_pr2) j
 end) i $o f $==
(fun i0 : I + J =>
 match
   i0 as s
   return
     (cat_binprod (cat_prod I x) (cat_prod J y) $->
      sum_ind (fun _ : I + J => A) x y s)
 with
 | inl i1 =>
     (fun i2 : I => cat_pr i2 $o cat_pr1) i1
 | inr j => (fun j0 : J => cat_pr j0 $o cat_pr2) j
 end) i $o g
i: I
cat_pr i $o (cat_pr1 $o f) $==
cat_pr i $o (cat_pr1 $o g)
      exact ((cat_assoc _ _ _)^$ $@ r (inl i) $@ cat_assoc _ _ _).
    +I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
z: A
f, g: z $-> cat_binprod (cat_prod I x) (cat_prod J y)
r: forall i : I + J,
(fun i0 : I + J =>
 match
   i0 as s
   return
     (cat_binprod (cat_prod I x) (cat_prod J y) $->
      sum_ind (fun _ : I + J => A) x y s)
 with
 | inl i1 =>
     (fun i2 : I => cat_pr i2 $o cat_pr1) i1
 | inr j => (fun j0 : J => cat_pr j0 $o cat_pr2) j
 end) i $o f $==
(fun i0 : I + J =>
 match
   i0 as s
   return
     (cat_binprod (cat_prod I x) (cat_prod J y) $->
      sum_ind (fun _ : I + J => A) x y s)
 with
 | inl i1 =>
     (fun i2 : I => cat_pr i2 $o cat_pr1) i1
 | inr j => (fun j0 : J => cat_pr j0 $o cat_pr2) j
 end) i $o g
cat_pr2 $o f $== cat_pr2 $o g rapply  cat_prod_pr_eta.I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
z: A
f, g: z $-> cat_binprod (cat_prod I x) (cat_prod J y)
r: forall i : I + J,
(fun i0 : I + J =>
 match
   i0 as s
   return
     (cat_binprod (cat_prod I x) (cat_prod J y) $->
      sum_ind (fun _ : I + J => A) x y s)
 with
 | inl i1 =>
     (fun i2 : I => cat_pr i2 $o cat_pr1) i1
 | inr j => (fun j0 : J => cat_pr j0 $o cat_pr2) j
 end) i $o f $==
(fun i0 : I + J =>
 match
   i0 as s
   return
     (cat_binprod (cat_prod I x) (cat_prod J y) $->
      sum_ind (fun _ : I + J => A) x y s)
 with
 | inl i1 =>
     (fun i2 : I => cat_pr i2 $o cat_pr1) i1
 | inr j => (fun j0 : J => cat_pr j0 $o cat_pr2) j
 end) i $o g
forall i : J,
cat_pr i $o (cat_pr2 $o f) $==
cat_pr i $o (cat_pr2 $o g)
      intros j.I, J, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: I -> A
y: J -> A
p: Product I x
q: Product J y
z: A
f, g: z $-> cat_binprod (cat_prod I x) (cat_prod J y)
r: forall i : I + J,
(fun i0 : I + J =>
 match
   i0 as s
   return
     (cat_binprod (cat_prod I x) (cat_prod J y) $->
      sum_ind (fun _ : I + J => A) x y s)
 with
 | inl i1 =>
     (fun i2 : I => cat_pr i2 $o cat_pr1) i1
 | inr j => (fun j0 : J => cat_pr j0 $o cat_pr2) j
 end) i $o f $==
(fun i0 : I + J =>
 match
   i0 as s
   return
     (cat_binprod (cat_prod I x) (cat_prod J y) $->
      sum_ind (fun _ : I + J => A) x y s)
 with
 | inl i1 =>
     (fun i2 : I => cat_pr i2 $o cat_pr1) i1
 | inr j => (fun j0 : J => cat_pr j0 $o cat_pr2) j
 end) i $o g
j: J
cat_pr j $o (cat_pr2 $o f) $==
cat_pr j $o (cat_pr2 $o g)
      exact ((cat_assoc _ _ _)^$ $@ r (inr j) $@ cat_assoc _ _ _).
Defined.

(** *** Binary product functor *)

(** We prove bifunctoriality of [cat_binprod : A -> A -> A] by factoring it as [cat_prod Bool o Bool_rec A]. First, we prove that [Bool_rec A : A -> A -> (Bool -> A)] is a bifunctor. *)
Local Instance is0bifunctor_boolrec {A : Type} `{Is1Cat A}
  : Is0Bifunctor (Bool_rec A).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
Is0Bifunctor (Bool_rec A)
Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
Is0Bifunctor (Bool_rec A)
  snapply Build_Is0Bifunctor'.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
Is01Cat A
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
Is01Cat A
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
Is0Functor (uncurry (Bool_rec A))
  1,2: exact _.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
Is0Functor (uncurry (Bool_rec A))
  snapply Build_Is0Functor.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
forall a b : A * A,
(a $-> b) ->
uncurry (Bool_rec A) a $-> uncurry (Bool_rec A) b
  intros [a b] [a' b'] [f g] [ | ].A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
a, b, a', b': A
f: fst (a, b) $-> fst (a', b')
g: snd (a, b) $-> snd (a', b')
uncurry (Bool_rec A) (a, b) true $->
uncurry (Bool_rec A) (a', b') true
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
a, b, a', b': A
f: fst (a, b) $-> fst (a', b')
g: snd (a, b) $-> snd (a', b')
uncurry (Bool_rec A) (a, b) false $->
uncurry (Bool_rec A) (a', b') false
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
a, b, a', b': A
f: fst (a, b) $-> fst (a', b')
g: snd (a, b) $-> snd (a', b')
uncurry (Bool_rec A) (a, b) true $->
uncurry (Bool_rec A) (a', b') true exact f.
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
a, b, a', b': A
f: fst (a, b) $-> fst (a', b')
g: snd (a, b) $-> snd (a', b')
uncurry (Bool_rec A) (a, b) false $->
uncurry (Bool_rec A) (a', b') false exact g.
Defined.

Local Instance is1bifunctor_boolrec {A : Type} `{Is1Cat A}
  : Is1Bifunctor (Bool_rec A).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
Is1Bifunctor (Bool_rec A)
Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
Is1Bifunctor (Bool_rec A)
  snapply Build_Is1Bifunctor'.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
Is1Functor (uncurry (Bool_rec A))
  snapply Build_Is1Functor.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
forall (a b : A * A) (f g : a $-> b),
f $== g ->
fmap (uncurry (Bool_rec A)) f $==
fmap (uncurry (Bool_rec A)) g
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
forall a : A * A,
fmap (uncurry (Bool_rec A)) (Id a) $==
Id (uncurry (Bool_rec A) a)
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
forall (a b c : A * A) 
(f : a $-> b) (g : b $-> c),
fmap (uncurry (Bool_rec A)) (g $o f) $==
fmap (uncurry (Bool_rec A)) g $o
fmap (uncurry (Bool_rec A)) f
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
forall (a b : A * A) (f g : a $-> b),
f $== g ->
fmap (uncurry (Bool_rec A)) f $==
fmap (uncurry (Bool_rec A)) g intros [a b] [a' b'] [f g] [f' g'] [p q] [ | ].A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
a, b, a', b': A
f: fst (a, b) $-> fst (a', b')
g: snd (a, b) $-> snd (a', b')
f': fst (a, b) $-> fst (a', b')
g': snd (a, b) $-> snd (a', b')
p: fst (f, g) $-> fst (f', g')
q: snd (f, g) $-> snd (f', g')
fmap (uncurry (Bool_rec A)) (f, g) true $->
fmap (uncurry (Bool_rec A)) (f', g') true
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
a, b, a', b': A
f: fst (a, b) $-> fst (a', b')
g: snd (a, b) $-> snd (a', b')
f': fst (a, b) $-> fst (a', b')
g': snd (a, b) $-> snd (a', b')
p: fst (f, g) $-> fst (f', g')
q: snd (f, g) $-> snd (f', g')
fmap (uncurry (Bool_rec A)) (f, g) false $->
fmap (uncurry (Bool_rec A)) (f', g') false
    +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
a, b, a', b': A
f: fst (a, b) $-> fst (a', b')
g: snd (a, b) $-> snd (a', b')
f': fst (a, b) $-> fst (a', b')
g': snd (a, b) $-> snd (a', b')
p: fst (f, g) $-> fst (f', g')
q: snd (f, g) $-> snd (f', g')
fmap (uncurry (Bool_rec A)) (f, g) true $->
fmap (uncurry (Bool_rec A)) (f', g') true exact p.
    +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
a, b, a', b': A
f: fst (a, b) $-> fst (a', b')
g: snd (a, b) $-> snd (a', b')
f': fst (a, b) $-> fst (a', b')
g': snd (a, b) $-> snd (a', b')
p: fst (f, g) $-> fst (f', g')
q: snd (f, g) $-> snd (f', g')
fmap (uncurry (Bool_rec A)) (f, g) false $->
fmap (uncurry (Bool_rec A)) (f', g') false exact q.
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
forall a : A * A,
fmap (uncurry (Bool_rec A)) (Id a) $==
Id (uncurry (Bool_rec A) a) intros [a b] [ | ]; reflexivity.
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
forall (a b c : A * A) (f : a $-> b) (g : b $-> c),
fmap (uncurry (Bool_rec A)) (g $o f) $==
fmap (uncurry (Bool_rec A)) g $o
fmap (uncurry (Bool_rec A)) f intros [a b] [a' b'] [a'' b''] [f f'] [g g'] [ | ]; reflexivity.
Defined.

(** As a special case of the product functor, restriction along [Bool_rec A] yields bifunctoriality of [cat_binprod]. *)
Instance is0bifunctor_cat_binprod {A : Type} `{HasBinaryProducts A}
  : Is0Bifunctor (fun x y => cat_binprod x y).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
Is0Bifunctor (fun x y : A => cat_binprod x y)
Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
Is0Bifunctor (fun x y : A => cat_binprod x y)
  pose (p:=@has_products _ _ _ _ _ _ hasproductsbool_hasbinaryproducts).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
p:= has_products: forall x : Bool -> A, Product Bool x
Is0Bifunctor (fun x y : A => cat_binprod x y)
  exact (is0bifunctor_postcompose
          (Bool_rec A) (fun x => cat_prod Bool x (product:=p x))).
Defined.

Instance is1bifunctor_cat_binprod {A : Type} `{HasBinaryProducts A}
  : Is1Bifunctor (fun x y => cat_binprod x y).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
Is1Bifunctor (fun x y : A => cat_binprod x y)
Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
Is1Bifunctor (fun x y : A => cat_binprod x y)
  pose (p:=@has_products _ _ _ _ _ _ hasproductsbool_hasbinaryproducts).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
p:= has_products: forall x : Bool -> A, Product Bool x
Is1Bifunctor (fun x y : A => cat_binprod x y)
  exact (is1bifunctor_postcompose
          (Bool_rec A) (fun x => cat_prod Bool x (product:=p x))).
Defined.

(** Binary products are functorial in each argument. *)
Instance is0functor_cat_binprod_l {A : Type} `{HasBinaryProducts A}
  (y : A)
  : Is0Functor (fun x => cat_binprod x y).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
y: A
Is0Functor (fun x : A => cat_binprod x y)
Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
y: A
Is0Functor (fun x : A => cat_binprod x y)
  exact (is0functor10_bifunctor (fun x y => cat_binprod x y) y).
Defined.

Instance is1functor_cat_binprod_l {A : Type} `{HasBinaryProducts A}
  (y : A)
  : Is1Functor (fun x => cat_binprod x y).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
y: A
Is1Functor (fun x : A => cat_binprod x y)
Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
y: A
Is1Functor (fun x : A => cat_binprod x y)
  exact (is1functor10_bifunctor _ y).
Defined.

Instance is0functor_cat_binprod_r {A : Type} `{HasBinaryProducts A}
  (x : A)
  : Is0Functor (fun y => cat_binprod x y).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: A
Is0Functor (fun y : A => cat_binprod x y)
Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: A
Is0Functor (fun y : A => cat_binprod x y)
  exact (is0functor01_bifunctor (fun x y => cat_binprod x y) x).
Defined.

Instance is1functor_cat_binprod_r {A : Type} `{HasBinaryProducts A}
  (x : A)
  : Is1Functor (fun y => cat_binprod x y).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: A
Is1Functor (fun y : A => cat_binprod x y)
Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: A
Is1Functor (fun y : A => cat_binprod x y)
  exact (is1functor01_bifunctor _ x).
Defined.

(** [cat_binprod_corec] is also functorial in each morphism. *)

Instance is0functor_cat_binprod_corec_l {A : Type}
  `{HasBinaryProducts A} {x y z : A} (g : z $-> y)
  : Is0Functor (fun f : z $-> y => cat_binprod_corec f g).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x, y, z: A
g: z $-> y
Is0Functor (fun f : z $-> y => cat_binprod_corec f g)
Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x, y, z: A
g: z $-> y
Is0Functor (fun f : z $-> y => cat_binprod_corec f g)
  snapply Build_Is0Functor.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x, y, z: A
g: z $-> y
forall a b : z $-> y,
(a $-> b) ->
(fun f : z $-> y => cat_binprod_corec f g) a $->
(fun f : z $-> y => cat_binprod_corec f g) b
  intros f f' p.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x, y, z: A
g, f, f': z $-> y
p: f $-> f'
(fun f : z $-> y => cat_binprod_corec f g) f $->
(fun f : z $-> y => cat_binprod_corec f g) f'
  by napply cat_binprod_corec_eta.
Defined.

Instance is0functor_cat_binprod_corec_r {A : Type}
  `{HasBinaryProducts A} {x y z : A} (f : z $-> x)
  : Is0Functor (fun g : z $-> x => cat_binprod_corec f g).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x, y, z: A
f: z $-> x
Is0Functor (fun g : z $-> x => cat_binprod_corec f g)
Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x, y, z: A
f: z $-> x
Is0Functor (fun g : z $-> x => cat_binprod_corec f g)
  snapply Build_Is0Functor.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x, y, z: A
f: z $-> x
forall a b : z $-> x,
(a $-> b) ->
(fun g : z $-> x => cat_binprod_corec f g) a $->
(fun g : z $-> x => cat_binprod_corec f g) b
  intros g h p.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x, y, z: A
f, g, h: z $-> x
p: g $-> h
(fun g : z $-> x => cat_binprod_corec f g) g $->
(fun g : z $-> x => cat_binprod_corec f g) h
  by napply cat_binprod_corec_eta.
Defined.

Definition cat_pr1_fmap01_binprod {A : Type} `{HasBinaryProducts A}
  (a : A) {x y : A} (g : x $-> y)
  : cat_pr1 $o fmap01 (fun x y => cat_binprod x y) a g $== cat_pr1
  := cat_binprod_beta_pr1 _ _ $@ cat_idl _.

Definition cat_pr1_fmap10_binprod {A : Type} `{HasBinaryProducts A}
  {x y : A} (f : x $-> y) (a : A)
  : cat_pr1 $o fmap10 (fun x y => cat_binprod x y) f a $== f $o cat_pr1
  := cat_binprod_beta_pr1 _ _.

Definition cat_pr1_fmap11_binprod {A : Type} `{HasBinaryProducts A}
  {w x y z : A} (f : w $-> y) (g : x $-> z)
  : cat_pr1 $o fmap11 (fun x y => cat_binprod x y) f g $== f $o cat_pr1
  := cat_binprod_beta_pr1 _ _.

Definition cat_pr2_fmap01_binprod {A : Type} `{HasBinaryProducts A}
  (a : A) {x y : A} (g : x $-> y)
  : cat_pr2 $o fmap01 (fun x y => cat_binprod x y) a g $== g $o cat_pr2
  := cat_binprod_beta_pr2 _ _.

Definition cat_pr2_fmap10_binprod {A : Type} `{HasBinaryProducts A}
  {x y : A} (f : x $-> y) (a : A)
  : cat_pr2 $o fmap10 (fun x y => cat_binprod x y) f a $== cat_pr2
  := cat_binprod_beta_pr2 _ _ $@ cat_idl _.

Definition cat_pr2_fmap11_binprod {A : Type} `{HasBinaryProducts A}
  {w x y z : A} (f : w $-> y) (g : x $-> z)
  : cat_pr2 $o fmap11 (fun x y => cat_binprod x y) f g $== g $o cat_pr2
  := cat_binprod_beta_pr2 _ _.

(** *** Diagonal *)

(** Annoyingly this doesn't follow directly from the general diagonal since [fun b => if b then x else x] is not definitionally equal to [fun _ => x]. *)
Definition cat_binprod_diag {A : Type}
  `{Is1Cat A} (x : A) `{!BinaryProduct x x}
  : x $-> cat_binprod' x x.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x: A
BinaryProduct0: BinaryProduct x x
x $-> cat_binprod' x x
Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x: A
BinaryProduct0: BinaryProduct x x
x $-> cat_binprod' x x
  snapply cat_binprod_corec; exact (Id _).
Defined.

(** *** Lemmas about [cat_binprod_corec] *)

Definition cat_binprod_fmap01_corec {A : Type}
  `{Is1Cat A, !HasBinaryProducts A} {w x y z : A}
  (f : w $-> z) (g : x $-> y) (h : w $-> x)
  : fmap01 (fun x y => cat_binprod x y) z g $o cat_binprod_corec f h
    $== cat_binprod_corec f (g $o h).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> z
g: x $-> y
h: w $-> x
fmap01 (fun x y : A => cat_binprod x y) z g $o
cat_binprod_corec f h $== cat_binprod_corec f (g $o h)
Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> z
g: x $-> y
h: w $-> x
fmap01 (fun x y : A => cat_binprod x y) z g $o
cat_binprod_corec f h $== cat_binprod_corec f (g $o h)
  snapply cat_binprod_eta_pr.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> z
g: x $-> y
h: w $-> x
cat_pr1 $o
(fmap01 (fun x y : A => cat_binprod x y) z g $o
 cat_binprod_corec f h) $==
cat_pr1 $o cat_binprod_corec f (g $o h)
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> z
g: x $-> y
h: w $-> x
cat_pr2 $o
(fmap01 (fun x y : A => cat_binprod x y) z g $o
 cat_binprod_corec f h) $==
cat_pr2 $o cat_binprod_corec f (g $o h)
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> z
g: x $-> y
h: w $-> x
cat_pr1 $o
(fmap01 (fun x y : A => cat_binprod x y) z g $o
 cat_binprod_corec f h) $==
cat_pr1 $o cat_binprod_corec f (g $o h) nrefine (cat_assoc_opp _ _ _ $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> z
g: x $-> y
h: w $-> x
cat_pr1 $o fmap01 (fun x y : A => cat_binprod x y) z g $o
cat_binprod_corec f h $==
cat_pr1 $o cat_binprod_corec f (g $o h)
    refine ((_ $@R _) $@ cat_assoc _ _ _ $@ cat_idl _ $@ _ $@ _^$).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> z
g: x $-> y
h: w $-> x
cat_pr1 $o fmap01 (fun x y : A => cat_binprod x y) z g $==
Id z $o ?Goal2
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> z
g: x $-> y
h: w $-> x
?Goal2 $o cat_binprod_corec f h $== ?Goal0
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> z
g: x $-> y
h: w $-> x
cat_pr1 $o cat_binprod_corec f (g $o h) $-> ?Goal0
    1-3: rapply cat_binprod_beta_pr1.
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> z
g: x $-> y
h: w $-> x
cat_pr2 $o
(fmap01 (fun x y : A => cat_binprod x y) z g $o
 cat_binprod_corec f h) $==
cat_pr2 $o cat_binprod_corec f (g $o h) nrefine (cat_assoc_opp _ _ _ $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> z
g: x $-> y
h: w $-> x
cat_pr2 $o fmap01 (fun x y : A => cat_binprod x y) z g $o
cat_binprod_corec f h $==
cat_pr2 $o cat_binprod_corec f (g $o h)
    refine ((_ $@R _) $@ cat_assoc _ _ _ $@ (_ $@L _) $@ _^$).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> z
g: x $-> y
h: w $-> x
cat_pr2 $o fmap01 (fun x y : A => cat_binprod x y) z g $==
?Goal2 $o ?Goal1
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> z
g: x $-> y
h: w $-> x
?Goal1 $o cat_binprod_corec f h $== ?Goal3
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> z
g: x $-> y
h: w $-> x
cat_pr2 $o cat_binprod_corec f (g $o h) $->
?Goal2 $o ?Goal3
    1-3: rapply cat_binprod_beta_pr2.
Defined.

Definition cat_binprod_fmap10_corec {A : Type}
  `{Is1Cat A, !HasBinaryProducts A} {w x y z : A}
  (f : x $-> y) (g : w $-> x) (h : w $-> z)
  : fmap10 (fun x y => cat_binprod x y) f z $o cat_binprod_corec g h
    $== cat_binprod_corec (f $o g) h.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: x $-> y
g: w $-> x
h: w $-> z
fmap10 (fun x y : A => cat_binprod x y) f z $o
cat_binprod_corec g h $== cat_binprod_corec (f $o g) h
Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: x $-> y
g: w $-> x
h: w $-> z
fmap10 (fun x y : A => cat_binprod x y) f z $o
cat_binprod_corec g h $== cat_binprod_corec (f $o g) h
  snapply cat_binprod_eta_pr.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: x $-> y
g: w $-> x
h: w $-> z
cat_pr1 $o
(fmap10 (fun x y : A => cat_binprod x y) f z $o
 cat_binprod_corec g h) $==
cat_pr1 $o cat_binprod_corec (f $o g) h
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: x $-> y
g: w $-> x
h: w $-> z
cat_pr2 $o
(fmap10 (fun x y : A => cat_binprod x y) f z $o
 cat_binprod_corec g h) $==
cat_pr2 $o cat_binprod_corec (f $o g) h
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: x $-> y
g: w $-> x
h: w $-> z
cat_pr1 $o
(fmap10 (fun x y : A => cat_binprod x y) f z $o
 cat_binprod_corec g h) $==
cat_pr1 $o cat_binprod_corec (f $o g) h refine (cat_assoc_opp _ _ _ $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: x $-> y
g: w $-> x
h: w $-> z
cat_pr1 $o fmap10 (fun x y : A => cat_binprod x y) f z $o
cat_binprod_corec g h $==
cat_pr1 $o cat_binprod_corec (f $o g) h
    refine ((_ $@R _) $@ cat_assoc _ _ _ $@ (_ $@L _) $@ _^$).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: x $-> y
g: w $-> x
h: w $-> z
cat_pr1 $o fmap10 (fun x y : A => cat_binprod x y) f z $==
?Goal3 $o ?Goal2
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: x $-> y
g: w $-> x
h: w $-> z
?Goal2 $o cat_binprod_corec g h $== ?Goal4
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: x $-> y
g: w $-> x
h: w $-> z
cat_pr1 $o cat_binprod_corec (f $o g) h $->
?Goal3 $o ?Goal4
    1-3: napply cat_binprod_beta_pr1.
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: x $-> y
g: w $-> x
h: w $-> z
cat_pr2 $o
(fmap10 (fun x y : A => cat_binprod x y) f z $o
 cat_binprod_corec g h) $==
cat_pr2 $o cat_binprod_corec (f $o g) h refine (cat_assoc_opp _ _ _ $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: x $-> y
g: w $-> x
h: w $-> z
cat_pr2 $o fmap10 (fun x y : A => cat_binprod x y) f z $o
cat_binprod_corec g h $==
cat_pr2 $o cat_binprod_corec (f $o g) h
    refine ((_ $@R _) $@ cat_assoc _ _ _ $@ cat_idl _ $@ _ $@ _^$).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: x $-> y
g: w $-> x
h: w $-> z
cat_pr2 $o fmap10 (fun x y : A => cat_binprod x y) f z $==
Id z $o ?Goal1
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: x $-> y
g: w $-> x
h: w $-> z
?Goal1 $o cat_binprod_corec g h $== ?Goal
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: x $-> y
g: w $-> x
h: w $-> z
cat_pr2 $o cat_binprod_corec (f $o g) h $-> ?Goal
    1-3: napply cat_binprod_beta_pr2.
Defined.

Definition cat_binprod_fmap11_corec {A : Type}
  `{Is1Cat A, !HasBinaryProducts A} {v w x y z : A}
  (f : w $-> y) (g : x $-> z) (h : v $-> w) (i : v $-> x)
  : fmap11 (fun x y => cat_binprod x y) f g $o cat_binprod_corec h i
    $== cat_binprod_corec (f $o h) (g $o i).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
v, w, x, y, z: A
f: w $-> y
g: x $-> z
h: v $-> w
i: v $-> x
fmap11 (fun x y : A => cat_binprod x y) f g $o
cat_binprod_corec h i $==
cat_binprod_corec (f $o h) (g $o i)
Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
v, w, x, y, z: A
f: w $-> y
g: x $-> z
h: v $-> w
i: v $-> x
fmap11 (fun x y : A => cat_binprod x y) f g $o
cat_binprod_corec h i $==
cat_binprod_corec (f $o h) (g $o i)
  snapply cat_binprod_eta_pr.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
v, w, x, y, z: A
f: w $-> y
g: x $-> z
h: v $-> w
i: v $-> x
cat_pr1 $o
(fmap11 (fun x y : A => cat_binprod x y) f g $o
 cat_binprod_corec h i) $==
cat_pr1 $o cat_binprod_corec (f $o h) (g $o i)
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
v, w, x, y, z: A
f: w $-> y
g: x $-> z
h: v $-> w
i: v $-> x
cat_pr2 $o
(fmap11 (fun x y : A => cat_binprod x y) f g $o
 cat_binprod_corec h i) $==
cat_pr2 $o cat_binprod_corec (f $o h) (g $o i)
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
v, w, x, y, z: A
f: w $-> y
g: x $-> z
h: v $-> w
i: v $-> x
cat_pr1 $o
(fmap11 (fun x y : A => cat_binprod x y) f g $o
 cat_binprod_corec h i) $==
cat_pr1 $o cat_binprod_corec (f $o h) (g $o i) refine (cat_assoc_opp _ _ _ $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
v, w, x, y, z: A
f: w $-> y
g: x $-> z
h: v $-> w
i: v $-> x
cat_pr1 $o fmap11 (fun x y : A => cat_binprod x y) f g $o
cat_binprod_corec h i $==
cat_pr1 $o cat_binprod_corec (f $o h) (g $o i)
    refine ((_ $@R _) $@ cat_assoc _ _ _ $@ (_ $@L _) $@ _^$).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
v, w, x, y, z: A
f: w $-> y
g: x $-> z
h: v $-> w
i: v $-> x
cat_pr1 $o fmap11 (fun x y : A => cat_binprod x y) f g $==
?Goal3 $o ?Goal2
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
v, w, x, y, z: A
f: w $-> y
g: x $-> z
h: v $-> w
i: v $-> x
?Goal2 $o cat_binprod_corec h i $== ?Goal4
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
v, w, x, y, z: A
f: w $-> y
g: x $-> z
h: v $-> w
i: v $-> x
cat_pr1 $o cat_binprod_corec (f $o h) (g $o i) $->
?Goal3 $o ?Goal4
    1-3: napply cat_binprod_beta_pr1.
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
v, w, x, y, z: A
f: w $-> y
g: x $-> z
h: v $-> w
i: v $-> x
cat_pr2 $o
(fmap11 (fun x y : A => cat_binprod x y) f g $o
 cat_binprod_corec h i) $==
cat_pr2 $o cat_binprod_corec (f $o h) (g $o i) nrefine (cat_assoc_opp _ _ _ $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
v, w, x, y, z: A
f: w $-> y
g: x $-> z
h: v $-> w
i: v $-> x
cat_pr2 $o fmap11 (fun x y : A => cat_binprod x y) f g $o
cat_binprod_corec h i $==
cat_pr2 $o cat_binprod_corec (f $o h) (g $o i)
    refine ((_ $@R _) $@ cat_assoc _ _ _ $@ (_ $@L _) $@ _^$).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
v, w, x, y, z: A
f: w $-> y
g: x $-> z
h: v $-> w
i: v $-> x
cat_pr2 $o fmap11 (fun x y : A => cat_binprod x y) f g $==
?Goal2 $o ?Goal1
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
v, w, x, y, z: A
f: w $-> y
g: x $-> z
h: v $-> w
i: v $-> x
?Goal1 $o cat_binprod_corec h i $== ?Goal3
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
HasBinaryProducts0: HasBinaryProducts A
v, w, x, y, z: A
f: w $-> y
g: x $-> z
h: v $-> w
i: v $-> x
cat_pr2 $o cat_binprod_corec (f $o h) (g $o i) $->
?Goal2 $o ?Goal3
    1-3: rapply cat_binprod_beta_pr2.
Defined.

(** *** Symmetry of binary products *)

Section Symmetry.

  (** The requirement of having all binary products can be weakened further to having specific binary products, but it is not clear this is a useful generality. *)
  Context {A : Type} `{HasEquivs A} `{!HasBinaryProducts A}.

  Definition cat_binprod_swap (x y : A) : cat_binprod x y $-> cat_binprod y x
    := cat_binprod_corec cat_pr2 cat_pr1.

  Lemma cat_binprod_swap_cat_binprod_swap (x y : A)
    : cat_binprod_swap x y $o cat_binprod_swap y x $== Id _.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y: A
cat_binprod_swap x y $o cat_binprod_swap y x $==
Id (cat_binprod y x)
  Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y: A
cat_binprod_swap x y $o cat_binprod_swap y x $==
Id (cat_binprod y x)
    napply cat_binprod_eta_pr.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y: A
cat_pr1 $o
(cat_binprod_swap x y $o cat_binprod_swap y x) $==
cat_pr1 $o Id (cat_binprod y x)
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y: A
cat_pr2 $o
(cat_binprod_swap x y $o cat_binprod_swap y x) $==
cat_pr2 $o Id (cat_binprod y x)
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y: A
cat_pr1 $o
(cat_binprod_swap x y $o cat_binprod_swap y x) $==
cat_pr1 $o Id (cat_binprod y x) refine ((cat_assoc _ _ _)^$ $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y: A
cat_pr1 $o cat_binprod_swap x y $o
cat_binprod_swap y x $==
cat_pr1 $o Id (cat_binprod y x)
      nrefine (cat_binprod_beta_pr1 _ _ $@R _ $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y: A
cat_pr2 $o cat_binprod_swap y x $==
cat_pr1 $o Id (cat_binprod y x)
      exact (cat_binprod_beta_pr2 _ _ $@ (cat_idr _)^$).
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y: A
cat_pr2 $o
(cat_binprod_swap x y $o cat_binprod_swap y x) $==
cat_pr2 $o Id (cat_binprod y x) refine ((cat_assoc _ _ _)^$ $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y: A
cat_pr2 $o cat_binprod_swap x y $o
cat_binprod_swap y x $==
cat_pr2 $o Id (cat_binprod y x)
      nrefine (cat_binprod_beta_pr2 _ _ $@R _ $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y: A
cat_pr1 $o cat_binprod_swap y x $==
cat_pr2 $o Id (cat_binprod y x)
      exact (cat_binprod_beta_pr1 _ _ $@ (cat_idr _)^$).
  Defined.

  Lemma cate_binprod_swap (x y : A)
    : cat_binprod x y $<~> cat_binprod y x.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y: A
cat_binprod x y $<~> cat_binprod y x
  Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y: A
cat_binprod x y $<~> cat_binprod y x
    snapply cate_adjointify.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y: A
cat_binprod x y $-> cat_binprod y x
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y: A
cat_binprod y x $-> cat_binprod x y
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y: A
?f $o ?g $== Id (cat_binprod y x)
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y: A
?g $o ?f $== Id (cat_binprod x y)
    1,2: napply cat_binprod_swap.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y: A
cat_binprod_swap x y $o cat_binprod_swap y x $==
Id (cat_binprod y x)
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y: A
cat_binprod_swap y x $o cat_binprod_swap x y $==
Id (cat_binprod x y)
    all: napply cat_binprod_swap_cat_binprod_swap.
  Defined.

  Definition cat_binprod_swap_corec {a b c : A} (f : a $-> b) (g : a $-> c)
    : cat_binprod_swap b c $o cat_binprod_corec f g $== cat_binprod_corec g f.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, b, c: A
f: a $-> b
g: a $-> c
cat_binprod_swap b c $o cat_binprod_corec f g $==
cat_binprod_corec g f
  Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, b, c: A
f: a $-> b
g: a $-> c
cat_binprod_swap b c $o cat_binprod_corec f g $==
cat_binprod_corec g f
    napply cat_binprod_eta_pr.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, b, c: A
f: a $-> b
g: a $-> c
cat_pr1 $o
(cat_binprod_swap b c $o cat_binprod_corec f g) $==
cat_pr1 $o cat_binprod_corec g f
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, b, c: A
f: a $-> b
g: a $-> c
cat_pr2 $o
(cat_binprod_swap b c $o cat_binprod_corec f g) $==
cat_pr2 $o cat_binprod_corec g f
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, b, c: A
f: a $-> b
g: a $-> c
cat_pr1 $o
(cat_binprod_swap b c $o cat_binprod_corec f g) $==
cat_pr1 $o cat_binprod_corec g f refine (cat_assoc_opp _ _ _ $@ (_ $@R _) $@ (_ $@ _^$)).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, b, c: A
f: a $-> b
g: a $-> c
cat_pr1 $o cat_binprod_swap b c $== ?Goal0
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, b, c: A
f: a $-> b
g: a $-> c
?Goal0 $o cat_binprod_corec f g $== ?Goal2
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, b, c: A
f: a $-> b
g: a $-> c
cat_pr1 $o cat_binprod_corec g f $-> ?Goal2
      1,3: napply cat_binprod_beta_pr1.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, b, c: A
f: a $-> b
g: a $-> c
cat_pr2 $o cat_binprod_corec f g $== g
      napply cat_binprod_beta_pr2.
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, b, c: A
f: a $-> b
g: a $-> c
cat_pr2 $o
(cat_binprod_swap b c $o cat_binprod_corec f g) $==
cat_pr2 $o cat_binprod_corec g f refine (cat_assoc_opp _ _ _ $@ (_ $@R _) $@ (_ $@ _^$)).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, b, c: A
f: a $-> b
g: a $-> c
cat_pr2 $o cat_binprod_swap b c $== ?Goal
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, b, c: A
f: a $-> b
g: a $-> c
?Goal $o cat_binprod_corec f g $== ?Goal1
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, b, c: A
f: a $-> b
g: a $-> c
cat_pr2 $o cat_binprod_corec g f $-> ?Goal1
      1,3: napply cat_binprod_beta_pr2.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, b, c: A
f: a $-> b
g: a $-> c
cat_pr1 $o cat_binprod_corec f g $== f
      napply cat_binprod_beta_pr1.
  Defined.

  Definition cat_binprod_swap_nat {a b c d : A} (f : a $-> c) (g : b $-> d)
    : cat_binprod_swap c d $o fmap11 (fun x y : A => cat_binprod x y) f g
    $== fmap11 (fun x y : A => cat_binprod x y) g f $o cat_binprod_swap a b
    := cat_binprod_swap_corec _ _ $@ (cat_binprod_fmap11_corec _ _ _ _)^$.

  Local Instance symmetricbraiding_binprod
    : SymmetricBraiding (fun x y => cat_binprod x y).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
SymmetricBraiding (fun x y : A => cat_binprod x y)
  Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
SymmetricBraiding (fun x y : A => cat_binprod x y)
    snapply Build_SymmetricBraiding.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
Braiding (fun x y : A => cat_binprod x y)
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
forall a b : A,
?braiding_symmetricbraiding a b $o
?braiding_symmetricbraiding b a $==
Id ((fun x y : A => cat_binprod x y) b a)
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
Braiding (fun x y : A => cat_binprod x y) snapply Build_NatTrans.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
uncurry (fun x y : A => cat_binprod x y) $=>
uncurry (flip (fun x y : A => cat_binprod x y))
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
Is1Natural (uncurry (fun x y : A => cat_binprod x y))
  (uncurry (flip (fun x y : A => cat_binprod x y)))
  ?alpha
      +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
uncurry (fun x y : A => cat_binprod x y) $=>
uncurry (flip (fun x y : A => cat_binprod x y)) intros [x y].A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y: A
uncurry (fun x y : A => cat_binprod x y) (x, y) $->
uncurry (flip (fun x y : A => cat_binprod x y)) (x, y)
        exact (cat_binprod_swap x y).
      +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
Is1Natural (uncurry (fun x y : A => cat_binprod x y))
  (uncurry (flip (fun x y : A => cat_binprod x y)))
  ((fun a : A * A =>
    (fun x y : A => cat_binprod_swap x y) (fst a)
      (snd a))
   :
   uncurry (fun x y : A => cat_binprod x y) $=>
   uncurry (flip (fun x y : A => cat_binprod x y))) snapply Build_Is1Natural.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
forall (a a' : A * A) (f : a $-> a'),
(fun a0 : A * A =>
 (fun x y : A => cat_binprod_swap x y) (fst a0)
   (snd a0)) a' $o
fmap (uncurry (fun x y : A => cat_binprod x y)) f $==
fmap (uncurry (flip (fun x y : A => cat_binprod x y)))
  f $o
(fun a0 : A * A =>
 (fun x y : A => cat_binprod_swap x y) (fst a0)
   (snd a0)) a
        intros [a b] [c d] [f g]; cbn in f, g.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, b, c, d: A
f: a $-> c
g: b $-> d
cat_binprod_swap c d $o
fmap (uncurry (fun x y : A => cat_binprod x y)) (f, g) $==
fmap (uncurry (flip (fun x y : A => cat_binprod x y)))
  (f, g) $o cat_binprod_swap a b
        exact(cat_binprod_swap_nat f g).
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
forall a b : A,
{|
  trans_nattrans :=
    (fun a0 : A * A =>
     (fun x y : A => cat_binprod_swap x y) (fst a0)
       (snd a0))
    :
    uncurry (fun x y : A => cat_binprod x y) $=>
    uncurry (flip (fun x y : A => cat_binprod x y));
  is1natural_nattrans :=
    Build_Is1Natural
      (fun a0 : A * A =>
       (fun x y : A => cat_binprod_swap x y) (fst a0)
         (snd a0))
      (fun a0 : A * A =>
       (fun (a1 b0 : A) (a' : A * A) =>
        (fun (c d : A) (f0 : (a1, b0) $-> (c, d)) =>
         (fun (f : fst (a1, b0) $-> fst (c, d))
            (g : snd (a1, b0) $-> snd (c, d)) =>
          cat_binprod_swap_nat f g) (fst f0) (snd f0))
          (fst a') (snd a')) (fst a0) (snd a0))
|} a b $o
{|
  trans_nattrans :=
    (fun a0 : A * A =>
     (fun x y : A => cat_binprod_swap x y) (fst a0)
       (snd a0))
    :
    uncurry (fun x y : A => cat_binprod x y) $=>
    uncurry (flip (fun x y : A => cat_binprod x y));
  is1natural_nattrans :=
    Build_Is1Natural
      (fun a0 : A * A =>
       (fun x y : A => cat_binprod_swap x y) (fst a0)
         (snd a0))
      (fun a0 : A * A =>
       (fun (a1 b0 : A) (a' : A * A) =>
        (fun (c d : A) (f0 : (a1, b0) $-> (c, d)) =>
         (fun (f : fst (a1, b0) $-> fst (c, d))
            (g : snd (a1, b0) $-> snd (c, d)) =>
          cat_binprod_swap_nat f g) (fst f0) (snd f0))
          (fst a') (snd a')) (fst a0) (snd a0))
|} b a $== Id ((fun x y : A => cat_binprod x y) b a) exact cat_binprod_swap_cat_binprod_swap.
  Defined.

End Symmetry.

(** *** Associativity of binary products *)

Section Associativity.

  Context {A : Type} `{HasEquivs A} `{!HasBinaryProducts A}.

  Definition cat_binprod_twist (x y z : A)
    : cat_binprod x (cat_binprod y z) $-> cat_binprod y (cat_binprod x z).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_binprod x (cat_binprod y z) $->
cat_binprod y (cat_binprod x z)
  Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_binprod x (cat_binprod y z) $->
cat_binprod y (cat_binprod x z)
    napply cat_binprod_corec.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_binprod x (cat_binprod y z) $-> y
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_binprod x (cat_binprod y z) $-> cat_binprod x z
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_binprod x (cat_binprod y z) $-> y exact (cat_pr1 $o cat_pr2).
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_binprod x (cat_binprod y z) $-> cat_binprod x z exact (fmap01 cat_binprod x cat_pr2).
  Defined.

  Definition cat_binprod_pr1_twist (x y z : A)
    : cat_pr1 $o cat_binprod_twist x y z $== cat_pr1 $o cat_pr2
    := cat_binprod_beta_pr1 _ _.

  Definition cat_binprod_pr1_pr2_twist (x y z : A)
    : cat_pr1 $o cat_pr2 $o cat_binprod_twist x y z $== cat_pr1.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr1 $o cat_pr2 $o cat_binprod_twist x y z $==
cat_pr1
  Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr1 $o cat_pr2 $o cat_binprod_twist x y z $==
cat_pr1
    nrefine (cat_assoc _ _ _ $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr1 $o (cat_pr2 $o cat_binprod_twist x y z) $==
cat_pr1
    nrefine ((_ $@L cat_binprod_beta_pr2 _ _) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr1 $o fmap01 cat_binprod x cat_pr2 $== cat_pr1
    napply cat_pr1_fmap01_binprod.
  Defined.

  Definition cat_binprod_pr2_pr2_twist (x y z : A)
    : cat_pr2 $o cat_pr2 $o cat_binprod_twist x y z $== cat_pr2 $o cat_pr2.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr2 $o cat_pr2 $o cat_binprod_twist x y z $==
cat_pr2 $o cat_pr2
  Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr2 $o cat_pr2 $o cat_binprod_twist x y z $==
cat_pr2 $o cat_pr2
    nrefine (cat_assoc _ _ _ $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr2 $o (cat_pr2 $o cat_binprod_twist x y z) $==
cat_pr2 $o cat_pr2
    nrefine ((_ $@L cat_binprod_beta_pr2 _ _) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr2 $o fmap01 cat_binprod x cat_pr2 $==
cat_pr2 $o cat_pr2
    napply cat_pr2_fmap01_binprod.
  Defined.

  Definition cat_binprod_twist_corec {w x y z : A}
    (f : w $-> x) (g : w $-> y) (h : w $-> z)
    : cat_binprod_twist x y z $o cat_binprod_corec f (cat_binprod_corec g h)
      $== cat_binprod_corec g (cat_binprod_corec f h).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
cat_binprod_twist x y z $o
cat_binprod_corec f (cat_binprod_corec g h) $==
cat_binprod_corec g (cat_binprod_corec f h)
  Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
cat_binprod_twist x y z $o
cat_binprod_corec f (cat_binprod_corec g h) $==
cat_binprod_corec g (cat_binprod_corec f h)
    napply cat_binprod_eta_pr.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
cat_pr1 $o
(cat_binprod_twist x y z $o
 cat_binprod_corec f (cat_binprod_corec g h)) $==
cat_pr1 $o cat_binprod_corec g (cat_binprod_corec f h)
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
cat_pr2 $o
(cat_binprod_twist x y z $o
 cat_binprod_corec f (cat_binprod_corec g h)) $==
cat_pr2 $o cat_binprod_corec g (cat_binprod_corec f h)
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
cat_pr1 $o
(cat_binprod_twist x y z $o
 cat_binprod_corec f (cat_binprod_corec g h)) $==
cat_pr1 $o cat_binprod_corec g (cat_binprod_corec f h) nrefine (cat_assoc_opp _ _ _ $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
cat_pr1 $o cat_binprod_twist x y z $o
cat_binprod_corec f (cat_binprod_corec g h) $==
cat_pr1 $o cat_binprod_corec g (cat_binprod_corec f h)
      refine ((_ $@R _) $@ cat_assoc _ _ _ $@ (_ $@L _) $@ (_ $@ _^$)).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
cat_pr1 $o cat_binprod_twist x y z $==
?Goal3 $o ?Goal2
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
?Goal2 $o cat_binprod_corec f (cat_binprod_corec g h) $==
?Goal4
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
?Goal3 $o ?Goal4 $== ?Goal6
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
cat_pr1 $o cat_binprod_corec g (cat_binprod_corec f h) $->
?Goal6
      1: napply cat_binprod_pr1_twist.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
cat_pr2 $o cat_binprod_corec f (cat_binprod_corec g h) $==
?Goal0
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
cat_pr1 $o ?Goal0 $== ?Goal2
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
cat_pr1 $o cat_binprod_corec g (cat_binprod_corec f h) $->
?Goal2
      1: napply cat_binprod_beta_pr2.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
cat_pr1 $o cat_binprod_corec g h $== ?Goal0
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
cat_pr1 $o cat_binprod_corec g (cat_binprod_corec f h) $->
?Goal0
      1,2: napply cat_binprod_beta_pr1.
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
cat_pr2 $o
(cat_binprod_twist x y z $o
 cat_binprod_corec f (cat_binprod_corec g h)) $==
cat_pr2 $o cat_binprod_corec g (cat_binprod_corec f h) refine (cat_assoc_opp _ _ _ $@ (_ $@R _) $@ _ $@ (cat_binprod_beta_pr2 _ _)^$).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
cat_pr2 $o cat_binprod_twist x y z $== ?Goal
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
?Goal $o cat_binprod_corec f (cat_binprod_corec g h) $==
cat_binprod_corec f h
      1: napply cat_binprod_beta_pr2.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
fmap01 cat_binprod x cat_pr2 $o
cat_binprod_corec f (cat_binprod_corec g h) $==
cat_binprod_corec f h
      nrefine (cat_binprod_fmap01_corec _ _ _ $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
cat_binprod_corec f (cat_pr2 $o cat_binprod_corec g h) $==
cat_binprod_corec f h
      napply cat_binprod_corec_eta.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
f $== f
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
cat_pr2 $o cat_binprod_corec g h $== h
      1: exact (Id _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
cat_pr2 $o cat_binprod_corec g h $== h
      napply cat_binprod_beta_pr2.
  Defined.

  Lemma cat_binprod_twist_cat_binprod_twist (x y z : A)
    : cat_binprod_twist x y z $o cat_binprod_twist y x z $== Id _.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_binprod_twist x y z $o cat_binprod_twist y x z $==
Id (cat_binprod y (cat_binprod x z))
  Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_binprod_twist x y z $o cat_binprod_twist y x z $==
Id (cat_binprod y (cat_binprod x z))
    napply cat_binprod_eta_pr_x_xx_id.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr1 $o
(cat_binprod_twist x y z $o cat_binprod_twist y x z) $==
cat_pr1
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr1 $o cat_pr2 $o
(cat_binprod_twist x y z $o cat_binprod_twist y x z) $==
cat_pr1 $o cat_pr2
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr2 $o cat_pr2 $o
(cat_binprod_twist x y z $o cat_binprod_twist y x z) $==
cat_pr2 $o cat_pr2
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr1 $o
(cat_binprod_twist x y z $o cat_binprod_twist y x z) $==
cat_pr1 nrefine (cat_assoc_opp _ _ _ $@ (cat_binprod_pr1_twist _ _ _ $@R _) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr1 $o cat_pr2 $o cat_binprod_twist y x z $==
cat_pr1
      napply cat_binprod_pr1_pr2_twist.
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr1 $o cat_pr2 $o
(cat_binprod_twist x y z $o cat_binprod_twist y x z) $==
cat_pr1 $o cat_pr2 nrefine (cat_assoc_opp _ _ _ $@ (cat_binprod_pr1_pr2_twist _ _ _ $@R _) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr1 $o cat_binprod_twist y x z $==
cat_pr1 $o cat_pr2
      napply cat_binprod_pr1_twist.
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr2 $o cat_pr2 $o
(cat_binprod_twist x y z $o cat_binprod_twist y x z) $==
cat_pr2 $o cat_pr2 nrefine (cat_assoc_opp _ _ _ $@ (cat_binprod_pr2_pr2_twist _ _ _ $@R _) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr2 $o cat_pr2 $o cat_binprod_twist y x z $==
cat_pr2 $o cat_pr2
      napply cat_binprod_pr2_pr2_twist.
  Defined.

  Definition cate_binprod_twist (x y z : A)
    : cat_binprod x (cat_binprod y z) $<~> cat_binprod y (cat_binprod x z).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_binprod x (cat_binprod y z) $<~>
cat_binprod y (cat_binprod x z)
  Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_binprod x (cat_binprod y z) $<~>
cat_binprod y (cat_binprod x z)
    snapply cate_adjointify.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_binprod x (cat_binprod y z) $->
cat_binprod y (cat_binprod x z)
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_binprod y (cat_binprod x z) $->
cat_binprod x (cat_binprod y z)
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
?f $o ?g $== Id (cat_binprod y (cat_binprod x z))
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
?g $o ?f $== Id (cat_binprod x (cat_binprod y z))
    1,2: napply cat_binprod_twist.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_binprod_twist x y z $o cat_binprod_twist y x z $==
Id (cat_binprod y (cat_binprod x z))
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_binprod_twist y x z $o cat_binprod_twist x y z $==
Id (cat_binprod x (cat_binprod y z))
    1,2: napply cat_binprod_twist_cat_binprod_twist.
  Defined.

  Definition cat_binprod_twist_nat {a a' b b' c c' : A}
    (f : a $-> a') (g : b $-> b') (h : c $-> c')
    : cat_binprod_twist a' b' c'
        $o fmap11 cat_binprod f (fmap11 cat_binprod g h)
      $== fmap11 cat_binprod g (fmap11 cat_binprod f h)
        $o cat_binprod_twist a b c.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
cat_binprod_twist a' b' c' $o
fmap11 cat_binprod f (fmap11 cat_binprod g h) $==
fmap11 cat_binprod g (fmap11 cat_binprod f h) $o
cat_binprod_twist a b c
  Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
cat_binprod_twist a' b' c' $o
fmap11 cat_binprod f (fmap11 cat_binprod g h) $==
fmap11 cat_binprod g (fmap11 cat_binprod f h) $o
cat_binprod_twist a b c
    napply cat_binprod_eta_pr.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
cat_pr1 $o
(cat_binprod_twist a' b' c' $o
 fmap11 cat_binprod f (fmap11 cat_binprod g h)) $==
cat_pr1 $o
(fmap11 cat_binprod g (fmap11 cat_binprod f h) $o
 cat_binprod_twist a b c)
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
cat_pr2 $o
(cat_binprod_twist a' b' c' $o
 fmap11 cat_binprod f (fmap11 cat_binprod g h)) $==
cat_pr2 $o
(fmap11 cat_binprod g (fmap11 cat_binprod f h) $o
 cat_binprod_twist a b c)
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
cat_pr1 $o
(cat_binprod_twist a' b' c' $o
 fmap11 cat_binprod f (fmap11 cat_binprod g h)) $==
cat_pr1 $o
(fmap11 cat_binprod g (fmap11 cat_binprod f h) $o
 cat_binprod_twist a b c) refine (cat_assoc_opp _ _ _ $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
cat_pr1 $o cat_binprod_twist a' b' c' $o
fmap11 cat_binprod f (fmap11 cat_binprod g h) $==
cat_pr1 $o
(fmap11 cat_binprod g (fmap11 cat_binprod f h) $o
 cat_binprod_twist a b c)
      nrefine ((cat_binprod_beta_pr1 _ _ $@R _) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
cat_pr1 $o cat_pr2 $o
fmap11 cat_binprod f (fmap11 cat_binprod g h) $==
cat_pr1 $o
(fmap11 cat_binprod g (fmap11 cat_binprod f h) $o
 cat_binprod_twist a b c)
      nrefine (cat_assoc _ _ _ $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
cat_pr1 $o
(cat_pr2 $o
 fmap11 cat_binprod f (fmap11 cat_binprod g h)) $==
cat_pr1 $o
(fmap11 cat_binprod g (fmap11 cat_binprod f h) $o
 cat_binprod_twist a b c)
      nrefine ((_ $@L _) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
cat_pr2 $o
fmap11 cat_binprod f (fmap11 cat_binprod g h) $==
?Goal0
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
cat_pr1 $o ?Goal0 $==
cat_pr1 $o
(fmap11 cat_binprod g (fmap11 cat_binprod f h) $o
 cat_binprod_twist a b c)
      1: napply cat_pr2_fmap11_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
cat_pr1 $o (fmap11 cat_binprod g h $o cat_pr2) $==
cat_pr1 $o
(fmap11 cat_binprod g (fmap11 cat_binprod f h) $o
 cat_binprod_twist a b c)
      nrefine (cat_assoc_opp _ _ _ $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
cat_pr1 $o fmap11 cat_binprod g h $o cat_pr2 $==
cat_pr1 $o
(fmap11 cat_binprod g (fmap11 cat_binprod f h) $o
 cat_binprod_twist a b c)
      nrefine ((_ $@R _) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
cat_pr1 $o fmap11 cat_binprod g h $== ?Goal0
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
?Goal0 $o cat_pr2 $==
cat_pr1 $o
(fmap11 cat_binprod g (fmap11 cat_binprod f h) $o
 cat_binprod_twist a b c)
      1: napply cat_pr1_fmap11_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
g $o cat_pr1 $o cat_pr2 $==
cat_pr1 $o
(fmap11 cat_binprod g (fmap11 cat_binprod f h) $o
 cat_binprod_twist a b c)
      nrefine (_ $@ cat_assoc _ _ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
g $o cat_pr1 $o cat_pr2 $==
cat_pr1 $o
fmap11 cat_binprod g (fmap11 cat_binprod f h) $o
cat_binprod_twist a b c
      refine (_ $@ (_^$ $@R _)).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
g $o cat_pr1 $o cat_pr2 $==
?Goal1 $o cat_binprod_twist a b c
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
cat_pr1 $o
fmap11 cat_binprod g (fmap11 cat_binprod f h) $->
?Goal1
      2: napply cat_pr1_fmap11_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
g $o cat_pr1 $o cat_pr2 $==
g $o cat_pr1 $o cat_binprod_twist a b c
      refine (cat_assoc _ _ _ $@ (_ $@L _^$) $@ (cat_assoc _ _ _)^$).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
cat_pr1 $o cat_binprod_twist a b c $->
cat_pr1 $o cat_pr2
      napply cat_binprod_beta_pr1.
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
cat_pr2 $o
(cat_binprod_twist a' b' c' $o
 fmap11 cat_binprod f (fmap11 cat_binprod g h)) $==
cat_pr2 $o
(fmap11 cat_binprod g (fmap11 cat_binprod f h) $o
 cat_binprod_twist a b c) nrefine (cat_assoc_opp _ _ _ $@ (cat_binprod_beta_pr2 _ _ $@R _) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
fmap01 cat_binprod a' cat_pr2 $o
fmap11 cat_binprod f (fmap11 cat_binprod g h) $==
cat_pr2 $o
(fmap11 cat_binprod g (fmap11 cat_binprod f h) $o
 cat_binprod_twist a b c)
      nrefine (_ $@ cat_assoc _ _ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
fmap01 cat_binprod a' cat_pr2 $o
fmap11 cat_binprod f (fmap11 cat_binprod g h) $==
cat_pr2 $o
fmap11 cat_binprod g (fmap11 cat_binprod f h) $o
cat_binprod_twist a b c
      refine (_ $@ (_^$ $@R _)).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
fmap01 cat_binprod a' cat_pr2 $o
fmap11 cat_binprod f (fmap11 cat_binprod g h) $==
?Goal0 $o cat_binprod_twist a b c
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
cat_pr2 $o
fmap11 cat_binprod g (fmap11 cat_binprod f h) $->
?Goal0
      2: napply cat_pr2_fmap11_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
fmap01 cat_binprod a' cat_pr2 $o
fmap11 cat_binprod f (fmap11 cat_binprod g h) $==
fmap11 cat_binprod f h $o cat_pr2 $o
cat_binprod_twist a b c
      refine (_ $@ (_ $@L _^$) $@ (cat_assoc _ _ _)^$).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
fmap01 cat_binprod a' cat_pr2 $o
fmap11 cat_binprod f (fmap11 cat_binprod g h) $==
fmap11 cat_binprod f h $o ?Goal0
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
cat_pr2 $o cat_binprod_twist a b c $-> ?Goal0
      2: napply cat_binprod_beta_pr2.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
fmap01 cat_binprod a' cat_pr2 $o
fmap11 cat_binprod f (fmap11 cat_binprod g h) $==
fmap11 cat_binprod f h $o fmap01 cat_binprod a cat_pr2
      refine (_^$ $@ _ $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
?Goal0 $->
fmap01 cat_binprod a' cat_pr2 $o
fmap11 cat_binprod f (fmap11 cat_binprod g h)
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
?Goal0 $== ?Goal
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
?Goal $==
fmap11 cat_binprod f h $o fmap01 cat_binprod a cat_pr2
      1,3: tapply fmap11_comp.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
fmap11 (fun x y : A => cat_binprod x y)
  (fmap (uncurry (Bool_rec A))
     (fmap (fun b : A => (a', b)) cat_pr2) true $o f)
  (fmap (uncurry (Bool_rec A))
     (fmap (fun b : A => (a', b)) cat_pr2) false $o
   fmap11 cat_binprod g h) $==
fmap11 cat_binprod
  (f $o
   fmap (uncurry (Bool_rec A))
     (fmap (fun b : A => (a, b)) cat_pr2) true)
  (h $o
   fmap (uncurry (Bool_rec A))
     (fmap (fun b : A => (a, b)) cat_pr2) false)
      rapply fmap22.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
fmap (uncurry (Bool_rec A))
  (fmap (fun b : A => (a', b)) cat_pr2) true $o f $==
f $o
fmap (uncurry (Bool_rec A))
  (fmap (fun b : A => (a, b)) cat_pr2) true
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
fmap (uncurry (Bool_rec A))
  (fmap (fun b : A => (a', b)) cat_pr2) false $o
fmap11 cat_binprod g h $==
h $o
fmap (uncurry (Bool_rec A))
  (fmap (fun b : A => (a, b)) cat_pr2) false
      1: exact (cat_idl _ $@ (cat_idr _)^$).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
fmap (uncurry (Bool_rec A))
  (fmap (fun b : A => (a', b)) cat_pr2) false $o
fmap11 cat_binprod g h $==
h $o
fmap (uncurry (Bool_rec A))
  (fmap (fun b : A => (a, b)) cat_pr2) false
      napply cat_binprod_beta_pr2.
  Defined.

  Local Existing Instance symmetricbraiding_binprod.

  Local Instance associator_cat_binprod : Associator cat_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
Associator cat_binprod
  Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
Associator cat_binprod
    snapply associator_twist.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
SymmetricBraiding cat_binprod
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
forall a b c : A,
cat_binprod a (cat_binprod b c) $->
cat_binprod b (cat_binprod a c)
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
forall a b c : A,
?twist a b c $o ?twist b a c $==
Id (cat_binprod b (cat_binprod a c))
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
forall (a a' b b' c c' : A) 
(f : a $-> a') (g : b $-> b') 
(h : c $-> c'),
?twist a' b' c' $o
fmap11 cat_binprod f (fmap11 cat_binprod g h) $==
fmap11 cat_binprod g (fmap11 cat_binprod f h) $o
?twist a b c
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
SymmetricBraiding cat_binprod exact _.
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
forall a b c : A,
cat_binprod a (cat_binprod b c) $->
cat_binprod b (cat_binprod a c) exact cat_binprod_twist.
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
forall a b c : A,
cat_binprod_twist a b c $o cat_binprod_twist b a c $==
Id (cat_binprod b (cat_binprod a c)) exact cat_binprod_twist_cat_binprod_twist.
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
forall (a a' b b' c c' : A) (f : a $-> a')
(g : b $-> b') (h : c $-> c'),
cat_binprod_twist a' b' c' $o
fmap11 cat_binprod f (fmap11 cat_binprod g h) $==
fmap11 cat_binprod g (fmap11 cat_binprod f h) $o
cat_binprod_twist a b c intros ? ? ? ? ? ?; exact cat_binprod_twist_nat.
  Defined.

  Definition cat_pr1_pr1_associator_binprod x y z
    : cat_pr1 $o cat_pr1 $o associator_cat_binprod x y z $== cat_pr1.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr1 $o cat_pr1 $o associator_cat_binprod x y z $==
cat_pr1
  Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr1 $o cat_pr1 $o associator_cat_binprod x y z $==
cat_pr1
    nrefine ((_ $@L associator_twist'_unfold _ _ _ _ _ _ _ _) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr1 $o cat_pr1 $o
(symmetricbraiding_binprod z (cat_binprod x y) $o
 (cat_binprod_twist x z y $o
  fmap01 cat_binprod x (symmetricbraiding_binprod y z))) $==
cat_pr1
    nrefine (cat_assoc _ _ _ $@ (_ $@L (cat_assoc_opp _ _ _ $@ (_ $@R _))) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr1 $o
symmetricbraiding_binprod z (cat_binprod x y) $==
?Goal
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr1 $o
(?Goal $o
 (cat_binprod_twist x z y $o
  fmap01 cat_binprod x (symmetricbraiding_binprod y z))) $==
cat_pr1
    1: napply cat_binprod_beta_pr1.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr1 $o
(cat_pr2 $o
 (cat_binprod_twist x z y $o
  fmap01 cat_binprod x (symmetricbraiding_binprod y z))) $==
cat_pr1
    do 2 nrefine (cat_assoc_opp _ _ _ $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr1 $o cat_pr2 $o cat_binprod_twist x z y $o
fmap01 cat_binprod x (symmetricbraiding_binprod y z) $==
cat_pr1
    nrefine ((cat_binprod_pr1_pr2_twist _ _ _ $@R _) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr1 $o
fmap01 cat_binprod x (symmetricbraiding_binprod y z) $==
cat_pr1
    napply cat_pr1_fmap01_binprod.
  Defined.

  Definition cat_pr2_pr1_associator_binprod x y z
    : cat_pr2 $o cat_pr1 $o associator_cat_binprod x y z $== cat_pr1 $o cat_pr2.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr2 $o cat_pr1 $o associator_cat_binprod x y z $==
cat_pr1 $o cat_pr2
  Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr2 $o cat_pr1 $o associator_cat_binprod x y z $==
cat_pr1 $o cat_pr2
    nrefine ((_ $@L associator_twist'_unfold _ _ _ _ _ _ _ _) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr2 $o cat_pr1 $o
(symmetricbraiding_binprod z (cat_binprod x y) $o
 (cat_binprod_twist x z y $o
  fmap01 cat_binprod x (symmetricbraiding_binprod y z))) $==
cat_pr1 $o cat_pr2
    nrefine (cat_assoc _ _ _ $@ (_ $@L (cat_assoc_opp _ _ _ $@ (_ $@R _))) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr1 $o
symmetricbraiding_binprod z (cat_binprod x y) $==
?Goal
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr2 $o
(?Goal $o
 (cat_binprod_twist x z y $o
  fmap01 cat_binprod x (symmetricbraiding_binprod y z))) $==
cat_pr1 $o cat_pr2
    1: napply cat_binprod_beta_pr1.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr2 $o
(cat_pr2 $o
 (cat_binprod_twist x z y $o
  fmap01 cat_binprod x (symmetricbraiding_binprod y z))) $==
cat_pr1 $o cat_pr2
    do 2 nrefine (cat_assoc_opp _ _ _ $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr2 $o cat_pr2 $o cat_binprod_twist x z y $o
fmap01 cat_binprod x (symmetricbraiding_binprod y z) $==
cat_pr1 $o cat_pr2
    nrefine ((cat_binprod_pr2_pr2_twist _ _ _ $@R _) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr2 $o cat_pr2 $o
fmap01 cat_binprod x (symmetricbraiding_binprod y z) $==
cat_pr1 $o cat_pr2
    nrefine (cat_assoc _ _ _ $@ (_ $@L cat_pr2_fmap01_binprod _ _) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr2 $o (symmetricbraiding_binprod y z $o cat_pr2) $==
cat_pr1 $o cat_pr2
    exact (cat_assoc_opp _ _ _ $@ (cat_binprod_beta_pr2 _ _ $@R _)).
  Defined.

  Definition cat_pr2_associator_binprod x y z
    : cat_pr2 $o associator_cat_binprod x y z $== cat_pr2 $o cat_pr2.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr2 $o associator_cat_binprod x y z $==
cat_pr2 $o cat_pr2
  Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr2 $o associator_cat_binprod x y z $==
cat_pr2 $o cat_pr2
    nrefine ((_ $@L associator_twist'_unfold _ _ _ _ _ _ _ _) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr2 $o
(symmetricbraiding_binprod z (cat_binprod x y) $o
 (cat_binprod_twist x z y $o
  fmap01 cat_binprod x (symmetricbraiding_binprod y z))) $==
cat_pr2 $o cat_pr2
    nrefine (cat_assoc_opp _ _ _ $@ (cat_binprod_beta_pr2 _ _ $@R _) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr1 $o
(cat_binprod_twist x z y $o
 fmap01 cat_binprod x (symmetricbraiding_binprod y z)) $==
cat_pr2 $o cat_pr2
    nrefine (cat_assoc_opp _ _ _ $@ (cat_binprod_pr1_twist _ _ _ $@R _) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr1 $o cat_pr2 $o
fmap01 cat_binprod x (symmetricbraiding_binprod y z) $==
cat_pr2 $o cat_pr2
    nrefine (cat_assoc _ _ _ $@ (_ $@L cat_pr2_fmap01_binprod _ _) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_pr1 $o (symmetricbraiding_binprod y z $o cat_pr2) $==
cat_pr2 $o cat_pr2
    exact (cat_assoc_opp _ _ _ $@ (cat_binprod_beta_pr1 _ _ $@R _)).
  Defined.

  Definition cat_binprod_associator_corec {w x y z}
    (f : w $-> x) (g : w $-> y) (h : w $-> z)
    : associator_cat_binprod x y z $o cat_binprod_corec f (cat_binprod_corec g h)
      $== cat_binprod_corec (cat_binprod_corec f g) h.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
associator_cat_binprod x y z $o
cat_binprod_corec f (cat_binprod_corec g h) $==
cat_binprod_corec (cat_binprod_corec f g) h 
  Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
associator_cat_binprod x y z $o
cat_binprod_corec f (cat_binprod_corec g h) $==
cat_binprod_corec (cat_binprod_corec f g) h
    nrefine ((associator_twist'_unfold _ _ _ _ _ _ _ _ $@R _) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
symmetricbraiding_binprod z (cat_binprod x y) $o
(cat_binprod_twist x z y $o
 fmap01 cat_binprod x (symmetricbraiding_binprod y z)) $o
cat_binprod_corec f (cat_binprod_corec g h) $==
cat_binprod_corec (cat_binprod_corec f g) h
    nrefine ((cat_assoc_opp _ _ _ $@R _) $@ cat_assoc _ _ _ $@ (_ $@L (_ $@ _)) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
fmap01 cat_binprod x (symmetricbraiding_binprod y z) $o
cat_binprod_corec f (cat_binprod_corec g h) $== ?Goal0
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
?Goal0 $== ?Goal
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
symmetricbraiding_binprod z (cat_binprod x y) $o
cat_binprod_twist x z y $o 
?Goal $== cat_binprod_corec (cat_binprod_corec f g) h 
    1: napply cat_binprod_fmap01_corec.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
cat_binprod_corec f
  (symmetricbraiding_binprod y z $o
   cat_binprod_corec g h) $== ?Goal
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
symmetricbraiding_binprod z (cat_binprod x y) $o
cat_binprod_twist x z y $o 
?Goal $== cat_binprod_corec (cat_binprod_corec f g) h
    1: rapply (cat_binprod_corec_eta _ _ _ _ (Id _)).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
symmetricbraiding_binprod y z $o cat_binprod_corec g h $==
?Goal0
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
symmetricbraiding_binprod z (cat_binprod x y) $o
cat_binprod_twist x z y $o 
cat_binprod_corec f ?Goal0 $==
cat_binprod_corec (cat_binprod_corec f g) h
    1: napply cat_binprod_swap_corec.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
symmetricbraiding_binprod z (cat_binprod x y) $o
cat_binprod_twist x z y $o
cat_binprod_corec f (cat_binprod_corec h g) $==
cat_binprod_corec (cat_binprod_corec f g) h
    nrefine (cat_assoc _ _ _ $@ (_ $@L _) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
cat_binprod_twist x z y $o
cat_binprod_corec f (cat_binprod_corec h g) $== ?Goal
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
symmetricbraiding_binprod z (cat_binprod x y) $o ?Goal $==
cat_binprod_corec (cat_binprod_corec f g) h
    1: napply cat_binprod_twist_corec.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
w, x, y, z: A
f: w $-> x
g: w $-> y
h: w $-> z
symmetricbraiding_binprod z (cat_binprod x y) $o
cat_binprod_corec h (cat_binprod_corec f g) $==
cat_binprod_corec (cat_binprod_corec f g) h
    napply cat_binprod_swap_corec.
  Defined.

  Context (unit : A) `{!IsTerminal unit}.

  Local Instance right_unitor_binprod
    : RightUnitor (fun x y => cat_binprod x y) unit.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
RightUnitor (fun x y : A => cat_binprod x y) unit
  Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
RightUnitor (fun x y : A => cat_binprod x y) unit
    snapply Build_NatEquiv.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
forall a : A,
flip (fun x y : A => cat_binprod x y) unit a $<~>
idmap a
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
Is1Natural
  (flip (fun x y : A => cat_binprod x y) unit) idmap
  (fun a : A => ?e a)
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
forall a : A,
flip (fun x y : A => cat_binprod x y) unit a $<~>
idmap a intros a; unfold flip.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a: A
cat_binprod a unit $<~> a
      snapply cate_adjointify.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a: A
cat_binprod a unit $-> a
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a: A
a $-> cat_binprod a unit
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a: A
?f $o ?g $== Id a
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a: A
?g $o ?f $== Id (cat_binprod a unit)
      +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a: A
cat_binprod a unit $-> a exact cat_pr1.
      +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a: A
a $-> cat_binprod a unit exact (cat_binprod_corec (Id _) (mor_terminal _ _)).
      +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a: A
cat_pr1 $o
cat_binprod_corec (Id a) (mor_terminal a unit) $==
Id a exact (cat_binprod_beta_pr1 _ _).
      +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a: A
cat_binprod_corec (Id a) (mor_terminal a unit) $o
cat_pr1 $== Id (cat_binprod a unit) napply cat_binprod_eta_pr.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a: A
cat_pr1 $o
(cat_binprod_corec (Id a) (mor_terminal a unit) $o
 cat_pr1) $== cat_pr1 $o Id (cat_binprod a unit)
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a: A
cat_pr2 $o
(cat_binprod_corec (Id a) (mor_terminal a unit) $o
 cat_pr1) $== cat_pr2 $o Id (cat_binprod a unit)
        *A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a: A
cat_pr1 $o
(cat_binprod_corec (Id a) (mor_terminal a unit) $o
 cat_pr1) $== cat_pr1 $o Id (cat_binprod a unit) nrefine (cat_assoc_opp _ _ _ $@ (cat_binprod_beta_pr1 _ _ $@R _) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a: A
Id a $o cat_pr1 $== cat_pr1 $o Id (cat_binprod a unit)
          exact (cat_idl _ $@ (cat_idr _)^$).
        *A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a: A
cat_pr2 $o
(cat_binprod_corec (Id a) (mor_terminal a unit) $o
 cat_pr1) $== cat_pr2 $o Id (cat_binprod a unit) nrefine (cat_assoc_opp _ _ _ $@ (cat_binprod_beta_pr2 _ _ $@R _) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a: A
mor_terminal a unit $o cat_pr1 $==
cat_pr2 $o Id (cat_binprod a unit)
          exact ((mor_terminal_unique _ _ _)^$ $@ mor_terminal_unique _ _ _).
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
Is1Natural
  (flip (fun x y : A => cat_binprod x y) unit) idmap
  (fun a : A =>
   (fun a0 : A =>
    cate_adjointify cat_pr1
      (cat_binprod_corec (Id a0)
         (mor_terminal a0 unit))
      (cat_binprod_beta_pr1 (Id a0)
         (mor_terminal a0 unit))
      (cat_binprod_eta_pr
         (cat_binprod_corec (Id a0)
            (mor_terminal a0 unit) $o cat_pr1)
         (Id (cat_binprod a0 unit))
         ((cat_assoc_opp cat_pr1
             (cat_binprod_corec (Id a0)
                (mor_terminal a0 unit)) cat_pr1 $@
           (cat_binprod_beta_pr1 (Id a0)
              (mor_terminal a0 unit) $@R cat_pr1)) $@
          (cat_idl cat_pr1 $@ (cat_idr cat_pr1)^$))
         ((cat_assoc_opp cat_pr1
             (cat_binprod_corec (Id a0)
                (mor_terminal a0 unit)) cat_pr2 $@
           (cat_binprod_beta_pr2 (Id a0)
              (mor_terminal a0 unit) $@R cat_pr1)) $@
          ((mor_terminal_unique (cat_binprod a0 unit)
              unit (mor_terminal a0 unit $o cat_pr1))^$ $@
           mor_terminal_unique (cat_binprod a0 unit)
             unit
             (cat_pr2 $o Id (cat_binprod a0 unit)))))
    :
    flip (fun x y : A => cat_binprod x y) unit a0 $<~>
    idmap a0) a) snapply Build_Is1Natural.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
forall (a a' : A) (f : a $-> a'),
(fun a0 : A =>
 cate_fun
   ((fun a1 : A =>
     cate_adjointify cat_pr1
       (cat_binprod_corec (Id a1)
          (mor_terminal a1 unit))
       (cat_binprod_beta_pr1 (Id a1)
          (mor_terminal a1 unit))
       (cat_binprod_eta_pr
          (cat_binprod_corec (Id a1)
             (mor_terminal a1 unit) $o cat_pr1)
          (Id (cat_binprod a1 unit))
          ((cat_assoc_opp cat_pr1
              (cat_binprod_corec (Id a1)
                 (mor_terminal a1 unit)) cat_pr1 $@
            (cat_binprod_beta_pr1 (Id a1)
               (mor_terminal a1 unit) $@R cat_pr1)) $@
           (cat_idl cat_pr1 $@ (cat_idr cat_pr1)^$))
          ((cat_assoc_opp cat_pr1
              (cat_binprod_corec (Id a1)
                 (mor_terminal a1 unit)) cat_pr2 $@
            (cat_binprod_beta_pr2 (Id a1)
               (mor_terminal a1 unit) $@R cat_pr1)) $@
           ((mor_terminal_unique (cat_binprod a1 unit)
               unit (mor_terminal a1 unit $o cat_pr1))^$ $@
            mor_terminal_unique (cat_binprod a1 unit)
              unit
              (cat_pr2 $o Id (cat_binprod a1 unit)))))
     :
     flip (fun x y : A => cat_binprod x y) unit a1 $<~>
     idmap a1) a0)) a' $o
fmap (flip (fun x y : A => cat_binprod x y) unit) f $==
fmap idmap f $o
(fun a0 : A =>
 cate_fun
   ((fun a1 : A =>
     cate_adjointify cat_pr1
       (cat_binprod_corec (Id a1)
          (mor_terminal a1 unit))
       (cat_binprod_beta_pr1 (Id a1)
          (mor_terminal a1 unit))
       (cat_binprod_eta_pr
          (cat_binprod_corec (Id a1)
             (mor_terminal a1 unit) $o cat_pr1)
          (Id (cat_binprod a1 unit))
          ((cat_assoc_opp cat_pr1
              (cat_binprod_corec (Id a1)
                 (mor_terminal a1 unit)) cat_pr1 $@
            (cat_binprod_beta_pr1 (Id a1)
               (mor_terminal a1 unit) $@R cat_pr1)) $@
           (cat_idl cat_pr1 $@ (cat_idr cat_pr1)^$))
          ((cat_assoc_opp cat_pr1
              (cat_binprod_corec (Id a1)
                 (mor_terminal a1 unit)) cat_pr2 $@
            (cat_binprod_beta_pr2 (Id a1)
               (mor_terminal a1 unit) $@R cat_pr1)) $@
           ((mor_terminal_unique (cat_binprod a1 unit)
               unit (mor_terminal a1 unit $o cat_pr1))^$ $@
            mor_terminal_unique (cat_binprod a1 unit)
              unit
              (cat_pr2 $o Id (cat_binprod a1 unit)))))
     :
     flip (fun x y : A => cat_binprod x y) unit a1 $<~>
     idmap a1) a0)) a
      intros a b f.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b: A
f: a $-> b
(fun a : A =>
 cate_fun
   ((fun a0 : A =>
     cate_adjointify cat_pr1
       (cat_binprod_corec (Id a0)
          (mor_terminal a0 unit))
       (cat_binprod_beta_pr1 (Id a0)
          (mor_terminal a0 unit))
       (cat_binprod_eta_pr
          (cat_binprod_corec (Id a0)
             (mor_terminal a0 unit) $o cat_pr1)
          (Id (cat_binprod a0 unit))
          ((cat_assoc_opp cat_pr1
              (cat_binprod_corec (Id a0)
                 (mor_terminal a0 unit)) cat_pr1 $@
            (cat_binprod_beta_pr1 (Id a0)
               (mor_terminal a0 unit) $@R cat_pr1)) $@
           (cat_idl cat_pr1 $@ (cat_idr cat_pr1)^$))
          ((cat_assoc_opp cat_pr1
              (cat_binprod_corec (Id a0)
                 (mor_terminal a0 unit)) cat_pr2 $@
            (cat_binprod_beta_pr2 (Id a0)
               (mor_terminal a0 unit) $@R cat_pr1)) $@
           ((mor_terminal_unique (cat_binprod a0 unit)
               unit (mor_terminal a0 unit $o cat_pr1))^$ $@
            mor_terminal_unique (cat_binprod a0 unit)
              unit
              (cat_pr2 $o Id (cat_binprod a0 unit)))))
     :
     flip (fun x y : A => cat_binprod x y) unit a0 $<~>
     idmap a0) a)) b $o
fmap (flip (fun x y : A => cat_binprod x y) unit) f $==
fmap idmap f $o
(fun a : A =>
 cate_fun
   ((fun a0 : A =>
     cate_adjointify cat_pr1
       (cat_binprod_corec (Id a0)
          (mor_terminal a0 unit))
       (cat_binprod_beta_pr1 (Id a0)
          (mor_terminal a0 unit))
       (cat_binprod_eta_pr
          (cat_binprod_corec (Id a0)
             (mor_terminal a0 unit) $o cat_pr1)
          (Id (cat_binprod a0 unit))
          ((cat_assoc_opp cat_pr1
              (cat_binprod_corec (Id a0)
                 (mor_terminal a0 unit)) cat_pr1 $@
            (cat_binprod_beta_pr1 (Id a0)
               (mor_terminal a0 unit) $@R cat_pr1)) $@
           (cat_idl cat_pr1 $@ (cat_idr cat_pr1)^$))
          ((cat_assoc_opp cat_pr1
              (cat_binprod_corec (Id a0)
                 (mor_terminal a0 unit)) cat_pr2 $@
            (cat_binprod_beta_pr2 (Id a0)
               (mor_terminal a0 unit) $@R cat_pr1)) $@
           ((mor_terminal_unique (cat_binprod a0 unit)
               unit (mor_terminal a0 unit $o cat_pr1))^$ $@
            mor_terminal_unique (cat_binprod a0 unit)
              unit
              (cat_pr2 $o Id (cat_binprod a0 unit)))))
     :
     flip (fun x y : A => cat_binprod x y) unit a0 $<~>
     idmap a0) a)) a
      refine ((_ $@R _) $@ _ $@ (_ $@L _^$)).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b: A
f: a $-> b
cate_adjointify cat_pr1
  (cat_binprod_corec (Id b) (mor_terminal b unit))
  (cat_binprod_beta_pr1 (Id b) (mor_terminal b unit))
  (cat_binprod_eta_pr
     (cat_binprod_corec (Id b) (mor_terminal b unit) $o
      cat_pr1) (Id (cat_binprod b unit))
     ((cat_assoc_opp cat_pr1
         (cat_binprod_corec (Id b)
            (mor_terminal b unit)) cat_pr1 $@
       (cat_binprod_beta_pr1 (Id b)
          (mor_terminal b unit) $@R cat_pr1)) $@
      (cat_idl cat_pr1 $@ (cat_idr cat_pr1)^$))
     ((cat_assoc_opp cat_pr1
         (cat_binprod_corec (Id b)
            (mor_terminal b unit)) cat_pr2 $@
       (cat_binprod_beta_pr2 (Id b)
          (mor_terminal b unit) $@R cat_pr1)) $@
      ((mor_terminal_unique (cat_binprod b unit) unit
          (mor_terminal b unit $o cat_pr1))^$ $@
       mor_terminal_unique (cat_binprod b unit) unit
         (cat_pr2 $o Id (cat_binprod b unit))))) $==
?Goal
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b: A
f: a $-> b
?Goal $o
fmap (flip (fun x y : A => cat_binprod x y) unit) f $==
fmap idmap f $o ?Goal2
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b: A
f: a $-> b
cate_adjointify cat_pr1
  (cat_binprod_corec (Id a) (mor_terminal a unit))
  (cat_binprod_beta_pr1 (Id a) (mor_terminal a unit))
  (cat_binprod_eta_pr
     (cat_binprod_corec (Id a) (mor_terminal a unit) $o
      cat_pr1) (Id (cat_binprod a unit))
     ((cat_assoc_opp cat_pr1
         (cat_binprod_corec 
            (Id a) (mor_terminal a unit)) cat_pr1 $@
       (cat_binprod_beta_pr1 
          (Id a) (mor_terminal a unit) $@R cat_pr1)) $@
      (cat_idl cat_pr1 $@ (cat_idr cat_pr1)^$))
     ((cat_assoc_opp cat_pr1
         (cat_binprod_corec 
            (Id a) (mor_terminal a unit)) cat_pr2 $@
       (cat_binprod_beta_pr2 
          (Id a) (mor_terminal a unit) $@R cat_pr1)) $@
      ((mor_terminal_unique 
          (cat_binprod a unit) unit
          (mor_terminal a unit $o cat_pr1))^$ $@
       mor_terminal_unique 
         (cat_binprod a unit) unit
         (cat_pr2 $o Id (cat_binprod a unit))))) $->
?Goal2
      1,3: napply cate_buildequiv_fun.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b: A
f: a $-> b
cat_pr1 $o
fmap (flip (fun x y : A => cat_binprod x y) unit) f $==
fmap idmap f $o cat_pr1
      napply cat_binprod_beta_pr1.
  Defined.

  Local Existing Instance left_unitor_twist.

  Local Instance triangle_binprod
    : TriangleIdentity (fun x y => cat_binprod x y) unit.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
TriangleIdentity (fun x y : A => cat_binprod x y) unit
  Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
TriangleIdentity (fun x y : A => cat_binprod x y) unit
    snapply triangle_twist.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
forall a b : A,
fmap01 (fun x y : A => cat_binprod x y) a
  (right_unitor_binprod b) $==
symmetricbraiding_binprod b a $o
fmap01 (fun x y : A => cat_binprod x y) b
  (right_unitor_binprod a) $o
cat_binprod_twist a b unit
    intros a b.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b: A
fmap01 (fun x y : A => cat_binprod x y) a
  (right_unitor_binprod b) $==
symmetricbraiding_binprod b a $o
fmap01 (fun x y : A => cat_binprod x y) b
  (right_unitor_binprod a) $o
cat_binprod_twist a b unit
    refine (fmap02 _ _ _ $@ _ $@ ((_ $@L fmap02 _ _ _^$) $@R _)).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b: A
right_unitor_binprod b $== ?Goal
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b: A
fmap01 (fun x y : A => cat_binprod x y) a ?Goal $==
symmetricbraiding_binprod b a $o
fmap01 (fun x y : A => cat_binprod x y) b ?Goal2 $o
cat_binprod_twist a b unit
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b: A
right_unitor_binprod a $-> ?Goal2
    1,3: napply cate_buildequiv_fun.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b: A
fmap01 (fun x y : A => cat_binprod x y) a cat_pr1 $==
symmetricbraiding_binprod b a $o
fmap01 (fun x y : A => cat_binprod x y) b cat_pr1 $o
cat_binprod_twist a b unit
    napply cat_binprod_eta_pr.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b: A
cat_pr1 $o
fmap01 (fun x y : A => cat_binprod x y) a cat_pr1 $==
cat_pr1 $o
(symmetricbraiding_binprod b a $o
 fmap01 (fun x y : A => cat_binprod x y) b cat_pr1 $o
 cat_binprod_twist a b unit)
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b: A
cat_pr2 $o
fmap01 (fun x y : A => cat_binprod x y) a cat_pr1 $==
cat_pr2 $o
(symmetricbraiding_binprod b a $o
 fmap01 (fun x y : A => cat_binprod x y) b cat_pr1 $o
 cat_binprod_twist a b unit)
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b: A
cat_pr1 $o
fmap01 (fun x y : A => cat_binprod x y) a cat_pr1 $==
cat_pr1 $o
(symmetricbraiding_binprod b a $o
 fmap01 (fun x y : A => cat_binprod x y) b cat_pr1 $o
 cat_binprod_twist a b unit) nrefine (cat_pr1_fmap01_binprod _ _ $@ _ $@ cat_assoc _ _ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b: A
cat_pr1 $==
cat_pr1 $o
(symmetricbraiding_binprod b a $o
 fmap01 (fun x y : A => cat_binprod x y) b cat_pr1) $o
cat_binprod_twist a b unit
      refine (_ $@ (((_^$ $@R _) $@ cat_assoc _ _ _) $@R _)).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b: A
cat_pr1 $==
?Goal1 $o
fmap01 (fun x y : A => cat_binprod x y) b cat_pr1 $o
cat_binprod_twist a b unit
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b: A
cat_pr1 $o symmetricbraiding_binprod b a $-> ?Goal1
      2: napply cat_binprod_beta_pr1.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b: A
cat_pr1 $==
cat_pr2 $o
fmap01 (fun x y : A => cat_binprod x y) b cat_pr1 $o
cat_binprod_twist a b unit
      refine ((_ $@R _) $@ _)^$.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b: A
cat_pr2 $o
fmap01 (fun x y : A => cat_binprod x y) b cat_pr1 $==
?Goal0
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b: A
?Goal0 $o cat_binprod_twist a b unit $== cat_pr1
      1: napply cat_pr2_fmap01_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b: A
cat_pr1 $o cat_pr2 $o cat_binprod_twist a b unit $==
cat_pr1
      napply cat_binprod_pr1_pr2_twist.
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b: A
cat_pr2 $o
fmap01 (fun x y : A => cat_binprod x y) a cat_pr1 $==
cat_pr2 $o
(symmetricbraiding_binprod b a $o
 fmap01 (fun x y : A => cat_binprod x y) b cat_pr1 $o
 cat_binprod_twist a b unit) nrefine (cat_pr2_fmap01_binprod _ _ $@ _ $@ cat_assoc _ _ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b: A
cat_pr1 $o cat_pr2 $==
cat_pr2 $o
(symmetricbraiding_binprod b a $o
 fmap01 (fun x y : A => cat_binprod x y) b cat_pr1) $o
cat_binprod_twist a b unit
      refine (_ $@ (((cat_binprod_beta_pr2 _ _)^$ $@R _) $@ cat_assoc _ _ _ $@R _)).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b: A
cat_pr1 $o cat_pr2 $==
cat_pr1 $o
fmap01 (fun x y : A => cat_binprod x y) b cat_pr1 $o
cat_binprod_twist a b unit
      refine ((_ $@R _) $@ _)^$.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b: A
cat_pr1 $o
fmap01 (fun x y : A => cat_binprod x y) b cat_pr1 $==
?Goal
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b: A
?Goal $o cat_binprod_twist a b unit $==
cat_pr1 $o cat_pr2
      1: napply cat_pr1_fmap01_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b: A
cat_pr1 $o cat_binprod_twist a b unit $==
cat_pr1 $o cat_pr2
      napply cat_binprod_beta_pr1.
  Defined.

  Local Instance pentagon_binprod
    : PentagonIdentity (fun x y => cat_binprod x y).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
PentagonIdentity (fun x y : A => cat_binprod x y)
  Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
PentagonIdentity (fun x y : A => cat_binprod x y)
    intros a b c d.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
associator_cat_binprod (cat_binprod a b) c d $o
associator_cat_binprod a b (cat_binprod c d) $==
fmap10 (fun x y : A => cat_binprod x y)
  (associator_cat_binprod a b c) d $o
associator_cat_binprod a (cat_binprod b c) d $o
fmap01 (fun x y : A => cat_binprod x y) a
  (associator_cat_binprod b c d)
    napply cat_binprod_eta_pr_xx_x.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o cat_pr1 $o
(associator_cat_binprod (cat_binprod a b) c d $o
 associator_cat_binprod a b (cat_binprod c d)) $==
cat_pr1 $o cat_pr1 $o
(fmap10 (fun x y : A => cat_binprod x y)
   (associator_cat_binprod a b c) d $o
 associator_cat_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_cat_binprod b c d))
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr2 $o cat_pr1 $o
(associator_cat_binprod (cat_binprod a b) c d $o
 associator_cat_binprod a b (cat_binprod c d)) $==
cat_pr2 $o cat_pr1 $o
(fmap10 (fun x y : A => cat_binprod x y)
   (associator_cat_binprod a b c) d $o
 associator_cat_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_cat_binprod b c d))
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr2 $o
(associator_cat_binprod (cat_binprod a b) c d $o
 associator_cat_binprod a b (cat_binprod c d)) $==
cat_pr2 $o
(fmap10 (fun x y : A => cat_binprod x y)
   (associator_cat_binprod a b c) d $o
 associator_cat_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_cat_binprod b c d))
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o cat_pr1 $o
(associator_cat_binprod (cat_binprod a b) c d $o
 associator_cat_binprod a b (cat_binprod c d)) $==
cat_pr1 $o cat_pr1 $o
(fmap10 (fun x y : A => cat_binprod x y)
   (associator_cat_binprod a b c) d $o
 associator_cat_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_cat_binprod b c d)) nrefine (cat_assoc_opp _ _ _ $@ (_ $@R _) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o cat_pr1 $o
associator_cat_binprod (cat_binprod a b) c d $==
?Goal1
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
?Goal1 $o associator_cat_binprod a b (cat_binprod c d) $==
cat_pr1 $o cat_pr1 $o
(fmap10 (fun x y : A => cat_binprod x y)
   (associator_cat_binprod a b c) d $o
 associator_cat_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_cat_binprod b c d))
      1: napply cat_pr1_pr1_associator_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o
associator_cat_binprod a b (cat_binprod c d) $==
cat_pr1 $o cat_pr1 $o
(fmap10 (fun x y : A => cat_binprod x y)
   (associator_cat_binprod a b c) d $o
 associator_cat_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_cat_binprod b c d))
      refine (_ $@ (_ $@L ((((_^$ $@R _) $@ cat_assoc _ _ _) $@R _)
        $@ cat_assoc _ _ _)) $@ cat_assoc_opp _ _ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o
associator_cat_binprod a b (cat_binprod c d) $==
cat_pr1 $o
(?Goal2 $o
 associator_cat_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_cat_binprod b c d))
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o
fmap10 (fun x y : A => cat_binprod x y)
  (associator_cat_binprod a b c) d $-> 
?Goal2
      2: napply cat_pr1_fmap10_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o
associator_cat_binprod a b (cat_binprod c d) $==
cat_pr1 $o
(associator_cat_binprod a b c $o cat_pr1 $o
 associator_cat_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_cat_binprod b c d))
      do 2 nrefine (_ $@ (_ $@L cat_assoc_opp _ _ _)).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o
associator_cat_binprod a b (cat_binprod c d) $==
cat_pr1 $o
(associator_cat_binprod a b c $o
 (cat_pr1 $o
  (associator_cat_binprod a (cat_binprod b c) d $o
   fmap01 (fun x y : A => cat_binprod x y) a
     (associator_cat_binprod b c d))))
      napply cat_binprod_eta_pr.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o
(cat_pr1 $o
 associator_cat_binprod a b (cat_binprod c d)) $==
cat_pr1 $o
(cat_pr1 $o
 (associator_cat_binprod a b c $o
  (cat_pr1 $o
   (associator_cat_binprod a (cat_binprod b c) d $o
    fmap01 (fun x y : A => cat_binprod x y) a
      (associator_cat_binprod b c d)))))
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr2 $o
(cat_pr1 $o
 associator_cat_binprod a b (cat_binprod c d)) $==
cat_pr2 $o
(cat_pr1 $o
 (associator_cat_binprod a b c $o
  (cat_pr1 $o
   (associator_cat_binprod a (cat_binprod b c) d $o
    fmap01 (fun x y : A => cat_binprod x y) a
      (associator_cat_binprod b c d)))))
      +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o
(cat_pr1 $o
 associator_cat_binprod a b (cat_binprod c d)) $==
cat_pr1 $o
(cat_pr1 $o
 (associator_cat_binprod a b c $o
  (cat_pr1 $o
   (associator_cat_binprod a (cat_binprod b c) d $o
    fmap01 (fun x y : A => cat_binprod x y) a
      (associator_cat_binprod b c d))))) nrefine (cat_assoc_opp _ _ _ $@ _ $@ cat_assoc _ _ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o cat_pr1 $o
associator_cat_binprod a b (cat_binprod c d) $==
cat_pr1 $o cat_pr1 $o
(associator_cat_binprod a b c $o
 (cat_pr1 $o
  (associator_cat_binprod a (cat_binprod b c) d $o
   fmap01 (fun x y : A => cat_binprod x y) a
     (associator_cat_binprod b c d))))
        refine (_ $@ _ $@ (_^$ $@R _) $@ cat_assoc _ _ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o cat_pr1 $o
associator_cat_binprod a b (cat_binprod c d) $==
?Goal2
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
?Goal2 $==
?Goal5 $o
(cat_pr1 $o
 (associator_cat_binprod a (cat_binprod b c) d $o
  fmap01 (fun x y : A => cat_binprod x y) a
    (associator_cat_binprod b c d)))
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o cat_pr1 $o associator_cat_binprod a b c $->
?Goal5
        1,3: napply cat_pr1_pr1_associator_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $==
cat_pr1 $o
(cat_pr1 $o
 (associator_cat_binprod a (cat_binprod b c) d $o
  fmap01 (fun x y : A => cat_binprod x y) a
    (associator_cat_binprod b c d)))
        do 2 nrefine (_ $@ cat_assoc _ _ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $==
cat_pr1 $o cat_pr1 $o
associator_cat_binprod a (cat_binprod b c) d $o
fmap01 (fun x y : A => cat_binprod x y) a
  (associator_cat_binprod b c d)
        refine (_^$ $@ (_^$ $@R _)).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
?Goal3 $o
fmap01 (fun x y : A => cat_binprod x y) a
  (associator_cat_binprod b c d) $-> cat_pr1
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o cat_pr1 $o
associator_cat_binprod a (cat_binprod b c) d $->
?Goal3
        2: napply cat_pr1_pr1_associator_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o
fmap01 (fun x y : A => cat_binprod x y) a
  (associator_cat_binprod b c d) $-> cat_pr1
        napply cat_pr1_fmap01_binprod.
      +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr2 $o
(cat_pr1 $o
 associator_cat_binprod a b (cat_binprod c d)) $==
cat_pr2 $o
(cat_pr1 $o
 (associator_cat_binprod a b c $o
  (cat_pr1 $o
   (associator_cat_binprod a (cat_binprod b c) d $o
    fmap01 (fun x y : A => cat_binprod x y) a
      (associator_cat_binprod b c d))))) nrefine (cat_assoc_opp _ _ _ $@ _ $@ cat_assoc _ _ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr2 $o cat_pr1 $o
associator_cat_binprod a b (cat_binprod c d) $==
cat_pr2 $o cat_pr1 $o
(associator_cat_binprod a b c $o
 (cat_pr1 $o
  (associator_cat_binprod a (cat_binprod b c) d $o
   fmap01 (fun x y : A => cat_binprod x y) a
     (associator_cat_binprod b c d))))
        refine (_ $@ _ $@ (_^$ $@R _) $@ cat_assoc _ _ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr2 $o cat_pr1 $o
associator_cat_binprod a b (cat_binprod c d) $==
?Goal1
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
?Goal1 $==
?Goal4 $o
(cat_pr1 $o
 (associator_cat_binprod a (cat_binprod b c) d $o
  fmap01 (fun x y : A => cat_binprod x y) a
    (associator_cat_binprod b c d)))
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr2 $o cat_pr1 $o associator_cat_binprod a b c $->
?Goal4
        1,3: napply cat_pr2_pr1_associator_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o cat_pr2 $==
cat_pr1 $o cat_pr2 $o
(cat_pr1 $o
 (associator_cat_binprod a (cat_binprod b c) d $o
  fmap01 (fun x y : A => cat_binprod x y) a
    (associator_cat_binprod b c d)))
        do 2 nrefine (_ $@ cat_assoc _ _ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o cat_pr2 $==
cat_pr1 $o cat_pr2 $o cat_pr1 $o
associator_cat_binprod a (cat_binprod b c) d $o
fmap01 (fun x y : A => cat_binprod x y) a
  (associator_cat_binprod b c d)
        refine (_ $@ ((cat_assoc _ _ _ $@ (_ $@L (_^$ $@ cat_assoc _ _ _))
          $@ cat_assoc_opp _ _ _ $@ cat_assoc_opp _ _ _) $@R _)).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o cat_pr2 $==
cat_pr1 $o ?Goal4 $o ?Goal3 $o
fmap01 (fun x y : A => cat_binprod x y) a
  (associator_cat_binprod b c d)
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr2 $o cat_pr1 $o
associator_cat_binprod a (cat_binprod b c) d $->
?Goal4 $o ?Goal3
        2: napply cat_pr2_pr1_associator_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o cat_pr2 $==
cat_pr1 $o cat_pr1 $o cat_pr2 $o
fmap01 (fun x y : A => cat_binprod x y) a
  (associator_cat_binprod b c d)
        refine (_^$ $@ (_ $@L _^$) $@ cat_assoc_opp _ _ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o cat_pr1 $o ?Goal2 $-> cat_pr1 $o cat_pr2
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr2 $o
fmap01 (fun x y : A => cat_binprod x y) a
  (associator_cat_binprod b c d) $-> 
?Goal2
        2: napply cat_pr2_fmap01_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o cat_pr1 $o
(associator_cat_binprod b c d $o cat_pr2) $->
cat_pr1 $o cat_pr2
        nrefine (cat_assoc_opp _ _ _ $@ (_ $@R _)).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o cat_pr1 $o associator_cat_binprod b c d $==
cat_pr1
        napply cat_pr1_pr1_associator_binprod.
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr2 $o cat_pr1 $o
(associator_cat_binprod (cat_binprod a b) c d $o
 associator_cat_binprod a b (cat_binprod c d)) $==
cat_pr2 $o cat_pr1 $o
(fmap10 (fun x y : A => cat_binprod x y)
   (associator_cat_binprod a b c) d $o
 associator_cat_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_cat_binprod b c d)) nrefine (cat_assoc_opp _ _ _ $@ (_ $@R _) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr2 $o cat_pr1 $o
associator_cat_binprod (cat_binprod a b) c d $==
?Goal0
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
?Goal0 $o associator_cat_binprod a b (cat_binprod c d) $==
cat_pr2 $o cat_pr1 $o
(fmap10 (fun x y : A => cat_binprod x y)
   (associator_cat_binprod a b c) d $o
 associator_cat_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_cat_binprod b c d))
      1: napply cat_pr2_pr1_associator_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o cat_pr2 $o
associator_cat_binprod a b (cat_binprod c d) $==
cat_pr2 $o cat_pr1 $o
(fmap10 (fun x y : A => cat_binprod x y)
   (associator_cat_binprod a b c) d $o
 associator_cat_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_cat_binprod b c d))
      nrefine (cat_assoc _ _ _ $@ _ $@ cat_assoc_opp _ _ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o
(cat_pr2 $o
 associator_cat_binprod a b (cat_binprod c d)) $==
cat_pr2 $o
(cat_pr1 $o
 (fmap10 (fun x y : A => cat_binprod x y)
    (associator_cat_binprod a b c) d $o
  associator_cat_binprod a (cat_binprod b c) d $o
  fmap01 (fun x y : A => cat_binprod x y) a
    (associator_cat_binprod b c d)))
      nrefine ((_ $@L cat_pr2_associator_binprod _ _ _) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o (cat_pr2 $o cat_pr2) $==
cat_pr2 $o
(cat_pr1 $o
 (fmap10 (fun x y : A => cat_binprod x y)
    (associator_cat_binprod a b c) d $o
  associator_cat_binprod a (cat_binprod b c) d $o
  fmap01 (fun x y : A => cat_binprod x y) a
    (associator_cat_binprod b c d)))
      refine (_ $@ (_ $@L ((((_^$ $@R _) $@ cat_assoc _ _ _) $@R _) $@ cat_assoc _ _ _))).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o (cat_pr2 $o cat_pr2) $==
cat_pr2 $o
(?Goal1 $o
 associator_cat_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_cat_binprod b c d))
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o
fmap10 (fun x y : A => cat_binprod x y)
  (associator_cat_binprod a b c) d $-> 
?Goal1
      2: napply cat_pr1_fmap10_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o (cat_pr2 $o cat_pr2) $==
cat_pr2 $o
(associator_cat_binprod a b c $o cat_pr1 $o
 associator_cat_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_cat_binprod b c d))
      nrefine (_ $@ (_ $@L (cat_assoc_opp _ _ _ $@ cat_assoc_opp _ _ _))).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o (cat_pr2 $o cat_pr2) $==
cat_pr2 $o
(associator_cat_binprod a b c $o
 (cat_pr1 $o
  (associator_cat_binprod a (cat_binprod b c) d $o
   fmap01 (fun x y : A => cat_binprod x y) a
     (associator_cat_binprod b c d))))
      refine (_ $@ (_^$ $@R _) $@ cat_assoc _ _ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o (cat_pr2 $o cat_pr2) $==
?Goal1 $o
(cat_pr1 $o
 (associator_cat_binprod a (cat_binprod b c) d $o
  fmap01 (fun x y : A => cat_binprod x y) a
    (associator_cat_binprod b c d)))
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr2 $o associator_cat_binprod a b c $-> ?Goal1
      2: napply cat_pr2_associator_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o (cat_pr2 $o cat_pr2) $==
cat_pr2 $o cat_pr2 $o
(cat_pr1 $o
 (associator_cat_binprod a (cat_binprod b c) d $o
  fmap01 (fun x y : A => cat_binprod x y) a
    (associator_cat_binprod b c d)))
      refine (_ $@ (_ $@L ((_^$ $@R _) $@ cat_assoc _ _ _ $@ cat_assoc _ _ _)) $@ cat_assoc_opp _ _ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o (cat_pr2 $o cat_pr2) $==
cat_pr2 $o
(?Goal1 $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_cat_binprod b c d))
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr2 $o cat_pr1 $o
associator_cat_binprod a (cat_binprod b c) d $->
?Goal1
      2: napply cat_pr2_pr1_associator_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o (cat_pr2 $o cat_pr2) $==
cat_pr2 $o
(cat_pr1 $o cat_pr2 $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_cat_binprod b c d))
      refine (_ $@ (_ $@L ((_ $@L _^$) $@ cat_assoc_opp _ _ _))).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o (cat_pr2 $o cat_pr2) $==
cat_pr2 $o (cat_pr1 $o ?Goal1)
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr2 $o
fmap01 (fun x y : A => cat_binprod x y) a
  (associator_cat_binprod b c d) $-> 
?Goal1
      2: napply cat_pr2_fmap01_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr1 $o (cat_pr2 $o cat_pr2) $==
cat_pr2 $o
(cat_pr1 $o (associator_cat_binprod b c d $o cat_pr2))
      refine (cat_assoc_opp _ _ _ $@ (_^$ $@R _) $@ cat_assoc _ _ _ $@ cat_assoc _ _ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr2 $o cat_pr1 $o associator_cat_binprod b c d $->
cat_pr1 $o cat_pr2
      napply cat_pr2_pr1_associator_binprod.
    -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr2 $o
(associator_cat_binprod (cat_binprod a b) c d $o
 associator_cat_binprod a b (cat_binprod c d)) $==
cat_pr2 $o
(fmap10 (fun x y : A => cat_binprod x y)
   (associator_cat_binprod a b c) d $o
 associator_cat_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_cat_binprod b c d)) nrefine (cat_assoc_opp _ _ _ $@ (cat_pr2_associator_binprod _ _ _ $@R _) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr2 $o cat_pr2 $o
associator_cat_binprod a b (cat_binprod c d) $==
cat_pr2 $o
(fmap10 (fun x y : A => cat_binprod x y)
   (associator_cat_binprod a b c) d $o
 associator_cat_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_cat_binprod b c d))
      nrefine (cat_assoc _ _ _ $@ (_ $@L (cat_pr2_associator_binprod _ _ _)) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr2 $o (cat_pr2 $o cat_pr2) $==
cat_pr2 $o
(fmap10 (fun x y : A => cat_binprod x y)
   (associator_cat_binprod a b c) d $o
 associator_cat_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_cat_binprod b c d))
      refine (_ $@ (_^$ $@R _) $@ cat_assoc _ _ _ $@ (_ $@L (cat_assoc_opp _ _ _))).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr2 $o (cat_pr2 $o cat_pr2) $==
?Goal0 $o
(associator_cat_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_cat_binprod b c d))
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr2 $o
fmap10 (fun x y : A => cat_binprod x y)
  (associator_cat_binprod a b c) d $-> 
?Goal0
      2: napply cat_pr2_fmap10_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr2 $o (cat_pr2 $o cat_pr2) $==
cat_pr2 $o
(associator_cat_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_cat_binprod b c d))
      refine (_ $@ cat_assoc_opp _ _ _ $@ (_^$ $@R _) $@ cat_assoc _ _ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr2 $o (cat_pr2 $o cat_pr2) $==
?Goal2 $o
(?Goal1 $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_cat_binprod b c d))
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr2 $o
associator_cat_binprod a (cat_binprod b c) d $->
?Goal2 $o ?Goal1
      2: napply cat_pr2_associator_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr2 $o (cat_pr2 $o cat_pr2) $==
cat_pr2 $o
(cat_pr2 $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_cat_binprod b c d))
      refine (cat_assoc_opp _ _ _ $@ (_^$ $@R _) $@ cat_assoc _ _ _
        $@ (_ $@L (cat_pr2_fmap01_binprod _ _)^$)).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c, d: A
cat_pr2 $o associator_cat_binprod b c d $->
cat_pr2 $o cat_pr2
      napply cat_pr2_associator_binprod.
  Defined.

  Local Instance hexagon_identity
    : HexagonIdentity (fun x y => cat_binprod x y).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
HexagonIdentity (fun x y : A => cat_binprod x y)
  Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
HexagonIdentity (fun x y : A => cat_binprod x y)
    intros a b c.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
fmap10 (fun x y : A => cat_binprod x y)
  (symmetricbraiding_binprod b a) c $o
associator_cat_binprod b a c $o
fmap01 (fun x y : A => cat_binprod x y) b
  (symmetricbraiding_binprod c a) $==
associator_cat_binprod a b c $o
symmetricbraiding_binprod (cat_binprod b c) a $o
associator_cat_binprod b c a
    nrefine (cat_assoc _ _ _ $@ _ $@ cat_assoc_opp _ _ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
fmap10 (fun x y : A => cat_binprod x y)
  (symmetricbraiding_binprod b a) c $o
(associator_cat_binprod b a c $o
 fmap01 (fun x y : A => cat_binprod x y) b
   (symmetricbraiding_binprod c a)) $==
associator_cat_binprod a b c $o
(symmetricbraiding_binprod (cat_binprod b c) a $o
 associator_cat_binprod b c a)
    napply cat_binprod_eta_pr.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr1 $o
(fmap10 (fun x y : A => cat_binprod x y)
   (symmetricbraiding_binprod b a) c $o
 (associator_cat_binprod b a c $o
  fmap01 (fun x y : A => cat_binprod x y) b
    (symmetricbraiding_binprod c a))) $==
cat_pr1 $o
(associator_cat_binprod a b c $o
 (symmetricbraiding_binprod (cat_binprod b c) a $o
  associator_cat_binprod b c a))
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o
(fmap10 (fun x y : A => cat_binprod x y)
   (symmetricbraiding_binprod b a) c $o
 (associator_cat_binprod b a c $o
  fmap01 (fun x y : A => cat_binprod x y) b
    (symmetricbraiding_binprod c a))) $==
cat_pr2 $o
(associator_cat_binprod a b c $o
 (symmetricbraiding_binprod (cat_binprod b c) a $o
  associator_cat_binprod b c a))
    {A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr1 $o
(fmap10 (fun x y : A => cat_binprod x y)
   (symmetricbraiding_binprod b a) c $o
 (associator_cat_binprod b a c $o
  fmap01 (fun x y : A => cat_binprod x y) b
    (symmetricbraiding_binprod c a))) $==
cat_pr1 $o
(associator_cat_binprod a b c $o
 (symmetricbraiding_binprod (cat_binprod b c) a $o
  associator_cat_binprod b c a)) nrefine (cat_assoc_opp _ _ _ $@ (cat_pr1_fmap10_binprod _ _ $@R _) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
symmetricbraiding_binprod b a $o cat_pr1 $o
(associator_cat_binprod b a c $o
 fmap01 (fun x y : A => cat_binprod x y) b
   (symmetricbraiding_binprod c a)) $==
cat_pr1 $o
(associator_cat_binprod a b c $o
 (symmetricbraiding_binprod (cat_binprod b c) a $o
  associator_cat_binprod b c a))
      nrefine (cat_assoc _ _ _ $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
symmetricbraiding_binprod b a $o
(cat_pr1 $o
 (associator_cat_binprod b a c $o
  fmap01 (fun x y : A => cat_binprod x y) b
    (symmetricbraiding_binprod c a))) $==
cat_pr1 $o
(associator_cat_binprod a b c $o
 (symmetricbraiding_binprod (cat_binprod b c) a $o
  associator_cat_binprod b c a))
      napply cat_binprod_eta_pr.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr1 $o
(symmetricbraiding_binprod b a $o
 (cat_pr1 $o
  (associator_cat_binprod b a c $o
   fmap01 (fun x y : A => cat_binprod x y) b
     (symmetricbraiding_binprod c a)))) $==
cat_pr1 $o
(cat_pr1 $o
 (associator_cat_binprod a b c $o
  (symmetricbraiding_binprod (cat_binprod b c) a $o
   associator_cat_binprod b c a)))
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o
(symmetricbraiding_binprod b a $o
 (cat_pr1 $o
  (associator_cat_binprod b a c $o
   fmap01 (fun x y : A => cat_binprod x y) b
     (symmetricbraiding_binprod c a)))) $==
cat_pr2 $o
(cat_pr1 $o
 (associator_cat_binprod a b c $o
  (symmetricbraiding_binprod (cat_binprod b c) a $o
   associator_cat_binprod b c a)))
      {A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr1 $o
(symmetricbraiding_binprod b a $o
 (cat_pr1 $o
  (associator_cat_binprod b a c $o
   fmap01 (fun x y : A => cat_binprod x y) b
     (symmetricbraiding_binprod c a)))) $==
cat_pr1 $o
(cat_pr1 $o
 (associator_cat_binprod a b c $o
  (symmetricbraiding_binprod (cat_binprod b c) a $o
   associator_cat_binprod b c a))) nrefine (cat_assoc_opp _ _ _ $@ _ $@ cat_assoc _ _ _ $@ cat_assoc _ _ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr1 $o symmetricbraiding_binprod b a $o
(cat_pr1 $o
 (associator_cat_binprod b a c $o
  fmap01 (fun x y : A => cat_binprod x y) b
    (symmetricbraiding_binprod c a))) $==
cat_pr1 $o cat_pr1 $o associator_cat_binprod a b c $o
(symmetricbraiding_binprod (cat_binprod b c) a $o
 associator_cat_binprod b c a)
        refine ((_ $@R _) $@ _ $@ (_^$ $@R _)).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr1 $o symmetricbraiding_binprod b a $== ?Goal1
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
?Goal1 $o
(cat_pr1 $o
 (associator_cat_binprod b a c $o
  fmap01 (fun x y : A => cat_binprod x y) b
    (symmetricbraiding_binprod c a))) $==
?Goal4 $o
(symmetricbraiding_binprod (cat_binprod b c) a $o
 associator_cat_binprod b c a)
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr1 $o cat_pr1 $o associator_cat_binprod a b c $->
?Goal4
        1: napply cat_binprod_beta_pr1.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o
(cat_pr1 $o
 (associator_cat_binprod b a c $o
  fmap01 (fun x y : A => cat_binprod x y) b
    (symmetricbraiding_binprod c a))) $==
?Goal2 $o
(symmetricbraiding_binprod (cat_binprod b c) a $o
 associator_cat_binprod b c a)
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr1 $o cat_pr1 $o associator_cat_binprod a b c $->
?Goal2
        2: napply cat_pr1_pr1_associator_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o
(cat_pr1 $o
 (associator_cat_binprod b a c $o
  fmap01 (fun x y : A => cat_binprod x y) b
    (symmetricbraiding_binprod c a))) $==
cat_pr1 $o
(symmetricbraiding_binprod (cat_binprod b c) a $o
 associator_cat_binprod b c a)
        nrefine (cat_assoc_opp _ _ _ $@ cat_assoc_opp _ _ _ $@ _ $@ cat_assoc _ _ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o cat_pr1 $o associator_cat_binprod b a c $o
fmap01 (fun x y : A => cat_binprod x y) b
  (symmetricbraiding_binprod c a) $==
cat_pr1 $o
symmetricbraiding_binprod (cat_binprod b c) a $o
associator_cat_binprod b c a
        refine ((_ $@R _) $@ _ $@ (_^$ $@R _)).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o cat_pr1 $o associator_cat_binprod b a c $==
?Goal1
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
?Goal1 $o
fmap01 (fun x y : A => cat_binprod x y) b
  (symmetricbraiding_binprod c a) $==
?Goal4 $o associator_cat_binprod b c a
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr1 $o
symmetricbraiding_binprod (cat_binprod b c) a $->
?Goal4
        1: napply cat_pr2_pr1_associator_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr1 $o cat_pr2 $o
fmap01 (fun x y : A => cat_binprod x y) b
  (symmetricbraiding_binprod c a) $==
?Goal2 $o associator_cat_binprod b c a
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr1 $o
symmetricbraiding_binprod (cat_binprod b c) a $->
?Goal2
        2: napply cat_binprod_beta_pr1.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr1 $o cat_pr2 $o
fmap01 (fun x y : A => cat_binprod x y) b
  (symmetricbraiding_binprod c a) $==
cat_pr2 $o associator_cat_binprod b c a
        refine (cat_assoc _ _ _ $@ (_ $@L _) $@ cat_assoc_opp _ _ _ $@ (_ $@R _) $@ _^$).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o
fmap01 (fun x y : A => cat_binprod x y) b
  (symmetricbraiding_binprod c a) $== ?Goal4 $o ?Goal3
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr1 $o ?Goal4 $== ?Goal5
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o associator_cat_binprod b c a $->
?Goal5 $o ?Goal3
        1: napply cat_pr2_fmap01_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr1 $o symmetricbraiding_binprod c a $== ?Goal1
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o associator_cat_binprod b c a $->
?Goal1 $o cat_pr2
        2: napply cat_pr2_associator_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr1 $o symmetricbraiding_binprod c a $== cat_pr2
        napply cat_binprod_beta_pr1. }A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o
(symmetricbraiding_binprod b a $o
 (cat_pr1 $o
  (associator_cat_binprod b a c $o
   fmap01 (fun x y : A => cat_binprod x y) b
     (symmetricbraiding_binprod c a)))) $==
cat_pr2 $o
(cat_pr1 $o
 (associator_cat_binprod a b c $o
  (symmetricbraiding_binprod (cat_binprod b c) a $o
   associator_cat_binprod b c a)))
      nrefine (cat_assoc_opp _ _ _ $@ _ $@ cat_assoc _ _ _ $@ cat_assoc _ _ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o symmetricbraiding_binprod b a $o
(cat_pr1 $o
 (associator_cat_binprod b a c $o
  fmap01 (fun x y : A => cat_binprod x y) b
    (symmetricbraiding_binprod c a))) $==
cat_pr2 $o cat_pr1 $o associator_cat_binprod a b c $o
(symmetricbraiding_binprod (cat_binprod b c) a $o
 associator_cat_binprod b c a)
      refine ((_ $@R _) $@ _ $@ (_^$ $@R _)).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o symmetricbraiding_binprod b a $== ?Goal0
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
?Goal0 $o
(cat_pr1 $o
 (associator_cat_binprod b a c $o
  fmap01 (fun x y : A => cat_binprod x y) b
    (symmetricbraiding_binprod c a))) $==
?Goal3 $o
(symmetricbraiding_binprod (cat_binprod b c) a $o
 associator_cat_binprod b c a)
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o cat_pr1 $o associator_cat_binprod a b c $->
?Goal3
      1: napply cat_binprod_beta_pr2.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr1 $o
(cat_pr1 $o
 (associator_cat_binprod b a c $o
  fmap01 (fun x y : A => cat_binprod x y) b
    (symmetricbraiding_binprod c a))) $==
?Goal1 $o
(symmetricbraiding_binprod (cat_binprod b c) a $o
 associator_cat_binprod b c a)
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o cat_pr1 $o associator_cat_binprod a b c $->
?Goal1
      2: napply cat_pr2_pr1_associator_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr1 $o
(cat_pr1 $o
 (associator_cat_binprod b a c $o
  fmap01 (fun x y : A => cat_binprod x y) b
    (symmetricbraiding_binprod c a))) $==
cat_pr1 $o cat_pr2 $o
(symmetricbraiding_binprod (cat_binprod b c) a $o
 associator_cat_binprod b c a)
      nrefine (cat_assoc_opp _ _ _ $@ cat_assoc_opp _ _ _ $@ _ $@ cat_assoc _ _ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr1 $o cat_pr1 $o associator_cat_binprod b a c $o
fmap01 (fun x y : A => cat_binprod x y) b
  (symmetricbraiding_binprod c a) $==
cat_pr1 $o cat_pr2 $o
symmetricbraiding_binprod (cat_binprod b c) a $o
associator_cat_binprod b c a
      refine ((_ $@R _) $@ _ $@ (((_ $@L _^$) $@ cat_assoc_opp _ _ _) $@R _)).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr1 $o cat_pr1 $o associator_cat_binprod b a c $==
?Goal0
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
?Goal0 $o
fmap01 (fun x y : A => cat_binprod x y) b
  (symmetricbraiding_binprod c a) $==
cat_pr1 $o ?Goal3 $o associator_cat_binprod b c a
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o
symmetricbraiding_binprod (cat_binprod b c) a $->
?Goal3
      1: napply cat_pr1_pr1_associator_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr1 $o
fmap01 (fun x y : A => cat_binprod x y) b
  (symmetricbraiding_binprod c a) $==
cat_pr1 $o ?Goal1 $o associator_cat_binprod b c a
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o
symmetricbraiding_binprod (cat_binprod b c) a $->
?Goal1
      2: napply cat_binprod_beta_pr2.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr1 $o
fmap01 (fun x y : A => cat_binprod x y) b
  (symmetricbraiding_binprod c a) $==
cat_pr1 $o cat_pr1 $o associator_cat_binprod b c a
      refine (cat_pr1_fmap01_binprod _ _ $@ _^$).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr1 $o cat_pr1 $o associator_cat_binprod b c a $->
cat_pr1
      napply cat_pr1_pr1_associator_binprod. }A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o
(fmap10 (fun x y : A => cat_binprod x y)
   (symmetricbraiding_binprod b a) c $o
 (associator_cat_binprod b a c $o
  fmap01 (fun x y : A => cat_binprod x y) b
    (symmetricbraiding_binprod c a))) $==
cat_pr2 $o
(associator_cat_binprod a b c $o
 (symmetricbraiding_binprod (cat_binprod b c) a $o
  associator_cat_binprod b c a))
    nrefine (cat_assoc_opp _ _ _ $@ _ $@ cat_assoc _ _ _ $@ cat_assoc _ _ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o
fmap10 (fun x y : A => cat_binprod x y)
  (symmetricbraiding_binprod b a) c $o
(associator_cat_binprod b a c $o
 fmap01 (fun x y : A => cat_binprod x y) b
   (symmetricbraiding_binprod c a)) $==
cat_pr2 $o associator_cat_binprod a b c $o
symmetricbraiding_binprod (cat_binprod b c) a $o
associator_cat_binprod b c a
    refine ((_ $@R _) $@ _ $@ ((_^$ $@R _) $@R _)).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o
fmap10 (fun x y : A => cat_binprod x y)
  (symmetricbraiding_binprod b a) c $== ?Goal
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
?Goal $o
(associator_cat_binprod b a c $o
 fmap01 (fun x y : A => cat_binprod x y) b
   (symmetricbraiding_binprod c a)) $==
?Goal2 $o
symmetricbraiding_binprod (cat_binprod b c) a $o
associator_cat_binprod b c a
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o associator_cat_binprod a b c $-> ?Goal2
    1: napply cat_pr2_fmap10_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o
(associator_cat_binprod b a c $o
 fmap01 (fun x y : A => cat_binprod x y) b
   (symmetricbraiding_binprod c a)) $==
?Goal0 $o
symmetricbraiding_binprod (cat_binprod b c) a $o
associator_cat_binprod b c a
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o associator_cat_binprod a b c $-> ?Goal0
    2: napply cat_pr2_associator_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o
(associator_cat_binprod b a c $o
 fmap01 (fun x y : A => cat_binprod x y) b
   (symmetricbraiding_binprod c a)) $==
cat_pr2 $o cat_pr2 $o
symmetricbraiding_binprod (cat_binprod b c) a $o
associator_cat_binprod b c a
    nrefine (cat_assoc_opp _ _ _ $@ (cat_pr2_associator_binprod _ _ _ $@R _) $@ _).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o cat_pr2 $o
fmap01 (fun x y : A => cat_binprod x y) b
  (symmetricbraiding_binprod c a) $==
cat_pr2 $o cat_pr2 $o
symmetricbraiding_binprod (cat_binprod b c) a $o
associator_cat_binprod b c a
    nrefine (cat_assoc _ _ _ $@ (_ $@L _) $@ _ $@ (cat_assoc_opp _ _ _ $@R _)).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o
fmap01 (fun x y : A => cat_binprod x y) b
  (symmetricbraiding_binprod c a) $== ?Goal
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o ?Goal $==
cat_pr2 $o
(cat_pr2 $o
 symmetricbraiding_binprod (cat_binprod b c) a) $o
associator_cat_binprod b c a
    1: napply cat_pr2_fmap01_binprod.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o (symmetricbraiding_binprod c a $o cat_pr2) $==
cat_pr2 $o
(cat_pr2 $o
 symmetricbraiding_binprod (cat_binprod b c) a) $o
associator_cat_binprod b c a
    refine (cat_assoc_opp _ _ _ $@ (_ $@R _) $@ _^$ $@ ((_ $@L _^$) $@R _)).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o symmetricbraiding_binprod c a $== ?Goal
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o ?Goal2 $o associator_cat_binprod b c a $->
?Goal $o cat_pr2
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o
symmetricbraiding_binprod (cat_binprod b c) a $->
?Goal2
    1,3: napply cat_binprod_beta_pr2.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
unit: A
IsTerminal0: IsTerminal unit
a, b, c: A
cat_pr2 $o cat_pr1 $o associator_cat_binprod b c a $->
cat_pr1 $o cat_pr2
    napply cat_pr2_pr1_associator_binprod.
  Defined.

  #[export] Instance ismonoidal_cat_binprod
    : IsMonoidal A (fun x y => cat_binprod x y) unit
    := {}.

  #[export] Instance issymmetricmonoidal_cat_binprod
    : IsSymmetricMonoidal A (fun x y => cat_binprod x y) unit
    := {}.

End Associativity.

(** *** Products in Type *)

(** Since we use the Yoneda lemma in this file, we therefore depend on WildCat.Universe which means these instances have to live here. *)
Instance hasbinaryproducts_type : HasBinaryProducts Type.HasBinaryProducts Type
Proof.HasBinaryProducts Type
  intros X Y.X, Y: Type
BinaryProduct X Y
  snapply Build_BinaryProduct.X, Y: Type
Type
X, Y: Type
?cat_binprod' $-> X
X, Y: Type
?cat_binprod' $-> Y
X, Y: Type
forall z : Type,
(z $-> X) -> (z $-> Y) -> z $-> ?cat_binprod'
X, Y: Type
forall (z : Type) (f : z $-> X) (g : z $-> Y),
?cat_pr1 $o ?cat_binprod_corec z f g $== f
X, Y: Type
forall (z : Type) (f : z $-> X) (g : z $-> Y),
?cat_pr2 $o ?cat_binprod_corec z f g $== g
X, Y: Type
forall (z : Type) (f g : z $-> ?cat_binprod'),
?cat_pr1 $o f $== ?cat_pr1 $o g ->
?cat_pr2 $o f $== ?cat_pr2 $o g -> f $== g
  -X, Y: Type
Type exact (X * Y).
  -X, Y: Type
X * Y $-> X exact fst.
  -X, Y: Type
X * Y $-> Y exact snd.
  -X, Y: Type
forall z : Type, (z $-> X) -> (z $-> Y) -> z $-> X * Y intros Z f g z.X, Y, Z: Type
f: Z $-> X
g: Z $-> Y
z: Z
X * Y exact (f z, g z).
  -X, Y: Type
forall (z : Type) (f : z $-> X) (g : z $-> Y),
fst $o
(fun (Z : Type) (f0 : Z $-> X) (g0 : Z $-> Y) =>
 (fun z0 : Z => (f0 z0, g0 z0)) : Z $-> X * Y) z f g $==
f reflexivity.
  -X, Y: Type
forall (z : Type) (f : z $-> X) (g : z $-> Y),
snd $o
(fun (Z : Type) (f0 : Z $-> X) (g0 : Z $-> Y) =>
 (fun z0 : Z => (f0 z0, g0 z0)) : Z $-> X * Y) z f g $==
g reflexivity.
  -X, Y: Type
forall (z : Type) (f g : z $-> X * Y),
fst $o f $== fst $o g ->
snd $o f $== snd $o g -> f $== g intros Z f g p q x.X, Y, Z: Type
f, g: Z $-> X * Y
p: fst $o f $== fst $o g
q: snd $o f $== snd $o g
x: Z
f x = g x
    napply path_prod.X, Y, Z: Type
f, g: Z $-> X * Y
p: fst $o f $== fst $o g
q: snd $o f $== snd $o g
x: Z
fst (f x) = fst (g x)
X, Y, Z: Type
f, g: Z $-> X * Y
p: fst $o f $== fst $o g
q: snd $o f $== snd $o g
x: Z
snd (f x) = snd (g x)
    +X, Y, Z: Type
f, g: Z $-> X * Y
p: fst $o f $== fst $o g
q: snd $o f $== snd $o g
x: Z
fst (f x) = fst (g x) exact (p x).
    +X, Y, Z: Type
f, g: Z $-> X * Y
p: fst $o f $== fst $o g
q: snd $o f $== snd $o g
x: Z
snd (f x) = snd (g x) exact (q x).
Defined.

(** Assuming [Funext], [Type] has all products. *)
Instance hasallproducts_type `{Funext} : HasAllProducts Type.H: Funext
HasAllProducts Type
Proof.H: Funext
HasAllProducts Type
  intros I x.H: Funext
I: Type
x: I -> Type
Product I x
  snapply Build_Product.H: Funext
I: Type
x: I -> Type
Type
H: Funext
I: Type
x: I -> Type
forall i : I, ?cat_prod $-> x i
H: Funext
I: Type
x: I -> Type
forall z : Type,
(forall i : I, z $-> x i) -> z $-> ?cat_prod
H: Funext
I: Type
x: I -> Type
forall (z : Type) (f : forall i : I, z $-> x i)
(i : I), ?cat_pr i $o ?cat_prod_corec z f $== f i
H: Funext
I: Type
x: I -> Type
forall (z : Type) (f g : z $-> ?cat_prod),
(forall i : I, ?cat_pr i $o f $== ?cat_pr i $o g) ->
f $== g
  -H: Funext
I: Type
x: I -> Type
Type exact (forall (i : I), x i).
  -H: Funext
I: Type
x: I -> Type
forall i : I, (forall i0 : I, x i0) $-> x i intros i f.H: Funext
I: Type
x: I -> Type
i: I
f: forall i : I, x i
x i exact (f i).
  -H: Funext
I: Type
x: I -> Type
forall z : Type,
(forall i : I, z $-> x i) -> z $-> (forall i : I, x i) intros A f a i.H: Funext
I: Type
x: I -> Type
A: Type
f: forall i : I, A $-> x i
a: A
i: I
x i exact (f i a).
  -H: Funext
I: Type
x: I -> Type
forall (z : Type) (f : forall i : I, z $-> x i)
(i : I),
(fun i0 : I =>
 (fun f0 : forall i1 : I, x i1 => f0 i0)
 :
 (forall i1 : I, x i1) $-> x i0) i $o
(fun (A : Type) (f0 : forall i0 : I, A $-> x i0) =>
 (fun (a : A) (i0 : I) => f0 i0 a)
 :
 A $-> (forall i0 : I, x i0)) z f $== f i reflexivity.
  -H: Funext
I: Type
x: I -> Type
forall (z : Type) (f g : z $-> (forall i : I, x i)),
(forall i : I,
 (fun i0 : I =>
  (fun f0 : forall i1 : I, x i1 => f0 i0)
  :
  (forall i1 : I, x i1) $-> x i0) i $o f $==
 (fun i0 : I =>
  (fun f0 : forall i1 : I, x i1 => f0 i0)
  :
  (forall i1 : I, x i1) $-> x i0) i $o g) -> f $== g intros A f g p a.H: Funext
I: Type
x: I -> Type
A: Type
f, g: A $-> (forall i : I, x i)
p: forall i : I,
(fun i0 : I =>
 (fun f : forall i1 : I, x i1 => f i0)
 :
 (forall i1 : I, x i1) $-> x i0) i $o f $==
(fun i0 : I =>
 (fun f : forall i1 : I, x i1 => f i0)
 :
 (forall i1 : I, x i1) $-> x i0) i $o g
a: A
f a = g a
    exact (path_forall _ _ (fun i => p i a)).
Defined.