(* -*- mode: coq; mode: visual-line -*- *)
Require Import HoTT.Basics HoTT.Types.
[Loading ML file number_string_notation_plugin.cmxs (using legacy method) ... done]
Require Import TruncType HSet.
Require Import HoTT.Truncations.Core.

Local Open Scope nat_scope.
Local Open Scope path_scope.

(** * The surreal numbers *)

(** Based on section 11.6 of the HoTT Book. *)

Declare Scope surreal_scope.
Delimit Scope surreal_scope with No.
Local Open Scope surreal_scope.

(** ** Option sorts *)

(** We refine the surreal numbers by parametrizing them by "option sorts", which are predicates on the types that index the options.  A surreal number with given option sorts "hereditarily" has all options parametrized by types belonging to that sort. *)

Definition OptionSort@{i} := Type@{i} -> Type@{i} -> Type@{i}.
Class InSort (S : OptionSort@{i}) (I J : Type@{i})
  := insort : S I J.

(** The surreal numbers use a lot of universes.  We include some universe annotations here and there to reduce the number of overall universe parameters from an unmanageable number to a slightly less unmanageable number.  This improves performance significantly.  We also use [abstract] and [Qed] whenever possible, for the same reason. *)

(** ** Definition *)

Module Export Surreals.

  Section OptionSort.

  (** We will use this to assert that certain inequalities below hold.  We locate it here, so that it depends on no universe variables. See the longer explanation below. *)
  Inductive No_Empty_for_admitted : Type0 := .
  Axiom No_Empty_admitted : No_Empty_for_admitted.

  Universe i.
  Context {S : OptionSort@{i}}.

  (** *** Games first *)

  (** Since Coq doesn't support inductive-inductive types natively, we have to hack a bit.  Inspired by Conway, we define [Game]s to be constructed by the point-constructor of [No] but without the hypothesis on inequality of options.  Then we define the inequalities as a mutual inductive family over [Game], and put an inductive predicate on [Game] characterizing those that are Numbers.  (This is roughly a standard technique described by Fredrik Nordvall Forsberg for reducing induction-induction to parametrized induction.)  We then proceed to add axioms for the path-constructors of [No].

  It should be emphasized that this is *not* currently a correct higher inductive-inductive definition of games; these "games" are only being used inside this module as a trick to produce [No] in a way that computes on the point-constructor.  It should be possible to make a higher inductive-inductive definition of games, but this is not it. *)

  Private Inductive Game : Type :=
  | opt : forall (L R : Type@{i})
                 (s : InSort S L R)
                 (xL : L -> Game) (xR : R -> Game), Game.

  Arguments opt {L R s} xL xR.

  Private Inductive game_le : Game -> Game -> Type :=
  | game_le_lr
    : forall (L R : Type@{i}) (s : InSort S L R)
             (xL : L -> Game) (xR : R -> Game)
             (L' R' : Type@{i}) (s' : InSort S L' R')
             (yL : L' -> Game) (yR : R' -> Game),
        (forall (l:L), game_lt (xL l) (opt yL yR)) ->
        (forall (r:R'), game_lt (opt xL xR) (yR r)) ->
        game_le (opt xL xR) (opt yL yR)

  with game_lt : Game -> Game -> Type :=
  | game_lt_l
    : forall (L R : Type@{i}) (s : InSort S L R)
             (xL : L -> Game) (xR : R -> Game)
             (L' R' : Type@{i}) (s' : InSort S L' R')
             (yL : L' -> Game) (yR : R' -> Game)
             (l : L'),
        (game_le (opt xL xR) (yL l)) ->
        game_lt (opt xL xR) (opt yL yR)
  | game_lt_r
    : forall (L R : Type@{i}) (s : InSort@{i} S L R)
             (xL : L -> Game) (xR : R -> Game)
             (L' R' : Type@{i}) (s' : InSort@{i} S L' R')
             (yL : L' -> Game) (yR : R' -> Game)
             (r : R),
        (game_le (xR r) (opt yL yR)) ->
        game_lt (opt xL xR) (opt yL yR).

  Arguments game_le_lr {L R s} xL xR {L' R' s'} yL yR _ _.
  Arguments game_lt_l {L R s} xL xR {L' R' s'} yL yR l _.
  Arguments game_lt_r {L R s} xL xR {L' R' s'} yL yR r _.

  (** *** Now the surreals *)

  Private Inductive is_surreal : Game -> Type :=
  | isno : forall (L R : Type@{i}) (s : InSort S L R)
                  (xL : L -> Game) (xR : R -> Game),
             (forall l, is_surreal (xL l))
             -> (forall r, is_surreal (xR r))
             -> (forall (l:L) (r:R), game_lt (xL l) (xR r))
             -> is_surreal (opt xL xR).

  Unset Nonrecursive Elimination Schemes.
  (** We call these "general surreal numbers" since they are parametrized by an option sort. *)
  Record GenNo : Type := Build_No
    { game_of : Game
    ; isno_game_of : is_surreal (game_of) }.

  Bind Scope surreal_scope with GenNo.

  Definition lt (x y : GenNo) := game_lt (game_of x) (game_of y).

  Definition le (x y : GenNo) := game_le (game_of x) (game_of y).

  Local Infix "<" := lt : surreal_scope.
  Local Infix "<=" := le : surreal_scope.

  Definition No_cut {L R : Type@{i}} {s : InSort S L R}
             (xL : L -> GenNo) (xR : R -> GenNo)
             (xcut : forall (l:L) (r:R), (xL l) < (xR r))
  : GenNo
    := Build_No (opt (game_of o xL) (game_of o xR))
                (isno _ _ _ _ _ (isno_game_of o xL)
                      (isno_game_of o xR) xcut).

  Notation "{ { xL | xR // xcut } }" := (No_cut xL xR xcut) : surreal_scope.

  Axiom path_No : forall (x y : GenNo), (x <= y) -> (y <= x) -> (x = y).
  Arguments path_No {x y} _ _.

  Definition le_lr
             {L R : Type@{i} } {s : InSort S L R}
             (xL : L -> GenNo) (xR : R -> GenNo)
             (xcut : forall (l:L) (r:R), (xL l) < (xR r))
             {L' R' : Type@{i} } {s' : InSort S L' R'}
             (yL : L' -> GenNo) (yR : R' -> GenNo)
             (ycut : forall (l:L') (r:R'), (yL l) < (yR r))
  : (forall (l:L), xL l < {{ yL | yR // ycut }}) ->
    (forall (r:R'), {{ xL | xR // xcut }} < yR r) ->
    {{ xL | xR // xcut }} <= {{ yL | yR // ycut }}
    := game_le_lr (game_of o xL) (game_of o xR)
                  (game_of o yL) (game_of o yR).

  Definition lt_l
             {L R : Type@{i} } {s : InSort S L R}
             (xL : L -> GenNo) (xR : R -> GenNo)
             (xcut : forall (l:L) (r:R), (xL l) < (xR r))
             {L' R' : Type@{i} } {s' : InSort S L' R'}
             (yL : L' -> GenNo) (yR : R' -> GenNo)
             (ycut : forall (l:L') (r:R'), (yL l) < (yR r))
             (l : L')
  : ({{ xL | xR // xcut }} <= yL l) ->
    {{ xL | xR // xcut }} < {{ yL | yR // ycut }}
    := game_lt_l (game_of o xL) (game_of o xR)
                 (game_of o yL) (game_of o yR) l.

  Definition lt_r
             {L R : Type@{i} } {s : InSort S L R}
             (xL : L -> GenNo) (xR : R -> GenNo)
             (xcut : forall (l:L) (r:R), (xL l) < (xR r))
             {L' R' : Type@{i} } {s' : InSort S L' R'}
             (yL : L' -> GenNo) (yR : R' -> GenNo)
             (ycut : forall (l:L') (r:R'), (yL l) < (yR r))
             (r : R)
  : (xR r <= {{ yL | yR // ycut }}) ->
    {{ xL | xR // xcut }} < {{ yL | yR // ycut }}
    := game_lt_r (game_of o xL) (game_of o xR)
                 (game_of o yL) (game_of o yR) r.

  Global Instance ishprop_No_le {x y : GenNo}
  : IsHProp (x <= y).
S: OptionSort
x, y: GenNo
IsHProp (x <= y)
  Admitted.

  Global Instance ishprop_No_lt {x y : GenNo}
  : IsHProp (x < y).
S: OptionSort
x, y: GenNo
IsHProp (x < y)
  Admitted.

  (** *** Now the induction principle. *)

  Section NoInd.

    Context
      (A : GenNo -> Type)
      (dle : forall (x y : GenNo), (x <= y) -> A x -> A y -> Type)
      (dlt : forall (x y : GenNo), (x < y) -> A x -> A y -> Type)
      {ishprop_le : forall x y a b p, IsHProp (dle x y p a b)}
      {ishprop_lt : forall x y a b p, IsHProp (dlt x y p a b)}
      (dcut : forall (L R : Type@{i}) (s : InSort S L R)
                     (xL : L -> GenNo) (xR : R -> GenNo)
                     (xcut : forall (l:L) (r:R), (xL l) < (xR r))
                     (fxL : forall l, A (xL l)) (fxR : forall r, A (xR r))
                     (fxcut : forall l r, dlt _ _ (xcut l r) (fxL l) (fxR r)),
                A {{ xL | xR // xcut }})
      (dpath : forall (x y : GenNo) (a:A x) (b:A y) (p : x <= y) (q : y <= x)
                      (dp : dle x y p a b) (dq : dle y x q b a),
                 path_No p q # a = b)
      (dle_lr : forall (L R : Type@{i}) (s : InSort S L R)
                       (xL : L -> GenNo) (xR : R -> GenNo)
                       (xcut : forall (l:L) (r:R), (xL l) < (xR r))
                       (fxL : forall l, A (xL l)) (fxR : forall r, A (xR r))
                       (fxcut : forall l r, dlt _ _ (xcut l r) (fxL l) (fxR r))
                       (L' R' : Type@{i}) (s' : InSort S L' R')
                       (yL : L' -> GenNo) (yR : R' -> GenNo)
                       (ycut : forall (l:L') (r:R'), (yL l) < (yR r))
                       (fyL : forall l, A (yL l)) (fyR : forall r, A (yR r))
                       (fycut : forall l r, dlt _ _ (ycut l r) (fyL l) (fyR r))
                       (p : forall (l:L), xL l < {{ yL | yR // ycut }})
                       (dp : forall (l:L),
                               dlt _ _ (p l)
                                   (fxL l)
                                   (dcut _ _ _ yL yR ycut fyL fyR fycut))
                       (q : forall (r:R'), {{ xL | xR // xcut }} < yR r)
                       (dq : forall (r:R'),
                               dlt _ _ (q r)
                                   (dcut _ _ _ xL xR xcut fxL fxR fxcut)
                                   (fyR r)),
                  dle {{ xL | xR // xcut }} {{ yL | yR // ycut }}
                      (le_lr xL xR xcut yL yR ycut p q)
                      (dcut _ _ _ xL xR xcut fxL fxR fxcut)
                      (dcut _ _ _ yL yR ycut fyL fyR fycut))
      (dlt_l : forall (L R : Type@{i}) (s : InSort S L R)
                      (xL : L -> GenNo) (xR : R -> GenNo)
                      (xcut : forall (l:L) (r:R), (xL l) < (xR r))
                      (fxL : forall l, A (xL l)) (fxR : forall r, A (xR r))
                      (fxcut : forall l r, dlt _ _ (xcut l r) (fxL l) (fxR r))
                      (L' R' : Type@{i}) (s' : InSort S L' R')
                      (yL : L' -> GenNo) (yR : R' -> GenNo)
                      (ycut : forall (l:L') (r:R'), (yL l) < (yR r))
                      (fyL : forall l, A (yL l)) (fyR : forall r, A (yR r))
                      (fycut : forall l r, dlt _ _ (ycut l r) (fyL l) (fyR r))
                      (l : L')
                      (p : {{ xL | xR // xcut }} <= yL l)
                      (dp : dle _ _ p
                                (dcut _ _ _ xL xR xcut fxL fxR fxcut)
                                (fyL l)),
                 dlt {{ xL | xR // xcut }} {{ yL | yR // ycut }}
                     (lt_l xL xR xcut yL yR ycut l p)
                     (dcut _ _ _ xL xR xcut fxL fxR fxcut)
                     (dcut _ _ _ yL yR ycut fyL fyR fycut))
      (dlt_r : forall (L R : Type@{i}) (s : InSort S L R)
                      (xL : L -> GenNo) (xR : R -> GenNo)
                      (xcut : forall (l:L) (r:R), (xL l) < (xR r))
                      (fxL : forall l, A (xL l)) (fxR : forall r, A (xR r))
                      (fxcut : forall l r, dlt _ _ (xcut l r) (fxL l) (fxR r))
                      (L' R' : Type@{i}) (s' : InSort S L' R')
                      (yL : L' -> GenNo) (yR : R' -> GenNo)
                      (ycut : forall (l:L') (r:R'), (yL l) < (yR r))
                      (fyL : forall l, A (yL l)) (fyR : forall r, A (yR r))
                      (fycut : forall l r, dlt _ _ (ycut l r) (fyL l) (fyR r))
                      (r : R)
                      (p : (xR r) <= {{ yL | yR // ycut }})
                      (dp : dle _ _ p
                                (fxR r)
                                (dcut _ _ _ yL yR ycut fyL fyR fycut)),
                 dlt {{ xL | xR // xcut }} {{ yL | yR // ycut }}
                     (lt_r xL xR xcut yL yR ycut r p)
                     (dcut _ _ _ xL xR xcut fxL fxR fxcut)
                     (dcut _ _ _ yL yR ycut fyL fyR fycut)).

    (** As usual for HITs implemented with [Private Inductive], we will define [No_ind] inside this module using a fixpoint over [No], thereby obtaining a judgmental computation rule for the point-constructor [No_cut], and then assert the other computation rules as axioms.  In this case, the relevant other rules are the preservation of inequalities.

However, it turns out that in defining [No_cut] we already need to know that it preserves inequalities.  Since this is eventually an axiom anyway, we could just assert it with [admit] in the proof.  However, if we did this then the [admit] would not be *judgmentally* equal to the axiom [No_ind_lt] that we assert afterwards.  Instead, we make use of the fact that [admit] is essentially by definition [match proof_admitted with end] for a global axiom [proof_admitted : Empty], so that if we use the same [admit] both inside the definition of [No_ind] and in asserting [No_ind_lt] as an axiom, they will be the same term judgmentally.

Finally, for conceptual isolation, and so as not to depend on the particular implementation of [admit], we use local copies of [Empty] and [proof_admitted].  These were defined at the start of the Section, because otherwise they depend on six universe variables. *)

    (** Technically, we induct over the inductive predicate witnessing Numberhood of games.  We prove the "induction step" separately to improve performance, possibly by preventing bare [fix]s from appearing upon simplification. *)
    Local Definition No_ind_internal_step
          (No_ind_internal : forall (x : Game) (xno : is_surreal x),
                               A (Build_No x xno))
          (x : Game) (xno : is_surreal x)
    : A (Build_No x xno).
S: OptionSort
A: GenNo -> Type
dle: forall x y : GenNo, x <= y -> A x -> A y -> Type
dlt: forall x y : GenNo, x < y -> A x -> A y -> Type
ishprop_le: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x <= y),
IsHProp (dle x y p a b)
ishprop_lt: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x < y),
IsHProp (dlt x y p a b)
dcut: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r)),
(forall (l : L) (r : R),
 dlt (xL l) (xR r) (xcut l r) (fxL l) (fxR r)) ->
A {{ xL | xR // xcut }}
dpath: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x <= y) 
(q : y <= x),
dle x y p a b ->
dle y x q b a ->
transport A (path_No p q) a = b
dle_lr: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) 
         (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) 
           (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo) (yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) 
           (fyL l) (fyR r))
(p : forall l : L,
     xL l < {{ yL | yR // ycut }}),
(forall l : L,
 dlt (xL l) {{ yL | yR // ycut }} 
   (p l) (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
forall
q : forall r : R',
    {{ xL | xR // xcut }} < yR r,
(forall r : R',
 dlt {{ xL | xR // xcut }} 
   (yR r) (q r)
   (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (le_lr xL xR xcut yL yR ycut p q)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) 
         (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) 
           (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo) (yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) 
           (fyL l) (fyR r)) 
(l : L') (p : {{ xL | xR // xcut }} <= yL l),
dle {{ xL | xR // xcut }} 
  (yL l) p
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (lt_l xL xR xcut yL yR ycut l p)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) 
         (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) 
           (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo) (yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) 
           (fyL l) (fyR r)) 
(r : R) (p : xR r <= {{ yL | yR // ycut }}),
dle (xR r) {{ yL | yR // ycut }} p 
  (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (lt_r xL xR xcut yL yR ycut r p)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
No_ind_internal: forall (x : Game)
(xno : is_surreal x),
A
  {|
    game_of := x;
    isno_game_of := xno
  |}
x: Game
xno: is_surreal x
A {| game_of := x; isno_game_of := xno |}
    Proof.
S: OptionSort
A: GenNo -> Type
dle: forall x y : GenNo, x <= y -> A x -> A y -> Type
dlt: forall x y : GenNo, x < y -> A x -> A y -> Type
ishprop_le: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x <= y),
IsHProp (dle x y p a b)
ishprop_lt: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x < y),
IsHProp (dlt x y p a b)
dcut: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r)),
(forall (l : L) (r : R),
 dlt (xL l) (xR r) (xcut l r) (fxL l) (fxR r)) ->
A {{ xL | xR // xcut }}
dpath: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x <= y) 
(q : y <= x),
dle x y p a b ->
dle y x q b a ->
transport A (path_No p q) a = b
dle_lr: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) 
         (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) 
           (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo) (yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) 
           (fyL l) (fyR r))
(p : forall l : L,
     xL l < {{ yL | yR // ycut }}),
(forall l : L,
 dlt (xL l) {{ yL | yR // ycut }} 
   (p l) (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
forall
q : forall r : R',
    {{ xL | xR // xcut }} < yR r,
(forall r : R',
 dlt {{ xL | xR // xcut }} 
   (yR r) (q r)
   (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (le_lr xL xR xcut yL yR ycut p q)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) 
         (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) 
           (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo) (yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) 
           (fyL l) (fyR r)) 
(l : L') (p : {{ xL | xR // xcut }} <= yL l),
dle {{ xL | xR // xcut }} 
  (yL l) p
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (lt_l xL xR xcut yL yR ycut l p)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) 
         (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) 
           (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo) (yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) 
           (fyL l) (fyR r)) 
(r : R) (p : xR r <= {{ yL | yR // ycut }}),
dle (xR r) {{ yL | yR // ycut }} p 
  (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (lt_r xL xR xcut yL yR ycut r p)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
No_ind_internal: forall (x : Game)
(xno : is_surreal x),
A
  {|
    game_of := x;
    isno_game_of := xno
  |}
x: Game
xno: is_surreal x
A {| game_of := x; isno_game_of := xno |}
      (* We use [revert] and [intros] as a way to ensure that the definition depends on all of the variables in the context. *)
      revert ishprop_le ishprop_lt dpath dle_lr dlt_l dlt_r.
S: OptionSort
A: GenNo -> Type
dle: forall x y : GenNo, x <= y -> A x -> A y -> Type
dlt: forall x y : GenNo, x < y -> A x -> A y -> Type
dcut: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r)),
(forall (l : L) (r : R),
 dlt (xL l) (xR r) (xcut l r) (fxL l) (fxR r)) ->
A {{ xL | xR // xcut }}
No_ind_internal: forall (x : Game)
(xno : is_surreal x),
A
  {|
    game_of := x;
    isno_game_of := xno
  |}
x: Game
xno: is_surreal x
(forall (x y : GenNo) (a : A x) (b : A y)
 (p : x <= y), IsHProp (dle x y p a b)) ->
(forall (x y : GenNo) (a : A x) (b : A y) (p : x < y),
 IsHProp (dlt x y p a b)) ->
(forall (x y : GenNo) (a : A x) (b : A y) (p : x <= y)
 (q : y <= x),
 dle x y p a b ->
 dle y x q b a -> transport A (path_No p q) a = b) ->
(forall (L R : Type) (s : InSort S L R)
 (xL : L -> GenNo) (xR : R -> GenNo)
 (xcut : forall (l : L) (r : R), xL l < xR r)
 (fxL : forall l : L, A (xL l))
 (fxR : forall r : R, A (xR r))
 (fxcut : forall (l : L) (r : R),
          dlt (xL l) (xR r) (xcut l r) (fxL l) (fxR r))
 (L' R' : Type) (s' : InSort S L' R')
 (yL : L' -> GenNo) (yR : R' -> GenNo)
 (ycut : forall (l : L') (r : R'), yL l < yR r)
 (fyL : forall l : L', A (yL l))
 (fyR : forall r : R', A (yR r))
 (fycut : forall (l : L') (r : R'),
          dlt (yL l) (yR r) (ycut l r) (fyL l) (fyR r))
 (p : forall l : L, xL l < {{ yL | yR // ycut }}),
 (forall l : L,
  dlt (xL l) {{ yL | yR // ycut }} (p l) (fxL l)
    (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
 forall
 q : forall r : R', {{ xL | xR // xcut }} < yR r,
 (forall r : R',
  dlt {{ xL | xR // xcut }} (yR r) (q r)
    (dcut L R s xL xR xcut fxL fxR fxcut) (fyR r)) ->
 dle {{ xL | xR // xcut }} {{ yL | yR // ycut }}
   (le_lr xL xR xcut yL yR ycut p q)
   (dcut L R s xL xR xcut fxL fxR fxcut)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
(forall (L R : Type) (s : InSort S L R)
 (xL : L -> GenNo) (xR : R -> GenNo)
 (xcut : forall (l : L) (r : R), xL l < xR r)
 (fxL : forall l : L, A (xL l))
 (fxR : forall r : R, A (xR r))
 (fxcut : forall (l : L) (r : R),
          dlt (xL l) (xR r) (xcut l r) (fxL l) (fxR r))
 (L' R' : Type) (s' : InSort S L' R')
 (yL : L' -> GenNo) (yR : R' -> GenNo)
 (ycut : forall (l : L') (r : R'), yL l < yR r)
 (fyL : forall l : L', A (yL l))
 (fyR : forall r : R', A (yR r))
 (fycut : forall (l : L') (r : R'),
          dlt (yL l) (yR r) (ycut l r) (fyL l) (fyR r))
 (l : L') (p : {{ xL | xR // xcut }} <= yL l),
 dle {{ xL | xR // xcut }} (yL l) p
   (dcut L R s xL xR xcut fxL fxR fxcut) (fyL l) ->
 dlt {{ xL | xR // xcut }} {{ yL | yR // ycut }}
   (lt_l xL xR xcut yL yR ycut l p)
   (dcut L R s xL xR xcut fxL fxR fxcut)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
(forall (L R : Type) (s : InSort S L R)
 (xL : L -> GenNo) (xR : R -> GenNo)
 (xcut : forall (l : L) (r : R), xL l < xR r)
 (fxL : forall l : L, A (xL l))
 (fxR : forall r : R, A (xR r))
 (fxcut : forall (l : L) (r : R),
          dlt (xL l) (xR r) (xcut l r) (fxL l) (fxR r))
 (L' R' : Type) (s' : InSort S L' R')
 (yL : L' -> GenNo) (yR : R' -> GenNo)
 (ycut : forall (l : L') (r : R'), yL l < yR r)
 (fyL : forall l : L', A (yL l))
 (fyR : forall r : R', A (yR r))
 (fycut : forall (l : L') (r : R'),
          dlt (yL l) (yR r) (ycut l r) (fyL l) (fyR r))
 (r : R) (p : xR r <= {{ yL | yR // ycut }}),
 dle (xR r) {{ yL | yR // ycut }} p (fxR r)
   (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
 dlt {{ xL | xR // xcut }} {{ yL | yR // ycut }}
   (lt_r xL xR xcut yL yR ycut r p)
   (dcut L R s xL xR xcut fxL fxR fxcut)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
A {| game_of := x; isno_game_of := xno |}
      destruct xno as [L R ? xL xR Lno Rno xcut].
S: OptionSort
A: GenNo -> Type
dle: forall x y : GenNo, x <= y -> A x -> A y -> Type
dlt: forall x y : GenNo, x < y -> A x -> A y -> Type
dcut: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r)),
(forall (l : L) (r : R),
 dlt (xL l) (xR r) (xcut l r) (fxL l) (fxR r)) ->
A {{ xL | xR // xcut }}
No_ind_internal: forall (x : Game)
(xno : is_surreal x),
A
  {|
    game_of := x;
    isno_game_of := xno
  |}
L, R: Type
s: InSort S L R
xL: L -> Game
xR: R -> Game
Lno: forall l : L, is_surreal (xL l)
Rno: forall r : R, is_surreal (xR r)
xcut: forall (l : L) (r : R), game_lt (xL l) (xR r)
(forall (x y : GenNo) (a : A x) (b : A y)
 (p : x <= y), IsHProp (dle x y p a b)) ->
(forall (x y : GenNo) (a : A x) (b : A y) (p : x < y),
 IsHProp (dlt x y p a b)) ->
(forall (x y : GenNo) (a : A x) (b : A y) (p : x <= y)
 (q : y <= x),
 dle x y p a b ->
 dle y x q b a -> transport A (path_No p q) a = b) ->
(forall (L R : Type) (s : InSort S L R)
 (xL : L -> GenNo) (xR : R -> GenNo)
 (xcut : forall (l : L) (r : R), xL l < xR r)
 (fxL : forall l : L, A (xL l))
 (fxR : forall r : R, A (xR r))
 (fxcut : forall (l : L) (r : R),
          dlt (xL l) (xR r) (xcut l r) (fxL l) (fxR r))
 (L' R' : Type) (s' : InSort S L' R')
 (yL : L' -> GenNo) (yR : R' -> GenNo)
 (ycut : forall (l : L') (r : R'), yL l < yR r)
 (fyL : forall l : L', A (yL l))
 (fyR : forall r : R', A (yR r))
 (fycut : forall (l : L') (r : R'),
          dlt (yL l) (yR r) (ycut l r) (fyL l) (fyR r))
 (p : forall l : L, xL l < {{ yL | yR // ycut }}),
 (forall l : L,
  dlt (xL l) {{ yL | yR // ycut }} (p l) (fxL l)
    (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
 forall
 q : forall r : R', {{ xL | xR // xcut }} < yR r,
 (forall r : R',
  dlt {{ xL | xR // xcut }} (yR r) (q r)
    (dcut L R s xL xR xcut fxL fxR fxcut) (fyR r)) ->
 dle {{ xL | xR // xcut }} {{ yL | yR // ycut }}
   (le_lr xL xR xcut yL yR ycut p q)
   (dcut L R s xL xR xcut fxL fxR fxcut)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
(forall (L R : Type) (s : InSort S L R)
 (xL : L -> GenNo) (xR : R -> GenNo)
 (xcut : forall (l : L) (r : R), xL l < xR r)
 (fxL : forall l : L, A (xL l))
 (fxR : forall r : R, A (xR r))
 (fxcut : forall (l : L) (r : R),
          dlt (xL l) (xR r) (xcut l r) (fxL l) (fxR r))
 (L' R' : Type) (s' : InSort S L' R')
 (yL : L' -> GenNo) (yR : R' -> GenNo)
 (ycut : forall (l : L') (r : R'), yL l < yR r)
 (fyL : forall l : L', A (yL l))
 (fyR : forall r : R', A (yR r))
 (fycut : forall (l : L') (r : R'),
          dlt (yL l) (yR r) (ycut l r) (fyL l) (fyR r))
 (l : L') (p : {{ xL | xR // xcut }} <= yL l),
 dle {{ xL | xR // xcut }} (yL l) p
   (dcut L R s xL xR xcut fxL fxR fxcut) (fyL l) ->
 dlt {{ xL | xR // xcut }} {{ yL | yR // ycut }}
   (lt_l xL xR xcut yL yR ycut l p)
   (dcut L R s xL xR xcut fxL fxR fxcut)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
(forall (L R : Type) (s : InSort S L R)
 (xL : L -> GenNo) (xR : R -> GenNo)
 (xcut : forall (l : L) (r : R), xL l < xR r)
 (fxL : forall l : L, A (xL l))
 (fxR : forall r : R, A (xR r))
 (fxcut : forall (l : L) (r : R),
          dlt (xL l) (xR r) (xcut l r) (fxL l) (fxR r))
 (L' R' : Type) (s' : InSort S L' R')
 (yL : L' -> GenNo) (yR : R' -> GenNo)
 (ycut : forall (l : L') (r : R'), yL l < yR r)
 (fyL : forall l : L', A (yL l))
 (fyR : forall r : R', A (yR r))
 (fycut : forall (l : L') (r : R'),
          dlt (yL l) (yR r) (ycut l r) (fyL l) (fyR r))
 (r : R) (p : xR r <= {{ yL | yR // ycut }}),
 dle (xR r) {{ yL | yR // ycut }} p (fxR r)
   (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
 dlt {{ xL | xR // xcut }} {{ yL | yR // ycut }}
   (lt_r xL xR xcut yL yR ycut r p)
   (dcut L R s xL xR xcut fxL fxR fxcut)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
A
  {|
    game_of := opt xL xR;
    isno_game_of := isno L R s xL xR Lno Rno xcut
  |}
      intros ishprop_le ishprop_lt dpath dle_lr dlt_l dlt_r.
S: OptionSort
A: GenNo -> Type
dle: forall x y : GenNo, x <= y -> A x -> A y -> Type
dlt: forall x y : GenNo, x < y -> A x -> A y -> Type
dcut: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r)),
(forall (l : L) (r : R),
 dlt (xL l) (xR r) (xcut l r) (fxL l) (fxR r)) ->
A {{ xL | xR // xcut }}
No_ind_internal: forall (x : Game)
(xno : is_surreal x),
A
  {|
    game_of := x;
    isno_game_of := xno
  |}
L, R: Type
s: InSort S L R
xL: L -> Game
xR: R -> Game
Lno: forall l : L, is_surreal (xL l)
Rno: forall r : R, is_surreal (xR r)
xcut: forall (l : L) (r : R), game_lt (xL l) (xR r)
ishprop_le: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x <= y),
IsHProp (dle x y p a b)
ishprop_lt: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x < y),
IsHProp (dlt x y p a b)
dpath: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x <= y) (q : y <= x),
dle x y p a b ->
dle y x q b a ->
transport A (path_No p q) a = b
dle_lr: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) (fxL l) 
           (fxR r)) (L' R' : Type)
(s' : InSort S L' R') (yL : L' -> GenNo)
(yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) (fyL l) 
           (fyR r))
(p : forall l : L,
     xL l < {{ yL | yR // ycut }}),
(forall l : L,
 dlt (xL l) {{ yL | yR // ycut }} 
   (p l) (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
forall
q : forall r : R',
    {{ xL | xR // xcut }} < yR r,
(forall r : R',
 dlt {{ xL | xR // xcut }} 
   (yR r) (q r)
   (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (le_lr xL xR xcut yL yR ycut p q)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) (fxL l) 
           (fxR r)) (L' R' : Type)
(s' : InSort S L' R') (yL : L' -> GenNo)
(yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) (fyL l) 
           (fyR r)) (l : L')
(p : {{ xL | xR // xcut }} <= yL l),
dle {{ xL | xR // xcut }} 
  (yL l) p
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (lt_l xL xR xcut yL yR ycut l p)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) (fxL l) 
           (fxR r)) (L' R' : Type)
(s' : InSort S L' R') (yL : L' -> GenNo)
(yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) (fyL l) 
           (fyR r)) (r : R)
(p : xR r <= {{ yL | yR // ycut }}),
dle (xR r) {{ yL | yR // ycut }} p 
  (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (lt_r xL xR xcut yL yR ycut r p)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
A
  {|
    game_of := opt xL xR;
    isno_game_of := isno L R s xL xR Lno Rno xcut
  |}
      simple refine (dcut L R _ (fun l => Build_No (xL l) (Lno l))
                   (fun r => Build_No (xR r) (Rno r)) xcut _ _ _).
S: OptionSort
A: GenNo -> Type
dle: forall x y : GenNo, x <= y -> A x -> A y -> Type
dlt: forall x y : GenNo, x < y -> A x -> A y -> Type
dcut: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r)),
(forall (l : L) (r : R),
 dlt (xL l) (xR r) (xcut l r) (fxL l) (fxR r)) ->
A {{ xL | xR // xcut }}
No_ind_internal: forall (x : Game)
(xno : is_surreal x),
A
  {|
    game_of := x;
    isno_game_of := xno
  |}
L, R: Type
s: InSort S L R
xL: L -> Game
xR: R -> Game
Lno: forall l : L, is_surreal (xL l)
Rno: forall r : R, is_surreal (xR r)
xcut: forall (l : L) (r : R), game_lt (xL l) (xR r)
ishprop_le: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x <= y),
IsHProp (dle x y p a b)
ishprop_lt: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x < y),
IsHProp (dlt x y p a b)
dpath: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x <= y) (q : y <= x),
dle x y p a b ->
dle y x q b a ->
transport A (path_No p q) a = b
dle_lr: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) (fxL l) 
           (fxR r)) (L' R' : Type)
(s' : InSort S L' R') (yL : L' -> GenNo)
(yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) (fyL l) 
           (fyR r))
(p : forall l : L,
     xL l < {{ yL | yR // ycut }}),
(forall l : L,
 dlt (xL l) {{ yL | yR // ycut }} 
   (p l) (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
forall
q : forall r : R',
    {{ xL | xR // xcut }} < yR r,
(forall r : R',
 dlt {{ xL | xR // xcut }} 
   (yR r) (q r)
   (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (le_lr xL xR xcut yL yR ycut p q)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) (fxL l) 
           (fxR r)) (L' R' : Type)
(s' : InSort S L' R') (yL : L' -> GenNo)
(yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) (fyL l) 
           (fyR r)) (l : L')
(p : {{ xL | xR // xcut }} <= yL l),
dle {{ xL | xR // xcut }} 
  (yL l) p
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (lt_l xL xR xcut yL yR ycut l p)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) (fxL l) 
           (fxR r)) (L' R' : Type)
(s' : InSort S L' R') (yL : L' -> GenNo)
(yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) (fyL l) 
           (fyR r)) (r : R)
(p : xR r <= {{ yL | yR // ycut }}),
dle (xR r) {{ yL | yR // ycut }} p 
  (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (lt_r xL xR xcut yL yR ycut r p)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
forall l : L,
A
  ((fun l0 : L =>
    {| game_of := xL l0; isno_game_of := Lno l0 |}) l)
S: OptionSort
A: GenNo -> Type
dle: forall x y : GenNo, x <= y -> A x -> A y -> Type
dlt: forall x y : GenNo, x < y -> A x -> A y -> Type
dcut: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r)),
(forall (l : L) (r : R),
 dlt (xL l) (xR r) (xcut l r) (fxL l) (fxR r)) ->
A {{ xL | xR // xcut }}
No_ind_internal: forall (x : Game)
(xno : is_surreal x),
A
  {|
    game_of := x;
    isno_game_of := xno
  |}
L, R: Type
s: InSort S L R
xL: L -> Game
xR: R -> Game
Lno: forall l : L, is_surreal (xL l)
Rno: forall r : R, is_surreal (xR r)
xcut: forall (l : L) (r : R), game_lt (xL l) (xR r)
ishprop_le: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x <= y),
IsHProp (dle x y p a b)
ishprop_lt: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x < y),
IsHProp (dlt x y p a b)
dpath: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x <= y) (q : y <= x),
dle x y p a b ->
dle y x q b a ->
transport A (path_No p q) a = b
dle_lr: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) (fxL l) 
           (fxR r)) (L' R' : Type)
(s' : InSort S L' R') (yL : L' -> GenNo)
(yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) (fyL l) 
           (fyR r))
(p : forall l : L,
     xL l < {{ yL | yR // ycut }}),
(forall l : L,
 dlt (xL l) {{ yL | yR // ycut }} 
   (p l) (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
forall
q : forall r : R',
    {{ xL | xR // xcut }} < yR r,
(forall r : R',
 dlt {{ xL | xR // xcut }} 
   (yR r) (q r)
   (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (le_lr xL xR xcut yL yR ycut p q)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) (fxL l) 
           (fxR r)) (L' R' : Type)
(s' : InSort S L' R') (yL : L' -> GenNo)
(yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) (fyL l) 
           (fyR r)) (l : L')
(p : {{ xL | xR // xcut }} <= yL l),
dle {{ xL | xR // xcut }} 
  (yL l) p
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (lt_l xL xR xcut yL yR ycut l p)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) (fxL l) 
           (fxR r)) (L' R' : Type)
(s' : InSort S L' R') (yL : L' -> GenNo)
(yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) (fyL l) 
           (fyR r)) (r : R)
(p : xR r <= {{ yL | yR // ycut }}),
dle (xR r) {{ yL | yR // ycut }} p 
  (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (lt_r xL xR xcut yL yR ycut r p)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
forall r : R,
A
  ((fun r0 : R =>
    {| game_of := xR r0; isno_game_of := Rno r0 |}) r)
S: OptionSort
A: GenNo -> Type
dle: forall x y : GenNo, x <= y -> A x -> A y -> Type
dlt: forall x y : GenNo, x < y -> A x -> A y -> Type
dcut: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r)),
(forall (l : L) (r : R),
 dlt (xL l) (xR r) (xcut l r) (fxL l) (fxR r)) ->
A {{ xL | xR // xcut }}
No_ind_internal: forall (x : Game)
(xno : is_surreal x),
A
  {|
    game_of := x;
    isno_game_of := xno
  |}
L, R: Type
s: InSort S L R
xL: L -> Game
xR: R -> Game
Lno: forall l : L, is_surreal (xL l)
Rno: forall r : R, is_surreal (xR r)
xcut: forall (l : L) (r : R), game_lt (xL l) (xR r)
ishprop_le: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x <= y),
IsHProp (dle x y p a b)
ishprop_lt: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x < y),
IsHProp (dlt x y p a b)
dpath: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x <= y) (q : y <= x),
dle x y p a b ->
dle y x q b a ->
transport A (path_No p q) a = b
dle_lr: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) (fxL l) 
           (fxR r)) (L' R' : Type)
(s' : InSort S L' R') (yL : L' -> GenNo)
(yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) (fyL l) 
           (fyR r))
(p : forall l : L,
     xL l < {{ yL | yR // ycut }}),
(forall l : L,
 dlt (xL l) {{ yL | yR // ycut }} 
   (p l) (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
forall
q : forall r : R',
    {{ xL | xR // xcut }} < yR r,
(forall r : R',
 dlt {{ xL | xR // xcut }} 
   (yR r) (q r)
   (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (le_lr xL xR xcut yL yR ycut p q)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) (fxL l) 
           (fxR r)) (L' R' : Type)
(s' : InSort S L' R') (yL : L' -> GenNo)
(yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) (fyL l) 
           (fyR r)) (l : L')
(p : {{ xL | xR // xcut }} <= yL l),
dle {{ xL | xR // xcut }} 
  (yL l) p
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (lt_l xL xR xcut yL yR ycut l p)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) (fxL l) 
           (fxR r)) (L' R' : Type)
(s' : InSort S L' R') (yL : L' -> GenNo)
(yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) (fyL l) 
           (fyR r)) (r : R)
(p : xR r <= {{ yL | yR // ycut }}),
dle (xR r) {{ yL | yR // ycut }} p 
  (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (lt_r xL xR xcut yL yR ycut r p)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
forall (l : L) (r : R),
dlt
  ((fun l0 : L =>
    {| game_of := xL l0; isno_game_of := Lno l0 |}) l)
  ((fun r0 : R =>
    {| game_of := xR r0; isno_game_of := Rno r0 |}) r)
  (xcut l r) (?fxL l) (?fxR r)
      -
S: OptionSort
A: GenNo -> Type
dle: forall x y : GenNo, x <= y -> A x -> A y -> Type
dlt: forall x y : GenNo, x < y -> A x -> A y -> Type
dcut: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r)),
(forall (l : L) (r : R),
 dlt (xL l) (xR r) (xcut l r) (fxL l) (fxR r)) ->
A {{ xL | xR // xcut }}
No_ind_internal: forall (x : Game)
(xno : is_surreal x),
A
  {|
    game_of := x;
    isno_game_of := xno
  |}
L, R: Type
s: InSort S L R
xL: L -> Game
xR: R -> Game
Lno: forall l : L, is_surreal (xL l)
Rno: forall r : R, is_surreal (xR r)
xcut: forall (l : L) (r : R), game_lt (xL l) (xR r)
ishprop_le: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x <= y),
IsHProp (dle x y p a b)
ishprop_lt: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x < y),
IsHProp (dlt x y p a b)
dpath: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x <= y) (q : y <= x),
dle x y p a b ->
dle y x q b a ->
transport A (path_No p q) a = b
dle_lr: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) (fxL l) 
           (fxR r)) (L' R' : Type)
(s' : InSort S L' R') (yL : L' -> GenNo)
(yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) (fyL l) 
           (fyR r))
(p : forall l : L,
     xL l < {{ yL | yR // ycut }}),
(forall l : L,
 dlt (xL l) {{ yL | yR // ycut }} 
   (p l) (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
forall
q : forall r : R',
    {{ xL | xR // xcut }} < yR r,
(forall r : R',
 dlt {{ xL | xR // xcut }} 
   (yR r) (q r)
   (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (le_lr xL xR xcut yL yR ycut p q)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) (fxL l) 
           (fxR r)) (L' R' : Type)
(s' : InSort S L' R') (yL : L' -> GenNo)
(yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) (fyL l) 
           (fyR r)) (l : L')
(p : {{ xL | xR // xcut }} <= yL l),
dle {{ xL | xR // xcut }} 
  (yL l) p
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (lt_l xL xR xcut yL yR ycut l p)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) (fxL l) 
           (fxR r)) (L' R' : Type)
(s' : InSort S L' R') (yL : L' -> GenNo)
(yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) (fyL l) 
           (fyR r)) (r : R)
(p : xR r <= {{ yL | yR // ycut }}),
dle (xR r) {{ yL | yR // ycut }} p 
  (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (lt_r xL xR xcut yL yR ycut r p)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
forall l : L,
A
  ((fun l0 : L =>
    {| game_of := xL l0; isno_game_of := Lno l0 |}) l) intros l; exact (No_ind_internal (xL l) (Lno l)).
      -
S: OptionSort
A: GenNo -> Type
dle: forall x y : GenNo, x <= y -> A x -> A y -> Type
dlt: forall x y : GenNo, x < y -> A x -> A y -> Type
dcut: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r)),
(forall (l : L) (r : R),
 dlt (xL l) (xR r) (xcut l r) (fxL l) (fxR r)) ->
A {{ xL | xR // xcut }}
No_ind_internal: forall (x : Game)
(xno : is_surreal x),
A
  {|
    game_of := x;
    isno_game_of := xno
  |}
L, R: Type
s: InSort S L R
xL: L -> Game
xR: R -> Game
Lno: forall l : L, is_surreal (xL l)
Rno: forall r : R, is_surreal (xR r)
xcut: forall (l : L) (r : R), game_lt (xL l) (xR r)
ishprop_le: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x <= y),
IsHProp (dle x y p a b)
ishprop_lt: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x < y),
IsHProp (dlt x y p a b)
dpath: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x <= y) (q : y <= x),
dle x y p a b ->
dle y x q b a ->
transport A (path_No p q) a = b
dle_lr: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) (fxL l) 
           (fxR r)) (L' R' : Type)
(s' : InSort S L' R') (yL : L' -> GenNo)
(yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) (fyL l) 
           (fyR r))
(p : forall l : L,
     xL l < {{ yL | yR // ycut }}),
(forall l : L,
 dlt (xL l) {{ yL | yR // ycut }} 
   (p l) (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
forall
q : forall r : R',
    {{ xL | xR // xcut }} < yR r,
(forall r : R',
 dlt {{ xL | xR // xcut }} 
   (yR r) (q r)
   (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (le_lr xL xR xcut yL yR ycut p q)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) (fxL l) 
           (fxR r)) (L' R' : Type)
(s' : InSort S L' R') (yL : L' -> GenNo)
(yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) (fyL l) 
           (fyR r)) (l : L')
(p : {{ xL | xR // xcut }} <= yL l),
dle {{ xL | xR // xcut }} 
  (yL l) p
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (lt_l xL xR xcut yL yR ycut l p)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) (fxL l) 
           (fxR r)) (L' R' : Type)
(s' : InSort S L' R') (yL : L' -> GenNo)
(yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) (fyL l) 
           (fyR r)) (r : R)
(p : xR r <= {{ yL | yR // ycut }}),
dle (xR r) {{ yL | yR // ycut }} p 
  (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (lt_r xL xR xcut yL yR ycut r p)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
forall r : R,
A
  ((fun r0 : R =>
    {| game_of := xR r0; isno_game_of := Rno r0 |}) r) intros r; exact (No_ind_internal (xR r) (Rno r)).
      -
S: OptionSort
A: GenNo -> Type
dle: forall x y : GenNo, x <= y -> A x -> A y -> Type
dlt: forall x y : GenNo, x < y -> A x -> A y -> Type
dcut: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r)),
(forall (l : L) (r : R),
 dlt (xL l) (xR r) (xcut l r) (fxL l) (fxR r)) ->
A {{ xL | xR // xcut }}
No_ind_internal: forall (x : Game)
(xno : is_surreal x),
A
  {|
    game_of := x;
    isno_game_of := xno
  |}
L, R: Type
s: InSort S L R
xL: L -> Game
xR: R -> Game
Lno: forall l : L, is_surreal (xL l)
Rno: forall r : R, is_surreal (xR r)
xcut: forall (l : L) (r : R), game_lt (xL l) (xR r)
ishprop_le: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x <= y),
IsHProp (dle x y p a b)
ishprop_lt: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x < y),
IsHProp (dlt x y p a b)
dpath: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x <= y) (q : y <= x),
dle x y p a b ->
dle y x q b a ->
transport A (path_No p q) a = b
dle_lr: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) (fxL l) 
           (fxR r)) (L' R' : Type)
(s' : InSort S L' R') (yL : L' -> GenNo)
(yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) (fyL l) 
           (fyR r))
(p : forall l : L,
     xL l < {{ yL | yR // ycut }}),
(forall l : L,
 dlt (xL l) {{ yL | yR // ycut }} 
   (p l) (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
forall
q : forall r : R',
    {{ xL | xR // xcut }} < yR r,
(forall r : R',
 dlt {{ xL | xR // xcut }} 
   (yR r) (q r)
   (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (le_lr xL xR xcut yL yR ycut p q)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) (fxL l) 
           (fxR r)) (L' R' : Type)
(s' : InSort S L' R') (yL : L' -> GenNo)
(yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) (fyL l) 
           (fyR r)) (l : L')
(p : {{ xL | xR // xcut }} <= yL l),
dle {{ xL | xR // xcut }} 
  (yL l) p
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (lt_l xL xR xcut yL yR ycut l p)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) (fxL l) 
           (fxR r)) (L' R' : Type)
(s' : InSort S L' R') (yL : L' -> GenNo)
(yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) (fyL l) 
           (fyR r)) (r : R)
(p : xR r <= {{ yL | yR // ycut }}),
dle (xR r) {{ yL | yR // ycut }} p 
  (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (lt_r xL xR xcut yL yR ycut r p)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
forall (l : L) (r : R),
dlt
  ((fun l0 : L =>
    {| game_of := xL l0; isno_game_of := Lno l0 |}) l)
  ((fun r0 : R =>
    {| game_of := xR r0; isno_game_of := Rno r0 |}) r)
  (xcut l r)
  ((fun l0 : L => No_ind_internal (xL l0) (Lno l0)) l)
  ((fun r0 : R => No_ind_internal (xR r0) (Rno r0)) r) intros; exact (match No_Empty_admitted with end).
    Defined.

    Local Fixpoint No_ind_internal (x : Game) (xno : is_surreal x)
          {struct xno}
    : A (Build_No x xno).
S: OptionSort
A: GenNo -> Type
dle: forall x y : GenNo, x <= y -> A x -> A y -> Type
dlt: forall x y : GenNo, x < y -> A x -> A y -> Type
ishprop_le: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x <= y),
IsHProp (dle x y p a b)
ishprop_lt: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x < y),
IsHProp (dlt x y p a b)
dcut: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r)),
(forall (l : L) (r : R),
 dlt (xL l) (xR r) (xcut l r) (fxL l) (fxR r)) ->
A {{ xL | xR // xcut }}
dpath: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x <= y) 
(q : y <= x),
dle x y p a b ->
dle y x q b a ->
transport A (path_No p q) a = b
dle_lr: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) 
         (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) 
           (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo) (yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) 
           (fyL l) (fyR r))
(p : forall l : L,
     xL l < {{ yL | yR // ycut }}),
(forall l : L,
 dlt (xL l) {{ yL | yR // ycut }} 
   (p l) (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
forall
q : forall r : R',
    {{ xL | xR // xcut }} < yR r,
(forall r : R',
 dlt {{ xL | xR // xcut }} 
   (yR r) (q r)
   (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (le_lr xL xR xcut yL yR ycut p q)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) 
         (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) 
           (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo) (yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) 
           (fyL l) (fyR r)) 
(l : L') (p : {{ xL | xR // xcut }} <= yL l),
dle {{ xL | xR // xcut }} 
  (yL l) p
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (lt_l xL xR xcut yL yR ycut l p)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) 
         (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) 
           (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo) (yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) 
           (fyL l) (fyR r)) 
(r : R) (p : xR r <= {{ yL | yR // ycut }}),
dle (xR r) {{ yL | yR // ycut }} p 
  (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (lt_r xL xR xcut yL yR ycut r p)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
No_ind_internal: forall (x : Game)
(xno : is_surreal x),
A
  {|
    game_of := x;
    isno_game_of := xno
  |}
x: Game
xno: is_surreal x
A {| game_of := x; isno_game_of := xno |}
    Proof.
S: OptionSort
A: GenNo -> Type
dle: forall x y : GenNo, x <= y -> A x -> A y -> Type
dlt: forall x y : GenNo, x < y -> A x -> A y -> Type
ishprop_le: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x <= y),
IsHProp (dle x y p a b)
ishprop_lt: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x < y),
IsHProp (dlt x y p a b)
dcut: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r)),
(forall (l : L) (r : R),
 dlt (xL l) (xR r) (xcut l r) (fxL l) (fxR r)) ->
A {{ xL | xR // xcut }}
dpath: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x <= y) 
(q : y <= x),
dle x y p a b ->
dle y x q b a ->
transport A (path_No p q) a = b
dle_lr: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) 
         (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) 
           (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo) (yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) 
           (fyL l) (fyR r))
(p : forall l : L,
     xL l < {{ yL | yR // ycut }}),
(forall l : L,
 dlt (xL l) {{ yL | yR // ycut }} 
   (p l) (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
forall
q : forall r : R',
    {{ xL | xR // xcut }} < yR r,
(forall r : R',
 dlt {{ xL | xR // xcut }} 
   (yR r) (q r)
   (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (le_lr xL xR xcut yL yR ycut p q)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) 
         (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) 
           (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo) (yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) 
           (fyL l) (fyR r)) 
(l : L') (p : {{ xL | xR // xcut }} <= yL l),
dle {{ xL | xR // xcut }} 
  (yL l) p
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (lt_l xL xR xcut yL yR ycut l p)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) 
         (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) 
           (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo) (yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) 
           (fyL l) (fyR r)) 
(r : R) (p : xR r <= {{ yL | yR // ycut }}),
dle (xR r) {{ yL | yR // ycut }} p 
  (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (lt_r xL xR xcut yL yR ycut r p)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
No_ind_internal: forall (x : Game)
(xno : is_surreal x),
A
  {|
    game_of := x;
    isno_game_of := xno
  |}
x: Game
xno: is_surreal x
A {| game_of := x; isno_game_of := xno |}
      exact (No_ind_internal_step No_ind_internal x xno).
    Defined.

    Definition No_ind (x : GenNo) : A x.
S: OptionSort
A: GenNo -> Type
dle: forall x y : GenNo, x <= y -> A x -> A y -> Type
dlt: forall x y : GenNo, x < y -> A x -> A y -> Type
ishprop_le: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x <= y),
IsHProp (dle x y p a b)
ishprop_lt: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x < y),
IsHProp (dlt x y p a b)
dcut: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r)),
(forall (l : L) (r : R),
 dlt (xL l) (xR r) (xcut l r) (fxL l) (fxR r)) ->
A {{ xL | xR // xcut }}
dpath: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x <= y) 
(q : y <= x),
dle x y p a b ->
dle y x q b a ->
transport A (path_No p q) a = b
dle_lr: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) 
         (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) 
           (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo) (yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) 
           (fyL l) (fyR r))
(p : forall l : L,
     xL l < {{ yL | yR // ycut }}),
(forall l : L,
 dlt (xL l) {{ yL | yR // ycut }} 
   (p l) (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
forall
q : forall r : R',
    {{ xL | xR // xcut }} < yR r,
(forall r : R',
 dlt {{ xL | xR // xcut }} 
   (yR r) (q r)
   (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (le_lr xL xR xcut yL yR ycut p q)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) 
         (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) 
           (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo) (yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) 
           (fyL l) (fyR r)) 
(l : L') (p : {{ xL | xR // xcut }} <= yL l),
dle {{ xL | xR // xcut }} 
  (yL l) p
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (lt_l xL xR xcut yL yR ycut l p)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) 
         (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) 
           (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo) (yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) 
           (fyL l) (fyR r)) 
(r : R) (p : xR r <= {{ yL | yR // ycut }}),
dle (xR r) {{ yL | yR // ycut }} p 
  (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (lt_r xL xR xcut yL yR ycut r p)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
x: GenNo
A x
    Proof.
S: OptionSort
A: GenNo -> Type
dle: forall x y : GenNo, x <= y -> A x -> A y -> Type
dlt: forall x y : GenNo, x < y -> A x -> A y -> Type
ishprop_le: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x <= y),
IsHProp (dle x y p a b)
ishprop_lt: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x < y),
IsHProp (dlt x y p a b)
dcut: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r)),
(forall (l : L) (r : R),
 dlt (xL l) (xR r) (xcut l r) (fxL l) (fxR r)) ->
A {{ xL | xR // xcut }}
dpath: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x <= y) 
(q : y <= x),
dle x y p a b ->
dle y x q b a ->
transport A (path_No p q) a = b
dle_lr: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) 
         (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) 
           (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo) (yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) 
           (fyL l) (fyR r))
(p : forall l : L,
     xL l < {{ yL | yR // ycut }}),
(forall l : L,
 dlt (xL l) {{ yL | yR // ycut }} 
   (p l) (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
forall
q : forall r : R',
    {{ xL | xR // xcut }} < yR r,
(forall r : R',
 dlt {{ xL | xR // xcut }} 
   (yR r) (q r)
   (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (le_lr xL xR xcut yL yR ycut p q)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) 
         (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) 
           (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo) (yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) 
           (fyL l) (fyR r)) 
(l : L') (p : {{ xL | xR // xcut }} <= yL l),
dle {{ xL | xR // xcut }} 
  (yL l) p
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (lt_l xL xR xcut yL yR ycut l p)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) 
         (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) 
           (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo) (yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) 
           (fyL l) (fyR r)) 
(r : R) (p : xR r <= {{ yL | yR // ycut }}),
dle (xR r) {{ yL | yR // ycut }} p 
  (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (lt_r xL xR xcut yL yR ycut r p)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
x: GenNo
A x
      destruct x as [x xno].
S: OptionSort
A: GenNo -> Type
dle: forall x y : GenNo, x <= y -> A x -> A y -> Type
dlt: forall x y : GenNo, x < y -> A x -> A y -> Type
ishprop_le: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x <= y),
IsHProp (dle x y p a b)
ishprop_lt: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x < y),
IsHProp (dlt x y p a b)
dcut: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r)),
(forall (l : L) (r : R),
 dlt (xL l) (xR r) (xcut l r) (fxL l) (fxR r)) ->
A {{ xL | xR // xcut }}
dpath: forall (x y : GenNo) (a : A x) 
(b : A y) (p : x <= y) 
(q : y <= x),
dle x y p a b ->
dle y x q b a ->
transport A (path_No p q) a = b
dle_lr: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) 
         (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) 
           (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo) (yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) 
           (fyL l) (fyR r))
(p : forall l : L,
     xL l < {{ yL | yR // ycut }}),
(forall l : L,
 dlt (xL l) {{ yL | yR // ycut }} 
   (p l) (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
forall
q : forall r : R',
    {{ xL | xR // xcut }} < yR r,
(forall r : R',
 dlt {{ xL | xR // xcut }} 
   (yR r) (q r)
   (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (le_lr xL xR xcut yL yR ycut p q)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) 
         (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) 
           (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo) (yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) 
           (fyL l) (fyR r)) 
(l : L') (p : {{ xL | xR // xcut }} <= yL l),
dle {{ xL | xR // xcut }} 
  (yL l) p
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (lt_l xL xR xcut yL yR ycut l p)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo) (xR : R -> GenNo)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : forall l : L, A (xL l))
(fxR : forall r : R, A (xR r))
(fxcut : forall (l : L) 
         (r : R),
         dlt (xL l) (xR r) 
           (xcut l r) 
           (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo) (yR : R' -> GenNo)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L', A (yL l))
(fyR : forall r : R', A (yR r))
(fycut : forall (l : L') 
         (r : R'),
         dlt (yL l) (yR r) 
           (ycut l r) 
           (fyL l) (fyR r)) 
(r : R) (p : xR r <= {{ yL | yR // ycut }}),
dle (xR r) {{ yL | yR // ycut }} p 
  (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
  (lt_r xL xR xcut yL yR ycut r p)
  (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
x: Game
xno: is_surreal x
A {| game_of := x; isno_game_of := xno |}
      exact (No_ind_internal x xno).
    Defined.

    Definition No_ind_le (x y : GenNo) (p : x <= y)
    : dle x y p (No_ind x) (No_ind y)
      := match No_Empty_admitted with end.

    Definition No_ind_lt (x y : GenNo) (p : x < y)
    : dlt x y p (No_ind x) (No_ind y)
      := match No_Empty_admitted with end.

    (** Sometimes it's convenient to have all three parts of [No_ind] in one package, so that we only have to verify the hypotheses once. *)
    Definition No_ind_package
    : { f : forall x, A x &
      (forall (x y : GenNo) (p : x <= y), dle x y p (f x) (f y)) *
      (forall (x y : GenNo) (p : x < y), dlt x y p (f x) (f y)) }
      := ( No_ind ; (No_ind_le , No_ind_lt) ).

    (** It's also sometimes convenient to have just the inequality parts together. *)
    Definition No_ind_le_lt (x y : GenNo)
    : (forall (p : x <= y), dle x y p (No_ind x) (No_ind y)) *
      (forall (p : x < y), dlt x y p (No_ind x) (No_ind y))
      := (No_ind_le x y , No_ind_lt x y).

    (** We verify that our definition computes judgmentally. *)
    Definition No_ind_cut
               (L R : Type@{i}) (s : InSort S L R)
               (xL : L -> GenNo) (xR : R -> GenNo)
               (xcut : forall (l:L) (r:R), (xL l) < (xR r))
    : No_ind {{ xL | xR // xcut }}
      = dcut L R _ xL xR xcut
             (fun l => No_ind (xL l)) (fun r => No_ind (xR r))
             (fun l r => No_ind_lt (xL l) (xR r) (xcut l r))
      := 1.

  End NoInd.

  End OptionSort.

  Arguments GenNo S : clear implicits.
  Infix "<" := lt : surreal_scope.
  Infix "<=" := le : surreal_scope.
  Notation "{ { xL | xR // xcut } }" := (No_cut xL xR xcut) : surreal_scope.

End Surreals.

Section OptionSort.
Universe i.
Context {S : OptionSort@{i}}.
Let No := GenNo S.

(** ** A few surreal numbers *)

Definition rempty_cut {L : Type} {xL : L -> No}
  : forall (l:L) (r:Empty), xL l < Empty_rec r
  := fun l => Empty_ind _.

Definition lempty_cut {R : Type} {xR : R -> No}
  : forall (l:Empty) (r:R), Empty_rec l < xR r
  := Empty_ind _.

Definition zero `{InSort S Empty Empty} : No
  := {{ Empty_rec | Empty_rec // lempty_cut }}.

Definition one `{InSort S Empty Empty} `{InSort S Unit Empty} : No
  := {{ unit_name zero | Empty_rec // rempty_cut }}.

Definition minusone `{InSort S Empty Empty} `{InSort S Empty Unit} : No
  := {{ Empty_rec | unit_name zero // lempty_cut }}.

(** ** More induction principles *)

(** *** The simplified induction principle for hprops *)

Definition No_ind_hprop (P : No -> Type) `{forall x, IsHProp (P x)}
           (dcut : forall (L R : Type) (s : InSort S L R)
                          (xL : L -> No) (xR : R -> No)
                          (xcut : forall (l:L) (r:R), (xL l) < (xR r))
                          (IHL : forall l, P (xL l))
                          (IHR : forall r, P (xR r)),
                     P {{ xL | xR // xcut }})
           (x : No)
: P x.
S: OptionSort
No:= GenNo S: Type
P: No -> Type
H: forall x : No, IsHProp (P x)
dcut: forall (L R : Type) (s : InSort S L R)
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r),
(forall l : L, P (xL l)) ->
(forall r : R, P (xR r)) ->
P {{ xL | xR // xcut }}
x: No
P x
Proof.
S: OptionSort
No:= GenNo S: Type
P: No -> Type
H: forall x : No, IsHProp (P x)
dcut: forall (L R : Type) (s : InSort S L R)
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r),
(forall l : L, P (xL l)) ->
(forall r : R, P (xR r)) ->
P {{ xL | xR // xcut }}
x: No
P x
  revert x;
  refine (No_ind P (fun _ _ _ _ _ => Unit) (fun _ _ _ _ _ => Unit)
                 _ _ _ _ _);
  intros; try apply path_ishprop; try exact tt.
S: OptionSort
No:= GenNo S: Type
P: No -> Type
H: forall x : No, IsHProp (P x)
dcut: forall (L R : Type) (s : InSort S L R)
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r),
(forall l : L, P (xL l)) ->
(forall r : R, P (xR r)) ->
P {{ xL | xR // xcut }}
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
fxL: forall l : L, P (xL l)
fxR: forall r : R, P (xR r)
fxcut: L -> R -> Unit
P {{ xL | xR // xcut }}
  apply dcut; assumption.
Defined.

(** See also [repeat_No_ind_hprop], below *)

(** *** The non-dependent recursion principle *)

Section NoRec.
  Context `{Funext}.

  Context  (A : Type)
           (dle : A -> A -> Type) `{is_mere_relation A dle}
           (dlt : A -> A -> Type) `{is_mere_relation A dlt}
           (dcut : forall (L R : Type@{i}) (s : InSort S L R)
                          (xL : L -> No) (xR : R -> No)
                          (xcut : forall (l:L) (r:R), (xL l) < (xR r))
                          (fxL : L -> A) (fxR : R -> A)
                          (fxcut : forall l r, dlt (fxL l) (fxR r)),
                     A)
           (dpath : forall a b, dle a b -> dle b a -> a = b)
           (dle_lr : forall (L R : Type@{i}) (s : InSort S L R)
                            (xL : L -> No) (xR : R -> No)
                            (xcut : forall (l:L) (r:R), (xL l) < (xR r))
                            (fxL : L -> A) (fxR : R -> A)
                            (fxcut : forall l r, dlt (fxL l) (fxR r))
                            (L' R' : Type@{i}) (s' : InSort S L' R')
                            (yL : L' -> No) (yR : R' -> No)
                            (ycut : forall (l:L') (r:R'), (yL l) < (yR r))
                            (fyL : L' -> A) (fyR : R' -> A)
                            (fycut : forall l r, dlt (fyL l) (fyR r))
                            (p : forall (l:L), xL l < {{ yL | yR // ycut }})
                            (dp : forall (l:L),
                                    dlt (fxL l) (dcut _ _ _ yL yR ycut fyL fyR fycut))
                            (q : forall (r:R'), {{ xL | xR // xcut }} < yR r)
                            (dq : forall (r:R'),
                                    dlt (dcut _ _ _ xL xR xcut fxL fxR fxcut) (fyR r)),
                       dle (dcut _ _ _ xL xR xcut fxL fxR fxcut)
                           (dcut _ _ _ yL yR ycut fyL fyR fycut))
           (dlt_l : forall (L R : Type@{i}) (s : InSort S L R)
                           (xL : L -> No) (xR : R -> No)
                           (xcut : forall (l:L) (r:R), (xL l) < (xR r))
                           (fxL : L -> A) (fxR : R -> A)
                           (fxcut : forall l r, dlt (fxL l) (fxR r))
                           (L' R' : Type@{i}) (s' : InSort S L' R')
                           (yL : L' -> No) (yR : R' -> No)
                           (ycut : forall (l:L') (r:R'), (yL l) < (yR r))
                           (fyL : L' -> A) (fyR : R' -> A)
                           (fycut : forall l r, dlt (fyL l) (fyR r))
                           (l : L') (p : {{ xL | xR // xcut }} <= yL l)
                           (dp : dle (dcut _ _ _ xL xR xcut fxL fxR fxcut) (fyL l)),
                      dlt (dcut _ _ _ xL xR xcut fxL fxR fxcut)
                          (dcut _ _ _ yL yR ycut fyL fyR fycut))
           (dlt_r : forall (L R : Type@{i}) (s : InSort S L R)
                           (xL : L -> No) (xR : R -> No)
                           (xcut : forall (l:L) (r:R), (xL l) < (xR r))
                           (fxL : L -> A) (fxR : R -> A)
                           (fxcut : forall l r, dlt (fxL l) (fxR r))
                           (L' R' : Type@{i}) (s' : InSort S L' R')
                           (yL : L' -> No) (yR : R' -> No)
                           (ycut : forall (l:L') (r:R'), (yL l) < (yR r))
                           (fyL : L' -> A) (fyR : R' -> A)
                           (fycut : forall l r, dlt (fyL l) (fyR r))
                           (r : R) (p : (xR r) <= {{ yL | yR // ycut }})
                           (dp : dle (fxR r) (dcut _ _ _ yL yR ycut fyL fyR fycut)),
                      dlt (dcut _ _ _ xL xR xcut fxL fxR fxcut)
                          (dcut _ _ _ yL yR ycut fyL fyR fycut)).

  Definition No_rec (x : No) : A.
S: OptionSort
No:= GenNo S: Type
H: Funext
A: Type
dle: A -> A -> Type
is_mere_relation0: is_mere_relation A dle
dlt: A -> A -> Type
is_mere_relation1: is_mere_relation A dlt
dcut: forall L R : Type,
InSort S L R ->
forall (xL : L -> No) 
(xR : R -> No),
(forall (l : L) (r : R), xL l < xR r) ->
forall (fxL : L -> A) 
(fxR : R -> A),
(forall (l : L) (r : R), dlt (fxL l) (fxR r)) ->
A
dpath: forall a b : A, dle a b -> dle b a -> a = b
dle_lr: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)),
(forall l : L, xL l < {{ yL | yR // ycut }}) ->
(forall l : L,
 dlt (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
(forall r : R', {{ xL | xR // xcut }} < yR r) ->
(forall r : R',
 dlt (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(l : L'),
{{ xL | xR // xcut }} <= yL l ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(r : R),
xR r <= {{ yL | yR // ycut }} ->
dle (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
x: No
A
  Proof.
S: OptionSort
No:= GenNo S: Type
H: Funext
A: Type
dle: A -> A -> Type
is_mere_relation0: is_mere_relation A dle
dlt: A -> A -> Type
is_mere_relation1: is_mere_relation A dlt
dcut: forall L R : Type,
InSort S L R ->
forall (xL : L -> No) 
(xR : R -> No),
(forall (l : L) (r : R), xL l < xR r) ->
forall (fxL : L -> A) 
(fxR : R -> A),
(forall (l : L) (r : R), dlt (fxL l) (fxR r)) ->
A
dpath: forall a b : A, dle a b -> dle b a -> a = b
dle_lr: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)),
(forall l : L, xL l < {{ yL | yR // ycut }}) ->
(forall l : L,
 dlt (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
(forall r : R', {{ xL | xR // xcut }} < yR r) ->
(forall r : R',
 dlt (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(l : L'),
{{ xL | xR // xcut }} <= yL l ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(r : R),
xR r <= {{ yL | yR // ycut }} ->
dle (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
x: No
A
    revert x;
    simple refine (No_ind (fun _ => A) (fun _ _ _ a b => dle a b)
                   (fun _ _ _ a b => dlt a b)
                   _ _ _ _ _);
    intros.
S: OptionSort
No:= GenNo S: Type
H: Funext
A: Type
dle: A -> A -> Type
is_mere_relation0: is_mere_relation A dle
dlt: A -> A -> Type
is_mere_relation1: is_mere_relation A dlt
dcut: forall L R : Type,
InSort S L R ->
forall (xL : L -> No) 
(xR : R -> No),
(forall (l : L) (r : R), xL l < xR r) ->
forall (fxL : L -> A) 
(fxR : R -> A),
(forall (l : L) (r : R), dlt (fxL l) (fxR r)) ->
A
dpath: forall a b : A, dle a b -> dle b a -> a = b
dle_lr: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)),
(forall l : L, xL l < {{ yL | yR // ycut }}) ->
(forall l : L,
 dlt (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
(forall r : R', {{ xL | xR // xcut }} < yR r) ->
(forall r : R',
 dlt (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(l : L'),
{{ xL | xR // xcut }} <= yL l ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(r : R),
xR r <= {{ yL | yR // ycut }} ->
dle (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
fxL: forall l : L, (fun _ : GenNo S => A) (xL l)
fxR: forall r : R, (fun _ : GenNo S => A) (xR r)
fxcut: forall (l : L) (r : R),
(fun (x y : GenNo S) 
   (_ : x < y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dlt a b) (xL l) (xR r) 
  (xcut l r) (fxL l) 
  (fxR r)
(fun _ : GenNo S => A) {{ xL | xR // xcut }}
S: OptionSort
No:= GenNo S: Type
H: Funext
A: Type
dle: A -> A -> Type
is_mere_relation0: is_mere_relation A dle
dlt: A -> A -> Type
is_mere_relation1: is_mere_relation A dlt
dcut: forall L R : Type,
InSort S L R ->
forall (xL : L -> No) 
(xR : R -> No),
(forall (l : L) (r : R), xL l < xR r) ->
forall (fxL : L -> A) 
(fxR : R -> A),
(forall (l : L) (r : R), dlt (fxL l) (fxR r)) ->
A
dpath: forall a b : A, dle a b -> dle b a -> a = b
dle_lr: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)),
(forall l : L, xL l < {{ yL | yR // ycut }}) ->
(forall l : L,
 dlt (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
(forall r : R', {{ xL | xR // xcut }} < yR r) ->
(forall r : R',
 dlt (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(l : L'),
{{ xL | xR // xcut }} <= yL l ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(r : R),
xR r <= {{ yL | yR // ycut }} ->
dle (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
x, y: GenNo S
a: (fun _ : GenNo S => A) x
b: (fun _ : GenNo S => A) y
p: x <= y
q: y <= x
dp: (fun (x y : GenNo S) 
   (_ : x <= y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dle a b) x y p a b
dq: (fun (x y : GenNo S) 
   (_ : x <= y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dle a b) y x q b a
transport (fun _ : GenNo S => A) (path_No x y p q) a =
b
S: OptionSort
No:= GenNo S: Type
H: Funext
A: Type
dle: A -> A -> Type
is_mere_relation0: is_mere_relation A dle
dlt: A -> A -> Type
is_mere_relation1: is_mere_relation A dlt
dcut: forall L R : Type,
InSort S L R ->
forall (xL : L -> No) 
(xR : R -> No),
(forall (l : L) (r : R), xL l < xR r) ->
forall (fxL : L -> A) 
(fxR : R -> A),
(forall (l : L) (r : R), dlt (fxL l) (fxR r)) ->
A
dpath: forall a b : A, dle a b -> dle b a -> a = b
dle_lr: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)),
(forall l : L, xL l < {{ yL | yR // ycut }}) ->
(forall l : L,
 dlt (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
(forall r : R', {{ xL | xR // xcut }} < yR r) ->
(forall r : R',
 dlt (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(l : L'),
{{ xL | xR // xcut }} <= yL l ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(r : R),
xR r <= {{ yL | yR // ycut }} ->
dle (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
fxL: forall l : L, (fun _ : GenNo S => A) (xL l)
fxR: forall r : R, (fun _ : GenNo S => A) (xR r)
fxcut: forall (l : L) (r : R),
(fun (x y : GenNo S) 
   (_ : x < y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dlt a b) (xL l) (xR r) 
  (xcut l r) (fxL l) 
  (fxR r)
L', R': Type
s': InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
fyL: forall l : L', (fun _ : GenNo S => A) (yL l)
fyR: forall r : R', (fun _ : GenNo S => A) (yR r)
fycut: forall (l : L') (r : R'),
(fun (x y : GenNo S) 
   (_ : x < y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dlt a b) (yL l) (yR r) 
  (ycut l r) (fyL l) 
  (fyR r)
p: forall l : L, xL l < {{ yL | yR // ycut }}
dp: forall l : L,
(fun (x y : GenNo S) 
   (_ : x < y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dlt a b) (xL l) {{ yL | yR // ycut }} 
  (p l) (fxL l)
  ((fun (L R : Type) 
      (s : InSort S L R) 
      (xL : L -> GenNo S) 
      (xR : R -> GenNo S)
      (xcut : forall 
              (l0 : L) 
              (r : R), 
              xL l0 < xR r)
      (fxL : forall 
             l0 : L,
             (fun _ : GenNo S => A) (xL l0))
      (fxR : forall 
             r : R, 
             (fun _ : GenNo S => A) (xR r))
      (fxcut : forall 
               (l0 : L) 
               (r : R),
               (fun 
                 (x y : GenNo S) 
                 (_ : x < y)
                 (a : (fun _ : GenNo S => A) x)
                 (b : (fun _ : GenNo S => A) y)
                => 
                dlt a b) 
                 (xL l0) 
                 (xR r) 
                 (xcut l0 r) 
                 (fxL l0) 
                 (fxR r)) => 
    ?Goal) L' R' s' yL yR ycut fyL fyR fycut)
q: forall r : R', {{ xL | xR // xcut }} < yR r
dq: forall r : R',
(fun (x y : GenNo S) 
   (_ : x < y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dlt a b) {{ xL | xR // xcut }} 
  (yR r) (q r)
  ((fun (L R : Type) 
      (s : InSort S L R) 
      (xL : L -> GenNo S) 
      (xR : R -> GenNo S)
      (xcut : forall 
              (l : L) 
              (r0 : R), 
              xL l < xR r0)
      (fxL : forall 
             l : L, 
             (fun _ : GenNo S => A) (xL l))
      (fxR : forall 
             r0 : R,
             (fun _ : GenNo S => A) (xR r0))
      (fxcut : forall 
               (l : L) 
               (r0 : R),
               (fun 
                 (x y : GenNo S) 
                 (_ : x < y)
                 (a : (fun _ : GenNo S => A) x)
                 (b : (fun _ : GenNo S => A) y)
                => 
                dlt a b) 
                 (xL l) 
                 (xR r0) 
                 (xcut l r0) 
                 (fxL l) 
                 (fxR r0)) => 
    ?Goal) L R s xL xR xcut fxL fxR fxcut)
  (fyR r)
(fun (x y : GenNo S) 
   (_ : x <= y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dle a b) {{ xL | xR // xcut }} {{ yL | yR // ycut }}
  (le_lr xL xR xcut yL yR ycut p q)
  ((fun (L R : Type) 
      (s : InSort S L R) 
      (xL : L -> GenNo S) 
      (xR : R -> GenNo S)
      (xcut : forall (l : L) (r : R), xL l < xR r)
      (fxL : forall 
             l : L, 
             (fun _ : GenNo S => A) (xL l))
      (fxR : forall 
             r : R, 
             (fun _ : GenNo S => A) (xR r))
      (fxcut : forall 
               (l : L) 
               (r : R),
               (fun 
                 (x y : GenNo S) 
                 (_ : x < y)
                 (a : (fun _ : GenNo S => A) x)
                 (b : (fun _ : GenNo S => A) y) =>
                dlt a b) 
                 (xL l) 
                 (xR r) 
                 (xcut l r) 
                 (fxL l) 
                 (fxR r)) => 
    ?Goal) L R s xL xR xcut fxL fxR fxcut)
  ((fun (L R : Type) 
      (s : InSort S L R) 
      (xL : L -> GenNo S) 
      (xR : R -> GenNo S)
      (xcut : forall (l : L) (r : R), xL l < xR r)
      (fxL : forall 
             l : L, 
             (fun _ : GenNo S => A) (xL l))
      (fxR : forall 
             r : R, 
             (fun _ : GenNo S => A) (xR r))
      (fxcut : forall 
               (l : L) 
               (r : R),
               (fun 
                 (x y : GenNo S) 
                 (_ : x < y)
                 (a : (fun _ : GenNo S => A) x)
                 (b : (fun _ : GenNo S => A) y) =>
                dlt a b) 
                 (xL l) 
                 (xR r) 
                 (xcut l r) 
                 (fxL l) 
                 (fxR r)) => 
    ?Goal) L' R' s' yL yR ycut fyL fyR fycut)
S: OptionSort
No:= GenNo S: Type
H: Funext
A: Type
dle: A -> A -> Type
is_mere_relation0: is_mere_relation A dle
dlt: A -> A -> Type
is_mere_relation1: is_mere_relation A dlt
dcut: forall L R : Type,
InSort S L R ->
forall (xL : L -> No) 
(xR : R -> No),
(forall (l : L) (r : R), xL l < xR r) ->
forall (fxL : L -> A) 
(fxR : R -> A),
(forall (l : L) (r : R), dlt (fxL l) (fxR r)) ->
A
dpath: forall a b : A, dle a b -> dle b a -> a = b
dle_lr: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)),
(forall l : L, xL l < {{ yL | yR // ycut }}) ->
(forall l : L,
 dlt (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
(forall r : R', {{ xL | xR // xcut }} < yR r) ->
(forall r : R',
 dlt (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(l : L'),
{{ xL | xR // xcut }} <= yL l ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(r : R),
xR r <= {{ yL | yR // ycut }} ->
dle (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
fxL: forall l : L, (fun _ : GenNo S => A) (xL l)
fxR: forall r : R, (fun _ : GenNo S => A) (xR r)
fxcut: forall (l : L) (r : R),
(fun (x y : GenNo S) 
   (_ : x < y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dlt a b) (xL l) (xR r) 
  (xcut l r) (fxL l) 
  (fxR r)
L', R': Type
s': InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
fyL: forall l : L', (fun _ : GenNo S => A) (yL l)
fyR: forall r : R', (fun _ : GenNo S => A) (yR r)
fycut: forall (l : L') (r : R'),
(fun (x y : GenNo S) 
   (_ : x < y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dlt a b) (yL l) (yR r) 
  (ycut l r) (fyL l) 
  (fyR r)
l: L'
p: {{ xL | xR // xcut }} <= yL l
dp: (fun (x y : GenNo S) 
   (_ : x <= y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dle a b) {{ xL | xR // xcut }} 
  (yL l) p
  ((fun (L R : Type) 
      (s : InSort S L R) 
      (xL : L -> GenNo S) 
      (xR : R -> GenNo S)
      (xcut : forall (l : L) (r : R), xL l < xR r)
      (fxL : forall 
             l : L, 
             (fun _ : GenNo S => A) (xL l))
      (fxR : forall 
             r : R, 
             (fun _ : GenNo S => A) (xR r))
      (fxcut : forall 
               (l : L) 
               (r : R),
               (fun 
                 (x y : GenNo S) 
                 (_ : x < y)
                 (a : (fun _ : GenNo S => A) x)
                 (b : (fun _ : GenNo S => A) y)
                => 
                dlt a b) 
                 (xL l) 
                 (xR r) 
                 (xcut l r) 
                 (fxL l) 
                 (fxR r)) => 
    ?Goal) L R s xL xR xcut fxL fxR fxcut)
  (fyL l)
(fun (x y : GenNo S) 
   (_ : x < y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dlt a b) {{ xL | xR // xcut }} {{ yL | yR // ycut }}
  (lt_l xL xR xcut yL yR ycut l p)
  ((fun (L R : Type) 
      (s : InSort S L R) 
      (xL : L -> GenNo S) 
      (xR : R -> GenNo S)
      (xcut : forall (l : L) (r : R), xL l < xR r)
      (fxL : forall 
             l : L, 
             (fun _ : GenNo S => A) (xL l))
      (fxR : forall 
             r : R, 
             (fun _ : GenNo S => A) (xR r))
      (fxcut : forall 
               (l : L) 
               (r : R),
               (fun 
                 (x y : GenNo S) 
                 (_ : x < y)
                 (a : (fun _ : GenNo S => A) x)
                 (b : (fun _ : GenNo S => A) y) =>
                dlt a b) 
                 (xL l) 
                 (xR r) 
                 (xcut l r) 
                 (fxL l) 
                 (fxR r)) => 
    ?Goal) L R s xL xR xcut fxL fxR fxcut)
  ((fun (L R : Type) 
      (s : InSort S L R) 
      (xL : L -> GenNo S) 
      (xR : R -> GenNo S)
      (xcut : forall (l : L) (r : R), xL l < xR r)
      (fxL : forall 
             l : L, 
             (fun _ : GenNo S => A) (xL l))
      (fxR : forall 
             r : R, 
             (fun _ : GenNo S => A) (xR r))
      (fxcut : forall 
               (l : L) 
               (r : R),
               (fun 
                 (x y : GenNo S) 
                 (_ : x < y)
                 (a : (fun _ : GenNo S => A) x)
                 (b : (fun _ : GenNo S => A) y) =>
                dlt a b) 
                 (xL l) 
                 (xR r) 
                 (xcut l r) 
                 (fxL l) 
                 (fxR r)) => 
    ?Goal) L' R' s' yL yR ycut fyL fyR fycut)
S: OptionSort
No:= GenNo S: Type
H: Funext
A: Type
dle: A -> A -> Type
is_mere_relation0: is_mere_relation A dle
dlt: A -> A -> Type
is_mere_relation1: is_mere_relation A dlt
dcut: forall L R : Type,
InSort S L R ->
forall (xL : L -> No) 
(xR : R -> No),
(forall (l : L) (r : R), xL l < xR r) ->
forall (fxL : L -> A) 
(fxR : R -> A),
(forall (l : L) (r : R), dlt (fxL l) (fxR r)) ->
A
dpath: forall a b : A, dle a b -> dle b a -> a = b
dle_lr: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)),
(forall l : L, xL l < {{ yL | yR // ycut }}) ->
(forall l : L,
 dlt (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
(forall r : R', {{ xL | xR // xcut }} < yR r) ->
(forall r : R',
 dlt (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(l : L'),
{{ xL | xR // xcut }} <= yL l ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(r : R),
xR r <= {{ yL | yR // ycut }} ->
dle (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
fxL: forall l : L, (fun _ : GenNo S => A) (xL l)
fxR: forall r : R, (fun _ : GenNo S => A) (xR r)
fxcut: forall (l : L) (r : R),
(fun (x y : GenNo S) 
   (_ : x < y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dlt a b) (xL l) (xR r) 
  (xcut l r) (fxL l) 
  (fxR r)
L', R': Type
s': InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
fyL: forall l : L', (fun _ : GenNo S => A) (yL l)
fyR: forall r : R', (fun _ : GenNo S => A) (yR r)
fycut: forall (l : L') (r : R'),
(fun (x y : GenNo S) 
   (_ : x < y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dlt a b) (yL l) (yR r) 
  (ycut l r) (fyL l) 
  (fyR r)
r: R
p: xR r <= {{ yL | yR // ycut }}
dp: (fun (x y : GenNo S) 
   (_ : x <= y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dle a b) (xR r) {{ yL | yR // ycut }} p 
  (fxR r)
  ((fun (L R : Type) 
      (s : InSort S L R) 
      (xL : L -> GenNo S) 
      (xR : R -> GenNo S)
      (xcut : forall (l : L) (r : R), xL l < xR r)
      (fxL : forall 
             l : L, 
             (fun _ : GenNo S => A) (xL l))
      (fxR : forall 
             r : R, 
             (fun _ : GenNo S => A) (xR r))
      (fxcut : forall 
               (l : L) 
               (r : R),
               (fun 
                 (x y : GenNo S) 
                 (_ : x < y)
                 (a : (fun _ : GenNo S => A) x)
                 (b : (fun _ : GenNo S => A) y)
                => 
                dlt a b) 
                 (xL l) 
                 (xR r) 
                 (xcut l r) 
                 (fxL l) 
                 (fxR r)) => 
    ?Goal) L' R' s' yL yR ycut fyL fyR fycut)
(fun (x y : GenNo S) 
   (_ : x < y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dlt a b) {{ xL | xR // xcut }} {{ yL | yR // ycut }}
  (lt_r xL xR xcut yL yR ycut r p)
  ((fun (L R : Type) 
      (s : InSort S L R) 
      (xL : L -> GenNo S) 
      (xR : R -> GenNo S)
      (xcut : forall (l : L) (r : R), xL l < xR r)
      (fxL : forall 
             l : L, 
             (fun _ : GenNo S => A) (xL l))
      (fxR : forall 
             r : R, 
             (fun _ : GenNo S => A) (xR r))
      (fxcut : forall 
               (l : L) 
               (r : R),
               (fun 
                 (x y : GenNo S) 
                 (_ : x < y)
                 (a : (fun _ : GenNo S => A) x)
                 (b : (fun _ : GenNo S => A) y) =>
                dlt a b) 
                 (xL l) 
                 (xR r) 
                 (xcut l r) 
                 (fxL l) 
                 (fxR r)) => 
    ?Goal) L R s xL xR xcut fxL fxR fxcut)
  ((fun (L R : Type) 
      (s : InSort S L R) 
      (xL : L -> GenNo S) 
      (xR : R -> GenNo S)
      (xcut : forall (l : L) (r : R), xL l < xR r)
      (fxL : forall 
             l : L, 
             (fun _ : GenNo S => A) (xL l))
      (fxR : forall 
             r : R, 
             (fun _ : GenNo S => A) (xR r))
      (fxcut : forall 
               (l : L) 
               (r : R),
               (fun 
                 (x y : GenNo S) 
                 (_ : x < y)
                 (a : (fun _ : GenNo S => A) x)
                 (b : (fun _ : GenNo S => A) y) =>
                dlt a b) 
                 (xL l) 
                 (xR r) 
                 (xcut l r) 
                 (fxL l) 
                 (fxR r)) => 
    ?Goal) L' R' s' yL yR ycut fyL fyR fycut)
    -
S: OptionSort
No:= GenNo S: Type
H: Funext
A: Type
dle: A -> A -> Type
is_mere_relation0: is_mere_relation A dle
dlt: A -> A -> Type
is_mere_relation1: is_mere_relation A dlt
dcut: forall L R : Type,
InSort S L R ->
forall (xL : L -> No) 
(xR : R -> No),
(forall (l : L) (r : R), xL l < xR r) ->
forall (fxL : L -> A) 
(fxR : R -> A),
(forall (l : L) (r : R), dlt (fxL l) (fxR r)) ->
A
dpath: forall a b : A, dle a b -> dle b a -> a = b
dle_lr: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)),
(forall l : L, xL l < {{ yL | yR // ycut }}) ->
(forall l : L,
 dlt (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
(forall r : R', {{ xL | xR // xcut }} < yR r) ->
(forall r : R',
 dlt (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(l : L'),
{{ xL | xR // xcut }} <= yL l ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(r : R),
xR r <= {{ yL | yR // ycut }} ->
dle (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
fxL: forall l : L, (fun _ : GenNo S => A) (xL l)
fxR: forall r : R, (fun _ : GenNo S => A) (xR r)
fxcut: forall (l : L) (r : R),
(fun (x y : GenNo S) 
   (_ : x < y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dlt a b) (xL l) (xR r) 
  (xcut l r) (fxL l) 
  (fxR r)
(fun _ : GenNo S => A) {{ xL | xR // xcut }} exact (dcut L R _ xL xR xcut fxL fxR fxcut).
    -
S: OptionSort
No:= GenNo S: Type
H: Funext
A: Type
dle: A -> A -> Type
is_mere_relation0: is_mere_relation A dle
dlt: A -> A -> Type
is_mere_relation1: is_mere_relation A dlt
dcut: forall L R : Type,
InSort S L R ->
forall (xL : L -> No) 
(xR : R -> No),
(forall (l : L) (r : R), xL l < xR r) ->
forall (fxL : L -> A) 
(fxR : R -> A),
(forall (l : L) (r : R), dlt (fxL l) (fxR r)) ->
A
dpath: forall a b : A, dle a b -> dle b a -> a = b
dle_lr: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)),
(forall l : L, xL l < {{ yL | yR // ycut }}) ->
(forall l : L,
 dlt (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
(forall r : R', {{ xL | xR // xcut }} < yR r) ->
(forall r : R',
 dlt (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(l : L'),
{{ xL | xR // xcut }} <= yL l ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(r : R),
xR r <= {{ yL | yR // ycut }} ->
dle (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
x, y: GenNo S
a: (fun _ : GenNo S => A) x
b: (fun _ : GenNo S => A) y
p: x <= y
q: y <= x
dp: (fun (x y : GenNo S) 
   (_ : x <= y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dle a b) x y p a b
dq: (fun (x y : GenNo S) 
   (_ : x <= y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dle a b) y x q b a
transport (fun _ : GenNo S => A) (path_No x y p q) a =
b refine (transport_const _ _ @ _).
S: OptionSort
No:= GenNo S: Type
H: Funext
A: Type
dle: A -> A -> Type
is_mere_relation0: is_mere_relation A dle
dlt: A -> A -> Type
is_mere_relation1: is_mere_relation A dlt
dcut: forall L R : Type,
InSort S L R ->
forall (xL : L -> No) 
(xR : R -> No),
(forall (l : L) (r : R), xL l < xR r) ->
forall (fxL : L -> A) 
(fxR : R -> A),
(forall (l : L) (r : R), dlt (fxL l) (fxR r)) ->
A
dpath: forall a b : A, dle a b -> dle b a -> a = b
dle_lr: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)),
(forall l : L, xL l < {{ yL | yR // ycut }}) ->
(forall l : L,
 dlt (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
(forall r : R', {{ xL | xR // xcut }} < yR r) ->
(forall r : R',
 dlt (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(l : L'),
{{ xL | xR // xcut }} <= yL l ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(r : R),
xR r <= {{ yL | yR // ycut }} ->
dle (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
x, y: GenNo S
a: (fun _ : GenNo S => A) x
b: (fun _ : GenNo S => A) y
p: x <= y
q: y <= x
dp: (fun (x y : GenNo S) 
   (_ : x <= y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dle a b) x y p a b
dq: (fun (x y : GenNo S) 
   (_ : x <= y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dle a b) y x q b a
a = b
      apply dpath; assumption.
    -
S: OptionSort
No:= GenNo S: Type
H: Funext
A: Type
dle: A -> A -> Type
is_mere_relation0: is_mere_relation A dle
dlt: A -> A -> Type
is_mere_relation1: is_mere_relation A dlt
dcut: forall L R : Type,
InSort S L R ->
forall (xL : L -> No) 
(xR : R -> No),
(forall (l : L) (r : R), xL l < xR r) ->
forall (fxL : L -> A) 
(fxR : R -> A),
(forall (l : L) (r : R), dlt (fxL l) (fxR r)) ->
A
dpath: forall a b : A, dle a b -> dle b a -> a = b
dle_lr: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)),
(forall l : L, xL l < {{ yL | yR // ycut }}) ->
(forall l : L,
 dlt (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
(forall r : R', {{ xL | xR // xcut }} < yR r) ->
(forall r : R',
 dlt (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(l : L'),
{{ xL | xR // xcut }} <= yL l ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(r : R),
xR r <= {{ yL | yR // ycut }} ->
dle (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
fxL: forall l : L, (fun _ : GenNo S => A) (xL l)
fxR: forall r : R, (fun _ : GenNo S => A) (xR r)
fxcut: forall (l : L) (r : R),
(fun (x y : GenNo S) 
   (_ : x < y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dlt a b) (xL l) (xR r) 
  (xcut l r) (fxL l) 
  (fxR r)
L', R': Type
s': InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
fyL: forall l : L', (fun _ : GenNo S => A) (yL l)
fyR: forall r : R', (fun _ : GenNo S => A) (yR r)
fycut: forall (l : L') (r : R'),
(fun (x y : GenNo S) 
   (_ : x < y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dlt a b) (yL l) (yR r) 
  (ycut l r) (fyL l) 
  (fyR r)
p: forall l : L, xL l < {{ yL | yR // ycut }}
dp: forall l : L,
(fun (x y : GenNo S) 
   (_ : x < y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dlt a b) (xL l) {{ yL | yR // ycut }} 
  (p l) (fxL l)
  ((fun (L R : Type) 
      (s : InSort S L R) 
      (xL : L -> GenNo S) 
      (xR : R -> GenNo S)
      (xcut : forall 
              (l0 : L) 
              (r : R), 
              xL l0 < xR r)
      (fxL : forall 
             l0 : L,
             (fun _ : GenNo S => A) (xL l0))
      (fxR : forall 
             r : R, 
             (fun _ : GenNo S => A) (xR r))
      (fxcut : forall 
               (l0 : L) 
               (r : R),
               (fun 
                 (x y : GenNo S) 
                 (_ : x < y)
                 (a : (fun _ : GenNo S => A) x)
                 (b : (fun _ : GenNo S => A) y)
                => 
                dlt a b) 
                 (xL l0) 
                 (xR r) 
                 (xcut l0 r) 
                 (fxL l0) 
                 (fxR r)) =>
    dcut L R s xL xR xcut fxL fxR fxcut) L' R' s'
     yL yR ycut fyL fyR fycut)
q: forall r : R', {{ xL | xR // xcut }} < yR r
dq: forall r : R',
(fun (x y : GenNo S) 
   (_ : x < y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dlt a b) {{ xL | xR // xcut }} 
  (yR r) (q r)
  ((fun (L R : Type) 
      (s : InSort S L R) 
      (xL : L -> GenNo S) 
      (xR : R -> GenNo S)
      (xcut : forall 
              (l : L) 
              (r0 : R), 
              xL l < xR r0)
      (fxL : forall 
             l : L, 
             (fun _ : GenNo S => A) (xL l))
      (fxR : forall 
             r0 : R,
             (fun _ : GenNo S => A) (xR r0))
      (fxcut : forall 
               (l : L) 
               (r0 : R),
               (fun 
                 (x y : GenNo S) 
                 (_ : x < y)
                 (a : (fun _ : GenNo S => A) x)
                 (b : (fun _ : GenNo S => A) y)
                => 
                dlt a b) 
                 (xL l) 
                 (xR r0) 
                 (xcut l r0) 
                 (fxL l) 
                 (fxR r0)) =>
    dcut L R s xL xR xcut fxL fxR fxcut) L R s xL
     xR xcut fxL fxR fxcut) 
  (fyR r)
(fun (x y : GenNo S) (_ : x <= y)
   (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => dle a b)
  {{ xL | xR // xcut }} {{ yL | yR // ycut }}
  (le_lr xL xR xcut yL yR ycut p q)
  ((fun (L R : Type) (s : InSort S L R)
      (xL : L -> GenNo S) (xR : R -> GenNo S)
      (xcut : forall (l : L) (r : R), xL l < xR r)
      (fxL : forall l : L,
             (fun _ : GenNo S => A) (xL l))
      (fxR : forall r : R,
             (fun _ : GenNo S => A) (xR r))
      (fxcut : forall (l : L) (r : R),
               (fun (x y : GenNo S) (_ : x < y)
                  (a : (fun _ : GenNo S => A) x)
                  (b : (fun _ : GenNo S => A) y) =>
                dlt a b) (xL l) (xR r) (xcut l r)
                 (fxL l) (fxR r)) =>
    dcut L R s xL xR xcut fxL fxR fxcut) L R s xL xR
     xcut fxL fxR fxcut)
  ((fun (L R : Type) (s : InSort S L R)
      (xL : L -> GenNo S) (xR : R -> GenNo S)
      (xcut : forall (l : L) (r : R), xL l < xR r)
      (fxL : forall l : L,
             (fun _ : GenNo S => A) (xL l))
      (fxR : forall r : R,
             (fun _ : GenNo S => A) (xR r))
      (fxcut : forall (l : L) (r : R),
               (fun (x y : GenNo S) (_ : x < y)
                  (a : (fun _ : GenNo S => A) x)
                  (b : (fun _ : GenNo S => A) y) =>
                dlt a b) (xL l) (xR r) (xcut l r)
                 (fxL l) (fxR r)) =>
    dcut L R s xL xR xcut fxL fxR fxcut) L' R' s' yL
     yR ycut fyL fyR fycut) cbn.
S: OptionSort
No:= GenNo S: Type
H: Funext
A: Type
dle: A -> A -> Type
is_mere_relation0: is_mere_relation A dle
dlt: A -> A -> Type
is_mere_relation1: is_mere_relation A dlt
dcut: forall L R : Type,
InSort S L R ->
forall (xL : L -> No) 
(xR : R -> No),
(forall (l : L) (r : R), xL l < xR r) ->
forall (fxL : L -> A) 
(fxR : R -> A),
(forall (l : L) (r : R), dlt (fxL l) (fxR r)) ->
A
dpath: forall a b : A, dle a b -> dle b a -> a = b
dle_lr: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)),
(forall l : L, xL l < {{ yL | yR // ycut }}) ->
(forall l : L,
 dlt (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
(forall r : R', {{ xL | xR // xcut }} < yR r) ->
(forall r : R',
 dlt (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(l : L'),
{{ xL | xR // xcut }} <= yL l ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(r : R),
xR r <= {{ yL | yR // ycut }} ->
dle (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
fxL: forall l : L, (fun _ : GenNo S => A) (xL l)
fxR: forall r : R, (fun _ : GenNo S => A) (xR r)
fxcut: forall (l : L) (r : R),
(fun (x y : GenNo S) 
   (_ : x < y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dlt a b) (xL l) (xR r) 
  (xcut l r) (fxL l) 
  (fxR r)
L', R': Type
s': InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
fyL: forall l : L', (fun _ : GenNo S => A) (yL l)
fyR: forall r : R', (fun _ : GenNo S => A) (yR r)
fycut: forall (l : L') (r : R'),
(fun (x y : GenNo S) 
   (_ : x < y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dlt a b) (yL l) (yR r) 
  (ycut l r) (fyL l) 
  (fyR r)
p: forall l : L, xL l < {{ yL | yR // ycut }}
dp: forall l : L,
(fun (x y : GenNo S) 
   (_ : x < y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dlt a b) (xL l) {{ yL | yR // ycut }} 
  (p l) (fxL l)
  ((fun (L R : Type) 
      (s : InSort S L R) 
      (xL : L -> GenNo S) 
      (xR : R -> GenNo S)
      (xcut : forall 
              (l0 : L) 
              (r : R), 
              xL l0 < xR r)
      (fxL : forall 
             l0 : L,
             (fun _ : GenNo S => A) (xL l0))
      (fxR : forall 
             r : R, 
             (fun _ : GenNo S => A) (xR r))
      (fxcut : forall 
               (l0 : L) 
               (r : R),
               (fun 
                 (x y : GenNo S) 
                 (_ : x < y)
                 (a : (fun _ : GenNo S => A) x)
                 (b : (fun _ : GenNo S => A) y)
                => 
                dlt a b) 
                 (xL l0) 
                 (xR r) 
                 (xcut l0 r) 
                 (fxL l0) 
                 (fxR r)) =>
    dcut L R s xL xR xcut fxL fxR fxcut) L' R' s'
     yL yR ycut fyL fyR fycut)
q: forall r : R', {{ xL | xR // xcut }} < yR r
dq: forall r : R',
(fun (x y : GenNo S) 
   (_ : x < y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dlt a b) {{ xL | xR // xcut }} 
  (yR r) (q r)
  ((fun (L R : Type) 
      (s : InSort S L R) 
      (xL : L -> GenNo S) 
      (xR : R -> GenNo S)
      (xcut : forall 
              (l : L) 
              (r0 : R), 
              xL l < xR r0)
      (fxL : forall 
             l : L, 
             (fun _ : GenNo S => A) (xL l))
      (fxR : forall 
             r0 : R,
             (fun _ : GenNo S => A) (xR r0))
      (fxcut : forall 
               (l : L) 
               (r0 : R),
               (fun 
                 (x y : GenNo S) 
                 (_ : x < y)
                 (a : (fun _ : GenNo S => A) x)
                 (b : (fun _ : GenNo S => A) y)
                => 
                dlt a b) 
                 (xL l) 
                 (xR r0) 
                 (xcut l r0) 
                 (fxL l) 
                 (fxR r0)) =>
    dcut L R s xL xR xcut fxL fxR fxcut) L R s xL
     xR xcut fxL fxR fxcut) 
  (fyR r)
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) apply dle_lr; assumption.
    -
S: OptionSort
No:= GenNo S: Type
H: Funext
A: Type
dle: A -> A -> Type
is_mere_relation0: is_mere_relation A dle
dlt: A -> A -> Type
is_mere_relation1: is_mere_relation A dlt
dcut: forall L R : Type,
InSort S L R ->
forall (xL : L -> No) 
(xR : R -> No),
(forall (l : L) (r : R), xL l < xR r) ->
forall (fxL : L -> A) 
(fxR : R -> A),
(forall (l : L) (r : R), dlt (fxL l) (fxR r)) ->
A
dpath: forall a b : A, dle a b -> dle b a -> a = b
dle_lr: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)),
(forall l : L, xL l < {{ yL | yR // ycut }}) ->
(forall l : L,
 dlt (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
(forall r : R', {{ xL | xR // xcut }} < yR r) ->
(forall r : R',
 dlt (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(l : L'),
{{ xL | xR // xcut }} <= yL l ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(r : R),
xR r <= {{ yL | yR // ycut }} ->
dle (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
fxL: forall l : L, (fun _ : GenNo S => A) (xL l)
fxR: forall r : R, (fun _ : GenNo S => A) (xR r)
fxcut: forall (l : L) (r : R),
(fun (x y : GenNo S) 
   (_ : x < y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dlt a b) (xL l) (xR r) 
  (xcut l r) (fxL l) 
  (fxR r)
L', R': Type
s': InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
fyL: forall l : L', (fun _ : GenNo S => A) (yL l)
fyR: forall r : R', (fun _ : GenNo S => A) (yR r)
fycut: forall (l : L') (r : R'),
(fun (x y : GenNo S) 
   (_ : x < y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dlt a b) (yL l) (yR r) 
  (ycut l r) (fyL l) 
  (fyR r)
l: L'
p: {{ xL | xR // xcut }} <= yL l
dp: (fun (x y : GenNo S) 
   (_ : x <= y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dle a b) {{ xL | xR // xcut }} 
  (yL l) p
  ((fun (L R : Type) 
      (s : InSort S L R) 
      (xL : L -> GenNo S) 
      (xR : R -> GenNo S)
      (xcut : forall (l : L) (r : R), xL l < xR r)
      (fxL : forall 
             l : L, 
             (fun _ : GenNo S => A) (xL l))
      (fxR : forall 
             r : R, 
             (fun _ : GenNo S => A) (xR r))
      (fxcut : forall 
               (l : L) 
               (r : R),
               (fun 
                 (x y : GenNo S) 
                 (_ : x < y)
                 (a : (fun _ : GenNo S => A) x)
                 (b : (fun _ : GenNo S => A) y)
                => 
                dlt a b) 
                 (xL l) 
                 (xR r) 
                 (xcut l r) 
                 (fxL l) 
                 (fxR r)) =>
    dcut L R s xL xR xcut fxL fxR fxcut) L R s xL
     xR xcut fxL fxR fxcut) 
  (fyL l)
(fun (x y : GenNo S) (_ : x < y)
   (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => dlt a b)
  {{ xL | xR // xcut }} {{ yL | yR // ycut }}
  (lt_l xL xR xcut yL yR ycut l p)
  ((fun (L R : Type) (s : InSort S L R)
      (xL : L -> GenNo S) (xR : R -> GenNo S)
      (xcut : forall (l : L) (r : R), xL l < xR r)
      (fxL : forall l : L,
             (fun _ : GenNo S => A) (xL l))
      (fxR : forall r : R,
             (fun _ : GenNo S => A) (xR r))
      (fxcut : forall (l : L) (r : R),
               (fun (x y : GenNo S) (_ : x < y)
                  (a : (fun _ : GenNo S => A) x)
                  (b : (fun _ : GenNo S => A) y) =>
                dlt a b) (xL l) (xR r) (xcut l r)
                 (fxL l) (fxR r)) =>
    dcut L R s xL xR xcut fxL fxR fxcut) L R s xL xR
     xcut fxL fxR fxcut)
  ((fun (L R : Type) (s : InSort S L R)
      (xL : L -> GenNo S) (xR : R -> GenNo S)
      (xcut : forall (l : L) (r : R), xL l < xR r)
      (fxL : forall l : L,
             (fun _ : GenNo S => A) (xL l))
      (fxR : forall r : R,
             (fun _ : GenNo S => A) (xR r))
      (fxcut : forall (l : L) (r : R),
               (fun (x y : GenNo S) (_ : x < y)
                  (a : (fun _ : GenNo S => A) x)
                  (b : (fun _ : GenNo S => A) y) =>
                dlt a b) (xL l) (xR r) (xcut l r)
                 (fxL l) (fxR r)) =>
    dcut L R s xL xR xcut fxL fxR fxcut) L' R' s' yL
     yR ycut fyL fyR fycut) cbn.
S: OptionSort
No:= GenNo S: Type
H: Funext
A: Type
dle: A -> A -> Type
is_mere_relation0: is_mere_relation A dle
dlt: A -> A -> Type
is_mere_relation1: is_mere_relation A dlt
dcut: forall L R : Type,
InSort S L R ->
forall (xL : L -> No) 
(xR : R -> No),
(forall (l : L) (r : R), xL l < xR r) ->
forall (fxL : L -> A) 
(fxR : R -> A),
(forall (l : L) (r : R), dlt (fxL l) (fxR r)) ->
A
dpath: forall a b : A, dle a b -> dle b a -> a = b
dle_lr: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)),
(forall l : L, xL l < {{ yL | yR // ycut }}) ->
(forall l : L,
 dlt (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
(forall r : R', {{ xL | xR // xcut }} < yR r) ->
(forall r : R',
 dlt (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(l : L'),
{{ xL | xR // xcut }} <= yL l ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(r : R),
xR r <= {{ yL | yR // ycut }} ->
dle (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
fxL: forall l : L, (fun _ : GenNo S => A) (xL l)
fxR: forall r : R, (fun _ : GenNo S => A) (xR r)
fxcut: forall (l : L) (r : R),
(fun (x y : GenNo S) 
   (_ : x < y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dlt a b) (xL l) (xR r) 
  (xcut l r) (fxL l) 
  (fxR r)
L', R': Type
s': InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
fyL: forall l : L', (fun _ : GenNo S => A) (yL l)
fyR: forall r : R', (fun _ : GenNo S => A) (yR r)
fycut: forall (l : L') (r : R'),
(fun (x y : GenNo S) 
   (_ : x < y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dlt a b) (yL l) (yR r) 
  (ycut l r) (fyL l) 
  (fyR r)
l: L'
p: {{ xL | xR // xcut }} <= yL l
dp: (fun (x y : GenNo S) 
   (_ : x <= y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dle a b) {{ xL | xR // xcut }} 
  (yL l) p
  ((fun (L R : Type) 
      (s : InSort S L R) 
      (xL : L -> GenNo S) 
      (xR : R -> GenNo S)
      (xcut : forall (l : L) (r : R), xL l < xR r)
      (fxL : forall 
             l : L, 
             (fun _ : GenNo S => A) (xL l))
      (fxR : forall 
             r : R, 
             (fun _ : GenNo S => A) (xR r))
      (fxcut : forall 
               (l : L) 
               (r : R),
               (fun 
                 (x y : GenNo S) 
                 (_ : x < y)
                 (a : (fun _ : GenNo S => A) x)
                 (b : (fun _ : GenNo S => A) y)
                => 
                dlt a b) 
                 (xL l) 
                 (xR r) 
                 (xcut l r) 
                 (fxL l) 
                 (fxR r)) =>
    dcut L R s xL xR xcut fxL fxR fxcut) L R s xL
     xR xcut fxL fxR fxcut) 
  (fyL l)
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) apply dlt_l with l; assumption.
    -
S: OptionSort
No:= GenNo S: Type
H: Funext
A: Type
dle: A -> A -> Type
is_mere_relation0: is_mere_relation A dle
dlt: A -> A -> Type
is_mere_relation1: is_mere_relation A dlt
dcut: forall L R : Type,
InSort S L R ->
forall (xL : L -> No) 
(xR : R -> No),
(forall (l : L) (r : R), xL l < xR r) ->
forall (fxL : L -> A) 
(fxR : R -> A),
(forall (l : L) (r : R), dlt (fxL l) (fxR r)) ->
A
dpath: forall a b : A, dle a b -> dle b a -> a = b
dle_lr: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)),
(forall l : L, xL l < {{ yL | yR // ycut }}) ->
(forall l : L,
 dlt (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
(forall r : R', {{ xL | xR // xcut }} < yR r) ->
(forall r : R',
 dlt (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(l : L'),
{{ xL | xR // xcut }} <= yL l ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(r : R),
xR r <= {{ yL | yR // ycut }} ->
dle (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
fxL: forall l : L, (fun _ : GenNo S => A) (xL l)
fxR: forall r : R, (fun _ : GenNo S => A) (xR r)
fxcut: forall (l : L) (r : R),
(fun (x y : GenNo S) 
   (_ : x < y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dlt a b) (xL l) (xR r) 
  (xcut l r) (fxL l) 
  (fxR r)
L', R': Type
s': InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
fyL: forall l : L', (fun _ : GenNo S => A) (yL l)
fyR: forall r : R', (fun _ : GenNo S => A) (yR r)
fycut: forall (l : L') (r : R'),
(fun (x y : GenNo S) 
   (_ : x < y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dlt a b) (yL l) (yR r) 
  (ycut l r) (fyL l) 
  (fyR r)
r: R
p: xR r <= {{ yL | yR // ycut }}
dp: (fun (x y : GenNo S) 
   (_ : x <= y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dle a b) (xR r) {{ yL | yR // ycut }} p 
  (fxR r)
  ((fun (L R : Type) 
      (s : InSort S L R) 
      (xL : L -> GenNo S) 
      (xR : R -> GenNo S)
      (xcut : forall (l : L) (r : R), xL l < xR r)
      (fxL : forall 
             l : L, 
             (fun _ : GenNo S => A) (xL l))
      (fxR : forall 
             r : R, 
             (fun _ : GenNo S => A) (xR r))
      (fxcut : forall 
               (l : L) 
               (r : R),
               (fun 
                 (x y : GenNo S) 
                 (_ : x < y)
                 (a : (fun _ : GenNo S => A) x)
                 (b : (fun _ : GenNo S => A) y)
                => 
                dlt a b) 
                 (xL l) 
                 (xR r) 
                 (xcut l r) 
                 (fxL l) 
                 (fxR r)) =>
    dcut L R s xL xR xcut fxL fxR fxcut) L' R' s'
     yL yR ycut fyL fyR fycut)
(fun (x y : GenNo S) (_ : x < y)
   (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => dlt a b)
  {{ xL | xR // xcut }} {{ yL | yR // ycut }}
  (lt_r xL xR xcut yL yR ycut r p)
  ((fun (L R : Type) (s : InSort S L R)
      (xL : L -> GenNo S) (xR : R -> GenNo S)
      (xcut : forall (l : L) (r : R), xL l < xR r)
      (fxL : forall l : L,
             (fun _ : GenNo S => A) (xL l))
      (fxR : forall r : R,
             (fun _ : GenNo S => A) (xR r))
      (fxcut : forall (l : L) (r : R),
               (fun (x y : GenNo S) (_ : x < y)
                  (a : (fun _ : GenNo S => A) x)
                  (b : (fun _ : GenNo S => A) y) =>
                dlt a b) (xL l) (xR r) (xcut l r)
                 (fxL l) (fxR r)) =>
    dcut L R s xL xR xcut fxL fxR fxcut) L R s xL xR
     xcut fxL fxR fxcut)
  ((fun (L R : Type) (s : InSort S L R)
      (xL : L -> GenNo S) (xR : R -> GenNo S)
      (xcut : forall (l : L) (r : R), xL l < xR r)
      (fxL : forall l : L,
             (fun _ : GenNo S => A) (xL l))
      (fxR : forall r : R,
             (fun _ : GenNo S => A) (xR r))
      (fxcut : forall (l : L) (r : R),
               (fun (x y : GenNo S) (_ : x < y)
                  (a : (fun _ : GenNo S => A) x)
                  (b : (fun _ : GenNo S => A) y) =>
                dlt a b) (xL l) (xR r) (xcut l r)
                 (fxL l) (fxR r)) =>
    dcut L R s xL xR xcut fxL fxR fxcut) L' R' s' yL
     yR ycut fyL fyR fycut) cbn.
S: OptionSort
No:= GenNo S: Type
H: Funext
A: Type
dle: A -> A -> Type
is_mere_relation0: is_mere_relation A dle
dlt: A -> A -> Type
is_mere_relation1: is_mere_relation A dlt
dcut: forall L R : Type,
InSort S L R ->
forall (xL : L -> No) 
(xR : R -> No),
(forall (l : L) (r : R), xL l < xR r) ->
forall (fxL : L -> A) 
(fxR : R -> A),
(forall (l : L) (r : R), dlt (fxL l) (fxR r)) ->
A
dpath: forall a b : A, dle a b -> dle b a -> a = b
dle_lr: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)),
(forall l : L, xL l < {{ yL | yR // ycut }}) ->
(forall l : L,
 dlt (fxL l)
   (dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
(forall r : R', {{ xL | xR // xcut }} < yR r) ->
(forall r : R',
 dlt (dcut L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_l: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(l : L'),
{{ xL | xR // xcut }} <= yL l ->
dle (dcut L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
dlt_r: forall (L R : Type) 
(s : InSort S L R) 
(xL : L -> No) (xR : R -> No)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) 
         (r : R), 
         dlt (fxL l) (fxR r)) 
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> No) (yR : R' -> No)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') 
         (r : R'), 
         dlt (fyL l) (fyR r)) 
(r : R),
xR r <= {{ yL | yR // ycut }} ->
dle (fxR r)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) ->
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut)
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
fxL: forall l : L, (fun _ : GenNo S => A) (xL l)
fxR: forall r : R, (fun _ : GenNo S => A) (xR r)
fxcut: forall (l : L) (r : R),
(fun (x y : GenNo S) 
   (_ : x < y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dlt a b) (xL l) (xR r) 
  (xcut l r) (fxL l) 
  (fxR r)
L', R': Type
s': InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
fyL: forall l : L', (fun _ : GenNo S => A) (yL l)
fyR: forall r : R', (fun _ : GenNo S => A) (yR r)
fycut: forall (l : L') (r : R'),
(fun (x y : GenNo S) 
   (_ : x < y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dlt a b) (yL l) (yR r) 
  (ycut l r) (fyL l) 
  (fyR r)
r: R
p: xR r <= {{ yL | yR // ycut }}
dp: (fun (x y : GenNo S) 
   (_ : x <= y) (a : (fun _ : GenNo S => A) x)
   (b : (fun _ : GenNo S => A) y) => 
 dle a b) (xR r) {{ yL | yR // ycut }} p 
  (fxR r)
  ((fun (L R : Type) 
      (s : InSort S L R) 
      (xL : L -> GenNo S) 
      (xR : R -> GenNo S)
      (xcut : forall (l : L) (r : R), xL l < xR r)
      (fxL : forall 
             l : L, 
             (fun _ : GenNo S => A) (xL l))
      (fxR : forall 
             r : R, 
             (fun _ : GenNo S => A) (xR r))
      (fxcut : forall 
               (l : L) 
               (r : R),
               (fun 
                 (x y : GenNo S) 
                 (_ : x < y)
                 (a : (fun _ : GenNo S => A) x)
                 (b : (fun _ : GenNo S => A) y)
                => 
                dlt a b) 
                 (xL l) 
                 (xR r) 
                 (xcut l r) 
                 (fxL l) 
                 (fxR r)) =>
    dcut L R s xL xR xcut fxL fxR fxcut) L' R' s'
     yL yR ycut fyL fyR fycut)
dlt (dcut L R s xL xR xcut fxL fxR fxcut)
  (dcut L' R' s' yL yR ycut fyL fyR fycut) apply dlt_r with r; assumption.
  Defined.

  Definition No_rec_le (x y : No) (p : x <= y)
  : dle (No_rec x) (No_rec y)
    := No_ind_le (fun _ => A) (fun _ _ _ a b => dle a b)
                 (fun _ _ _ a b => dlt a b) _ _ _ _ _ x y p.

  Definition No_rec_lt (x y : No) (p : x < y)
  : dlt (No_rec x) (No_rec y)
    := No_ind_lt (fun _ => A) (fun _ _ _ a b => dle a b)
                 (fun _ _ _ a b => dlt a b) _ _ _ _ _ x y p.

  Definition No_rec_package
  : { f : No -> A &
      (forall (x y : No) (p : x <= y), dle (f x) (f y)) *
      (forall (x y : No) (p : x < y), dlt (f x) (f y)) }
    := ( No_rec ; (No_rec_le , No_rec_lt) ).


  Definition No_rec_cut
    (L R : Type@{i}) (s : InSort S L R)
    (xL : L -> No) (xR : R -> No)
    (xcut : forall (l:L) (r:R), (xL l) < (xR r))
    : No_rec {{ xL | xR // xcut }}
      = dcut L R _ xL xR xcut
          (fun l => No_rec (xL l)) (fun r => No_rec (xR r))
          (fun l r => No_rec_lt (xL l) (xR r) (xcut l r))
    := 1.


End NoRec.

(** ** Conway's Theorem 0 *)

(** First we prove that *if* a left option of [y] is [<=] itself, then it is [< y]. *)
Lemma Conway_theorem0_lemma1 `{Funext} (x : No) (xle : x <= x)
      {L' R' : Type@{i}} {s' : InSort S L' R'}
      (yL : L' -> No) (yR : R' -> No)
      (ycut : forall (l:L') (r:R'), (yL l) < (yR r))
      (l : L') (p : x = yL l)
: x < {{ yL | yR // ycut }}.
S: OptionSort
No:= GenNo S: Type
H: Funext
x: No
xle: x <= x
L', R': Type
s': InSort S L' R'
yL: L' -> No
yR: R' -> No
ycut: forall (l : L') (r : R'), yL l < yR r
l: L'
p: x = yL l
x < {{ yL | yR // ycut }}
Proof.
S: OptionSort
No:= GenNo S: Type
H: Funext
x: No
xle: x <= x
L', R': Type
s': InSort S L' R'
yL: L' -> No
yR: R' -> No
ycut: forall (l : L') (r : R'), yL l < yR r
l: L'
p: x = yL l
x < {{ yL | yR // ycut }}
  generalize dependent x; refine (No_ind_hprop _ _); intros.
S: OptionSort
No:= GenNo S: Type
H: Funext
L', R': Type
s': InSort S L' R'
yL: L' -> No
yR: R' -> No
ycut: forall (l : L') (r : R'), yL l < yR r
l: L'
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l0 : L,
xL l0 <= xL l0 ->
xL l0 = yL l -> xL l0 < {{ yL | yR // ycut }}
IHR: forall r : R,
xR r <= xR r ->
xR r = yL l -> xR r < {{ yL | yR // ycut }}
xle: {{ xL | xR // xcut }} <= {{ xL | xR // xcut }}
p: {{ xL | xR // xcut }} = yL l
{{ xL | xR // xcut }} < {{ yL | yR // ycut }}
  apply lt_l with l.
S: OptionSort
No:= GenNo S: Type
H: Funext
L', R': Type
s': InSort S L' R'
yL: L' -> No
yR: R' -> No
ycut: forall (l : L') (r : R'), yL l < yR r
l: L'
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l0 : L,
xL l0 <= xL l0 ->
xL l0 = yL l -> xL l0 < {{ yL | yR // ycut }}
IHR: forall r : R,
xR r <= xR r ->
xR r = yL l -> xR r < {{ yL | yR // ycut }}
xle: {{ xL | xR // xcut }} <= {{ xL | xR // xcut }}
p: {{ xL | xR // xcut }} = yL l
{{ xL | xR // xcut }} <= yL l
  exact (transport (fun z => {{ xL | xR // xcut}} <= z) p xle).
Defined.

(** And dually *)
Lemma Conway_theorem0_lemma2 `{Funext} (x : No) (xle : x <= x)
      {L' R' : Type@{i}} {s' : InSort S L' R'}
      (yL : L' -> No) (yR : R' -> No)
      (ycut : forall (l:L') (r:R'), (yL l) < (yR r))
      (r : R') (p : x = yR r)
: {{ yL | yR // ycut }} < x.
S: OptionSort
No:= GenNo S: Type
H: Funext
x: No
xle: x <= x
L', R': Type
s': InSort S L' R'
yL: L' -> No
yR: R' -> No
ycut: forall (l : L') (r : R'), yL l < yR r
r: R'
p: x = yR r
{{ yL | yR // ycut }} < x
Proof.
S: OptionSort
No:= GenNo S: Type
H: Funext
x: No
xle: x <= x
L', R': Type
s': InSort S L' R'
yL: L' -> No
yR: R' -> No
ycut: forall (l : L') (r : R'), yL l < yR r
r: R'
p: x = yR r
{{ yL | yR // ycut }} < x
  generalize dependent x; refine (No_ind_hprop _ _); intros.
S: OptionSort
No:= GenNo S: Type
H: Funext
L', R': Type
s': InSort S L' R'
yL: L' -> No
yR: R' -> No
ycut: forall (l : L') (r : R'), yL l < yR r
r: R'
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L,
xL l <= xL l ->
xL l = yR r -> {{ yL | yR // ycut }} < xL l
IHR: forall r0 : R,
xR r0 <= xR r0 ->
xR r0 = yR r -> {{ yL | yR // ycut }} < xR r0
xle: {{ xL | xR // xcut }} <= {{ xL | xR // xcut }}
p: {{ xL | xR // xcut }} = yR r
{{ yL | yR // ycut }} < {{ xL | xR // xcut }}
  apply lt_r with r.
S: OptionSort
No:= GenNo S: Type
H: Funext
L', R': Type
s': InSort S L' R'
yL: L' -> No
yR: R' -> No
ycut: forall (l : L') (r : R'), yL l < yR r
r: R'
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L,
xL l <= xL l ->
xL l = yR r -> {{ yL | yR // ycut }} < xL l
IHR: forall r0 : R,
xR r0 <= xR r0 ->
xR r0 = yR r -> {{ yL | yR // ycut }} < xR r0
xle: {{ xL | xR // xcut }} <= {{ xL | xR // xcut }}
p: {{ xL | xR // xcut }} = yR r
yR r <= {{ xL | xR // xcut }}
  exact (transport (fun z => z <= {{ xL | xR // xcut}}) p xle).
Defined.

(** Theorem 0 Part (i) *)
Theorem le_reflexive `{Funext} (x : No)
: x <= x.
S: OptionSort
No:= GenNo S: Type
H: Funext
x: No
x <= x
Proof.
S: OptionSort
No:= GenNo S: Type
H: Funext
x: No
x <= x
  revert x; refine (No_ind_hprop _ _); intros.
S: OptionSort
No:= GenNo S: Type
H: Funext
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, xL l <= xL l
IHR: forall r : R, xR r <= xR r
{{ xL | xR // xcut }} <= {{ xL | xR // xcut }}
  apply le_lr.
S: OptionSort
No:= GenNo S: Type
H: Funext
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, xL l <= xL l
IHR: forall r : R, xR r <= xR r
forall l : L, xL l < {{ xL | xR // xcut }}
S: OptionSort
No:= GenNo S: Type
H: Funext
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, xL l <= xL l
IHR: forall r : R, xR r <= xR r
forall r : R, {{ xL | xR // xcut }} < xR r
  -
S: OptionSort
No:= GenNo S: Type
H: Funext
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, xL l <= xL l
IHR: forall r : R, xR r <= xR r
forall l : L, xL l < {{ xL | xR // xcut }} intros l.
S: OptionSort
No:= GenNo S: Type
H: Funext
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, xL l <= xL l
IHR: forall r : R, xR r <= xR r
l: L
xL l < {{ xL | xR // xcut }} refine (Conway_theorem0_lemma1 (xL l) (IHL l) _ _ _ _ 1).
  -
S: OptionSort
No:= GenNo S: Type
H: Funext
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, xL l <= xL l
IHR: forall r : R, xR r <= xR r
forall r : R, {{ xL | xR // xcut }} < xR r intros r.
S: OptionSort
No:= GenNo S: Type
H: Funext
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, xL l <= xL l
IHR: forall r : R, xR r <= xR r
r: R
{{ xL | xR // xcut }} < xR r refine (Conway_theorem0_lemma2 (xR r) (IHR r) _ _ _ _ 1).
Defined.

Instance reflexive_le `{Funext} : Reflexive le
  := le_reflexive.

(** Theorem 0 Part (ii), left half *)
Theorem lt_lopt `{Funext}
        {L R : Type@{i}} {s : InSort S L R}
        (xL : L -> No) (xR : R -> No)
        (xcut : forall (l:L) (r:R), (xL l) < (xR r))
        (l : L)
: xL l < {{ xL | xR // xcut }}.
S: OptionSort
No:= GenNo S: Type
H: Funext
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
l: L
xL l < {{ xL | xR // xcut }}
Proof.
S: OptionSort
No:= GenNo S: Type
H: Funext
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
l: L
xL l < {{ xL | xR // xcut }}
  refine (Conway_theorem0_lemma1 (xL l) _ _ _ _ _ 1).
S: OptionSort
No:= GenNo S: Type
H: Funext
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
l: L
xL l <= xL l
  apply le_reflexive.
Defined.

(** Theorem 0 Part (ii), right half *)
Theorem lt_ropt `{Funext}
        {L R : Type@{i}} {s : InSort S L R}
        (xL : L -> No) (xR : R -> No)
        (xcut : forall (l:L) (r:R), (xL l) < (xR r))
        (r : R)
: {{ xL | xR // xcut }} < xR r.
S: OptionSort
No:= GenNo S: Type
H: Funext
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
r: R
{{ xL | xR // xcut }} < xR r
Proof.
S: OptionSort
No:= GenNo S: Type
H: Funext
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
r: R
{{ xL | xR // xcut }} < xR r
  refine (Conway_theorem0_lemma2 (xR r) _ _ _ _ _ 1).
S: OptionSort
No:= GenNo S: Type
H: Funext
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
r: R
xR r <= xR r
  apply le_reflexive.
Defined.

Global Instance isset_No `{Funext} : IsHSet No.
S: OptionSort
No:= GenNo S: Type
H: Funext
IsHSet No
Proof.
S: OptionSort
No:= GenNo S: Type
H: Funext
IsHSet No
  refine (@ishset_hrel_subpaths No (fun (x y:No) => (x <= y) * (y <= x)) _ _ _).
S: OptionSort
No:= GenNo S: Type
H: Funext
Reflexive (fun x y : No => (x <= y) * (y <= x))
S: OptionSort
No:= GenNo S: Type
H: Funext
forall x y : No, (x <= y) * (y <= x) -> x = y
  -
S: OptionSort
No:= GenNo S: Type
H: Funext
Reflexive (fun x y : No => (x <= y) * (y <= x)) intros x; split; apply le_reflexive.
  -
S: OptionSort
No:= GenNo S: Type
H: Funext
forall x y : No, (x <= y) * (y <= x) -> x = y intros x y [xley ylex]; apply path_No; assumption.
Defined.


(** ** "One-line proofs" *)

(** In particular, the proofs of cut-ness don't impact equality of surreals.  However, in practice we generally need more than this: we need to be able to modify the indexing types along equivalences. *)

Definition path_No_easy `{Funext}
           {L R : Type} {s : InSort S L R}
           (xL : L -> No) (xR : R -> No)
           {L' R' : Type} {s' : InSort S L' R'}
           (xL' : L' -> No) (xR' : R' -> No)
           (eL : L <~> L') (eR : R <~> R')
           (xLeq : forall l, xL l = xL' (eL l))
           (xReq : forall r, xR r = xR' (eR r))
           (xcut : forall (l:L) (r:R), (xL l) < (xR r))
           (xcut' : forall (l:L') (r:R'), (xL' l) < (xR' r))
: {{ xL | xR // xcut }} = {{ xL' | xR' // xcut' }}.
S: OptionSort
No:= GenNo S: Type
H: Funext
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
L', R': Type
s': InSort S L' R'
xL': L' -> No
xR': R' -> No
eL: L <~> L'
eR: R <~> R'
xLeq: forall l : L, xL l = xL' (eL l)
xReq: forall r : R, xR r = xR' (eR r)
xcut: forall (l : L) (r : R), xL l < xR r
xcut': forall (l : L') (r : R'), xL' l < xR' r
{{ xL | xR // xcut }} = {{ xL' | xR' // xcut' }}
Proof.
S: OptionSort
No:= GenNo S: Type
H: Funext
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
L', R': Type
s': InSort S L' R'
xL': L' -> No
xR': R' -> No
eL: L <~> L'
eR: R <~> R'
xLeq: forall l : L, xL l = xL' (eL l)
xReq: forall r : R, xR r = xR' (eR r)
xcut: forall (l : L) (r : R), xL l < xR r
xcut': forall (l : L') (r : R'), xL' l < xR' r
{{ xL | xR // xcut }} = {{ xL' | xR' // xcut' }}
  apply path_No; apply le_lr;
  [ intros l; rewrite xLeq
  | intros r; rewrite <- (eisretr eR r), <- xReq
  | intros l; rewrite <- (eisretr eL l), <- xLeq
  | intros r; rewrite xReq ];
  try apply lt_lopt;
  try apply lt_ropt.
Qed.

Definition path_No_easy' `{Funext}
           {L R : Type} {s : InSort S L R}
           (xL xL' : L -> No) (xR xR' : R -> No)
           (xLeq : forall l, xL l = xL' l)
           (xReq : forall r, xR r = xR' r)
           (xcut : forall (l:L) (r:R), (xL l) < (xR r))
: {{ xL | xR // xcut }}
  = {{ xL' | xR' //
       (fun l r => transport (fun xy => fst xy < snd xy)
                             (path_prod' (xLeq l) (xReq r))
                             (xcut l r)) }}
  := path_No_easy xL xR xL' xR' 1 1 xLeq xReq xcut _.

End OptionSort.

(** When we want to do induction on several variables at once, we have to be careful to do them in the right order.  This tactic does that, by calling itself recursively (although it doesn't choose useful names for all the hypotheses it introduces).  We have to define this here outside of all sections so that it will be visible globally. *)
Ltac repeat_No_ind_hprop :=
  try match goal with
      | [ x : GenNo ?S |- _ ] =>
        revert x;
        repeat_No_ind_hprop;
        refine (No_ind_hprop _ _);
        intros ? ? ? ? ? ? ? ?
      end.

(** ** Encode-decode to characterize [<] and [<=] recursively (Theorem 11.6.7). *)

Section NoCodes.
  Context `{Univalence}.
  Universe i.
  Context {S : OptionSort@{i}}.
  Let No := GenNo S.

  Let A := {le'_x : No -> HProp &
           {lt'_x : No -> HProp &
           (forall y : No, lt'_x y -> le'_x y) *
           (forall y z : No, le'_x y -> y <= z -> le'_x z) *
           (forall y z : No, le'_x y -> y < z -> lt'_x z) *
           (forall y z : No, lt'_x y -> y <= z -> lt'_x z)} }.

  Section Inner.

    Context {L R : Type@{i} } {s : InSort S L R}
            (xL : L -> No) (xR : R -> No)
            (xcut : forall (l : L) (r : R), xL l < xR r)
            (xL_let : L -> A) (xR_let : R -> A)
            (x_lt_le : forall (l : L) (r : R) (y : No),
                         (xR_let r).1 y -> ((xL_let l).2).1 y).

    Let A' (y : No) : Type
    := { lelt'_x_y : HProp * HProp &
         (snd lelt'_x_y -> fst lelt'_x_y) *
         (forall l : L, fst lelt'_x_y -> ((xL_let l).2).1 y) *
         (forall r : R, (xR_let r).1 y -> snd lelt'_x_y) }.

    Let A'le (y z : No) (p : y <= z) (tr : A' y) (sq : A' z) : Type
      := (fst tr.1 -> fst sq.1) * (snd tr.1 -> snd sq.1).

    Let A'lt (y z : No) (p : y < z) (tr : A' y) (sq : A' z) : Type
      := (fst tr.1 -> snd sq.1).

    Local Definition inner_package
    : { inner : forall (y : No), A' y &
       (forall y z p, A'le y z p (inner y) (inner z)) *
       (forall y z p, A'lt y z p (inner y) (inner z)) }.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
xL_let: L -> A
xR_let: R -> A
x_lt_le: forall (l : L) (r : R) (y : No),
(xR_let r).1 y -> ((xL_let l).2).1 y
A':= fun y : No =>
{lelt'_x_y : HProp * HProp &
(snd lelt'_x_y -> fst lelt'_x_y) *
(forall l : L, fst lelt'_x_y -> ((xL_let l).2).1 y) *
(forall r : R, (xR_let r).1 y -> snd lelt'_x_y)}: No -> Type
A'le:= fun (y z : No) (_ : y <= z) 
  (tr : A' y) (sq : A' z) =>
(fst tr.1 -> fst sq.1) * (snd tr.1 -> snd sq.1): forall y z : No, y <= z -> A' y -> A' z -> Type
A'lt:= fun (y z : No) (_ : y < z) 
  (tr : A' y) (sq : A' z) =>
fst tr.1 -> snd sq.1: forall y z : No, y < z -> A' y -> A' z -> Type
{inner : forall y : No, A' y &
(forall (y z : No) (p : y <= z),
 A'le y z p (inner y) (inner z)) *
(forall (y z : No) (p : y < z),
 A'lt y z p (inner y) (inner z))}
    Proof.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
xL_let: L -> A
xR_let: R -> A
x_lt_le: forall (l : L) (r : R) (y : No),
(xR_let r).1 y -> ((xL_let l).2).1 y
A':= fun y : No =>
{lelt'_x_y : HProp * HProp &
(snd lelt'_x_y -> fst lelt'_x_y) *
(forall l : L, fst lelt'_x_y -> ((xL_let l).2).1 y) *
(forall r : R, (xR_let r).1 y -> snd lelt'_x_y)}: No -> Type
A'le:= fun (y z : No) (_ : y <= z) 
  (tr : A' y) (sq : A' z) =>
(fst tr.1 -> fst sq.1) * (snd tr.1 -> snd sq.1): forall y z : No, y <= z -> A' y -> A' z -> Type
A'lt:= fun (y z : No) (_ : y < z) 
  (tr : A' y) (sq : A' z) =>
fst tr.1 -> snd sq.1: forall y z : No, y < z -> A' y -> A' z -> Type
{inner : forall y : No, A' y &
(forall (y z : No) (p : y <= z),
 A'le y z p (inner y) (inner z)) *
(forall (y z : No) (p : y < z),
 A'lt y z p (inner y) (inner z))}
      simple refine (No_ind_package A' A'le A'lt _ _ _ _ _ );
      unfold A', A'le, A'lt; try exact _.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
xL_let: L -> A
xR_let: R -> A
x_lt_le: forall (l : L) (r : R) (y : No),
(xR_let r).1 y -> ((xL_let l).2).1 y
A':= fun y : No =>
{lelt'_x_y : HProp * HProp &
(snd lelt'_x_y -> fst lelt'_x_y) *
(forall l : L, fst lelt'_x_y -> ((xL_let l).2).1 y) *
(forall r : R, (xR_let r).1 y -> snd lelt'_x_y)}: No -> Type
A'le:= fun (y z : No) (_ : y <= z) 
  (tr : A' y) (sq : A' z) =>
(fst tr.1 -> fst sq.1) * (snd tr.1 -> snd sq.1): forall y z : No, y <= z -> A' y -> A' z -> Type
A'lt:= fun (y z : No) (_ : y < z) 
  (tr : A' y) (sq : A' z) =>
fst tr.1 -> snd sq.1: forall y z : No, y < z -> A' y -> A' z -> Type
forall (L0 R0 : Type) (s : InSort S L0 R0)
(xL : L0 -> GenNo S) (xR : R0 -> GenNo S)
(xcut : forall (l : L0) (r : R0), xL l < xR r)
(fxL : forall l : L0,
       {lelt'_x_y : HProp * HProp &
       (snd lelt'_x_y -> fst lelt'_x_y) *
       (forall l0 : L,
        fst lelt'_x_y -> ((xL_let l0).2).1 (xL l)) *
       (forall r : R,
        (xR_let r).1 (xL l) -> snd lelt'_x_y)})
(fxR : forall r : R0,
       {lelt'_x_y : HProp * HProp &
       (snd lelt'_x_y -> fst lelt'_x_y) *
       (forall l : L,
        fst lelt'_x_y -> ((xL_let l).2).1 (xR r)) *
       (forall r0 : R,
        (xR_let r0).1 (xR r) -> snd lelt'_x_y)}),
(forall (l : L0) (r : R0),
 fst (fxL l).1 -> snd (fxR r).1) ->
{lelt'_x_y : HProp * HProp &
(snd lelt'_x_y -> fst lelt'_x_y) *
(forall l : L,
 fst lelt'_x_y ->
 ((xL_let l).2).1 {{ xL | xR // xcut }}) *
(forall r : R,
 (xR_let r).1 {{ xL | xR // xcut }} -> snd lelt'_x_y)}
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
xL_let: L -> A
xR_let: R -> A
x_lt_le: forall (l : L) (r : R) (y : No),
(xR_let r).1 y -> ((xL_let l).2).1 y
A':= fun y : No =>
{lelt'_x_y : HProp * HProp &
(snd lelt'_x_y -> fst lelt'_x_y) *
(forall l : L, fst lelt'_x_y -> ((xL_let l).2).1 y) *
(forall r : R, (xR_let r).1 y -> snd lelt'_x_y)}: No -> Type
A'le:= fun (y z : No) (_ : y <= z) 
  (tr : A' y) (sq : A' z) =>
(fst tr.1 -> fst sq.1) * (snd tr.1 -> snd sq.1): forall y z : No, y <= z -> A' y -> A' z -> Type
A'lt:= fun (y z : No) (_ : y < z) 
  (tr : A' y) (sq : A' z) =>
fst tr.1 -> snd sq.1: forall y z : No, y < z -> A' y -> A' z -> Type
forall (x y : GenNo S)
(a : {lelt'_x_y : HProp * HProp &
     (snd lelt'_x_y -> fst lelt'_x_y) *
     (forall l : L,
      fst lelt'_x_y -> ((xL_let l).2).1 x) *
     (forall r : R, (xR_let r).1 x -> snd lelt'_x_y)})
(b : {lelt'_x_y : HProp * HProp &
     (snd lelt'_x_y -> fst lelt'_x_y) *
     (forall l : L,
      fst lelt'_x_y -> ((xL_let l).2).1 y) *
     (forall r : R, (xR_let r).1 y -> snd lelt'_x_y)})
(p : x <= y) (q : y <= x),
(fst a.1 -> fst b.1) * (snd a.1 -> snd b.1) ->
(fst b.1 -> fst a.1) * (snd b.1 -> snd a.1) ->
transport
  (fun y0 : No =>
   {lelt'_x_y : HProp * HProp &
   (snd lelt'_x_y -> fst lelt'_x_y) *
   (forall l : L, fst lelt'_x_y -> ((xL_let l).2).1 y0) *
   (forall r : R, (xR_let r).1 y0 -> snd lelt'_x_y)})
  (path_No x y p q) a = b
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
xL_let: L -> A
xR_let: R -> A
x_lt_le: forall (l : L) (r : R) (y : No),
(xR_let r).1 y -> ((xL_let l).2).1 y
A':= fun y : No =>
{lelt'_x_y : HProp * HProp &
(snd lelt'_x_y -> fst lelt'_x_y) *
(forall l : L, fst lelt'_x_y -> ((xL_let l).2).1 y) *
(forall r : R, (xR_let r).1 y -> snd lelt'_x_y)}: No -> Type
A'le:= fun (y z : No) (_ : y <= z) 
  (tr : A' y) (sq : A' z) =>
(fst tr.1 -> fst sq.1) * (snd tr.1 -> snd sq.1): forall y z : No, y <= z -> A' y -> A' z -> Type
A'lt:= fun (y z : No) (_ : y < z) 
  (tr : A' y) (sq : A' z) =>
fst tr.1 -> snd sq.1: forall y z : No, y < z -> A' y -> A' z -> Type
forall (L0 R0 : Type) (s0 : InSort S L0 R0)
(xL0 : L0 -> GenNo S) (xR0 : R0 -> GenNo S)
(xcut0 : forall (l : L0) (r : R0), xL0 l < xR0 r)
(fxL : forall l : L0,
       {lelt'_x_y : HProp * HProp &
       (snd lelt'_x_y -> fst lelt'_x_y) *
       (forall l0 : L,
        fst lelt'_x_y -> ((xL_let l0).2).1 (xL0 l)) *
       (forall r : R,
        (xR_let r).1 (xL0 l) -> snd lelt'_x_y)})
(fxR : forall r : R0,
       {lelt'_x_y : HProp * HProp &
       (snd lelt'_x_y -> fst lelt'_x_y) *
       (forall l : L,
        fst lelt'_x_y -> ((xL_let l).2).1 (xR0 r)) *
       (forall r0 : R,
        (xR_let r0).1 (xR0 r) -> snd lelt'_x_y)})
(fxcut : forall (l : L0) 
         (r : R0), fst (fxL l).1 -> snd (fxR r).1)
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo S) (yR : R' -> GenNo S)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L',
       {lelt'_x_y : HProp * HProp &
       (snd lelt'_x_y -> fst lelt'_x_y) *
       (forall l0 : L,
        fst lelt'_x_y -> ((xL_let l0).2).1 (yL l)) *
       (forall r : R,
        (xR_let r).1 (yL l) -> snd lelt'_x_y)})
(fyR : forall r : R',
       {lelt'_x_y : HProp * HProp &
       (snd lelt'_x_y -> fst lelt'_x_y) *
       (forall l : L,
        fst lelt'_x_y -> ((xL_let l).2).1 (yR r)) *
       (forall r0 : R,
        (xR_let r0).1 (yR r) -> snd lelt'_x_y)})
(fycut : forall (l : L') 
         (r : R'), fst (fyL l).1 -> snd (fyR r).1),
(forall l : L0, xL0 l < {{ yL | yR // ycut }}) ->
(forall l : L0,
 fst (fxL l).1 ->
 snd (?Goal L' R' s' yL yR ycut fyL fyR fycut).1) ->
(forall r : R', {{ xL0 | xR0 // xcut0 }} < yR r) ->
(forall r : R',
 fst (?Goal L0 R0 s0 xL0 xR0 xcut0 fxL fxR fxcut).1 ->
 snd (fyR r).1) ->
(fst (?Goal L0 R0 s0 xL0 xR0 xcut0 fxL fxR fxcut).1 ->
 fst (?Goal L' R' s' yL yR ycut fyL fyR fycut).1) *
(snd (?Goal L0 R0 s0 xL0 xR0 xcut0 fxL fxR fxcut).1 ->
 snd (?Goal L' R' s' yL yR ycut fyL fyR fycut).1)
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
xL_let: L -> A
xR_let: R -> A
x_lt_le: forall (l : L) (r : R) (y : No),
(xR_let r).1 y -> ((xL_let l).2).1 y
A':= fun y : No =>
{lelt'_x_y : HProp * HProp &
(snd lelt'_x_y -> fst lelt'_x_y) *
(forall l : L, fst lelt'_x_y -> ((xL_let l).2).1 y) *
(forall r : R, (xR_let r).1 y -> snd lelt'_x_y)}: No -> Type
A'le:= fun (y z : No) (_ : y <= z) 
  (tr : A' y) (sq : A' z) =>
(fst tr.1 -> fst sq.1) * (snd tr.1 -> snd sq.1): forall y z : No, y <= z -> A' y -> A' z -> Type
A'lt:= fun (y z : No) (_ : y < z) 
  (tr : A' y) (sq : A' z) =>
fst tr.1 -> snd sq.1: forall y z : No, y < z -> A' y -> A' z -> Type
forall (L0 R0 : Type) (s0 : InSort S L0 R0)
(xL0 : L0 -> GenNo S) (xR0 : R0 -> GenNo S)
(xcut0 : forall (l : L0) (r : R0), xL0 l < xR0 r)
(fxL : forall l : L0,
       {lelt'_x_y : HProp * HProp &
       (snd lelt'_x_y -> fst lelt'_x_y) *
       (forall l0 : L,
        fst lelt'_x_y -> ((xL_let l0).2).1 (xL0 l)) *
       (forall r : R,
        (xR_let r).1 (xL0 l) -> snd lelt'_x_y)})
(fxR : forall r : R0,
       {lelt'_x_y : HProp * HProp &
       (snd lelt'_x_y -> fst lelt'_x_y) *
       (forall l : L,
        fst lelt'_x_y -> ((xL_let l).2).1 (xR0 r)) *
       (forall r0 : R,
        (xR_let r0).1 (xR0 r) -> snd lelt'_x_y)})
(fxcut : forall (l : L0) 
         (r : R0), fst (fxL l).1 -> snd (fxR r).1)
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo S) (yR : R' -> GenNo S)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L',
       {lelt'_x_y : HProp * HProp &
       (snd lelt'_x_y -> fst lelt'_x_y) *
       (forall l0 : L,
        fst lelt'_x_y -> ((xL_let l0).2).1 (yL l)) *
       (forall r : R,
        (xR_let r).1 (yL l) -> snd lelt'_x_y)})
(fyR : forall r : R',
       {lelt'_x_y : HProp * HProp &
       (snd lelt'_x_y -> fst lelt'_x_y) *
       (forall l : L,
        fst lelt'_x_y -> ((xL_let l).2).1 (yR r)) *
       (forall r0 : R,
        (xR_let r0).1 (yR r) -> snd lelt'_x_y)})
(fycut : forall (l : L') 
         (r : R'), fst (fyL l).1 -> snd (fyR r).1)
(l : L'),
{{ xL0 | xR0 // xcut0 }} <= yL l ->
(fst (?Goal L0 R0 s0 xL0 xR0 xcut0 fxL fxR fxcut).1 ->
 fst (fyL l).1) *
(snd (?Goal L0 R0 s0 xL0 xR0 xcut0 fxL fxR fxcut).1 ->
 snd (fyL l).1) ->
fst (?Goal L0 R0 s0 xL0 xR0 xcut0 fxL fxR fxcut).1 ->
snd (?Goal L' R' s' yL yR ycut fyL fyR fycut).1
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
xL_let: L -> A
xR_let: R -> A
x_lt_le: forall (l : L) (r : R) (y : No),
(xR_let r).1 y -> ((xL_let l).2).1 y
A':= fun y : No =>
{lelt'_x_y : HProp * HProp &
(snd lelt'_x_y -> fst lelt'_x_y) *
(forall l : L, fst lelt'_x_y -> ((xL_let l).2).1 y) *
(forall r : R, (xR_let r).1 y -> snd lelt'_x_y)}: No -> Type
A'le:= fun (y z : No) (_ : y <= z) 
  (tr : A' y) (sq : A' z) =>
(fst tr.1 -> fst sq.1) * (snd tr.1 -> snd sq.1): forall y z : No, y <= z -> A' y -> A' z -> Type
A'lt:= fun (y z : No) (_ : y < z) 
  (tr : A' y) (sq : A' z) =>
fst tr.1 -> snd sq.1: forall y z : No, y < z -> A' y -> A' z -> Type
forall (L0 R0 : Type) (s0 : InSort S L0 R0)
(xL0 : L0 -> GenNo S) (xR0 : R0 -> GenNo S)
(xcut0 : forall (l : L0) (r : R0), xL0 l < xR0 r)
(fxL : forall l : L0,
       {lelt'_x_y : HProp * HProp &
       (snd lelt'_x_y -> fst lelt'_x_y) *
       (forall l0 : L,
        fst lelt'_x_y -> ((xL_let l0).2).1 (xL0 l)) *
       (forall r : R,
        (xR_let r).1 (xL0 l) -> snd lelt'_x_y)})
(fxR : forall r : R0,
       {lelt'_x_y : HProp * HProp &
       (snd lelt'_x_y -> fst lelt'_x_y) *
       (forall l : L,
        fst lelt'_x_y -> ((xL_let l).2).1 (xR0 r)) *
       (forall r0 : R,
        (xR_let r0).1 (xR0 r) -> snd lelt'_x_y)})
(fxcut : forall (l : L0) 
         (r : R0), fst (fxL l).1 -> snd (fxR r).1)
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo S) (yR : R' -> GenNo S)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L',
       {lelt'_x_y : HProp * HProp &
       (snd lelt'_x_y -> fst lelt'_x_y) *
       (forall l0 : L,
        fst lelt'_x_y -> ((xL_let l0).2).1 (yL l)) *
       (forall r : R,
        (xR_let r).1 (yL l) -> snd lelt'_x_y)})
(fyR : forall r : R',
       {lelt'_x_y : HProp * HProp &
       (snd lelt'_x_y -> fst lelt'_x_y) *
       (forall l : L,
        fst lelt'_x_y -> ((xL_let l).2).1 (yR r)) *
       (forall r0 : R,
        (xR_let r0).1 (yR r) -> snd lelt'_x_y)})
(fycut : forall (l : L') 
         (r : R'), fst (fyL l).1 -> snd (fyR r).1)
(r : R0),
xR0 r <= {{ yL | yR // ycut }} ->
(fst (fxR r).1 ->
 fst (?Goal L' R' s' yL yR ycut fyL fyR fycut).1) *
(snd (fxR r).1 ->
 snd (?Goal L' R' s' yL yR ycut fyL fyR fycut).1) ->
fst (?Goal L0 R0 s0 xL0 xR0 xcut0 fxL fxR fxcut).1 ->
snd (?Goal L' R' s' yL yR ycut fyL fyR fycut).1
      -
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
xL_let: L -> A
xR_let: R -> A
x_lt_le: forall (l : L) (r : R) (y : No),
(xR_let r).1 y -> ((xL_let l).2).1 y
A':= fun y : No =>
{lelt'_x_y : HProp * HProp &
(snd lelt'_x_y -> fst lelt'_x_y) *
(forall l : L, fst lelt'_x_y -> ((xL_let l).2).1 y) *
(forall r : R, (xR_let r).1 y -> snd lelt'_x_y)}: No -> Type
A'le:= fun (y z : No) (_ : y <= z) 
  (tr : A' y) (sq : A' z) =>
(fst tr.1 -> fst sq.1) * (snd tr.1 -> snd sq.1): forall y z : No, y <= z -> A' y -> A' z -> Type
A'lt:= fun (y z : No) (_ : y < z) 
  (tr : A' y) (sq : A' z) =>
fst tr.1 -> snd sq.1: forall y z : No, y < z -> A' y -> A' z -> Type
forall (L0 R0 : Type) (s : InSort S L0 R0)
(xL : L0 -> GenNo S) (xR : R0 -> GenNo S)
(xcut : forall (l : L0) (r : R0), xL l < xR r)
(fxL : forall l : L0,
       {lelt'_x_y : HProp * HProp &
       (snd lelt'_x_y -> fst lelt'_x_y) *
       (forall l0 : L,
        fst lelt'_x_y -> ((xL_let l0).2).1 (xL l)) *
       (forall r : R,
        (xR_let r).1 (xL l) -> snd lelt'_x_y)})
(fxR : forall r : R0,
       {lelt'_x_y : HProp * HProp &
       (snd lelt'_x_y -> fst lelt'_x_y) *
       (forall l : L,
        fst lelt'_x_y -> ((xL_let l).2).1 (xR r)) *
       (forall r0 : R,
        (xR_let r0).1 (xR r) -> snd lelt'_x_y)}),
(forall (l : L0) (r : R0),
 fst (fxL l).1 -> snd (fxR r).1) ->
{lelt'_x_y : HProp * HProp &
(snd lelt'_x_y -> fst lelt'_x_y) *
(forall l : L,
 fst lelt'_x_y ->
 ((xL_let l).2).1 {{ xL | xR // xcut }}) *
(forall r : R,
 (xR_let r).1 {{ xL | xR // xcut }} -> snd lelt'_x_y)} intros L' R' ? yL yR ycut x_let_yL x_let_yR y_lt_le.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
xL_let: L -> A
xR_let: R -> A
x_lt_le: forall (l : L) (r : R) (y : No),
(xR_let r).1 y -> ((xL_let l).2).1 y
A':= fun y : No =>
{lelt'_x_y : HProp * HProp &
(snd lelt'_x_y -> fst lelt'_x_y) *
(forall l : L, fst lelt'_x_y -> ((xL_let l).2).1 y) *
(forall r : R, (xR_let r).1 y -> snd lelt'_x_y)}: No -> Type
A'le:= fun (y z : No) (_ : y <= z) 
  (tr : A' y) (sq : A' z) =>
(fst tr.1 -> fst sq.1) * (snd tr.1 -> snd sq.1): forall y z : No, y <= z -> A' y -> A' z -> Type
A'lt:= fun (y z : No) (_ : y < z) 
  (tr : A' y) (sq : A' z) =>
fst tr.1 -> snd sq.1: forall y z : No, y < z -> A' y -> A' z -> Type
L', R': Type
s0: InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
x_let_yL: forall l : L',
{lelt'_x_y : HProp * HProp &
(snd lelt'_x_y -> fst lelt'_x_y) *
(forall l0 : L,
 fst lelt'_x_y -> ((xL_let l0).2).1 (yL l)) *
(forall r : R,
 (xR_let r).1 (yL l) -> snd lelt'_x_y)}
x_let_yR: forall r : R',
{lelt'_x_y : HProp * HProp &
(snd lelt'_x_y -> fst lelt'_x_y) *
(forall l : L,
 fst lelt'_x_y -> ((xL_let l).2).1 (yR r)) *
(forall r0 : R,
 (xR_let r0).1 (yR r) -> snd lelt'_x_y)}
y_lt_le: forall (l : L') (r : R'),
fst (x_let_yL l).1 -> snd (x_let_yR r).1
{lelt'_x_y : HProp * HProp &
(snd lelt'_x_y -> fst lelt'_x_y) *
(forall l : L,
 fst lelt'_x_y ->
 ((xL_let l).2).1 {{ yL | yR // ycut }}) *
(forall r : R,
 (xR_let r).1 {{ yL | yR // ycut }} -> snd lelt'_x_y)}
        set (y := {{ yL | yR // ycut }}).
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
xL_let: L -> A
xR_let: R -> A
x_lt_le: forall (l : L) (r : R) (y : No),
(xR_let r).1 y -> ((xL_let l).2).1 y
A':= fun y : No =>
{lelt'_x_y : HProp * HProp &
(snd lelt'_x_y -> fst lelt'_x_y) *
(forall l : L, fst lelt'_x_y -> ((xL_let l).2).1 y) *
(forall r : R, (xR_let r).1 y -> snd lelt'_x_y)}: No -> Type
A'le:= fun (y z : No) (_ : y <= z) 
  (tr : A' y) (sq : A' z) =>
(fst tr.1 -> fst sq.1) * (snd tr.1 -> snd sq.1): forall y z : No, y <= z -> A' y -> A' z -> Type
A'lt:= fun (y z : No) (_ : y < z) 
  (tr : A' y) (sq : A' z) =>
fst tr.1 -> snd sq.1: forall y z : No, y < z -> A' y -> A' z -> Type
L', R': Type
s0: InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
x_let_yL: forall l : L',
{lelt'_x_y : HProp * HProp &
(snd lelt'_x_y -> fst lelt'_x_y) *
(forall l0 : L,
 fst lelt'_x_y -> ((xL_let l0).2).1 (yL l)) *
(forall r : R,
 (xR_let r).1 (yL l) -> snd lelt'_x_y)}
x_let_yR: forall r : R',
{lelt'_x_y : HProp * HProp &
(snd lelt'_x_y -> fst lelt'_x_y) *
(forall l : L,
 fst lelt'_x_y -> ((xL_let l).2).1 (yR r)) *
(forall r0 : R,
 (xR_let r0).1 (yR r) -> snd lelt'_x_y)}
y_lt_le: forall (l : L') (r : R'),
fst (x_let_yL l).1 -> snd (x_let_yR r).1
y:= {{ yL | yR // ycut }}: GenNo S
{lelt'_x_y : HProp * HProp &
(snd lelt'_x_y -> fst lelt'_x_y) *
(forall l : L, fst lelt'_x_y -> ((xL_let l).2).1 y) *
(forall r : R, (xR_let r).1 y -> snd lelt'_x_y)}
        exists (Build_HProp
                  ((forall l, (xL_let l).2.1 y) *
                   (forall r', snd (x_let_yR r').1)) ,
                (hor {l':L' & fst (x_let_yL l').1}
                    {r:R   & (xR_let r).1 y})).
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
xL_let: L -> A
xR_let: R -> A
x_lt_le: forall (l : L) (r : R) (y : No),
(xR_let r).1 y -> ((xL_let l).2).1 y
A':= fun y : No =>
{lelt'_x_y : HProp * HProp &
(snd lelt'_x_y -> fst lelt'_x_y) *
(forall l : L, fst lelt'_x_y -> ((xL_let l).2).1 y) *
(forall r : R, (xR_let r).1 y -> snd lelt'_x_y)}: No -> Type
A'le:= fun (y z : No) (_ : y <= z) 
  (tr : A' y) (sq : A' z) =>
(fst tr.1 -> fst sq.1) * (snd tr.1 -> snd sq.1): forall y z : No, y <= z -> A' y -> A' z -> Type
A'lt:= fun (y z : No) (_ : y < z) 
  (tr : A' y) (sq : A' z) =>
fst tr.1 -> snd sq.1: forall y z : No, y < z -> A' y -> A' z -> Type
L', R': Type
s0: InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
x_let_yL: forall l : L',
{lelt'_x_y : HProp * HProp &
(snd lelt'_x_y -> fst lelt'_x_y) *
(forall l0 : L,
 fst lelt'_x_y -> ((xL_let l0).2).1 (yL l)) *
(forall r : R,
 (xR_let r).1 (yL l) -> snd lelt'_x_y)}
x_let_yR: forall r : R',
{lelt'_x_y : HProp * HProp &
(snd lelt'_x_y -> fst lelt'_x_y) *
(forall l : L,
 fst lelt'_x_y -> ((xL_let l).2).1 (yR r)) *
(forall r0 : R,
 (xR_let r0).1 (yR r) -> snd lelt'_x_y)}
y_lt_le: forall (l : L') (r : R'),
fst (x_let_yL l).1 -> snd (x_let_yR r).1
y:= {{ yL | yR // ycut }}: GenNo S
(snd
   (Build_HProp
      ((forall l : L, ((xL_let l).2).1 y) *
       (forall r' : R', snd (x_let_yR r').1)),
   hor {l' : L' & fst (x_let_yL l').1}
     {r : R & (xR_let r).1 y}) ->
 fst
   (Build_HProp
      ((forall l : L, ((xL_let l).2).1 y) *
       (forall r' : R', snd (x_let_yR r').1)),
   hor {l' : L' & fst (x_let_yL l').1}
     {r : R & (xR_let r).1 y})) *
(forall l : L,
 fst
   (Build_HProp
      ((forall l0 : L, ((xL_let l0).2).1 y) *
       (forall r' : R', snd (x_let_yR r').1)),
   hor {l' : L' & fst (x_let_yL l').1}
     {r : R & (xR_let r).1 y}) -> ((xL_let l).2).1 y) *
(forall r : R,
 (xR_let r).1 y ->
 snd
   (Build_HProp
      ((forall l : L, ((xL_let l).2).1 y) *
       (forall r' : R', snd (x_let_yR r').1)),
   hor {l' : L' & fst (x_let_yL l').1}
     {r0 : R & (xR_let r0).1 y}))
        abstract (
            refine ((_,_),_);
            [ intros h; strip_truncations;
              destruct h as [[l' h]|[r h]]; split; intros;
              [ refine (snd (fst (xL_let l).2.2) (yL l') y _ _);
                [ refine (fst (fst (fst (xL_let l).2.2)) (yL l') _);
                  exact (snd (fst (x_let_yL l').2) l h)
                | by (apply lt_lopt; exact _) ]
              | exact (y_lt_le l' r' h)
              | exact (x_lt_le l r y h)
              | refine (snd (x_let_yR r').2 r _);
                refine (fst (fst (fst (xR_let r).2.2)) _ _);
                refine (snd (fst (xR_let r).2.2) y (yR r') h _);
                apply lt_ropt; exact _ ]
            | intros l [h k]; apply h
            | intros r h; apply tr, inr; exact (r;h) ] ).
      -
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
xL_let: L -> A
xR_let: R -> A
x_lt_le: forall (l : L) (r : R) (y : No),
(xR_let r).1 y -> ((xL_let l).2).1 y
A':= fun y : No =>
{lelt'_x_y : HProp * HProp &
(snd lelt'_x_y -> fst lelt'_x_y) *
(forall l : L, fst lelt'_x_y -> ((xL_let l).2).1 y) *
(forall r : R, (xR_let r).1 y -> snd lelt'_x_y)}: No -> Type
A'le:= fun (y z : No) (_ : y <= z) 
  (tr : A' y) (sq : A' z) =>
(fst tr.1 -> fst sq.1) * (snd tr.1 -> snd sq.1): forall y z : No, y <= z -> A' y -> A' z -> Type
A'lt:= fun (y z : No) (_ : y < z) 
  (tr : A' y) (sq : A' z) =>
fst tr.1 -> snd sq.1: forall y z : No, y < z -> A' y -> A' z -> Type
forall (x y : GenNo S)
(a : {lelt'_x_y : HProp * HProp &
     (snd lelt'_x_y -> fst lelt'_x_y) *
     (forall l : L,
      fst lelt'_x_y -> ((xL_let l).2).1 x) *
     (forall r : R, (xR_let r).1 x -> snd lelt'_x_y)})
(b : {lelt'_x_y : HProp * HProp &
     (snd lelt'_x_y -> fst lelt'_x_y) *
     (forall l : L,
      fst lelt'_x_y -> ((xL_let l).2).1 y) *
     (forall r : R, (xR_let r).1 y -> snd lelt'_x_y)})
(p : x <= y) (q : y <= x),
(fst a.1 -> fst b.1) * (snd a.1 -> snd b.1) ->
(fst b.1 -> fst a.1) * (snd b.1 -> snd a.1) ->
transport
  (fun y0 : No =>
   {lelt'_x_y : HProp * HProp &
   (snd lelt'_x_y -> fst lelt'_x_y) *
   (forall l : L, fst lelt'_x_y -> ((xL_let l).2).1 y0) *
   (forall r : R, (xR_let r).1 y0 -> snd lelt'_x_y)})
  (path_No x y p q) a = b abstract (
            intros y z
                   [[x_le_y x_lt_y] ?]
                   [[x_le_z x_lt_z] ?]
                   p q;
            cbn; intros [p1 p2] [q1 q2];
            rewrite transport_sigma'; (* cbn; *)
            refine (path_sigma' _
                      (path_prod' (path_hprop (equiv_iff_hprop p1 q1))
                                  (path_hprop (equiv_iff_hprop p2 q2)))
                      _);
            apply path_ishprop ).
      -
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
xL_let: L -> A
xR_let: R -> A
x_lt_le: forall (l : L) (r : R) (y : No),
(xR_let r).1 y -> ((xL_let l).2).1 y
A':= fun y : No =>
{lelt'_x_y : HProp * HProp &
(snd lelt'_x_y -> fst lelt'_x_y) *
(forall l : L, fst lelt'_x_y -> ((xL_let l).2).1 y) *
(forall r : R, (xR_let r).1 y -> snd lelt'_x_y)}: No -> Type
A'le:= fun (y z : No) (_ : y <= z) 
  (tr : A' y) (sq : A' z) =>
(fst tr.1 -> fst sq.1) * (snd tr.1 -> snd sq.1): forall y z : No, y <= z -> A' y -> A' z -> Type
A'lt:= fun (y z : No) (_ : y < z) 
  (tr : A' y) (sq : A' z) =>
fst tr.1 -> snd sq.1: forall y z : No, y < z -> A' y -> A' z -> Type
forall (L0 R0 : Type) (s : InSort S L0 R0)
(xL : L0 -> GenNo S) (xR : R0 -> GenNo S)
(xcut : forall (l : L0) (r : R0), xL l < xR r)
(fxL : forall l : L0,
       {lelt'_x_y : HProp * HProp &
       (snd lelt'_x_y -> fst lelt'_x_y) *
       (forall l0 : L,
        fst lelt'_x_y -> ((xL_let l0).2).1 (xL l)) *
       (forall r : R,
        (xR_let r).1 (xL l) -> snd lelt'_x_y)})
(fxR : forall r : R0,
       {lelt'_x_y : HProp * HProp &
       (snd lelt'_x_y -> fst lelt'_x_y) *
       (forall l : L,
        fst lelt'_x_y -> ((xL_let l).2).1 (xR r)) *
       (forall r0 : R,
        (xR_let r0).1 (xR r) -> snd lelt'_x_y)})
(fxcut : forall (l : L0) (r : R0),
         fst (fxL l).1 -> snd (fxR r).1)
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo S) (yR : R' -> GenNo S)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L',
       {lelt'_x_y : HProp * HProp &
       (snd lelt'_x_y -> fst lelt'_x_y) *
       (forall l0 : L,
        fst lelt'_x_y -> ((xL_let l0).2).1 (yL l)) *
       (forall r : R,
        (xR_let r).1 (yL l) -> snd lelt'_x_y)})
(fyR : forall r : R',
       {lelt'_x_y : HProp * HProp &
       (snd lelt'_x_y -> fst lelt'_x_y) *
       (forall l : L,
        fst lelt'_x_y -> ((xL_let l).2).1 (yR r)) *
       (forall r0 : R,
        (xR_let r0).1 (yR r) -> snd lelt'_x_y)})
(fycut : forall (l : L') (r : R'),
         fst (fyL l).1 -> snd (fyR r).1),
(forall l : L0, xL l < {{ yL | yR // ycut }}) ->
(forall l : L0,
 fst (fxL l).1 ->
 snd
   ((fun (L'0 R'0 : Type) (s0 : InSort S L'0 R'0)
       (yL0 : L'0 -> GenNo S) (yR0 : R'0 -> GenNo S)
       (ycut0 : forall (l0 : L'0) (r : R'0),
                yL0 l0 < yR0 r)
       (x_let_yL : forall l0 : L'0,
                   {lelt'_x_y : HProp * HProp &
                   (snd lelt'_x_y -> fst lelt'_x_y) *
                   (forall l1 : L,
                    fst lelt'_x_y ->
                    ((xL_let l1).2).1 (yL0 l0)) *
                   (forall r : R,
                    (xR_let r).1 (yL0 l0) ->
                    snd lelt'_x_y)})
       (x_let_yR : forall r : R'0,
                   {lelt'_x_y : HProp * HProp &
                   (snd lelt'_x_y -> fst lelt'_x_y) *
                   (forall l0 : L,
                    fst lelt'_x_y ->
                    ((xL_let l0).2).1 (yR0 r)) *
                   (forall r0 : R,
                    (xR_let r0).1 (yR0 r) ->
                    snd lelt'_x_y)})
       (y_lt_le : forall (l0 : L'0) (r : R'0),
                  fst (x_let_yL l0).1 ->
                  snd (x_let_yR r).1) =>
     let y := {{ yL0 | yR0 // ycut0 }} in
     ((Build_HProp
         ((forall l0 : L, ((xL_let l0).2).1 y) *
          (forall r' : R'0, snd (x_let_yR r').1)),
      hor {l' : L'0 & fst (x_let_yL l').1}
        {r : R & (xR_let r).1 y});
     inner_package_subproof L'0 R'0 s0 yL0 yR0 ycut0
       x_let_yL x_let_yR y_lt_le)) L' R' s' yL yR ycut
      fyL fyR fycut).1) ->
(forall r : R', {{ xL | xR // xcut }} < yR r) ->
(forall r : R',
 fst
   ((fun (L'0 R'0 : Type) (s0 : InSort S L'0 R'0)
       (yL0 : L'0 -> GenNo S) (yR0 : R'0 -> GenNo S)
       (ycut0 : forall (l : L'0) (r0 : R'0),
                yL0 l < yR0 r0)
       (x_let_yL : forall l : L'0,
                   {lelt'_x_y : HProp * HProp &
                   (snd lelt'_x_y -> fst lelt'_x_y) *
                   (forall l0 : L,
                    fst lelt'_x_y ->
                    ((xL_let l0).2).1 (yL0 l)) *
                   (forall r0 : R,
                    (xR_let r0).1 (yL0 l) ->
                    snd lelt'_x_y)})
       (x_let_yR : forall r0 : R'0,
                   {lelt'_x_y : HProp * HProp &
                   (snd lelt'_x_y -> fst lelt'_x_y) *
                   (forall l : L,
                    fst lelt'_x_y ->
                    ((xL_let l).2).1 (yR0 r0)) *
                   (forall r1 : R,
                    (xR_let r1).1 (yR0 r0) ->
                    snd lelt'_x_y)})
       (y_lt_le : forall (l : L'0) (r0 : R'0),
                  fst (x_let_yL l).1 ->
                  snd (x_let_yR r0).1) =>
     let y := {{ yL0 | yR0 // ycut0 }} in
     ((Build_HProp
         ((forall l : L, ((xL_let l).2).1 y) *
          (forall r' : R'0, snd (x_let_yR r').1)),
      hor {l' : L'0 & fst (x_let_yL l').1}
        {r0 : R & (xR_let r0).1 y});
     inner_package_subproof L'0 R'0 s0 yL0 yR0 ycut0
       x_let_yL x_let_yR y_lt_le)) L0 R0 s xL xR xcut
      fxL fxR fxcut).1 -> snd (fyR r).1) ->
(fst
   ((fun (L'0 R'0 : Type) (s0 : InSort S L'0 R'0)
       (yL0 : L'0 -> GenNo S) (yR0 : R'0 -> GenNo S)
       (ycut0 : forall (l : L'0) (r : R'0),
                yL0 l < yR0 r)
       (x_let_yL : forall l : L'0,
                   {lelt'_x_y : HProp * HProp &
                   (snd lelt'_x_y -> fst lelt'_x_y) *
                   (forall l0 : L,
                    fst lelt'_x_y ->
                    ((xL_let l0).2).1 (yL0 l)) *
                   (forall r : R,
                    (xR_let r).1 (yL0 l) ->
                    snd lelt'_x_y)})
       (x_let_yR : forall r : R'0,
                   {lelt'_x_y : HProp * HProp &
                   (snd lelt'_x_y -> fst lelt'_x_y) *
                   (forall l : L,
                    fst lelt'_x_y ->
                    ((xL_let l).2).1 (yR0 r)) *
                   (forall r0 : R,
                    (xR_let r0).1 (yR0 r) ->
                    snd lelt'_x_y)})
       (y_lt_le : forall (l : L'0) (r : R'0),
                  fst (x_let_yL l).1 ->
                  snd (x_let_yR r).1) =>
     let y := {{ yL0 | yR0 // ycut0 }} in
     ((Build_HProp
         ((forall l : L, ((xL_let l).2).1 y) *
          (forall r' : R'0, snd (x_let_yR r').1)),
      hor {l' : L'0 & fst (x_let_yL l').1}
        {r : R & (xR_let r).1 y});
     inner_package_subproof L'0 R'0 s0 yL0 yR0 ycut0
       x_let_yL x_let_yR y_lt_le)) L0 R0 s xL xR xcut
      fxL fxR fxcut).1 ->
 fst
   ((fun (L'0 R'0 : Type) (s0 : InSort S L'0 R'0)
       (yL0 : L'0 -> GenNo S) (yR0 : R'0 -> GenNo S)
       (ycut0 : forall (l : L'0) (r : R'0),
                yL0 l < yR0 r)
       (x_let_yL : forall l : L'0,
                   {lelt'_x_y : HProp * HProp &
                   (snd lelt'_x_y -> fst lelt'_x_y) *
                   (forall l0 : L,
                    fst lelt'_x_y ->
                    ((xL_let l0).2).1 (yL0 l)) *
                   (forall r : R,
                    (xR_let r).1 (yL0 l) ->
                    snd lelt'_x_y)})
       (x_let_yR : forall r : R'0,
                   {lelt'_x_y : HProp * HProp &
                   (snd lelt'_x_y -> fst lelt'_x_y) *
                   (forall l : L,
                    fst lelt'_x_y ->
                    ((xL_let l).2).1 (yR0 r)) *
                   (forall r0 : R,
                    (xR_let r0).1 (yR0 r) ->
                    snd lelt'_x_y)})
       (y_lt_le : forall (l : L'0) (r : R'0),
                  fst (x_let_yL l).1 ->
                  snd (x_let_yR r).1) =>
     let y := {{ yL0 | yR0 // ycut0 }} in
     ((Build_HProp
         ((forall l : L, ((xL_let l).2).1 y) *
          (forall r' : R'0, snd (x_let_yR r').1)),
      hor {l' : L'0 & fst (x_let_yL l').1}
        {r : R & (xR_let r).1 y});
     inner_package_subproof L'0 R'0 s0 yL0 yR0 ycut0
       x_let_yL x_let_yR y_lt_le)) L' R' s' yL yR ycut
      fyL fyR fycut).1) *
(snd
   ((fun (L'0 R'0 : Type) (s0 : InSort S L'0 R'0)
       (yL0 : L'0 -> GenNo S) (yR0 : R'0 -> GenNo S)
       (ycut0 : forall (l : L'0) (r : R'0),
                yL0 l < yR0 r)
       (x_let_yL : forall l : L'0,
                   {lelt'_x_y : HProp * HProp &
                   (snd lelt'_x_y -> fst lelt'_x_y) *
                   (forall l0 : L,
                    fst lelt'_x_y ->
                    ((xL_let l0).2).1 (yL0 l)) *
                   (forall r : R,
                    (xR_let r).1 (yL0 l) ->
                    snd lelt'_x_y)})
       (x_let_yR : forall r : R'0,
                   {lelt'_x_y : HProp * HProp &
                   (snd lelt'_x_y -> fst lelt'_x_y) *
                   (forall l : L,
                    fst lelt'_x_y ->
                    ((xL_let l).2).1 (yR0 r)) *
                   (forall r0 : R,
                    (xR_let r0).1 (yR0 r) ->
                    snd lelt'_x_y)})
       (y_lt_le : forall (l : L'0) (r : R'0),
                  fst (x_let_yL l).1 ->
                  snd (x_let_yR r).1) =>
     let y := {{ yL0 | yR0 // ycut0 }} in
     ((Build_HProp
         ((forall l : L, ((xL_let l).2).1 y) *
          (forall r' : R'0, snd (x_let_yR r').1)),
      hor {l' : L'0 & fst (x_let_yL l').1}
        {r : R & (xR_let r).1 y});
     inner_package_subproof L'0 R'0 s0 yL0 yR0 ycut0
       x_let_yL x_let_yR y_lt_le)) L0 R0 s xL xR xcut
      fxL fxR fxcut).1 ->
 snd
   ((fun (L'0 R'0 : Type) (s0 : InSort S L'0 R'0)
       (yL0 : L'0 -> GenNo S) (yR0 : R'0 -> GenNo S)
       (ycut0 : forall (l : L'0) (r : R'0),
                yL0 l < yR0 r)
       (x_let_yL : forall l : L'0,
                   {lelt'_x_y : HProp * HProp &
                   (snd lelt'_x_y -> fst lelt'_x_y) *
                   (forall l0 : L,
                    fst lelt'_x_y ->
                    ((xL_let l0).2).1 (yL0 l)) *
                   (forall r : R,
                    (xR_let r).1 (yL0 l) ->
                    snd lelt'_x_y)})
       (x_let_yR : forall r : R'0,
                   {lelt'_x_y : HProp * HProp &
                   (snd lelt'_x_y -> fst lelt'_x_y) *
                   (forall l : L,
                    fst lelt'_x_y ->
                    ((xL_let l).2).1 (yR0 r)) *
                   (forall r0 : R,
                    (xR_let r0).1 (yR0 r) ->
                    snd lelt'_x_y)})
       (y_lt_le : forall (l : L'0) (r : R'0),
                  fst (x_let_yL l).1 ->
                  snd (x_let_yR r).1) =>
     let y := {{ yL0 | yR0 // ycut0 }} in
     ((Build_HProp
         ((forall l : L, ((xL_let l).2).1 y) *
          (forall r' : R'0, snd (x_let_yR r').1)),
      hor {l' : L'0 & fst (x_let_yL l').1}
        {r : R & (xR_let r).1 y});
     inner_package_subproof L'0 R'0 s0 yL0 yR0 ycut0
       x_let_yL x_let_yR y_lt_le)) L' R' s' yL yR ycut
      fyL fyR fycut).1) abstract (
            cbn;
            intros L' R' ? yL yR ycut x_let_yL x_let_yR y_lt_le;
            set (y := {{ yL | yR // ycut }});
            intros L'' R'' ? zL zR zcut x_let_zL x_let_zR z_lt_le;
            set (z := {{ zL | zR // zcut }});
            intros yL_lt_z h1 y_lt_zR h2;
            assert (y_le_z := le_lr yL yR ycut zL zR zcut yL_lt_z y_lt_zR);
            split; [ intros [h3 h4]; split
                   | intros h3; strip_truncations;
                     destruct h3 as [[l' h3]|[r h3]] ] ;
            [ intros l; refine (snd (xL_let l).2.2 y z (h3 l) y_le_z)
            | intros r''; refine (h2 r'' (h3 , h4))
            | refine (h1 l' h3)
            | apply tr, inr; exists r;
              refine (snd (fst (fst (xR_let r).2.2)) y z h3 y_le_z) ] ).
      -
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
xL_let: L -> A
xR_let: R -> A
x_lt_le: forall (l : L) (r : R) (y : No),
(xR_let r).1 y -> ((xL_let l).2).1 y
A':= fun y : No =>
{lelt'_x_y : HProp * HProp &
(snd lelt'_x_y -> fst lelt'_x_y) *
(forall l : L, fst lelt'_x_y -> ((xL_let l).2).1 y) *
(forall r : R, (xR_let r).1 y -> snd lelt'_x_y)}: No -> Type
A'le:= fun (y z : No) (_ : y <= z) 
  (tr : A' y) (sq : A' z) =>
(fst tr.1 -> fst sq.1) * (snd tr.1 -> snd sq.1): forall y z : No, y <= z -> A' y -> A' z -> Type
A'lt:= fun (y z : No) (_ : y < z) 
  (tr : A' y) (sq : A' z) =>
fst tr.1 -> snd sq.1: forall y z : No, y < z -> A' y -> A' z -> Type
forall (L0 R0 : Type) (s : InSort S L0 R0)
(xL : L0 -> GenNo S) (xR : R0 -> GenNo S)
(xcut : forall (l : L0) (r : R0), xL l < xR r)
(fxL : forall l : L0,
       {lelt'_x_y : HProp * HProp &
       (snd lelt'_x_y -> fst lelt'_x_y) *
       (forall l0 : L,
        fst lelt'_x_y -> ((xL_let l0).2).1 (xL l)) *
       (forall r : R,
        (xR_let r).1 (xL l) -> snd lelt'_x_y)})
(fxR : forall r : R0,
       {lelt'_x_y : HProp * HProp &
       (snd lelt'_x_y -> fst lelt'_x_y) *
       (forall l : L,
        fst lelt'_x_y -> ((xL_let l).2).1 (xR r)) *
       (forall r0 : R,
        (xR_let r0).1 (xR r) -> snd lelt'_x_y)})
(fxcut : forall (l : L0) (r : R0),
         fst (fxL l).1 -> snd (fxR r).1)
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo S) (yR : R' -> GenNo S)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L',
       {lelt'_x_y : HProp * HProp &
       (snd lelt'_x_y -> fst lelt'_x_y) *
       (forall l0 : L,
        fst lelt'_x_y -> ((xL_let l0).2).1 (yL l)) *
       (forall r : R,
        (xR_let r).1 (yL l) -> snd lelt'_x_y)})
(fyR : forall r : R',
       {lelt'_x_y : HProp * HProp &
       (snd lelt'_x_y -> fst lelt'_x_y) *
       (forall l : L,
        fst lelt'_x_y -> ((xL_let l).2).1 (yR r)) *
       (forall r0 : R,
        (xR_let r0).1 (yR r) -> snd lelt'_x_y)})
(fycut : forall (l : L') (r : R'),
         fst (fyL l).1 -> snd (fyR r).1) (l : L'),
{{ xL | xR // xcut }} <= yL l ->
(fst
   ((fun (L'0 R'0 : Type) (s0 : InSort S L'0 R'0)
       (yL0 : L'0 -> GenNo S) (yR0 : R'0 -> GenNo S)
       (ycut0 : forall (l0 : L'0) (r : R'0),
                yL0 l0 < yR0 r)
       (x_let_yL : forall l0 : L'0,
                   {lelt'_x_y : HProp * HProp &
                   (snd lelt'_x_y -> fst lelt'_x_y) *
                   (forall l1 : L,
                    fst lelt'_x_y ->
                    ((xL_let l1).2).1 (yL0 l0)) *
                   (forall r : R,
                    (xR_let r).1 (yL0 l0) ->
                    snd lelt'_x_y)})
       (x_let_yR : forall r : R'0,
                   {lelt'_x_y : HProp * HProp &
                   (snd lelt'_x_y -> fst lelt'_x_y) *
                   (forall l0 : L,
                    fst lelt'_x_y ->
                    ((xL_let l0).2).1 (yR0 r)) *
                   (forall r0 : R,
                    (xR_let r0).1 (yR0 r) ->
                    snd lelt'_x_y)})
       (y_lt_le : forall (l0 : L'0) (r : R'0),
                  fst (x_let_yL l0).1 ->
                  snd (x_let_yR r).1) =>
     let y := {{ yL0 | yR0 // ycut0 }} in
     ((Build_HProp
         ((forall l0 : L, ((xL_let l0).2).1 y) *
          (forall r' : R'0, snd (x_let_yR r').1)),
      hor {l' : L'0 & fst (x_let_yL l').1}
        {r : R & (xR_let r).1 y});
     inner_package_subproof L'0 R'0 s0 yL0 yR0 ycut0
       x_let_yL x_let_yR y_lt_le)) L0 R0 s xL xR xcut
      fxL fxR fxcut).1 -> fst (fyL l).1) *
(snd
   ((fun (L'0 R'0 : Type) (s0 : InSort S L'0 R'0)
       (yL0 : L'0 -> GenNo S) (yR0 : R'0 -> GenNo S)
       (ycut0 : forall (l0 : L'0) (r : R'0),
                yL0 l0 < yR0 r)
       (x_let_yL : forall l0 : L'0,
                   {lelt'_x_y : HProp * HProp &
                   (snd lelt'_x_y -> fst lelt'_x_y) *
                   (forall l1 : L,
                    fst lelt'_x_y ->
                    ((xL_let l1).2).1 (yL0 l0)) *
                   (forall r : R,
                    (xR_let r).1 (yL0 l0) ->
                    snd lelt'_x_y)})
       (x_let_yR : forall r : R'0,
                   {lelt'_x_y : HProp * HProp &
                   (snd lelt'_x_y -> fst lelt'_x_y) *
                   (forall l0 : L,
                    fst lelt'_x_y ->
                    ((xL_let l0).2).1 (yR0 r)) *
                   (forall r0 : R,
                    (xR_let r0).1 (yR0 r) ->
                    snd lelt'_x_y)})
       (y_lt_le : forall (l0 : L'0) (r : R'0),
                  fst (x_let_yL l0).1 ->
                  snd (x_let_yR r).1) =>
     let y := {{ yL0 | yR0 // ycut0 }} in
     ((Build_HProp
         ((forall l0 : L, ((xL_let l0).2).1 y) *
          (forall r' : R'0, snd (x_let_yR r').1)),
      hor {l' : L'0 & fst (x_let_yL l').1}
        {r : R & (xR_let r).1 y});
     inner_package_subproof L'0 R'0 s0 yL0 yR0 ycut0
       x_let_yL x_let_yR y_lt_le)) L0 R0 s xL xR xcut
      fxL fxR fxcut).1 -> snd (fyL l).1) ->
fst
  ((fun (L'0 R'0 : Type) (s0 : InSort S L'0 R'0)
      (yL0 : L'0 -> GenNo S) (yR0 : R'0 -> GenNo S)
      (ycut0 : forall (l0 : L'0) (r : R'0),
               yL0 l0 < yR0 r)
      (x_let_yL : forall l0 : L'0,
                  {lelt'_x_y : HProp * HProp &
                  (snd lelt'_x_y -> fst lelt'_x_y) *
                  (forall l1 : L,
                   fst lelt'_x_y ->
                   ((xL_let l1).2).1 (yL0 l0)) *
                  (forall r : R,
                   (xR_let r).1 (yL0 l0) ->
                   snd lelt'_x_y)})
      (x_let_yR : forall r : R'0,
                  {lelt'_x_y : HProp * HProp &
                  (snd lelt'_x_y -> fst lelt'_x_y) *
                  (forall l0 : L,
                   fst lelt'_x_y ->
                   ((xL_let l0).2).1 (yR0 r)) *
                  (forall r0 : R,
                   (xR_let r0).1 (yR0 r) ->
                   snd lelt'_x_y)})
      (y_lt_le : forall (l0 : L'0) (r : R'0),
                 fst (x_let_yL l0).1 ->
                 snd (x_let_yR r).1) =>
    let y := {{ yL0 | yR0 // ycut0 }} in
    ((Build_HProp
        ((forall l0 : L, ((xL_let l0).2).1 y) *
         (forall r' : R'0, snd (x_let_yR r').1)),
     hor {l' : L'0 & fst (x_let_yL l').1}
       {r : R & (xR_let r).1 y});
    inner_package_subproof L'0 R'0 s0 yL0 yR0 ycut0
      x_let_yL x_let_yR y_lt_le)) L0 R0 s xL xR xcut
     fxL fxR fxcut).1 ->
snd
  ((fun (L'0 R'0 : Type) (s0 : InSort S L'0 R'0)
      (yL0 : L'0 -> GenNo S) (yR0 : R'0 -> GenNo S)
      (ycut0 : forall (l0 : L'0) (r : R'0),
               yL0 l0 < yR0 r)
      (x_let_yL : forall l0 : L'0,
                  {lelt'_x_y : HProp * HProp &
                  (snd lelt'_x_y -> fst lelt'_x_y) *
                  (forall l1 : L,
                   fst lelt'_x_y ->
                   ((xL_let l1).2).1 (yL0 l0)) *
                  (forall r : R,
                   (xR_let r).1 (yL0 l0) ->
                   snd lelt'_x_y)})
      (x_let_yR : forall r : R'0,
                  {lelt'_x_y : HProp * HProp &
                  (snd lelt'_x_y -> fst lelt'_x_y) *
                  (forall l0 : L,
                   fst lelt'_x_y ->
                   ((xL_let l0).2).1 (yR0 r)) *
                  (forall r0 : R,
                   (xR_let r0).1 (yR0 r) ->
                   snd lelt'_x_y)})
      (y_lt_le : forall (l0 : L'0) (r : R'0),
                 fst (x_let_yL l0).1 ->
                 snd (x_let_yR r).1) =>
    let y := {{ yL0 | yR0 // ycut0 }} in
    ((Build_HProp
        ((forall l0 : L, ((xL_let l0).2).1 y) *
         (forall r' : R'0, snd (x_let_yR r').1)),
     hor {l' : L'0 & fst (x_let_yL l').1}
       {r : R & (xR_let r).1 y});
    inner_package_subproof L'0 R'0 s0 yL0 yR0 ycut0
      x_let_yL x_let_yR y_lt_le)) L' R' s' yL yR ycut
     fyL fyR fycut).1 abstract (
            cbn;
            intros L' R' ? yL yR ycut x_let_yL x_let_yR y_lt_le;
            set (y := {{ yL | yR // ycut }});
            intros L'' R'' ? zL zR zcut x_let_zL x_let_zR z_lt_le;
            set (z := {{ zL | zR // zcut }});
            intros l'' y_le_zL [h1 h2] x_le_y;
            apply tr, inl; exact (l''; h1 x_le_y) ).
      -
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> No
xR: R -> No
xcut: forall (l : L) (r : R), xL l < xR r
xL_let: L -> A
xR_let: R -> A
x_lt_le: forall (l : L) (r : R) (y : No),
(xR_let r).1 y -> ((xL_let l).2).1 y
A':= fun y : No =>
{lelt'_x_y : HProp * HProp &
(snd lelt'_x_y -> fst lelt'_x_y) *
(forall l : L, fst lelt'_x_y -> ((xL_let l).2).1 y) *
(forall r : R, (xR_let r).1 y -> snd lelt'_x_y)}: No -> Type
A'le:= fun (y z : No) (_ : y <= z) 
  (tr : A' y) (sq : A' z) =>
(fst tr.1 -> fst sq.1) * (snd tr.1 -> snd sq.1): forall y z : No, y <= z -> A' y -> A' z -> Type
A'lt:= fun (y z : No) (_ : y < z) 
  (tr : A' y) (sq : A' z) =>
fst tr.1 -> snd sq.1: forall y z : No, y < z -> A' y -> A' z -> Type
forall (L0 R0 : Type) (s : InSort S L0 R0)
(xL : L0 -> GenNo S) (xR : R0 -> GenNo S)
(xcut : forall (l : L0) (r : R0), xL l < xR r)
(fxL : forall l : L0,
       {lelt'_x_y : HProp * HProp &
       (snd lelt'_x_y -> fst lelt'_x_y) *
       (forall l0 : L,
        fst lelt'_x_y -> ((xL_let l0).2).1 (xL l)) *
       (forall r : R,
        (xR_let r).1 (xL l) -> snd lelt'_x_y)})
(fxR : forall r : R0,
       {lelt'_x_y : HProp * HProp &
       (snd lelt'_x_y -> fst lelt'_x_y) *
       (forall l : L,
        fst lelt'_x_y -> ((xL_let l).2).1 (xR r)) *
       (forall r0 : R,
        (xR_let r0).1 (xR r) -> snd lelt'_x_y)})
(fxcut : forall (l : L0) (r : R0),
         fst (fxL l).1 -> snd (fxR r).1)
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo S) (yR : R' -> GenNo S)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : forall l : L',
       {lelt'_x_y : HProp * HProp &
       (snd lelt'_x_y -> fst lelt'_x_y) *
       (forall l0 : L,
        fst lelt'_x_y -> ((xL_let l0).2).1 (yL l)) *
       (forall r : R,
        (xR_let r).1 (yL l) -> snd lelt'_x_y)})
(fyR : forall r : R',
       {lelt'_x_y : HProp * HProp &
       (snd lelt'_x_y -> fst lelt'_x_y) *
       (forall l : L,
        fst lelt'_x_y -> ((xL_let l).2).1 (yR r)) *
       (forall r0 : R,
        (xR_let r0).1 (yR r) -> snd lelt'_x_y)})
(fycut : forall (l : L') (r : R'),
         fst (fyL l).1 -> snd (fyR r).1) (r : R0),
xR r <= {{ yL | yR // ycut }} ->
(fst (fxR r).1 ->
 fst
   ((fun (L'0 R'0 : Type) (s0 : InSort S L'0 R'0)
       (yL0 : L'0 -> GenNo S) (yR0 : R'0 -> GenNo S)
       (ycut0 : forall (l : L'0) (r0 : R'0),
                yL0 l < yR0 r0)
       (x_let_yL : forall l : L'0,
                   {lelt'_x_y : HProp * HProp &
                   (snd lelt'_x_y -> fst lelt'_x_y) *
                   (forall l0 : L,
                    fst lelt'_x_y ->
                    ((xL_let l0).2).1 (yL0 l)) *
                   (forall r0 : R,
                    (xR_let r0).1 (yL0 l) ->
                    snd lelt'_x_y)})
       (x_let_yR : forall r0 : R'0,
                   {lelt'_x_y : HProp * HProp &
                   (snd lelt'_x_y -> fst lelt'_x_y) *
                   (forall l : L,
                    fst lelt'_x_y ->
                    ((xL_let l).2).1 (yR0 r0)) *
                   (forall r1 : R,
                    (xR_let r1).1 (yR0 r0) ->
                    snd lelt'_x_y)})
       (y_lt_le : forall (l : L'0) (r0 : R'0),
                  fst (x_let_yL l).1 ->
                  snd (x_let_yR r0).1) =>
     let y := {{ yL0 | yR0 // ycut0 }} in
     ((Build_HProp
         ((forall l : L, ((xL_let l).2).1 y) *
          (forall r' : R'0, snd (x_let_yR r').1)),
      hor {l' : L'0 & fst (x_let_yL l').1}
        {r0 : R & (xR_let r0).1 y});
     inner_package_subproof L'0 R'0 s0 yL0 yR0 ycut0
       x_let_yL x_let_yR y_lt_le)) L' R' s' yL yR ycut
      fyL fyR fycut).1) *
(snd (fxR r).1 ->
 snd
   ((fun (L'0 R'0 : Type) (s0 : InSort S L'0 R'0)
       (yL0 : L'0 -> GenNo S) (yR0 : R'0 -> GenNo S)
       (ycut0 : forall (l : L'0) (r0 : R'0),
                yL0 l < yR0 r0)
       (x_let_yL : forall l : L'0,
                   {lelt'_x_y : HProp * HProp &
                   (snd lelt'_x_y -> fst lelt'_x_y) *
                   (forall l0 : L,
                    fst lelt'_x_y ->
                    ((xL_let l0).2).1 (yL0 l)) *
                   (forall r0 : R,
                    (xR_let r0).1 (yL0 l) ->
                    snd lelt'_x_y)})
       (x_let_yR : forall r0 : R'0,
                   {lelt'_x_y : HProp * HProp &
                   (snd lelt'_x_y -> fst lelt'_x_y) *
                   (forall l : L,
                    fst lelt'_x_y ->
                    ((xL_let l).2).1 (yR0 r0)) *
                   (forall r1 : R,
                    (xR_let r1).1 (yR0 r0) ->
                    snd lelt'_x_y)})
       (y_lt_le : forall (l : L'0) (r0 : R'0),
                  fst (x_let_yL l).1 ->
                  snd (x_let_yR r0).1) =>
     let y := {{ yL0 | yR0 // ycut0 }} in
     ((Build_HProp
         ((forall l : L, ((xL_let l).2).1 y) *
          (forall r' : R'0, snd (x_let_yR r').1)),
      hor {l' : L'0 & fst (x_let_yL l').1}
        {r0 : R & (xR_let r0).1 y});
     inner_package_subproof L'0 R'0 s0 yL0 yR0 ycut0
       x_let_yL x_let_yR y_lt_le)) L' R' s' yL yR ycut
      fyL fyR fycut).1) ->
fst
  ((fun (L'0 R'0 : Type) (s0 : InSort S L'0 R'0)
      (yL0 : L'0 -> GenNo S) (yR0 : R'0 -> GenNo S)
      (ycut0 : forall (l : L'0) (r0 : R'0),
               yL0 l < yR0 r0)
      (x_let_yL : forall l : L'0,
                  {lelt'_x_y : HProp * HProp &
                  (snd lelt'_x_y -> fst lelt'_x_y) *
                  (forall l0 : L,
                   fst lelt'_x_y ->
                   ((xL_let l0).2).1 (yL0 l)) *
                  (forall r0 : R,
                   (xR_let r0).1 (yL0 l) ->
                   snd lelt'_x_y)})
      (x_let_yR : forall r0 : R'0,
                  {lelt'_x_y : HProp * HProp &
                  (snd lelt'_x_y -> fst lelt'_x_y) *
                  (forall l : L,
                   fst lelt'_x_y ->
                   ((xL_let l).2).1 (yR0 r0)) *
                  (forall r1 : R,
                   (xR_let r1).1 (yR0 r0) ->
                   snd lelt'_x_y)})
      (y_lt_le : forall (l : L'0) (r0 : R'0),
                 fst (x_let_yL l).1 ->
                 snd (x_let_yR r0).1) =>
    let y := {{ yL0 | yR0 // ycut0 }} in
    ((Build_HProp
        ((forall l : L, ((xL_let l).2).1 y) *
         (forall r' : R'0, snd (x_let_yR r').1)),
     hor {l' : L'0 & fst (x_let_yL l').1}
       {r0 : R & (xR_let r0).1 y});
    inner_package_subproof L'0 R'0 s0 yL0 yR0 ycut0
      x_let_yL x_let_yR y_lt_le)) L0 R0 s xL xR xcut
     fxL fxR fxcut).1 ->
snd
  ((fun (L'0 R'0 : Type) (s0 : InSort S L'0 R'0)
      (yL0 : L'0 -> GenNo S) (yR0 : R'0 -> GenNo S)
      (ycut0 : forall (l : L'0) (r0 : R'0),
               yL0 l < yR0 r0)
      (x_let_yL : forall l : L'0,
                  {lelt'_x_y : HProp * HProp &
                  (snd lelt'_x_y -> fst lelt'_x_y) *
                  (forall l0 : L,
                   fst lelt'_x_y ->
                   ((xL_let l0).2).1 (yL0 l)) *
                  (forall r0 : R,
                   (xR_let r0).1 (yL0 l) ->
                   snd lelt'_x_y)})
      (x_let_yR : forall r0 : R'0,
                  {lelt'_x_y : HProp * HProp &
                  (snd lelt'_x_y -> fst lelt'_x_y) *
                  (forall l : L,
                   fst lelt'_x_y ->
                   ((xL_let l).2).1 (yR0 r0)) *
                  (forall r1 : R,
                   (xR_let r1).1 (yR0 r0) ->
                   snd lelt'_x_y)})
      (y_lt_le : forall (l : L'0) (r0 : R'0),
                 fst (x_let_yL l).1 ->
                 snd (x_let_yR r0).1) =>
    let y := {{ yL0 | yR0 // ycut0 }} in
    ((Build_HProp
        ((forall l : L, ((xL_let l).2).1 y) *
         (forall r' : R'0, snd (x_let_yR r').1)),
     hor {l' : L'0 & fst (x_let_yL l').1}
       {r0 : R & (xR_let r0).1 y});
    inner_package_subproof L'0 R'0 s0 yL0 yR0 ycut0
      x_let_yL x_let_yR y_lt_le)) L' R' s' yL yR ycut
     fyL fyR fycut).1 abstract (
            cbn;
            intros L' R' ? yL yR ycut x_let_yL x_let_yR y_lt_le;
            set (y := {{ yL | yR // ycut }});
            intros L'' R'' ? zL zR zcut x_let_zL x_let_zR z_lt_le;
            set (z := {{ zL | zR // zcut }});
            intros r' yR_le_z [h1 h2] x_le_y;
            apply h2; exact (snd x_le_y r') ).
    Defined.

    Local Definition inner (y : No) : A' y
      := inner_package.1 y.

    (** These computation laws hold definitionally, but it helps Coq out if we prove them explicitly and then rewrite along them later. *)
    Definition inner_cut_le
               (L' R' : Type@{i}) {s : InSort S L' R'}
               (yL : L' -> No) (yR : R' -> No)
               (ycut : forall (l:L') (r:R'), (yL l) < (yR r))
    : fst (inner {{ yL | yR // ycut }}).1 =
      (Build_HProp ((forall l, (xL_let l).2.1 {{ yL | yR // ycut }}) *
                   (forall r', snd (inner (yR r')).1)))
      := 1.

    Definition inner_cut_lt
               (L' R' : Type@{i}) {s : InSort S L' R'}
               (yL : L' -> No) (yR : R' -> No)
               (ycut : forall (l:L') (r:R'), (yL l) < (yR r))
    : snd (inner {{ yL | yR // ycut }}).1 =
      (hor {l':L' & fst (inner (yL l')).1}
           {r:R & (xR_let r).1 {{ yL | yR // ycut }} })
      := 1.

    Local Definition inner_le y z p : A'le y z p (inner y) (inner z)
      := fst (inner_package.2) y z p.

    Local Definition inner_lt y z p : A'lt y z p (inner y) (inner z)
      := snd (inner_package.2) y z p.

  End Inner.

  (** We instruct [simpl]/[cbn] not to unfold [inner].  We will do the "unfolding" ourselves by rewriting along [inner_cut_le] and [inner_cut_lt], so as to keep better control over the resulting terms (and particularly their size).  *)
  Arguments inner : simpl never.

  Definition No_codes_package
  : { lelt : No -> A &
         (forall (x y : No), (x <= y) ->
            forall z, ((lelt y).1 z -> (lelt x).1 z) *
                      ((lelt y).2.1 z -> (lelt x).2.1 z)) *
         (forall (x y : No), (x < y) ->
            forall z, ((lelt y).1 z -> (lelt x).2.1 z)) }.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
{lelt : No -> A &
(forall x y : No,
 x <= y ->
 forall z : No,
 ((lelt y).1 z -> (lelt x).1 z) *
 (((lelt y).2).1 z -> ((lelt x).2).1 z)) *
(forall x y : No,
 x < y ->
 forall z : No, (lelt y).1 z -> ((lelt x).2).1 z)}
  Proof.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
{lelt : No -> A &
(forall x y : No,
 x <= y ->
 forall z : No,
 ((lelt y).1 z -> (lelt x).1 z) *
 (((lelt y).2).1 z -> ((lelt x).2).1 z)) *
(forall x y : No,
 x < y ->
 forall z : No, (lelt y).1 z -> ((lelt x).2).1 z)}
    simple refine (No_rec_package A
              (fun dm ht => forall y, (ht.1 y -> dm.1 y)
                                      * (ht.2.1 y -> dm.2.1 y))
              (fun dm ht => forall y, (ht.1 y -> dm.2.1 y))
              _ _ _ _ _).
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
forall L R : Type,
InSort S L R ->
forall (xL : L -> GenNo S) (xR : R -> GenNo S),
(forall (l : L) (r : R), xL l < xR r) ->
forall (fxL : L -> A) (fxR : R -> A),
(forall (l : L) (r : R),
 (fun dm ht : A => forall y : No, ht.1 y -> (dm.2).1 y)
   (fxL l) (fxR r)) -> A
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
forall a b : A,
(fun dm ht : A =>
 forall y : No,
 (ht.1 y -> dm.1 y) * ((ht.2).1 y -> (dm.2).1 y)) a b ->
(fun dm ht : A =>
 forall y : No,
 (ht.1 y -> dm.1 y) * ((ht.2).1 y -> (dm.2).1 y)) b a ->
a = b
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo S) (xR : R -> GenNo S)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) (r : R),
         (fun dm ht : A =>
          forall y : No, ht.1 y -> (dm.2).1 y) (fxL l)
           (fxR r)) (L' R' : Type)
(s' : InSort S L' R') (yL : L' -> GenNo S)
(yR : R' -> GenNo S)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') (r : R'),
         (fun dm ht : A =>
          forall y : No, ht.1 y -> (dm.2).1 y) (fyL l)
           (fyR r)),
(forall l : L, xL l < {{ yL | yR // ycut }}) ->
(forall l : L,
 (fun dm ht : A => forall y : No, ht.1 y -> (dm.2).1 y)
   (fxL l) (?dcut L' R' s' yL yR ycut fyL fyR fycut)) ->
(forall r : R', {{ xL | xR // xcut }} < yR r) ->
(forall r : R',
 (fun dm ht : A => forall y : No, ht.1 y -> (dm.2).1 y)
   (?dcut L R s xL xR xcut fxL fxR fxcut) (fyR r)) ->
(fun dm ht : A =>
 forall y : No,
 (ht.1 y -> dm.1 y) * ((ht.2).1 y -> (dm.2).1 y))
  (?dcut L R s xL xR xcut fxL fxR fxcut)
  (?dcut L' R' s' yL yR ycut fyL fyR fycut)
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo S) (xR : R -> GenNo S)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) (r : R),
         (fun dm ht : A =>
          forall y : No, ht.1 y -> (dm.2).1 y) (fxL l)
           (fxR r)) (L' R' : Type)
(s' : InSort S L' R') (yL : L' -> GenNo S)
(yR : R' -> GenNo S)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') (r : R'),
         (fun dm ht : A =>
          forall y : No, ht.1 y -> (dm.2).1 y) (fyL l)
           (fyR r)) (l : L'),
{{ xL | xR // xcut }} <= yL l ->
(fun dm ht : A =>
 forall y : No,
 (ht.1 y -> dm.1 y) * ((ht.2).1 y -> (dm.2).1 y))
  (?dcut L R s xL xR xcut fxL fxR fxcut) (fyL l) ->
(fun dm ht : A => forall y : No, ht.1 y -> (dm.2).1 y)
  (?dcut L R s xL xR xcut fxL fxR fxcut)
  (?dcut L' R' s' yL yR ycut fyL fyR fycut)
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo S) (xR : R -> GenNo S)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) (r : R),
         (fun dm ht : A =>
          forall y : No, ht.1 y -> (dm.2).1 y) (fxL l)
           (fxR r)) (L' R' : Type)
(s' : InSort S L' R') (yL : L' -> GenNo S)
(yR : R' -> GenNo S)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') (r : R'),
         (fun dm ht : A =>
          forall y : No, ht.1 y -> (dm.2).1 y) (fyL l)
           (fyR r)) (r : R),
xR r <= {{ yL | yR // ycut }} ->
(fun dm ht : A =>
 forall y : No,
 (ht.1 y -> dm.1 y) * ((ht.2).1 y -> (dm.2).1 y))
  (fxR r) (?dcut L' R' s' yL yR ycut fyL fyR fycut) ->
(fun dm ht : A => forall y : No, ht.1 y -> (dm.2).1 y)
  (?dcut L R s xL xR xcut fxL fxR fxcut)
  (?dcut L' R' s' yL yR ycut fyL fyR fycut)
    -
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
forall L R : Type,
InSort S L R ->
forall (xL : L -> GenNo S) (xR : R -> GenNo S),
(forall (l : L) (r : R), xL l < xR r) ->
forall (fxL : L -> A) (fxR : R -> A),
(forall (l : L) (r : R),
 (fun dm ht : A => forall y : No, ht.1 y -> (dm.2).1 y)
   (fxL l) (fxR r)) -> A intros L R ? xL xR xcut xL_let xR_let x_lt_le.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xL_let: L -> A
xR_let: R -> A
x_lt_le: forall (l : L) (r : R),
(fun dm ht : A =>
 forall y : No, ht.1 y -> (dm.2).1 y)
  (xL_let l) (xR_let r)
A
      pose (x := {{ xL | xR // xcut }}).
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xL_let: L -> A
xR_let: R -> A
x_lt_le: forall (l : L) (r : R),
(fun dm ht : A =>
 forall y : No, ht.1 y -> (dm.2).1 y)
  (xL_let l) (xR_let r)
x:= {{ xL | xR // xcut }}: GenNo S
A
      exists (fun y => fst (inner xL_let xR_let x_lt_le y).1).
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xL_let: L -> A
xR_let: R -> A
x_lt_le: forall (l : L) (r : R),
(fun dm ht : A =>
 forall y : No, ht.1 y -> (dm.2).1 y)
  (xL_let l) (xR_let r)
x:= {{ xL | xR // xcut }}: GenNo S
{lt'_x : No -> HProp &
(forall y : No,
 lt'_x y -> fst (inner xL_let xR_let x_lt_le y).1) *
(forall y z : No,
 fst (inner xL_let xR_let x_lt_le y).1 ->
 y <= z -> fst (inner xL_let xR_let x_lt_le z).1) *
(forall y z : No,
 fst (inner xL_let xR_let x_lt_le y).1 ->
 y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}
      exists (fun y => snd (inner xL_let xR_let x_lt_le y).1).
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xL_let: L -> A
xR_let: R -> A
x_lt_le: forall (l : L) (r : R),
(fun dm ht : A =>
 forall y : No, ht.1 y -> (dm.2).1 y)
  (xL_let l) (xR_let r)
x:= {{ xL | xR // xcut }}: GenNo S
(forall y : No,
 snd (inner xL_let xR_let x_lt_le y).1 ->
 fst (inner xL_let xR_let x_lt_le y).1) *
(forall y z : No,
 fst (inner xL_let xR_let x_lt_le y).1 ->
 y <= z -> fst (inner xL_let xR_let x_lt_le z).1) *
(forall y z : No,
 fst (inner xL_let xR_let x_lt_le y).1 ->
 y < z -> snd (inner xL_let xR_let x_lt_le z).1) *
(forall y z : No,
 snd (inner xL_let xR_let x_lt_le y).1 ->
 y <= z -> snd (inner xL_let xR_let x_lt_le z).1)
      abstract (
          repeat split;
          [ intros y; exact (fst (fst (inner xL_let xR_let x_lt_le y).2))
          | intros y z x_le_y y_le_z;
            exact (fst (inner_le xL_let xR_let x_lt_le y z y_le_z) x_le_y)
          | intros y z x_le_y y_lt_z;
            exact (inner_lt xL_let xR_let x_lt_le y z y_lt_z x_le_y)
          | intros y z x_lt_y y_le_z;
            exact (snd (inner_le xL_let xR_let x_lt_le y z y_le_z) x_lt_y) ]).
    -
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
forall a b : A,
(fun dm ht : A =>
 forall y : No,
 (ht.1 y -> dm.1 y) * ((ht.2).1 y -> (dm.2).1 y)) a b ->
(fun dm ht : A =>
 forall y : No,
 (ht.1 y -> dm.1 y) * ((ht.2).1 y -> (dm.2).1 y)) b a ->
a = b abstract (
          intros [x_le [x_lt ?]] [x_le' [x_lt' ?]] p q; cbn in p, q;
          simple refine (path_sigma' _ _ _);
          [ apply path_arrow; intros y; apply path_hprop, equiv_iff_hprop;
            [ exact (fst (q y)) | exact (fst (p y)) ]
          | rewrite transport_sigma'; cbn;
            simple refine (path_sigma' _ _ _);
            [ apply path_arrow; intros y; apply path_hprop, equiv_iff_hprop;
              [ exact (snd (q y)) | exact (snd (p y)) ]
            | apply path_ishprop ] ] ).
    -
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo S) (xR : R -> GenNo S)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) (r : R),
         (fun dm ht : A =>
          forall y : No, ht.1 y -> (dm.2).1 y) (fxL l)
           (fxR r)) (L' R' : Type)
(s' : InSort S L' R') (yL : L' -> GenNo S)
(yR : R' -> GenNo S)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') (r : R'),
         (fun dm ht : A =>
          forall y : No, ht.1 y -> (dm.2).1 y) (fyL l)
           (fyR r)),
(forall l : L, xL l < {{ yL | yR // ycut }}) ->
(forall l : L,
 (fun dm ht : A => forall y : No, ht.1 y -> (dm.2).1 y)
   (fxL l)
   ((fun (L0 R0 : Type) (s0 : InSort S L0 R0)
       (xL0 : L0 -> GenNo S) (xR0 : R0 -> GenNo S)
       (xcut0 : forall (l0 : L0) (r : R0),
                xL0 l0 < xR0 r) (xL_let : L0 -> A)
       (xR_let : R0 -> A)
       (x_lt_le : forall (l0 : L0) (r : R0),
                  (fun dm ht : A =>
                   forall y : No, ht.1 y -> (dm.2).1 y)
                    (xL_let l0) (xR_let r)) =>
     let x := {{ xL0 | xR0 // xcut0 }} in
     (fun y : No =>
      fst (inner xL_let xR_let x_lt_le y).1;
     fun y : No =>
     snd (inner xL_let xR_let x_lt_le y).1;
     No_codes_package_subproof L0 R0 xL_let xR_let
       x_lt_le)) L' R' s' yL yR ycut fyL fyR fycut)) ->
(forall r : R', {{ xL | xR // xcut }} < yR r) ->
(forall r : R',
 (fun dm ht : A => forall y : No, ht.1 y -> (dm.2).1 y)
   ((fun (L0 R0 : Type) (s0 : InSort S L0 R0)
       (xL0 : L0 -> GenNo S) (xR0 : R0 -> GenNo S)
       (xcut0 : forall (l : L0) (r0 : R0),
                xL0 l < xR0 r0) (xL_let : L0 -> A)
       (xR_let : R0 -> A)
       (x_lt_le : forall (l : L0) (r0 : R0),
                  (fun dm ht : A =>
                   forall y : No, ht.1 y -> (dm.2).1 y)
                    (xL_let l) (xR_let r0)) =>
     let x := {{ xL0 | xR0 // xcut0 }} in
     (fun y : No =>
      fst (inner xL_let xR_let x_lt_le y).1;
     fun y : No =>
     snd (inner xL_let xR_let x_lt_le y).1;
     No_codes_package_subproof L0 R0 xL_let xR_let
       x_lt_le)) L R s xL xR xcut fxL fxR fxcut)
   (fyR r)) ->
(fun dm ht : A =>
 forall y : No,
 (ht.1 y -> dm.1 y) * ((ht.2).1 y -> (dm.2).1 y))
  ((fun (L0 R0 : Type) (s0 : InSort S L0 R0)
      (xL0 : L0 -> GenNo S) (xR0 : R0 -> GenNo S)
      (xcut0 : forall (l : L0) (r : R0), xL0 l < xR0 r)
      (xL_let : L0 -> A) (xR_let : R0 -> A)
      (x_lt_le : forall (l : L0) (r : R0),
                 (fun dm ht : A =>
                  forall y : No, ht.1 y -> (dm.2).1 y)
                   (xL_let l) (xR_let r)) =>
    let x := {{ xL0 | xR0 // xcut0 }} in
    (fun y : No =>
     fst (inner xL_let xR_let x_lt_le y).1;
    fun y : No =>
    snd (inner xL_let xR_let x_lt_le y).1;
    No_codes_package_subproof L0 R0 xL_let xR_let
      x_lt_le)) L R s xL xR xcut fxL fxR fxcut)
  ((fun (L0 R0 : Type) (s0 : InSort S L0 R0)
      (xL0 : L0 -> GenNo S) (xR0 : R0 -> GenNo S)
      (xcut0 : forall (l : L0) (r : R0), xL0 l < xR0 r)
      (xL_let : L0 -> A) (xR_let : R0 -> A)
      (x_lt_le : forall (l : L0) (r : R0),
                 (fun dm ht : A =>
                  forall y : No, ht.1 y -> (dm.2).1 y)
                   (xL_let l) (xR_let r)) =>
    let x := {{ xL0 | xR0 // xcut0 }} in
    (fun y : No =>
     fst (inner xL_let xR_let x_lt_le y).1;
    fun y : No =>
    snd (inner xL_let xR_let x_lt_le y).1;
    No_codes_package_subproof L0 R0 xL_let xR_let
      x_lt_le)) L' R' s' yL yR ycut fyL fyR fycut) abstract (
          intros L R ? xL xR xcut xL_let xR_let x_le_lt
                 L' R' ? yL yR ycut yL_let yR_let y_le_lt;
          set (x := {{ xL | xR // xcut }});
          set (y := {{ yL | yR // ycut }});
          cbn;
          intros xL_lt_y xL_lt_z x_lt_yR le_lt_y;
          refine (No_ind_hprop _ _);
          intros L'' R'' ? zL zR zcut zLH zRH; split;
          [ rewrite !inner_cut_le;
            intros y_le_z; split;
            [ intros l; refine (xL_lt_z l {{ zL | zR // zcut }} y_le_z)
            | intros r; refine (snd (zRH r) (snd y_le_z r)) ]
          | rewrite !inner_cut_lt;
            intros y_lt_z; strip_truncations;
            destruct y_lt_z as [[l y_le_zL]|[r yR_le_z]];
            [ apply tr; left; exact (l; fst (zLH l) y_le_zL)
            | refine (le_lt_y r {{ zL | zR // zcut }} yR_le_z) ]] ).
    -
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo S) (xR : R -> GenNo S)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) (r : R),
         (fun dm ht : A =>
          forall y : No, ht.1 y -> (dm.2).1 y) (fxL l)
           (fxR r)) (L' R' : Type)
(s' : InSort S L' R') (yL : L' -> GenNo S)
(yR : R' -> GenNo S)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') (r : R'),
         (fun dm ht : A =>
          forall y : No, ht.1 y -> (dm.2).1 y) (fyL l)
           (fyR r)) (l : L'),
{{ xL | xR // xcut }} <= yL l ->
(fun dm ht : A =>
 forall y : No,
 (ht.1 y -> dm.1 y) * ((ht.2).1 y -> (dm.2).1 y))
  ((fun (L0 R0 : Type) (s0 : InSort S L0 R0)
      (xL0 : L0 -> GenNo S) (xR0 : R0 -> GenNo S)
      (xcut0 : forall (l0 : L0) (r : R0),
               xL0 l0 < xR0 r) (xL_let : L0 -> A)
      (xR_let : R0 -> A)
      (x_lt_le : forall (l0 : L0) (r : R0),
                 (fun dm ht : A =>
                  forall y : No, ht.1 y -> (dm.2).1 y)
                   (xL_let l0) (xR_let r)) =>
    let x := {{ xL0 | xR0 // xcut0 }} in
    (fun y : No =>
     fst (inner xL_let xR_let x_lt_le y).1;
    fun y : No =>
    snd (inner xL_let xR_let x_lt_le y).1;
    No_codes_package_subproof L0 R0 xL_let xR_let
      x_lt_le)) L R s xL xR xcut fxL fxR fxcut)
  (fyL l) ->
(fun dm ht : A => forall y : No, ht.1 y -> (dm.2).1 y)
  ((fun (L0 R0 : Type) (s0 : InSort S L0 R0)
      (xL0 : L0 -> GenNo S) (xR0 : R0 -> GenNo S)
      (xcut0 : forall (l0 : L0) (r : R0),
               xL0 l0 < xR0 r) (xL_let : L0 -> A)
      (xR_let : R0 -> A)
      (x_lt_le : forall (l0 : L0) (r : R0),
                 (fun dm ht : A =>
                  forall y : No, ht.1 y -> (dm.2).1 y)
                   (xL_let l0) (xR_let r)) =>
    let x := {{ xL0 | xR0 // xcut0 }} in
    (fun y : No =>
     fst (inner xL_let xR_let x_lt_le y).1;
    fun y : No =>
    snd (inner xL_let xR_let x_lt_le y).1;
    No_codes_package_subproof L0 R0 xL_let xR_let
      x_lt_le)) L R s xL xR xcut fxL fxR fxcut)
  ((fun (L0 R0 : Type) (s0 : InSort S L0 R0)
      (xL0 : L0 -> GenNo S) (xR0 : R0 -> GenNo S)
      (xcut0 : forall (l0 : L0) (r : R0),
               xL0 l0 < xR0 r) (xL_let : L0 -> A)
      (xR_let : R0 -> A)
      (x_lt_le : forall (l0 : L0) (r : R0),
                 (fun dm ht : A =>
                  forall y : No, ht.1 y -> (dm.2).1 y)
                   (xL_let l0) (xR_let r)) =>
    let x := {{ xL0 | xR0 // xcut0 }} in
    (fun y : No =>
     fst (inner xL_let xR_let x_lt_le y).1;
    fun y : No =>
    snd (inner xL_let xR_let x_lt_le y).1;
    No_codes_package_subproof L0 R0 xL_let xR_let
      x_lt_le)) L' R' s' yL yR ycut fyL fyR fycut) abstract (
          intros L R ? xL xR xcut xL_let xR_let x_le_lt
                 L' R' ? yL yR ycut yL_let yR_let y_le_lt;
          set (x := {{ xL | xR // xcut }});
          set (y := {{ yL | yR // ycut }});
          cbn; intros l x_le_yL zH;
          refine (No_ind_hprop _ _);
          intros L'' R'' ? zL zR zcut zLH zRH y_le_z;
          refine (snd (zH {{ zL | zR // zcut }}) _);
          rewrite inner_cut_le in y_le_z;
          exact (fst y_le_z l) ).
    -
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo S) (xR : R -> GenNo S)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> A) (fxR : R -> A)
(fxcut : forall (l : L) (r : R),
         (fun dm ht : A =>
          forall y : No, ht.1 y -> (dm.2).1 y) (fxL l)
           (fxR r)) (L' R' : Type)
(s' : InSort S L' R') (yL : L' -> GenNo S)
(yR : R' -> GenNo S)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> A) (fyR : R' -> A)
(fycut : forall (l : L') (r : R'),
         (fun dm ht : A =>
          forall y : No, ht.1 y -> (dm.2).1 y) (fyL l)
           (fyR r)) (r : R),
xR r <= {{ yL | yR // ycut }} ->
(fun dm ht : A =>
 forall y : No,
 (ht.1 y -> dm.1 y) * ((ht.2).1 y -> (dm.2).1 y))
  (fxR r)
  ((fun (L0 R0 : Type) (s0 : InSort S L0 R0)
      (xL0 : L0 -> GenNo S) (xR0 : R0 -> GenNo S)
      (xcut0 : forall (l : L0) (r0 : R0),
               xL0 l < xR0 r0) (xL_let : L0 -> A)
      (xR_let : R0 -> A)
      (x_lt_le : forall (l : L0) (r0 : R0),
                 (fun dm ht : A =>
                  forall y : No, ht.1 y -> (dm.2).1 y)
                   (xL_let l) (xR_let r0)) =>
    let x := {{ xL0 | xR0 // xcut0 }} in
    (fun y : No =>
     fst (inner xL_let xR_let x_lt_le y).1;
    fun y : No =>
    snd (inner xL_let xR_let x_lt_le y).1;
    No_codes_package_subproof L0 R0 xL_let xR_let
      x_lt_le)) L' R' s' yL yR ycut fyL fyR fycut) ->
(fun dm ht : A => forall y : No, ht.1 y -> (dm.2).1 y)
  ((fun (L0 R0 : Type) (s0 : InSort S L0 R0)
      (xL0 : L0 -> GenNo S) (xR0 : R0 -> GenNo S)
      (xcut0 : forall (l : L0) (r0 : R0),
               xL0 l < xR0 r0) (xL_let : L0 -> A)
      (xR_let : R0 -> A)
      (x_lt_le : forall (l : L0) (r0 : R0),
                 (fun dm ht : A =>
                  forall y : No, ht.1 y -> (dm.2).1 y)
                   (xL_let l) (xR_let r0)) =>
    let x := {{ xL0 | xR0 // xcut0 }} in
    (fun y : No =>
     fst (inner xL_let xR_let x_lt_le y).1;
    fun y : No =>
    snd (inner xL_let xR_let x_lt_le y).1;
    No_codes_package_subproof L0 R0 xL_let xR_let
      x_lt_le)) L R s xL xR xcut fxL fxR fxcut)
  ((fun (L0 R0 : Type) (s0 : InSort S L0 R0)
      (xL0 : L0 -> GenNo S) (xR0 : R0 -> GenNo S)
      (xcut0 : forall (l : L0) (r0 : R0),
               xL0 l < xR0 r0) (xL_let : L0 -> A)
      (xR_let : R0 -> A)
      (x_lt_le : forall (l : L0) (r0 : R0),
                 (fun dm ht : A =>
                  forall y : No, ht.1 y -> (dm.2).1 y)
                   (xL_let l) (xR_let r0)) =>
    let x := {{ xL0 | xR0 // xcut0 }} in
    (fun y : No =>
     fst (inner xL_let xR_let x_lt_le y).1;
    fun y : No =>
    snd (inner xL_let xR_let x_lt_le y).1;
    No_codes_package_subproof L0 R0 xL_let xR_let
      x_lt_le)) L' R' s' yL yR ycut fyL fyR fycut) abstract (
          intros L R ? xL xR xcut xL_let xR_let x_le_lt
                 L' R' ? yL yR ycut yL_let yR_let y_le_lt;
          set (x := {{ xL | xR // xcut }});
          set (y := {{ yL | yR // ycut }});
          cbn; intros r xR_le_y zH;
          refine (No_ind_hprop _ _);
          intros L'' R'' ? zL zR zcut zLH zRH y_le_z;
          rewrite inner_cut_lt;
          apply tr; right; exists r;
          refine (fst (zH {{ zL | zR // zcut }}) y_le_z) ).
  Defined.

  Definition le' (x y : No) : HProp
    := (No_codes_package.1 x).1 y.

  Definition lt' (x y : No) : HProp
    := (No_codes_package.1 x).2.1 y.

  Definition lt'_le' x y
  : lt' x y -> le' x y
    := (fst (fst (fst (No_codes_package.1 x).2.2)) y).

  Definition le_le'_trans x y z
  : x <= y -> le' y z -> le' x z
    := fun p q => (fst (fst (No_codes_package.2) x y p z) q).

  Definition le_lt'_trans x y z
  : x <= y -> lt' y z -> lt' x z
    := fun p q => (snd (fst (No_codes_package.2) x y p z) q).

  Definition lt_le'_trans x y z
  : x < y -> le' y z -> lt' x z
    := fun p q => (snd (No_codes_package.2) x y p z q).

  Definition le'_le_trans x y z
  :  le' x y -> y <= z -> le' x z
    := fun p q => (snd (fst (fst (No_codes_package.1 x).2.2)) y z p q).

  Definition le'_lt_trans x y z
  : le' x y -> y < z -> lt' x z
    := fun p q => (snd (fst (No_codes_package.1 x).2.2) y z p q).

  Definition lt'_le_trans x y z
  : lt' x y -> y <= z -> lt' x z
    := fun p q => (snd (No_codes_package.1 x).2.2 y z p q).

  (** These computation laws hold definitionally, but it takes Coq a little while to verify that.  Thus, we prove them once and then [rewrite] along them later, so we don't have to do the verification every time. *)
  Definition le'_cut
             (L R : Type) (s : InSort S L R)
             (xL : L -> No) (xR : R -> No)
             (xcut : forall (l : L) (r : R), xL l < xR r)
             (L' R' : Type) (s' : InSort S L' R')
             (yL : L' -> No) (yR : R' -> No)
             (ycut : forall (l : L') (r : R'), yL l < yR r)
  : le' {{xL | xR // xcut}} {{yL | yR // ycut}}
    = ((forall l, lt' (xL l) {{ yL | yR // ycut }}) *
       (forall r', lt' {{ xL | xR // xcut }} (yR r')))
        (** For some reason, Coq has a really hard time checking the version of this that asserts an equality in [HProp].  But fortunately, we only ever really need the equality of types. *)
        :> Type
    := 1.

  Definition lt'_cut
             (L R : Type) (s : InSort S L R)
             (xL : L -> No) (xR : R -> No)
             (xcut : forall (l : L) (r : R), xL l < xR r)
             (L' R' : Type) (s' : InSort S L' R')
             (yL : L' -> No) (yR : R' -> No)
             (ycut : forall (l : L') (r : R'), yL l < yR r)
  : lt' {{xL | xR // xcut}} {{yL | yR // ycut}}
    = (hor {l':L' & le' {{ xL | xR // xcut }} (yL l')}
                  {r:R   & le' (xR r) {{ yL | yR // ycut }} })
    := 1.

  Definition No_encode_le_lt (x y : No)
  : ((x <= y) -> (le' x y)) * ((x < y) -> (lt' x y)).
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
(x <= y -> le' x y) * (x < y -> lt' x y)
  Proof.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
(x <= y -> le' x y) * (x < y -> lt' x y)
    refine (No_ind_le_lt (fun _ => Unit)
                         (fun x y _ _ _ => le' x y)
                         (fun x y _ _ _ => lt' x y)
                         _ _ _ _ _ x y).
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
forall L R : Type,
InSort S L R ->
forall (xL : L -> GenNo S) (xR : R -> GenNo S),
(forall (l : L) (r : R), xL l < xR r) ->
(L -> Unit) ->
(R -> Unit) ->
(forall (l : L) (r : R), lt' (xL l) (xR r)) -> Unit
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
forall (x y : GenNo S) (a b : Unit) (p : x <= y)
(q : y <= x),
le' x y ->
le' y x ->
transport (fun _ : GenNo S => Unit) (path_No x y p q)
  a = b
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo S) (xR : R -> GenNo S)
(xcut : forall (l : L) (r : R), xL l < xR r),
(L -> Unit) ->
(R -> Unit) ->
(forall (l : L) (r : R), lt' (xL l) (xR r)) ->
forall (L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo S) (yR : R' -> GenNo S)
(ycut : forall (l : L') (r : R'), yL l < yR r),
(L' -> Unit) ->
(R' -> Unit) ->
(forall (l : L') (r : R'), lt' (yL l) (yR r)) ->
(forall l : L, xL l < {{ yL | yR // ycut }}) ->
(forall l : L, lt' (xL l) {{ yL | yR // ycut }}) ->
(forall r : R', {{ xL | xR // xcut }} < yR r) ->
(forall r : R', lt' {{ xL | xR // xcut }} (yR r)) ->
le' {{ xL | xR // xcut }} {{ yL | yR // ycut }}
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo S) (xR : R -> GenNo S)
(xcut : forall (l : L) (r : R), xL l < xR r),
(L -> Unit) ->
(R -> Unit) ->
(forall (l : L) (r : R), lt' (xL l) (xR r)) ->
forall (L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo S) (yR : R' -> GenNo S)
(ycut : forall (l : L') (r : R'), yL l < yR r),
(L' -> Unit) ->
(R' -> Unit) ->
(forall (l : L') (r : R'), lt' (yL l) (yR r)) ->
forall l : L',
{{ xL | xR // xcut }} <= yL l ->
le' {{ xL | xR // xcut }} (yL l) ->
lt' {{ xL | xR // xcut }} {{ yL | yR // ycut }}
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo S) (xR : R -> GenNo S)
(xcut : forall (l : L) (r : R), xL l < xR r),
(L -> Unit) ->
(R -> Unit) ->
(forall (l : L) (r : R), lt' (xL l) (xR r)) ->
forall (L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo S) (yR : R' -> GenNo S)
(ycut : forall (l : L') (r : R'), yL l < yR r),
(L' -> Unit) ->
(R' -> Unit) ->
(forall (l : L') (r : R'), lt' (yL l) (yR r)) ->
forall r : R,
xR r <= {{ yL | yR // ycut }} ->
le' (xR r) {{ yL | yR // ycut }} ->
lt' {{ xL | xR // xcut }} {{ yL | yR // ycut }}
    +
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
forall L R : Type,
InSort S L R ->
forall (xL : L -> GenNo S) (xR : R -> GenNo S),
(forall (l : L) (r : R), xL l < xR r) ->
(L -> Unit) ->
(R -> Unit) ->
(forall (l : L) (r : R), lt' (xL l) (xR r)) -> Unit intros; exact tt.
    +
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
forall (x y : GenNo S) (a b : Unit) (p : x <= y)
(q : y <= x),
le' x y ->
le' y x ->
transport (fun _ : GenNo S => Unit) (path_No x y p q)
  a = b intros; apply path_contr.
    +
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo S) (xR : R -> GenNo S)
(xcut : forall (l : L) (r : R), xL l < xR r),
(L -> Unit) ->
(R -> Unit) ->
(forall (l : L) (r : R), lt' (xL l) (xR r)) ->
forall (L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo S) (yR : R' -> GenNo S)
(ycut : forall (l : L') (r : R'), yL l < yR r),
(L' -> Unit) ->
(R' -> Unit) ->
(forall (l : L') (r : R'), lt' (yL l) (yR r)) ->
(forall l : L, xL l < {{ yL | yR // ycut }}) ->
(forall l : L, lt' (xL l) {{ yL | yR // ycut }}) ->
(forall r : R', {{ xL | xR // xcut }} < yR r) ->
(forall r : R', lt' {{ xL | xR // xcut }} (yR r)) ->
le' {{ xL | xR // xcut }} {{ yL | yR // ycut }} intros L R ? xL xR xcut _ _ xcut'
             L' R' ? yL yR ycut _ _ ycut'
             xL_lt_y xL_lt_y' x_lt_yR x_lt_yR'.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xcut': forall (l : L) (r : R), lt' (xL l) (xR r)
L', R': Type
s': InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
ycut': forall (l : L') (r : R'), lt' (yL l) (yR r)
xL_lt_y: forall l : L, xL l < {{ yL | yR // ycut }}
xL_lt_y': forall l : L,
lt' (xL l) {{ yL | yR // ycut }}
x_lt_yR: forall r : R', {{ xL | xR // xcut }} < yR r
x_lt_yR': forall r : R',
lt' {{ xL | xR // xcut }} (yR r)
le' {{ xL | xR // xcut }} {{ yL | yR // ycut }}
      rewrite le'_cut.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xcut': forall (l : L) (r : R), lt' (xL l) (xR r)
L', R': Type
s': InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
ycut': forall (l : L') (r : R'), lt' (yL l) (yR r)
xL_lt_y: forall l : L, xL l < {{ yL | yR // ycut }}
xL_lt_y': forall l : L,
lt' (xL l) {{ yL | yR // ycut }}
x_lt_yR: forall r : R', {{ xL | xR // xcut }} < yR r
x_lt_yR': forall r : R',
lt' {{ xL | xR // xcut }} (yR r)
(forall l : L, lt' (xL l) {{ yL | yR // ycut }}) *
(forall r' : R', lt' {{ xL | xR // xcut }} (yR r'))
      exact (xL_lt_y' , x_lt_yR').
    +
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo S) (xR : R -> GenNo S)
(xcut : forall (l : L) (r : R), xL l < xR r),
(L -> Unit) ->
(R -> Unit) ->
(forall (l : L) (r : R), lt' (xL l) (xR r)) ->
forall (L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo S) (yR : R' -> GenNo S)
(ycut : forall (l : L') (r : R'), yL l < yR r),
(L' -> Unit) ->
(R' -> Unit) ->
(forall (l : L') (r : R'), lt' (yL l) (yR r)) ->
forall l : L',
{{ xL | xR // xcut }} <= yL l ->
le' {{ xL | xR // xcut }} (yL l) ->
lt' {{ xL | xR // xcut }} {{ yL | yR // ycut }} intros L R ? xL xR xcut _ _ xcut'
             L' R' ? yL yR ycut _ _ ycut'
             l x_le_yL x_le_yL'.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xcut': forall (l : L) (r : R), lt' (xL l) (xR r)
L', R': Type
s': InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
ycut': forall (l : L') (r : R'), lt' (yL l) (yR r)
l: L'
x_le_yL: {{ xL | xR // xcut }} <= yL l
x_le_yL': le' {{ xL | xR // xcut }} (yL l)
lt' {{ xL | xR // xcut }} {{ yL | yR // ycut }}
      rewrite lt'_cut.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xcut': forall (l : L) (r : R), lt' (xL l) (xR r)
L', R': Type
s': InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
ycut': forall (l : L') (r : R'), lt' (yL l) (yR r)
l: L'
x_le_yL: {{ xL | xR // xcut }} <= yL l
x_le_yL': le' {{ xL | xR // xcut }} (yL l)
hor {l' : L' & le' {{ xL | xR // xcut }} (yL l')}
  {r : R & le' (xR r) {{ yL | yR // ycut }}}
      apply tr; left.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xcut': forall (l : L) (r : R), lt' (xL l) (xR r)
L', R': Type
s': InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
ycut': forall (l : L') (r : R'), lt' (yL l) (yR r)
l: L'
x_le_yL: {{ xL | xR // xcut }} <= yL l
x_le_yL': le' {{ xL | xR // xcut }} (yL l)
{l' : L' & le' {{ xL | xR // xcut }} (yL l')} exists l.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xcut': forall (l : L) (r : R), lt' (xL l) (xR r)
L', R': Type
s': InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
ycut': forall (l : L') (r : R'), lt' (yL l) (yR r)
l: L'
x_le_yL: {{ xL | xR // xcut }} <= yL l
x_le_yL': le' {{ xL | xR // xcut }} (yL l)
le' {{ xL | xR // xcut }} (yL l) exact x_le_yL'.
    +
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo S) (xR : R -> GenNo S)
(xcut : forall (l : L) (r : R), xL l < xR r),
(L -> Unit) ->
(R -> Unit) ->
(forall (l : L) (r : R), lt' (xL l) (xR r)) ->
forall (L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo S) (yR : R' -> GenNo S)
(ycut : forall (l : L') (r : R'), yL l < yR r),
(L' -> Unit) ->
(R' -> Unit) ->
(forall (l : L') (r : R'), lt' (yL l) (yR r)) ->
forall r : R,
xR r <= {{ yL | yR // ycut }} ->
le' (xR r) {{ yL | yR // ycut }} ->
lt' {{ xL | xR // xcut }} {{ yL | yR // ycut }} intros L R ? xL xR xcut _ _ xcut'
             L' R' ? yL yR ycut _ _ ycut'
             r xR_le_y xR_le_y'.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xcut': forall (l : L) (r : R), lt' (xL l) (xR r)
L', R': Type
s': InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
ycut': forall (l : L') (r : R'), lt' (yL l) (yR r)
r: R
xR_le_y: xR r <= {{ yL | yR // ycut }}
xR_le_y': le' (xR r) {{ yL | yR // ycut }}
lt' {{ xL | xR // xcut }} {{ yL | yR // ycut }}
      rewrite lt'_cut.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xcut': forall (l : L) (r : R), lt' (xL l) (xR r)
L', R': Type
s': InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
ycut': forall (l : L') (r : R'), lt' (yL l) (yR r)
r: R
xR_le_y: xR r <= {{ yL | yR // ycut }}
xR_le_y': le' (xR r) {{ yL | yR // ycut }}
hor {l' : L' & le' {{ xL | xR // xcut }} (yL l')}
  {r : R & le' (xR r) {{ yL | yR // ycut }}}
      apply tr; right.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xcut': forall (l : L) (r : R), lt' (xL l) (xR r)
L', R': Type
s': InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
ycut': forall (l : L') (r : R'), lt' (yL l) (yR r)
r: R
xR_le_y: xR r <= {{ yL | yR // ycut }}
xR_le_y': le' (xR r) {{ yL | yR // ycut }}
{r : R & le' (xR r) {{ yL | yR // ycut }}} exists r.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xcut': forall (l : L) (r : R), lt' (xL l) (xR r)
L', R': Type
s': InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
ycut': forall (l : L') (r : R'), lt' (yL l) (yR r)
r: R
xR_le_y: xR r <= {{ yL | yR // ycut }}
xR_le_y': le' (xR r) {{ yL | yR // ycut }}
le' (xR r) {{ yL | yR // ycut }} exact xR_le_y'.
  Qed.

  Definition No_decode_le_lt (x y : No)
  : ((le' x y) -> (x <= y)) * ((lt' x y) -> (x < y)).
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
(le' x y -> x <= y) * (lt' x y -> x < y)
  Proof.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
(le' x y -> x <= y) * (lt' x y -> x < y)
    revert x y.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
forall x y : No,
(le' x y -> x <= y) * (lt' x y -> x < y)
    refine (No_ind_hprop _ _); intros L R ? xL xR xcut xHL xHR.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xHL: forall (l : L) (y : No),
(le' (xL l) y -> xL l <= y) *
(lt' (xL l) y -> xL l < y)
xHR: forall (r : R) (y : No),
(le' (xR r) y -> xR r <= y) *
(lt' (xR r) y -> xR r < y)
forall y : No,
(le' {{ xL | xR // xcut }} y ->
 {{ xL | xR // xcut }} <= y) *
(lt' {{ xL | xR // xcut }} y ->
 {{ xL | xR // xcut }} < y)
    nrefine (No_ind_hprop _ _).
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xHL: forall (l : L) (y : No),
(le' (xL l) y -> xL l <= y) *
(lt' (xL l) y -> xL l < y)
xHR: forall (r : R) (y : No),
(le' (xR r) y -> xR r <= y) *
(lt' (xR r) y -> xR r < y)
forall x : GenNo S,
IsHProp
  ((le' {{ xL | xR // xcut }} x ->
    {{ xL | xR // xcut }} <= x) *
   (lt' {{ xL | xR // xcut }} x ->
    {{ xL | xR // xcut }} < x))
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xHL: forall (l : L) (y : No),
(le' (xL l) y -> xL l <= y) *
(lt' (xL l) y -> xL l < y)
xHR: forall (r : R) (y : No),
(le' (xR r) y -> xR r <= y) *
(lt' (xR r) y -> xR r < y)
forall (L0 R0 : Type) (s0 : InSort S L0 R0)
(xL0 : L0 -> GenNo S) (xR0 : R0 -> GenNo S)
(xcut0 : forall (l : L0) (r : R0), xL0 l < xR0 r),
(forall l : L0,
 (le' {{ xL | xR // xcut }} (xL0 l) ->
  {{ xL | xR // xcut }} <= xL0 l) *
 (lt' {{ xL | xR // xcut }} (xL0 l) ->
  {{ xL | xR // xcut }} < xL0 l)) ->
(forall r : R0,
 (le' {{ xL | xR // xcut }} (xR0 r) ->
  {{ xL | xR // xcut }} <= xR0 r) *
 (lt' {{ xL | xR // xcut }} (xR0 r) ->
  {{ xL | xR // xcut }} < xR0 r)) ->
(le' {{ xL | xR // xcut }} {{ xL0 | xR0 // xcut0 }} ->
 {{ xL | xR // xcut }} <= {{ xL0 | xR0 // xcut0 }}) *
(lt' {{ xL | xR // xcut }} {{ xL0 | xR0 // xcut0 }} ->
 {{ xL | xR // xcut }} < {{ xL0 | xR0 // xcut0 }})
    (* Coq can find this proof by typeclass search, but helping it out makes this faster. *)
    {
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xHL: forall (l : L) (y : No),
(le' (xL l) y -> xL l <= y) *
(lt' (xL l) y -> xL l < y)
xHR: forall (r : R) (y : No),
(le' (xR r) y -> xR r <= y) *
(lt' (xR r) y -> xR r < y)
forall x : GenNo S,
IsHProp
  ((le' {{ xL | xR // xcut }} x ->
    {{ xL | xR // xcut }} <= x) *
   (lt' {{ xL | xR // xcut }} x ->
    {{ xL | xR // xcut }} < x)) intro x; nrapply istrunc_prod; nrapply istrunc_arrow; exact _. }
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xHL: forall (l : L) (y : No),
(le' (xL l) y -> xL l <= y) *
(lt' (xL l) y -> xL l < y)
xHR: forall (r : R) (y : No),
(le' (xR r) y -> xR r <= y) *
(lt' (xR r) y -> xR r < y)
forall (L0 R0 : Type) (s0 : InSort S L0 R0)
(xL0 : L0 -> GenNo S) (xR0 : R0 -> GenNo S)
(xcut0 : forall (l : L0) (r : R0), xL0 l < xR0 r),
(forall l : L0,
 (le' {{ xL | xR // xcut }} (xL0 l) ->
  {{ xL | xR // xcut }} <= xL0 l) *
 (lt' {{ xL | xR // xcut }} (xL0 l) ->
  {{ xL | xR // xcut }} < xL0 l)) ->
(forall r : R0,
 (le' {{ xL | xR // xcut }} (xR0 r) ->
  {{ xL | xR // xcut }} <= xR0 r) *
 (lt' {{ xL | xR // xcut }} (xR0 r) ->
  {{ xL | xR // xcut }} < xR0 r)) ->
(le' {{ xL | xR // xcut }} {{ xL0 | xR0 // xcut0 }} ->
 {{ xL | xR // xcut }} <= {{ xL0 | xR0 // xcut0 }}) *
(lt' {{ xL | xR // xcut }} {{ xL0 | xR0 // xcut0 }} ->
 {{ xL | xR // xcut }} < {{ xL0 | xR0 // xcut0 }})
    intros L' R' ? yL yR ycut yHL yHR.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xHL: forall (l : L) (y : No),
(le' (xL l) y -> xL l <= y) *
(lt' (xL l) y -> xL l < y)
xHR: forall (r : R) (y : No),
(le' (xR r) y -> xR r <= y) *
(lt' (xR r) y -> xR r < y)
L', R': Type
s0: InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
yHL: forall l : L',
(le' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} <= yL l) *
(lt' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} < yL l)
yHR: forall r : R',
(le' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} <= yR r) *
(lt' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} < yR r)
(le' {{ xL | xR // xcut }} {{ yL | yR // ycut }} ->
 {{ xL | xR // xcut }} <= {{ yL | yR // ycut }}) *
(lt' {{ xL | xR // xcut }} {{ yL | yR // ycut }} ->
 {{ xL | xR // xcut }} < {{ yL | yR // ycut }}) split.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xHL: forall (l : L) (y : No),
(le' (xL l) y -> xL l <= y) *
(lt' (xL l) y -> xL l < y)
xHR: forall (r : R) (y : No),
(le' (xR r) y -> xR r <= y) *
(lt' (xR r) y -> xR r < y)
L', R': Type
s0: InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
yHL: forall l : L',
(le' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} <= yL l) *
(lt' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} < yL l)
yHR: forall r : R',
(le' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} <= yR r) *
(lt' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} < yR r)
le' {{ xL | xR // xcut }} {{ yL | yR // ycut }} ->
{{ xL | xR // xcut }} <= {{ yL | yR // ycut }}
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xHL: forall (l : L) (y : No),
(le' (xL l) y -> xL l <= y) *
(lt' (xL l) y -> xL l < y)
xHR: forall (r : R) (y : No),
(le' (xR r) y -> xR r <= y) *
(lt' (xR r) y -> xR r < y)
L', R': Type
s0: InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
yHL: forall l : L',
(le' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} <= yL l) *
(lt' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} < yL l)
yHR: forall r : R',
(le' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} <= yR r) *
(lt' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} < yR r)
lt' {{ xL | xR // xcut }} {{ yL | yR // ycut }} ->
{{ xL | xR // xcut }} < {{ yL | yR // ycut }}
    -
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xHL: forall (l : L) (y : No),
(le' (xL l) y -> xL l <= y) *
(lt' (xL l) y -> xL l < y)
xHR: forall (r : R) (y : No),
(le' (xR r) y -> xR r <= y) *
(lt' (xR r) y -> xR r < y)
L', R': Type
s0: InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
yHL: forall l : L',
(le' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} <= yL l) *
(lt' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} < yL l)
yHR: forall r : R',
(le' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} <= yR r) *
(lt' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} < yR r)
le' {{ xL | xR // xcut }} {{ yL | yR // ycut }} ->
{{ xL | xR // xcut }} <= {{ yL | yR // ycut }} intros x_le_y.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xHL: forall (l : L) (y : No),
(le' (xL l) y -> xL l <= y) *
(lt' (xL l) y -> xL l < y)
xHR: forall (r : R) (y : No),
(le' (xR r) y -> xR r <= y) *
(lt' (xR r) y -> xR r < y)
L', R': Type
s0: InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
yHL: forall l : L',
(le' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} <= yL l) *
(lt' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} < yL l)
yHR: forall r : R',
(le' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} <= yR r) *
(lt' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} < yR r)
x_le_y: le' {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
{{ xL | xR // xcut }} <= {{ yL | yR // ycut }}
      rewrite le'_cut in x_le_y.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xHL: forall (l : L) (y : No),
(le' (xL l) y -> xL l <= y) *
(lt' (xL l) y -> xL l < y)
xHR: forall (r : R) (y : No),
(le' (xR r) y -> xR r <= y) *
(lt' (xR r) y -> xR r < y)
L', R': Type
s0: InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
yHL: forall l : L',
(le' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} <= yL l) *
(lt' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} < yL l)
yHR: forall r : R',
(le' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} <= yR r) *
(lt' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} < yR r)
x_le_y: (forall l : L,
 lt' (xL l) {{ yL | yR // ycut }}) *
(forall r' : R',
 lt' {{ xL | xR // xcut }} (yR r'))
{{ xL | xR // xcut }} <= {{ yL | yR // ycut }}
      exact (le_lr xL xR xcut yL yR ycut
                   (fun l => snd (xHL l _) (fst x_le_y l))
                   (fun r => snd (yHR r) (snd x_le_y r))).
    -
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xHL: forall (l : L) (y : No),
(le' (xL l) y -> xL l <= y) *
(lt' (xL l) y -> xL l < y)
xHR: forall (r : R) (y : No),
(le' (xR r) y -> xR r <= y) *
(lt' (xR r) y -> xR r < y)
L', R': Type
s0: InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
yHL: forall l : L',
(le' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} <= yL l) *
(lt' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} < yL l)
yHR: forall r : R',
(le' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} <= yR r) *
(lt' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} < yR r)
lt' {{ xL | xR // xcut }} {{ yL | yR // ycut }} ->
{{ xL | xR // xcut }} < {{ yL | yR // ycut }} intros x_lt_y.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xHL: forall (l : L) (y : No),
(le' (xL l) y -> xL l <= y) *
(lt' (xL l) y -> xL l < y)
xHR: forall (r : R) (y : No),
(le' (xR r) y -> xR r <= y) *
(lt' (xR r) y -> xR r < y)
L', R': Type
s0: InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
yHL: forall l : L',
(le' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} <= yL l) *
(lt' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} < yL l)
yHR: forall r : R',
(le' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} <= yR r) *
(lt' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} < yR r)
x_lt_y: lt' {{ xL | xR // xcut }}
  {{ yL | yR // ycut }}
{{ xL | xR // xcut }} < {{ yL | yR // ycut }}
      rewrite lt'_cut in x_lt_y.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xHL: forall (l : L) (y : No),
(le' (xL l) y -> xL l <= y) *
(lt' (xL l) y -> xL l < y)
xHR: forall (r : R) (y : No),
(le' (xR r) y -> xR r <= y) *
(lt' (xR r) y -> xR r < y)
L', R': Type
s0: InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
yHL: forall l : L',
(le' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} <= yL l) *
(lt' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} < yL l)
yHR: forall r : R',
(le' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} <= yR r) *
(lt' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} < yR r)
x_lt_y: hor
  {l' : L' &
  le' {{ xL | xR // xcut }} (yL l')}
  {r : R & le' (xR r) {{ yL | yR // ycut }}}
{{ xL | xR // xcut }} < {{ yL | yR // ycut }}
      strip_truncations; destruct x_lt_y as [[l x_le_yL]|[r xR_le_y]].
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xHL: forall (l : L) (y : No),
(le' (xL l) y -> xL l <= y) *
(lt' (xL l) y -> xL l < y)
xHR: forall (r : R) (y : No),
(le' (xR r) y -> xR r <= y) *
(lt' (xR r) y -> xR r < y)
L', R': Type
s0: InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
yHL: forall l : L',
(le' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} <= yL l) *
(lt' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} < yL l)
yHR: forall r : R',
(le' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} <= yR r) *
(lt' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} < yR r)
l: L'
x_le_yL: le' {{ xL | xR // xcut }} (yL l)
{{ xL | xR // xcut }} < {{ yL | yR // ycut }}
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xHL: forall (l : L) (y : No),
(le' (xL l) y -> xL l <= y) *
(lt' (xL l) y -> xL l < y)
xHR: forall (r : R) (y : No),
(le' (xR r) y -> xR r <= y) *
(lt' (xR r) y -> xR r < y)
L', R': Type
s0: InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
yHL: forall l : L',
(le' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} <= yL l) *
(lt' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} < yL l)
yHR: forall r : R',
(le' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} <= yR r) *
(lt' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} < yR r)
r: R
xR_le_y: le' (xR r) {{ yL | yR // ycut }}
{{ xL | xR // xcut }} < {{ yL | yR // ycut }}
      +
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xHL: forall (l : L) (y : No),
(le' (xL l) y -> xL l <= y) *
(lt' (xL l) y -> xL l < y)
xHR: forall (r : R) (y : No),
(le' (xR r) y -> xR r <= y) *
(lt' (xR r) y -> xR r < y)
L', R': Type
s0: InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
yHL: forall l : L',
(le' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} <= yL l) *
(lt' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} < yL l)
yHR: forall r : R',
(le' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} <= yR r) *
(lt' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} < yR r)
l: L'
x_le_yL: le' {{ xL | xR // xcut }} (yL l)
{{ xL | xR // xcut }} < {{ yL | yR // ycut }} apply lt_l with l.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xHL: forall (l : L) (y : No),
(le' (xL l) y -> xL l <= y) *
(lt' (xL l) y -> xL l < y)
xHR: forall (r : R) (y : No),
(le' (xR r) y -> xR r <= y) *
(lt' (xR r) y -> xR r < y)
L', R': Type
s0: InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
yHL: forall l : L',
(le' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} <= yL l) *
(lt' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} < yL l)
yHR: forall r : R',
(le' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} <= yR r) *
(lt' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} < yR r)
l: L'
x_le_yL: le' {{ xL | xR // xcut }} (yL l)
{{ xL | xR // xcut }} <= yL l
        exact (fst (yHL l) x_le_yL).
      +
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xHL: forall (l : L) (y : No),
(le' (xL l) y -> xL l <= y) *
(lt' (xL l) y -> xL l < y)
xHR: forall (r : R) (y : No),
(le' (xR r) y -> xR r <= y) *
(lt' (xR r) y -> xR r < y)
L', R': Type
s0: InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
yHL: forall l : L',
(le' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} <= yL l) *
(lt' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} < yL l)
yHR: forall r : R',
(le' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} <= yR r) *
(lt' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} < yR r)
r: R
xR_le_y: le' (xR r) {{ yL | yR // ycut }}
{{ xL | xR // xcut }} < {{ yL | yR // ycut }} apply lt_r with r.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
xHL: forall (l : L) (y : No),
(le' (xL l) y -> xL l <= y) *
(lt' (xL l) y -> xL l < y)
xHR: forall (r : R) (y : No),
(le' (xR r) y -> xR r <= y) *
(lt' (xR r) y -> xR r < y)
L', R': Type
s0: InSort S L' R'
yL: L' -> GenNo S
yR: R' -> GenNo S
ycut: forall (l : L') (r : R'), yL l < yR r
yHL: forall l : L',
(le' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} <= yL l) *
(lt' {{ xL | xR // xcut }} (yL l) ->
 {{ xL | xR // xcut }} < yL l)
yHR: forall r : R',
(le' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} <= yR r) *
(lt' {{ xL | xR // xcut }} (yR r) ->
 {{ xL | xR // xcut }} < yR r)
r: R
xR_le_y: le' (xR r) {{ yL | yR // ycut }}
xR r <= {{ yL | yR // ycut }}
        exact (fst (xHR r _) xR_le_y).
  Qed.

  Definition No_encode_le x y := fst (No_encode_le_lt x y).
  Definition No_encode_lt x y := snd (No_encode_le_lt x y).
  Definition No_decode_le x y := fst (No_decode_le_lt x y).
  Definition No_decode_lt x y := snd (No_decode_le_lt x y).

  Corollary lt_le {x y : No} (p : x < y) : x <= y.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
p: x < y
x <= y
  Proof.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
p: x < y
x <= y
    apply No_decode_le.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
p: x < y
le' x y
    apply lt'_le'.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
p: x < y
lt' x y
    apply No_encode_lt.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y: No
p: x < y
x < y
    assumption.
  Qed.

  (** Conway's theorem 1 *)
  Corollary le_le_trans {x y z : No}
  : (x <= y) -> (y <= z) -> (x <= z).
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y, z: No
x <= y -> y <= z -> x <= z
  Proof.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y, z: No
x <= y -> y <= z -> x <= z
    intros p q.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y, z: No
p: x <= y
q: y <= z
x <= z
    apply No_decode_le.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y, z: No
p: x <= y
q: y <= z
le' x z
    refine (le_le'_trans x y z p _).
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y, z: No
p: x <= y
q: y <= z
le' y z
    apply No_encode_le.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y, z: No
p: x <= y
q: y <= z
y <= z
    assumption.
  Qed.

  Global Instance trans_le : Transitive le
    := @le_le_trans.

  Corollary le_lt_trans {x y z : No}
  : (x <= y) -> (y < z) -> (x < z).
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y, z: No
x <= y -> y < z -> x < z
  Proof.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y, z: No
x <= y -> y < z -> x < z
    intros p q.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y, z: No
p: x <= y
q: y < z
x < z
    apply No_decode_lt.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y, z: No
p: x <= y
q: y < z
lt' x z
    refine (le_lt'_trans x y z p _).
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y, z: No
p: x <= y
q: y < z
lt' y z
    apply No_encode_lt.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y, z: No
p: x <= y
q: y < z
y < z
    assumption.
  Qed.

  Corollary lt_le_trans {x y z : No}
  : (x < y) -> (y <= z) -> (x < z).
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y, z: No
x < y -> y <= z -> x < z
  Proof.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y, z: No
x < y -> y <= z -> x < z
    intros p q.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y, z: No
p: x < y
q: y <= z
x < z
    apply No_decode_lt.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y, z: No
p: x < y
q: y <= z
lt' x z
    refine (lt_le'_trans x y z p _).
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y, z: No
p: x < y
q: y <= z
le' y z
    apply No_encode_le.
H: Univalence
S: OptionSort
No:= GenNo S: Type
A:= {le'_x : No -> HProp &
{lt'_x : No -> HProp &
(forall y : No, lt'_x y -> le'_x y) *
(forall y z : No, le'_x y -> y <= z -> le'_x z) *
(forall y z : No, le'_x y -> y < z -> lt'_x z) *
(forall y z : No, lt'_x y -> y <= z -> lt'_x z)}}: Type
x, y, z: No
p: x < y
q: y <= z
y <= z
    assumption.
  Qed.

  Definition lt_lt_trans {x y z : No}
  : (x < y) -> (y < z) -> (x < z)
    := fun p q => lt_le_trans p (lt_le q).

  Global Instance trans_lt : Transitive lt
    := @lt_lt_trans.

End NoCodes.

(** ** Changing option sorts *)

(** There is of course a "maximal" option sort, which defines "the" surreal numbers as in the book. *)

Definition MaxSort : OptionSort := fun _ _ => Unit.
Definition No : Type := GenNo MaxSort.

(** This instance should be the one found by default, so that cuts live in [No] unless otherwise specified.  Thus, all other global instances of [InSort] should be declared with higher priority. *)
Global Instance insort_maxsort {L R : Type}
  : InSort MaxSort L R | 0
  := tt.

(** Furthermore, every other kind of surreal number *embeds* into the maximal ones.  So the other kinds of surreal numbers are really just subsets of the usual set of surreal numbers; but I don't know of a good way to define them except as their own HIITs. *)

Section RaiseSort.
  Context `{ua: Univalence} `{S : OptionSort}.

  Definition No_raise : GenNo S -> No.
ua: Univalence
S: OptionSort
GenNo S -> No
  Proof.
ua: Univalence
S: OptionSort
GenNo S -> No
    simple refine (No_rec No le lt _ _ _ _ _).
ua: Univalence
S: OptionSort
forall L R : Type,
InSort S L R ->
forall (xL : L -> GenNo S) (xR : R -> GenNo S),
(forall (l : L) (r : R), xL l < xR r) ->
forall (fxL : L -> No) (fxR : R -> No),
(forall (l : L) (r : R), fxL l < fxR r) -> No
ua: Univalence
S: OptionSort
forall a b : No, a <= b -> b <= a -> a = b
ua: Univalence
S: OptionSort
forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo S) (xR : R -> GenNo S)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> No) (fxR : R -> No)
(fxcut : forall (l : L) (r : R), fxL l < fxR r)
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo S) (yR : R' -> GenNo S)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> No) (fyR : R' -> No)
(fycut : forall (l : L') (r : R'), fyL l < fyR r),
(forall l : L, xL l < {{ yL | yR // ycut }}) ->
(forall l : L,
 fxL l < ?dcut L' R' s' yL yR ycut fyL fyR fycut) ->
(forall r : R', {{ xL | xR // xcut }} < yR r) ->
(forall r : R',
 ?dcut L R s xL xR xcut fxL fxR fxcut < fyR r) ->
?dcut L R s xL xR xcut fxL fxR fxcut <=
?dcut L' R' s' yL yR ycut fyL fyR fycut
ua: Univalence
S: OptionSort
forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo S) (xR : R -> GenNo S)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> No) (fxR : R -> No)
(fxcut : forall (l : L) (r : R), fxL l < fxR r)
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo S) (yR : R' -> GenNo S)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> No) (fyR : R' -> No)
(fycut : forall (l : L') (r : R'), fyL l < fyR r)
(l : L'),
{{ xL | xR // xcut }} <= yL l ->
?dcut L R s xL xR xcut fxL fxR fxcut <= fyL l ->
?dcut L R s xL xR xcut fxL fxR fxcut <
?dcut L' R' s' yL yR ycut fyL fyR fycut
ua: Univalence
S: OptionSort
forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo S) (xR : R -> GenNo S)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> No) (fxR : R -> No)
(fxcut : forall (l : L) (r : R), fxL l < fxR r)
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo S) (yR : R' -> GenNo S)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> No) (fyR : R' -> No)
(fycut : forall (l : L') (r : R'), fyL l < fyR r)
(r : R),
xR r <= {{ yL | yR // ycut }} ->
fxR r <= ?dcut L' R' s' yL yR ycut fyL fyR fycut ->
?dcut L R s xL xR xcut fxL fxR fxcut <
?dcut L' R' s' yL yR ycut fyL fyR fycut
    -
ua: Univalence
S: OptionSort
forall L R : Type,
InSort S L R ->
forall (xL : L -> GenNo S) (xR : R -> GenNo S),
(forall (l : L) (r : R), xL l < xR r) ->
forall (fxL : L -> No) (fxR : R -> No),
(forall (l : L) (r : R), fxL l < fxR r) -> No intros L R ? xL xR xcut fxL fxR fxcut.
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
fxL: L -> No
fxR: R -> No
fxcut: forall (l : L) (r : R), fxL l < fxR r
No
      exact {{ fxL | fxR // fxcut }}.
    -
ua: Univalence
S: OptionSort
forall a b : No, a <= b -> b <= a -> a = b apply path_No.
    -
ua: Univalence
S: OptionSort
forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo S) (xR : R -> GenNo S)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> No) (fxR : R -> No)
(fxcut : forall (l : L) (r : R), fxL l < fxR r)
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo S) (yR : R' -> GenNo S)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> No) (fyR : R' -> No)
(fycut : forall (l : L') (r : R'), fyL l < fyR r),
(forall l : L, xL l < {{ yL | yR // ycut }}) ->
(forall l : L,
 fxL l <
 (fun (L0 R0 : Type) (_ : InSort S L0 R0)
    (xL0 : L0 -> GenNo S) (xR0 : R0 -> GenNo S)
    (_ : forall (l0 : L0) (r : R0), xL0 l0 < xR0 r)
    (fxL0 : L0 -> No) (fxR0 : R0 -> No)
    (fxcut0 : forall (l0 : L0) (r : R0),
              fxL0 l0 < fxR0 r) =>
  {{ fxL0 | fxR0 // fxcut0 }}) L' R' s' yL yR ycut fyL
   fyR fycut) ->
(forall r : R', {{ xL | xR // xcut }} < yR r) ->
(forall r : R',
 (fun (L0 R0 : Type) (_ : InSort S L0 R0)
    (xL0 : L0 -> GenNo S) (xR0 : R0 -> GenNo S)
    (_ : forall (l : L0) (r0 : R0), xL0 l < xR0 r0)
    (fxL0 : L0 -> No) (fxR0 : R0 -> No)
    (fxcut0 : forall (l : L0) (r0 : R0),
              fxL0 l < fxR0 r0) =>
  {{ fxL0 | fxR0 // fxcut0 }}) L R s xL xR xcut fxL
   fxR fxcut < fyR r) ->
(fun (L0 R0 : Type) (_ : InSort S L0 R0)
   (xL0 : L0 -> GenNo S) (xR0 : R0 -> GenNo S)
   (_ : forall (l : L0) (r : R0), xL0 l < xR0 r)
   (fxL0 : L0 -> No) (fxR0 : R0 -> No)
   (fxcut0 : forall (l : L0) (r : R0), fxL0 l < fxR0 r)
 => {{ fxL0 | fxR0 // fxcut0 }}) L R s xL xR xcut fxL
  fxR fxcut <=
(fun (L0 R0 : Type) (_ : InSort S L0 R0)
   (xL0 : L0 -> GenNo S) (xR0 : R0 -> GenNo S)
   (_ : forall (l : L0) (r : R0), xL0 l < xR0 r)
   (fxL0 : L0 -> No) (fxR0 : R0 -> No)
   (fxcut0 : forall (l : L0) (r : R0), fxL0 l < fxR0 r)
 => {{ fxL0 | fxR0 // fxcut0 }}) L' R' s' yL yR ycut
  fyL fyR fycut intros; apply le_lr; assumption.
    -
ua: Univalence
S: OptionSort
forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo S) (xR : R -> GenNo S)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> No) (fxR : R -> No)
(fxcut : forall (l : L) (r : R), fxL l < fxR r)
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo S) (yR : R' -> GenNo S)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> No) (fyR : R' -> No)
(fycut : forall (l : L') (r : R'), fyL l < fyR r)
(l : L'),
{{ xL | xR // xcut }} <= yL l ->
(fun (L0 R0 : Type) (_ : InSort S L0 R0)
   (xL0 : L0 -> GenNo S) (xR0 : R0 -> GenNo S)
   (_ : forall (l0 : L0) (r : R0), xL0 l0 < xR0 r)
   (fxL0 : L0 -> No) (fxR0 : R0 -> No)
   (fxcut0 : forall (l0 : L0) (r : R0),
             fxL0 l0 < fxR0 r) =>
 {{ fxL0 | fxR0 // fxcut0 }}) L R s xL xR xcut fxL fxR
  fxcut <= fyL l ->
(fun (L0 R0 : Type) (_ : InSort S L0 R0)
   (xL0 : L0 -> GenNo S) (xR0 : R0 -> GenNo S)
   (_ : forall (l0 : L0) (r : R0), xL0 l0 < xR0 r)
   (fxL0 : L0 -> No) (fxR0 : R0 -> No)
   (fxcut0 : forall (l0 : L0) (r : R0),
             fxL0 l0 < fxR0 r) =>
 {{ fxL0 | fxR0 // fxcut0 }}) L R s xL xR xcut fxL fxR
  fxcut <
(fun (L0 R0 : Type) (_ : InSort S L0 R0)
   (xL0 : L0 -> GenNo S) (xR0 : R0 -> GenNo S)
   (_ : forall (l0 : L0) (r : R0), xL0 l0 < xR0 r)
   (fxL0 : L0 -> No) (fxR0 : R0 -> No)
   (fxcut0 : forall (l0 : L0) (r : R0),
             fxL0 l0 < fxR0 r) =>
 {{ fxL0 | fxR0 // fxcut0 }}) L' R' s' yL yR ycut fyL
  fyR fycut intros; apply lt_l with l; assumption.
    -
ua: Univalence
S: OptionSort
forall (L R : Type) (s : InSort S L R)
(xL : L -> GenNo S) (xR : R -> GenNo S)
(xcut : forall (l : L) (r : R), xL l < xR r)
(fxL : L -> No) (fxR : R -> No)
(fxcut : forall (l : L) (r : R), fxL l < fxR r)
(L' R' : Type) (s' : InSort S L' R')
(yL : L' -> GenNo S) (yR : R' -> GenNo S)
(ycut : forall (l : L') (r : R'), yL l < yR r)
(fyL : L' -> No) (fyR : R' -> No)
(fycut : forall (l : L') (r : R'), fyL l < fyR r)
(r : R),
xR r <= {{ yL | yR // ycut }} ->
fxR r <=
(fun (L0 R0 : Type) (_ : InSort S L0 R0)
   (xL0 : L0 -> GenNo S) (xR0 : R0 -> GenNo S)
   (_ : forall (l : L0) (r0 : R0), xL0 l < xR0 r0)
   (fxL0 : L0 -> No) (fxR0 : R0 -> No)
   (fxcut0 : forall (l : L0) (r0 : R0),
             fxL0 l < fxR0 r0) =>
 {{ fxL0 | fxR0 // fxcut0 }}) L' R' s' yL yR ycut fyL
  fyR fycut ->
(fun (L0 R0 : Type) (_ : InSort S L0 R0)
   (xL0 : L0 -> GenNo S) (xR0 : R0 -> GenNo S)
   (_ : forall (l : L0) (r0 : R0), xL0 l < xR0 r0)
   (fxL0 : L0 -> No) (fxR0 : R0 -> No)
   (fxcut0 : forall (l : L0) (r0 : R0),
             fxL0 l < fxR0 r0) =>
 {{ fxL0 | fxR0 // fxcut0 }}) L R s xL xR xcut fxL fxR
  fxcut <
(fun (L0 R0 : Type) (_ : InSort S L0 R0)
   (xL0 : L0 -> GenNo S) (xR0 : R0 -> GenNo S)
   (_ : forall (l : L0) (r0 : R0), xL0 l < xR0 r0)
   (fxL0 : L0 -> No) (fxR0 : R0 -> No)
   (fxcut0 : forall (l : L0) (r0 : R0),
             fxL0 l < fxR0 r0) =>
 {{ fxL0 | fxR0 // fxcut0 }}) L' R' s' yL yR ycut fyL
  fyR fycut intros; apply lt_r with r; assumption.
  Defined.

  (** See discussion at [plus_inner_cut] in [Addition.v]. *)
  Definition No_raise_cut
             {L R : Type} {s : InSort S L R}
             (xL : L -> GenNo S) (xR : R -> GenNo S)
             (xcut : forall l r, xL l < xR r)
    : { rxcut : forall l r, No_raise (xL l) < No_raise (xR r) &
        No_raise {{ xL | xR // xcut }} =
        {{ (fun l => No_raise (xL l)) | (fun r => No_raise (xR r)) // rxcut }} }.
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
{rxcut
: forall (l : L) (r : R),
  No_raise (xL l) < No_raise (xR r) &
No_raise {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | (fun r : R =>
                                   No_raise (xR r)) // rxcut }}}
  Proof.
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
{rxcut
: forall (l : L) (r : R),
  No_raise (xL l) < No_raise (xR r) &
No_raise {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | (fun r : R =>
                                   No_raise (xR r)) // rxcut }}}
    eexists.
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
No_raise {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | (fun r : R =>
                                   No_raise (xR r)) // 
?rxcut }}
    (* Manual rewrite instead of letting unification handle it as it would expose the case analysis on the private type. *)
    unfold No_raise at 1.
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
No_rec No le lt
  (fun (L R : Type) (_ : InSort S L R)
     (xL : L -> GenNo S) (xR : R -> GenNo S)
     (_ : forall (l : L) (r : R), xL l < xR r)
     (fxL : L -> No) (fxR : R -> No)
     (fxcut : forall (l : L) (r : R), fxL l < fxR r)
   => {{ fxL | fxR // fxcut }}) path_No
  (fun (L R : Type) (s : InSort S L R)
     (xL : L -> GenNo S) (xR : R -> GenNo S)
     (xcut : forall (l : L) (r : R), xL l < xR r)
     (fxL : L -> No) (fxR : R -> No)
     (fxcut : forall (l : L) (r : R), fxL l < fxR r)
     (L' R' : Type) (s' : InSort S L' R')
     (yL : L' -> GenNo S) (yR : R' -> GenNo S)
     (ycut : forall (l : L') (r : R'), yL l < yR r)
     (fyL : L' -> No) (fyR : R' -> No)
     (fycut : forall (l : L') (r : R'), fyL l < fyR r)
     (_ : forall l : L, xL l < {{ yL | yR // ycut }})
     (dp : forall l : L,
           fxL l < {{ fyL | fyR // fycut }})
     (_ : forall r : R', {{ xL | xR // xcut }} < yR r)
     (dq : forall r : R',
           {{ fxL | fxR // fxcut }} < fyR r) =>
   le_lr fxL fxR fxcut fyL fyR fycut dp dq)
  (fun (L R : Type) (s : InSort S L R)
     (xL : L -> GenNo S) (xR : R -> GenNo S)
     (xcut : forall (l : L) (r : R), xL l < xR r)
     (fxL : L -> No) (fxR : R -> No)
     (fxcut : forall (l : L) (r : R), fxL l < fxR r)
     (L' R' : Type) (_ : InSort S L' R')
     (yL : L' -> GenNo S) (yR : R' -> GenNo S)
     (_ : forall (l : L') (r : R'), yL l < yR r)
     (fyL : L' -> No) (fyR : R' -> No)
     (fycut : forall (l : L') (r : R'), fyL l < fyR r)
     (l : L') (_ : {{ xL | xR // xcut }} <= yL l)
     (dp : {{ fxL | fxR // fxcut }} <= fyL l) =>
   lt_l fxL fxR fxcut fyL fyR fycut l dp)
  (fun (L R : Type) (_ : InSort S L R)
     (xL : L -> GenNo S) (xR : R -> GenNo S)
     (_ : forall (l : L) (r : R), xL l < xR r)
     (fxL : L -> No) (fxR : R -> No)
     (fxcut : forall (l : L) (r : R), fxL l < fxR r)
     (L' R' : Type) (s' : InSort S L' R')
     (yL : L' -> GenNo S) (yR : R' -> GenNo S)
     (ycut : forall (l : L') (r : R'), yL l < yR r)
     (fyL : L' -> No) (fyR : R' -> No)
     (fycut : forall (l : L') (r : R'), fyL l < fyR r)
     (r : R) (_ : xR r <= {{ yL | yR // ycut }})
     (dp : fxR r <= {{ fyL | fyR // fycut }}) =>
   lt_r fxL fxR fxcut fyL fyR fycut r dp)
  {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | (fun r : R =>
                                   No_raise (xR r)) // 
?rxcut }}
    rewrite No_rec_cut.
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
{{ fun l : L =>
   No_rec No le lt
     (fun (L R : Type) (_ : InSort S L R)
        (xL : L -> GenNo S) (xR : R -> GenNo S)
        (_ : forall (l0 : L) (r : R), xL l0 < xR r)
        (fxL : L -> No) (fxR : R -> No)
        (fxcut : forall (l0 : L) (r : R),
                 fxL l0 < fxR r) =>
      {{ fxL | fxR // fxcut }}) path_No
     (fun (L R : Type) (s : InSort S L R)
        (xL : L -> GenNo S) (xR : R -> GenNo S)
        (xcut : forall (l0 : L) (r : R), xL l0 < xR r)
        (fxL : L -> No) (fxR : R -> No)
        (fxcut : forall (l0 : L) (r : R),
                 fxL l0 < fxR r) (L' R' : Type)
        (s' : InSort S L' R') (yL : L' -> GenNo S)
        (yR : R' -> GenNo S)
        (ycut : forall (l0 : L') (r : R'),
                yL l0 < yR r) (fyL : L' -> No)
        (fyR : R' -> No)
        (fycut : forall (l0 : L') (r : R'),
                 fyL l0 < fyR r)
        (_ : forall l0 : L,
             xL l0 < {{ yL | yR // ycut }})
        (dp : forall l0 : L,
              fxL l0 < {{ fyL | fyR // fycut }})
        (_ : forall r : R',
             {{ xL | xR // xcut }} < yR r)
        (dq : forall r : R',
              {{ fxL | fxR // fxcut }} < fyR r) =>
      le_lr fxL fxR fxcut fyL fyR fycut dp dq)
     (fun (L R : Type) (s : InSort S L R)
        (xL : L -> GenNo S) (xR : R -> GenNo S)
        (xcut : forall (l0 : L) (r : R), xL l0 < xR r)
        (fxL : L -> No) (fxR : R -> No)
        (fxcut : forall (l0 : L) (r : R),
                 fxL l0 < fxR r) (L' R' : Type)
        (_ : InSort S L' R') (yL : L' -> GenNo S)
        (yR : R' -> GenNo S)
        (_ : forall (l0 : L') (r : R'), yL l0 < yR r)
        (fyL : L' -> No) (fyR : R' -> No)
        (fycut : forall (l0 : L') (r : R'),
                 fyL l0 < fyR r) (l0 : L')
        (_ : {{ xL | xR // xcut }} <= yL l0)
        (dp : {{ fxL | fxR // fxcut }} <= fyL l0) =>
      lt_l fxL fxR fxcut fyL fyR fycut l0 dp)
     (fun (L R : Type) (_ : InSort S L R)
        (xL : L -> GenNo S) (xR : R -> GenNo S)
        (_ : forall (l0 : L) (r : R), xL l0 < xR r)
        (fxL : L -> No) (fxR : R -> No)
        (fxcut : forall (l0 : L) (r : R),
                 fxL l0 < fxR r) (L' R' : Type)
        (s' : InSort S L' R') (yL : L' -> GenNo S)
        (yR : R' -> GenNo S)
        (ycut : forall (l0 : L') (r : R'),
                yL l0 < yR r) (fyL : L' -> No)
        (fyR : R' -> No)
        (fycut : forall (l0 : L') (r : R'),
                 fyL l0 < fyR r) (r : R)
        (_ : xR r <= {{ yL | yR // ycut }})
        (dp : fxR r <= {{ fyL | fyR // fycut }}) =>
      lt_r fxL fxR fxcut fyL fyR fycut r dp) (xL l) | 
(fun r : R =>
 No_rec No le lt
   (fun (L R : Type) (_ : InSort S L R)
      (xL : L -> GenNo S) (xR : R -> GenNo S)
      (_ : forall (l : L) (r0 : R), xL l < xR r0)
      (fxL : L -> No) (fxR : R -> No)
      (fxcut : forall (l : L) (r0 : R), fxL l < fxR r0)
    => {{ fxL | fxR // fxcut }}) path_No
   (fun (L R : Type) (s : InSort S L R)
      (xL : L -> GenNo S) (xR : R -> GenNo S)
      (xcut : forall (l : L) (r0 : R), xL l < xR r0)
      (fxL : L -> No) (fxR : R -> No)
      (fxcut : forall (l : L) (r0 : R), fxL l < fxR r0)
      (L' R' : Type) (s' : InSort S L' R')
      (yL : L' -> GenNo S) (yR : R' -> GenNo S)
      (ycut : forall (l : L') (r0 : R'), yL l < yR r0)
      (fyL : L' -> No) (fyR : R' -> No)
      (fycut : forall (l : L') (r0 : R'),
               fyL l < fyR r0)
      (_ : forall l : L, xL l < {{ yL | yR // ycut }})
      (dp : forall l : L,
            fxL l < {{ fyL | fyR // fycut }})
      (_ : forall r0 : R',
           {{ xL | xR // xcut }} < yR r0)
      (dq : forall r0 : R',
            {{ fxL | fxR // fxcut }} < fyR r0) =>
    le_lr fxL fxR fxcut fyL fyR fycut dp dq)
   (fun (L R : Type) (s : InSort S L R)
      (xL : L -> GenNo S) (xR : R -> GenNo S)
      (xcut : forall (l : L) (r0 : R), xL l < xR r0)
      (fxL : L -> No) (fxR : R -> No)
      (fxcut : forall (l : L) (r0 : R), fxL l < fxR r0)
      (L' R' : Type) (_ : InSort S L' R')
      (yL : L' -> GenNo S) (yR : R' -> GenNo S)
      (_ : forall (l : L') (r0 : R'), yL l < yR r0)
      (fyL : L' -> No) (fyR : R' -> No)
      (fycut : forall (l : L') (r0 : R'),
               fyL l < fyR r0) (l : L')
      (_ : {{ xL | xR // xcut }} <= yL l)
      (dp : {{ fxL | fxR // fxcut }} <= fyL l) =>
    lt_l fxL fxR fxcut fyL fyR fycut l dp)
   (fun (L R : Type) (_ : InSort S L R)
      (xL : L -> GenNo S) (xR : R -> GenNo S)
      (_ : forall (l : L) (r0 : R), xL l < xR r0)
      (fxL : L -> No) (fxR : R -> No)
      (fxcut : forall (l : L) (r0 : R), fxL l < fxR r0)
      (L' R' : Type) (s' : InSort S L' R')
      (yL : L' -> GenNo S) (yR : R' -> GenNo S)
      (ycut : forall (l : L') (r0 : R'), yL l < yR r0)
      (fyL : L' -> No) (fyR : R' -> No)
      (fycut : forall (l : L') (r0 : R'),
               fyL l < fyR r0) (r0 : R)
      (_ : xR r0 <= {{ yL | yR // ycut }})
      (dp : fxR r0 <= {{ fyL | fyR // fycut }}) =>
    lt_r fxL fxR fxcut fyL fyR fycut r0 dp) (xR r)) // 
fun (l : L) (r : R) =>
No_rec_lt No le lt
  (fun (L R : Type) (_ : InSort S L R)
     (xL : L -> GenNo S) (xR : R -> GenNo S)
     (_ : forall (l0 : L) (r0 : R), xL l0 < xR r0)
     (fxL : L -> No) (fxR : R -> No)
     (fxcut : forall (l0 : L) (r0 : R),
              fxL l0 < fxR r0) =>
   {{ fxL | fxR // fxcut }}) path_No
  (fun (L R : Type) (s : InSort S L R)
     (xL : L -> GenNo S) (xR : R -> GenNo S)
     (xcut : forall (l0 : L) (r0 : R), xL l0 < xR r0)
     (fxL : L -> No) (fxR : R -> No)
     (fxcut : forall (l0 : L) (r0 : R),
              fxL l0 < fxR r0) (L' R' : Type)
     (s' : InSort S L' R') (yL : L' -> GenNo S)
     (yR : R' -> GenNo S)
     (ycut : forall (l0 : L') (r0 : R'), yL l0 < yR r0)
     (fyL : L' -> No) (fyR : R' -> No)
     (fycut : forall (l0 : L') (r0 : R'),
              fyL l0 < fyR r0)
     (_ : forall l0 : L, xL l0 < {{ yL | yR // ycut }})
     (dp : forall l0 : L,
           fxL l0 < {{ fyL | fyR // fycut }})
     (_ : forall r0 : R',
          {{ xL | xR // xcut }} < yR r0)
     (dq : forall r0 : R',
           {{ fxL | fxR // fxcut }} < fyR r0) =>
   le_lr fxL fxR fxcut fyL fyR fycut dp dq)
  (fun (L R : Type) (s : InSort S L R)
     (xL : L -> GenNo S) (xR : R -> GenNo S)
     (xcut : forall (l0 : L) (r0 : R), xL l0 < xR r0)
     (fxL : L -> No) (fxR : R -> No)
     (fxcut : forall (l0 : L) (r0 : R),
              fxL l0 < fxR r0) (L' R' : Type)
     (_ : InSort S L' R') (yL : L' -> GenNo S)
     (yR : R' -> GenNo S)
     (_ : forall (l0 : L') (r0 : R'), yL l0 < yR r0)
     (fyL : L' -> No) (fyR : R' -> No)
     (fycut : forall (l0 : L') (r0 : R'),
              fyL l0 < fyR r0) (l0 : L')
     (_ : {{ xL | xR // xcut }} <= yL l0)
     (dp : {{ fxL | fxR // fxcut }} <= fyL l0) =>
   lt_l fxL fxR fxcut fyL fyR fycut l0 dp)
  (fun (L R : Type) (_ : InSort S L R)
     (xL : L -> GenNo S) (xR : R -> GenNo S)
     (_ : forall (l0 : L) (r0 : R), xL l0 < xR r0)
     (fxL : L -> No) (fxR : R -> No)
     (fxcut : forall (l0 : L) (r0 : R),
              fxL l0 < fxR r0) (L' R' : Type)
     (s' : InSort S L' R') (yL : L' -> GenNo S)
     (yR : R' -> GenNo S)
     (ycut : forall (l0 : L') (r0 : R'), yL l0 < yR r0)
     (fyL : L' -> No) (fyR : R' -> No)
     (fycut : forall (l0 : L') (r0 : R'),
              fyL l0 < fyR r0) (r0 : R)
     (_ : xR r0 <= {{ yL | yR // ycut }})
     (dp : fxR r0 <= {{ fyL | fyR // fycut }}) =>
   lt_r fxL fxR fxcut fyL fyR fycut r0 dp) (xL l)
  (xR r) (xcut l r) }} =
{{ fun l : L => No_raise (xL l) | (fun r : R =>
                                   No_raise (xR r)) // 
?rxcut }}
    reflexivity.
  Qed.

  Definition No_raise_le (x y : GenNo S)
    : (x <= y) -> (No_raise x <= No_raise y)
    := No_rec_le _ _ _ _ _ _ _ _ x y.

  Definition No_raise_lt (x y : GenNo S)
    : (x < y) -> (No_raise x < No_raise y)
    := No_rec_lt _ _ _ _ _ _ _ _ x y.

  Definition No_raise_reflects_lelt (x y : GenNo S)
    : ((No_raise x <= No_raise y) -> (x <= y)) *
      ((No_raise x <  No_raise y) -> (x <  y)).
ua: Univalence
S: OptionSort
x, y: GenNo S
(No_raise x <= No_raise y -> x <= y) *
(No_raise x < No_raise y -> x < y)
  Proof.
ua: Univalence
S: OptionSort
x, y: GenNo S
(No_raise x <= No_raise y -> x <= y) *
(No_raise x < No_raise y -> x < y)
    repeat_No_ind_hprop.
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall (l : L) (y : GenNo S),
(No_raise (xL l) <= No_raise y -> xL l <= y) *
(No_raise (xL l) < No_raise y -> xL l < y)
IHR: forall (r : R) (y : GenNo S),
(No_raise (xR r) <= No_raise y -> xR r <= y) *
(No_raise (xR r) < No_raise y -> xR r < y)
L0, R0: Type
s0: InSort S L0 R0
xL0: L0 -> GenNo S
xR0: R0 -> GenNo S
xcut0: forall (l : L0) (r : R0), xL0 l < xR0 r
IHL0: forall l : L0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} <= xL0 l) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} < xL0 l)
IHR0: forall r : R0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} <= xR0 r) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} < xR0 r)
(No_raise {{ xL | xR // xcut }} <=
 No_raise {{ xL0 | xR0 // xcut0 }} ->
 {{ xL | xR // xcut }} <= {{ xL0 | xR0 // xcut0 }}) *
(No_raise {{ xL | xR // xcut }} <
 No_raise {{ xL0 | xR0 // xcut0 }} ->
 {{ xL | xR // xcut }} < {{ xL0 | xR0 // xcut0 }})
    destruct (No_raise_cut xL xR xcut) as [rxcut p]; rewrite p.
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall (l : L) (y : GenNo S),
(No_raise (xL l) <= No_raise y -> xL l <= y) *
(No_raise (xL l) < No_raise y -> xL l < y)
IHR: forall (r : R) (y : GenNo S),
(No_raise (xR r) <= No_raise y -> xR r <= y) *
(No_raise (xR r) < No_raise y -> xR r < y)
L0, R0: Type
s0: InSort S L0 R0
xL0: L0 -> GenNo S
xR0: R0 -> GenNo S
xcut0: forall (l : L0) (r : R0), xL0 l < xR0 r
IHL0: forall l : L0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} <= xL0 l) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} < xL0 l)
IHR0: forall r : R0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} <= xR0 r) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} < xR0 r)
rxcut: forall (l : L) (r : R),
No_raise (xL l) < No_raise (xR r)
p: No_raise {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }}
({{ fun l : L => No_raise (xL l) | (fun r : R =>
                                    No_raise (xR r)) // rxcut }} <=
 No_raise {{ xL0 | xR0 // xcut0 }} ->
 {{ xL | xR // xcut }} <= {{ xL0 | xR0 // xcut0 }}) *
({{ fun l : L => No_raise (xL l) | (fun r : R =>
                                    No_raise (xR r)) // rxcut }} <
 No_raise {{ xL0 | xR0 // xcut0 }} ->
 {{ xL | xR // xcut }} < {{ xL0 | xR0 // xcut0 }})
    destruct (No_raise_cut xL0 xR0 xcut0) as [rxcut0 q]; rewrite q.
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall (l : L) (y : GenNo S),
(No_raise (xL l) <= No_raise y -> xL l <= y) *
(No_raise (xL l) < No_raise y -> xL l < y)
IHR: forall (r : R) (y : GenNo S),
(No_raise (xR r) <= No_raise y -> xR r <= y) *
(No_raise (xR r) < No_raise y -> xR r < y)
L0, R0: Type
s0: InSort S L0 R0
xL0: L0 -> GenNo S
xR0: R0 -> GenNo S
xcut0: forall (l : L0) (r : R0), xL0 l < xR0 r
IHL0: forall l : L0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} <= xL0 l) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} < xL0 l)
IHR0: forall r : R0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} <= xR0 r) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} < xR0 r)
rxcut: forall (l : L) (r : R),
No_raise (xL l) < No_raise (xR r)
p: No_raise {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }}
rxcut0: forall (l : L0) (r : R0),
No_raise (xL0 l) < No_raise (xR0 r)
q: No_raise {{ xL0 | xR0 // xcut0 }} =
{{ fun l : L0 => No_raise (xL0 l) | 
(fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
({{ fun l : L => No_raise (xL l) | (fun r : R =>
                                    No_raise (xR r)) // rxcut }} <=
 {{ fun l : L0 => No_raise (xL0 l) | (fun r : R0 =>
                                      No_raise (xR0 r)) // rxcut0 }} ->
 {{ xL | xR // xcut }} <= {{ xL0 | xR0 // xcut0 }}) *
({{ fun l : L => No_raise (xL l) | (fun r : R =>
                                    No_raise (xR r)) // rxcut }} <
 {{ fun l : L0 => No_raise (xL0 l) | (fun r : R0 =>
                                      No_raise (xR0 r)) // rxcut0 }} ->
 {{ xL | xR // xcut }} < {{ xL0 | xR0 // xcut0 }})
    split; intros sh.
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall (l : L) (y : GenNo S),
(No_raise (xL l) <= No_raise y -> xL l <= y) *
(No_raise (xL l) < No_raise y -> xL l < y)
IHR: forall (r : R) (y : GenNo S),
(No_raise (xR r) <= No_raise y -> xR r <= y) *
(No_raise (xR r) < No_raise y -> xR r < y)
L0, R0: Type
s0: InSort S L0 R0
xL0: L0 -> GenNo S
xR0: R0 -> GenNo S
xcut0: forall (l : L0) (r : R0), xL0 l < xR0 r
IHL0: forall l : L0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} <= xL0 l) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} < xL0 l)
IHR0: forall r : R0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} <= xR0 r) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} < xR0 r)
rxcut: forall (l : L) (r : R),
No_raise (xL l) < No_raise (xR r)
p: No_raise {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }}
rxcut0: forall (l : L0) (r : R0),
No_raise (xL0 l) < No_raise (xR0 r)
q: No_raise {{ xL0 | xR0 // xcut0 }} =
{{ fun l : L0 => No_raise (xL0 l) | 
(fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
sh: {{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }} <=
{{ fun l : L0 => No_raise (xL0 l) | 
(fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
{{ xL | xR // xcut }} <= {{ xL0 | xR0 // xcut0 }}
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall (l : L) (y : GenNo S),
(No_raise (xL l) <= No_raise y -> xL l <= y) *
(No_raise (xL l) < No_raise y -> xL l < y)
IHR: forall (r : R) (y : GenNo S),
(No_raise (xR r) <= No_raise y -> xR r <= y) *
(No_raise (xR r) < No_raise y -> xR r < y)
L0, R0: Type
s0: InSort S L0 R0
xL0: L0 -> GenNo S
xR0: R0 -> GenNo S
xcut0: forall (l : L0) (r : R0), xL0 l < xR0 r
IHL0: forall l : L0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} <= xL0 l) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} < xL0 l)
IHR0: forall r : R0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} <= xR0 r) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} < xR0 r)
rxcut: forall (l : L) (r : R),
No_raise (xL l) < No_raise (xR r)
p: No_raise {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }}
rxcut0: forall (l : L0) (r : R0),
No_raise (xL0 l) < No_raise (xR0 r)
q: No_raise {{ xL0 | xR0 // xcut0 }} =
{{ fun l : L0 => No_raise (xL0 l) | 
(fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
sh: {{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }} <
{{ fun l : L0 => No_raise (xL0 l) | 
(fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
{{ xL | xR // xcut }} < {{ xL0 | xR0 // xcut0 }}
    -
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall (l : L) (y : GenNo S),
(No_raise (xL l) <= No_raise y -> xL l <= y) *
(No_raise (xL l) < No_raise y -> xL l < y)
IHR: forall (r : R) (y : GenNo S),
(No_raise (xR r) <= No_raise y -> xR r <= y) *
(No_raise (xR r) < No_raise y -> xR r < y)
L0, R0: Type
s0: InSort S L0 R0
xL0: L0 -> GenNo S
xR0: R0 -> GenNo S
xcut0: forall (l : L0) (r : R0), xL0 l < xR0 r
IHL0: forall l : L0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} <= xL0 l) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} < xL0 l)
IHR0: forall r : R0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} <= xR0 r) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} < xR0 r)
rxcut: forall (l : L) (r : R),
No_raise (xL l) < No_raise (xR r)
p: No_raise {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }}
rxcut0: forall (l : L0) (r : R0),
No_raise (xL0 l) < No_raise (xR0 r)
q: No_raise {{ xL0 | xR0 // xcut0 }} =
{{ fun l : L0 => No_raise (xL0 l) | 
(fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
sh: {{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }} <=
{{ fun l : L0 => No_raise (xL0 l) | 
(fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
{{ xL | xR // xcut }} <= {{ xL0 | xR0 // xcut0 }} apply No_encode_le in sh; rewrite le'_cut in sh.
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall (l : L) (y : GenNo S),
(No_raise (xL l) <= No_raise y -> xL l <= y) *
(No_raise (xL l) < No_raise y -> xL l < y)
IHR: forall (r : R) (y : GenNo S),
(No_raise (xR r) <= No_raise y -> xR r <= y) *
(No_raise (xR r) < No_raise y -> xR r < y)
L0, R0: Type
s0: InSort S L0 R0
xL0: L0 -> GenNo S
xR0: R0 -> GenNo S
xcut0: forall (l : L0) (r : R0), xL0 l < xR0 r
IHL0: forall l : L0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} <= xL0 l) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} < xL0 l)
IHR0: forall r : R0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} <= xR0 r) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} < xR0 r)
rxcut: forall (l : L) (r : R),
No_raise (xL l) < No_raise (xR r)
p: No_raise {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }}
rxcut0: forall (l : L0) (r : R0),
No_raise (xL0 l) < No_raise (xR0 r)
q: No_raise {{ xL0 | xR0 // xcut0 }} =
{{ fun l : L0 => No_raise (xL0 l) | 
(fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
sh: (forall l : L,
 lt' (No_raise (xL l))
   {{ fun l0 : L0 => No_raise (xL0 l0) | 
   (fun r : R0 => No_raise (xR0 r)) // rxcut0 }}) *
(forall r' : R0,
 lt'
   {{ fun l : L => No_raise (xL l) | 
   (fun r : R => No_raise (xR r)) // rxcut }}
   (No_raise (xR0 r')))
{{ xL | xR // xcut }} <= {{ xL0 | xR0 // xcut0 }}
      apply le_lr.
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall (l : L) (y : GenNo S),
(No_raise (xL l) <= No_raise y -> xL l <= y) *
(No_raise (xL l) < No_raise y -> xL l < y)
IHR: forall (r : R) (y : GenNo S),
(No_raise (xR r) <= No_raise y -> xR r <= y) *
(No_raise (xR r) < No_raise y -> xR r < y)
L0, R0: Type
s0: InSort S L0 R0
xL0: L0 -> GenNo S
xR0: R0 -> GenNo S
xcut0: forall (l : L0) (r : R0), xL0 l < xR0 r
IHL0: forall l : L0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} <= xL0 l) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} < xL0 l)
IHR0: forall r : R0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} <= xR0 r) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} < xR0 r)
rxcut: forall (l : L) (r : R),
No_raise (xL l) < No_raise (xR r)
p: No_raise {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }}
rxcut0: forall (l : L0) (r : R0),
No_raise (xL0 l) < No_raise (xR0 r)
q: No_raise {{ xL0 | xR0 // xcut0 }} =
{{ fun l : L0 => No_raise (xL0 l) | 
(fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
sh: (forall l : L,
 lt' (No_raise (xL l))
   {{ fun l0 : L0 => No_raise (xL0 l0) | 
   (fun r : R0 => No_raise (xR0 r)) // rxcut0 }}) *
(forall r' : R0,
 lt'
   {{ fun l : L => No_raise (xL l) | 
   (fun r : R => No_raise (xR r)) // rxcut }}
   (No_raise (xR0 r')))
forall l : L, xL l < {{ xL0 | xR0 // xcut0 }}
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall (l : L) (y : GenNo S),
(No_raise (xL l) <= No_raise y -> xL l <= y) *
(No_raise (xL l) < No_raise y -> xL l < y)
IHR: forall (r : R) (y : GenNo S),
(No_raise (xR r) <= No_raise y -> xR r <= y) *
(No_raise (xR r) < No_raise y -> xR r < y)
L0, R0: Type
s0: InSort S L0 R0
xL0: L0 -> GenNo S
xR0: R0 -> GenNo S
xcut0: forall (l : L0) (r : R0), xL0 l < xR0 r
IHL0: forall l : L0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} <= xL0 l) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} < xL0 l)
IHR0: forall r : R0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} <= xR0 r) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} < xR0 r)
rxcut: forall (l : L) (r : R),
No_raise (xL l) < No_raise (xR r)
p: No_raise {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }}
rxcut0: forall (l : L0) (r : R0),
No_raise (xL0 l) < No_raise (xR0 r)
q: No_raise {{ xL0 | xR0 // xcut0 }} =
{{ fun l : L0 => No_raise (xL0 l) | 
(fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
sh: (forall l : L,
 lt' (No_raise (xL l))
   {{ fun l0 : L0 => No_raise (xL0 l0) | 
   (fun r : R0 => No_raise (xR0 r)) // rxcut0 }}) *
(forall r' : R0,
 lt'
   {{ fun l : L => No_raise (xL l) | 
   (fun r : R => No_raise (xR r)) // rxcut }}
   (No_raise (xR0 r')))
forall r : R0, {{ xL | xR // xcut }} < xR0 r
      +
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall (l : L) (y : GenNo S),
(No_raise (xL l) <= No_raise y -> xL l <= y) *
(No_raise (xL l) < No_raise y -> xL l < y)
IHR: forall (r : R) (y : GenNo S),
(No_raise (xR r) <= No_raise y -> xR r <= y) *
(No_raise (xR r) < No_raise y -> xR r < y)
L0, R0: Type
s0: InSort S L0 R0
xL0: L0 -> GenNo S
xR0: R0 -> GenNo S
xcut0: forall (l : L0) (r : R0), xL0 l < xR0 r
IHL0: forall l : L0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} <= xL0 l) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} < xL0 l)
IHR0: forall r : R0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} <= xR0 r) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} < xR0 r)
rxcut: forall (l : L) (r : R),
No_raise (xL l) < No_raise (xR r)
p: No_raise {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }}
rxcut0: forall (l : L0) (r : R0),
No_raise (xL0 l) < No_raise (xR0 r)
q: No_raise {{ xL0 | xR0 // xcut0 }} =
{{ fun l : L0 => No_raise (xL0 l) | 
(fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
sh: (forall l : L,
 lt' (No_raise (xL l))
   {{ fun l0 : L0 => No_raise (xL0 l0) | 
   (fun r : R0 => No_raise (xR0 r)) // rxcut0 }}) *
(forall r' : R0,
 lt'
   {{ fun l : L => No_raise (xL l) | 
   (fun r : R => No_raise (xR r)) // rxcut }}
   (No_raise (xR0 r')))
forall l : L, xL l < {{ xL0 | xR0 // xcut0 }} intros l.
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall (l : L) (y : GenNo S),
(No_raise (xL l) <= No_raise y -> xL l <= y) *
(No_raise (xL l) < No_raise y -> xL l < y)
IHR: forall (r : R) (y : GenNo S),
(No_raise (xR r) <= No_raise y -> xR r <= y) *
(No_raise (xR r) < No_raise y -> xR r < y)
L0, R0: Type
s0: InSort S L0 R0
xL0: L0 -> GenNo S
xR0: R0 -> GenNo S
xcut0: forall (l : L0) (r : R0), xL0 l < xR0 r
IHL0: forall l : L0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} <= xL0 l) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} < xL0 l)
IHR0: forall r : R0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} <= xR0 r) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} < xR0 r)
rxcut: forall (l : L) (r : R),
No_raise (xL l) < No_raise (xR r)
p: No_raise {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }}
rxcut0: forall (l : L0) (r : R0),
No_raise (xL0 l) < No_raise (xR0 r)
q: No_raise {{ xL0 | xR0 // xcut0 }} =
{{ fun l : L0 => No_raise (xL0 l) | 
(fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
sh: (forall l : L,
 lt' (No_raise (xL l))
   {{ fun l0 : L0 => No_raise (xL0 l0) | 
   (fun r : R0 => No_raise (xR0 r)) // rxcut0 }}) *
(forall r' : R0,
 lt'
   {{ fun l : L => No_raise (xL l) | 
   (fun r : R => No_raise (xR r)) // rxcut }}
   (No_raise (xR0 r')))
l: L
xL l < {{ xL0 | xR0 // xcut0 }}
        apply IHL, No_decode_lt.
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall (l : L) (y : GenNo S),
(No_raise (xL l) <= No_raise y -> xL l <= y) *
(No_raise (xL l) < No_raise y -> xL l < y)
IHR: forall (r : R) (y : GenNo S),
(No_raise (xR r) <= No_raise y -> xR r <= y) *
(No_raise (xR r) < No_raise y -> xR r < y)
L0, R0: Type
s0: InSort S L0 R0
xL0: L0 -> GenNo S
xR0: R0 -> GenNo S
xcut0: forall (l : L0) (r : R0), xL0 l < xR0 r
IHL0: forall l : L0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} <= xL0 l) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} < xL0 l)
IHR0: forall r : R0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} <= xR0 r) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} < xR0 r)
rxcut: forall (l : L) (r : R),
No_raise (xL l) < No_raise (xR r)
p: No_raise {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }}
rxcut0: forall (l : L0) (r : R0),
No_raise (xL0 l) < No_raise (xR0 r)
q: No_raise {{ xL0 | xR0 // xcut0 }} =
{{ fun l : L0 => No_raise (xL0 l) | 
(fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
sh: (forall l : L,
 lt' (No_raise (xL l))
   {{ fun l0 : L0 => No_raise (xL0 l0) | 
   (fun r : R0 => No_raise (xR0 r)) // rxcut0 }}) *
(forall r' : R0,
 lt'
   {{ fun l : L => No_raise (xL l) | 
   (fun r : R => No_raise (xR r)) // rxcut }}
   (No_raise (xR0 r')))
l: L
lt' (No_raise (xL l))
  (No_raise {{ xL0 | xR0 // xcut0 }})
        rewrite q; exact (fst sh l).
      +
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall (l : L) (y : GenNo S),
(No_raise (xL l) <= No_raise y -> xL l <= y) *
(No_raise (xL l) < No_raise y -> xL l < y)
IHR: forall (r : R) (y : GenNo S),
(No_raise (xR r) <= No_raise y -> xR r <= y) *
(No_raise (xR r) < No_raise y -> xR r < y)
L0, R0: Type
s0: InSort S L0 R0
xL0: L0 -> GenNo S
xR0: R0 -> GenNo S
xcut0: forall (l : L0) (r : R0), xL0 l < xR0 r
IHL0: forall l : L0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} <= xL0 l) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} < xL0 l)
IHR0: forall r : R0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} <= xR0 r) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} < xR0 r)
rxcut: forall (l : L) (r : R),
No_raise (xL l) < No_raise (xR r)
p: No_raise {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }}
rxcut0: forall (l : L0) (r : R0),
No_raise (xL0 l) < No_raise (xR0 r)
q: No_raise {{ xL0 | xR0 // xcut0 }} =
{{ fun l : L0 => No_raise (xL0 l) | 
(fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
sh: (forall l : L,
 lt' (No_raise (xL l))
   {{ fun l0 : L0 => No_raise (xL0 l0) | 
   (fun r : R0 => No_raise (xR0 r)) // rxcut0 }}) *
(forall r' : R0,
 lt'
   {{ fun l : L => No_raise (xL l) | 
   (fun r : R => No_raise (xR r)) // rxcut }}
   (No_raise (xR0 r')))
forall r : R0, {{ xL | xR // xcut }} < xR0 r intros r.
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall (l : L) (y : GenNo S),
(No_raise (xL l) <= No_raise y -> xL l <= y) *
(No_raise (xL l) < No_raise y -> xL l < y)
IHR: forall (r : R) (y : GenNo S),
(No_raise (xR r) <= No_raise y -> xR r <= y) *
(No_raise (xR r) < No_raise y -> xR r < y)
L0, R0: Type
s0: InSort S L0 R0
xL0: L0 -> GenNo S
xR0: R0 -> GenNo S
xcut0: forall (l : L0) (r : R0), xL0 l < xR0 r
IHL0: forall l : L0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} <= xL0 l) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} < xL0 l)
IHR0: forall r : R0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} <= xR0 r) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} < xR0 r)
rxcut: forall (l : L) (r : R),
No_raise (xL l) < No_raise (xR r)
p: No_raise {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }}
rxcut0: forall (l : L0) (r : R0),
No_raise (xL0 l) < No_raise (xR0 r)
q: No_raise {{ xL0 | xR0 // xcut0 }} =
{{ fun l : L0 => No_raise (xL0 l) | 
(fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
sh: (forall l : L,
 lt' (No_raise (xL l))
   {{ fun l0 : L0 => No_raise (xL0 l0) | 
   (fun r : R0 => No_raise (xR0 r)) // rxcut0 }}) *
(forall r' : R0,
 lt'
   {{ fun l : L => No_raise (xL l) | 
   (fun r : R => No_raise (xR r)) // rxcut }}
   (No_raise (xR0 r')))
r: R0
{{ xL | xR // xcut }} < xR0 r
        apply IHR0, No_decode_lt.
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall (l : L) (y : GenNo S),
(No_raise (xL l) <= No_raise y -> xL l <= y) *
(No_raise (xL l) < No_raise y -> xL l < y)
IHR: forall (r : R) (y : GenNo S),
(No_raise (xR r) <= No_raise y -> xR r <= y) *
(No_raise (xR r) < No_raise y -> xR r < y)
L0, R0: Type
s0: InSort S L0 R0
xL0: L0 -> GenNo S
xR0: R0 -> GenNo S
xcut0: forall (l : L0) (r : R0), xL0 l < xR0 r
IHL0: forall l : L0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} <= xL0 l) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} < xL0 l)
IHR0: forall r : R0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} <= xR0 r) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} < xR0 r)
rxcut: forall (l : L) (r : R),
No_raise (xL l) < No_raise (xR r)
p: No_raise {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }}
rxcut0: forall (l : L0) (r : R0),
No_raise (xL0 l) < No_raise (xR0 r)
q: No_raise {{ xL0 | xR0 // xcut0 }} =
{{ fun l : L0 => No_raise (xL0 l) | 
(fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
sh: (forall l : L,
 lt' (No_raise (xL l))
   {{ fun l0 : L0 => No_raise (xL0 l0) | 
   (fun r : R0 => No_raise (xR0 r)) // rxcut0 }}) *
(forall r' : R0,
 lt'
   {{ fun l : L => No_raise (xL l) | 
   (fun r : R => No_raise (xR r)) // rxcut }}
   (No_raise (xR0 r')))
r: R0
lt' (No_raise {{ xL | xR // xcut }})
  (No_raise (xR0 r))
        rewrite p; exact (snd sh r).
    -
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall (l : L) (y : GenNo S),
(No_raise (xL l) <= No_raise y -> xL l <= y) *
(No_raise (xL l) < No_raise y -> xL l < y)
IHR: forall (r : R) (y : GenNo S),
(No_raise (xR r) <= No_raise y -> xR r <= y) *
(No_raise (xR r) < No_raise y -> xR r < y)
L0, R0: Type
s0: InSort S L0 R0
xL0: L0 -> GenNo S
xR0: R0 -> GenNo S
xcut0: forall (l : L0) (r : R0), xL0 l < xR0 r
IHL0: forall l : L0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} <= xL0 l) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} < xL0 l)
IHR0: forall r : R0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} <= xR0 r) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} < xR0 r)
rxcut: forall (l : L) (r : R),
No_raise (xL l) < No_raise (xR r)
p: No_raise {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }}
rxcut0: forall (l : L0) (r : R0),
No_raise (xL0 l) < No_raise (xR0 r)
q: No_raise {{ xL0 | xR0 // xcut0 }} =
{{ fun l : L0 => No_raise (xL0 l) | 
(fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
sh: {{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }} <
{{ fun l : L0 => No_raise (xL0 l) | 
(fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
{{ xL | xR // xcut }} < {{ xL0 | xR0 // xcut0 }} apply No_encode_lt in sh; rewrite lt'_cut in sh.
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall (l : L) (y : GenNo S),
(No_raise (xL l) <= No_raise y -> xL l <= y) *
(No_raise (xL l) < No_raise y -> xL l < y)
IHR: forall (r : R) (y : GenNo S),
(No_raise (xR r) <= No_raise y -> xR r <= y) *
(No_raise (xR r) < No_raise y -> xR r < y)
L0, R0: Type
s0: InSort S L0 R0
xL0: L0 -> GenNo S
xR0: R0 -> GenNo S
xcut0: forall (l : L0) (r : R0), xL0 l < xR0 r
IHL0: forall l : L0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} <= xL0 l) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} < xL0 l)
IHR0: forall r : R0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} <= xR0 r) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} < xR0 r)
rxcut: forall (l : L) (r : R),
No_raise (xL l) < No_raise (xR r)
p: No_raise {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }}
rxcut0: forall (l : L0) (r : R0),
No_raise (xL0 l) < No_raise (xR0 r)
q: No_raise {{ xL0 | xR0 // xcut0 }} =
{{ fun l : L0 => No_raise (xL0 l) | 
(fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
sh: hor
  {l' : L0 &
  le'
    {{ fun l : L => No_raise (xL l) | 
    (fun r : R => No_raise (xR r)) // rxcut }}
    (No_raise (xL0 l'))}
  {r : R &
  le' (No_raise (xR r))
    {{ fun l : L0 => No_raise (xL0 l) | 
    (fun r0 : R0 => No_raise (xR0 r0)) // rxcut0 }}}
{{ xL | xR // xcut }} < {{ xL0 | xR0 // xcut0 }}
      strip_truncations.
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall (l : L) (y : GenNo S),
(No_raise (xL l) <= No_raise y -> xL l <= y) *
(No_raise (xL l) < No_raise y -> xL l < y)
IHR: forall (r : R) (y : GenNo S),
(No_raise (xR r) <= No_raise y -> xR r <= y) *
(No_raise (xR r) < No_raise y -> xR r < y)
L0, R0: Type
s0: InSort S L0 R0
xL0: L0 -> GenNo S
xR0: R0 -> GenNo S
xcut0: forall (l : L0) (r : R0), xL0 l < xR0 r
IHL0: forall l : L0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} <= xL0 l) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} < xL0 l)
IHR0: forall r : R0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} <= xR0 r) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} < xR0 r)
rxcut: forall (l : L) (r : R),
No_raise (xL l) < No_raise (xR r)
p: No_raise {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }}
rxcut0: forall (l : L0) (r : R0),
No_raise (xL0 l) < No_raise (xR0 r)
q: No_raise {{ xL0 | xR0 // xcut0 }} =
{{ fun l : L0 => No_raise (xL0 l) | 
(fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
sh: {l' : L0 &
le'
  {{ fun l : L => No_raise (xL l) | 
  (fun r : R => No_raise (xR r)) // rxcut }}
  (No_raise (xL0 l'))} +
{r : R &
le' (No_raise (xR r))
  {{ fun l : L0 => No_raise (xL0 l) | 
  (fun r0 : R0 => No_raise (xR0 r0)) // rxcut0 }}}
{{ xL | xR // xcut }} < {{ xL0 | xR0 // xcut0 }}
      destruct sh as [[l sh]|[r sh]].
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall (l : L) (y : GenNo S),
(No_raise (xL l) <= No_raise y -> xL l <= y) *
(No_raise (xL l) < No_raise y -> xL l < y)
IHR: forall (r : R) (y : GenNo S),
(No_raise (xR r) <= No_raise y -> xR r <= y) *
(No_raise (xR r) < No_raise y -> xR r < y)
L0, R0: Type
s0: InSort S L0 R0
xL0: L0 -> GenNo S
xR0: R0 -> GenNo S
xcut0: forall (l : L0) (r : R0), xL0 l < xR0 r
IHL0: forall l : L0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} <= xL0 l) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} < xL0 l)
IHR0: forall r : R0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} <= xR0 r) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} < xR0 r)
rxcut: forall (l : L) (r : R),
No_raise (xL l) < No_raise (xR r)
p: No_raise {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }}
rxcut0: forall (l : L0) (r : R0),
No_raise (xL0 l) < No_raise (xR0 r)
q: No_raise {{ xL0 | xR0 // xcut0 }} =
{{ fun l : L0 => No_raise (xL0 l) | 
(fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
l: L0
sh: le'
  {{ fun l : L => No_raise (xL l) | 
  (fun r : R => No_raise (xR r)) // rxcut }}
  (No_raise (xL0 l))
{{ xL | xR // xcut }} < {{ xL0 | xR0 // xcut0 }}
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall (l : L) (y : GenNo S),
(No_raise (xL l) <= No_raise y -> xL l <= y) *
(No_raise (xL l) < No_raise y -> xL l < y)
IHR: forall (r : R) (y : GenNo S),
(No_raise (xR r) <= No_raise y -> xR r <= y) *
(No_raise (xR r) < No_raise y -> xR r < y)
L0, R0: Type
s0: InSort S L0 R0
xL0: L0 -> GenNo S
xR0: R0 -> GenNo S
xcut0: forall (l : L0) (r : R0), xL0 l < xR0 r
IHL0: forall l : L0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} <= xL0 l) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} < xL0 l)
IHR0: forall r : R0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} <= xR0 r) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} < xR0 r)
rxcut: forall (l : L) (r : R),
No_raise (xL l) < No_raise (xR r)
p: No_raise {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }}
rxcut0: forall (l : L0) (r : R0),
No_raise (xL0 l) < No_raise (xR0 r)
q: No_raise {{ xL0 | xR0 // xcut0 }} =
{{ fun l : L0 => No_raise (xL0 l) | 
(fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
r: R
sh: le' (No_raise (xR r))
  {{ fun l : L0 => No_raise (xL0 l) | 
  (fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
{{ xL | xR // xcut }} < {{ xL0 | xR0 // xcut0 }}
      +
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall (l : L) (y : GenNo S),
(No_raise (xL l) <= No_raise y -> xL l <= y) *
(No_raise (xL l) < No_raise y -> xL l < y)
IHR: forall (r : R) (y : GenNo S),
(No_raise (xR r) <= No_raise y -> xR r <= y) *
(No_raise (xR r) < No_raise y -> xR r < y)
L0, R0: Type
s0: InSort S L0 R0
xL0: L0 -> GenNo S
xR0: R0 -> GenNo S
xcut0: forall (l : L0) (r : R0), xL0 l < xR0 r
IHL0: forall l : L0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} <= xL0 l) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} < xL0 l)
IHR0: forall r : R0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} <= xR0 r) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} < xR0 r)
rxcut: forall (l : L) (r : R),
No_raise (xL l) < No_raise (xR r)
p: No_raise {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }}
rxcut0: forall (l : L0) (r : R0),
No_raise (xL0 l) < No_raise (xR0 r)
q: No_raise {{ xL0 | xR0 // xcut0 }} =
{{ fun l : L0 => No_raise (xL0 l) | 
(fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
l: L0
sh: le'
  {{ fun l : L => No_raise (xL l) | 
  (fun r : R => No_raise (xR r)) // rxcut }}
  (No_raise (xL0 l))
{{ xL | xR // xcut }} < {{ xL0 | xR0 // xcut0 }} apply lt_l with l.
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall (l : L) (y : GenNo S),
(No_raise (xL l) <= No_raise y -> xL l <= y) *
(No_raise (xL l) < No_raise y -> xL l < y)
IHR: forall (r : R) (y : GenNo S),
(No_raise (xR r) <= No_raise y -> xR r <= y) *
(No_raise (xR r) < No_raise y -> xR r < y)
L0, R0: Type
s0: InSort S L0 R0
xL0: L0 -> GenNo S
xR0: R0 -> GenNo S
xcut0: forall (l : L0) (r : R0), xL0 l < xR0 r
IHL0: forall l : L0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} <= xL0 l) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} < xL0 l)
IHR0: forall r : R0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} <= xR0 r) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} < xR0 r)
rxcut: forall (l : L) (r : R),
No_raise (xL l) < No_raise (xR r)
p: No_raise {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }}
rxcut0: forall (l : L0) (r : R0),
No_raise (xL0 l) < No_raise (xR0 r)
q: No_raise {{ xL0 | xR0 // xcut0 }} =
{{ fun l : L0 => No_raise (xL0 l) | 
(fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
l: L0
sh: le'
  {{ fun l : L => No_raise (xL l) | 
  (fun r : R => No_raise (xR r)) // rxcut }}
  (No_raise (xL0 l))
{{ xL | xR // xcut }} <= xL0 l
        apply IHL0, (@No_decode_le ua). (* Need to pass in [Univalence] to make this fast. TODO: should be fast without ua with Coq 8.19.  If so, remove this when 8.19 is our minimum version. *)
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall (l : L) (y : GenNo S),
(No_raise (xL l) <= No_raise y -> xL l <= y) *
(No_raise (xL l) < No_raise y -> xL l < y)
IHR: forall (r : R) (y : GenNo S),
(No_raise (xR r) <= No_raise y -> xR r <= y) *
(No_raise (xR r) < No_raise y -> xR r < y)
L0, R0: Type
s0: InSort S L0 R0
xL0: L0 -> GenNo S
xR0: R0 -> GenNo S
xcut0: forall (l : L0) (r : R0), xL0 l < xR0 r
IHL0: forall l : L0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} <= xL0 l) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} < xL0 l)
IHR0: forall r : R0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} <= xR0 r) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} < xR0 r)
rxcut: forall (l : L) (r : R),
No_raise (xL l) < No_raise (xR r)
p: No_raise {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }}
rxcut0: forall (l : L0) (r : R0),
No_raise (xL0 l) < No_raise (xR0 r)
q: No_raise {{ xL0 | xR0 // xcut0 }} =
{{ fun l : L0 => No_raise (xL0 l) | 
(fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
l: L0
sh: le'
  {{ fun l : L => No_raise (xL l) | 
  (fun r : R => No_raise (xR r)) // rxcut }}
  (No_raise (xL0 l))
le' (No_raise {{ xL | xR // xcut }})
  (No_raise (xL0 l))
        rewrite p; exact sh.
      +
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall (l : L) (y : GenNo S),
(No_raise (xL l) <= No_raise y -> xL l <= y) *
(No_raise (xL l) < No_raise y -> xL l < y)
IHR: forall (r : R) (y : GenNo S),
(No_raise (xR r) <= No_raise y -> xR r <= y) *
(No_raise (xR r) < No_raise y -> xR r < y)
L0, R0: Type
s0: InSort S L0 R0
xL0: L0 -> GenNo S
xR0: R0 -> GenNo S
xcut0: forall (l : L0) (r : R0), xL0 l < xR0 r
IHL0: forall l : L0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} <= xL0 l) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} < xL0 l)
IHR0: forall r : R0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} <= xR0 r) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} < xR0 r)
rxcut: forall (l : L) (r : R),
No_raise (xL l) < No_raise (xR r)
p: No_raise {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }}
rxcut0: forall (l : L0) (r : R0),
No_raise (xL0 l) < No_raise (xR0 r)
q: No_raise {{ xL0 | xR0 // xcut0 }} =
{{ fun l : L0 => No_raise (xL0 l) | 
(fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
r: R
sh: le' (No_raise (xR r))
  {{ fun l : L0 => No_raise (xL0 l) | 
  (fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
{{ xL | xR // xcut }} < {{ xL0 | xR0 // xcut0 }} apply lt_r with r.
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall (l : L) (y : GenNo S),
(No_raise (xL l) <= No_raise y -> xL l <= y) *
(No_raise (xL l) < No_raise y -> xL l < y)
IHR: forall (r : R) (y : GenNo S),
(No_raise (xR r) <= No_raise y -> xR r <= y) *
(No_raise (xR r) < No_raise y -> xR r < y)
L0, R0: Type
s0: InSort S L0 R0
xL0: L0 -> GenNo S
xR0: R0 -> GenNo S
xcut0: forall (l : L0) (r : R0), xL0 l < xR0 r
IHL0: forall l : L0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} <= xL0 l) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} < xL0 l)
IHR0: forall r : R0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} <= xR0 r) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} < xR0 r)
rxcut: forall (l : L) (r : R),
No_raise (xL l) < No_raise (xR r)
p: No_raise {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }}
rxcut0: forall (l : L0) (r : R0),
No_raise (xL0 l) < No_raise (xR0 r)
q: No_raise {{ xL0 | xR0 // xcut0 }} =
{{ fun l : L0 => No_raise (xL0 l) | 
(fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
r: R
sh: le' (No_raise (xR r))
  {{ fun l : L0 => No_raise (xL0 l) | 
  (fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
xR r <= {{ xL0 | xR0 // xcut0 }}
        apply IHR, No_decode_le.
ua: Univalence
S: OptionSort
L, R: Type
s: InSort S L R
xL: L -> GenNo S
xR: R -> GenNo S
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall (l : L) (y : GenNo S),
(No_raise (xL l) <= No_raise y -> xL l <= y) *
(No_raise (xL l) < No_raise y -> xL l < y)
IHR: forall (r : R) (y : GenNo S),
(No_raise (xR r) <= No_raise y -> xR r <= y) *
(No_raise (xR r) < No_raise y -> xR r < y)
L0, R0: Type
s0: InSort S L0 R0
xL0: L0 -> GenNo S
xR0: R0 -> GenNo S
xcut0: forall (l : L0) (r : R0), xL0 l < xR0 r
IHL0: forall l : L0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} <= xL0 l) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xL0 l) ->
 {{ xL | xR // xcut }} < xL0 l)
IHR0: forall r : R0,
(No_raise {{ xL | xR // xcut }} <=
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} <= xR0 r) *
(No_raise {{ xL | xR // xcut }} <
 No_raise (xR0 r) ->
 {{ xL | xR // xcut }} < xR0 r)
rxcut: forall (l : L) (r : R),
No_raise (xL l) < No_raise (xR r)
p: No_raise {{ xL | xR // xcut }} =
{{ fun l : L => No_raise (xL l) | 
(fun r : R => No_raise (xR r)) // rxcut }}
rxcut0: forall (l : L0) (r : R0),
No_raise (xL0 l) < No_raise (xR0 r)
q: No_raise {{ xL0 | xR0 // xcut0 }} =
{{ fun l : L0 => No_raise (xL0 l) | 
(fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
r: R
sh: le' (No_raise (xR r))
  {{ fun l : L0 => No_raise (xL0 l) | 
  (fun r : R0 => No_raise (xR0 r)) // rxcut0 }}
le' (No_raise (xR r))
  (No_raise {{ xL0 | xR0 // xcut0 }})
        rewrite q; exact sh.
  Qed.

  Definition No_raise_reflects_le (x y : GenNo S)
    : (No_raise x <= No_raise y) -> (x <= y)
    := fst (No_raise_reflects_lelt x y).

  Definition No_raise_reflects_lt (x y : GenNo S)
    : (No_raise x <  No_raise y) -> (x <  y)
    := snd (No_raise_reflects_lelt x y).

  Global Instance isemb_No_raise : IsEmbedding No_raise.
ua: Univalence
S: OptionSort
IsEmbedding No_raise
  Proof.
ua: Univalence
S: OptionSort
IsEmbedding No_raise
    apply isembedding_isinj_hset.
ua: Univalence
S: OptionSort
isinj No_raise
    intros x y e; apply path_No.
ua: Univalence
S: OptionSort
x, y: GenNo S
e: No_raise x = No_raise y
x <= y
ua: Univalence
S: OptionSort
x, y: GenNo S
e: No_raise x = No_raise y
y <= x
    -
ua: Univalence
S: OptionSort
x, y: GenNo S
e: No_raise x = No_raise y
x <= y refine (No_raise_reflects_le x y _).
ua: Univalence
S: OptionSort
x, y: GenNo S
e: No_raise x = No_raise y
No_raise x <= No_raise y
      rewrite e; apply reflexive_le.
    -
ua: Univalence
S: OptionSort
x, y: GenNo S
e: No_raise x = No_raise y
y <= x refine (No_raise_reflects_le y x _).
ua: Univalence
S: OptionSort
x, y: GenNo S
e: No_raise x = No_raise y
No_raise y <= No_raise x
      rewrite e; apply reflexive_le.
  Qed.

End RaiseSort.

(** ** Ordinals *)

(** The type of "plump ordinals" can be identified with surreal numbers that hereditarily have no right options. *)
Definition OrdSort : OptionSort := fun L R => ~R.
Definition POrd := GenNo OrdSort.
Global Instance insort_ordsort {L : Type}
  : InSort OrdSort L Empty | 100
  := idmap.

(** ** Decidable options *)

(** A particularly interesting option sort restricts [L] and [R] to be decidable, i.e. either inhabited or empty. *)
Definition DecSort : OptionSort
  := fun L R => Decidable L * Decidable R.
Definition DecNo : Type := GenNo DecSort.

Global Instance insort_decsort {L R : Type}
         {dl : Decidable L} {dr : Decidable R}
  : InSort DecSort L R | 100
  := (dl , dr).

(** Perhaps surprisingly, this is not a restriction at all!  Any surreal number can be presented by a cut in which all the option sorts are hereditarily decidable.  The basic idea is that we can always add a "sufficiently large" right option and a "sufficiently small" left option in order to make both families of options inhabited without changing the value of the cut, but the details are a bit tricky. *)
Global Instance isequiv_DecNo_raise `{Univalence}
  : IsEquiv (@No_raise DecSort).
H: Univalence
IsEquiv No_raise
Proof.
H: Univalence
IsEquiv No_raise
  apply isequiv_surj_emb; try exact _.
H: Univalence
ReflectiveSubuniverse.IsConnMap (Tr (-1)) No_raise
  apply BuildIsSurjection; intros x.
H: Univalence
x: No
merely (hfiber No_raise x)
  apply tr.
H: Univalence
x: No
hfiber No_raise x
  revert x; refine (No_ind_hprop _ _).
H: Univalence
forall (L R : Type) (s : InSort MaxSort L R)
(xL : L -> GenNo MaxSort) (xR : R -> GenNo MaxSort)
(xcut : forall (l : L) (r : R), xL l < xR r),
(forall l : L, hfiber No_raise (xL l)) ->
(forall r : R, hfiber No_raise (xR r)) ->
hfiber No_raise {{ xL | xR // xcut }}
  intros L R s xL xR xcut IHL IHR.
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
hfiber No_raise {{ xL | xR // xcut }}
  pose (uLR := Unit + (L + R)).
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
hfiber No_raise {{ xL | xR // xcut }}
  assert (Decidable uLR) by exact (inl (inl tt)).
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
hfiber No_raise {{ xL | xR // xcut }}
  pose (xLR := sum_ind _ (fun _ => zero) (sum_ind (fun _ => DecNo) (fun l => (IHL l).1) (fun r => (IHR r).1)) : uLR -> DecNo).
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
hfiber No_raise {{ xL | xR // xcut }}
  pose (z := {{ xLR | Empty_rec // rempty_cut }}).
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
hfiber No_raise {{ xL | xR // xcut }}
  pose (z' := {{ unit_name z | Empty_rec // rempty_cut }}).
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
hfiber No_raise {{ xL | xR // xcut }}
  pose (y := {{ Empty_rec | xLR // lempty_cut }}).
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
hfiber No_raise {{ xL | xR // xcut }}
  pose (y' := {{ Empty_rec | unit_name y // lempty_cut }} ).
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
hfiber No_raise {{ xL | xR // xcut }}
  pose (L' := Unit + L).
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
hfiber No_raise {{ xL | xR // xcut }}
  assert (Decidable L') by exact (inl (inl tt)).
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
hfiber No_raise {{ xL | xR // xcut }}
  pose (wL := sum_ind _ (fun _ => y') (fun l => (IHL l).1) : L' -> DecNo).
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
hfiber No_raise {{ xL | xR // xcut }}
  pose (R' := Unit + R).
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
hfiber No_raise {{ xL | xR // xcut }}
  assert (Decidable R') by exact (inl (inl tt)).
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
hfiber No_raise {{ xL | xR // xcut }}
  pose (wR := sum_ind _ (fun _ => z') (fun r => (IHR r).1) : R' -> DecNo).
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
hfiber No_raise {{ xL | xR // xcut }}
  assert (wcut : forall l r, wL l < wR r).
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
forall (l : L') (r : R'), wL l < wR r
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
hfiber No_raise {{ xL | xR // xcut }}
  {
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
forall (l : L') (r : R'), wL l < wR r intros [[]|l] [[]|r]; cbn.
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
y' < z'
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
r: R
y' < (IHR r).1
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
l: L
(IHL l).1 < z'
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
l: L
r: R
(IHL l).1 < (IHR r).1
    -
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
y' < z' transitivity y.
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
y' < y
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
y < z'
      {
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
y' < y refine (lt_ropt _ _ _ tt). }
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
y < z'
      transitivity z.
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
y < z
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
z < z'
      {
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
y < z apply lt_l with (inl tt); cbn.
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
{{ Empty_rec | xLR // lempty_cut }} <= zero
        apply le_lr; intros []. }
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
z < z'
      {
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
z < z' refine (lt_lopt _ _ _ tt). }
    -
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
r: R
y' < (IHR r).1 transitivity y.
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
r: R
y' < y
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
r: R
y < (IHR r).1
      {
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
r: R
y' < y refine (lt_ropt _ _ _ tt). }
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
r: R
y < (IHR r).1
      {
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
r: R
y < (IHR r).1 refine (lt_ropt _ _ _ (inr (inr r))). }
    -
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
l: L
(IHL l).1 < z' transitivity z.
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
l: L
(IHL l).1 < z
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
l: L
z < z'
      {
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
l: L
(IHL l).1 < z refine (lt_lopt _ _ _ (inr (inl l))). }
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
l: L
z < z'
      {
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
l: L
z < z' refine (lt_lopt _ _ _ tt). }
    -
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
l: L
r: R
(IHL l).1 < (IHR r).1 apply No_raise_reflects_lt.
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
l: L
r: R
No_raise (IHL l).1 < No_raise (IHR r).1
      rewrite (IHL l).2, (IHR r).2.
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
l: L
r: R
xL l < xR r
      apply xcut. }
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
hfiber No_raise {{ xL | xR // xcut }}
  exists ({{ wL | wR // wcut }}).
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
No_raise {{ wL | wR // wcut }} = {{ xL | xR // xcut }}
  destruct (No_raise_cut wL wR wcut) as [rwcut p].
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
p: No_raise {{ wL | wR // wcut }} =
{{ fun l : L' => No_raise (wL l) | 
(fun r : R' => No_raise (wR r)) // rwcut }}
No_raise {{ wL | wR // wcut }} = {{ xL | xR // xcut }}
  rewrite p; clear p.
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
{{ fun l : L' => No_raise (wL l) | 
(fun r : R' => No_raise (wR r)) // rwcut }} =
{{ xL | xR // xcut }}
  apply path_No; apply le_lr.
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
forall l : L', No_raise (wL l) < {{ xL | xR // xcut }}
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
forall r : R,
{{ fun l : L' => No_raise (wL l) | 
(fun r0 : R' => No_raise (wR r0)) // rwcut }} < 
xR r
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
forall l : L,
xL l <
{{ fun l0 : L' => No_raise (wL l0) | 
(fun r : R' => No_raise (wR r)) // rwcut }}
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
forall r : R', {{ xL | xR // xcut }} < No_raise (wR r)
  -
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
forall l : L', No_raise (wL l) < {{ xL | xR // xcut }} intros [[]|l].
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
No_raise (wL (inl tt)) < {{ xL | xR // xcut }}
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
l: L
No_raise (wL (inr l)) < {{ xL | xR // xcut }}
    +
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
No_raise (wL (inl tt)) < {{ xL | xR // xcut }} apply (lt_le_trans (y := No_raise y)).
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
No_raise (wL (inl tt)) < No_raise y
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
No_raise y <= {{ xL | xR // xcut }}
      *
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
No_raise (wL (inl tt)) < No_raise y apply No_raise_lt.
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
wL (inl tt) < y
        refine (lt_ropt _ _ _ tt).
      *
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
No_raise y <= {{ xL | xR // xcut }} unfold y.
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
No_raise {{ Empty_rec | xLR // lempty_cut }} <=
{{ xL | xR // xcut }} rewrite (No_raise_cut _ _ _).2.
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
{{ fun l : Empty => No_raise (Empty_rec l) | 
(fun r : uLR => No_raise (xLR r)) // 
(No_raise_cut Empty_rec xLR lempty_cut).1 }} <=
{{ xL | xR // xcut }}
        apply le_lr; [ intros [] | intros r ].
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
r: R
{{ fun l : Empty => No_raise (Empty_rec l) | 
(fun r : uLR => No_raise (xLR r)) // 
(No_raise_cut Empty_rec xLR lempty_cut).1 }} < 
xR r
        rewrite <- (IHR r).2.
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
r: R
{{ fun l : Empty => No_raise (Empty_rec l) | 
(fun r : uLR => No_raise (xLR r)) // 
(No_raise_cut Empty_rec xLR lempty_cut).1 }} <
No_raise (IHR r).1
        refine (lt_ropt _ _ _ (inr (inr r))).
    +
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
l: L
No_raise (wL (inr l)) < {{ xL | xR // xcut }} rewrite (IHL l).2.
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
l: L
xL l < {{ xL | xR // xcut }}
      refine (lt_lopt _ _ _ l).
  -
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
forall r : R,
{{ fun l : L' => No_raise (wL l) | 
(fun r0 : R' => No_raise (wR r0)) // rwcut }} < 
xR r intros r.
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
r: R
{{ fun l : L' => No_raise (wL l) | 
(fun r : R' => No_raise (wR r)) // rwcut }} < 
xR r
    rewrite <- (IHR r).2.
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
r: R
{{ fun l : L' => No_raise (wL l) | 
(fun r : R' => No_raise (wR r)) // rwcut }} <
No_raise (IHR r).1
    refine (lt_ropt _ _ _ (inr r)).
  -
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
forall l : L,
xL l <
{{ fun l0 : L' => No_raise (wL l0) | 
(fun r : R' => No_raise (wR r)) // rwcut }} intros l.
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
l: L
xL l <
{{ fun l : L' => No_raise (wL l) | 
(fun r : R' => No_raise (wR r)) // rwcut }}
    rewrite <- (IHL l).2.
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
l: L
No_raise (IHL l).1 <
{{ fun l : L' => No_raise (wL l) | 
(fun r : R' => No_raise (wR r)) // rwcut }}
    refine (lt_lopt _ _ _ (inr l)).
  -
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
forall r : R', {{ xL | xR // xcut }} < No_raise (wR r) intros [[]|r].
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
{{ xL | xR // xcut }} < No_raise (wR (inl tt))
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
r: R
{{ xL | xR // xcut }} < No_raise (wR (inr r))
    +
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
{{ xL | xR // xcut }} < No_raise (wR (inl tt)) apply (le_lt_trans (y := No_raise z)).
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
{{ xL | xR // xcut }} <= No_raise z
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
No_raise z < No_raise (wR (inl tt))
      *
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
{{ xL | xR // xcut }} <= No_raise z unfold z.
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
{{ xL | xR // xcut }} <=
No_raise {{ xLR | Empty_rec // rempty_cut }} rewrite (No_raise_cut _ _ _).2.
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
{{ xL | xR // xcut }} <=
{{ fun l : uLR => No_raise (xLR l) | 
(fun r : Empty => No_raise (Empty_rec r)) // 
(No_raise_cut xLR Empty_rec rempty_cut).1 }}
        apply le_lr; [ intros l | intros [] ].
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
l: L
xL l <
{{ fun l : uLR => No_raise (xLR l) | 
(fun r : Empty => No_raise (Empty_rec r)) // 
(No_raise_cut xLR Empty_rec rempty_cut).1 }}
        rewrite <- (IHL l).2.
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
l: L
No_raise (IHL l).1 <
{{ fun l : uLR => No_raise (xLR l) | 
(fun r : Empty => No_raise (Empty_rec r)) // 
(No_raise_cut xLR Empty_rec rempty_cut).1 }}
        refine (lt_lopt _ _ _ (inr (inl l))).
      *
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
No_raise z < No_raise (wR (inl tt)) apply No_raise_lt.
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
z < wR (inl tt)
        refine (lt_lopt _ _ _ tt).
    +
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
r: R
{{ xL | xR // xcut }} < No_raise (wR (inr r)) rewrite (IHR r).2.
H: Univalence
L, R: Type
s: InSort MaxSort L R
xL: L -> GenNo MaxSort
xR: R -> GenNo MaxSort
xcut: forall (l : L) (r : R), xL l < xR r
IHL: forall l : L, hfiber No_raise (xL l)
IHR: forall r : R, hfiber No_raise (xR r)
uLR:= Unit + (L + R): Type
X: Decidable uLR
xLR:= sum_ind (fun _ : Unit + (L + R) => DecNo)
  (unit_name zero)
  (sum_ind (fun _ : L + R => DecNo)
     (fun l : L => (IHL l).1)
     (fun r : R => (IHR r).1))
:
uLR -> DecNo: uLR -> DecNo
z:= {{ xLR | Empty_rec // rempty_cut }}: GenNo DecSort
z':= {{ unit_name z | Empty_rec // rempty_cut }}: GenNo DecSort
y:= {{ Empty_rec | xLR // lempty_cut }}: GenNo DecSort
y':= {{ Empty_rec | unit_name y // lempty_cut }}: GenNo DecSort
L':= Unit + L: Type
X0: Decidable L'
wL:= sum_ind (fun _ : Unit + L => DecNo) 
  (unit_name y') (fun l : L => (IHL l).1)
:
L' -> DecNo: L' -> DecNo
R':= Unit + R: Type
X1: Decidable R'
wR:= sum_ind (fun _ : Unit + R => DecNo) 
  (unit_name z') (fun r : R => (IHR r).1)
:
R' -> DecNo: R' -> DecNo
wcut: forall (l : L') (r : R'), wL l < wR r
rwcut: forall (l : L') (r : R'),
No_raise (wL l) < No_raise (wR r)
r: R
{{ xL | xR // xcut }} < xR r
      refine (lt_ropt _ _ _ r).
Defined.

Definition equiv_DecNo_raise `{Univalence}
  : DecNo <~> No
  := Build_Equiv _ _ No_raise _.

(** Note that this does not extend to other sorts.  For instance, it is *not* true that any plump ordinal is equal to a cut whose types of left and right options are respectively hereditarily decidable and hereditarily empty.  In particular, when making the type of left options inhabited, we have to use surreals whose type of right options is also inhabited.  For instance, [{{ fun _:P => zero | Empty_rec // rempty_cut }}], for a proposition [P], is a plump ordinal, but to make its left options inhabited we have to use a negative surreal, which is not itself a plump ordinal.  *)