HoTT.WildCat.Products.v.alectryon.json

Require Import Basics.Equivalences Basics.Overture Basics.Tactics.Require Import Basics.Equivalences Basics.Overture Basics.Tactics.
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.Graph WildCat.ZeroGroupoid
               WildCat.Monoidal WildCat.MonoidalTwistConstruction
               WildCat.FunctorCat.

(** * Categories with products *)

(** ** Indexed 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 i0 : I, prod $-> x i0
i: I
yon_0gpd prod z $-> (fun i0 : I => yon_0gpd (x i0) 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 z0 : A, (forall i : I, z0 $-> x i) -> z0 $-> cat_prod
cat_prod_beta_pr: forall (z0 : A) (f : forall i : I, z0 $-> x i) (i : I),
cat_pr i $o cat_prod_corec z0 f $== f i
cat_prod_eta_pr: forall (z0 : A) (f g : z0 $-> 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 z0 : A, (forall i : I, z0 $-> x i) -> z0 $-> cat_prod
cat_prod_beta_pr: forall (z0 : A) (f : forall i : I, z0 $-> x i) (i : I),
cat_pr i $o cat_prod_corec z0 f $== f i
cat_prod_eta_pr: forall (z0 : A) (f g : z0 $-> 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 z0 : A, (forall i : I, z0 $-> x i) -> z0 $-> cat_prod
cat_prod_beta_pr: forall (z0 : A) (f : forall i : I, z0 $-> x i) (i : I),
cat_pr i $o cat_prod_corec z0 f $== f i
cat_prod_eta_pr: forall (z0 : A) (f g : z0 $-> 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 z0 : A, (forall i : I, z0 $-> x i) -> z0 $-> cat_prod
cat_prod_beta_pr: forall (z0 : A) (f : forall i : I, z0 $-> x i) (i : I),
cat_pr i $o cat_prod_corec z0 f $== f i
cat_prod_eta_pr: forall (z0 : A) (f g : z0 $-> cat_prod),
(forall i : I, cat_pr i $o f $== cat_pr i $o g) -> f $== g
z: A
forall x0 y : 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 z0 : A, (forall i : I, z0 $-> x i) -> z0 $-> cat_prod
cat_prod_beta_pr: forall (z0 : A) (f : forall i : I, z0 $-> x i) (i : I),
cat_pr i $o cat_prod_corec z0 f $== f i
cat_prod_eta_pr: forall (z0 : A) (f g : z0 $-> 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 z0 : A, (forall i : I, z0 $-> x i) -> z0 $-> cat_prod
cat_prod_beta_pr: forall (z0 : A) (f0 : forall i : I, z0 $-> x i) (i : I),
cat_pr i $o cat_prod_corec z0 f0 $== f0 i
cat_prod_eta_pr: forall (z0 : A) (f0 g : z0 $-> cat_prod),
(forall i : I, cat_pr i $o f0 $== cat_pr i $o g) -> f0 $== g
z: A
f: zerogpd_graph (prod_0gpd I (fun i : I => yon_0gpd (x i) z))
{a : 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 z0 : A, (forall i : I, z0 $-> x i) -> z0 $-> cat_prod
cat_prod_beta_pr: forall (z0 : A) (f0 : forall i : I, z0 $-> x i) (i : I),
cat_pr i $o cat_prod_corec z0 f0 $== f0 i
cat_prod_eta_pr: forall (z0 : A) (f0 g : z0 $-> cat_prod),
(forall i : I, cat_pr i $o f0 $== cat_pr i $o g) -> f0 $== g
z: A
f: 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 i0 : I, cat_prod $-> x i0
cat_prod_corec: forall z0 : A, (forall i0 : I, z0 $-> x i0) -> z0 $-> cat_prod
cat_prod_beta_pr: forall (z0 : A) (f0 : forall i0 : I, z0 $-> x i0) 
(i0 : I), cat_pr i0 $o cat_prod_corec z0 f0 $== f0 i0
cat_prod_eta_pr: forall (z0 : A) (f0 g : z0 $-> cat_prod),
(forall i0 : I, cat_pr i0 $o f0 $== cat_pr i0 $o g) -> f0 $== g
z: A
f: zerogpd_graph (prod_0gpd I (fun i0 : I => yon_0gpd (x i0) 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 z0 : A, (forall i : I, z0 $-> x i) -> z0 $-> cat_prod
cat_prod_beta_pr: forall (z0 : A) (f : forall i : I, z0 $-> x i) (i : I),
cat_pr i $o cat_prod_corec z0 f $== f i
cat_prod_eta_pr: forall (z0 : A) (f g : z0 $-> cat_prod),
(forall i : I, cat_pr i $o f $== cat_pr i $o g) -> f $== g
z: A
forall x0 y : 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 z0 : A, (forall i : I, z0 $-> x i) -> z0 $-> cat_prod
cat_prod_beta_pr: forall (z0 : A) (f0 : forall i : I, z0 $-> x i) (i : I),
cat_pr i $o cat_prod_corec z0 f0 $== f0 i
cat_prod_eta_pr: forall (z0 : A) (f0 g0 : z0 $-> cat_prod),
(forall i : I, cat_pr i $o f0 $== cat_pr i $o g0) -> f0 $== g0
z: A
f, g: 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
zerogpd_graph
  ((fun z : A^op => prod_0gpd I (fun i : I => yon_0gpd (x i) z)) a) ->
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
forall
a0
 b0 : zerogpd_graph
        ((fun z : A^op => prod_0gpd I (fun i : I => yon_0gpd (x i) z)) a),
(a0 $-> b0) -> ?F a0 $-> ?F b0
    -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
zerogpd_graph
  ((fun z : A^op => prod_0gpd I (fun i : I => yon_0gpd (x i) z)) a) ->
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: zerogpd_graph
  ((fun z : A^op => prod_0gpd I (fun i0 : I => yon_0gpd (x i0) 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
forall
a0
 b0 : zerogpd_graph
        ((fun z : A^op => prod_0gpd I (fun i : I => yon_0gpd (x i) z)) a),
(a0 $-> b0) ->
(fun
   g : 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)
 :
 zerogpd_graph
   ((fun z : A^op => prod_0gpd I (fun i : I => yon_0gpd (x i) z)) b))
  a0 $->
(fun
   g : 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)
 :
 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: zerogpd_graph
  ((fun z : A^op => prod_0gpd I (fun i0 : I => yon_0gpd (x i0) 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: zerogpd_graph (prod_0gpd I (fun i0 : I => yon_0gpd (x i0) a))
i: I
fmap (fun z : A^op => prod_0gpd I (fun i0 : I => yon_0gpd (x i0) z)) f r i $->
fmap (fun z : A^op => prod_0gpd I (fun i0 : I => yon_0gpd (x i0) 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: zerogpd_graph (prod_0gpd I (fun i0 : I => yon_0gpd (x i0) 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: zerogpd_graph (prod_0gpd I (fun i0 : I => yon_0gpd (x i0) a))
i: I
fmap (fun z : A^op => prod_0gpd I (fun i0 : I => yon_0gpd (x i0) z)) 
  (Id a) r i $->
Id (prod_0gpd I (fun i0 : I => yon_0gpd (x i0) 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: zerogpd_graph (prod_0gpd I (fun i0 : I => yon_0gpd (x i0) a))
i: I
fmap (fun z : A^op => prod_0gpd I (fun i0 : I => yon_0gpd (x i0) z)) 
  (g $o f) r i $->
(fmap (fun z : A^op => prod_0gpd I (fun i0 : I => yon_0gpd (x i0) z)) g $o
 fmap (fun z : A^op => prod_0gpd I (fun i0 : I => yon_0gpd (x i0) 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 z0 : A^op => prod_0gpd I (fun i : I => yon_0gpd (x i) z0)) z $<~>
(fun z0 : A^op => prod_0gpd J (fun i : J => yon_0gpd (y i) z0)) 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 i0 : I, x i0 $<~> y (ie i0)
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: 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: zerogpd_graph (prod_0gpd I (fun i : I => yon_0gpd (x i) a))
j: J
transport (fun x0 : J => b $-> y x0) (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 x0 : J => a $-> y x0) (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: zerogpd_graph (prod_0gpd I (fun i : I => yon_0gpd (x i) a))
j: J
transport (fun x0 : J => b $-> y x0) 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 x0 : J => a $-> y x0) 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 x0 : I -> A => cat_prod I x0) f $==
fmap (fun x0 : I -> A => cat_prod I x0) 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 x0 : I -> A => cat_prod I x0) (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 x0 : I -> A => cat_prod I x0) (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 x0 : I -> A => cat_prod I x0) (g $o f) $==
fmap (fun x0 : I -> A => cat_prod I x0) g $o
fmap (fun x0 : I -> A => cat_prod I x0) 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 x0 : I -> A => cat_prod I x0) (g $o f) $==
cat_pr i $o
(fmap (fun x0 : I -> A => cat_prod I x0) g $o
 fmap (fun x0 : I -> A => cat_prod I x0) 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 x0 : I -> A => cat_prod I x0) (g $o f) $==
cat_pr i $o
(fmap (fun x0 : I -> A => cat_prod I x0) g $o
 fmap (fun x0 : I -> A => cat_prod I x0) 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 x0 : I -> A => cat_prod I x0) g $o
 fmap (fun x0 : I -> A => cat_prod I x0) 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 x0 : I -> A => cat_prod I x0) g $o
fmap (fun x0 : I -> A => cat_prod I x0) 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 x0 : I -> A => cat_prod I x0) g $o
fmap (fun x0 : I -> A => cat_prod I x0) 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 x0 : I -> A => cat_prod I x0) 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 x0 : I -> A => cat_prod I x0) 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.

(** *** An empty product is terminal *)

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 (Bool_rec _ x 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 (Bool_rec _ x y).

Section BinaryProducts.

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

  Definition cat_binprod' : A
    := cat_prod Bool (Bool_rec _ x 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 $-> Bool_rec A x y i
    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 $-> Bool_rec A x y true
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 $-> Bool_rec A x y false
    -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 $-> Bool_rec A x y true 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 $-> Bool_rec A x y false 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 =>
   match i as b return (z $-> Bool_rec A x y b) with
   | true => cat_pr1 $o f
   | false => cat_pr2 $o f
   end) $==
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 =>
   match i0 as b return (z $-> Bool_rec A x y b) with
   | true => cat_pr1 $o f
   | false => cat_pr2 $o f
   end) $==
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 =>
   match i as b return (z $-> Bool_rec A x y b) with
   | true => cat_pr1 $o f
   | false => cat_pr2 $o f
   end) $==
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 =>
   match i as b return (z $-> Bool_rec A x y b) with
   | true => cat_pr1 $o f
   | false => cat_pr2 $o f
   end) $==
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 =>
   match i as b return (z $-> Bool_rec A x y b) with
   | true => cat_pr1 $o f
   | false => cat_pr2 $o f
   end) $==
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 =>
   match i as b return (z $-> Bool_rec A x y b) with
   | true => cat_pr1 $o f
   | false => cat_pr2 $o f
   end) $==
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,
match i as b return (z $-> Bool_rec A x y b) with
| true => f
| false => g
end $==
match i as b return (z $-> Bool_rec A x y b) with
| true => f'
| false => g'
end
    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 (Bool_rec _ x 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 (Bool_rec A x 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 (Bool_rec A x 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' $-> Bool_rec A x 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 $-> Bool_rec A x 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 $-> Bool_rec A x 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' $-> Bool_rec A x 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' $-> Bool_rec A x y 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
cat_binprod' $-> Bool_rec A x y 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
cat_binprod' $-> Bool_rec A x y true 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' $-> Bool_rec A x y false 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 $-> Bool_rec A x 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 z0 : A, (z0 $-> x) -> (z0 $-> y) -> z0 $-> cat_binprod'
cat_binprod_beta_pr1: forall (z0 : A) (f0 : z0 $-> x) (g : z0 $-> y),
cat_pr1 $o cat_binprod_corec z0 f0 g $== f0
cat_binprod_beta_pr2: forall (z0 : A) (f0 : z0 $-> x) (g : z0 $-> y),
cat_pr2 $o cat_binprod_corec z0 f0 g $== g
cat_binprod_eta_pr: forall (z0 : A) (f0 g : z0 $-> cat_binprod'),
cat_pr1 $o f0 $== cat_pr1 $o g -> cat_pr2 $o f0 $== cat_pr2 $o g -> f0 $== g
z: A
f: forall i : Bool, z $-> Bool_rec A x 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 z0 : A, (z0 $-> x) -> (z0 $-> y) -> z0 $-> cat_binprod'
cat_binprod_beta_pr1: forall (z0 : A) (f0 : z0 $-> x) (g : z0 $-> y),
cat_pr1 $o cat_binprod_corec z0 f0 g $== f0
cat_binprod_beta_pr2: forall (z0 : A) (f0 : z0 $-> x) (g : z0 $-> y),
cat_pr2 $o cat_binprod_corec z0 f0 g $== g
cat_binprod_eta_pr: forall (z0 : A) (f0 g : z0 $-> cat_binprod'),
cat_pr1 $o f0 $== cat_pr1 $o g -> cat_pr2 $o f0 $== cat_pr2 $o g -> f0 $== g
z: A
f: forall i : Bool, z $-> Bool_rec A x 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 z0 : A, (z0 $-> x) -> (z0 $-> y) -> z0 $-> cat_binprod'
cat_binprod_beta_pr1: forall (z0 : A) (f0 : z0 $-> x) (g : z0 $-> y),
cat_pr1 $o cat_binprod_corec z0 f0 g $== f0
cat_binprod_beta_pr2: forall (z0 : A) (f0 : z0 $-> x) (g : z0 $-> y),
cat_pr2 $o cat_binprod_corec z0 f0 g $== g
cat_binprod_eta_pr: forall (z0 : A) (f0 g : z0 $-> cat_binprod'),
cat_pr1 $o f0 $== cat_pr1 $o g -> cat_pr2 $o f0 $== cat_pr2 $o g -> f0 $== g
z: A
f: forall i : Bool, z $-> Bool_rec A x 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 z0 : A, (z0 $-> x) -> (z0 $-> y) -> z0 $-> cat_binprod'
cat_binprod_beta_pr1: forall (z0 : A) (f0 : z0 $-> x) (g : z0 $-> y),
cat_pr1 $o cat_binprod_corec z0 f0 g $== f0
cat_binprod_beta_pr2: forall (z0 : A) (f0 : z0 $-> x) (g : z0 $-> y),
cat_pr2 $o cat_binprod_corec z0 f0 g $== g
cat_binprod_eta_pr: forall (z0 : A) (f0 g : z0 $-> cat_binprod'),
cat_pr1 $o f0 $== cat_pr1 $o g -> cat_pr2 $o f0 $== cat_pr2 $o g -> f0 $== g
z: A
f: forall i : Bool, z $-> Bool_rec A x 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 z0 : A, (z0 $-> x) -> (z0 $-> y) -> z0 $-> cat_binprod'
cat_binprod_beta_pr1: forall (z0 : A) (f0 : z0 $-> x) (g : z0 $-> y),
cat_pr1 $o cat_binprod_corec z0 f0 g $== f0
cat_binprod_beta_pr2: forall (z0 : A) (f0 : z0 $-> x) (g : z0 $-> y),
cat_pr2 $o cat_binprod_corec z0 f0 g $== g
cat_binprod_eta_pr: forall (z0 : A) (f0 g : z0 $-> cat_binprod'),
cat_pr1 $o f0 $== cat_pr1 $o g -> cat_pr2 $o f0 $== cat_pr2 $o g -> f0 $== g
z: A
f: forall i : Bool, z $-> Bool_rec A x 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 $-> Bool_rec A x y i) 
(i : Bool),
(fun i0 : Bool =>
 match i0 as b return (cat_binprod' $-> Bool_rec A x y b) with
 | true => cat_pr1
 | false => cat_pr2
 end) i $o
(fun (z0 : A) (f0 : forall i0 : Bool, z0 $-> Bool_rec A x 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 z0 : A, (z0 $-> x) -> (z0 $-> y) -> z0 $-> cat_binprod'
cat_binprod_beta_pr1: forall (z0 : A) (f0 : z0 $-> x) (g : z0 $-> y),
cat_pr1 $o cat_binprod_corec z0 f0 g $== f0
cat_binprod_beta_pr2: forall (z0 : A) (f0 : z0 $-> x) (g : z0 $-> y),
cat_pr2 $o cat_binprod_corec z0 f0 g $== g
cat_binprod_eta_pr: forall (z0 : A) (f0 g : z0 $-> cat_binprod'),
cat_pr1 $o f0 $== cat_pr1 $o g -> cat_pr2 $o f0 $== cat_pr2 $o g -> f0 $== g
z: A
f: forall i : Bool, z $-> Bool_rec A x 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 z0 : A, (z0 $-> x) -> (z0 $-> y) -> z0 $-> cat_binprod'
cat_binprod_beta_pr1: forall (z0 : A) (f0 : z0 $-> x) (g : z0 $-> y),
cat_pr1 $o cat_binprod_corec z0 f0 g $== f0
cat_binprod_beta_pr2: forall (z0 : A) (f0 : z0 $-> x) (g : z0 $-> y),
cat_pr2 $o cat_binprod_corec z0 f0 g $== g
cat_binprod_eta_pr: forall (z0 : A) (f0 g : z0 $-> cat_binprod'),
cat_pr1 $o f0 $== cat_pr1 $o g -> cat_pr2 $o f0 $== cat_pr2 $o g -> f0 $== g
z: A
f: forall i : Bool, z $-> Bool_rec A x 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 z0 : A, (z0 $-> x) -> (z0 $-> y) -> z0 $-> cat_binprod'
cat_binprod_beta_pr1: forall (z0 : A) (f0 : z0 $-> x) (g : z0 $-> y),
cat_pr1 $o cat_binprod_corec z0 f0 g $== f0
cat_binprod_beta_pr2: forall (z0 : A) (f0 : z0 $-> x) (g : z0 $-> y),
cat_pr2 $o cat_binprod_corec z0 f0 g $== g
cat_binprod_eta_pr: forall (z0 : A) (f0 g : z0 $-> cat_binprod'),
cat_pr1 $o f0 $== cat_pr1 $o g -> cat_pr2 $o f0 $== cat_pr2 $o g -> f0 $== g
z: A
f: forall i : Bool, z $-> Bool_rec A x 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 z0 : A, (z0 $-> x) -> (z0 $-> y) -> z0 $-> cat_binprod'
cat_binprod_beta_pr1: forall (z0 : A) (f0 : z0 $-> x) (g : z0 $-> y),
cat_pr1 $o cat_binprod_corec z0 f0 g $== f0
cat_binprod_beta_pr2: forall (z0 : A) (f0 : z0 $-> x) (g : z0 $-> y),
cat_pr2 $o cat_binprod_corec z0 f0 g $== g
cat_binprod_eta_pr: forall (z0 : A) (f0 g : z0 $-> cat_binprod'),
cat_pr1 $o f0 $== cat_pr1 $o g -> cat_pr2 $o f0 $== cat_pr2 $o g -> f0 $== g
z: A
f: forall i : Bool, z $-> Bool_rec A x 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 =>
  match i0 as b return (cat_binprod' $-> Bool_rec A x y b) with
  | true => cat_pr1
  | false => cat_pr2
  end) i $o
 f $==
 (fun i0 : Bool =>
  match i0 as b return (cat_binprod' $-> Bool_rec A x y b) with
  | true => cat_pr1
  | false => cat_pr2
  end) 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 z0 : A, (z0 $-> x) -> (z0 $-> y) -> z0 $-> cat_binprod'
cat_binprod_beta_pr1: forall (z0 : A) (f0 : z0 $-> x) (g0 : z0 $-> y),
cat_pr1 $o cat_binprod_corec z0 f0 g0 $== f0
cat_binprod_beta_pr2: forall (z0 : A) (f0 : z0 $-> x) (g0 : z0 $-> y),
cat_pr2 $o cat_binprod_corec z0 f0 g0 $== g0
cat_binprod_eta_pr: forall (z0 : A) (f0 g0 : z0 $-> cat_binprod'),
cat_pr1 $o f0 $== cat_pr1 $o g0 ->
cat_pr2 $o f0 $== cat_pr2 $o g0 -> f0 $== g0
z: A
f, g: z $-> cat_binprod'
p: forall i : Bool,
(fun i0 : Bool =>
 match i0 as b return (cat_binprod' $-> Bool_rec A x y b) with
 | true => cat_pr1
 | false => cat_pr2
 end) i $o
f $==
(fun i0 : Bool =>
 match i0 as b return (cat_binprod' $-> Bool_rec A x y b) with
 | true => cat_pr1
 | false => cat_pr2
 end) 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 z0 : A, (z0 $-> x) -> (z0 $-> y) -> z0 $-> cat_binprod'
cat_binprod_beta_pr1: forall (z0 : A) (f0 : z0 $-> x) (g0 : z0 $-> y),
cat_pr1 $o cat_binprod_corec z0 f0 g0 $== f0
cat_binprod_beta_pr2: forall (z0 : A) (f0 : z0 $-> x) (g0 : z0 $-> y),
cat_pr2 $o cat_binprod_corec z0 f0 g0 $== g0
cat_binprod_eta_pr: forall (z0 : A) (f0 g0 : z0 $-> cat_binprod'),
cat_pr1 $o f0 $== cat_pr1 $o g0 ->
cat_pr2 $o f0 $== cat_pr2 $o g0 -> f0 $== g0
z: A
f, g: z $-> cat_binprod'
p: forall i : Bool,
(fun i0 : Bool =>
 match i0 as b return (cat_binprod' $-> Bool_rec A x y b) with
 | true => cat_pr1
 | false => cat_pr2
 end) i $o
f $==
(fun i0 : Bool =>
 match i0 as b return (cat_binprod' $-> Bool_rec A x y b) with
 | true => cat_pr1
 | false => cat_pr2
 end) 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 z0 : A, (z0 $-> x) -> (z0 $-> y) -> z0 $-> cat_binprod'
cat_binprod_beta_pr1: forall (z0 : A) (f0 : z0 $-> x) (g0 : z0 $-> y),
cat_pr1 $o cat_binprod_corec z0 f0 g0 $== f0
cat_binprod_beta_pr2: forall (z0 : A) (f0 : z0 $-> x) (g0 : z0 $-> y),
cat_pr2 $o cat_binprod_corec z0 f0 g0 $== g0
cat_binprod_eta_pr: forall (z0 : A) (f0 g0 : z0 $-> cat_binprod'),
cat_pr1 $o f0 $== cat_pr1 $o g0 ->
cat_pr2 $o f0 $== cat_pr2 $o g0 -> f0 $== g0
z: A
f, g: z $-> cat_binprod'
p: forall i : Bool,
(fun i0 : Bool =>
 match i0 as b return (cat_binprod' $-> Bool_rec A x y b) with
 | true => cat_pr1
 | false => cat_pr2
 end) i $o
f $==
(fun i0 : Bool =>
 match i0 as b return (cat_binprod' $-> Bool_rec A x y b) with
 | true => cat_pr1
 | false => cat_pr2
 end) 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 z0 : A, (z0 $-> x) -> (z0 $-> y) -> z0 $-> cat_binprod'
cat_binprod_beta_pr1: forall (z0 : A) (f0 : z0 $-> x) (g0 : z0 $-> y),
cat_pr1 $o cat_binprod_corec z0 f0 g0 $== f0
cat_binprod_beta_pr2: forall (z0 : A) (f0 : z0 $-> x) (g0 : z0 $-> y),
cat_pr2 $o cat_binprod_corec z0 f0 g0 $== g0
cat_binprod_eta_pr: forall (z0 : A) (f0 g0 : z0 $-> cat_binprod'),
cat_pr1 $o f0 $== cat_pr1 $o g0 ->
cat_pr2 $o f0 $== cat_pr2 $o g0 -> f0 $== g0
z: A
f, g: z $-> cat_binprod'
p: forall i : Bool,
(fun i0 : Bool =>
 match i0 as b return (cat_binprod' $-> Bool_rec A x y b) with
 | true => cat_pr1
 | false => cat_pr2
 end) i $o
f $==
(fun i0 : Bool =>
 match i0 as b return (cat_binprod' $-> Bool_rec A x y b) with
 | true => cat_pr1
 | false => cat_pr2
 end) 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 z0 : A, (z0 $-> x) -> (z0 $-> y) -> z0 $-> cat_binprod'
cat_binprod_beta_pr1: forall (z0 : A) (f0 : z0 $-> x) (g0 : z0 $-> y),
cat_pr1 $o cat_binprod_corec z0 f0 g0 $== f0
cat_binprod_beta_pr2: forall (z0 : A) (f0 : z0 $-> x) (g0 : z0 $-> y),
cat_pr2 $o cat_binprod_corec z0 f0 g0 $== g0
cat_binprod_eta_pr: forall (z0 : A) (f0 g0 : z0 $-> cat_binprod'),
cat_pr1 $o f0 $== cat_pr1 $o g0 ->
cat_pr2 $o f0 $== cat_pr2 $o g0 -> f0 $== g0
z: A
f, g: z $-> cat_binprod'
p: forall i : Bool,
(fun i0 : Bool =>
 match i0 as b return (cat_binprod' $-> Bool_rec A x y b) with
 | true => cat_pr1
 | false => cat_pr2
 end) i $o
f $==
(fun i0 : Bool =>
 match i0 as b return (cat_binprod' $-> Bool_rec A x y b) with
 | true => cat_pr1
 | false => cat_pr2
 end) 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 =>
 match i0 as b return (cat_binprod (x true) (x false) $-> x b) with
 | true => cat_pr1
 | false => cat_pr2
 end) 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 =>
  match i0 as b return (cat_binprod (x true) (x false) $-> x b) with
  | true => cat_pr1
  | false => cat_pr2
  end) i $o
 f $==
 (fun i0 : Bool =>
  match i0 as b return (cat_binprod (x true) (x false) $-> x b) with
  | true => cat_pr1
  | false => cat_pr2
  end) 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 =>
 match i0 as b return (cat_binprod (x true) (x false) $-> x b) with
 | true => cat_pr1
 | false => cat_pr2
 end) i $o
f $==
(fun i0 : Bool =>
 match i0 as b return (cat_binprod (x true) (x false) $-> x b) with
 | true => cat_pr1
 | false => cat_pr2
 end) 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 =>
 match i0 as b return (cat_binprod (x true) (x false) $-> x b) with
 | true => cat_pr1
 | false => cat_pr2
 end) i $o
f $==
(fun i0 : Bool =>
 match i0 as b return (cat_binprod (x true) (x false) $-> x b) with
 | true => cat_pr1
 | false => cat_pr2
 end) 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 =>
 match i0 as b return (cat_binprod (x true) (x false) $-> x b) with
 | true => cat_pr1
 | false => cat_pr2
 end) i $o
f $==
(fun i0 : Bool =>
 match i0 as b return (cat_binprod (x true) (x false) $-> x b) with
 | true => cat_pr1
 | false => cat_pr2
 end) 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 =>
 match i0 as b return (cat_binprod (x true) (x false) $-> x b) with
 | true => cat_pr1
 | false => cat_pr2
 end) i $o
f $==
(fun i0 : Bool =>
 match i0 as b return (cat_binprod (x true) (x false) $-> x b) with
 | true => cat_pr1
 | false => cat_pr2
 end) 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 =>
 match i0 as b return (cat_binprod (x true) (x false) $-> x b) with
 | true => cat_pr1
 | false => cat_pr2
 end) i $o
f $==
(fun i0 : Bool =>
 match i0 as b return (cat_binprod (x true) (x false) $-> x b) with
 | true => cat_pr1
 | false => cat_pr2
 end) 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 i0 : I + J, z $-> sum_ind (fun _ : I + J => A) x y i0
i: I
cat_pr i $o cat_pr1 $o
cat_binprod_corec (cat_prod_corec I (fun x0 : I => f (inl x0)))
  (cat_prod_corec J (fun x0 : J => f (inr x0))) $==
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 x0 : I => f (inl x0)))
  (cat_prod_corec J (fun x0 : J => f (inr x0))) $==
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 i0 : I + J, z $-> sum_ind (fun _ : I + J => A) x y i0
i: I
cat_pr i $o cat_pr1 $o
cat_binprod_corec (cat_prod_corec I (fun x0 : I => f (inl x0)))
  (cat_prod_corec J (fun x0 : J => f (inr x0))) $==
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 i0 : I + J, z $-> sum_ind (fun _ : I + J => A) x y i0
i: I
cat_pr i $o
(cat_pr1 $o
 cat_binprod_corec (cat_prod_corec I (fun x0 : I => f (inl x0)))
   (cat_prod_corec J (fun x0 : J => f (inr x0)))) $==
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 i0 : I + J, z $-> sum_ind (fun _ : I + J => A) x y i0
i: I
cat_pr i $o cat_prod_corec I (fun x0 : I => f (inl x0)) $== 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 x0 : I => f (inl x0)))
  (cat_prod_corec J (fun x0 : J => f (inr x0))) $==
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 x0 : I => f (inl x0)))
   (cat_prod_corec J (fun x0 : J => f (inr x0)))) $==
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 x0 : J => f (inr x0)) $== 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 i0 : I + J,
(fun i1 : I + J =>
 match
   i1 as s
   return
     (cat_binprod (cat_prod I x) (cat_prod J y) $->
      sum_ind (fun _ : I + J => A) x y s)
 with
 | inl i2 => (fun i3 : I => cat_pr i3 $o cat_pr1) i2
 | inr j => (fun j0 : J => cat_pr j0 $o cat_pr2) j
 end) i0 $o
f $==
(fun i1 : I + J =>
 match
   i1 as s
   return
     (cat_binprod (cat_prod I x) (cat_prod J y) $->
      sum_ind (fun _ : I + J => A) x y s)
 with
 | inl i2 => (fun i3 : I => cat_pr i3 $o cat_pr1) i2
 | inr j => (fun j0 : J => cat_pr j0 $o cat_pr2) j
 end) i0 $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 j0 => (fun j1 : J => cat_pr j1 $o cat_pr2) j0
 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 j0 => (fun j1 : J => cat_pr j1 $o cat_pr2) j0
 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 f0 : z $-> y => cat_binprod_corec f0 g) f $->
(fun f0 : z $-> y => cat_binprod_corec f0 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 g0 : z $-> x => cat_binprod_corec f g0) g $->
(fun g0 : z $-> x => cat_binprod_corec f g0) 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 [Bool_rec _ x 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) 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 x0 y0 : A => cat_binprod x0 y0) (x, y) $->
uncurry (flip (fun x0 y0 : A => cat_binprod x0 y0)) (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.

(** *** Binary product gives a symmetric monoidal structure *)

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 b0 : A => (a', b0)) cat_pr2) true $o
   f)
  (fmap (uncurry (Bool_rec A)) (fmap (fun b0 : A => (a', b0)) cat_pr2) false $o
   fmap11 cat_binprod g h) $==
fmap11 cat_binprod
  (f $o
   fmap (uncurry (Bool_rec A)) (fmap (fun b0 : A => (a, b0)) cat_pr2) true)
  (h $o
   fmap (uncurry (Bool_rec A)) (fmap (fun b0 : A => (a, b0)) 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 b0 : A => (a', b0)) cat_pr2) true $o f $==
f $o fmap (uncurry (Bool_rec A)) (fmap (fun b0 : A => (a, b0)) 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 b0 : A => (a', b0)) cat_pr2) false $o
fmap11 cat_binprod g h $==
h $o fmap (uncurry (Bool_rec A)) (fmap (fun b0 : A => (a, b0)) 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 b0 : A => (a', b0)) cat_pr2) false $o
fmap11 cat_binprod g h $==
h $o fmap (uncurry (Bool_rec A)) (fmap (fun b0 : A => (a, b0)) cat_pr2) false
      napply cat_binprod_beta_pr2.
  Defined.

  Local Existing Instance symmetricbraiding_binprod.

  #[export] 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 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))
  b $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
      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.

(** ** Examples *)

(** *** 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. *)

(** 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 i0 : I, x i0
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 i0 : I, A $-> x i0
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 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
a: A
f a = g a
    exact (path_forall _ _ (fun i => p i a)).
Defined.

(** It follows that [Type] has binary products, but we prove this separately to avoid [Funext]. *)
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.

(** *** Products in ZeroGpd *)

(** Since we use products in ZeroGpd to define general products, we must depend on ZeroGroupoid, which means that these instances have to live here. *)

(** Note that this does not rely on [Funext], since the 1-cells in the product 0-groupoid are *defined* to be homotopies. *)
Instance hasallproducts_0gpd : HasAllProducts ZeroGpd.HasAllProducts ZeroGpd
Proof.HasAllProducts ZeroGpd
  intros I x.I: Type
x: I -> ZeroGpd
Product I x
  snapply Build_Product.I: Type
x: I -> ZeroGpd
ZeroGpd
I: Type
x: I -> ZeroGpd
forall i : I, ?cat_prod $-> x i
I: Type
x: I -> ZeroGpd
forall z : ZeroGpd, (forall i : I, z $-> x i) -> z $-> ?cat_prod
I: Type
x: I -> ZeroGpd
forall (z : ZeroGpd) (f : forall i : I, z $-> x i) 
(i : I), ?cat_pr i $o ?cat_prod_corec z f $== f i
I: Type
x: I -> ZeroGpd
forall (z : ZeroGpd) (f g : z $-> ?cat_prod),
(forall i : I, ?cat_pr i $o f $== ?cat_pr i $o g) -> f $== g
  -I: Type
x: I -> ZeroGpd
ZeroGpd exact (prod_0gpd I x).
  -I: Type
x: I -> ZeroGpd
forall i : I, prod_0gpd I x $-> x i exact prod_0gpd_pr.
  -I: Type
x: I -> ZeroGpd
forall z : ZeroGpd, (forall i : I, z $-> x i) -> z $-> prod_0gpd I x intro G.I: Type
x: I -> ZeroGpd
G: ZeroGpd
(forall i : I, G $-> x i) -> G $-> prod_0gpd I x apply equiv_prod_0gpd_corec.
  -I: Type
x: I -> ZeroGpd
forall (z : ZeroGpd) (f : forall i : I, z $-> x i) 
(i : I),
prod_0gpd_pr i $o
(fun G : ZeroGpd => let X := equiv_fun equiv_prod_0gpd_corec in X) z f $==
f i reflexivity.
  -I: Type
x: I -> ZeroGpd
forall (z : ZeroGpd) (f g : z $-> prod_0gpd I x),
(forall i : I, prod_0gpd_pr i $o f $== prod_0gpd_pr i $o g) -> f $== g intros G f g p.I: Type
x: I -> ZeroGpd
G: ZeroGpd
f, g: G $-> prod_0gpd I x
p: forall i : I, prod_0gpd_pr i $o f $== prod_0gpd_pr i $o g
f $== g  intro a.I: Type
x: I -> ZeroGpd
G: ZeroGpd
f, g: G $-> prod_0gpd I x
p: forall i : I, prod_0gpd_pr i $o f $== prod_0gpd_pr i $o g
a: zerogpd_graph G
f a $-> g a  intro i.I: Type
x: I -> ZeroGpd
G: ZeroGpd
f, g: G $-> prod_0gpd I x
p: forall i0 : I, prod_0gpd_pr i0 $o f $== prod_0gpd_pr i0 $o g
a: zerogpd_graph G
i: I
f a i $-> g a i
    exact (p i a).
Defined.

(** This follows from the previous result, but we prove it separately because using these custom binary products can make certain things easier, and can sometimes avoid the need to use [Funext]. *)
Instance hasbinaryproducts_0gpd : HasBinaryProducts ZeroGpd.HasBinaryProducts ZeroGpd
Proof.HasBinaryProducts ZeroGpd
  intros G H.G, H: ZeroGpd
BinaryProduct G H
  snapply Build_BinaryProduct.G, H: ZeroGpd
ZeroGpd
G, H: ZeroGpd
?cat_binprod' $-> G
G, H: ZeroGpd
?cat_binprod' $-> H
G, H: ZeroGpd
forall z : ZeroGpd, (z $-> G) -> (z $-> H) -> z $-> ?cat_binprod'
G, H: ZeroGpd
forall (z : ZeroGpd) (f : z $-> G) (g : z $-> H),
?cat_pr1 $o ?cat_binprod_corec z f g $== f
G, H: ZeroGpd
forall (z : ZeroGpd) (f : z $-> G) (g : z $-> H),
?cat_pr2 $o ?cat_binprod_corec z f g $== g
G, H: ZeroGpd
forall (z : ZeroGpd) (f g : z $-> ?cat_binprod'),
?cat_pr1 $o f $== ?cat_pr1 $o g -> ?cat_pr2 $o f $== ?cat_pr2 $o g -> f $== g
  -G, H: ZeroGpd
ZeroGpd exact (binprod_0gpd G H).
  -G, H: ZeroGpd
binprod_0gpd G H $-> G apply binprod_0gpd_pr1.
  -G, H: ZeroGpd
binprod_0gpd G H $-> H apply binprod_0gpd_pr2.
  -G, H: ZeroGpd
forall z : ZeroGpd, (z $-> G) -> (z $-> H) -> z $-> binprod_0gpd G H intro K.G, H, K: ZeroGpd
(K $-> G) -> (K $-> H) -> K $-> binprod_0gpd G H exact (fun f g => (equiv_binprod_0gpd_corec G H K (f, g))).
  -G, H: ZeroGpd
forall (z : ZeroGpd) (f : z $-> G) (g : z $-> H),
binprod_0gpd_pr1 G H $o
(fun (K : ZeroGpd) (f0 : K $-> G) (g0 : K $-> H) =>
 equiv_binprod_0gpd_corec G H K (f0, g0)) z f g $==
f reflexivity.
  -G, H: ZeroGpd
forall (z : ZeroGpd) (f : z $-> G) (g : z $-> H),
binprod_0gpd_pr2 G H $o
(fun (K : ZeroGpd) (f0 : K $-> G) (g0 : K $-> H) =>
 equiv_binprod_0gpd_corec G H K (f0, g0)) z f g $==
g reflexivity.
  -G, H: ZeroGpd
forall (z : ZeroGpd) (f g : z $-> binprod_0gpd G H),
binprod_0gpd_pr1 G H $o f $== binprod_0gpd_pr1 G H $o g ->
binprod_0gpd_pr2 G H $o f $== binprod_0gpd_pr2 G H $o g -> f $== g intros K f g p q.G, H, K: ZeroGpd
f, g: K $-> binprod_0gpd G H
p: binprod_0gpd_pr1 G H $o f $== binprod_0gpd_pr1 G H $o g
q: binprod_0gpd_pr2 G H $o f $== binprod_0gpd_pr2 G H $o g
f $== g intro k.G, H, K: ZeroGpd
f, g: K $-> binprod_0gpd G H
p: binprod_0gpd_pr1 G H $o f $== binprod_0gpd_pr1 G H $o g
q: binprod_0gpd_pr2 G H $o f $== binprod_0gpd_pr2 G H $o g
k: zerogpd_graph K
f k $-> g k exact (p k, q k).
Defined.