Products.v

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

(** * Categories with products *)

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

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

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

(** A convenience wrapper for building products *)
Definition Build_Product (I : Type) {A : Type} `{Is1Cat A} {x : I -> A}
  (cat_prod : A) (cat_pr : forall i : I, cat_prod $-> x i)
  (cat_prod_corec : forall z : A,
    (forall i : I, z $-> x i) -> (z $-> cat_prod))
  (cat_prod_beta_pr : forall (z : A) (f : forall i, z $-> x i) (i : I),
    cat_pr i $o cat_prod_corec z f $== f i)
  (cat_prod_eta_pr : forall (z : A) (f g : z $-> cat_prod),
    (forall i : I, cat_pr i $o f $== cat_pr i $o g) -> f $== g)
  : Product I x.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x: I -> A
cat_prod: A
cat_pr: forall i : I, cat_prod $-> x i
cat_prod_corec: forall z : A,
(forall i : I, z $-> x i) ->
z $-> cat_prod
cat_prod_beta_pr: forall (z : A)
(f : forall i : I, z $-> x i)
(i : I),
cat_pr i $o cat_prod_corec z f $==
f i
cat_prod_eta_pr: forall (z : A)
(f g : z $-> cat_prod),
(forall i : I,
 cat_pr i $o f $== cat_pr i $o g) ->
f $== g
Product I x
Proof.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x: I -> A
cat_prod: A
cat_pr: forall i : I, cat_prod $-> x i
cat_prod_corec: forall z : A,
(forall i : I, z $-> x i) ->
z $-> cat_prod
cat_prod_beta_pr: forall (z : A)
(f : forall i : I, z $-> x i)
(i : I),
cat_pr i $o cat_prod_corec z f $==
f i
cat_prod_eta_pr: forall (z : A)
(f g : z $-> cat_prod),
(forall i : I,
 cat_pr i $o f $== cat_pr i $o g) ->
f $== g
Product I x
  snrapply (Build_Product' I A _ _ _ _ _ cat_prod cat_pr).I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x: I -> A
cat_prod: A
cat_pr: forall i : I, cat_prod $-> x i
cat_prod_corec: forall z : A,
(forall i : I, z $-> x i) ->
z $-> cat_prod
cat_prod_beta_pr: forall (z : A)
(f : forall i : I, z $-> x i)
(i : I),
cat_pr i $o cat_prod_corec z f $==
f i
cat_prod_eta_pr: forall (z : A)
(f g : z $-> cat_prod),
(forall i : I,
 cat_pr i $o f $== cat_pr i $o g) ->
f $== g
forall z : A,
CatIsEquiv (cat_prod_corec_inv cat_prod x z cat_pr)
  intros z.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x: I -> A
cat_prod: A
cat_pr: forall i : I, cat_prod $-> x i
cat_prod_corec: forall z : A,
(forall i : I, z $-> x i) ->
z $-> cat_prod
cat_prod_beta_pr: forall (z : A)
(f : forall i : I, z $-> x i)
(i : I),
cat_pr i $o cat_prod_corec z f $==
f i
cat_prod_eta_pr: forall (z : A)
(f g : z $-> cat_prod),
(forall i : I,
 cat_pr i $o f $== cat_pr i $o g) ->
f $== g
z: A
CatIsEquiv (cat_prod_corec_inv cat_prod x z cat_pr)
  nrapply isequiv_0gpd_issurjinj.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x: I -> A
cat_prod: A
cat_pr: forall i : I, cat_prod $-> x i
cat_prod_corec: forall z : A,
(forall i : I, z $-> x i) ->
z $-> cat_prod
cat_prod_beta_pr: forall (z : A)
(f : forall i : I, z $-> x i)
(i : I),
cat_pr i $o cat_prod_corec z f $==
f i
cat_prod_eta_pr: forall (z : A)
(f g : z $-> cat_prod),
(forall i : I,
 cat_pr i $o f $== cat_pr i $o g) ->
f $== g
z: A
IsSurjInj (cat_prod_corec_inv cat_prod x z cat_pr)
  nrapply Build_IsSurjInj.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x: I -> A
cat_prod: A
cat_pr: forall i : I, cat_prod $-> x i
cat_prod_corec: forall z : A,
(forall i : I, z $-> x i) ->
z $-> cat_prod
cat_prod_beta_pr: forall (z : A)
(f : forall i : I, z $-> x i)
(i : I),
cat_pr i $o cat_prod_corec z f $==
f i
cat_prod_eta_pr: forall (z : A)
(f g : z $-> cat_prod),
(forall i : I,
 cat_pr i $o f $== cat_pr i $o g) ->
f $== g
z: A
SplEssSurj (cat_prod_corec_inv cat_prod x z cat_pr)
I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x: I -> A
cat_prod: A
cat_pr: forall i : I, cat_prod $-> x i
cat_prod_corec: forall z : A,
(forall i : I, z $-> x i) ->
z $-> cat_prod
cat_prod_beta_pr: forall (z : A)
(f : forall i : I, z $-> x i)
(i : I),
cat_pr i $o cat_prod_corec z f $==
f i
cat_prod_eta_pr: forall (z : A)
(f g : z $-> cat_prod),
(forall i : I,
 cat_pr i $o f $== cat_pr i $o g) ->
f $== g
z: A
forall x0 y : yon_0gpd cat_prod z,
cat_prod_corec_inv cat_prod x z cat_pr x0 $==
cat_prod_corec_inv cat_prod x z cat_pr y -> 
x0 $== y
  -I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x: I -> A
cat_prod: A
cat_pr: forall i : I, cat_prod $-> x i
cat_prod_corec: forall z : A,
(forall i : I, z $-> x i) ->
z $-> cat_prod
cat_prod_beta_pr: forall (z : A)
(f : forall i : I, z $-> x i)
(i : I),
cat_pr i $o cat_prod_corec z f $==
f i
cat_prod_eta_pr: forall (z : A)
(f g : z $-> cat_prod),
(forall i : I,
 cat_pr i $o f $== cat_pr i $o g) ->
f $== g
z: A
SplEssSurj (cat_prod_corec_inv cat_prod x z cat_pr) intros f.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x: I -> A
cat_prod: A
cat_pr: forall i : I, cat_prod $-> x i
cat_prod_corec: forall z : A,
(forall i : I, z $-> x i) ->
z $-> cat_prod
cat_prod_beta_pr: forall (z : A)
(f : forall i : I, z $-> x i)
(i : I),
cat_pr i $o cat_prod_corec z f $==
f i
cat_prod_eta_pr: forall (z : A)
(f g : z $-> cat_prod),
(forall i : I,
 cat_pr i $o f $== cat_pr i $o g) ->
f $== g
z: A
f: prod_0gpd I (fun i : I => yon_0gpd (x i) z)
{a : yon_0gpd cat_prod z &
cat_prod_corec_inv cat_prod x z cat_pr a $== f}
    exists (cat_prod_corec z f).I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x: I -> A
cat_prod: A
cat_pr: forall i : I, cat_prod $-> x i
cat_prod_corec: forall z : A,
(forall i : I, z $-> x i) ->
z $-> cat_prod
cat_prod_beta_pr: forall (z : A)
(f : forall i : I, z $-> x i)
(i : I),
cat_pr i $o cat_prod_corec z f $==
f i
cat_prod_eta_pr: forall (z : A)
(f g : z $-> cat_prod),
(forall i : I,
 cat_pr i $o f $== cat_pr i $o g) ->
f $== g
z: A
f: prod_0gpd I (fun i : I => yon_0gpd (x i) z)
cat_prod_corec_inv cat_prod x z cat_pr
  (cat_prod_corec z f) $== f
    intros i.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x: I -> A
cat_prod: A
cat_pr: forall i : I, cat_prod $-> x i
cat_prod_corec: forall z : A,
(forall i : I, z $-> x i) ->
z $-> cat_prod
cat_prod_beta_pr: forall (z : A)
(f : forall i : I, z $-> x i)
(i : I),
cat_pr i $o cat_prod_corec z f $==
f i
cat_prod_eta_pr: forall (z : A)
(f g : z $-> cat_prod),
(forall i : I,
 cat_pr i $o f $== cat_pr i $o g) ->
f $== g
z: A
f: prod_0gpd I (fun i : I => yon_0gpd (x i) z)
i: I
cat_prod_corec_inv cat_prod x z cat_pr
  (cat_prod_corec z f) i $-> f i
    nrapply cat_prod_beta_pr.
  -I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x: I -> A
cat_prod: A
cat_pr: forall i : I, cat_prod $-> x i
cat_prod_corec: forall z : A,
(forall i : I, z $-> x i) ->
z $-> cat_prod
cat_prod_beta_pr: forall (z : A)
(f : forall i : I, z $-> x i)
(i : I),
cat_pr i $o cat_prod_corec z f $==
f i
cat_prod_eta_pr: forall (z : A)
(f g : z $-> cat_prod),
(forall i : I,
 cat_pr i $o f $== cat_pr i $o g) ->
f $== g
z: A
forall x0 y : yon_0gpd cat_prod z,
cat_prod_corec_inv cat_prod x z cat_pr x0 $==
cat_prod_corec_inv cat_prod x z cat_pr y -> x0 $== y intros f g p.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
x: I -> A
cat_prod: A
cat_pr: forall i : I, cat_prod $-> x i
cat_prod_corec: forall z : A,
(forall i : I, z $-> x i) ->
z $-> cat_prod
cat_prod_beta_pr: forall (z : A)
(f : forall i : I, z $-> x i)
(i : I),
cat_pr i $o cat_prod_corec z f $==
f i
cat_prod_eta_pr: forall (z : A)
(f g : z $-> cat_prod),
(forall i : I,
 cat_pr i $o f $== cat_pr i $o g) ->
f $== g
z: A
f, g: 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 nrapply 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))
    snrapply 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
    snrapply Build_Morphism_0Gpd.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
prod_0gpd I (fun i : I => yon_0gpd (x i) a) ->
prod_0gpd I (fun i : I => yon_0gpd (x i) b)
I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
a, b: A^op
f: a $-> b
Is0Functor ?fun_0gpd
    -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
prod_0gpd I (fun i : I => yon_0gpd (x i) a) ->
prod_0gpd I (fun i : I => yon_0gpd (x i) 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: prod_0gpd I (fun i : I => yon_0gpd (x i) a)
i: I
yon_0gpd (x i) b
      exact (f $o g i).
    -I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
a, b: A^op
f: a $-> b
Is0Functor
  (fun g : prod_0gpd I (fun i : I => yon_0gpd (x i) a)
   =>
   (fun i : I => f $o g i)
   :
   prod_0gpd I (fun i : I => yon_0gpd (x i) b)) snrapply Build_Is0Functor.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
a, b: A^op
f: a $-> b
forall
a0 b0 : prod_0gpd I (fun i : I => yon_0gpd (x i) a),
(a0 $-> b0) ->
(fun g : prod_0gpd I (fun i : I => yon_0gpd (x i) a)
 =>
 (fun i : I => f $o g i)
 :
 prod_0gpd I (fun i : I => yon_0gpd (x i) b)) a0 $->
(fun g : prod_0gpd I (fun i : I => yon_0gpd (x i) a)
 =>
 (fun i : I => f $o g i)
 :
 prod_0gpd I (fun i : I => yon_0gpd (x i) 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: prod_0gpd I (fun i : I => yon_0gpd (x i) 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))
    snrapply 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: prod_0gpd I (fun i : I => yon_0gpd (x i) a)
i: I
fmap
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z)) f r i $->
fmap
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z)) g r i
      refine (_ $@L _).I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
a, b: A^op
f, g: a $-> b
p: f $== g
r: prod_0gpd I (fun i : I => yon_0gpd (x i) a)
i: I
f $== g
      exact p.
    -I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
forall a : A^op,
fmap
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z)) (Id a) $==
Id
  ((fun z : A^op =>
    prod_0gpd I (fun i : I => yon_0gpd (x i) z)) a) intros a r i.I, A: Type
x: I -> A
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: Product I x
a: A^op
r: prod_0gpd I (fun i : I => yon_0gpd (x i) a)
i: I
fmap
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z)) (Id a)
  r i $->
Id (prod_0gpd I (fun i : I => yon_0gpd (x i) a)) r i
      nrapply 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: prod_0gpd I (fun i : I => yon_0gpd (x i) a)
i: I
fmap
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z))
  (g $o f) r i $->
(fmap
   (fun z : A^op =>
    prod_0gpd I (fun i : I => yon_0gpd (x i) z)) g $o
 fmap
   (fun z : A^op =>
    prod_0gpd I (fun i : I => yon_0gpd (x i) z)) f) r
  i
      nrapply 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))
    snrapply 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; nrapply 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'
    nrapply (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 nrapply 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
  nrapply 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))
  (FunctorCat.fun11_fun A^op ZeroGpd
     (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))
  snrapply Build_NatEquiv.I, J: Type
ie: I <~> J
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
x: I -> A
Product0: Product I x
y: J -> A
Product1: Product J y
e: forall i : I, x i $<~> y (ie i)
forall a : A^op,
(fun z : A^op =>
 prod_0gpd I (fun i : I => yon_0gpd (x i) z)) a $<~>
(fun z : A^op =>
 prod_0gpd J (fun i : J => yon_0gpd (y i) z)) a
I, J: Type
ie: I <~> J
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
x: I -> A
Product0: Product I x
y: J -> A
Product1: Product J y
e: forall i : I, x i $<~> y (ie i)
Is1Natural
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z))
  (fun z : A^op =>
   prod_0gpd J (fun i : J => yon_0gpd (y i) z))
  (fun a : A^op => ?e a)
  -I, J: Type
ie: I <~> J
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
x: I -> A
Product0: Product I x
y: J -> A
Product1: Product J y
e: forall i : I, x i $<~> y (ie i)
forall a : A^op,
(fun z : A^op =>
 prod_0gpd I (fun i : I => yon_0gpd (x i) z)) a $<~>
(fun z : A^op =>
 prod_0gpd J (fun i : J => yon_0gpd (y i) z)) a intros z.I, J: Type
ie: I <~> J
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
x: I -> A
Product0: Product I x
y: J -> A
Product1: Product J y
e: forall i : I, x i $<~> y (ie i)
z: A^op
(fun z : A^op =>
 prod_0gpd I (fun i : I => yon_0gpd (x i) z)) z $<~>
(fun z : A^op =>
 prod_0gpd J (fun i : J => yon_0gpd (y i) z)) z
    nrapply (cate_prod_0gpd ie).I, J: Type
ie: I <~> J
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
x: I -> A
Product0: Product I x
y: J -> A
Product1: Product J y
e: forall i : I, x i $<~> y (ie i)
z: A^op
forall i : I,
yon_0gpd (x i) z $<~> yon_0gpd (y (ie i)) z
    intros i.I, J: Type
ie: I <~> J
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
x: I -> A
Product0: Product I x
y: J -> A
Product1: Product J y
e: forall i : I, x i $<~> y (ie i)
z: A^op
i: I
yon_0gpd (x i) z $<~> yon_0gpd (y (ie i)) z
    exact (natequiv_yon_equiv_0gpd (e i) _).
  -I, J: Type
ie: I <~> J
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
x: I -> A
Product0: Product I x
y: J -> A
Product1: Product J y
e: forall i : I, x i $<~> y (ie i)
Is1Natural
  (fun z : A^op =>
   prod_0gpd I (fun i : I => yon_0gpd (x i) z))
  (fun z : A^op =>
   prod_0gpd J (fun i : J => yon_0gpd (y i) z))
  (fun a : A^op =>
   (fun z : A^op =>
    cate_prod_0gpd ie (fun i : I => yon_0gpd (x i) z)
      (fun i : J => yon_0gpd (y i) z)
      (fun i : I => natequiv_yon_equiv_0gpd (e i) z))
     a) 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: 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: prod_0gpd I (fun i : I => yon_0gpd (x i) a)
j: J
transport (fun x : J => b $-> y x) (eisretr ie j)
  (cate_fun' (x (ie^-1 j)) (y (ie (ie^-1 j)))
     (e (ie^-1 j)) $o (g (ie^-1 j) $o f)) $->
transport (fun x : J => a $-> y x) (eisretr ie j)
  (cate_fun' (x (ie^-1 j)) (y (ie (ie^-1 j)))
     (e (ie^-1 j)) $o g (ie^-1 j)) $o f
    destruct (eisretr ie j).I, J: Type
ie: I <~> J
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
x: I -> A
Product0: Product I x
y: J -> A
Product1: Product J y
e: forall i : I, x i $<~> y (ie i)
a, b: A^op
f: a $-> b
g: prod_0gpd I (fun i : I => yon_0gpd (x i) a)
j: J
transport (fun x : J => b $-> y x) 1
  (cate_fun' (x (ie^-1 j)) (y (ie (ie^-1 j)))
     (e (ie^-1 j)) $o (g (ie^-1 j) $o f)) $->
transport (fun x : J => a $-> y x) 1
  (cate_fun' (x (ie^-1 j)) (y (ie (ie^-1 j)))
     (e (ie^-1 j)) $o g (ie^-1 j)) $o f
    exact (cat_assoc_opp _ _ _).
Defined.

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

(** *** Existence of products *)

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

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

(** *** Product functor *)

Global 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)
  nrapply 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.

Global 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)
  nrapply Build_Is1Functor.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
forall (a b : I -> A) (f g : a $-> b),
f $== g ->
fmap (fun x : I -> A => cat_prod I x) f $==
fmap (fun x : I -> A => cat_prod I x) g
I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
forall a : I -> A,
fmap (fun x : I -> A => cat_prod I x) (Id a) $==
Id (cat_prod I a)
I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
forall (a b c : I -> A) 
(f : a $-> b) (g : b $-> c),
fmap (fun x : I -> A => cat_prod I x) (g $o f) $==
fmap (fun x : I -> A => cat_prod I x) g $o
fmap (fun x : I -> A => cat_prod I x) f
  -I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
forall (a b : I -> A) (f g : a $-> b),
f $== g ->
fmap (fun x : I -> A => cat_prod I x) f $==
fmap (fun x : I -> A => cat_prod I x) g intros x y f g p.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
x, y: I -> A
f, g: x $-> y
p: f $== g
fmap (fun x : I -> A => cat_prod I x) f $==
fmap (fun x : I -> A => cat_prod I x) g
    exact (cat_prod_corec_eta I (fun i => p i $@R cat_pr i)).
  -I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
forall a : I -> A,
fmap (fun x : I -> A => cat_prod I x) (Id a) $==
Id (cat_prod I a) intros x.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
x: I -> A
fmap (fun x : I -> A => cat_prod I x) (Id x) $==
Id (cat_prod I x)
    nrefine (_ $@ (cat_prod_eta I (Id _))).I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
x: I -> A
fmap (fun x : I -> A => cat_prod I x) (Id x) $==
cat_prod_corec I
  (fun i : I => cat_pr i $o Id (cat_prod I x))
    exact (cat_prod_corec_eta I (fun i => cat_idl _ $@ (cat_idr _)^$)).
  -I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
forall (a b c : I -> A) (f : a $-> b) (g : b $-> c),
fmap (fun x : I -> A => cat_prod I x) (g $o f) $==
fmap (fun x : I -> A => cat_prod I x) g $o
fmap (fun x : I -> A => cat_prod I x) f intros x y z f g.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
x, y, z: I -> A
f: x $-> y
g: y $-> z
fmap (fun x : I -> A => cat_prod I x) (g $o f) $==
fmap (fun x : I -> A => cat_prod I x) g $o
fmap (fun x : I -> A => cat_prod I x) f
    nrapply cat_prod_pr_eta.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
x, y, z: I -> A
f: x $-> y
g: y $-> z
forall i : I,
cat_pr i $o
fmap (fun x : I -> A => cat_prod I x) (g $o f) $==
cat_pr i $o
(fmap (fun x : I -> A => cat_prod I x) g $o
 fmap (fun x : I -> A => cat_prod I x) f)
    intros i.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
x, y, z: I -> A
f: x $-> y
g: y $-> z
i: I
cat_pr i $o
fmap (fun x : I -> A => cat_prod I x) (g $o f) $==
cat_pr i $o
(fmap (fun x : I -> A => cat_prod I x) g $o
 fmap (fun x : I -> A => cat_prod I x) f)
    nrefine (cat_prod_beta _ _ _ $@ _).I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
x, y, z: I -> A
f: x $-> y
g: y $-> z
i: I
(g $o f) i $o cat_pr i $==
cat_pr i $o
(fmap (fun x : I -> A => cat_prod I x) g $o
 fmap (fun x : I -> A => cat_prod I x) f)
    nrefine (_ $@ cat_assoc _ _ _).I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
x, y, z: I -> A
f: x $-> y
g: y $-> z
i: I
(g $o f) i $o cat_pr i $==
cat_pr i $o fmap (fun x : I -> A => cat_prod I x) g $o
fmap (fun x : I -> A => cat_prod I x) f
    symmetry.I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
x, y, z: I -> A
f: x $-> y
g: y $-> z
i: I
cat_pr i $o fmap (fun x : I -> A => cat_prod I x) g $o
fmap (fun x : I -> A => cat_prod I x) f $==
(g $o f) i $o cat_pr i
    nrefine (cat_prod_beta _ _ _ $@R _ $@ _).I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
x, y, z: I -> A
f: x $-> y
g: y $-> z
i: I
g i $o cat_pr i $o
fmap (fun x : I -> A => cat_prod I x) f $==
(g $o f) i $o cat_pr i
    nrefine (cat_assoc _ _ _ $@ _).I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
x, y, z: I -> A
f: x $-> y
g: y $-> z
i: I
g i $o
(cat_pr i $o fmap (fun x : I -> A => cat_prod I x) f) $==
(g $o f) i $o cat_pr i
    nrefine (_ $@L cat_prod_beta _ _ _ $@ _).I, A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasProducts I A
x, y, z: I -> A
f: x $-> y
g: y $-> z
i: I
g i $o (f i $o cat_pr i) $== (g $o f) i $o cat_pr i
    nrapply cat_assoc_opp.
Defined.

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

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

(** *** Binary products *)

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

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

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

Section BinaryProducts.

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

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

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

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

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

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

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

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

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

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

End BinaryProducts.

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

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

Definition cat_binprod_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
  snrapply 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 snrapply 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
  snrapply 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
  snrapply 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))
  snrapply 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
  snrapply Build_Product.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
A
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
forall i : Bool, ?cat_prod $-> x i
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
forall z : A,
(forall i : Bool, z $-> x i) -> z $-> ?cat_prod
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
forall (z : A) (f : forall i : Bool, z $-> x i)
(i : Bool), ?cat_pr i $o ?cat_prod_corec z f $== f i
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
forall (z : A) (f g : z $-> ?cat_prod),
(forall i : Bool, ?cat_pr i $o f $== ?cat_pr i $o g) ->
f $== g
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
A exact (cat_binprod (x true) (x false)).
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
forall i : Bool,
cat_binprod (x true) (x false) $-> x i intros [|].A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
cat_binprod (x true) (x false) $-> x true
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
cat_binprod (x true) (x false) $-> x false
    +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
cat_binprod (x true) (x false) $-> x true exact cat_pr1.
    +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
cat_binprod (x true) (x false) $-> x false exact cat_pr2.
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
forall z : A,
(forall i : Bool, z $-> x i) ->
z $-> cat_binprod (x true) (x false) intros z f.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
z: A
f: forall i : Bool, z $-> x i
z $-> cat_binprod (x true) (x false)
    exact (cat_binprod_corec (f true) (f false)).
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
forall (z : A) (f : forall i : Bool, z $-> x i)
(i : Bool),
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod (x true) (x false) $-> x b)
 then cat_pr1
 else cat_pr2) i $o
(fun (z0 : A) (f0 : forall i0 : Bool, z0 $-> x i0) =>
 cat_binprod_corec (f0 true) (f0 false)) z f $== f i intros z f [|].A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
z: A
f: forall i : Bool, z $-> x i
cat_pr1 $o cat_binprod_corec (f true) (f false) $==
f true
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
z: A
f: forall i : Bool, z $-> x i
cat_pr2 $o cat_binprod_corec (f true) (f false) $==
f false
    +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
z: A
f: forall i : Bool, z $-> x i
cat_pr1 $o cat_binprod_corec (f true) (f false) $==
f true exact (cat_binprod_beta_pr1 (f true) (f false)).
    +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
z: A
f: forall i : Bool, z $-> x i
cat_pr2 $o cat_binprod_corec (f true) (f false) $==
f false exact (cat_binprod_beta_pr2 (f true) (f false)).
  -A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
forall (z : A)
(f g : z $-> cat_binprod (x true) (x false)),
(forall i : Bool,
 (fun i0 : Bool =>
  if i0 as b
   return (cat_binprod (x true) (x false) $-> x b)
  then cat_pr1
  else cat_pr2) i $o f $==
 (fun i0 : Bool =>
  if i0 as b
   return (cat_binprod (x true) (x false) $-> x b)
  then cat_pr1
  else cat_pr2) i $o g) -> f $== g intros z f g p.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
z: A
f, g: z $-> cat_binprod (x true) (x false)
p: forall i : Bool,
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod (x true) (x false) $-> x b)
 then cat_pr1
 else cat_pr2) i $o f $==
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod (x true) (x false) $-> x b)
 then cat_pr1
 else cat_pr2) i $o g
f $== g
    nrapply cat_binprod_eta_pr.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
z: A
f, g: z $-> cat_binprod (x true) (x false)
p: forall i : Bool,
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod (x true) (x false) $-> x b)
 then cat_pr1
 else cat_pr2) i $o f $==
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod (x true) (x false) $-> x b)
 then cat_pr1
 else cat_pr2) i $o g
cat_pr1 $o f $== cat_pr1 $o g
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
z: A
f, g: z $-> cat_binprod (x true) (x false)
p: forall i : Bool,
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod (x true) (x false) $-> x b)
 then cat_pr1
 else cat_pr2) i $o f $==
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod (x true) (x false) $-> x b)
 then cat_pr1
 else cat_pr2) i $o g
cat_pr2 $o f $== cat_pr2 $o g
    +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
z: A
f, g: z $-> cat_binprod (x true) (x false)
p: forall i : Bool,
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod (x true) (x false) $-> x b)
 then cat_pr1
 else cat_pr2) i $o f $==
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod (x true) (x false) $-> x b)
 then cat_pr1
 else cat_pr2) i $o g
cat_pr1 $o f $== cat_pr1 $o g exact (p true).
    +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x: Bool -> A
z: A
f, g: z $-> cat_binprod (x true) (x false)
p: forall i : Bool,
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod (x true) (x false) $-> x b)
 then cat_pr1
 else cat_pr2) i $o f $==
(fun i0 : Bool =>
 if i0 as b
  return (cat_binprod (x true) (x false) $-> x b)
 then cat_pr1
 else cat_pr2) i $o g
cat_pr2 $o f $== cat_pr2 $o g exact (p false).
Defined.

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

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

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

(** *** Binary product functor *)

(** We prove bifunctoriality of [cat_binprod : A -> A -> A] by factoring it as [cat_prod Bool o Bool_rec A]. First, we prove that [Bool_rec A : A -> A -> (Bool -> A)] is a bifunctor. *)
Local Instance is0bifunctor_boolrec {A : Type} `{Is1Cat A}
  : Is0Bifunctor (Bool_rec A).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
