(* -*- mode: coq; mode: visual-line -*- *)
Require Import Basics.
[Loading ML file number_string_notation_plugin.cmxs (using legacy method) ... done]
Require Import Types.
Require Import HSet.
Require Import Spaces.Nat.Core.
Require Import HFiber.
Require Import Factorization.
Require Import Truncations.
Require Import Colimits.Quotient.
Require Import Projective.
Require Import Fin.

Local Open Scope path_scope.
Local Open Scope nat_scope.

(** ** Definition of general finite sets *)

Class Finite (X : Type) :=
  { fcard : nat ;
    merely_equiv_fin : merely (X <~> Fin fcard) }.

Arguments fcard X {_}.
Arguments merely_equiv_fin X {_}.

Definition issig_finite X
: { n : nat & merely (X <~> Fin n) } <~> Finite X.
X: Type
{n : nat & merely (X <~> Fin n)} <~> Finite X
Proof.
X: Type
{n : nat & merely (X <~> Fin n)} <~> Finite X
  issig.
Defined.

(** Note that the sigma over cardinalities is not truncated.  Nevertheless, because canonical finite sets of different cardinalities are not isomorphic, being finite is still an hprop.  (Thus, we could have truncated the sigma and gotten an equivalent definition, but it would be less convenient to reason about.) *)
Global Instance ishprop_finite X
: IsHProp (Finite X).
X: Type
IsHProp (Finite X)
Proof.
X: Type
IsHProp (Finite X)
  refine (istrunc_equiv_istrunc _ (issig_finite X)).
X: Type
IsHProp {n : nat & merely (X <~> Fin n)}
  apply ishprop_sigma_disjoint; intros n m Hn Hm.
X: Type
n, m: nat
Hn: merely (X <~> Fin n)
Hm: merely (X <~> Fin m)
n = m
  strip_truncations.
X: Type
n, m: nat
Hm: X <~> Fin m
Hn: X <~> Fin n
n = m
  refine (nat_eq_fin_equiv n m (Hm oE Hn^-1)).
Defined.

(** ** Preservation of finiteness by equivalences *)

Definition finite_equiv X {Y} (e : X -> Y) `{IsEquiv X Y e}
: Finite X -> Finite Y.
X, Y: Type
e: X -> Y
H: IsEquiv e
Finite X -> Finite Y
Proof.
X, Y: Type
e: X -> Y
H: IsEquiv e
Finite X -> Finite Y
  intros ?.
X, Y: Type
e: X -> Y
H: IsEquiv e
X0: Finite X
Finite Y
  refine (Build_Finite Y (fcard X) _).
X, Y: Type
e: X -> Y
H: IsEquiv e
X0: Finite X
merely (Y <~> Fin (fcard X))
  assert (f := merely_equiv_fin X); strip_truncations.
X, Y: Type
e: X -> Y
H: IsEquiv e
X0: Finite X
f: X <~> Fin (fcard X)
merely (Y <~> Fin (fcard X))
  apply tr.
X, Y: Type
e: X -> Y
H: IsEquiv e
X0: Finite X
f: X <~> Fin (fcard X)
Y <~> Fin (fcard X)
  exact (equiv_compose f e^-1).
Defined.

Definition finite_equiv' X {Y} (e : X <~> Y)
: Finite X -> Finite Y
  := finite_equiv X e.

Corollary finite_equiv_equiv X Y
: (X <~> Y) -> (Finite X <~> Finite Y).
X, Y: Type
X <~> Y -> Finite X <~> Finite Y
Proof.
X, Y: Type
X <~> Y -> Finite X <~> Finite Y
  intros ?; apply equiv_iff_hprop; apply finite_equiv';
    [ assumption | symmetry; assumption ].
Defined.

Definition fcard_equiv {X Y} (e : X -> Y) `{IsEquiv X Y e}
           `{Finite X} `{Finite Y}
: fcard X = fcard Y.
X, Y: Type
e: X -> Y
H: IsEquiv e
H0: Finite X
H1: Finite Y
fcard X = fcard Y
Proof.
X, Y: Type
e: X -> Y
H: IsEquiv e
H0: Finite X
H1: Finite Y
fcard X = fcard Y
  transitivity (@fcard Y (finite_equiv X e _)).
X, Y: Type
e: X -> Y
H: IsEquiv e
H0: Finite X
H1: Finite Y
fcard X = fcard Y
X, Y: Type
e: X -> Y
H: IsEquiv e
H0: Finite X
H1: Finite Y
fcard Y = fcard Y
  -
X, Y: Type
e: X -> Y
H: IsEquiv e
H0: Finite X
H1: Finite Y
fcard X = fcard Y reflexivity.
  -
X, Y: Type
e: X -> Y
H: IsEquiv e
H0: Finite X
H1: Finite Y
fcard Y = fcard Y exact (ap (@fcard Y) (path_ishprop _ _)).
Defined.

Definition fcard_equiv' {X Y} (e : X <~> Y)
           `{Finite X} `{Finite Y}
: fcard X = fcard Y
  := fcard_equiv e.

(** ** Simple examples of finite sets *)

(** Canonical finite sets are finite *)
Global Instance finite_fin n : Finite (Fin n)
  := Build_Finite _ n (tr (equiv_idmap _)).

(** This includes the empty set. *)
Global Instance finite_empty : Finite Empty
  := finite_fin 0.

