DEFINITION weight_le()
TYPE =
       t:T
         .f:natnat
           .g:natnat
             .n:nat.(le (f n) (g n))
               le (weight_map f t) (weight_map g t)
BODY =
       assume tT
          we proceed by induction on t to prove 
             f:natnat
               .g:natnat
                 .n:nat.(le (f n) (g n))
                   le (weight_map f t) (weight_map g t)
             case TSort : n:nat 
                the thesis becomes 
                f:natnat
                  .g:natnat
                    .n0:nat.(le (f n0) (g n0))
                      le (weight_map g (TSort n)) (weight_map g (TSort n))
                    assume fnatnat
                    assume gnatnat
                    suppose n0:nat.(le (f n0) (g n0))
                      by (le_n .)
                      we proved le (weight_map g (TSort n)) (weight_map g (TSort n))
                      that is equivalent to le (weight_map f (TSort n)) (weight_map g (TSort n))

                      f:natnat
                        .g:natnat
                          .n0:nat.(le (f n0) (g n0))
                            le (weight_map g (TSort n)) (weight_map g (TSort n))
             case TLRef : n:nat 
                the thesis becomes 
                f:natnat
                  .g:natnat.H:n0:nat.(le (f n0) (g n0)).(le (f n) (g n))
                    assume fnatnat
                    assume gnatnat
                    suppose Hn0:nat.(le (f n0) (g n0))
                      by (H .)
                      we proved le (f n) (g n)
                      that is equivalent to le (weight_map f (TLRef n)) (weight_map g (TLRef n))

                      f:natnat
                        .g:natnat.H:n0:nat.(le (f n0) (g n0)).(le (f n) (g n))
             case THead 
                we need to prove 
                k:K
                  .t0:T
                    .f:natnat
                        .g:natnat
                          .n:nat.(le (f n) (g n))
                            le (weight_map f t0) (weight_map g t0)
                      t1:T
                           .f:natnat
                               .g:natnat
                                 .n:nat.(le (f n) (g n))
                                   le (weight_map f t1) (weight_map g t1)
                             f:natnat
                                  .g:natnat
                                    .n:nat.(le (f n) (g n))
                                      le (weight_map f (THead k t0 t1)) (weight_map g (THead k t0 t1))
                   assume kK
                      we proceed by induction on k to prove 
                         t0:T
                           .f:natnat
                               .g:natnat
                                 .n:nat.(le (f n) (g n))
                                   le (weight_map f t0) (weight_map g t0)
                             t1:T
                                  .f:natnat
                                      .g:natnat
                                        .n:nat.(le (f n) (g n))
                                          le (weight_map f t1) (weight_map g t1)
                                    f:natnat
                                         .g:natnat
                                           .n:nat.(le (f n) (g n))
                                             le (weight_map f (THead k t0 t1)) (weight_map g (THead k t0 t1))
                         case Bind : b:B 
                            the thesis becomes 
                            t0:T
                              .f:natnat
                                  .g:natnat
                                    .n:nat.(le (f n) (g n))
                                      le (weight_map f t0) (weight_map g t0)
                                t1:T
                                     .f:natnat
                                         .g:natnat
                                           .n:nat.(le (f n) (g n))
                                             le (weight_map f t1) (weight_map g t1)
                                       f:natnat
                                            .g:natnat
                                              .n:nat.(le (f n) (g n))
                                                (le
                                                     weight_map f (THead (Bind b) t0 t1)
                                                     weight_map g (THead (Bind b) t0 t1))
                               we proceed by induction on b to prove 
                                  t0:T
                                    .f:natnat
                                        .g:natnat
                                          .n:nat.(le (f n) (g n))
                                            le (weight_map f t0) (weight_map g t0)
                                      t1:T
                                           .f:natnat
                                               .g:natnat
                                                 .n:nat.(le (f n) (g n))
                                                   le (weight_map f t1) (weight_map g t1)
                                             f:natnat
                                                  .g:natnat
                                                    .n:nat.(le (f n) (g n))
                                                      (le
                                                           <λb1:B.nat>
                                                             CASE b OF
                                                               Abbr
                                                                   S
                                                                     plus
                                                                       weight_map f t0
                                                                       weight_map (wadd f (S (weight_map f t0))) t1
                                                             | AbstS (plus (weight_map f t0) (weight_map (wadd f O) t1))
                                                             | VoidS (plus (weight_map f t0) (weight_map (wadd f O) t1))
                                                           <λb1:B.nat>
                                                             CASE b OF
                                                               Abbr
                                                                   S
                                                                     plus
                                                                       weight_map g t0
                                                                       weight_map (wadd g (S (weight_map g t0))) t1
                                                             | AbstS (plus (weight_map g t0) (weight_map (wadd g O) t1))
                                                             | VoidS (plus (weight_map g t0) (weight_map (wadd g O) t1)))
                                  case Abbr : 
                                     the thesis becomes 
                                     t0:T
                                       .f:natnat
                                           .g:natnat
                                             .n:nat.(le (f n) (g n))
                                               le (weight_map f t0) (weight_map g t0)
                                         t1:T
                                              .f:natnat
                                                  .g:natnat
                                                    .n:nat.(le (f n) (g n))
                                                      le (weight_map f t1) (weight_map g t1)
                                                f:natnat
                                                     .g:natnat
                                                       .n:nat.(le (f n) (g n))
                                                         (le
                                                              <λb1:B.nat>
                                                                CASE Abbr OF
                                                                  Abbr
                                                                      S
                                                                        plus
                                                                          weight_map f t0
                                                                          weight_map (wadd f (S (weight_map f t0))) t1
                                                                | AbstS (plus (weight_map f t0) (weight_map (wadd f O) t1))
                                                                | VoidS (plus (weight_map f t0) (weight_map (wadd f O) t1))
                                                              <λb1:B.nat>
                                                                CASE Abbr OF
                                                                  Abbr
                                                                      S
                                                                        plus
                                                                          weight_map g t0
                                                                          weight_map (wadd g (S (weight_map g t0))) t1
                                                                | AbstS (plus (weight_map g t0) (weight_map (wadd g O) t1))
                                                                | VoidS (plus (weight_map g t0) (weight_map (wadd g O) t1)))
                                         assume t0T
                                         suppose H
                                            f:natnat
                                              .g:natnat
                                                .n:nat.(le (f n) (g n))
                                                  le (weight_map f t0) (weight_map g t0)
                                         assume t1T
                                         suppose H0
                                            f:natnat
                                              .g:natnat
                                                .n:nat.(le (f n) (g n))
                                                  le (weight_map f t1) (weight_map g t1)
                                         assume fnatnat
                                         assume gnatnat
                                         suppose H1n:nat.(le (f n) (g n))
                                           (h1
                                              by (H . . H1)
le (weight_map f t0) (weight_map g t0)
                                           end of h1
                                           (h2
                                              assume nnat
                                                 by (H . . H1)
                                                 we proved le (weight_map f t0) (weight_map g t0)
                                                 by (le_n_S . . previous)
                                                 we proved le (S (weight_map f t0)) (S (weight_map g t0))
                                                 by (wadd_le . . H1 . . previous .)
                                                 we proved 
                                                    le
                                                      wadd f (S (weight_map f t0)) n
                                                      wadd g (S (weight_map g t0)) n
                                              we proved 
                                                 n:nat
                                                   .le
                                                     wadd f (S (weight_map f t0)) n
                                                     wadd g (S (weight_map g t0)) n
                                              by (H0 . . previous)

                                                 le
                                                   weight_map (wadd f (S (weight_map f t0))) t1
                                                   weight_map (wadd g (S (weight_map g t0))) t1
                                           end of h2
                                           by (le_plus_plus . . . . h1 h2)
                                           we proved 
                                              le
                                                plus
                                                  weight_map f t0
                                                  weight_map (wadd f (S (weight_map f t0))) t1
                                                plus
                                                  weight_map g t0
                                                  weight_map (wadd g (S (weight_map g t0))) t1
                                           by (le_n_S . . previous)
                                           we proved 
                                              le
                                                S
                                                  plus
                                                    weight_map f t0
                                                    weight_map (wadd f (S (weight_map f t0))) t1
                                                S
                                                  plus
                                                    weight_map g t0
                                                    weight_map (wadd g (S (weight_map g t0))) t1
                                           that is equivalent to 
                                              le
                                                <λb1:B.nat>
                                                  CASE Abbr OF
                                                    Abbr
                                                        S
                                                          plus
                                                            weight_map f t0
                                                            weight_map (wadd f (S (weight_map f t0))) t1
                                                  | AbstS (plus (weight_map f t0) (weight_map (wadd f O) t1))
                                                  | VoidS (plus (weight_map f t0) (weight_map (wadd f O) t1))
                                                <λb1:B.nat>
                                                  CASE Abbr OF
                                                    Abbr
                                                        S
                                                          plus
                                                            weight_map g t0
                                                            weight_map (wadd g (S (weight_map g t0))) t1
                                                  | AbstS (plus (weight_map g t0) (weight_map (wadd g O) t1))
                                                  | VoidS (plus (weight_map g t0) (weight_map (wadd g O) t1))

                                           t0:T
                                             .f:natnat
                                                 .g:natnat
                                                   .n:nat.(le (f n) (g n))
                                                     le (weight_map f t0) (weight_map g t0)
                                               t1:T
                                                    .f:natnat
                                                        .g:natnat
                                                          .n:nat.(le (f n) (g n))
                                                            le (weight_map f t1) (weight_map g t1)
                                                      f:natnat
                                                           .g:natnat
                                                             .n:nat.(le (f n) (g n))
                                                               (le
                                                                    <λb1:B.nat>
                                                                      CASE Abbr OF
                                                                        Abbr
                                                                            S
                                                                              plus
                                                                                weight_map f t0
                                                                                weight_map (wadd f (S (weight_map f t0))) t1
                                                                      | AbstS (plus (weight_map f t0) (weight_map (wadd f O) t1))
                                                                      | VoidS (plus (weight_map f t0) (weight_map (wadd f O) t1))
                                                                    <λb1:B.nat>
                                                                      CASE Abbr OF
                                                                        Abbr
                                                                            S
                                                                              plus
                                                                                weight_map g t0
                                                                                weight_map (wadd g (S (weight_map g t0))) t1
                                                                      | AbstS (plus (weight_map g t0) (weight_map (wadd g O) t1))
                                                                      | VoidS (plus (weight_map g t0) (weight_map (wadd g O) t1)))
                                  case Abst : 
                                     the thesis becomes 
                                     t0:T
                                       .f:natnat
                                           .g:natnat
                                             .n:nat.(le (f n) (g n))
                                               le (weight_map f t0) (weight_map g t0)
                                         t1:T
                                              .f:natnat
                                                  .g:natnat
                                                    .n:nat.(le (f n) (g n))
                                                      le (weight_map f t1) (weight_map g t1)
                                                f:natnat
                                                     .g:natnat
                                                       .n:nat.(le (f n) (g n))
                                                         (le
                                                              <λb1:B.nat>
                                                                CASE Abst OF
                                                                  Abbr
                                                                      S
                                                                        plus
                                                                          weight_map f t0
                                                                          weight_map (wadd f (S (weight_map f t0))) t1
                                                                | AbstS (plus (weight_map f t0) (weight_map (wadd f O) t1))
                                                                | VoidS (plus (weight_map f t0) (weight_map (wadd f O) t1))
                                                              <λb1:B.nat>
                                                                CASE Abst OF
                                                                  Abbr
                                                                      S
                                                                        plus
                                                                          weight_map g t0
                                                                          weight_map (wadd g (S (weight_map g t0))) t1
                                                                | AbstS (plus (weight_map g t0) (weight_map (wadd g O) t1))
                                                                | VoidS (plus (weight_map g t0) (weight_map (wadd g O) t1)))
                                         assume t0T
                                         suppose H
                                            f:natnat
                                              .g:natnat
                                                .n:nat.(le (f n) (g n))
                                                  le (weight_map f t0) (weight_map g t0)
                                         assume t1T
                                         suppose H0
                                            f:natnat
                                              .g:natnat
                                                .n:nat.(le (f n) (g n))
                                                  le (weight_map f t1) (weight_map g t1)
                                         assume fnatnat
                                         assume gnatnat
                                         suppose H1n:nat.(le (f n) (g n))
                                           (h1
                                              by (H . . H1)
le (weight_map f t0) (weight_map g t0)
                                           end of h1
                                           (h2
                                              assume nnat
                                                 by (le_n .)
                                                 we proved le O O
                                                 by (wadd_le . . H1 . . previous .)
                                                 we proved le (wadd f O n) (wadd g O n)
                                              we proved n:nat.(le (wadd f O n) (wadd g O n))
                                              by (H0 . . previous)
le (weight_map (wadd f O) t1) (weight_map (wadd g O) t1)
                                           end of h2
                                           by (le_plus_plus . . . . h1 h2)
                                           we proved 
                                              le
                                                plus (weight_map f t0) (weight_map (wadd f O) t1)
                                                plus (weight_map g t0) (weight_map (wadd g O) t1)
                                           by (le_n_S . . previous)
                                           we proved 
                                              le
                                                S (plus (weight_map f t0) (weight_map (wadd f O) t1))
                                                S (plus (weight_map g t0) (weight_map (wadd g O) t1))
                                           that is equivalent to 
                                              le
                                                <λb1:B.nat>
                                                  CASE Abst OF
                                                    Abbr
                                                        S
                                                          plus
                                                            weight_map f t0
                                                            weight_map (wadd f (S (weight_map f t0))) t1
                                                  | AbstS (plus (weight_map f t0) (weight_map (wadd f O) t1))
                                                  | VoidS (plus (weight_map f t0) (weight_map (wadd f O) t1))
                                                <λb1:B.nat>
                                                  CASE Abst OF
                                                    Abbr
                                                        S
                                                          plus
                                                            weight_map g t0
                                                            weight_map (wadd g (S (weight_map g t0))) t1
                                                  | AbstS (plus (weight_map g t0) (weight_map (wadd g O) t1))
                                                  | VoidS (plus (weight_map g t0) (weight_map (wadd g O) t1))

                                           t0:T
                                             .f:natnat
                                                 .g:natnat
                                                   .n:nat.(le (f n) (g n))
                                                     le (weight_map f t0) (weight_map g t0)
                                               t1:T
                                                    .f:natnat
                                                        .g:natnat
                                                          .n:nat.(le (f n) (g n))
                                                            le (weight_map f t1) (weight_map g t1)
                                                      f:natnat
                                                           .g:natnat
                                                             .n:nat.(le (f n) (g n))
                                                               (le
                                                                    <λb1:B.nat>
                                                                      CASE Abst OF
                                                                        Abbr
                                                                            S
                                                                              plus
                                                                                weight_map f t0
                                                                                weight_map (wadd f (S (weight_map f t0))) t1
                                                                      | AbstS (plus (weight_map f t0) (weight_map (wadd f O) t1))
                                                                      | VoidS (plus (weight_map f t0) (weight_map (wadd f O) t1))
                                                                    <λb1:B.nat>
                                                                      CASE Abst OF
                                                                        Abbr
                                                                            S
                                                                              plus
                                                                                weight_map g t0
                                                                                weight_map (wadd g (S (weight_map g t0))) t1
                                                                      | AbstS (plus (weight_map g t0) (weight_map (wadd g O) t1))
                                                                      | VoidS (plus (weight_map g t0) (weight_map (wadd g O) t1)))
                                  case Void : 
                                     the thesis becomes 
                                     t0:T
                                       .f:natnat
                                           .g:natnat
                                             .n:nat.(le (f n) (g n))
                                               le (weight_map f t0) (weight_map g t0)
                                         t1:T
                                              .f:natnat
                                                  .g:natnat
                                                    .n:nat.(le (f n) (g n))
                                                      le (weight_map f t1) (weight_map g t1)
                                                f:natnat
                                                     .g:natnat
                                                       .n:nat.(le (f n) (g n))
                                                         (le
                                                              <λb1:B.nat>
                                                                CASE Void OF
                                                                  Abbr
                                                                      S
                                                                        plus
                                                                          weight_map f t0
                                                                          weight_map (wadd f (S (weight_map f t0))) t1
                                                                | AbstS (plus (weight_map f t0) (weight_map (wadd f O) t1))
                                                                | VoidS (plus (weight_map f t0) (weight_map (wadd f O) t1))
                                                              <λb1:B.nat>
                                                                CASE Void OF
                                                                  Abbr
                                                                      S
                                                                        plus
                                                                          weight_map g t0
                                                                          weight_map (wadd g (S (weight_map g t0))) t1
                                                                | AbstS (plus (weight_map g t0) (weight_map (wadd g O) t1))
                                                                | VoidS (plus (weight_map g t0) (weight_map (wadd g O) t1)))
                                         assume t0T
                                         suppose H
                                            f:natnat
                                              .g:natnat
                                                .n:nat.(le (f n) (g n))
                                                  le (weight_map f t0) (weight_map g t0)
                                         assume t1T
                                         suppose H0
                                            f:natnat
                                              .g:natnat
                                                .n:nat.(le (f n) (g n))
                                                  le (weight_map f t1) (weight_map g t1)
                                         assume fnatnat
                                         assume gnatnat
                                         suppose H1n:nat.(le (f n) (g n))
                                           (h1
                                              by (H . . H1)
le (weight_map f t0) (weight_map g t0)
                                           end of h1
                                           (h2
                                              assume nnat
                                                 by (le_n .)
                                                 we proved le O O
                                                 by (wadd_le . . H1 . . previous .)
                                                 we proved le (wadd f O n) (wadd g O n)
                                              we proved n:nat.(le (wadd f O n) (wadd g O n))
                                              by (H0 . . previous)
le (weight_map (wadd f O) t1) (weight_map (wadd g O) t1)
                                           end of h2
                                           by (le_plus_plus . . . . h1 h2)
                                           we proved 
                                              le
                                                plus (weight_map f t0) (weight_map (wadd f O) t1)
                                                plus (weight_map g t0) (weight_map (wadd g O) t1)
                                           by (le_n_S . . previous)
                                           we proved 
                                              le
                                                S (plus (weight_map f t0) (weight_map (wadd f O) t1))
                                                S (plus (weight_map g t0) (weight_map (wadd g O) t1))
                                           that is equivalent to 
                                              le
                                                <λb1:B.nat>
                                                  CASE Void OF
                                                    Abbr
                                                        S
                                                          plus
                                                            weight_map f t0
                                                            weight_map (wadd f (S (weight_map f t0))) t1
                                                  | AbstS (plus (weight_map f t0) (weight_map (wadd f O) t1))
                                                  | VoidS (plus (weight_map f t0) (weight_map (wadd f O) t1))
                                                <λb1:B.nat>
                                                  CASE Void OF
                                                    Abbr
                                                        S
                                                          plus
                                                            weight_map g t0
                                                            weight_map (wadd g (S (weight_map g t0))) t1
                                                  | AbstS (plus (weight_map g t0) (weight_map (wadd g O) t1))
                                                  | VoidS (plus (weight_map g t0) (weight_map (wadd g O) t1))

                                           t0:T
                                             .f:natnat
                                                 .g:natnat
                                                   .n:nat.(le (f n) (g n))
                                                     le (weight_map f t0) (weight_map g t0)
                                               t1:T
                                                    .f:natnat
                                                        .g:natnat
                                                          .n:nat.(le (f n) (g n))
                                                            le (weight_map f t1) (weight_map g t1)
                                                      f:natnat
                                                           .g:natnat
                                                             .n:nat.(le (f n) (g n))
                                                               (le
                                                                    <λb1:B.nat>
                                                                      CASE Void OF
                                                                        Abbr
                                                                            S
                                                                              plus
                                                                                weight_map f t0
                                                                                weight_map (wadd f (S (weight_map f t0))) t1
                                                                      | AbstS (plus (weight_map f t0) (weight_map (wadd f O) t1))
                                                                      | VoidS (plus (weight_map f t0) (weight_map (wadd f O) t1))
                                                                    <λb1:B.nat>
                                                                      CASE Void OF
                                                                        Abbr
                                                                            S
                                                                              plus
                                                                                weight_map g t0
                                                                                weight_map (wadd g (S (weight_map g t0))) t1
                                                                      | AbstS (plus (weight_map g t0) (weight_map (wadd g O) t1))
                                                                      | VoidS (plus (weight_map g t0) (weight_map (wadd g O) t1)))
                               we proved 
                                  t0:T
                                    .f:natnat
                                        .g:natnat
                                          .n:nat.(le (f n) (g n))
                                            le (weight_map f t0) (weight_map g t0)
                                      t1:T
                                           .f:natnat
                                               .g:natnat
                                                 .n:nat.(le (f n) (g n))
                                                   le (weight_map f t1) (weight_map g t1)
                                             f:natnat
                                                  .g:natnat
                                                    .n:nat.(le (f n) (g n))
                                                      (le
                                                           <λb1:B.nat>
                                                             CASE b OF
                                                               Abbr
                                                                   S
                                                                     plus
                                                                       weight_map f t0
                                                                       weight_map (wadd f (S (weight_map f t0))) t1
                                                             | AbstS (plus (weight_map f t0) (weight_map (wadd f O) t1))
                                                             | VoidS (plus (weight_map f t0) (weight_map (wadd f O) t1))
                                                           <λb1:B.nat>
                                                             CASE b OF
                                                               Abbr
                                                                   S
                                                                     plus
                                                                       weight_map g t0
                                                                       weight_map (wadd g (S (weight_map g t0))) t1
                                                             | AbstS (plus (weight_map g t0) (weight_map (wadd g O) t1))
                                                             | VoidS (plus (weight_map g t0) (weight_map (wadd g O) t1)))

                                  t0:T
                                    .f:natnat
                                        .g:natnat
                                          .n:nat.(le (f n) (g n))
                                            le (weight_map f t0) (weight_map g t0)
                                      t1:T
                                           .f:natnat
                                               .g:natnat
                                                 .n:nat.(le (f n) (g n))
                                                   le (weight_map f t1) (weight_map g t1)
                                             f:natnat
                                                  .g:natnat
                                                    .n:nat.(le (f n) (g n))
                                                      (le
                                                           weight_map f (THead (Bind b) t0 t1)
                                                           weight_map g (THead (Bind b) t0 t1))
                         case Flat : :F 
                            the thesis becomes 
                            t0:T
                              .H:f0:natnat
                                       .g:natnat
                                         .(n:nat.(le (f0 n) (g n)))(le (weight_map f0 t0) (weight_map g t0))
                                .t1:T
                                  .H0:f0:natnat
                                             .g:natnat
                                               .(n:nat.(le (f0 n) (g n)))(le (weight_map f0 t1) (weight_map g t1))
                                    .f0:natnat
                                      .g:natnat
                                        .H1:n:nat.(le (f0 n) (g n))
                                          .le
                                            S (plus (weight_map f0 t0) (weight_map f0 t1))
                                            S (plus (weight_map g t0) (weight_map g t1))
                                assume t0T
                                suppose H
                                   f0:natnat
                                     .g:natnat
                                       .(n:nat.(le (f0 n) (g n)))(le (weight_map f0 t0) (weight_map g t0))
                                assume t1T
                                suppose H0
                                   f0:natnat
                                     .g:natnat
                                       .(n:nat.(le (f0 n) (g n)))(le (weight_map f0 t1) (weight_map g t1))
                                assume f0natnat
                                assume gnatnat
                                suppose H1n:nat.(le (f0 n) (g n))
                                  (h1
                                     by (H . . H1)
le (weight_map f0 t0) (weight_map g t0)
                                  end of h1
                                  (h2
                                     by (H0 . . H1)
le (weight_map f0 t1) (weight_map g t1)
                                  end of h2
                                  by (le_plus_plus . . . . h1 h2)
                                  we proved 
                                     le
                                       plus (weight_map f0 t0) (weight_map f0 t1)
                                       plus (weight_map g t0) (weight_map g t1)
                                  by (le_n_S . . previous)
                                  we proved 
                                     le
                                       S (plus (weight_map f0 t0) (weight_map f0 t1))
                                       S (plus (weight_map g t0) (weight_map g t1))
                                  that is equivalent to 
                                     le
                                       weight_map f0 (THead (Flat __8) t0 t1)
                                       weight_map g (THead (Flat __8) t0 t1)

                                  t0:T
                                    .H:f0:natnat
                                             .g:natnat
                                               .(n:nat.(le (f0 n) (g n)))(le (weight_map f0 t0) (weight_map g t0))
                                      .t1:T
                                        .H0:f0:natnat
                                                   .g:natnat
                                                     .(n:nat.(le (f0 n) (g n)))(le (weight_map f0 t1) (weight_map g t1))
                                          .f0:natnat
                                            .g:natnat
                                              .H1:n:nat.(le (f0 n) (g n))
                                                .le
                                                  S (plus (weight_map f0 t0) (weight_map f0 t1))
                                                  S (plus (weight_map g t0) (weight_map g t1))
                      we proved 
                         t0:T
                           .f:natnat
                               .g:natnat
                                 .n:nat.(le (f n) (g n))
                                   le (weight_map f t0) (weight_map g t0)
                             t1:T
                                  .f:natnat
                                      .g:natnat
                                        .n:nat.(le (f n) (g n))
                                          le (weight_map f t1) (weight_map g t1)
                                    f:natnat
                                         .g:natnat
                                           .n:nat.(le (f n) (g n))
                                             le (weight_map f (THead k t0 t1)) (weight_map g (THead k t0 t1))

                      k:K
                        .t0:T
                          .f:natnat
                              .g:natnat
                                .n:nat.(le (f n) (g n))
                                  le (weight_map f t0) (weight_map g t0)
                            t1:T
                                 .f:natnat
                                     .g:natnat
                                       .n:nat.(le (f n) (g n))
                                         le (weight_map f t1) (weight_map g t1)
                                   f:natnat
                                        .g:natnat
                                          .n:nat.(le (f n) (g n))
                                            le (weight_map f (THead k t0 t1)) (weight_map g (THead k t0 t1))
          we proved 
             f:natnat
               .g:natnat
                 .n:nat.(le (f n) (g n))
                   le (weight_map f t) (weight_map g t)
       we proved 
          t:T
            .f:natnat
              .g:natnat
                .n:nat.(le (f n) (g n))
                  le (weight_map f t) (weight_map g t)