Is0Bifunctor (Bool_rec A)
Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
Is0Bifunctor (Bool_rec A)
  snrapply 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))
  snrapply 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)
  snrapply Build_Is1Bifunctor'.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
Is1Functor (uncurry (Bool_rec A))
  snrapply 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]. *)
Global 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.

Global 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. *)
Global 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 y).
Defined.

Global 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.

Global 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 x).
Defined.

Global 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 morphsism. *)

Global 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)
  snrapply Build_Is0Functor.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x, y, z: A
g: z $-> y
forall a b : z $-> y,
(a $-> b) ->
(fun f : z $-> y => cat_binprod_corec f g) a $->
(fun f : z $-> y => cat_binprod_corec f g) b
  intros f f' p.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x, y, z: A
g, f, f': z $-> y
p: f $-> f'
(fun f : z $-> y => cat_binprod_corec f g) f $->
(fun f : z $-> y => cat_binprod_corec f g) f'
  by nrapply cat_binprod_corec_eta.
Defined.

Global 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)
  snrapply Build_Is0Functor.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x, y, z: A
f: z $-> x
forall a b : z $-> x,
(a $-> b) ->
(fun g : z $-> x => cat_binprod_corec f g) a $->
(fun g : z $-> x => cat_binprod_corec f g) b
  intros g h p.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasBinaryProducts A