(** The unit type is finite, since it's equivalent to [Fin 1]. *)
Global Instance finite_unit : Finite Unit.
Finite Unit
Proof.
Finite Unit
  refine (finite_equiv' (Fin 1) _ _); simpl.
Empty + Unit <~> Unit
  apply sum_empty_l.
Defined.

(** Thus, any contractible type is finite. *)
Global Instance finite_contr X `{Contr X} : Finite X
  := finite_equiv Unit equiv_contr_unit^-1 _.

(** Any decidable hprop is finite, since it must be equivalent to [Empty] or [Unit]. *)
Definition finite_decidable_hprop X `{IsHProp X} `{Decidable X}
: Finite X.
X: Type
IsHProp0: IsHProp X
H: Decidable X
Finite X
Proof.
X: Type
IsHProp0: IsHProp X
H: Decidable X
Finite X
  destruct (dec X) as [x|nx].
X: Type
IsHProp0: IsHProp X
H: Decidable X
x: X
Finite X
X: Type
IsHProp0: IsHProp X
H: Decidable X
nx: ~ X
Finite X
  -
X: Type
IsHProp0: IsHProp X
H: Decidable X
x: X
Finite X assert (Contr X) by exact (contr_inhabited_hprop X x).
X: Type
IsHProp0: IsHProp X
H: Decidable X
x: X
X0: Contr X
Finite X
    exact _.
  -
X: Type
IsHProp0: IsHProp X
H: Decidable X
nx: ~ X
Finite X refine (finite_equiv Empty nx^-1 _).
Defined.

#[export]
Hint Immediate finite_decidable_hprop : typeclass_instances.

(** It follows that the propositional truncation of any finite set is finite. *)
Global Instance finite_merely X {fX : Finite X}
: Finite (merely X).
X: Type
fX: Finite X
Finite (merely X)
Proof.
X: Type
fX: Finite X
Finite (merely X)
  (** As in decidable_finite_hprop, we case on cardinality first to avoid needing funext. *)
  destruct fX as [[|n] e]; refine (finite_decidable_hprop _).
X: Type
e: merely (X <~> Fin 0)
Decidable (merely X)
X: Type
n: nat
e: merely (X <~> Fin n.+1)
Decidable (merely X)
  -
X: Type
e: merely (X <~> Fin 0)
Decidable (merely X) right.
X: Type
e: merely (X <~> Fin 0)
~ merely X
    intros x; strip_truncations; exact (e x).
  -
X: Type
n: nat
e: merely (X <~> Fin n.+1)
Decidable (merely X) left.
X: Type
n: nat
e: merely (X <~> Fin n.+1)
merely X
    strip_truncations; exact (tr (e^-1 (inr tt))).
Defined.

(** Finite sets are closed under path-spaces. *)
Global Instance finite_paths {X} `{Finite X} (x y : X)
: Finite (x = y).
X: Type
H: Finite X
x, y: X
Finite (x = y)
Proof.
X: Type
H: Finite X
x, y: X
Finite (x = y)
  (** If we assume [Funext], then typeclass inference produces this automatically, since [X] has decidable equality and (hence) is a set, so [x=y] is a decidable hprop.  But we can also deduce it without funext, since [Finite] is an hprop even without funext. *)
  assert (e := merely_equiv_fin X).
X: Type
H: Finite X
x, y: X
e: merely (X <~> Fin (fcard X))
Finite (x = y)
  strip_truncations.
X: Type
H: Finite X
x, y: X
e: X <~> Fin (fcard X)
Finite (x = y)
  refine (finite_equiv _ (ap e)^-1 _).
X: Type
H: Finite X
x, y: X
e: X <~> Fin (fcard X)
Finite (e x = e y)
  apply finite_decidable_hprop; exact _.
Defined.

(** Finite sets are also closed under successors. *)

Global Instance finite_succ X `{Finite X} : Finite (X + Unit).
X: Type
H: Finite X
Finite (X + Unit)
Proof.
X: Type
H: Finite X
Finite (X + Unit)
  refine (Build_Finite _ (fcard X).+1 _).
X: Type
H: Finite X
merely (X + Unit <~> Fin (fcard X).+1)
  pose proof (merely_equiv_fin X).
X: Type
H: Finite X
X0: merely (X <~> Fin (fcard X))
merely (X + Unit <~> Fin (fcard X).+1)
  strip_truncations; apply tr.
X: Type
H: Finite X
X0: X <~> Fin (fcard X)
X + Unit <~> Fin (fcard X).+1
  refine (_ +E 1); assumption.
Defined.

Definition fcard_succ X `{Finite X}
: fcard (X + Unit) = (fcard X).+1
  := 1.

(** ** Decidability *)		

(** Like canonical finite sets, finite sets have decidable equality. *)
Global Instance decidablepaths_finite `{Funext} X `{Finite X}
: DecidablePaths X.
H: Funext
X: Type
H0: Finite X
DecidablePaths X
Proof.
H: Funext
X: Type
H0: Finite X
DecidablePaths X
  assert (e := merely_equiv_fin X).
H: Funext
X: Type
H0: Finite X
e: merely (X <~> Fin (fcard X))
DecidablePaths X
  strip_truncations.
H: Funext
X: Type
H0: Finite X
e: X <~> Fin (fcard X)
DecidablePaths X
  refine (decidablepaths_equiv _ e^-1 _).
Defined.

(** However, contrary to what you might expect, we cannot assert that "every finite set is decidable"!  That would be claiming a *uniform* way to select an element from every nonempty finite set, which contradicts univalence. *)

(** One thing we can prove is that any finite hprop is decidable. *)
Global Instance decidable_finite_hprop X `{IsHProp X} {fX : Finite X}
: Decidable X.
X: Type
IsHProp0: IsHProp X
fX: Finite X
Decidable X
Proof.
X: Type
IsHProp0: IsHProp X
fX: Finite X
Decidable X
  (** To avoid having to use [Funext], we case on the cardinality of [X] before stripping the truncation from its equivalence to [Fin n]; if we did things in the other order then we'd have to know that [Decidable X] is an hprop, which requires funext. *)
  destruct fX as [[|n] e].
X: Type
IsHProp0: IsHProp X
e: merely (X <~> Fin 0)
Decidable X
X: Type
IsHProp0: IsHProp X
n: nat
e: merely (X <~> Fin n.+1)
Decidable X
  -
X: Type
IsHProp0: IsHProp X
e: merely (X <~> Fin 0)
Decidable X right; intros x.
X: Type
IsHProp0: IsHProp X
e: merely (X <~> Fin 0)
x: X
Empty
    strip_truncations; exact (e x).
  -
X: Type
IsHProp0: IsHProp X
n: nat
e: merely (X <~> Fin n.+1)
Decidable X left.
X: Type
IsHProp0: IsHProp X
n: nat
e: merely (X <~> Fin n.+1)
X
    strip_truncations; exact (e^-1 (inr tt)).
Defined.

(** It follows that if [X] is finite, then its propositional truncation is decidable. *)
Global Instance decidable_merely_finite X {fX : Finite X}
: Decidable (merely X).
X: Type
fX: Finite X
Decidable (merely X)
Proof.
X: Type
fX: Finite X
Decidable (merely X)
  exact _.
Defined.

(** From this, it follows that any finite set is *merely* decidable. *)
Definition merely_decidable_finite X `{Finite X}
: merely (Decidable X).
X: Type
H: Finite X
merely (Decidable X)
Proof.
X: Type
H: Finite X
merely (Decidable X)
  apply O_decidable; exact _.
Defined.

(** ** Induction over finite sets *)

(** Most concrete applications of this don't actually require univalence, but the general version does.  For this reason the general statement is less useful (and less used in the sequel) than it might be. *)
Definition finite_ind_hprop `{Univalence}
           (P : forall X, Finite X -> Type)
           `{forall X (fX:Finite X), IsHProp (P X _)}
           (f0 : P Empty _)
           (fs : forall X (fX:Finite X), P X _ -> P (X + Unit)%type _)
           (X : Type) `{Finite X}
: P X _.
H: Univalence
P: forall X : Type, Finite X -> Type
H0: forall (X : Type) (fX : Finite X),
IsHProp (P X fX)
f0: P Empty finite_empty
fs: forall (X : Type) (fX : Finite X),
P X fX -> P (X + Unit)%type (finite_succ X)
X: Type
H1: Finite X
P X H1
Proof.
H: Univalence
P: forall X : Type, Finite X -> Type
H0: forall (X : Type) (fX : Finite X),
IsHProp (P X fX)
f0: P Empty finite_empty
fs: forall (X : Type) (fX : Finite X),
P X fX -> P (X + Unit)%type (finite_succ X)
X: Type
H1: Finite X
P X H1
  assert (e := merely_equiv_fin X).
H: Univalence
P: forall X : Type, Finite X -> Type
H0: forall (X : Type) (fX : Finite X),
IsHProp (P X fX)
f0: P Empty finite_empty
fs: forall (X : Type) (fX : Finite X),
P X fX -> P (X + Unit)%type (finite_succ X)
X: Type
H1: Finite X
e: merely (X <~> Fin (fcard X))
P X H1
  strip_truncations.
H: Univalence
P: forall X : Type, Finite X -> Type
H0: forall (X : Type) (fX : Finite X),
IsHProp (P X fX)
f0: P Empty finite_empty
fs: forall (X : Type) (fX : Finite X),
P X fX -> P (X + Unit)%type (finite_succ X)
X: Type
H1: Finite X
e: X <~> Fin (fcard X)
P X H1
  assert (p := transportD Finite P (path_universe e^-1) _).
H: Univalence
P: forall X : Type, Finite X -> Type
H0: forall (X : Type) (fX : Finite X),
IsHProp (P X fX)
f0: P Empty finite_empty
fs: forall (X : Type) (fX : Finite X),
P X fX -> P (X + Unit)%type (finite_succ X)
X: Type
H1: Finite X
e: X <~> Fin (fcard X)
p: P (Fin (fcard X)) (finite_fin (fcard X)) ->
P X
  (transport Finite (path_universe e^-1)
     (finite_fin (fcard X)))
P X H1
  refine (transport (P X) (path_ishprop _ _) (p _)).
H: Univalence
P: forall X : Type, Finite X -> Type
H0: forall (X : Type) (fX : Finite X),
IsHProp (P X fX)
f0: P Empty finite_empty
fs: forall (X : Type) (fX : Finite X),
P X fX -> P (X + Unit)%type (finite_succ X)
X: Type
H1: Finite X
e: X <~> Fin (fcard X)
p: P (Fin (fcard X)) (finite_fin (fcard X)) ->
P X
  (transport Finite (path_universe e^-1)
     (finite_fin (fcard X)))
P (Fin (fcard X)) (finite_fin (fcard X))
  generalize (fcard X); intros n.
H: Univalence
P: forall X : Type, Finite X -> Type
H0: forall (X : Type) (fX : Finite X),
IsHProp (P X fX)
f0: P Empty finite_empty
fs: forall (X : Type) (fX : Finite X),
P X fX -> P (X + Unit)%type (finite_succ X)
X: Type
H1: Finite X
e: X <~> Fin (fcard X)
p: P (Fin (fcard X)) (finite_fin (fcard X)) ->
P X
  (transport Finite (path_universe e^-1)
     (finite_fin (fcard X)))
n: nat
P (Fin n) (finite_fin n)
  induction n as [|n IH].
H: Univalence
P: forall X : Type, Finite X -> Type
H0: forall (X : Type) (fX : Finite X),
IsHProp (P X fX)
f0: P Empty finite_empty
fs: forall (X : Type) (fX : Finite X),
P X fX -> P (X + Unit)%type (finite_succ X)
X: Type
H1: Finite X
e: X <~> Fin (fcard X)
p: P (Fin (fcard X)) (finite_fin (fcard X)) ->
P X
  (transport Finite (path_universe e^-1)
     (finite_fin (fcard X)))
P (Fin 0) (finite_fin 0)
H: Univalence
P: forall X : Type, Finite X -> Type
H0: forall (X : Type) (fX : Finite X),
IsHProp (P X fX)
f0: P Empty finite_empty
fs: forall (X : Type) (fX : Finite X),
P X fX -> P (X + Unit)%type (finite_succ X)
X: Type
H1: Finite X
e: X <~> Fin (fcard X)
p: P (Fin (fcard X)) (finite_fin (fcard X)) ->
P X
  (transport Finite (path_universe e^-1)
     (finite_fin (fcard X)))
n: nat
IH: P (Fin n) (finite_fin n)
P (Fin n.+1) (finite_fin n.+1)
  -
H: Univalence
P: forall X : Type, Finite X -> Type
H0: forall (X : Type) (fX : Finite X),
IsHProp (P X fX)
f0: P Empty finite_empty
fs: forall (X : Type) (fX : Finite X),
P X fX -> P (X + Unit)%type (finite_succ X)
X: Type
H1: Finite X
e: X <~> Fin (fcard X)
p: P (Fin (fcard X)) (finite_fin (fcard X)) ->
P X
  (transport Finite (path_universe e^-1)
     (finite_fin (fcard X)))
P (Fin 0) (finite_fin 0) exact f0.
  -
H: Univalence
P: forall X : Type, Finite X -> Type
H0: forall (X : Type) (fX : Finite X),
IsHProp (P X fX)
f0: P Empty finite_empty
fs: forall (X : Type) (fX : Finite X),
P X fX -> P (X + Unit)%type (finite_succ X)
X: Type
H1: Finite X
e: X <~> Fin (fcard X)
p: P (Fin (fcard X)) (finite_fin (fcard X)) ->
P X
  (transport Finite (path_universe e^-1)
     (finite_fin (fcard X)))
n: nat
IH: P (Fin n) (finite_fin n)
P (Fin n.+1) (finite_fin n.+1) refine (transport (P (Fin n.+1)) (path_ishprop _ _) (fs _ _ IH)).
Defined.

(** ** The finite axiom of choice, and projectivity *)

Definition finite_choice {X} `{Finite X} : HasChoice X.
X: Type
H: Finite X
HasChoice X
Proof.
X: Type
H: Finite X
HasChoice X
  intros P oP f; clear oP.
X: Type
H: Finite X
P: X -> Type
f: forall x : X, merely (P x)
merely (forall x : X, P x)
  assert (e := merely_equiv_fin X).
X: Type
H: Finite X
P: X -> Type
f: forall x : X, merely (P x)
e: merely (X <~> Fin (fcard X))
merely (forall x : X, P x)
  strip_truncations.
X: Type
H: Finite X
P: X -> Type
f: forall x : X, merely (P x)
e: X <~> Fin (fcard X)
merely (forall x : X, P x)
  set (P' := P o e^-1).
X: Type
H: Finite X
P: X -> Type
f: forall x : X, merely (P x)
e: X <~> Fin (fcard X)
P':= P o e^-1: Fin (fcard X) -> Type
merely (forall x : X, P x)
  assert (f' := (fun x => f (e^-1 x)) : forall x, merely (P' x)).
X: Type
H: Finite X
P: X -> Type
f: forall x : X, merely (P x)
e: X <~> Fin (fcard X)
P':= P o e^-1: Fin (fcard X) -> Type
f': forall x : Fin (fcard X), merely (P' x)
merely (forall x : X, P x)
  refine (Trunc_functor (X := forall x:Fin (fcard X), P' x) (-1) _ _).
X: Type
H: Finite X
P: X -> Type
f: forall x : X, merely (P x)
e: X <~> Fin (fcard X)
P':= P o e^-1: Fin (fcard X) -> Type
f': forall x : Fin (fcard X), merely (P' x)
(forall x : Fin (fcard X), P' x) -> forall x : X, P x
X: Type
H: Finite X
P: X -> Type
f: forall x : X, merely (P x)
e: X <~> Fin (fcard X)
P':= P o e^-1: Fin (fcard X) -> Type
f': forall x : Fin (fcard X), merely (P' x)
Tr (-1) (forall x : Fin (fcard X), P' x)
  -
X: Type
H: Finite X
P: X -> Type
f: forall x : X, merely (P x)
e: X <~> Fin (fcard X)
P':= P o e^-1: Fin (fcard X) -> Type
f': forall x : Fin (fcard X), merely (P' x)
(forall x : Fin (fcard X), P' x) -> forall x : X, P x intros g x; exact (eissect e x # g (e x)).
  -
X: Type
H: Finite X
P: X -> Type
f: forall x : X, merely (P x)
e: X <~> Fin (fcard X)
P':= P o e^-1: Fin (fcard X) -> Type
f': forall x : Fin (fcard X), merely (P' x)
Tr (-1) (forall x : Fin (fcard X), P' x) clearbody P'; clear f P e.
X: Type
H: Finite X
P': Fin (fcard X) -> Type
f': forall x : Fin (fcard X), merely (P' x)
Tr (-1) (forall x : Fin (fcard X), P' x)
    generalize dependent (fcard X); intros n P f.
X: Type
H: Finite X
n: nat
P: Fin n -> Type
f: forall x : Fin n, merely (P x)
Tr (-1) (forall x : Fin n, P x)
    induction n as [|n IH].
X: Type
H: Finite X
P: Fin 0 -> Type
f: forall x : Fin 0, merely (P x)
Tr (-1) (forall x : Fin 0, P x)
X: Type
H: Finite X
n: nat
P: Fin n.+1 -> Type
f: forall x : Fin n.+1, merely (P x)
IH: forall P : Fin n -> Type,
(forall x : Fin n, merely (P x)) ->
Tr (-1) (forall x : Fin n, P x)
Tr (-1) (forall x : Fin n.+1, P x)
    +
X: Type
H: Finite X
P: Fin 0 -> Type
f: forall x : Fin 0, merely (P x)
Tr (-1) (forall x : Fin 0, P x) exact (tr (Empty_ind P)).
    +
X: Type
H: Finite X
n: nat
P: Fin n.+1 -> Type
f: forall x : Fin n.+1, merely (P x)
IH: forall P : Fin n -> Type,
(forall x : Fin n, merely (P x)) ->
Tr (-1) (forall x : Fin n, P x)
Tr (-1) (forall x : Fin n.+1, P x) specialize (IH (P o inl) (f o inl)).
X: Type
H: Finite X
n: nat
P: Fin n.+1 -> Type
f: forall x : Fin n.+1, merely (P x)
IH: Tr (-1) (forall x : Fin n, (P o inl) x)
Tr (-1) (forall x : Fin n.+1, P x)
      assert (e := f (inr tt)).
X: Type
H: Finite X
n: nat
P: Fin n.+1 -> Type
f: forall x : Fin n.+1, merely (P x)
IH: Tr (-1) (forall x : Fin n, (P o inl) x)
e: merely (P (inr tt))
Tr (-1) (forall x : Fin n.+1, P x)
      strip_truncations.
X: Type
H: Finite X
n: nat
P: Fin n.+1 -> Type
f: forall x : Fin n.+1, merely (P x)
e: P (inr tt)
IH: forall x : Fin n, P (inl x)
Tr (-1) (forall x : Fin n.+1, P x)
      exact (tr (sum_ind P IH (Unit_ind e))).
Defined.

Corollary isprojective_fin_n (n : nat) : IsProjective (Fin n).
n: nat
IsProjective (Fin n)
Proof.
n: nat
IsProjective (Fin n)
  apply (iff_isoprojective_hasochoice _ (Fin n)).
n: nat
HasChoice (Fin n)
  rapply finite_choice.
Defined.

(** ** Constructions on finite sets *)

(** Finite sets are closed under sums, products, function spaces, and equivalence spaces.  There are multiple choices we could make regarding how to prove these facts.  Since we know what the cardinalities ought to be in all cases (since we know how to add, multiply, exponentiate, and take factorials of natural numbers), we could specify those off the bat, and then reduce to the case of canonical finite sets.  However, it's more amusing to instead prove finiteness of these constructions by "finite-set induction", and then *deduce* that their cardinalities are given by the corresponding operations on natural numbers (because they satisfy the same recurrences). *)

(** *** Binary sums *)

Global Instance finite_sum X Y `{Finite X} `{Finite Y}
: Finite (X + Y).
X, Y: Type
H: Finite X
H0: Finite Y
Finite (X + Y)
Proof.
X, Y: Type
H: Finite X
H0: Finite Y
Finite (X + Y)
  assert (e := merely_equiv_fin Y).
X, Y: Type
H: Finite X
H0: Finite Y
e: merely (Y <~> Fin (fcard Y))
Finite (X + Y)
  strip_truncations.
X, Y: Type
H: Finite X
H0: Finite Y
e: Y <~> Fin (fcard Y)
Finite (X + Y)
  refine (finite_equiv _ (functor_sum idmap e^-1) _).
X, Y: Type
H: Finite X
H0: Finite Y
e: Y <~> Fin (fcard Y)
Finite (X + Fin (fcard Y))
  generalize (fcard Y); intros n.
X, Y: Type
H: Finite X
H0: Finite Y
e: Y <~> Fin (fcard Y)
n: nat
Finite (X + Fin n)
  induction n as [|n IH].
X, Y: Type
H: Finite X
H0: Finite Y
e: Y <~> Fin (fcard Y)
Finite (X + Fin 0)
X, Y: Type
H: Finite X
H0: Finite Y
e: Y <~> Fin (fcard Y)
n: nat
IH: Finite (X + Fin n)
Finite (X + Fin n.+1)
  -
X, Y: Type
H: Finite X
H0: Finite Y
e: Y <~> Fin (fcard Y)
Finite (X + Fin 0) refine (finite_equiv _ (sum_empty_r X)^-1 _).
  -
X, Y: Type
H: Finite X
H0: Finite Y
e: Y <~> Fin (fcard Y)
n: nat
IH: Finite (X + Fin n)
Finite (X + Fin n.+1) refine (finite_equiv _ (equiv_sum_assoc X _ Unit) _).
Defined.

(** Note that the cardinality function [fcard] actually computes.  The same will be true of all the other proofs in this section, though we don't always verify it. *)
Goal fcard (Fin 3 + Fin 4) = 7.
fcard (Fin 3 + Fin 4) = 7
  reflexivity.
Abort.

Definition fcard_sum X Y `{Finite X} `{Finite Y}
: fcard (X + Y) = (fcard X + fcard Y).
X, Y: Type
H: Finite X
H0: Finite Y
fcard (X + Y) = fcard X + fcard Y
Proof.
X, Y: Type
H: Finite X
H0: Finite Y
fcard (X + Y) = fcard X + fcard Y
  refine (_ @ nat_add_comm _ _).
X, Y: Type
H: Finite X
H0: Finite Y
fcard (X + Y) = fcard Y + fcard X
  assert (e := merely_equiv_fin Y).
X, Y: Type
H: Finite X
H0: Finite Y
e: merely (Y <~> Fin (fcard Y))
fcard (X + Y) = fcard Y + fcard X
  strip_truncations.
X, Y: Type
H: Finite X
H0: Finite Y
e: Y <~> Fin (fcard Y)
fcard (X + Y) = fcard Y + fcard X
  refine (fcard_equiv' (1 +E e) @ _).
X, Y: Type
H: Finite X
H0: Finite Y
e: Y <~> Fin (fcard Y)
fcard (X + Fin (fcard Y)) = fcard Y + fcard X
  refine (_ @ ap (fun y => (y + fcard X)) (fcard_equiv e^-1)).
X, Y: Type
H: Finite X
H0: Finite Y
e: Y <~> Fin (fcard Y)
fcard (X + Fin (fcard Y)) =
fcard (Fin (fcard Y)) + fcard X
  generalize (fcard Y); intros n.
X, Y: Type
H: Finite X
H0: Finite Y
e: Y <~> Fin (fcard Y)
n: nat
fcard (X + Fin n) = fcard (Fin n) + fcard X
  induction n as [|n IH].
X, Y: Type
H: Finite X
H0: Finite Y
e: Y <~> Fin (fcard Y)
fcard (X + Fin 0) = fcard (Fin 0) + fcard X
X, Y: Type
H: Finite X
H0: Finite Y
e: Y <~> Fin (fcard Y)
n: nat
IH: fcard (X + Fin n) = fcard (Fin n) + fcard X
fcard (X + Fin n.+1) = fcard (Fin n.+1) + fcard X
  -
X, Y: Type
H: Finite X
H0: Finite Y
e: Y <~> Fin (fcard Y)
fcard (X + Fin 0) = fcard (Fin 0) + fcard X refine (fcard_equiv (sum_empty_r X)^-1).
  -
X, Y: Type
H: Finite X
H0: Finite Y
e: Y <~> Fin (fcard Y)
n: nat
IH: fcard (X + Fin n) = fcard (Fin n) + fcard X
fcard (X + Fin n.+1) = fcard (Fin n.+1) + fcard X refine (fcard_equiv (equiv_sum_assoc _ _ _)^-1 @ _).
X, Y: Type
H: Finite X
H0: Finite Y
e: Y <~> Fin (fcard Y)
n: nat
IH: fcard (X + Fin n) = fcard (Fin n) + fcard X
fcard
  (X +
   (fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n + Unit) = fcard (Fin n.+1) + fcard X
    exact (ap S IH).
Defined.

(** *** Binary products *)

Global Instance finite_prod X Y `{Finite X} `{Finite Y}
: Finite (X * Y).
X, Y: Type
H: Finite X
H0: Finite Y
Finite (X * Y)
Proof.
X, Y: Type
H: Finite X
H0: Finite Y
Finite (X * Y)
  assert (e := merely_equiv_fin Y).
X, Y: Type
H: Finite X
H0: Finite Y
e: merely (Y <~> Fin (fcard Y))
Finite (X * Y)
  strip_truncations.
X, Y: Type
H: Finite X
H0: Finite Y
e: Y <~> Fin (fcard Y)
Finite (X * Y)
  refine (finite_equiv _ (functor_prod idmap e^-1) _).
X, Y: Type
H: Finite X
H0: Finite Y
e: Y <~> Fin (fcard Y)
Finite (X * Fin (fcard Y))
  generalize (fcard Y); intros n.
X, Y: Type
H: Finite X
H0: Finite Y
e: Y <~> Fin (fcard Y)
n: nat
Finite (X * Fin n)
  induction n as [|n IH].
X, Y: Type
H: Finite X
H0: Finite Y
e: Y <~> Fin (fcard Y)
Finite (X * Fin 0)
X, Y: Type
H: Finite X
H0: Finite Y
e: Y <~> Fin (fcard Y)
n: nat
IH: Finite (X * Fin n)
Finite (X * Fin n.+1)
  -
X, Y: Type
H: Finite X
H0: Finite Y
e: Y <~> Fin (fcard Y)
Finite (X * Fin 0) refine (finite_equiv _ (prod_empty_r X)^-1 _).
  -
X, Y: Type
H: Finite X
H0: Finite Y
e: Y <~> Fin (fcard Y)
n: nat
IH: Finite (X * Fin n)
Finite (X * Fin n.+1) refine (finite_equiv _ (sum_distrib_l X _ Unit)^-1 (finite_sum _ _)).
X, Y: Type
H: Finite X
H0: Finite Y
e: Y <~> Fin (fcard Y)
n: nat
IH: Finite (X * Fin n)
Finite (X * Unit)
    refine (finite_equiv _ (prod_unit_r X)^-1 _).
Defined.

Definition fcard_prod X Y `{Finite X} `{Finite Y}
: fcard (X * Y) = fcard X * fcard Y.
X, Y: Type
H: Finite X
H0: Finite Y
fcard (X * Y) = fcard X * fcard Y
Proof.
X, Y: Type
H: Finite X
H0: Finite Y
fcard (X * Y) = fcard X * fcard Y
  assert (e := merely_equiv_fin X).
X, Y: Type
H: Finite X
H0: Finite Y
e: merely (X <~> Fin (fcard X))
fcard (X * Y) = fcard X * fcard Y
  strip_truncations.
X, Y: Type
H: Finite X
H0: Finite Y
e: X <~> Fin (fcard X)
fcard (X * Y) = fcard X * fcard Y
  refine (fcard_equiv' (e *E 1) @ _).
X, Y: Type
H: Finite X
H0: Finite Y
e: X <~> Fin (fcard X)
fcard (Fin (fcard X) * Y) = fcard X * fcard Y
  refine (_ @ ap (fun x => x * fcard Y) (fcard_equiv e^-1)).
X, Y: Type
H: Finite X
H0: Finite Y
e: X <~> Fin (fcard X)
fcard (Fin (fcard X) * Y) =
fcard (Fin (fcard X)) * fcard Y
  generalize (fcard X); intros n.
X, Y: Type
H: Finite X
H0: Finite Y
e: X <~> Fin (fcard X)
n: nat
fcard (Fin n * Y) = fcard (Fin n) * fcard Y
  induction n as [|n IH].
X, Y: Type
H: Finite X
H0: Finite Y
e: X <~> Fin (fcard X)
fcard (Fin 0 * Y) = fcard (Fin 0) * fcard Y
X, Y: Type
H: Finite X
H0: Finite Y
e: X <~> Fin (fcard X)
n: nat
IH: fcard (Fin n * Y) = fcard (Fin n) * fcard Y
fcard (Fin n.+1 * Y) = fcard (Fin n.+1) * fcard Y
  -
X, Y: Type
H: Finite X
H0: Finite Y
e: X <~> Fin (fcard X)
fcard (Fin 0 * Y) = fcard (Fin 0) * fcard Y refine (fcard_equiv (prod_empty_l Y)).
  -
X, Y: Type
H: Finite X
H0: Finite Y
e: X <~> Fin (fcard X)
n: nat
IH: fcard (Fin n * Y) = fcard (Fin n) * fcard Y
fcard (Fin n.+1 * Y) = fcard (Fin n.+1) * fcard Y refine (fcard_equiv (sum_distrib_r Y (Fin n) Unit) @ _).
X, Y: Type
H: Finite X
H0: Finite Y
e: X <~> Fin (fcard X)
n: nat
IH: fcard (Fin n * Y) = fcard (Fin n) * fcard Y
fcard (Fin n * Y + Unit * Y) =
fcard (Fin n.+1) * fcard Y
    refine (fcard_sum _ _ @ _).
X, Y: Type
H: Finite X
H0: Finite Y
e: X <~> Fin (fcard X)
n: nat
IH: fcard (Fin n * Y) = fcard (Fin n) * fcard Y
fcard (Fin n * Y) + fcard (Unit * Y) =
fcard (Fin n.+1) * fcard Y
    simpl.
X, Y: Type
H: Finite X
H0: Finite Y
e: X <~> Fin (fcard X)
n: nat
IH: fcard (Fin n * Y) = fcard (Fin n) * fcard Y
fcard (Fin n * Y) + fcard (Unit * Y) =
fcard Y + n * fcard Y
    refine (_ @ nat_add_comm _ _).
X, Y: Type
H: Finite X
H0: Finite Y
e: X <~> Fin (fcard X)
n: nat
IH: fcard (Fin n * Y) = fcard (Fin n) * fcard Y
fcard (Fin n * Y) + fcard (Unit * Y) =
n * fcard Y + fcard Y
    refine (ap011 add _ _).
X, Y: Type
H: Finite X
H0: Finite Y
e: X <~> Fin (fcard X)
n: nat
IH: fcard (Fin n * Y) = fcard (Fin n) * fcard Y
fcard (Fin n * Y) = n * fcard Y
X, Y: Type
H: Finite X
H0: Finite Y
e: X <~> Fin (fcard X)
n: nat
IH: fcard (Fin n * Y) = fcard (Fin n) * fcard Y
fcard (Unit * Y) = fcard Y
    +
X, Y: Type
H: Finite X
H0: Finite Y
e: X <~> Fin (fcard X)
n: nat
IH: fcard (Fin n * Y) = fcard (Fin n) * fcard Y
fcard (Fin n * Y) = n * fcard Y apply IH.
    +
X, Y: Type
H: Finite X
H0: Finite Y
e: X <~> Fin (fcard X)
n: nat
IH: fcard (Fin n * Y) = fcard (Fin n) * fcard Y
fcard (Unit * Y) = fcard Y apply fcard_equiv', prod_unit_l.
  Defined.

(** *** Function types *)

(** Finite sets are closed under function types, and even dependent function types. *)

Global Instance finite_forall `{Funext} {X} (Y : X -> Type)
       `{Finite X} `{forall x, Finite (Y x)}
: Finite (forall x:X, Y x).
H: Funext
X: Type
Y: X -> Type
H0: Finite X
H1: forall x : X, Finite (Y x)
Finite (forall x : X, Y x)
Proof.
H: Funext
X: Type
Y: X -> Type
H0: Finite X
H1: forall x : X, Finite (Y x)
Finite (forall x : X, Y x)
  assert (e := merely_equiv_fin X).
H: Funext
X: Type
Y: X -> Type
H0: Finite X
H1: forall x : X, Finite (Y x)
e: merely (X <~> Fin (fcard X))
Finite (forall x : X, Y x)
  strip_truncations.
H: Funext
X: Type
Y: X -> Type
H0: Finite X
H1: forall x : X, Finite (Y x)
e: X <~> Fin (fcard X)
Finite (forall x : X, Y x)
  simple refine (finite_equiv' _
            (equiv_functor_forall' (P := fun x => Y (e^-1 x)) e _) _); try exact _.
H: Funext
X: Type
Y: X -> Type
H0: Finite X
H1: forall x : X, Finite (Y x)
e: X <~> Fin (fcard X)
forall b : X,
(fun x : Fin (fcard X) => Y (e^-1 x)) (e b) <~> Y b
H: Funext
X: Type
Y: X -> Type
H0: Finite X
H1: forall x : X, Finite (Y x)
e: X <~> Fin (fcard X)
Finite
  (forall a : Fin (fcard X),
   (fun x : Fin (fcard X) => Y (e^-1 x)) a)
  {
H: Funext
X: Type
Y: X -> Type
H0: Finite X
H1: forall x : X, Finite (Y x)
e: X <~> Fin (fcard X)
forall b : X,
(fun x : Fin (fcard X) => Y (e^-1 x)) (e b) <~> Y b intros x; refine (equiv_transport _ (eissect e x)). }
H: Funext
X: Type
Y: X -> Type
H0: Finite X
H1: forall x : X, Finite (Y x)
e: X <~> Fin (fcard X)
Finite
  (forall a : Fin (fcard X),
   (fun x : Fin (fcard X) => Y (e^-1 x)) a)
  set (Y' := Y o e^-1); change (Finite (forall x, Y' x)).
H: Funext
X: Type
Y: X -> Type
H0: Finite X
H1: forall x : X, Finite (Y x)
e: X <~> Fin (fcard X)
Y':= Y o e^-1: Fin (fcard X) -> Type
Finite (forall x : Fin (fcard X), Y' x)
  assert (forall x, Finite (Y' x)) by exact _; clearbody Y'; clear e.
H: Funext
X: Type
Y: X -> Type
H0: Finite X
H1: forall x : X, Finite (Y x)
Y': Fin (fcard X) -> Type
X0: forall x : Fin (fcard X), Finite (Y' x)
Finite (forall x : Fin (fcard X), Y' x)
  generalize dependent (fcard X); intros n Y' ?.
H: Funext
X: Type
Y: X -> Type
H0: Finite X
H1: forall x : X, Finite (Y x)
n: nat
Y': Fin n -> Type
X0: forall x : Fin n, Finite (Y' x)
Finite (forall x : Fin n, Y' x)
  induction n as [|n IH].
H: Funext
X: Type
Y: X -> Type
H0: Finite X
H1: forall x : X, Finite (Y x)
Y': Fin 0 -> Type
X0: forall x : Fin 0, Finite (Y' x)
Finite (forall x : Fin 0, Y' x)
H: Funext
X: Type
Y: X -> Type
H0: Finite X
H1: forall x : X, Finite (Y x)
n: nat
Y': Fin n.+1 -> Type
X0: forall x : Fin n.+1, Finite (Y' x)
IH: forall Y' : Fin n -> Type,
(forall x : Fin n, Finite (Y' x)) ->
Finite (forall x : Fin n, Y' x)
Finite (forall x : Fin n.+1, Y' x)
  -
H: Funext
X: Type
Y: X -> Type
H0: Finite X
H1: forall x : X, Finite (Y x)
Y': Fin 0 -> Type
X0: forall x : Fin 0, Finite (Y' x)
Finite (forall x : Fin 0, Y' x) exact _.
  -
H: Funext
X: Type
Y: X -> Type
H0: Finite X
H1: forall x : X, Finite (Y x)
n: nat
Y': Fin n.+1 -> Type
X0: forall x : Fin n.+1, Finite (Y' x)
IH: forall Y' : Fin n -> Type,
(forall x : Fin n, Finite (Y' x)) ->
Finite (forall x : Fin n, Y' x)
Finite (forall x : Fin n.+1, Y' x) refine (finite_equiv _ (equiv_sum_ind Y') _).
H: Funext
X: Type
Y: X -> Type
H0: Finite X
H1: forall x : X, Finite (Y x)
n: nat
Y': Fin n.+1 -> Type
X0: forall x : Fin n.+1, Finite (Y' x)
IH: forall Y' : Fin n -> Type,
(forall x : Fin n, Finite (Y' x)) ->
Finite (forall x : Fin n, Y' x)
Finite
  ((forall
    a : (fix Fin (n : nat) : Type0 :=
           match n with
           | 0 => Empty
           | n0.+1 => (Fin n0 + Unit)%type
           end) n, Y' (inl a)) *
   (forall b : Unit, Y' (inr b)))
    apply finite_prod.
H: Funext
X: Type
Y: X -> Type
H0: Finite X
H1: forall x : X, Finite (Y x)
n: nat
Y': Fin n.+1 -> Type
X0: forall x : Fin n.+1, Finite (Y' x)
IH: forall Y' : Fin n -> Type,
(forall x : Fin n, Finite (Y' x)) ->
Finite (forall x : Fin n, Y' x)
Finite
  (forall
   a : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n, Y' (inl a))
H: Funext
X: Type
Y: X -> Type
H0: Finite X
H1: forall x : X, Finite (Y x)
n: nat
Y': Fin n.+1 -> Type
X0: forall x : Fin n.+1, Finite (Y' x)
IH: forall Y' : Fin n -> Type,
(forall x : Fin n, Finite (Y' x)) ->
Finite (forall x : Fin n, Y' x)
Finite (forall b : Unit, Y' (inr b))
    +
H: Funext
X: Type
Y: X -> Type
H0: Finite X
H1: forall x : X, Finite (Y x)
n: nat
Y': Fin n.+1 -> Type
X0: forall x : Fin n.+1, Finite (Y' x)
IH: forall Y' : Fin n -> Type,
(forall x : Fin n, Finite (Y' x)) ->
Finite (forall x : Fin n, Y' x)
Finite
  (forall
   a : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n, Y' (inl a)) apply IH; exact _.
    +
H: Funext
X: Type
Y: X -> Type
H0: Finite X
H1: forall x : X, Finite (Y x)
n: nat
Y': Fin n.+1 -> Type
X0: forall x : Fin n.+1, Finite (Y' x)
IH: forall Y' : Fin n -> Type,
(forall x : Fin n, Finite (Y' x)) ->
Finite (forall x : Fin n, Y' x)
Finite (forall b : Unit, Y' (inr b)) refine (finite_equiv _ (@Unit_ind (fun u => Y' (inr u))) _).
H: Funext
X: Type
Y: X -> Type
H0: Finite X
H1: forall x : X, Finite (Y x)
n: nat
Y': Fin n.+1 -> Type
X0: forall x : Fin n.+1, Finite (Y' x)
IH: forall Y' : Fin n -> Type,
(forall x : Fin n, Finite (Y' x)) ->
Finite (forall x : Fin n, Y' x)
IsEquiv (Unit_ind (A:=fun u : Unit => Y' (inr u)))
      refine (isequiv_unit_ind (Y' o inr)).
Defined.

#[local] Hint Extern 4 => progress (cbv beta iota) : typeclass_instances.

Definition fcard_arrow `{Funext} X Y `{Finite X} `{Finite Y}
: fcard (X -> Y) = nat_exp (fcard Y) (fcard X).
H: Funext
X, Y: Type
H0: Finite X
H1: Finite Y
fcard (forall x : X, (fun _ : X => Y) x) =
nat_exp (fcard Y) (fcard X)
Proof.
H: Funext
X, Y: Type
H0: Finite X
H1: Finite Y
fcard (forall x : X, (fun _ : X => Y) x) =
nat_exp (fcard Y) (fcard X)
  assert (e := merely_equiv_fin X).
H: Funext
X, Y: Type
H0: Finite X
H1: Finite Y
e: merely (X <~> Fin (fcard X))
fcard (forall x : X, (fun _ : X => Y) x) =
nat_exp (fcard Y) (fcard X)
  strip_truncations.
H: Funext
X, Y: Type
H0: Finite X
H1: Finite Y
e: X <~> Fin (fcard X)
fcard (forall x : X, (fun _ : X => Y) x) =
nat_exp (fcard Y) (fcard X)
  refine (fcard_equiv (functor_arrow e idmap)^-1 @ _).
H: Funext
X, Y: Type
H0: Finite X
H1: Finite Y
e: X <~> Fin (fcard X)
fcard
  (forall x : Fin (fcard X),
   (fun _ : Fin (fcard X) => Y) x) =
nat_exp (fcard Y) (fcard X)
  refine (_ @ ap (fun x => nat_exp (fcard Y) x) (fcard_equiv e)).
H: Funext
X, Y: Type
H0: Finite X
H1: Finite Y
e: X <~> Fin (fcard X)
fcard
  (forall x : Fin (fcard X),
   (fun _ : Fin (fcard X) => Y) x) =
nat_exp (fcard Y) (fcard X)
  generalize (fcard X); intros n.
H: Funext
X, Y: Type
H0: Finite X
H1: Finite Y
e: X <~> Fin (fcard X)
n: nat
fcard (forall x : Fin n, (fun _ : Fin n => Y) x) =
nat_exp (fcard Y) n
  induction n as [|n IH].
H: Funext
X, Y: Type
H0: Finite X
H1: Finite Y
e: X <~> Fin (fcard X)
fcard (forall x : Fin 0, (fun _ : Fin 0 => Y) x) =
nat_exp (fcard Y) 0
H: Funext
X, Y: Type
H0: Finite X
H1: Finite Y
e: X <~> Fin (fcard X)
n: nat
IH: fcard (forall x : Fin n, (fun _ : Fin n => Y) x) =
nat_exp (fcard Y) n
fcard (forall x : Fin n.+1, (fun _ : Fin n.+1 => Y) x) =
nat_exp (fcard Y) n.+1
  -
H: Funext
X, Y: Type
H0: Finite X
H1: Finite Y
e: X <~> Fin (fcard X)
fcard (forall x : Fin 0, (fun _ : Fin 0 => Y) x) =
nat_exp (fcard Y) 0 reflexivity.
  -
H: Funext
X, Y: Type
H0: Finite X
H1: Finite Y
e: X <~> Fin (fcard X)
n: nat
IH: fcard (forall x : Fin n, (fun _ : Fin n => Y) x) =
nat_exp (fcard Y) n
fcard (forall x : Fin n.+1, (fun _ : Fin n.+1 => Y) x) =
nat_exp (fcard Y) n.+1 refine (fcard_equiv (equiv_sum_ind (fun (_:Fin n.+1) => Y))^-1 @ _).
H: Funext
X, Y: Type
H0: Finite X
H1: Finite Y
e: X <~> Fin (fcard X)
n: nat
IH: fcard (forall x : Fin n, (fun _ : Fin n => Y) x) =
nat_exp (fcard Y) n
fcard
  (((fix Fin (n : nat) : Type0 :=
       match n with
       | 0 => Empty
       | n0.+1 => (Fin n0 + Unit)%type
       end) n -> Y) * (Unit -> Y)) =
nat_exp (fcard Y) n.+1
    refine (fcard_prod _ _ @ _).
H: Funext
X, Y: Type
H0: Finite X
H1: Finite Y
e: X <~> Fin (fcard X)
n: nat
IH: fcard (forall x : Fin n, (fun _ : Fin n => Y) x) =
nat_exp (fcard Y) n
fcard
  (forall
   x : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n,
   (fun
      _ : (fix Fin (n : nat) : Type0 :=
             match n with
             | 0 => Empty
             | n0.+1 => (Fin n0 + Unit)%type
             end) n => Y) x) *
fcard (forall x : Unit, unit_name Y x) =
nat_exp (fcard Y) n.+1
    apply (ap011 mul).
H: Funext
X, Y: Type
H0: Finite X
H1: Finite Y
e: X <~> Fin (fcard X)
n: nat
IH: fcard (forall x : Fin n, (fun _ : Fin n => Y) x) =
nat_exp (fcard Y) n
fcard
  (forall
   x : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n,
   (fun
      _ : (fix Fin (n : nat) : Type0 :=
             match n with
             | 0 => Empty
             | n0.+1 => (Fin n0 + Unit)%type
             end) n => Y) x) =
(fix nat_exp (n m : nat) {struct m} : nat :=
   match m with
   | 0 => 1
   | m0.+1 => nat_exp n m0 * n
   end) (fcard Y) n
H: Funext
X, Y: Type
H0: Finite X
H1: Finite Y
e: X <~> Fin (fcard X)
n: nat
IH: fcard (forall x : Fin n, (fun _ : Fin n => Y) x) =
nat_exp (fcard Y) n
fcard (forall x : Unit, unit_name Y x) = fcard Y
    +
H: Funext
X, Y: Type
H0: Finite X
H1: Finite Y
e: X <~> Fin (fcard X)
n: nat
IH: fcard (forall x : Fin n, (fun _ : Fin n => Y) x) =
nat_exp (fcard Y) n
fcard
  (forall
   x : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n,
   (fun
      _ : (fix Fin (n : nat) : Type0 :=
             match n with
             | 0 => Empty
             | n0.+1 => (Fin n0 + Unit)%type
             end) n => Y) x) =
(fix nat_exp (n m : nat) {struct m} : nat :=
   match m with
   | 0 => 1
   | m0.+1 => nat_exp n m0 * n
   end) (fcard Y) n assumption.
    +
H: Funext
X, Y: Type
H0: Finite X
H1: Finite Y
e: X <~> Fin (fcard X)
n: nat
IH: fcard (forall x : Fin n, (fun _ : Fin n => Y) x) =
nat_exp (fcard Y) n
fcard (forall x : Unit, unit_name Y x) = fcard Y refine (fcard_equiv (@Unit_ind (fun (_:Unit) => Y))^-1).
Defined.

(** [fcard] still computes, despite the funext: *)
Goal forall fs:Funext, fcard (Fin 3 -> Fin 4) = 64.
forall fs : Funext,
fcard (forall x : Fin 3, (fun _ : Fin 3 => Fin 4) x) =
64
  reflexivity.
Abort.

(** *** Automorphism types (i.e. symmetric groups) *)

Global Instance finite_aut `{Funext} X `{Finite X}
: Finite (X <~> X).
H: Funext
X: Type
H0: Finite X
Finite (X <~> X)
Proof.
H: Funext
X: Type
H0: Finite X
Finite (X <~> X)
  assert (e := merely_equiv_fin X).
H: Funext
X: Type
H0: Finite X
e: merely (X <~> Fin (fcard X))
Finite (X <~> X)
  strip_truncations.
H: Funext
X: Type
H0: Finite X
e: X <~> Fin (fcard X)
Finite (X <~> X)
  refine (finite_equiv _
            (equiv_functor_equiv e^-1 e^-1) _).
H: Funext
X: Type
H0: Finite X
e: X <~> Fin (fcard X)
Finite (Fin (fcard X) <~> Fin (fcard X))
  generalize (fcard X); intros n.
H: Funext
X: Type
H0: Finite X
e: X <~> Fin (fcard X)
n: nat
Finite (Fin n <~> Fin n)
  induction n as [|n IH].
H: Funext
X: Type
H0: Finite X
e: X <~> Fin (fcard X)
Finite (Fin 0 <~> Fin 0)
H: Funext
X: Type
H0: Finite X
e: X <~> Fin (fcard X)
n: nat
IH: Finite (Fin n <~> Fin n)
Finite (Fin n.+1 <~> Fin n.+1)
  -
H: Funext
X: Type
H0: Finite X
e: X <~> Fin (fcard X)
Finite (Fin 0 <~> Fin 0) exact _.
  -
H: Funext
X: Type
H0: Finite X
e: X <~> Fin (fcard X)
n: nat
IH: Finite (Fin n <~> Fin n)
Finite (Fin n.+1 <~> Fin n.+1) refine (finite_equiv _ (equiv_fin_equiv n n) _).
Defined.

Definition fcard_aut `{Funext} X `{Finite X}
: fcard (X <~> X) = factorial (fcard X).
H: Funext
X: Type
H0: Finite X
fcard (X <~> X) = factorial (fcard X)
Proof.
H: Funext
X: Type
H0: Finite X
fcard (X <~> X) = factorial (fcard X)
  assert (e := merely_equiv_fin X).
H: Funext
X: Type
H0: Finite X
e: merely (X <~> Fin (fcard X))
fcard (X <~> X) = factorial (fcard X)
  strip_truncations.
H: Funext
X: Type
H0: Finite X
e: X <~> Fin (fcard X)
fcard (X <~> X) = factorial (fcard X)
  refine (fcard_equiv
            (equiv_functor_equiv e^-1 e^-1)^-1 @ _).
H: Funext
X: Type
H0: Finite X
e: X <~> Fin (fcard X)
fcard (Fin (fcard X) <~> Fin (fcard X)) =
factorial (fcard X)
  generalize (fcard X); intros n.
H: Funext
X: Type
H0: Finite X
e: X <~> Fin (fcard X)
n: nat
fcard (Fin n <~> Fin n) = factorial n
  induction n as [|n IH].
H: Funext
X: Type
H0: Finite X
e: X <~> Fin (fcard X)
fcard (Fin 0 <~> Fin 0) = factorial 0
H: Funext
X: Type
H0: Finite X
e: X <~> Fin (fcard X)
n: nat
IH: fcard (Fin n <~> Fin n) = factorial n
fcard (Fin n.+1 <~> Fin n.+1) = factorial n.+1
  -
H: Funext
X: Type
H0: Finite X
e: X <~> Fin (fcard X)
fcard (Fin 0 <~> Fin 0) = factorial 0 reflexivity.
  -
H: Funext
X: Type
H0: Finite X
e: X <~> Fin (fcard X)
n: nat
IH: fcard (Fin n <~> Fin n) = factorial n
fcard (Fin n.+1 <~> Fin n.+1) = factorial n.+1 refine (fcard_equiv (equiv_fin_equiv n n)^-1 @ _).
H: Funext
X: Type
H0: Finite X
e: X <~> Fin (fcard X)
n: nat
IH: fcard (Fin n <~> Fin n) = factorial n
fcard (Fin n.+1 * (Fin n <~> Fin n)) = factorial n.+1
    refine (fcard_prod _ _ @ _).
H: Funext
X: Type
H0: Finite X
e: X <~> Fin (fcard X)
n: nat
IH: fcard (Fin n <~> Fin n) = factorial n
fcard (Fin n.+1) * fcard (Fin n <~> Fin n) =
factorial n.+1
    apply ap011.
H: Funext
X: Type
H0: Finite X
e: X <~> Fin (fcard X)
n: nat
IH: fcard (Fin n <~> Fin n) = factorial n
fcard (Fin n.+1) = n.+1
H: Funext
X: Type
H0: Finite X
e: X <~> Fin (fcard X)
n: nat
IH: fcard (Fin n <~> Fin n) = factorial n
fcard (Fin n <~> Fin n) =
(fix factorial (n : nat) : nat :=
   match n with
   | 0 => 1
   | n0.+1 => n0.+1 * factorial n0
   end) n
    +
H: Funext
X: Type
H0: Finite X
e: X <~> Fin (fcard X)
n: nat
IH: fcard (Fin n <~> Fin n) = factorial n
fcard (Fin n.+1) = n.+1 reflexivity.
    +
H: Funext
X: Type
H0: Finite X
e: X <~> Fin (fcard X)
n: nat
IH: fcard (Fin n <~> Fin n) = factorial n
fcard (Fin n <~> Fin n) =
(fix factorial (n : nat) : nat :=
   match n with
   | 0 => 1
   | n0.+1 => n0.+1 * factorial n0
   end) n assumption.
Defined.

(** [fcard] still computes: *)
Goal forall fs:Funext, fcard (Fin 4 <~> Fin 4) = 24.
forall fs : Funext, fcard (Fin 4 <~> Fin 4) = 24
  reflexivity.
Abort.

(** ** Finite sums of natural numbers *)

(** Perhaps slightly less obviously, finite sets are also closed under sigmas. *)

Global Instance finite_sigma {X} (Y : X -> Type)
       `{Finite X} `{forall x, Finite (Y x)}
: Finite { x:X & Y x }.
X: Type
Y: X -> Type
H: Finite X
H0: forall x : X, Finite (Y x)
Finite {x : X & Y x}
Proof.
X: Type
Y: X -> Type
H: Finite X
H0: forall x : X, Finite (Y x)
Finite {x : X & Y x}
  assert (e := merely_equiv_fin X).
X: Type
Y: X -> Type
H: Finite X
H0: forall x : X, Finite (Y x)
e: merely (X <~> Fin (fcard X))
Finite {x : X & Y x}
  strip_truncations.
X: Type
Y: X -> Type
H: Finite X
H0: forall x : X, Finite (Y x)
e: X <~> Fin (fcard X)
Finite {x : X & Y x}
  refine (finite_equiv' _
            (equiv_functor_sigma (equiv_inverse e)
                                 (fun x (y:Y (e^-1 x)) => y)) _).
X: Type
Y: X -> Type
H: Finite X
H0: forall x : X, Finite (Y x)
e: X <~> Fin (fcard X)
Finite {x : Fin (fcard X) & Y (e^-1 x)}
  (** Unfortunately, because [compose] is currently beta-expanded, [set (Y' := Y o e^-1)] doesn't change the goal. *)
  set (Y' := fun x => Y (e^-1 x)).
X: Type
Y: X -> Type
H: Finite X
H0: forall x : X, Finite (Y x)
e: X <~> Fin (fcard X)
Y':= fun x : Fin (fcard X) => Y (e^-1 x): Fin (fcard X) -> Type
Finite {x : _ & Y' x}
  assert (forall x, Finite (Y' x)) by exact _; clearbody Y'; clear e.
X: Type
Y: X -> Type
H: Finite X
H0: forall x : X, Finite (Y x)
Y': Fin (fcard X) -> Type
X0: forall x : Fin (fcard X), Finite (Y' x)
Finite {x : _ & Y' x}
  generalize dependent (fcard X); intros n Y' ?.
X: Type
Y: X -> Type
H: Finite X
H0: forall x : X, Finite (Y x)
n: nat
Y': Fin n -> Type
X0: forall x : Fin n, Finite (Y' x)
Finite {x : _ & Y' x}
  induction n as [|n IH].
X: Type
Y: X -> Type
H: Finite X
H0: forall x : X, Finite (Y x)
Y': Fin 0 -> Type
X0: forall x : Fin 0, Finite (Y' x)
Finite {x : _ & Y' x}
X: Type
Y: X -> Type
H: Finite X
H0: forall x : X, Finite (Y x)
n: nat
Y': Fin n.+1 -> Type
X0: forall x : Fin n.+1, Finite (Y' x)
IH: forall Y' : Fin n -> Type,
(forall x : Fin n, Finite (Y' x)) ->
Finite {x : _ & Y' x}
Finite {x : _ & Y' x}
  -
X: Type
Y: X -> Type
H: Finite X
H0: forall x : X, Finite (Y x)
Y': Fin 0 -> Type
X0: forall x : Fin 0, Finite (Y' x)
Finite {x : _ & Y' x} refine (finite_equiv Empty pr1^-1 _).
  -
X: Type
Y: X -> Type
H: Finite X
H0: forall x : X, Finite (Y x)
n: nat
Y': Fin n.+1 -> Type
X0: forall x : Fin n.+1, Finite (Y' x)
IH: forall Y' : Fin n -> Type,
(forall x : Fin n, Finite (Y' x)) ->
Finite {x : _ & Y' x}
Finite {x : _ & Y' x} refine (finite_equiv _ (equiv_sigma_sum (Fin n) Unit Y')^-1 _).
X: Type
Y: X -> Type
H: Finite X
H0: forall x : X, Finite (Y x)
n: nat
Y': Fin n.+1 -> Type
X0: forall x : Fin n.+1, Finite (Y' x)
IH: forall Y' : Fin n -> Type,
(forall x : Fin n, Finite (Y' x)) ->
Finite {x : _ & Y' x}
Finite
  ({a : Fin n & Y' (inl a)} + {b : Unit & Y' (inr b)})
    apply finite_sum.
X: Type
Y: X -> Type
H: Finite X
H0: forall x : X, Finite (Y x)
n: nat
Y': Fin n.+1 -> Type
X0: forall x : Fin n.+1, Finite (Y' x)
IH: forall Y' : Fin n -> Type,
(forall x : Fin n, Finite (Y' x)) ->
Finite {x : _ & Y' x}
Finite {a : Fin n & Y' (inl a)}
X: Type
Y: X -> Type
H: Finite X
H0: forall x : X, Finite (Y x)
n: nat
Y': Fin n.+1 -> Type
X0: forall x : Fin n.+1, Finite (Y' x)
IH: forall Y' : Fin n -> Type,
(forall x : Fin n, Finite (Y' x)) ->
Finite {x : _ & Y' x}
Finite {b : Unit & Y' (inr b)}
    +
X: Type
Y: X -> Type
H: Finite X
H0: forall x : X, Finite (Y x)
n: nat
Y': Fin n.+1 -> Type
X0: forall x : Fin n.+1, Finite (Y' x)
IH: forall Y' : Fin n -> Type,
(forall x : Fin n, Finite (Y' x)) ->
Finite {x : _ & Y' x}
Finite {a : Fin n & Y' (inl a)} apply IH; exact _.
    +
X: Type
Y: X -> Type
H: Finite X
H0: forall x : X, Finite (Y x)
n: nat
Y': Fin n.+1 -> Type
X0: forall x : Fin n.+1, Finite (Y' x)
IH: forall Y' : Fin n -> Type,
(forall x : Fin n, Finite (Y' x)) ->
Finite {x : _ & Y' x}
Finite {b : Unit & Y' (inr b)} refine (finite_equiv _ (equiv_contr_sigma _)^-1 _).
Defined.

(** Amusingly, this automatically gives us a way to add up a family of natural numbers indexed by any finite set.  (We could of course also define such an operation directly, probably using [merely_ind_hset].) *)

Definition finadd {X} `{Finite X} (f : X -> nat) : nat
  := fcard { x:X & Fin (f x) }.

Definition fcard_sigma {X} (Y : X -> Type)
       `{Finite X} `{forall x, Finite (Y x)}
: fcard { x:X & Y x } = finadd (fun x => fcard (Y x)).
X: Type
Y: X -> Type
H: Finite X
H0: forall x : X, Finite (Y x)
fcard {x : X & Y x} =
finadd (fun x : X => fcard (Y x))
Proof.
X: Type
Y: X -> Type
H: Finite X
H0: forall x : X, Finite (Y x)
fcard {x : X & Y x} =
finadd (fun x : X => fcard (Y x))
  set (f := fun x => fcard (Y x)).
X: Type
Y: X -> Type
H: Finite X
H0: forall x : X, Finite (Y x)
f:= fun x : X => fcard (Y x): X -> nat
fcard {x : X & Y x} = finadd f
  set (g := fun x => merely_equiv_fin (Y x) : merely (Y x <~> Fin (f x))).
X: Type
Y: X -> Type
H: Finite X
H0: forall x : X, Finite (Y x)
f:= fun x : X => fcard (Y x): X -> nat
g:= fun x : X =>
merely_equiv_fin (Y x) : merely (Y x <~> Fin (f x)): forall x : X, merely (Y x <~> Fin (f x))
fcard {x : X & Y x} = finadd f
  apply finite_choice in g; [| exact _].
X: Type
Y: X -> Type
H: Finite X
H0: forall x : X, Finite (Y x)
f:= fun x : X => fcard (Y x): X -> nat
g: merely (forall x : X, Y x <~> Fin (f x))
fcard {x : X & Y x} = finadd f
  strip_truncations.
X: Type
Y: X -> Type
H: Finite X
H0: forall x : X, Finite (Y x)
f:= fun x : X => fcard (Y x): X -> nat
g: forall x : X, Y x <~> Fin (f x)
fcard {x : X & Y x} = finadd f
  unfold finadd.
X: Type
Y: X -> Type
H: Finite X
H0: forall x : X, Finite (Y x)
f:= fun x : X => fcard (Y x): X -> nat
g: forall x : X, Y x <~> Fin (f x)
fcard {x : X & Y x} =
fcard {x : X & (fun x0 : X => Fin (f x0)) x}
  refine (fcard_equiv' (equiv_functor_sigma_id g)).
Defined.

(** The sum of a finite constant family is the product by its cardinality. *)
Definition finadd_const X `{Finite X} n
: finadd (fun x:X => n) = fcard X * n.
X: Type
H: Finite X
n: nat
finadd (fun _ : X => n) = fcard X * n
Proof.
X: Type
H: Finite X
n: nat
finadd (fun _ : X => n) = fcard X * n
  transitivity (fcard (X * Fin n)).
X: Type
H: Finite X
n: nat
finadd (fun _ : X => n) = fcard (X * Fin n)
X: Type
H: Finite X
n: nat
fcard (X * Fin n) = fcard X * n
  -
X: Type
H: Finite X
n: nat
finadd (fun _ : X => n) = fcard (X * Fin n) exact (fcard_equiv' (equiv_sigma_prod0 X (Fin n))).
  -
X: Type
H: Finite X
n: nat
fcard (X * Fin n) = fcard X * n exact (fcard_prod X (Fin n)).
Defined.

(** Closure under sigmas and paths also implies closure under hfibers. *)
Definition finite_hfiber {X Y} (f : X -> Y) (y : Y)
       `{Finite X} `{Finite Y}
: Finite (hfiber f y).
X, Y: Type
f: X -> Y
y: Y
H: Finite X
H0: Finite Y
Finite (hfiber f y)
Proof.
X, Y: Type
f: X -> Y
y: Y
H: Finite X
H0: Finite Y
Finite (hfiber f y)
  exact _.
Defined.

(** Therefore, the cardinality of the domain of a map between finite sets is the sum of the cardinalities of its hfibers. *)
Definition fcard_domain {X Y} (f : X -> Y) `{Finite X} `{Finite Y}
: fcard X = finadd (fun y => fcard (hfiber f y)).
X, Y: Type
f: X -> Y
H: Finite X
H0: Finite Y
fcard X =
finadd
  (fun y : Y =>
   fcard {x : X & (fun x0 : X => f x0 = y) x})
Proof.
X, Y: Type
f: X -> Y
H: Finite X
H0: Finite Y
fcard X =
finadd
  (fun y : Y =>
   fcard {x : X & (fun x0 : X => f x0 = y) x})
  refine (_ @ fcard_sigma (hfiber f)).
X, Y: Type
f: X -> Y
H: Finite X
H0: Finite Y
fcard X = fcard {x : Y & hfiber f x}
  refine (fcard_equiv' (equiv_fibration_replacement f)).
Defined.

(** In particular, the image of a map between finite sets is finite. *)
Definition finite_image
       {X Y} `{Finite X} `{Finite Y} (f : X -> Y)
: Finite (himage f).
X, Y: Type
H: Finite X
H0: Finite Y
f: X -> Y
Finite (himage f)
Proof.
X, Y: Type
H: Finite X
H0: Finite Y
f: X -> Y
Finite (himage f)
  exact _.
Defined.

(** ** Finite products of natural numbers *)

(** Similarly, closure of finite sets under [forall] automatically gives us a way to multiply a family of natural numbers indexed by any finite set.  Of course, if we defined this explicitly, it wouldn't need funext. *)

Definition finmult `{Funext} {X} `{Finite X} (f : X -> nat) : nat
  := fcard (forall x:X, Fin (f x)).

Definition fcard_forall `{Funext} {X} (Y : X -> Type)
       `{Finite X} `{forall x, Finite (Y x)}
: fcard (forall x:X, Y x) = finmult (fun x => fcard (Y x)).
H: Funext
X: Type
Y: X -> Type
H0: Finite X
H1: forall x : X, Finite (Y x)
fcard (forall x : X, Y x) =
finmult (fun x : X => fcard (Y x))
Proof.
H: Funext
X: Type
Y: X -> Type
H0: Finite X
H1: forall x : X, Finite (Y x)
fcard (forall x : X, Y x) =
finmult (fun x : X => fcard (Y x))
  set (f := fun x => fcard (Y x)).
H: Funext
X: Type
Y: X -> Type
H0: Finite X
H1: forall x : X, Finite (Y x)
f:= fun x : X => fcard (Y x): X -> nat
fcard (forall x : X, Y x) = finmult f
  set (g := fun x => merely_equiv_fin (Y x) : merely (Y x <~> Fin (f x))).
H: Funext
X: Type
Y: X -> Type
H0: Finite X
H1: forall x : X, Finite (Y x)
f:= fun x : X => fcard (Y x): X -> nat
g:= fun x : X =>
merely_equiv_fin (Y x) : merely (Y x <~> Fin (f x)): forall x : X, merely (Y x <~> Fin (f x))
fcard (forall x : X, Y x) = finmult f
  apply finite_choice in g; [| exact _].
H: Funext
X: Type
Y: X -> Type
H0: Finite X
H1: forall x : X, Finite (Y x)
f:= fun x : X => fcard (Y x): X -> nat
g: merely (forall x : X, Y x <~> Fin (f x))
fcard (forall x : X, Y x) = finmult f
  strip_truncations.
H: Funext
X: Type
Y: X -> Type
H0: Finite X
H1: forall x : X, Finite (Y x)
f:= fun x : X => fcard (Y x): X -> nat
g: forall x : X, Y x <~> Fin (f x)
fcard (forall x : X, Y x) = finmult f
  unfold finmult.
H: Funext
X: Type
Y: X -> Type
H0: Finite X
H1: forall x : X, Finite (Y x)
f:= fun x : X => fcard (Y x): X -> nat
g: forall x : X, Y x <~> Fin (f x)
fcard (forall x : X, Y x) =
fcard (forall x : X, (fun x0 : X => Fin (f x0)) x)
  refine (fcard_equiv' (equiv_functor_forall' (equiv_idmap X) g)).
Defined.

(** The product of a finite constant family is the exponential by its cardinality. *)
Definition finmult_const `{Funext} X `{Finite X} n
: finmult (fun x:X => n) = nat_exp n (fcard X).
H: Funext
X: Type
H0: Finite X
n: nat
finmult (fun _ : X => n) = nat_exp n (fcard X)
Proof.
H: Funext
X: Type
H0: Finite X
n: nat
finmult (fun _ : X => n) = nat_exp n (fcard X)
  refine (fcard_arrow X (Fin n)).
Defined.


(** ** Finite subsets *)

(** Closure under sigmas implies that a detachable subset of a finite set is finite. *)
Global Instance finite_detachable_subset {X} `{Finite X} (P : X -> Type)
       `{forall x, IsHProp (P x)} `{forall x, Decidable (P x)}
: Finite { x:X & P x }.
X: Type
H: Finite X
P: X -> Type
H0: forall x : X, IsHProp (P x)
H1: forall x : X, Decidable (P x)
Finite {x : X & P x}
Proof.
X: Type
H: Finite X
P: X -> Type
H0: forall x : X, IsHProp (P x)
H1: forall x : X, Decidable (P x)
Finite {x : X & P x}
  exact _.
Defined.

(** Conversely, if a subset of a finite set is finite, then it is detachable.  We show first that an embedding between finite subsets has detachable image. *)
Definition detachable_image_finite
           {X Y} `{Finite X} `{Finite Y} (f : X -> Y) `{IsEmbedding f}
: forall y, Decidable (hfiber f y).
X, Y: Type
H: Finite X
H0: Finite Y
f: X -> Y
IsEmbedding0: IsEmbedding f
forall y : Y, Decidable (hfiber f y)
Proof.
X, Y: Type
H: Finite X
H0: Finite Y
f: X -> Y
IsEmbedding0: IsEmbedding f
forall y : Y, Decidable (hfiber f y)
  intros y.
X, Y: Type
H: Finite X
H0: Finite Y
f: X -> Y
IsEmbedding0: IsEmbedding f
y: Y
Decidable (hfiber f y)
  assert (ff : Finite (hfiber f y)) by exact _.
X, Y: Type
H: Finite X
H0: Finite Y
f: X -> Y
IsEmbedding0: IsEmbedding f
y: Y
ff: Finite (hfiber f y)
Decidable (hfiber f y)
  destruct ff as [[|n] e].
X, Y: Type
H: Finite X
H0: Finite Y
f: X -> Y
IsEmbedding0: IsEmbedding f
y: Y
e: merely (hfiber f y <~> Fin 0)
Decidable (hfiber f y)
X, Y: Type
H: Finite X
H0: Finite Y
f: X -> Y
IsEmbedding0: IsEmbedding f
y: Y
n: nat
e: merely (hfiber f y <~> Fin n.+1)
Decidable (hfiber f y)
  -
X, Y: Type
H: Finite X
H0: Finite Y
f: X -> Y
IsEmbedding0: IsEmbedding f
y: Y
e: merely (hfiber f y <~> Fin 0)
Decidable (hfiber f y) right; intros u; strip_truncations; exact (e u).
  -
X, Y: Type
H: Finite X
H0: Finite Y
f: X -> Y
IsEmbedding0: IsEmbedding f
y: Y
n: nat
e: merely (hfiber f y <~> Fin n.+1)
Decidable (hfiber f y) left; strip_truncations; exact (e^-1 (inr tt)).
Defined.

Definition detachable_finite_subset {X} `{Finite X}
           (P : X -> Type) `{forall x, IsHProp (P x)}
           {Pf : Finite ({ x:X & P x })}
: forall x, Decidable (P x).
X: Type
H: Finite X
P: X -> Type
H0: forall x : X, IsHProp (P x)
Pf: Finite {x : X & P x}
forall x : X, Decidable (P x)
Proof.
X: Type
H: Finite X
P: X -> Type
H0: forall x : X, IsHProp (P x)
Pf: Finite {x : X & P x}
forall x : X, Decidable (P x)
  intros x.
X: Type
H: Finite X
P: X -> Type
H0: forall x : X, IsHProp (P x)
Pf: Finite {x : X & P x}
x: X
Decidable (P x)
  refine (decidable_equiv _ (hfiber_fibration x P)^-1 _).
X: Type
H: Finite X
P: X -> Type
H0: forall x : X, IsHProp (P x)
Pf: Finite {x : X & P x}
x: X
Decidable (hfiber pr1 x)
  (* The try clause below is only needed for Coq <= 8.11 *)
  refine (detachable_image_finite pr1 x); try assumption.
X: Type
H: Finite X
P: X -> Type
H0: forall x : X, IsHProp (P x)
Pf: Finite {x : X & P x}
x: X
IsEmbedding pr1
  -
X: Type
H: Finite X
P: X -> Type
H0: forall x : X, IsHProp (P x)
Pf: Finite {x : X & P x}
x: X
IsEmbedding pr1 apply (mapinO_pr1 (Tr (-1))).  (** Why doesn't Coq find this? *)
Defined.

(** ** Quotients *)

(** The quotient of a finite set by a detachable equivalence relation is finite. *)

Section DecidableQuotients.
  Context `{Univalence} {X} `{Finite X}
          (R : Relation X) `{is_mere_relation X R}
          `{Reflexive _ R} `{Transitive _ R} `{Symmetric _ R}
          {Rd : forall x y, Decidable (R x y)}.

  Global Instance finite_quotient : Finite (Quotient R).
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
Finite (Quotient R)
  Proof.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
Finite (Quotient R)
    assert (e := merely_equiv_fin X).
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
e: merely (X <~> Fin (fcard X))
Finite (Quotient R)
    strip_truncations.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
e: X <~> Fin (fcard X)
Finite (Quotient R)
    pose (R' x y := R (e^-1 x) (e^-1 y)).
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
e: X <~> Fin (fcard X)
R':= fun x y : Fin (fcard X) => R (e^-1 x) (e^-1 y): Fin (fcard X) -> Fin (fcard X) -> Type
Finite (Quotient R)
    assert (is_mere_relation _ R') by exact _.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
e: X <~> Fin (fcard X)
R':= fun x y : Fin (fcard X) => R (e^-1 x) (e^-1 y): Fin (fcard X) -> Fin (fcard X) -> Type
X0: is_mere_relation (Fin (fcard X)) R'
Finite (Quotient R)
    assert (Reflexive R') by (intros ?; unfold R'; apply reflexivity).
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
e: X <~> Fin (fcard X)
R':= fun x y : Fin (fcard X) => R (e^-1 x) (e^-1 y): Fin (fcard X) -> Fin (fcard X) -> Type
X0: is_mere_relation (Fin (fcard X)) R'
X1: Reflexive R'
Finite (Quotient R)
    assert (Symmetric R') by (intros ? ?; unfold R'; apply symmetry).
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
e: X <~> Fin (fcard X)
R':= fun x y : Fin (fcard X) => R (e^-1 x) (e^-1 y): Fin (fcard X) -> Fin (fcard X) -> Type
X0: is_mere_relation (Fin (fcard X)) R'
X1: Reflexive R'
X2: Symmetric R'
Finite (Quotient R)
    assert (Transitive R') by (intros ? ? ?; unfold R'; apply transitivity).
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
e: X <~> Fin (fcard X)
R':= fun x y : Fin (fcard X) => R (e^-1 x) (e^-1 y): Fin (fcard X) -> Fin (fcard X) -> Type
X0: is_mere_relation (Fin (fcard X)) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
Finite (Quotient R)
    assert (R'd : forall x y, Decidable (R' x y))
      by (intros ? ?; unfold R'; apply Rd).
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
e: X <~> Fin (fcard X)
R':= fun x y : Fin (fcard X) => R (e^-1 x) (e^-1 y): Fin (fcard X) -> Fin (fcard X) -> Type
X0: is_mere_relation (Fin (fcard X)) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin (fcard X), Decidable (R' x y)
Finite (Quotient R)
    srefine (finite_equiv' _ (equiv_quotient_functor R' R e^-1 _) _).
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
e: X <~> Fin (fcard X)
R':= fun x y : Fin (fcard X) => R (e^-1 x) (e^-1 y): Fin (fcard X) -> Fin (fcard X) -> Type
X0: is_mere_relation (Fin (fcard X)) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin (fcard X), Decidable (R' x y)
forall x y : Fin (fcard X),
R' x y <-> R (e^-1 x) (e^-1 y)
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
e: X <~> Fin (fcard X)
R':= fun x y : Fin (fcard X) => R (e^-1 x) (e^-1 y): Fin (fcard X) -> Fin (fcard X) -> Type
X0: is_mere_relation (Fin (fcard X)) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin (fcard X), Decidable (R' x y)
Finite (Quotient R')
    1: by try (intros; split).
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
e: X <~> Fin (fcard X)
R':= fun x y : Fin (fcard X) => R (e^-1 x) (e^-1 y): Fin (fcard X) -> Fin (fcard X) -> Type
X0: is_mere_relation (Fin (fcard X)) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin (fcard X), Decidable (R' x y)
Finite (Quotient R')
    clearbody R'; clear e.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
R': Fin (fcard X) -> Fin (fcard X) -> Type
X0: is_mere_relation (Fin (fcard X)) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin (fcard X), Decidable (R' x y)
Finite (Quotient R')
    generalize dependent (fcard X);
      intros n; induction n as [|n IH]; intros R' ? ? ? ? ?.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
R': Fin 0 -> Fin 0 -> Type
X0: is_mere_relation (Fin 0) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin 0, Decidable (R' x y)
Finite (Quotient R')
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
Finite (Quotient R')
    -
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
R': Fin 0 -> Fin 0 -> Type
X0: is_mere_relation (Fin 0) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin 0, Decidable (R' x y)
Finite (Quotient R') refine (finite_equiv Empty _^-1 _).
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
R': Fin 0 -> Fin 0 -> Type
X0: is_mere_relation (Fin 0) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin 0, Decidable (R' x y)
Quotient R' -> Empty
      refine (Quotient_rec R' _ Empty_rec (fun x _ _ => match x with end)).
    -
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
Finite (Quotient R') pose (R'' x y := R' (inl x) (inl y)).
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
Finite (Quotient R')
      assert (is_mere_relation _ R'') by exact _.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
Finite (Quotient R')
      assert (Reflexive R'') by (intros ?; unfold R''; apply reflexivity).
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
Finite (Quotient R')
      assert (Symmetric R'') by (intros ? ?; unfold R''; apply symmetry).
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
Finite (Quotient R')
      assert (Transitive R'') by (intros ? ? ?; unfold R''; apply transitivity).
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
Finite (Quotient R')
      assert (forall x y, Decidable (R'' x y)) by (intros ? ?; unfold R''; apply R'd).
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
Finite (Quotient R')
      assert (inlresp := (fun x y => idmap)
                         : forall x y, R'' x y -> R' (inl x) (inl y)).
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
Finite (Quotient R')
      destruct (dec (merely {x:Fin n & R' (inl x) (inr tt)})) as [p|np].
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
p: merely {x : Fin n & R' (inl x) (inr tt)}
Finite (Quotient R')
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
Finite (Quotient R')
      {
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
p: merely {x : Fin n & R' (inl x) (inr tt)}
Finite (Quotient R') strip_truncations.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
p: {x : Fin n & R' (inl x) (inr tt)}
Finite (Quotient R')
        destruct p as [x r].
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
x: Fin n
r: R' (inl x) (inr tt)
Finite (Quotient R')
        refine (finite_equiv' (Quotient R'') _ _).
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
x: Fin n
r: R' (inl x) (inr tt)
Quotient R'' <~> Quotient R'
        refine (Build_Equiv _ _ (Quotient_functor R'' R' inl inlresp) _).
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
x: Fin n
r: R' (inl x) (inr tt)
IsEquiv (Quotient_functor R'' R' inl inlresp)
        apply isequiv_surj_emb.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
x: Fin n
r: R' (inl x) (inr tt)
IsConnMap (Tr (-1))
  (Quotient_functor R'' R' inl inlresp)
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
x: Fin n
r: R' (inl x) (inr tt)
IsEmbedding (Quotient_functor R'' R' inl inlresp)
        -
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
x: Fin n
r: R' (inl x) (inr tt)
IsConnMap (Tr (-1))
  (Quotient_functor R'' R' inl inlresp) apply BuildIsSurjection.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
x: Fin n
r: R' (inl x) (inr tt)
forall b : Quotient R',
merely
  (hfiber (Quotient_functor R'' R' inl inlresp) b)
          refine (Quotient_ind_hprop R' _ _).
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
x: Fin n
r: R' (inl x) (inr tt)
forall x : Fin n.+1,
merely
  (hfiber (Quotient_functor R'' R' inl inlresp)
     (class_of R' x))
          intros [y|[]]; apply tr.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
x: Fin n
r: R' (inl x) (inr tt)
y: Fin n
hfiber (Quotient_functor R'' R' inl inlresp)
  (class_of R' (inl y))
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
x: Fin n
r: R' (inl x) (inr tt)
hfiber (Quotient_functor R'' R' inl inlresp)
  (class_of R' (inr tt))
          +
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
x: Fin n
r: R' (inl x) (inr tt)
y: Fin n
hfiber (Quotient_functor R'' R' inl inlresp)
  (class_of R' (inl y)) exists (class_of R'' y); reflexivity.
          +
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
x: Fin n
r: R' (inl x) (inr tt)
hfiber (Quotient_functor R'' R' inl inlresp)
  (class_of R' (inr tt)) exists (class_of R'' x); simpl.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
x: Fin n
r: R' (inl x) (inr tt)
class_of R' (inl x) = class_of R' (inr tt)
            apply qglue, r.
        -
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
x: Fin n
r: R' (inl x) (inr tt)
IsEmbedding (Quotient_functor R'' R' inl inlresp) apply isembedding_isinj_hset; intros u.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
x: Fin n
r: R' (inl x) (inr tt)
u: Quotient R''
forall x1 : Quotient R'',
Quotient_functor R'' R' inl inlresp u =
Quotient_functor R'' R' inl inlresp x1 -> u = x1
          refine (Quotient_ind_hprop R'' _ _); intros v.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
x: Fin n
r: R' (inl x) (inr tt)
u: Quotient R''
v: (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n
Quotient_functor R'' R' inl inlresp u =
Quotient_functor R'' R' inl inlresp (class_of R'' v) ->
u = class_of R'' v
          revert u; refine (Quotient_ind_hprop R'' _ _); intros u.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
x: Fin n
r: R' (inl x) (inr tt)
v, u: (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n
Quotient_functor R'' R' inl inlresp (class_of R'' u) =
Quotient_functor R'' R' inl inlresp (class_of R'' v) ->
class_of R'' u = class_of R'' v
          simpl; intros q.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
x: Fin n
r: R' (inl x) (inr tt)
v, u: (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n
q: class_of R' (inl u) = class_of R' (inl v)
class_of R'' u = class_of R'' v
          apply qglue; unfold R''.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
x: Fin n
r: R' (inl x) (inr tt)
v, u: (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n
q: class_of R' (inl u) = class_of R' (inl v)
R' (inl u) (inl v)
          exact (related_quotient_paths R' (inl u) (inl v) q). }
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
Finite (Quotient R')
      {
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
Finite (Quotient R') refine (finite_equiv' (Quotient R'' + Unit) _ _).
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
Quotient R'' + Unit <~> Quotient R'
        refine (Build_Equiv _ _ (sum_ind (fun _ => Quotient R')
                                        (Quotient_functor R'' R' inl inlresp)
                                        (fun _ => class_of R' (inr tt))) _).
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
IsEquiv
  (sum_ind
     (fun _ : Quotient R'' + Unit => Quotient R')
     (Quotient_functor R'' R' inl inlresp)
     (unit_name (class_of R' (inr tt))))
        apply isequiv_surj_emb.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
IsConnMap (Tr (-1))
  (sum_ind
     (fun _ : Quotient R'' + Unit => Quotient R')
     (Quotient_functor R'' R' inl inlresp)
     (unit_name (class_of R' (inr tt))))
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
IsEmbedding
  (sum_ind
     (fun _ : Quotient R'' + Unit => Quotient R')
     (Quotient_functor R'' R' inl inlresp)
     (unit_name (class_of R' (inr tt))))
        -
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
IsConnMap (Tr (-1))
  (sum_ind
     (fun _ : Quotient R'' + Unit => Quotient R')
     (Quotient_functor R'' R' inl inlresp)
     (unit_name (class_of R' (inr tt)))) apply BuildIsSurjection.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
forall b : Quotient R',
merely
  (hfiber
     (sum_ind
        (fun _ : Quotient R'' + Unit => Quotient R')
        (Quotient_functor R'' R' inl inlresp)
        (unit_name (class_of R' (inr tt)))) b)
          refine (Quotient_ind_hprop R' _ _).
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
forall x : Fin n.+1,
merely
  (hfiber
     (sum_ind
        (fun _ : Quotient R'' + Unit => Quotient R')
        (Quotient_functor R'' R' inl inlresp)
        (unit_name (class_of R' (inr tt))))
     (class_of R' x))
          intros [y|[]]; apply tr.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
y: Fin n
hfiber
  (sum_ind
     (fun _ : Quotient R'' + Unit => Quotient R')
     (Quotient_functor R'' R' inl inlresp)
     (unit_name (class_of R' (inr tt))))
  (class_of R' (inl y))
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
hfiber
  (sum_ind
     (fun _ : Quotient R'' + Unit => Quotient R')
     (Quotient_functor R'' R' inl inlresp)
     (unit_name (class_of R' (inr tt))))
  (class_of R' (inr tt))
          +
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
y: Fin n
hfiber
  (sum_ind
     (fun _ : Quotient R'' + Unit => Quotient R')
     (Quotient_functor R'' R' inl inlresp)
     (unit_name (class_of R' (inr tt))))
  (class_of R' (inl y)) exists (inl (class_of R'' y)); reflexivity.
          +
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
hfiber
  (sum_ind
     (fun _ : Quotient R'' + Unit => Quotient R')
     (Quotient_functor R'' R' inl inlresp)
     (unit_name (class_of R' (inr tt))))
  (class_of R' (inr tt)) exists (inr tt); reflexivity.
        -
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
IsEmbedding
  (sum_ind
     (fun _ : Quotient R'' + Unit => Quotient R')
     (Quotient_functor R'' R' inl inlresp)
     (unit_name (class_of R' (inr tt)))) apply isembedding_isinj_hset; intros u.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
u: (Quotient R'' + Unit)%type
forall x1 : Quotient R'' + Unit,
sum_ind (fun _ : Quotient R'' + Unit => Quotient R')
  (Quotient_functor R'' R' inl inlresp)
  (unit_name (class_of R' (inr tt))) u =
sum_ind (fun _ : Quotient R'' + Unit => Quotient R')
  (Quotient_functor R'' R' inl inlresp)
  (unit_name (class_of R' (inr tt))) x1 -> u = x1
          refine (sum_ind _ _ _).
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
u: (Quotient R'' + Unit)%type
forall a : Quotient R'',
sum_ind (fun _ : Quotient R'' + Unit => Quotient R')
  (Quotient_functor R'' R' inl inlresp)
  (unit_name (class_of R' (inr tt))) u =
sum_ind (fun _ : Quotient R'' + Unit => Quotient R')
  (Quotient_functor R'' R' inl inlresp)
  (unit_name (class_of R' (inr tt))) (inl a) ->
u = inl a
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
u: (Quotient R'' + Unit)%type
forall b : Unit,
sum_ind (fun _ : Quotient R'' + Unit => Quotient R')
  (Quotient_functor R'' R' inl inlresp)
  (unit_name (class_of R' (inr tt))) u =
sum_ind (fun _ : Quotient R'' + Unit => Quotient R')
  (Quotient_functor R'' R' inl inlresp)
  (unit_name (class_of R' (inr tt))) 
  (inr b) -> u = inr b
          +
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
u: (Quotient R'' + Unit)%type
forall a : Quotient R'',
sum_ind (fun _ : Quotient R'' + Unit => Quotient R')
  (Quotient_functor R'' R' inl inlresp)
  (unit_name (class_of R' (inr tt))) u =
sum_ind (fun _ : Quotient R'' + Unit => Quotient R')
  (Quotient_functor R'' R' inl inlresp)
  (unit_name (class_of R' (inr tt))) (inl a) ->
u = inl a refine (Quotient_ind_hprop R'' _ _); intros v.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
u: (Quotient R'' + Unit)%type
v: (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n
sum_ind (fun _ : Quotient R'' + Unit => Quotient R')
  (Quotient_functor R'' R' inl inlresp)
  (unit_name (class_of R' (inr tt))) u =
sum_ind (fun _ : Quotient R'' + Unit => Quotient R')
  (Quotient_functor R'' R' inl inlresp)
  (unit_name (class_of R' (inr tt)))
  (inl (class_of R'' v)) -> u = inl (class_of R'' v)
            revert u; refine (sum_ind _ _ _).
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
v: (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n
forall a : Quotient R'',
sum_ind (fun _ : Quotient R'' + Unit => Quotient R')
  (Quotient_functor R'' R' inl inlresp)
  (unit_name (class_of R' (inr tt))) (inl a) =
sum_ind (fun _ : Quotient R'' + Unit => Quotient R')
  (Quotient_functor R'' R' inl inlresp)
  (unit_name (class_of R' (inr tt)))
  (inl (class_of R'' v)) ->
inl a = inl (class_of R'' v)
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
v: (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n
forall b : Unit,
sum_ind (fun _ : Quotient R'' + Unit => Quotient R')
  (Quotient_functor R'' R' inl inlresp)
  (unit_name (class_of R' (inr tt))) 
  (inr b) =
sum_ind (fun _ : Quotient R'' + Unit => Quotient R')
  (Quotient_functor R'' R' inl inlresp)
  (unit_name (class_of R' (inr tt)))
  (inl (class_of R'' v)) ->
inr b = inl (class_of R'' v)
            *
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
v: (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n
forall a : Quotient R'',
sum_ind (fun _ : Quotient R'' + Unit => Quotient R')
  (Quotient_functor R'' R' inl inlresp)
  (unit_name (class_of R' (inr tt))) (inl a) =
sum_ind (fun _ : Quotient R'' + Unit => Quotient R')
  (Quotient_functor R'' R' inl inlresp)
  (unit_name (class_of R' (inr tt)))
  (inl (class_of R'' v)) ->
inl a = inl (class_of R'' v) refine (Quotient_ind_hprop R'' _ _); intros u.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
v, u: (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n
sum_ind (fun _ : Quotient R'' + Unit => Quotient R')
  (Quotient_functor R'' R' inl inlresp)
  (unit_name (class_of R' (inr tt)))
  (inl (class_of R'' u)) =
sum_ind (fun _ : Quotient R'' + Unit => Quotient R')
  (Quotient_functor R'' R' inl inlresp)
  (unit_name (class_of R' (inr tt)))
  (inl (class_of R'' v)) ->
inl (class_of R'' u) = inl (class_of R'' v)
              simpl; intros q.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
v, u: (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n
q: class_of R' (inl u) = class_of R' (inl v)
inl (class_of R'' u) = inl (class_of R'' v)
              apply ap, qglue; unfold R''.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
v, u: (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n
q: class_of R' (inl u) = class_of R' (inl v)
R' (inl u) (inl v)
              exact (related_quotient_paths R' (inl u) (inl v) q).
            *
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
v: (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n
forall b : Unit,
sum_ind (fun _ : Quotient R'' + Unit => Quotient R')
  (Quotient_functor R'' R' inl inlresp)
  (unit_name (class_of R' (inr tt))) (inr b) =
sum_ind (fun _ : Quotient R'' + Unit => Quotient R')
  (Quotient_functor R'' R' inl inlresp)
  (unit_name (class_of R' (inr tt)))
  (inl (class_of R'' v)) ->
inr b = inl (class_of R'' v) intros []; simpl.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
v: (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n
class_of R' (inr tt) = class_of R' (inl v) ->
inr tt = inl (class_of R'' v)
              intros q.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
v: (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n
q: class_of R' (inr tt) = class_of R' (inl v)
inr tt = inl (class_of R'' v)
              apply related_quotient_paths in q; try exact _.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
v: (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n
q: R' (inr tt) (inl v)
inr tt = inl (class_of R'' v)
              apply symmetry in q.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
v: (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n
q: R' (inl v) (inr tt)
inr tt = inl (class_of R'' v)
              elim (np (tr (v ; q))).
          +
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
u: (Quotient R'' + Unit)%type
forall b : Unit,
sum_ind (fun _ : Quotient R'' + Unit => Quotient R')
  (Quotient_functor R'' R' inl inlresp)
  (unit_name (class_of R' (inr tt))) u =
sum_ind (fun _ : Quotient R'' + Unit => Quotient R')
  (Quotient_functor R'' R' inl inlresp)
  (unit_name (class_of R' (inr tt))) (inr b) ->
u = inr b intros []; simpl.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
u: (Quotient R'' + Unit)%type
sum_ind (fun _ : Quotient R'' + Unit => Quotient R')
  (Quotient_functor R'' R' inl inlresp)
  (unit_name (class_of R' (inr tt))) u =
class_of R' (inr tt) -> u = inr tt
            destruct u as [u|[]]; simpl.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
u: Quotient R''
Quotient_functor R'' R' inl inlresp u =
class_of R' (inr tt) -> inl u = inr tt
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
class_of R' (inr tt) = class_of R' (inr tt) ->
inr tt = inr tt
            *
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
u: Quotient R''
Quotient_functor R'' R' inl inlresp u =
class_of R' (inr tt) -> inl u = inr tt revert u; refine (Quotient_ind_hprop R'' _ _); intros u; simpl.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
u: (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n
class_of R' (inl u) = class_of R' (inr tt) ->
inl (class_of R'' u) = inr tt
              intros q.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
u: (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n
q: class_of R' (inl u) = class_of R' (inr tt)
inl (class_of R'' u) = inr tt
              apply related_quotient_paths in q; try exact _.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
u: (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n
q: R' (inl u) (inr tt)
inl (class_of R'' u) = inr tt
              elim (np (tr (u;q))).
            *
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
n: nat
IH: forall R' : Fin n -> Fin n -> Type,
is_mere_relation (Fin n) R' ->
Reflexive R' ->
Symmetric R' ->
Transitive R' ->
(forall x y : Fin n, Decidable (R' x y)) ->
Finite (Quotient R')
R': Fin n.+1 -> Fin n.+1 -> Type
X0: is_mere_relation (Fin n.+1) R'
X1: Reflexive R'
X2: Symmetric R'
X3: Transitive R'
R'd: forall x y : Fin n.+1, Decidable (R' x y)
R'':= fun
  x
   y : (fix Fin (n : nat) : Type0 :=
          match n with
          | 0 => Empty
          | n0.+1 => (Fin n0 + Unit)%type
          end) n => 
R' (inl x) (inl y): (fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n ->
(fix Fin (n : nat) : Type0 :=
   match n with
   | 0 => Empty
   | n0.+1 => (Fin n0 + Unit)%type
   end) n -> Type
X4: is_mere_relation
  ((fix Fin (n : nat) : Type0 :=
      match n with
      | 0 => Empty
      | n0.+1 => (Fin n0 + Unit)%type
      end) n) R''
X5: Reflexive R''
X6: Symmetric R''
X7: Transitive R''
X8: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n, Decidable (R'' x y)
inlresp: forall
x
 y : (fix Fin (n : nat) : Type0 :=
        match n with
        | 0 => Empty
        | n0.+1 => (Fin n0 + Unit)%type
        end) n,
R'' x y -> R' (inl x) (inl y)
np: ~ merely {x : Fin n & R' (inl x) (inr tt)}
class_of R' (inr tt) = class_of R' (inr tt) ->
inr tt = inr tt intros; reflexivity. }
  Defined.

  (** Therefore, the cardinality of [X] is the sum of the cardinalities of its equivalence classes. *)
  Definition fcard_quotient
  : fcard X = finadd (fun z:Quotient R => fcard {x:X & in_class R z x}).
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
fcard X =
finadd
  (fun z : Quotient R =>
   fcard
     {x : X &
     (fun x0 : X => trunctype_type (in_class R z x0))
       x})
  Proof.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
fcard X =
finadd
  (fun z : Quotient R =>
   fcard
     {x : X &
     (fun x0 : X => trunctype_type (in_class R z x0))
       x})
    refine (fcard_domain (class_of R) @ _).
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
finadd
  (fun y : Quotient R =>
   fcard {x : X & (fun x0 : X => class_of R x0 = y) x}) =
finadd
  (fun z : Quotient R =>
   fcard
     {x : X &
     (fun x0 : X => trunctype_type (in_class R z x0))
       x})
    apply ap, path_arrow; intros z; revert z.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
forall z : Quotient R,
fcard {x : X & (fun x0 : X => class_of R x0 = z) x} =
fcard
  {x : X &
  (fun x0 : X => trunctype_type (in_class R z x0)) x}
    refine (Quotient_ind_hprop _ _ _); intros x; simpl.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
x: X
fcard
  {x0 : X &
  (fun x1 : X => class_of R x1 = class_of R x) x0} =
fcard {x0 : X & (fun x1 : X => R x x1) x0}
    apply fcard_equiv'; unfold hfiber.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
x: X
{x0 : X & class_of R x0 = class_of R x} <~>
{x0 : X & R x x0}
    refine (equiv_functor_sigma_id _); intros y; simpl.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
x, y: X
class_of R y = class_of R x <~> R x y
    symmetry.
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
x, y: X
R x y <~> class_of R y = class_of R x
    refine (path_quotient R y x oE _).
H: Univalence
X: Type
H0: Finite X
R: Relation X
is_mere_relation0: is_mere_relation X R
H1: Reflexive R
H2: Transitive R
H3: Symmetric R
Rd: forall x y : X, Decidable (R x y)
x, y: X
R x y <~> R y x
    apply equiv_iff_hprop; apply symmetry.
  Defined.

End DecidableQuotients.

(** ** Injections *)

(** An injection between finite sets induces an inequality between their cardinalities. *)
Definition leq_inj_finite {X Y} {fX : Finite X} {fY : Finite Y}
           (f : X -> Y) (i : IsEmbedding f)
: fcard X <= fcard Y.
X, Y: Type
fX: Finite X
fY: Finite Y
f: X -> Y
i: IsEmbedding f
fcard X <= fcard Y
Proof.
X, Y: Type
fX: Finite X
fY: Finite Y
f: X -> Y
i: IsEmbedding f
fcard X <= fcard Y
  assert (MapIn (Tr (-1)) f) by exact _.
X, Y: Type
fX: Finite X
fY: Finite Y
f: X -> Y
i: IsEmbedding f
X0: MapIn (Tr (-1)) f
fcard X <= fcard Y clear i.
X, Y: Type
fX: Finite X
fY: Finite Y
f: X -> Y
X0: MapIn (Tr (-1)) f
fcard X <= fcard Y
  destruct fX as [n e]; simpl.
X, Y: Type
n: nat
e: merely (X <~> Fin n)
fY: Finite Y
f: X -> Y
X0: MapIn (Tr (-1)) f
n <= fcard Y
  destruct fY as [m e']; simpl.
X, Y: Type
n: nat
e: merely (X <~> Fin n)
m: nat
e': merely (Y <~> Fin m)
f: X -> Y
X0: MapIn (Tr (-1)) f
n <= m
  strip_truncations.
X, Y: Type
n, m: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
e': Y <~> Fin m
e: X <~> Fin n
n <= m
  pose (g := e' o f o e^-1).
X, Y: Type
n, m: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
e': Y <~> Fin m
e: X <~> Fin n
g:= e' o f o e^-1: Fin n -> Fin m
n <= m
  assert (MapIn (Tr (-1)) g) by (unfold g; exact _).
X, Y: Type
n, m: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
e': Y <~> Fin m
e: X <~> Fin n
g:= e' o f o e^-1: Fin n -> Fin m
X1: MapIn (Tr (-1)) g
n <= m
  clearbody g.
X, Y: Type
n, m: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
e': Y <~> Fin m
e: X <~> Fin n
g: Fin n -> Fin m
X1: MapIn (Tr (-1)) g
n <= m clear e e'.
X, Y: Type
n, m: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
g: Fin n -> Fin m
X1: MapIn (Tr (-1)) g
n <= m generalize dependent m.
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
forall (m : nat) (g : Fin n -> Fin m),
MapIn (Tr (-1)) g -> n <= m
  induction n as [|n IHn].
X, Y: Type
f: X -> Y
X0: MapIn (Tr (-1)) f
forall (m : nat) (g : Fin 0 -> Fin m),
MapIn (Tr (-1)) g -> 0 <= m
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
forall (m : nat) (g : Fin n.+1 -> Fin m),
MapIn (Tr (-1)) g -> n.+1 <= m
  1: exact _.
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
forall (m : nat) (g : Fin n.+1 -> Fin m),
MapIn (Tr (-1)) g -> n.+1 <= m
  intros m g ?.
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m
X1: MapIn (Tr (-1)) g
n.+1 <= m
  assert (i : isinj g) by (apply isinj_embedding; exact _).
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m
X1: MapIn (Tr (-1)) g
i: isinj g
n.+1 <= m
  destruct m as [|m].
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
g: Fin n.+1 -> Fin 0
X1: MapIn (Tr (-1)) g
i: isinj g
n.+1 <= 0
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
n.+1 <= m.+1
  {
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
g: Fin n.+1 -> Fin 0
X1: MapIn (Tr (-1)) g
i: isinj g
n.+1 <= 0 elim (g (inr tt)). }
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
n.+1 <= m.+1
  pose (h := (fin_transpose_last_with m (g (inr tt)))^-1 o g).
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
n.+1 <= m.+1
  assert (MapIn (Tr (-1)) h) by (unfold h; exact _).
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
n.+1 <= m.+1
  assert (Ha : forall a:Fin n, is_inl (h (inl a))).
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
forall a : Fin n, is_inl (h (inl a))
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
Ha: forall a : Fin n, is_inl (h (inl a))
n.+1 <= m.+1
  {
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
forall a : Fin n, is_inl (h (inl a)) intros a.
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
a: Fin n
is_inl (h (inl a))
    remember (g (inl a)) as b eqn:p.
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
a: Fin n
b: Fin m.+1
p: g (inl a) = b
is_inl (h (inl a))
    destruct b as [b|[]].
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
a: Fin n
b: Fin m
p: g (inl a) = inl b
is_inl (h (inl a))
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
a: Fin n
p: g (inl a) = inr tt
is_inl (h (inl a))
    -
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
a: Fin n
b: Fin m
p: g (inl a) = inl b
is_inl (h (inl a)) assert (q : g (inl a) <> (g (inr tt))).
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
a: Fin n
b: Fin m
p: g (inl a) = inl b
g (inl a) <> g (inr tt)
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
a: Fin n
b: Fin m
p: g (inl a) = inl b
q: g (inl a) <> g (inr tt)
is_inl (h (inl a))
      {
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
a: Fin n
b: Fin m
p: g (inl a) = inl b
g (inl a) <> g (inr tt) intros r.
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
a: Fin n
b: Fin m
p: g (inl a) = inl b
r: g (inl a) = g (inr tt)
Empty exact (inl_ne_inr _ _ (i _ _ r)). }
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
a: Fin n
b: Fin m
p: g (inl a) = inl b
q: g (inl a) <> g (inr tt)
is_inl (h (inl a))
      rewrite p in q; apply symmetric_neq in q.
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
a: Fin n
b: Fin m
p: g (inl a) = inl b
q: g (inr tt) <> inl b
is_inl (h (inl a))
      assert (r : h (inl a) = inl b).
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
a: Fin n
b: Fin m
p: g (inl a) = inl b
q: g (inr tt) <> inl b
h (inl a) = inl b
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
a: Fin n
b: Fin m
p: g (inl a) = inl b
q: g (inr tt) <> inl b
r: h (inl a) = inl b
is_inl (h (inl a))
      {
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
a: Fin n
b: Fin m
p: g (inl a) = inl b
q: g (inr tt) <> inl b
h (inl a) = inl b unfold h; apply moveR_equiv_V; symmetry.
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
a: Fin n
b: Fin m
p: g (inl a) = inl b
q: g (inr tt) <> inl b
fin_transpose_last_with m (g (inr tt)) (inl b) =
g (inl a)
        refine (fin_transpose_last_with_rest m (g (inr tt)) b q @ p^). }
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
a: Fin n
b: Fin m
p: g (inl a) = inl b
q: g (inr tt) <> inl b
r: h (inl a) = inl b
is_inl (h (inl a))
      rewrite r; exact tt.
    -
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
a: Fin n
p: g (inl a) = inr tt
is_inl (h (inl a)) assert (q : h (inl a) = g (inr tt)).
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
a: Fin n
p: g (inl a) = inr tt
h (inl a) = g (inr tt)
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
a: Fin n
p: g (inl a) = inr tt
q: h (inl a) = g (inr tt)
is_inl (h (inl a))
      {
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
a: Fin n
p: g (inl a) = inr tt
h (inl a) = g (inr tt) unfold h; apply moveR_equiv_V; symmetry.
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
a: Fin n
p: g (inl a) = inr tt
fin_transpose_last_with m (g (inr tt)) (g (inr tt)) =
g (inl a)
        refine (_ @ p^); apply fin_transpose_last_with_with. }
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
a: Fin n
p: g (inl a) = inr tt
q: h (inl a) = g (inr tt)
is_inl (h (inl a))
      rewrite q.
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
a: Fin n
p: g (inl a) = inr tt
q: h (inl a) = g (inr tt)
is_inl (g (inr tt))
      destruct (is_inl_or_is_inr (g (inr tt))) as [l|r]; try assumption.
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
a: Fin n
p: g (inl a) = inr tt
q: h (inl a) = g (inr tt)
r: is_inr (g (inr tt))
is_inl (g (inr tt))
      assert (s := inr_un_inr _ r).
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
a: Fin n
p: g (inl a) = inr tt
q: h (inl a) = g (inr tt)
r: is_inr (g (inr tt))
s: inr (un_inr (g (inr tt)) r) = g (inr tt)
is_inl (g (inr tt))
      revert s; generalize (un_inr (g (inr tt)) r); intros [] s.
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
a: Fin n
p: g (inl a) = inr tt
q: h (inl a) = g (inr tt)
r: is_inr (g (inr tt))
s: inr tt = g (inr tt)
is_inl (g (inr tt))
      elim (inl_ne_inr _ _ (i _ _ (p @ s))). }
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
Ha: forall a : Fin n, is_inl (h (inl a))
n.+1 <= m.+1
  assert (Hb : forall b:Unit, is_inr (h (inr b))).
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
Ha: forall a : Fin n, is_inl (h (inl a))
forall b : Unit, is_inr (h (inr b))
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
Ha: forall a : Fin n, is_inl (h (inl a))
Hb: forall b : Unit, is_inr (h (inr b))
n.+1 <= m.+1
  {
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
Ha: forall a : Fin n, is_inl (h (inl a))
forall b : Unit, is_inr (h (inr b)) intros [].
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
Ha: forall a : Fin n, is_inl (h (inl a))
is_inr (h (inr tt))
    assert (q : h (inr tt) = inr tt).
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
Ha: forall a : Fin n, is_inl (h (inl a))
h (inr tt) = inr tt
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
Ha: forall a : Fin n, is_inl (h (inl a))
q: h (inr tt) = inr tt
is_inr (h (inr tt))
    {
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
Ha: forall a : Fin n, is_inl (h (inl a))
h (inr tt) = inr tt unfold h; apply moveR_equiv_V; symmetry.
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
Ha: forall a : Fin n, is_inl (h (inl a))
fin_transpose_last_with m (g (inr tt)) (inr tt) =
g (inr tt)
      apply fin_transpose_last_with_last. }
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
Ha: forall a : Fin n, is_inl (h (inl a))
q: h (inr tt) = inr tt
is_inr (h (inr tt))
    rewrite q; exact tt. }
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
Ha: forall a : Fin n, is_inl (h (inl a))
Hb: forall b : Unit, is_inr (h (inr b))
n.+1 <= m.+1
  apply leq_S_n'.
X, Y: Type
n: nat
f: X -> Y
X0: MapIn (Tr (-1)) f
IHn: forall (m : nat) (g : Fin n -> Fin m), MapIn (Tr (-1)) g -> n <= m
m: nat
g: Fin n.+1 -> Fin m.+1
X1: MapIn (Tr (-1)) g
i: isinj g
h:= (fin_transpose_last_with m (g (inr tt)))^-1 o g: Fin n.+1 -> Fin m.+1
X2: MapIn (Tr (-1)) h
Ha: forall a : Fin n, is_inl (h (inl a))
Hb: forall b : Unit, is_inr (h (inr b))
n <= m
  exact (IHn m (unfunctor_sum_l h Ha)
             (mapinO_unfunctor_sum_l (Tr (-1)) h Ha Hb)).
Qed.

(** ** Surjections  *)
(** A surjection between finite sets induces an inequality between their cardinalities. *)
Definition geq_surj_finite  {X Y} {fX : Finite X} {fY : Finite Y}
           (f : X -> Y) (i : IsSurjection f)
  : fcard X >= fcard Y.
X, Y: Type
fX: Finite X
fY: Finite Y
f: X -> Y
i: IsConnMap (Tr (-1)) f
fcard X >= fcard Y
Proof.
X, Y: Type
fX: Finite X
fY: Finite Y
f: X -> Y
i: IsConnMap (Tr (-1)) f
fcard X >= fcard Y
  destruct fX as [n e], fY as [m e']; simpl.
X, Y: Type
n: nat
e: merely (X <~> Fin n)
m: nat
e': merely (Y <~> Fin m)
f: X -> Y
i: IsConnMap (Tr (-1)) f
n >= m
  assert (k := isprojective_fin_n m).
X, Y: Type
n: nat
e: merely (X <~> Fin n)
m: nat
e': merely (Y <~> Fin m)
f: X -> Y
i: IsConnMap (Tr (-1)) f
k: IsProjective (Fin m)
n >= m
  strip_truncations.
X, Y: Type
n, m: nat
f: X -> Y
i: IsConnMap (Tr (-1)) f
k: IsProjective (Fin m)
e': Y <~> Fin m
e: X <~> Fin n
n >= m
  pose (g := e' o f o e^-1).
X, Y: Type
n, m: nat
f: X -> Y
i: IsConnMap (Tr (-1)) f
k: IsProjective (Fin m)
e': Y <~> Fin m
e: X <~> Fin n
g:= e' o f o e^-1: Fin n -> Fin m
n >= m
  assert (k' : IsSurjection g) by exact _ .
X, Y: Type
n, m: nat
f: X -> Y
i: IsConnMap (Tr (-1)) f
k: IsProjective (Fin m)
e': Y <~> Fin m
e: X <~> Fin n
g:= e' o f o e^-1: Fin n -> Fin m
k': IsConnMap (Tr (-1)) g
n >= m
  clearbody g; clear i f.
X, Y: Type
n, m: nat
k: IsProjective (Fin m)
e': Y <~> Fin m
e: X <~> Fin n
g: Fin n -> Fin m
k': IsConnMap (Tr (-1)) g
n >= m
  assert (j := k (Fin n) _ (Fin m) _ idmap g k').
X, Y: Type
n, m: nat
k: IsProjective (Fin m)
e': Y <~> Fin m
e: X <~> Fin n
g: Fin n -> Fin m
k': IsConnMap (Tr (-1)) g
j: merely {s : Fin m -> Fin n & g o s == idmap}
n >= m
  strip_truncations.
X, Y: Type
n, m: nat
k: IsProjective (Fin m)
e': Y <~> Fin m
e: X <~> Fin n
g: Fin n -> Fin m
k': IsConnMap (Tr (-1)) g
j: {s : Fin m -> Fin n &
(fun x : Fin m => g (s x)) == idmap}
n >= m
  simpl; destruct j as [s is_section].
X, Y: Type
n, m: nat
k: IsProjective (Fin m)
e': Y <~> Fin m
e: X <~> Fin n
g: Fin n -> Fin m
k': IsConnMap (Tr (-1)) g
s: Fin m -> Fin n
is_section: (fun x : Fin m => g (s x)) == idmap
n >= m 
  change n with (fcard (Fin n)).
X, Y: Type
n, m: nat
k: IsProjective (Fin m)
e': Y <~> Fin m
e: X <~> Fin n
g: Fin n -> Fin m
k': IsConnMap (Tr (-1)) g
s: Fin m -> Fin n
is_section: (fun x : Fin m => g (s x)) == idmap
fcard (Fin n) >= m
  change m with (fcard (Fin m)).
X, Y: Type
n, m: nat
k: IsProjective (Fin m)
e': Y <~> Fin m
e: X <~> Fin n
g: Fin n -> Fin m
k': IsConnMap (Tr (-1)) g
s: Fin m -> Fin n
is_section: (fun x : Fin m => g (s x)) == idmap
fcard (Fin n) >= fcard (Fin m)
  apply (leq_inj_finite s).
X, Y: Type
n, m: nat
k: IsProjective (Fin m)
e': Y <~> Fin m
e: X <~> Fin n
g: Fin n -> Fin m
k': IsConnMap (Tr (-1)) g
s: Fin m -> Fin n
is_section: (fun x : Fin m => g (s x)) == idmap
IsEmbedding s
  apply isembedding_isinj_hset, (isinj_section is_section).
Defined.

  (** ** Enumerations *)

(** A function from [nat] to a finite set must repeat itself eventually. *)
Section Enumeration.
  Context `{Funext} {X} `{Finite@{_ Set _} X} (e : nat -> X).

  Let er (n : nat) : Fin n -> X
    := fun k => e (nat_fin n k).

  Lemma finite_enumeration_stage (n : nat)
  : IsEmbedding (er n)
    + { n : nat & { k : nat & e n = e (n + k).+1 }}.
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
(IsEmbedding (er n) +
 {n : nat & {k : nat & e n = e (n + k).+1}})%type
  Proof.
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
(IsEmbedding (er n) +
 {n : nat & {k : nat & e n = e (n + k).+1}})%type
    induction n as [|n [IH|IH]].
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
(IsEmbedding (er 0) +
 {n : nat & {k : nat & e n = e (n + k).+1}})%type
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: IsEmbedding (er n)
(IsEmbedding (er n.+1) +
 {n : nat & {k : nat & e n = e (n + k).+1}})%type
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: {n : nat & {k : nat & e n = e (n + k).+1}}
(IsEmbedding (er n.+1) +
 {n : nat & {k : nat & e n = e (n + k).+1}})%type
    -
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
(IsEmbedding (er 0) +
 {n : nat & {k : nat & e n = e (n + k).+1}})%type left.
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
IsEmbedding (er 0) intros x.
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
x: X
IsHProp (hfiber (er 0) x)
      apply hprop_inhabited_contr; intros [[] _].
    -
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: IsEmbedding (er n)
(IsEmbedding (er n.+1) +
 {n : nat & {k : nat & e n = e (n + k).+1}})%type destruct (detachable_image_finite (er n) (er n.+1 (inr tt)))
        as [[k p]|ne].
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: IsEmbedding (er n)
k: Fin n
p: er n k = er n.+1 (inr tt)
(IsEmbedding (er n.+1) +
 {n : nat & {k : nat & e n = e (n + k).+1}})%type
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: IsEmbedding (er n)
ne: ~ hfiber (er n) (er n.+1 (inr tt))
(IsEmbedding (er n.+1) +
 {n : nat & {k : nat & e n = e (n + k).+1}})%type
      +
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: IsEmbedding (er n)
k: Fin n
p: er n k = er n.+1 (inr tt)
(IsEmbedding (er n.+1) +
 {n : nat & {k : nat & e n = e (n + k).+1}})%type right.
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: IsEmbedding (er n)
k: Fin n
p: er n k = er n.+1 (inr tt)
{n : nat & {k : nat & e n = e (n + k).+1}}
        exists (nat_fin n k).
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: IsEmbedding (er n)
k: Fin n
p: er n k = er n.+1 (inr tt)
{k0 : nat & e (nat_fin n k) = e (nat_fin n k + k0).+1}
        exists (nat_fin_compl n k).
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: IsEmbedding (er n)
k: Fin n
p: er n k = er n.+1 (inr tt)
e (nat_fin n k) =
e (nat_fin n k + nat_fin_compl n k).+1
        rewrite nat_fin_compl_compl.
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: IsEmbedding (er n)
k: Fin n
p: er n k = er n.+1 (inr tt)
e (nat_fin n k) = e n
        exact p.
      +
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: IsEmbedding (er n)
ne: ~ hfiber (er n) (er n.+1 (inr tt))
(IsEmbedding (er n.+1) +
 {n : nat & {k : nat & e n = e (n + k).+1}})%type left.
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: IsEmbedding (er n)
ne: ~ hfiber (er n) (er n.+1 (inr tt))
IsEmbedding (er n.+1) intros x.
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: IsEmbedding (er n)
ne: ~ hfiber (er n) (er n.+1 (inr tt))
x: X
IsHProp (hfiber (er n.+1) x)
        apply hprop_allpath.
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: IsEmbedding (er n)
ne: ~ hfiber (er n) (er n.+1 (inr tt))
x: X
forall x0 y : hfiber (er n.+1) x, x0 = y
        intros k l.
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: IsEmbedding (er n)
ne: ~ hfiber (er n) (er n.+1 (inr tt))
x: X
k, l: hfiber (er n.+1) x
k = l
        apply path_sigma_hprop.
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: IsEmbedding (er n)
ne: ~ hfiber (er n) (er n.+1 (inr tt))
x: X
k, l: hfiber (er n.+1) x
k.1 = l.1
        destruct k as [[k|[]] p], l as [[l|[]] q]; simpl.
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: IsEmbedding (er n)
ne: ~ hfiber (er n) (er n.+1 (inr tt))
x: X
k: Fin n
p: er n.+1 (inl k) = x
l: Fin n
q: er n.+1 (inl l) = x
inl k = inl l
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: IsEmbedding (er n)
ne: ~ hfiber (er n) (er n.+1 (inr tt))
x: X
k: Fin n
p: er n.+1 (inl k) = x
q: er n.+1 (inr tt) = x
inl k = inr tt
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: IsEmbedding (er n)
ne: ~ hfiber (er n) (er n.+1 (inr tt))
x: X
p: er n.+1 (inr tt) = x
l: Fin n
q: er n.+1 (inl l) = x
inr tt = inl l
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: IsEmbedding (er n)
ne: ~ hfiber (er n) (er n.+1 (inr tt))
x: X
p, q: er n.+1 (inr tt) = x
inr tt = inr tt
        *
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: IsEmbedding (er n)
ne: ~ hfiber (er n) (er n.+1 (inr tt))
x: X
k: Fin n
p: er n.+1 (inl k) = x
l: Fin n
q: er n.+1 (inl l) = x
inl k = inl l apply isinj_embedding in IH.
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: isinj (er n)
ne: ~ hfiber (er n) (er n.+1 (inr tt))
x: X
k: Fin n
p: er n.+1 (inl k) = x
l: Fin n
q: er n.+1 (inl l) = x
inl k = inl l
          apply ap.
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: isinj (er n)
ne: ~ hfiber (er n) (er n.+1 (inr tt))
x: X
k: Fin n
p: er n.+1 (inl k) = x
l: Fin n
q: er n.+1 (inl l) = x
k = l
          apply IH.
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: isinj (er n)
ne: ~ hfiber (er n) (er n.+1 (inr tt))
x: X
k: Fin n
p: er n.+1 (inl k) = x
l: Fin n
q: er n.+1 (inl l) = x
er n k = er n l
          unfold er in p, q.
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: isinj (er n)
ne: ~ hfiber (er n) (er n.+1 (inr tt))
x: X
k: Fin n
p: e (nat_fin n.+1 (inl k)) = x
l: Fin n
q: e (nat_fin n.+1 (inl l)) = x
er n k = er n l simpl in p, q.
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: isinj (er n)
ne: ~ hfiber (er n) (er n.+1 (inr tt))
x: X
k: Fin n
p: e (nat_fin n k) = x
l: Fin n
q: e (nat_fin n l) = x
er n k = er n l
          exact (p @ q^).
        *
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: IsEmbedding (er n)
ne: ~ hfiber (er n) (er n.+1 (inr tt))
x: X
k: Fin n
p: er n.+1 (inl k) = x
q: er n.+1 (inr tt) = x
inl k = inr tt refine (Empty_rec (ne _)).
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: IsEmbedding (er n)
ne: ~ hfiber (er n) (er n.+1 (inr tt))
x: X
k: Fin n
p: er n.+1 (inl k) = x
q: er n.+1 (inr tt) = x
hfiber (er n) (er n.+1 (inr tt))
          exists k.
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: IsEmbedding (er n)
ne: ~ hfiber (er n) (er n.+1 (inr tt))
x: X
k: Fin n
p: er n.+1 (inl k) = x
q: er n.+1 (inr tt) = x
er n k = er n.+1 (inr tt)
          exact (p @ q^).
        *
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: IsEmbedding (er n)
ne: ~ hfiber (er n) (er n.+1 (inr tt))
x: X
p: er n.+1 (inr tt) = x
l: Fin n
q: er n.+1 (inl l) = x
inr tt = inl l refine (Empty_rec (ne _)).
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: IsEmbedding (er n)
ne: ~ hfiber (er n) (er n.+1 (inr tt))
x: X
p: er n.+1 (inr tt) = x
l: Fin n
q: er n.+1 (inl l) = x
hfiber (er n) (er n.+1 (inr tt))
          exists l.
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: IsEmbedding (er n)
ne: ~ hfiber (er n) (er n.+1 (inr tt))
x: X
p: er n.+1 (inr tt) = x
l: Fin n
q: er n.+1 (inl l) = x
er n l = er n.+1 (inr tt)
          exact (q @ p^).
        *
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: IsEmbedding (er n)
ne: ~ hfiber (er n) (er n.+1 (inr tt))
x: X
p, q: er n.+1 (inr tt) = x
inr tt = inr tt reflexivity.
    -
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
n: nat
IH: {n : nat & {k : nat & e n = e (n + k).+1}}
(IsEmbedding (er n.+1) +
 {n : nat & {k : nat & e n = e (n + k).+1}})%type right; exact IH.
  Defined.

  Definition finite_enumeration_repeats
  : { n : nat & { k : nat & e n = e (n + k).+1 }}.
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
{n : nat & {k : nat & e n = e (n + k).+1}}
  Proof.
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
{n : nat & {k : nat & e n = e (n + k).+1}}
    destruct (finite_enumeration_stage (fcard X).+1) as [p|?].
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
p: IsEmbedding (er (fcard X).+1)
{n : nat & {k : nat & e n = e (n + k).+1}}
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
s: {n : nat & {k : nat & e n = e (n + k).+1}}
{n : nat & {k : nat & e n = e (n + k).+1}}
    -
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
p: IsEmbedding (er (fcard X).+1)
{n : nat & {k : nat & e n = e (n + k).+1}} assert (q := leq_inj_finite (er (fcard X).+1) p); simpl in q.
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
p: IsEmbedding (er (fcard X).+1)
q: (fcard X).+1 <= fcard X
{n : nat & {k : nat & e n = e (n + k).+1}}
      elim (not_lt_n_n _ q).
    -
H: Funext
X: Type
H0: Finite X
e: nat -> X
er:= fun (n : nat) (k : Fin n) => e (nat_fin n k): forall n : nat, Fin n -> X
s: {n : nat & {k : nat & e n = e (n + k).+1}}
{n : nat & {k : nat & e n = e (n + k).+1}} assumption.
  Defined.

End Enumeration.