x, y, z: A
f, g, h: z $-> x
p: g $-> h
(fun g : z $-> x => cat_binprod_corec f g) g $->
(fun g : z $-> x => cat_binprod_corec f g) h
  by nrapply 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 _ _.

(** *** 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)
    nrapply 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
    snrapply 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: nrapply 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: nrapply cat_binprod_swap_cat_binprod_swap.
  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.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
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
  Proof.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
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
    nrapply 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, d: A
f: a $-> c
g: b $-> d
cat_pr1 $o
(cat_binprod_swap c d $o
 fmap11 (fun x y : A => cat_binprod x y) f g) $==
cat_pr1 $o
(fmap11 (fun x y : A => cat_binprod x y) g f $o
 cat_binprod_swap a b)
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_pr2 $o
(cat_binprod_swap c d $o
 fmap11 (fun x y : A => cat_binprod x y) f g) $==
cat_pr2 $o
(fmap11 (fun x y : A => cat_binprod x y) g f $o
 cat_binprod_swap a b)
    -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_pr1 $o
(cat_binprod_swap c d $o
 fmap11 (fun x y : A => cat_binprod x y) f g) $==
cat_pr1 $o
(fmap11 (fun x y : A => cat_binprod x y) g f $o
 cat_binprod_swap a b) 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, b, c, d: A
f: a $-> c
g: b $-> d
cat_pr1 $o cat_binprod_swap c d $o
fmap11 (fun x y : A => cat_binprod x y) f g $==
cat_pr1 $o
(fmap11 (fun x y : A => cat_binprod x y) g f $o
 cat_binprod_swap a b)
      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, b, c, d: A
f: a $-> c
g: b $-> d
cat_pr2 $o fmap11 (fun x y : A => cat_binprod x y) f g $==
cat_pr1 $o
(fmap11 (fun x y : A => cat_binprod x y) g f $o
 cat_binprod_swap a b)
      nrefine (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, b, c, d: A
f: a $-> c
g: b $-> d
g $o cat_pr2 $==
cat_pr1 $o
(fmap11 (fun x y : A => cat_binprod x y) g f $o
 cat_binprod_swap a b)
      nrefine (_ $@ cat_assoc _ _ _).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
g $o cat_pr2 $==
cat_pr1 $o fmap11 (fun x y : A => cat_binprod x y) g f $o
cat_binprod_swap a b
      refine (_ $@ (_^$ $@R _)).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
g $o cat_pr2 $== ?Goal1 $o cat_binprod_swap a b
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_pr1 $o fmap11 (fun x y : A => cat_binprod x y) g f $->
?Goal1
      2: nrapply 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, b, c, d: A
f: a $-> c
g: b $-> d
g $o cat_pr2 $== g $o cat_pr1 $o cat_binprod_swap a b
      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, b, c, d: A
f: a $-> c
g: b $-> d
cat_pr1 $o cat_binprod_swap a b $-> cat_pr2
      nrapply 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, d: A
f: a $-> c
g: b $-> d
cat_pr2 $o
(cat_binprod_swap c d $o
 fmap11 (fun x y : A => cat_binprod x y) f g) $==
cat_pr2 $o
(fmap11 (fun x y : A => cat_binprod x y) g f $o
 cat_binprod_swap a b) refine ((cat_assoc _ _ _)^$ $@ _).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_pr2 $o cat_binprod_swap c d $o
fmap11 (fun x y : A => cat_binprod x y) f g $==
cat_pr2 $o
(fmap11 (fun x y : A => cat_binprod x y) g f $o
 cat_binprod_swap a b)
      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
a, b, c, d: A
f: a $-> c
g: b $-> d
cat_pr1 $o fmap11 (fun x y : A => cat_binprod x y) f g $==
cat_pr2 $o
(fmap11 (fun x y : A => cat_binprod x y) g f $o
 cat_binprod_swap a b)
      nrefine (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, b, c, d: A
f: a $-> c
g: b $-> d
f $o cat_pr1 $==
cat_pr2 $o
(fmap11 (fun x y : A => cat_binprod x y) g f $o
 cat_binprod_swap a b)
      nrefine (_ $@ cat_assoc _ _ _).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
f $o cat_pr1 $==
cat_pr2 $o fmap11 (fun x y : A => cat_binprod x y) g f $o
cat_binprod_swap a b
      refine (_ $@ (_^$ $@R _)).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
f $o cat_pr1 $== ?Goal0 $o cat_binprod_swap a b
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_pr2 $o fmap11 (fun x y : A => cat_binprod x y) g f $->
?Goal0
      2: nrapply 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, b, c, d: A
f: a $-> c
g: b $-> d
f $o cat_pr1 $== f $o cat_pr2 $o cat_binprod_swap a b
      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
a, b, c, d: A
f: a $-> c
g: b $-> d
cat_pr2 $o cat_binprod_swap a b $-> cat_pr1
      nrapply cat_binprod_beta_pr2.
  Defined.

  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)
    snrapply 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) snrapply Build_Braiding.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
forall a b : A,
(fun x y : A => cat_binprod x y) a b $->
(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
Is1Natural (uncurry (fun x y : A => cat_binprod x y))
  (uncurry (flip (fun x y : A => cat_binprod x y)))
  (fun pat : A * A =>
   let x := pat in
   let a := fst x in let b := snd x in ?braid a b)
      +A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
forall a b : A,
(fun x y : A => cat_binprod x y) a b $->
(fun x y : A => cat_binprod x y) b a exact cat_binprod_swap.
      +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 pat : A * A =>
   let x := pat in
   let a := fst x in
   let b := snd x in cat_binprod_swap a b) 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
(let x := (c, d) in
 let a := fst x in
 let b := snd x in cat_binprod_swap a b) $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
(let x := (a, b) in
 let a := fst x in
 let b := snd x in 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,
{|
  braid := cat_binprod_swap;
  is1natural_braiding_uncurried :=
    (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))
    :
    Is1Natural
      (uncurry (fun x y : A => cat_binprod x y))
      (uncurry (flip (fun x y : A => cat_binprod x y)))
      (fun pat : A * A =>
       let x := pat in
       let a0 := fst x in
       let b0 := snd x in cat_binprod_swap a0 b0)
|} a b $o
{|
  braid := cat_binprod_swap;
  is1natural_braiding_uncurried :=
    (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))
    :
    Is1Natural
      (uncurry (fun x y : A => cat_binprod x y))
      (uncurry (flip (fun x y : A => cat_binprod x y)))
      (fun pat : A * A =>
       let x := pat in
       let a0 := fst x in
       let b0 := snd x in cat_binprod_swap a0 b0)
|} b a $== Id ((fun x y : A => cat_binprod x y) b a) exact cat_binprod_swap_cat_binprod_swap.
  Defined.

End Symmetry.

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

Section Associativity.

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

  Definition cat_binprod_twist (x y z : A)
    : cat_binprod x (cat_binprod y z) $-> cat_binprod y (cat_binprod x z).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_binprod x (cat_binprod y z) $->
cat_binprod y (cat_binprod x z)
  Proof.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
x, y, z: A
cat_binprod x (cat_binprod y z) $->
cat_binprod y (cat_binprod x z)
    nrapply 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 (fun x y => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) x cat_pr2 $==
cat_pr1
    nrapply 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 (fun x y : A => cat_binprod x y) x cat_pr2 $==
cat_pr2 $o cat_pr2
    nrapply cat_pr2_fmap01_binprod.
  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))
    nrapply 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
      nrapply 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
      nrapply 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
      nrapply 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)
    snrapply 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: nrapply 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: nrapply 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 (fun x y => cat_binprod x y) f (fmap11 (fun x y => cat_binprod x y) g h)
      $== fmap11 (fun x y => cat_binprod x y) g (fmap11 (fun x y => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) f
  (fmap11 (fun x y : A => cat_binprod x y) g h) $==
fmap11 (fun x y : A => cat_binprod x y) g
  (fmap11 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) f
  (fmap11 (fun x y : A => cat_binprod x y) g h) $==
fmap11 (fun x y : A => cat_binprod x y) g
  (fmap11 (fun x y : A => cat_binprod x y) f h) $o
cat_binprod_twist a b c
    nrapply 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 (fun x y : A => cat_binprod x y) f
   (fmap11 (fun x y : A => cat_binprod x y) g h)) $==
cat_pr1 $o
(fmap11 (fun x y : A => cat_binprod x y) g
   (fmap11 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) f
   (fmap11 (fun x y : A => cat_binprod x y) g h)) $==
cat_pr2 $o
(fmap11 (fun x y : A => cat_binprod x y) g
   (fmap11 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) f
   (fmap11 (fun x y : A => cat_binprod x y) g h)) $==
cat_pr1 $o
(fmap11 (fun x y : A => cat_binprod x y) g
   (fmap11 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) f
  (fmap11 (fun x y : A => cat_binprod x y) g h) $==
cat_pr1 $o
(fmap11 (fun x y : A => cat_binprod x y) g
   (fmap11 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) f
  (fmap11 (fun x y : A => cat_binprod x y) g h) $==
cat_pr1 $o
(fmap11 (fun x y : A => cat_binprod x y) g
   (fmap11 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) f
   (fmap11 (fun x y : A => cat_binprod x y) g h)) $==
cat_pr1 $o
(fmap11 (fun x y : A => cat_binprod x y) g
   (fmap11 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) f
  (fmap11 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) g
   (fmap11 (fun x y : A => cat_binprod x y) f h) $o
 cat_binprod_twist a b c)
      1: nrapply 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 (fun x y : A => cat_binprod x y) g h $o
 cat_pr2) $==
cat_pr1 $o
(fmap11 (fun x y : A => cat_binprod x y) g
   (fmap11 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) g h $o
cat_pr2 $==
cat_pr1 $o
(fmap11 (fun x y : A => cat_binprod x y) g
   (fmap11 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) g
   (fmap11 (fun x y : A => cat_binprod x y) f h) $o
 cat_binprod_twist a b c)
      1: nrapply 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 (fun x y : A => cat_binprod x y) g
   (fmap11 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) g
  (fmap11 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) g
  (fmap11 (fun x y : A => cat_binprod x y) f h) $->
?Goal1
      2: nrapply 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
      nrapply 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 (fun x y : A => cat_binprod x y) f
   (fmap11 (fun x y : A => cat_binprod x y) g h)) $==
cat_pr2 $o
(fmap11 (fun x y : A => cat_binprod x y) g
   (fmap11 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) a' cat_pr2 $o
fmap11 (fun x y : A => cat_binprod x y) f
  (fmap11 (fun x y : A => cat_binprod x y) g h) $==
cat_pr2 $o
(fmap11 (fun x y : A => cat_binprod x y) g
   (fmap11 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) a' cat_pr2 $o
fmap11 (fun x y : A => cat_binprod x y) f
  (fmap11 (fun x y : A => cat_binprod x y) g h) $==
cat_pr2 $o
fmap11 (fun x y : A => cat_binprod x y) g
  (fmap11 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) a' cat_pr2 $o
fmap11 (fun x y : A => cat_binprod x y) f
  (fmap11 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) g
  (fmap11 (fun x y : A => cat_binprod x y) f h) $->
?Goal0
      2: nrapply 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 (fun x y : A => cat_binprod x y) a' cat_pr2 $o
fmap11 (fun x y : A => cat_binprod x y) f
  (fmap11 (fun x y : A => cat_binprod x y) g h) $==
fmap11 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) a' cat_pr2 $o
fmap11 (fun x y : A => cat_binprod x y) f
  (fmap11 (fun x y : A => cat_binprod x y) g h) $==
fmap11 (fun x y : A => cat_binprod x y) 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: nrapply 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 (fun x y : A => cat_binprod x y) a' cat_pr2 $o
fmap11 (fun x y : A => cat_binprod x y) f
  (fmap11 (fun x y : A => cat_binprod x y) g h) $==
fmap11 (fun x y : A => cat_binprod x y) f h $o
fmap01 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) a' cat_pr2 $o
fmap11 (fun x y : A => cat_binprod x y) f
  (fmap11 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) f h $o
fmap01 (fun x y : A => cat_binprod x y) a cat_pr2
      1,3: rapply fmap11_comp.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
fmap11 (fun x y : A => cat_binprod x y)
  (fmap (uncurry (Bool_rec A))
     (fmap (fun b : A => (a', b)) cat_pr2) true $o f)
  (fmap (uncurry (Bool_rec A))
     (fmap (fun b : A => (a', b)) cat_pr2) false $o
   fmap11 (fun x y : A => cat_binprod x y) g h) $==
fmap11 (fun x y : A => cat_binprod x y)
  (f $o
   fmap (uncurry (Bool_rec A))
     (fmap (fun b : A => (a, b)) cat_pr2) true)
  (h $o
   fmap (uncurry (Bool_rec A))
     (fmap (fun b : A => (a, b)) cat_pr2) false)
      rapply fmap22.A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
fmap (uncurry (Bool_rec A))
  (fmap (fun b : A => (a', b)) cat_pr2) true $o f $==
f $o
fmap (uncurry (Bool_rec A))
  (fmap (fun b : A => (a, b)) cat_pr2) true
A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
fmap (uncurry (Bool_rec A))
  (fmap (fun b : A => (a', b)) cat_pr2) false $o
fmap11 (fun x y : A => cat_binprod x y) g h $==
h $o
fmap (uncurry (Bool_rec A))
  (fmap (fun b : A => (a, b)) cat_pr2) false
      1: exact (cat_idl _ $@ (cat_idr _)^$).A: Type
IsGraph0: IsGraph A
Is2Graph0: Is2Graph A
Is01Cat0: Is01Cat A
H: Is1Cat A
H0: HasEquivs A
HasBinaryProducts0: HasBinaryProducts A
a, a', b, b', c, c': A
f: a $-> a'
g: b $-> b'
h: c $-> c'
fmap (uncurry (Bool_rec A))
  (fmap (fun b : A => (a', b)) cat_pr2) false $o
fmap11 (fun x y : A => cat_binprod x y) g h $==
h $o
fmap (uncurry (Bool_rec A))
  (fmap (fun b : A => (a, b)) cat_pr2) false
      nrapply cat_binprod_beta_pr2.
  Defined.

  Local Existing Instance symmetricbraiding_binprod.

  Local Instance associator_binprod : Associator (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
Associator (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
Associator (fun x y : A => cat_binprod x y)
    snrapply associator_twist.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)
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,
(fun x y : A => cat_binprod x y) a
  ((fun x y : A => cat_binprod x y) b c) $->
(fun x y : A => cat_binprod x y) b
  ((fun x y : A => cat_binprod x y) 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
  ((fun x y : A => cat_binprod x y) b
     ((fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) f
  (fmap11 (fun x y : A => cat_binprod x y) g h) $==
fmap11 (fun x y : A => cat_binprod x y) g
  (fmap11 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) 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,
(fun x y : A => cat_binprod x y) a
  ((fun x y : A => cat_binprod x y) b c) $->
(fun x y : A => cat_binprod x y) b
  ((fun x y : A => cat_binprod x y) 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
  ((fun x y : A => cat_binprod x y) b
     ((fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) f
  (fmap11 (fun x y : A => cat_binprod x y) g h) $==
fmap11 (fun x y : A => cat_binprod x y) g
  (fmap11 (fun x y : A => cat_binprod x y) 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_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_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_binprod x y z $==
cat_pr1
    nrefine ((_ $@L Monoidal.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 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) x
    (symmetricbraiding_binprod y z))) $== cat_pr1
    1: nrapply 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 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) x
  (symmetricbraiding_binprod y z) $== cat_pr1
    nrapply cat_pr1_fmap01_binprod.
  Defined.

  Definition cat_pr2_pr1_associator_binprod x y z
    : cat_pr2 $o cat_pr1 $o associator_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_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_binprod x y z $==
cat_pr1 $o cat_pr2
    nrefine ((_ $@L Monoidal.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 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) x
    (symmetricbraiding_binprod y z))) $==
cat_pr1 $o cat_pr2
    1: nrapply 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 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) 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_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_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_binprod x y z $==
cat_pr2 $o cat_pr2
    nrefine ((_ $@L Monoidal.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 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) 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 (fun x y : A => cat_binprod x y) 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.

  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
    snrapply 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
      snrapply 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) nrapply 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) 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
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))))) $o
fmap (flip (fun x y : A => cat_binprod x y) unit) f $==
fmap idmap f $o
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)))))
      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: nrapply 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
      nrapply 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
    snrapply 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: nrapply 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
    nrapply 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: nrapply 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: nrapply 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
      nrapply 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: nrapply 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
      nrapply 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_binprod (cat_binprod a b) c d $o
associator_binprod a b (cat_binprod c d) $==
fmap10 (fun x y : A => cat_binprod x y)
  (associator_binprod a b c) d $o
associator_binprod a (cat_binprod b c) d $o
fmap01 (fun x y : A => cat_binprod x y) a
  (associator_binprod b c d)
    nrapply 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_binprod (cat_binprod a b) c d $o
 associator_binprod a b (cat_binprod c d)) $==
cat_pr1 $o cat_pr1 $o
(fmap10 (fun x y : A => cat_binprod x y)
   (associator_binprod a b c) d $o
 associator_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_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_binprod (cat_binprod a b) c d $o
 associator_binprod a b (cat_binprod c d)) $==
cat_pr2 $o cat_pr1 $o
(fmap10 (fun x y : A => cat_binprod x y)
   (associator_binprod a b c) d $o
 associator_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_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_binprod (cat_binprod a b) c d $o
 associator_binprod a b (cat_binprod c d)) $==
cat_pr2 $o
(fmap10 (fun x y : A => cat_binprod x y)
   (associator_binprod a b c) d $o
 associator_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_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_binprod (cat_binprod a b) c d $o
 associator_binprod a b (cat_binprod c d)) $==
cat_pr1 $o cat_pr1 $o
(fmap10 (fun x y : A => cat_binprod x y)
   (associator_binprod a b c) d $o
 associator_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_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_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_binprod a b (cat_binprod c d) $==
cat_pr1 $o cat_pr1 $o
(fmap10 (fun x y : A => cat_binprod x y)
   (associator_binprod a b c) d $o
 associator_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_binprod b c d))
      1: nrapply 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_binprod a b (cat_binprod c d) $==
cat_pr1 $o cat_pr1 $o
(fmap10 (fun x y : A => cat_binprod x y)
   (associator_binprod a b c) d $o
 associator_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_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_binprod a b (cat_binprod c d) $==
cat_pr1 $o
(?Goal2 $o associator_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_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_binprod a b c) d $-> 
?Goal2
      2: nrapply 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_binprod a b (cat_binprod c d) $==
cat_pr1 $o
(associator_binprod a b c $o cat_pr1 $o
 associator_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_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_binprod a b (cat_binprod c d) $==
cat_pr1 $o
(associator_binprod a b c $o
 (cat_pr1 $o
  (associator_binprod a (cat_binprod b c) d $o
   fmap01 (fun x y : A => cat_binprod x y) a
     (associator_binprod b c d))))
      nrapply 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_binprod a b (cat_binprod c d)) $==
cat_pr1 $o
(cat_pr1 $o
 (associator_binprod a b c $o
  (cat_pr1 $o
   (associator_binprod a (cat_binprod b c) d $o
    fmap01 (fun x y : A => cat_binprod x y) a
      (associator_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_binprod a b (cat_binprod c d)) $==
cat_pr2 $o
(cat_pr1 $o
 (associator_binprod a b c $o
  (cat_pr1 $o
   (associator_binprod a (cat_binprod b c) d $o
    fmap01 (fun x y : A => cat_binprod x y) a
      (associator_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_binprod a b (cat_binprod c d)) $==
cat_pr1 $o
(cat_pr1 $o
 (associator_binprod a b c $o
  (cat_pr1 $o
   (associator_binprod a (cat_binprod b c) d $o
    fmap01 (fun x y : A => cat_binprod x y) a
      (associator_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_binprod a b (cat_binprod c d) $==
cat_pr1 $o cat_pr1 $o
(associator_binprod a b c $o
 (cat_pr1 $o
  (associator_binprod a (cat_binprod b c) d $o
   fmap01 (fun x y : A => cat_binprod x y) a
     (associator_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_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_binprod a (cat_binprod b c) d $o
  fmap01 (fun x y : A => cat_binprod x y) a
    (associator_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_binprod a b c $->
?Goal5
        1,3: nrapply 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_binprod a (cat_binprod b c) d $o
  fmap01 (fun x y : A => cat_binprod x y) a
    (associator_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_binprod a (cat_binprod b c) d $o
fmap01 (fun x y : A => cat_binprod x y) a
  (associator_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_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_binprod a (cat_binprod b c) d $-> 
?Goal3
        2: nrapply 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_binprod b c d) $-> cat_pr1
        nrapply 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_binprod a b (cat_binprod c d)) $==
cat_pr2 $o
(cat_pr1 $o
 (associator_binprod a b c $o
  (cat_pr1 $o
   (associator_binprod a (cat_binprod b c) d $o
    fmap01 (fun x y : A => cat_binprod x y) a
      (associator_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_binprod a b (cat_binprod c d) $==
cat_pr2 $o cat_pr1 $o
(associator_binprod a b c $o
 (cat_pr1 $o
  (associator_binprod a (cat_binprod b c) d $o
   fmap01 (fun x y : A => cat_binprod x y) a
     (associator_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_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_binprod a (cat_binprod b c) d $o
  fmap01 (fun x y : A => cat_binprod x y) a
    (associator_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_binprod a b c $->
?Goal4
        1,3: nrapply 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_binprod a (cat_binprod b c) d $o
  fmap01 (fun x y : A => cat_binprod x y) a
    (associator_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_binprod a (cat_binprod b c) d $o
fmap01 (fun x y : A => cat_binprod x y) a
  (associator_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_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_binprod a (cat_binprod b c) d $->
?Goal4 $o ?Goal3
        2: nrapply 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_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_binprod b c d) $-> 
?Goal2
        2: nrapply 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_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_binprod b c d $==
cat_pr1
        nrapply 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_binprod (cat_binprod a b) c d $o
 associator_binprod a b (cat_binprod c d)) $==
cat_pr2 $o cat_pr1 $o
(fmap10 (fun x y : A => cat_binprod x y)
   (associator_binprod a b c) d $o
 associator_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_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_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_binprod a b (cat_binprod c d) $==
cat_pr2 $o cat_pr1 $o
(fmap10 (fun x y : A => cat_binprod x y)
   (associator_binprod a b c) d $o
 associator_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_binprod b c d))
      1: nrapply 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_binprod a b (cat_binprod c d) $==
cat_pr2 $o cat_pr1 $o
(fmap10 (fun x y : A => cat_binprod x y)
   (associator_binprod a b c) d $o
 associator_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_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_binprod a b (cat_binprod c d)) $==
cat_pr2 $o
(cat_pr1 $o
 (fmap10 (fun x y : A => cat_binprod x y)
    (associator_binprod a b c) d $o
  associator_binprod a (cat_binprod b c) d $o
  fmap01 (fun x y : A => cat_binprod x y) a
    (associator_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_binprod a b c) d $o
  associator_binprod a (cat_binprod b c) d $o
  fmap01 (fun x y : A => cat_binprod x y) a
    (associator_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_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_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_binprod a b c) d $-> 
?Goal1
      2: nrapply 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_binprod a b c $o cat_pr1 $o
 associator_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_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_binprod a b c $o
 (cat_pr1 $o
  (associator_binprod a (cat_binprod b c) d $o
   fmap01 (fun x y : A => cat_binprod x y) a
     (associator_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_binprod a (cat_binprod b c) d $o
  fmap01 (fun x y : A => cat_binprod x y) a
    (associator_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_binprod a b c $-> ?Goal1
      2: nrapply 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_binprod a (cat_binprod b c) d $o
  fmap01 (fun x y : A => cat_binprod x y) a
    (associator_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_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_binprod a (cat_binprod b c) d $-> 
?Goal1
      2: nrapply 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_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_binprod b c d) $-> 
?Goal1
      2: nrapply 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_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_binprod b c d $->
cat_pr1 $o cat_pr2
      nrapply 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_binprod (cat_binprod a b) c d $o
 associator_binprod a b (cat_binprod c d)) $==
cat_pr2 $o
(fmap10 (fun x y : A => cat_binprod x y)
   (associator_binprod a b c) d $o
 associator_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_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_binprod a b (cat_binprod c d) $==
cat_pr2 $o
(fmap10 (fun x y : A => cat_binprod x y)
   (associator_binprod a b c) d $o
 associator_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_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_binprod a b c) d $o
 associator_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_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_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_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_binprod a b c) d $-> 
?Goal0
      2: nrapply 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_binprod a (cat_binprod b c) d $o
 fmap01 (fun x y : A => cat_binprod x y) a
   (associator_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_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_binprod a (cat_binprod b c) d $->
?Goal2 $o ?Goal1
      2: nrapply 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_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_binprod b c d $->
cat_pr2 $o cat_pr2
      nrapply 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_binprod b a c $o
fmap01 (fun x y : A => cat_binprod x y) b
  (symmetricbraiding_binprod c a) $==
associator_binprod a b c $o
symmetricbraiding_binprod (cat_binprod b c) a $o
associator_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_binprod b a c $o
 fmap01 (fun x y : A => cat_binprod x y) b
   (symmetricbraiding_binprod c a)) $==
associator_binprod a b c $o
(symmetricbraiding_binprod (cat_binprod b c) a $o
 associator_binprod b c a)
    nrapply 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_binprod b a c $o
  fmap01 (fun x y : A => cat_binprod x y) b
    (symmetricbraiding_binprod c a))) $==
cat_pr1 $o
(associator_binprod a b c $o
 (symmetricbraiding_binprod (cat_binprod b c) a $o
  associator_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_binprod b a c $o
  fmap01 (fun x y : A => cat_binprod x y) b
    (symmetricbraiding_binprod c a))) $==
cat_pr2 $o
(associator_binprod a b c $o
 (symmetricbraiding_binprod (cat_binprod b c) a $o
  associator_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_binprod b a c $o
  fmap01 (fun x y : A => cat_binprod x y) b
    (symmetricbraiding_binprod c a))) $==
cat_pr1 $o
(associator_binprod a b c $o
 (symmetricbraiding_binprod (cat_binprod b c) a $o
  associator_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_binprod b a c $o
 fmap01 (fun x y : A => cat_binprod x y) b
   (symmetricbraiding_binprod c a)) $==
cat_pr1 $o
(associator_binprod a b c $o
 (symmetricbraiding_binprod (cat_binprod b c) a $o
  associator_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_binprod b a c $o
  fmap01 (fun x y : A => cat_binprod x y) b
    (symmetricbraiding_binprod c a))) $==
cat_pr1 $o
(associator_binprod a b c $o
 (symmetricbraiding_binprod (cat_binprod b c) a $o
  associator_binprod b c a))
      nrapply 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_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_binprod a b c $o
  (symmetricbraiding_binprod (cat_binprod b c) a $o
   associator_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_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_binprod a b c $o
  (symmetricbraiding_binprod (cat_binprod b c) a $o
   associator_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_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_binprod a b c $o
  (symmetricbraiding_binprod (cat_binprod b c) a $o
   associator_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_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_binprod a b c $o
(symmetricbraiding_binprod (cat_binprod b c) a $o
 associator_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_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_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_binprod a b c $->
?Goal4
        1: nrapply 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_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_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_binprod a b c $->
?Goal2
        2: nrapply 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_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_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_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_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_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_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: nrapply 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_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: nrapply 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_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_binprod b c a $->
?Goal5 $o ?Goal3
        1: nrapply 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_binprod b c a $->
?Goal1 $o cat_pr2
        2: nrapply 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
        nrapply 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_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_binprod a b c $o
  (symmetricbraiding_binprod (cat_binprod b c) a $o
   associator_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_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_binprod a b c $o
(symmetricbraiding_binprod (cat_binprod b c) a $o
 associator_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_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_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_binprod a b c $->
?Goal3
      1: nrapply 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_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_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_binprod a b c $->
?Goal1
      2: nrapply 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_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_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_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_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_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_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: nrapply 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_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: nrapply 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_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_binprod b c a $->
cat_pr1
      nrapply 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_binprod b a c $o
  fmap01 (fun x y : A => cat_binprod x y) b
    (symmetricbraiding_binprod c a))) $==
cat_pr2 $o
(associator_binprod a b c $o
 (symmetricbraiding_binprod (cat_binprod b c) a $o
  associator_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_binprod b a c $o
 fmap01 (fun x y : A => cat_binprod x y) b
   (symmetricbraiding_binprod c a)) $==
cat_pr2 $o associator_binprod a b c $o
symmetricbraiding_binprod (cat_binprod b c) a $o
associator_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_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_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_binprod a b c $-> ?Goal2
    1: nrapply 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_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_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_binprod a b c $-> ?Goal0
    2: nrapply 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_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_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_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_binprod b c a
    1: nrapply 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_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_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: nrapply 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_binprod b c a $->
cat_pr1 $o cat_pr2
    nrapply cat_pr2_pr1_associator_binprod.
  Defined.

  Global Instance ismonoidal_binprod
    : IsMonoidal A (fun x y => cat_binprod x y) unit
    := {}.

  Global Instance issymmetricmonoidal_binprod
    : IsSymmetricMonoidal A (fun x y => cat_binprod x y) unit
    := {}.

End Associativity.

(** *** Products in Type *)

(** Since we use the Yoneda lemma in this file, we therefore depend on WildCat.Universe which means these instances have to live here. *)
Global Instance hasbinaryproducts_type : HasBinaryProducts Type.HasBinaryProducts Type
Proof.HasBinaryProducts Type
  intros X Y.X, Y: Type
BinaryProduct X Y
  snrapply 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
    nrapply path_prod.X, Y, Z: Type
f, g: Z $-> X * Y
p: fst $o f $== fst $o g
q: snd $o f $== snd $o g
x: Z
fst (f x) = fst (g x)
X, Y, Z: Type
f, g: Z $-> X * Y
p: fst $o f $== fst $o g
q: snd $o f $== snd $o g
x: Z
snd (f x) = snd (g x)
    +X, Y, Z: Type
f, g: Z $-> X * Y
p: fst $o f $== fst $o g
q: snd $o f $== snd $o g
x: Z
fst (f x) = fst (g x) exact (p x).
    +X, Y, Z: Type
f, g: Z $-> X * Y
p: fst $o f $== fst $o g
q: snd $o f $== snd $o g
x: Z
snd (f x) = snd (g x) exact (q x).
Defined.

(** Assuming [Funext], [Type] has all products. *)
Global 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
  snrapply Build_Product.H: Funext
I: Type
x: I -> Type
Type
H: Funext
I: Type
x: I -> Type
forall i : I, ?cat_prod $-> x i
H: Funext
I: Type
x: I -> Type
forall z : Type,
(forall i : I, z $-> x i) -> z $-> ?cat_prod
H: Funext
I: Type
x: I -> Type
forall (z : Type) (f : forall i : I, z $-> x i)
(i : I), ?cat_pr i $o ?cat_prod_corec z f $== f i
H: Funext
I: Type
x: I -> Type
forall (z : Type) (f g : z $-> ?cat_prod),
(forall i : I, ?cat_pr i $o f $== ?cat_pr i $o g) ->
f $== g
  -H: Funext
I: Type
x: I -> Type
Type exact (forall (i : I), x i).
  -H: Funext
I: Type
x: I -> Type
forall i : I, (forall i0 : I, x i0) $-> x i intros i f.H: Funext
I: Type
x: I -> Type
i: I
f: forall i : I, x i
x i exact (f i).
  -H: Funext
I: Type
x: I -> Type
forall z : Type,
(forall i : I, z $-> x i) -> z $-> (forall i : I, x i) intros A f a i.H: Funext
I: Type
x: I -> Type
A: Type
f: forall i : I, A $-> x i
a: A
i: I
x i exact (f i a).
  -H: Funext
I: Type
x: I -> Type
forall (z : Type) (f : forall i : I, z $-> x i)
(i : I),
(fun i0 : I =>
 (fun f0 : forall i1 : I, x i1 => f0 i0)
 :
 (forall i1 : I, x i1) $-> x i0) i $o
(fun (A : Type) (f0 : forall i0 : I, A $-> x i0) =>
 (fun (a : A) (i0 : I) => f0 i0 a)
 :
 A $-> (forall i0 : I, x i0)) z f $== f i reflexivity.
  -H: Funext
I: Type
x: I -> Type
forall (z : Type) (f g : z $-> (forall i : I, x i)),
(forall i : I,
 (fun i0 : I =>
  (fun f0 : forall i1 : I, x i1 => f0 i0)
  :
  (forall i1 : I, x i1) $-> x i0) i $o f $==
 (fun i0 : I =>
  (fun f0 : forall i1 : I, x i1 => f0 i0)
  :
  (forall i1 : I, x i1) $-> x i0) i $o g) -> f $== g intros A f g p a.H: Funext
I: Type
x: I -> Type
A: Type
f, g: A $-> (forall i : I, x i)
p: forall i : I,
(fun i0 : I =>
 (fun f : forall i1 : I, x i1 => f i0)
 :
 (forall i1 : I, x i1) $-> x i0) i $o f $==
(fun i0 : I =>
 (fun f : forall i1 : I, x i1 => f i0)
 :
 (forall i1 : I, x i1) $-> x i0) i $o g
a: A
f a = g a
    exact (path_forall _ _ (fun i => p i a)).
Defined.