
%% PVS Version 5.0 - Allegro CL Enterprise Edition 8.2 [64-bit Mac OS X (Intel)] (Nov 3, 2011 16:18)
%% 8.2 [64-bit Mac OS X (Intel)] (Nov 3, 2011 16:18)
$$$pvs-strategies
(defstep s-rest ()
   (then 
      (skosimp)
      (expand "step")
      (assert)
      (hide-all-but ( 1 ) +)
      (branch (split) ((grind))) ) 
      "help string"
      "skosimp, expand step, assert, hide, split, grind" )

(defstep replaceh (arg)
   (replace arg :hide? t) 
   "help string" 
   "replace arg :hide? t" )

(defstep s-ensures () 
   (then  
     (skosimp)
     (use ensures_leto)
     (assert)
     (hide 2)
     (expand "ensures")
     (expand "co")
     (expand "transient")
     (expand "<=" +)
     (expand "wp")
     (expand "cap")
     (expand "cup")
     (expand "neg")
     (expand "at") )
   "help-string"
   "using ensures, and expanding; the argument is the responsible thread" )

$$$ownpred.pvs
% Wim H. Hesselink, October 2012

ownpred[t: TYPE]: THEORY
% to avoid the function member
% about predicates, relations, and mu-calculus

BEGIN
  p, q, r, s: VAR pred[t]
  x, y: VAR t
  k, n: VAR nat
  pseq: VAR [nat -> pred[t]]
  rel: VAR pred[[t, t]]

  neg(p)(x): bool =
    NOT p(x)

  neg_involutive: LEMMA
    neg(neg(p)) = p

  cup(p, q)(x): bool =
    p(x) OR q (x)

  cap(p, q)(x): bool =
    p(x) AND q (x)

  bigcup(pseq)(x): bool =
    EXISTS k: pseq(k)(x)

  bigcup(n, pseq)(x): bool =
    EXISTS k: k < n AND pseq(k)(x)

  wp(rel)(q)(x): bool =
    FORALL y: rel(x, y) IMPLIES q(y)

END ownpred

$$$ownpred.prf
(ownpred
 (neg_involutive 0
  (neg_involutive-1 nil 3358782077
   ("" (skolem!)
    (("" (apply-extensionality :hide? t)
      (("" (expand "neg") (("" (propax) nil nil)) nil)) nil))
    nil)
   ((t formal-type-decl nil ownpred nil)
    (boolean nonempty-type-decl nil booleans nil)
    (neg const-decl "bool" ownpred nil)
    (pred type-eq-decl nil defined_types nil)
    (bool nonempty-type-eq-decl nil booleans nil))
   shostak)))


$$$bdUnity.pvs
% Bounded Unity by Wim H. Hesselink, September-October 2013

bdUnity[ t: TYPE ]: THEORY

BEGIN
  IMPORTING ownpred, 
    maxfinset % used in run_round below

  p, q, pq, pa, pm: VAR pred[t]
  x, y: VAR t
  i, j, k, m, n: VAR nat
  xs, ys: VAR [nat -> t]
  pset: VAR pred[pred[t]]

  specification: TYPE = [#
    inv: pred[t],               % the global invariant
    step: pred[[t, t]],         % the step relation
    fwd: [nat -> pred[[t, t]]]  % weak fairness relations
  #]

  s: VAR specification

  enabled(s)(k)(x): bool =
    EXISTS y: s`fwd(k)(x, y)

  good(s): bool =
    reflexive?(s`step)                    % 
    AND (s`inv <= wp(s`step)(s`inv))      % 
    AND (FORALL k: s`fwd(k) <= s`step)    % all used in machine closed
    AND (FORALL x: s`inv(x) IMPLIES       % locally finite(s)
      is_finite({k | enabled(s)(k)(x)}) ) % 

  nuspec: (good) = (#
    inv := fullset,
    step := fullset,
    fwd := (LAMBDA i: emptyset)
  #)

  co(s)(p, q): bool =
    cap(p, s`inv) <= wp(s`step)(q)

  unless(s)(p, q): bool =
    cap(cap(p, neg(q)), s`inv) <=  wp(s`step)(cup(p, q))
  
  unless_co: LEMMA
    unless(s)(p, q) = co(s)(cap(p, neg(q)), cup(p, q))

  co_unless: LEMMA
    pm = difference(q, p) AND p <= pa AND pa <= q
    IMPLIES co(s)(p, q) = unless(s)(pa, pm)

  stable(s)(p): bool =
    co(s)(p, p)

  cobar(s)(p, q): bool =
    EXISTS k: p <= enabled(s)(k)
      AND FORALL x, y: p(x) AND s`fwd(k)(x, y) IMPLIES q(y)

  transient(s)(p): bool =
    EXISTS k: cap(p, s`inv) <= enabled(s)(k)
      AND FORALL x, y: p(x) AND s`fwd(k)(x, y) AND s`inv(x)
          IMPLIES NOT p(y)

  ensuresA(s)(p, q): bool =
    co(s)(cap(p, neg(q)), cup(p, q))
    AND cobar(s)(cap(cap(p, neg(q)), s`inv), q)

  ensures(s)(p, q): bool =
    co(s)(cap(p, neg(q)), cup(p, q))
    AND transient(s)(cap(p, neg(q)))

  ensuresA_ensures: LEMMA
    good(s) IMPLIES 
      ensuresA(s)(p, q) = ensures(s)(p, q)

  fw(s)(k)(x, y): bool =
    s`fwd(k)(x, y) OR NOT enabled(s)(k)(x)

  subset_ensures: LEMMA % 
    cap(p, s`inv) <= q IMPLIES ensures(s)(p, q)

  stable_unless: LEMMA
    unless(s)(p, q) AND stable(s)(pq)
    IMPLIES unless(s)(cap(p, pq), q)

  stable_ensures: LEMMA % 
    ensures(s)(p, q) AND stable(s)(pq)
    IMPLIES ensures(s)(cap(p, pq), q)

% Formal semantics of bounded unity

% An operational interpretation

  exec(s)(xs): bool =
    FORALL n: s`step(xs(n), xs(n+1)) AND s`inv(xs(n))

  weakfair(s)(k)(xs): bool =
    FORALL n: EXISTS i: 
      fw(s)(k)(xs(n+i), xs(n+i+1))

  run(s)(xs): bool = 
    exec(s)(xs) AND FORALL k: weakfair(s)(k)(xs)

  sched(n): nat =
    min({i | EXISTS k: k * k + i = n})

  sched_schedules: LEMMA
    i <= j IMPLIES sched(j * j + i) = i 

  choice(s, k, x): pred[t] =
    { y | s`fwd(k)(x, y)}

  chosen(s, k, x): t =
    IF empty?(choice(s, k, x)) THEN x 
    ELSE epsilon(choice(s, k, x)) ENDIF

  runfrom(s, x)(n): RECURSIVE t =
    IF n = 0 THEN x 
    ELSE chosen(s, sched(n - 1), runfrom(s, x)(n - 1)) ENDIF
    MEASURE n

  runfrom_run: LEMMA
    s`inv(x) AND good(s) 
    IMPLIES run(s)(runfrom(s, x))

  run_exists: LEMMA 
    s`inv(x) AND good(s) 
    IMPLIES EXISTS xs: run(s)(xs) AND xs(0) = x
      
  machine_closed: LEMMA 
    exec(s)(xs) AND good(s) 
    IMPLIES 
      EXISTS ys: run(s)(ys) AND 
        (FORALL i: i  <= n IMPLIES ys(i) = xs(i)) 
      
  drop(n)(xs)(i): t =
    xs(n + i)

  drop_run: LEMMA
    run(s)(xs) IMPLIES run(s)(drop(n)(xs))

  round(s)(n, xs): bool =
    FORALL k: EXISTS i: i < n AND fw(s)(k)(xs(i), xs(i+1))

  run_round: LEMMA % locally finite
    run(s)(xs) AND good(s)
    IMPLIES EXISTS n: round(s)(n, xs)

  rounds(s)(i)(n, xs): RECURSIVE bool =
    IF i = 0 THEN true ELSE
      EXISTS j: j <= n AND round(s)(j, xs)
        AND rounds(s)(i-1)(n-j, drop(j)(xs))
    ENDIF 
    MEASURE i

  run_rounds: LEMMA
    run(s)(xs) AND good(s)
    IMPLIES EXISTS n: rounds(s)(i)(n, xs)

  rounds_split: LEMMA
    rounds(s)(j+m)(n, xs) IMPLIES 
    EXISTS i: i <= n AND rounds(s)(j)(i, xs) 
      AND rounds(s)(m)(n-i, drop(i)(xs))

  rounds_down: LEMMA
    i <= j AND rounds(s)(j)(n, xs) IMPLIES rounds(s)(i)(n, xs)

  rounds_furtheron: LEMMA
    rounds(s)(j)(n, drop(i)(xs)) 
    IMPLIES rounds(s)(j)(n + i, xs)

  leto(s)(j, p, q): bool =       % bounded leads-to
    FORALL xs: exec(s)(xs) AND p(xs(0)) IMPLIES 
      FORALL n: rounds(s)(j)(n, xs) 
      IMPLIES EXISTS i: i <= n AND q(xs(i))

  leadsto(s)(p, q): bool =
    FORALL xs: run(s)(xs) AND p(xs(0)) IMPLIES
      EXISTS i: q(xs(i))

  leto_leadsto: LEMMA
    leto(s)(j, p, q)  AND good(s)
    IMPLIES leadsto(s)(p, q)

% Fundamental rules for leto

  subset_leto: LEMMA % 
    cap(p, s`inv) <= q IMPLIES leto(s)(j, p, q)

  ensures_leto: LEMMA % 
    ensures(s)(p, q)
    IMPLIES leto(s)(1, p, q)

  leto_union: LEMMA
    (FORALL p: pset(p) IMPLIES leto(s)(n, p, q))
    IMPLIES leto(s)(n, Union(pset), q)

  leto_transitive: LEMMA
    leto(s)(m, p, pq) AND leto(s)(n, pq, q)
    IMPLIES leto(s)(m + n, p, q)

  PSP_leto: LEMMA % 
    leto(s)(n, p, q) AND unless(s)(pa, pm) 
    IMPLIES leto(s)(n, cap(p, pa), cup(cap(q, pa), pm))

  PSP0_leto: LEMMA % 
    unless(s)(p, q) AND leto(s)(n, fullset, neg(pa)) AND p <= pa
    IMPLIES leto(s)(n, p, q)

  leto_completion: LEMMA
    (FORALL q: pset(q) 
       IMPLIES leto(s)(n, p, q) AND unless(s)(q, pm) )
    IMPLIES leto(s)(n, p, cup(Intersection(pset), pm))

% Derived rules 

  stable_conjunction: LEMMA
    leto(s)(n, p, q) AND stable(s)(pa) 
    IMPLIES leto(s) (n, cap(p, pa), cap(q, pa))

  cup_leto: LEMMA
    leto(s)(m, p, q) AND leto(s)(m, pq, q) 
    IMPLIES leto(s)(m, cup(p, pq), q)

  leto_transitive_2: LEMMA
    leto(s)(m, p, cup(pq, pa)) AND leto(s)(n, pq, cup(q, pa))
    IMPLIES leto(s)(m + n, p, cup(q, pa))

  leto_transitive_1: LEMMA
    leto(s)(m, p, cup(pq, q)) AND leto(s)(n, pq, q)
    IMPLIES leto(s)(m + n, p, q)

  leto_up: LEMMA % 
    leto(s)(i, p, q) AND i <= j IMPLIES leto(s)(j, p, q)

  sub_leto: LEMMA
    cap(p, s`inv) <= pq AND leto(s)(n, pq, q)
    IMPLIES leto(s)(n, p, q)
   
  leto_sub: LEMMA
    cap(pq, s`inv) <= q AND leto(s)(n, p, pq)
    IMPLIES leto(s)(n, p, q)

  shunting_leto: LEMMA
    leto(s)(n, cap(p, neg(pq)), q) 
    IMPLIES leto(s)(n, p, cup(q, pq)) 

  leto_inv: LEMMA
    leto(s)(j, cap(p, s`inv), q) = leto(s)(j, p, q)

%%%%%%%%  Measure

  z: VAR int
  vf, svf: VAR [t -> int]
  vena: VAR [nat -> pred[t]]
  r: VAR posnat
  fac, del: VAR posnat % factor, delay 
  delay, offset: VAR nat
  cov: VAR [nat -> pred[t]]
  we: VAR [posnat -> posnat]
  mwe: VAR posnat
  alt, exc: VAR pred[t]

  leq(z, vf)(x): bool =
    z <= vf(x)

  disgrowth(s, vf, we, cov): bool =
    (FORALL z, r: leto(s)(we(r), cap(leq(z, vf), cov(r)), 
                          leq(z + we(r), vf) ))

  distributed_progress: THEOREM  % 
    disgrowth(s, vf, we, cov)
    AND (FORALL r: we(r) <= mwe)
    AND (FORALL x: s`inv(x) IMPLIES EXISTS i: cov(i)(x))
    IMPLIES leto(s)(n + mwe - 1, leq(z, vf), cup(leq(z + n, vf), cov(0)))

  proportional_progress: THEOREM 
    (FORALL k, z: leto(s)(k + offset, leq(z, vf), cup(leq(z + k, vf), alt)))
    AND (FORALL x: s`inv(x) IMPLIES fac * svf(x) <= vf(x))
    AND (FORALL x: s`inv(x) IMPLIES vf(x) <= fac * svf(x) + delay OR exc(x))
    IMPLIES leto(s)(fac * i + delay + offset, 
              leq(z, svf), cup(leq(z + i, svf), cup(alt, exc)) )

  fwd_measure(vf, vena, s): bool =
    (FORALL x, y: s`step(x, y) AND s`inv(x) IMPLIES vf(x) <= vf(y)) % 1
    AND (FORALL k: cap(vena(k), s`inv) <= enabled(s)(k))            % 2  
    AND (FORALL k, x, y: s`fwd(k)(x, y) AND vena(k)(x) AND s`inv(x) % 3
         IMPLIES vf(x) < vf(y) )
    AND (FORALL k, x, y: s`step(x, y) AND vena(k)(x) AND s`inv(x)   % 4
         IMPLIES vena(k)(y) OR vf(x) < vf(y) )

  fwd_measure_ensures: LEMMA %% using %1, %4, %2, %3, using ensures
    fwd_measure(vf, vena, s) IMPLIES 
      leto(s)(1, cap(leq(z, vf), vena(k)), leq(z + 1, vf))

  none(vena, s)(x): bool =
    FORALL k: NOT vena(k)(x)

  fwd_measure_leadsto: LEMMA
    fwd_measure(vf, vena, s) IMPLIES 
      leto(s)(1, leq(z, vf), cup(leq(z + 1, vf), none(vena, s)))

  fwd_measure_leadsto_more: LEMMA
    fwd_measure(vf, vena, s) IMPLIES 
      leto(s)(n, leq(z, vf), cup(leq(z + n, vf), none(vena, s)))

  proportional(vf, svf, fac, del)(x): bool =
    fac * svf(x) <= vf(x) AND vf(x) < fac * svf(x) + del 

  proportional_measure_leadsto: THEOREM 
    fwd_measure(vf, vena, s) 
    AND subset?(s`inv, proportional(vf, svf, fac, del))
    AND fac * (i - 1) + del <= n 
    IMPLIES leto(s)(n, leq(z, svf), cup(leq(z + i, svf), none(vena, s)))

  proportionA(vf, svf, fac)(x): bool =
    fac * svf(x) <= vf(x) 

  proportionB(vf, svf, fac, del)(x): bool =
    vf(x) < fac * svf(x) + del 

  proportional_measure_leadsto1: THEOREM 
    fwd_measure(vf, vena, s) 
    AND subset?(s`inv, proportionA(vf, svf, fac))
    AND subset?(cap(s`inv, p), proportionB(vf, svf, fac, del))
    AND fac * (i - 1) + del <= n 
    IMPLIES leto(s)(n, leq(z, svf), 
              cup(neg(p), cup(leq(z + i, svf), none(vena, s))) )

%%%% now the same for leadsto

  subset_leadsto: LEMMA % 
    cap(p, s`inv) <= q IMPLIES leadsto(s)(p, q)

  ensures_leadsto: LEMMA % 
    ensures(s)(p, q)
    IMPLIES leadsto(s)(p, q)

  leadsto_union: LEMMA
    (FORALL p: pset(p) IMPLIES leadsto(s)(p, q))
    IMPLIES leadsto(s)(Union(pset), q)

  leadsto_transitive: LEMMA
    leadsto(s)(p, pq) AND leadsto(s)(pq, q)
    IMPLIES leadsto(s)(p, q)

  PSP_leadsto: LEMMA % 
    leadsto(s)(p, q) AND unless(s)(pa, pm) 
    IMPLIES leadsto(s)(cap(p, pa), cup(cap(q, pa), pm))

  % leadsto_completion: LEMMA % This can be proved if pset is finite.
  %   (FORALL q: pset(q) 
  %      IMPLIES leadsto(s)(n, p, q) AND unless(s)(q, pm) )
  %   IMPLIES leadsto(s)(n, p, cup(Intersection(pset), pm))

% Derived rules 

  cup_leadsto: LEMMA % can be derived from leadsto_union
    leadsto(s)(p, q) AND leadsto(s)(pq, q) 
    IMPLIES leadsto(s)(cup(p, pq), q)

  leadsto_transitive_2: LEMMA
    leadsto(s)(p, cup(pq, pa)) AND leadsto(s)(pq, cup(q, pa))
    IMPLIES leadsto(s)(p, cup(q, pa))

  leadsto_transitive_1: LEMMA
    leadsto(s)(p, cup(pq, q)) AND leadsto(s)(pq, q)
    IMPLIES leadsto(s)(p, q)

  sub_leadsto: LEMMA
    cap(p, s`inv) <= pq AND leadsto(s)(pq, q)
    IMPLIES leadsto(s)(p, q)
   
  leadsto_sub: LEMMA
    cap(pq, s`inv) <= q AND leadsto(s)(p, pq)
    IMPLIES leadsto(s)(p, q)

  shunting_leadsto: LEMMA
    leadsto(s)(cap(p, neg(pq)), q) 
    IMPLIES leadsto(s)(p, cup(q, pq)) 

  leadsto_inv: LEMMA
    leadsto(s)(cap(p, s`inv), q) = leadsto(s)(p, q)

  bounding_leadsto: LEMMA
    leadsto(s)(p, q) AND leto(s)(n, p, cup(q, pa))
    AND stable(s)(pa) AND empty?(cap(q, pa)) AND good(s)
    IMPLIES leto(s)(n, p, q)

END bdUnity

$$$bdUnity.prf
(bdUnity
 (nuspec_TCC1 0
  (nuspec_TCC1-1 nil 3591000903
   ("" (expand "good")
    (("" (split)
      (("1" (grind) nil nil) ("2" (grind) nil nil)
       ("3" (grind) nil nil)
       ("4" (skosimp)
        (("4" (expand "is_finite")
          (("4" (inst + 1 id)
            (("1" (grind) nil nil)
             ("2" (skosimp)
              (("2" (expand "id")
                (("2" (expand "fullset")
                  (("2" (typepred x1!1)
                    (("2" (expand "enabled")
                      (("2" (expand "emptyset")
                        (("2" (propax) nil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((fullset const-decl "set" sets nil)
    (reflexive? const-decl "bool" relations nil)
    (wp const-decl "bool" ownpred nil)
    (<= const-decl "bool" mucalculus nil)
    (emptyset const-decl "set" sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (injective? const-decl "bool" functions nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (below type-eq-decl nil nat_types nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (t formal-type-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (specification type-eq-decl nil bdUnity nil)
    (enabled const-decl "bool" bdUnity nil)
    (set type-eq-decl nil sets nil)
    (x!1 skolem-const-decl "t" bdUnity nil)
    (< const-decl "bool" reals nil)
    (bijective? const-decl "bool" functions nil)
    (id const-decl "(bijective?[T, T])" identity nil)
    (good const-decl "bool" bdUnity nil))
   nil))
 (unless_co 0
  (unless_co-1 nil 3588931070 ("" (grind) nil nil)
   ((neg const-decl "bool" ownpred nil)
    (cap const-decl "bool" ownpred nil)
    (cup const-decl "bool" ownpred nil)
    (wp const-decl "bool" ownpred nil)
    (<= const-decl "bool" mucalculus nil)
    (unless const-decl "bool" bdUnity nil)
    (co const-decl "bool" bdUnity nil))
   shostak))
 (co_unless 0
  (co_unless-1 nil 3590830368
   ("" (skosimp)
    (("" (use unless_co)
      (("" (replace -1 :hide? t)
        ((""
          (case "cap(pa!1, neg(pm!1)) = p!1 AND cup(pa!1, pm!1) = q!1")
          (("1" (flatten) (("1" (assert) nil nil)) nil)
           ("2" (hide 2)
            (("2" (split)
              (("1" (apply-extensionality :hide? t)
                (("1" (iff) (("1" (grind) nil nil)) nil)) nil)
               ("2" (apply-extensionality :hide? t)
                (("2" (iff) (("2" (grind) nil nil)) nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((unless_co formula-decl nil bdUnity nil)
    (specification type-eq-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (t formal-type-decl nil bdUnity nil)
    (cup const-decl "bool" ownpred nil)
    (neg const-decl "bool" ownpred nil)
    (cap const-decl "bool" ownpred nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" mucalculus nil)
    (member const-decl "bool" sets nil)
    (difference const-decl "set" sets nil))
   shostak))
 (ensuresA_ensures 0
  (ensuresA_ensures-2 nil 3679320788
   ("" (skosimp)
    (("" (iff)
      (("" (prop)
        (("1" (expand "ensuresA")
          (("1" (expand "ensures")
            (("1" (flatten)
              (("1" (assert)
                (("1" (expand "transient")
                  (("1" (expand "cobar")
                    (("1" (skosimp)
                      (("1" (inst? +)
                        (("1" (assert)
                          (("1" (skosimp)
                            (("1" (expand "cap")
                              (("1"
                                (inst?)
                                (("1"
                                  (flatten)
                                  (("1"
                                    (assert)
                                    (("1"
                                      (expand "neg")
                                      (("1" (propax) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (expand "ensuresA")
          (("2" (expand "ensures")
            (("2" (flatten)
              (("2" (assert)
                (("2" (expand "cobar")
                  (("2" (expand "transient")
                    (("2" (skosimp)
                      (("2" (inst? +)
                        (("2" (assert)
                          (("2" (skosimp)
                            (("2" (inst?)
                              (("2"
                                (assert)
                                (("2"
                                  (expand "cap")
                                  (("2"
                                    (flatten)
                                    (("2"
                                      (expand "neg")
                                      (("2"
                                        (assert)
                                        (("2"
                                          (hide -2)
                                          (("2"
                                            (expand "co")
                                            (("2"
                                              (expand "<=")
                                              (("2"
                                                (expand "wp")
                                                (("2"
                                                  (expand "cap")
                                                  (("2"
                                                    (inst - x!1)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (expand "cup")
                                                        (("2"
                                                          (inst - y!1)
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (expand
                                                               "good")
                                                              (("2"
                                                                (flatten)
                                                                (("2"
                                                                  (inst?
                                                                   -6)
                                                                  (("2"
                                                                    (expand
                                                                     "<=")
                                                                    (("2"
                                                                      (inst?
                                                                       -6)
                                                                      (("2"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((<= const-decl "bool" mucalculus nil)
    (good const-decl "bool" bdUnity nil)
    (cup const-decl "bool" ownpred nil)
    (wp const-decl "bool" ownpred nil)
    (co const-decl "bool" bdUnity nil)
    (ensuresA const-decl "bool" bdUnity nil)
    (transient const-decl "bool" bdUnity nil)
    (cap const-decl "bool" ownpred nil)
    (neg const-decl "bool" ownpred nil)
    (t formal-type-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (cobar const-decl "bool" bdUnity nil)
    (ensures const-decl "bool" bdUnity nil))
   nil)
  (ensuresA_ensures-1 nil 3679319991
   ("" (skolem!)
    (("" (iff)
      (("" (prop)
        (("1" (expand "ensuresA")
          (("1" (expand "ensures")
            (("1" (flatten)
              (("1" (assert)
                (("1" (expand "transient")
                  (("1" (expand "cobar")
                    (("1" (skosimp)
                      (("1" (inst? +)
                        (("1" (assert)
                          (("1" (skosimp)
                            (("1" (expand "cap")
                              (("1"
                                (inst?)
                                (("1"
                                  (flatten)
                                  (("1"
                                    (assert)
                                    (("1"
                                      (expand "neg")
                                      (("1" (propax) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (expand "ensuresA")
          (("2" (expand "ensures")
            (("2" (flatten)
              (("2" (assert)
                (("2" (expand "cobar")
                  (("2" (expand "transient")
                    (("2" (skosimp)
                      (("2" (inst? +)
                        (("2" (assert)
                          (("2" (skosimp)
                            (("2" (inst?)
                              (("2"
                                (assert)
                                (("2"
                                  (expand "cap")
                                  (("2"
                                    (flatten)
                                    (("2"
                                      (expand "neg")
                                      (("2"
                                        (assert)
                                        (("2"
                                          (hide -2)
                                          (("2"
                                            (expand "co")
                                            (("2"
                                              (expand "<=")
                                              (("2"
                                                (expand "wp")
                                                (("2"
                                                  (expand "cap")
                                                  (("2"
                                                    (inst - x!1)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (postpone)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   nil shostak))
 (subset_ensures 0
  (subset_ensures-1 nil 3679321705
   ("" (expand "ensures")
    (("" (expand "co")
      (("" (expand "transient")
        (("" (expand "<=")
          (("" (expand "wp")
            (("" (expand "cap")
              (("" (skosimp*)
                (("" (split)
                  (("1" (skosimp*)
                    (("1" (expand "cup")
                      (("1" (expand "neg")
                        (("1" (inst - s!2) (("1" (assert) nil nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (inst + 0)
                    (("2" (expand "neg")
                      (("2" (split)
                        (("1" (skosimp)
                          (("1" (inst - s!2) (("1" (assert) nil nil))
                            nil))
                          nil)
                         ("2" (skosimp)
                          (("2" (inst - x!1) (("2" (assert) nil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((co const-decl "bool" bdUnity nil)
    (<= const-decl "bool" mucalculus nil)
    (cap const-decl "bool" ownpred nil)
    (cup const-decl "bool" ownpred nil)
    (t formal-type-decl nil bdUnity nil)
    (neg const-decl "bool" ownpred nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (wp const-decl "bool" ownpred nil)
    (transient const-decl "bool" bdUnity nil)
    (ensures const-decl "bool" bdUnity nil))
   shostak))
 (stable_unless 0
  (stable_unless-1 nil 3588931363
   ("" (expand "unless")
    (("" (expand "<=")
      (("" (expand "wp")
        (("" (skosimp*)
          (("" (expand "cup")
            (("" (expand "cap")
              (("" (flatten)
                (("" (expand "neg")
                  (("" (inst?)
                    (("" (assert)
                      (("" (inst - y!1)
                        (("" (assert)
                          (("" (expand "stable")
                            (("" (expand "co")
                              ((""
                                (expand "wp")
                                ((""
                                  (expand "<=")
                                  ((""
                                    (expand "cap")
                                    ((""
                                      (inst?)
                                      ((""
                                        (assert)
                                        ((""
                                          (inst - y!1)
                                          (("" (assert) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((<= const-decl "bool" mucalculus nil)
    (cap const-decl "bool" ownpred nil)
    (neg const-decl "bool" ownpred nil)
    (co const-decl "bool" bdUnity nil)
    (stable const-decl "bool" bdUnity nil)
    (t formal-type-decl nil bdUnity nil)
    (cup const-decl "bool" ownpred nil)
    (wp const-decl "bool" ownpred nil)
    (unless const-decl "bool" bdUnity nil))
   shostak))
 (stable_ensures 0
  (stable_ensures-1 nil 3679322160
   ("" (expand "ensures")
    (("" (skosimp)
      (("" (split)
        (("1" (lemma stable_unless)
          (("1" (inst?)
            (("1" (inst - q!1 s!1)
              (("1" (lemma unless_co)
                (("1" (assert)
                  (("1" (inst-cp - p!1 q!1 s!1)
                    (("1" (assert)
                      (("1" (hide -2)
                        (("1" (inst?) (("1" (assert) nil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (expand "transient")
          (("2" (skosimp)
            (("2" (inst? +)
              (("2" (split)
                (("1" (expand "<=")
                  (("1" (expand "cap")
                    (("1" (skosimp)
                      (("1" (inst?) (("1" (assert) nil nil)) nil))
                      nil))
                    nil))
                  nil)
                 ("2" (expand "cap")
                  (("2" (skosimp)
                    (("2" (inst?) (("2" (assert) nil nil)) nil)) nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((transient const-decl "bool" bdUnity nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (<= const-decl "bool" mucalculus nil)
    (stable_unless formula-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (specification type-eq-decl nil bdUnity nil)
    (cap const-decl "bool" ownpred nil)
    (unless_co formula-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (t formal-type-decl nil bdUnity nil)
    (ensures const-decl "bool" bdUnity nil))
   shostak))
 (sched_TCC1 0
  (sched_TCC1-1 nil 3624340822
   ("" (expand "nonempty?")
    (("" (expand "empty?")
      (("" (expand "member")
        (("" (skosimp)
          (("" (inst?) (("" (inst + 0) (("" (assert) nil nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((empty? const-decl "bool" sets nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (member const-decl "bool" sets nil)
    (nonempty? const-decl "bool" sets nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil))
   nil))
 (sched_schedules 0
  (sched_schedules-1 nil 3624340824
   ("" (skosimp)
    (("" (expand "sched")
      ((""
        (name-replace mn
         "min({i | EXISTS k: i + k * k = j!1 * j!1 + i!1})")
        (("1" (typepred mn)
          (("1" (skolem!)
            (("1" (inst - i!1)
              (("1" (split)
                (("1"
                  (case "forall (x, y: nat): x <= y IMPLIES x*x <= y*y")
                  (("1" (case "k!1 + 1 <= j!1")
                    (("1" (assert)
                      (("1" (inst?) (("1" (assert) nil nil)) nil)) nil)
                     ("2" (case "j!1 + 1 <= k!1")
                      (("1" (inst?) (("1" (assert) nil nil)) nil)
                       ("2" (assert) nil nil))
                      nil))
                    nil)
                   ("2" (hide - 2)
                    (("2" (skosimp)
                      (("2" (name dd "y!1-x!1")
                        (("2" (case "y!1= dd + x!1")
                          (("1" (replaceh -1)
                            (("1" (assert)
                              (("1"
                                (case "dd >= 0")
                                (("1"
                                  (hide -2 -3)
                                  (("1"
                                    (typepred x!1)
                                    (("1"
                                      (case "dd > 0")
                                      (("1"
                                        (assert)
                                        (("1"
                                          (case "x!1>0")
                                          (("1"
                                            (hide -3 -4)
                                            (("1"
                                              (lemma
                                               both_sides_times_pos_ge1)
                                              (("1"
                                                (case "dd * x!1 >= 0")
                                                (("1"
                                                  (case "dd * dd >= 0")
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil)
                                                   ("2"
                                                    (inst - dd dd 0)
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (inst - x!1 dd 0)
                                                  (("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2" (assert) nil nil))
                                          nil))
                                        nil)
                                       ("2" (assert) nil nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2" (assert) nil nil))
                                nil))
                              nil))
                            nil)
                           ("2" (assert) nil nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (inst + j!1) (("2" (assert) nil nil)) nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (expand "nonempty?")
          (("2" (expand "empty?")
            (("2" (expand "member")
              (("2" (inst - i!1)
                (("2" (inst + j!1) (("2" (assert) nil nil)) nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (sched const-decl "nat" bdUnity nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (> const-decl "bool" reals nil)
    (both_sides_times_pos_ge1 formula-decl nil real_props nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (min const-decl "{a | S(a) AND (FORALL x: S(x) IMPLIES a <= x)}"
         min_nat nil)
    (<= const-decl "bool" reals nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (nonempty? const-decl "bool" sets nil)
    (set type-eq-decl nil sets nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil))
   shostak))
 (chosen_TCC1 0
  (chosen_TCC1-1 nil 3624344465 ("" (existence-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (>= const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (t formal-type-decl nil bdUnity nil)
    (choice const-decl "pred[t]" bdUnity nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil))
   nil))
 (runfrom_TCC1 0
  (runfrom_TCC1-1 nil 3624344465 ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (>= const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (runfrom_TCC2 0
  (runfrom_TCC2-1 nil 3624344465 ("" (termination-tcc) nil nil) nil
   nil))
 (runfrom_run 0
  (runfrom_run-1 nil 3624344650
   ("" (expand "run")
    (("" (skosimp)
      (("" (split)
        (("1" (expand "exec")
          (("1" (name-replace xss "runfrom(s!1, x!1)" nil)
            (("1" (case "FORALL n: s!1`step(xss(n), xss(1 + n))")
              (("1" (case "FORALL n: s!1`inv(xss(n))")
                (("1" (skolem!)
                  (("1" (inst?)
                    (("1" (inst?) (("1" (assert) nil nil)) nil)) nil))
                  nil)
                 ("2" (hide 2)
                  (("2" (induct n)
                    (("1" (expand "xss")
                      (("1" (expand "runfrom") (("1" (propax) nil nil))
                        nil))
                      nil)
                     ("2" (skosimp)
                      (("2" (inst?)
                        (("2" (expand "good")
                          (("2" (flatten)
                            (("2" (expand "<=")
                              (("2"
                                (inst?)
                                (("2"
                                  (assert)
                                  (("2"
                                    (expand "wp")
                                    (("2"
                                      (inst - "xss(1 + j!1)")
                                      (("2" (assert) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (hide 2)
                (("2" (skolem!)
                  (("2" (name-replace xss1 "xss(1 + n!1)" nil)
                    (("2" (expand xss -1)
                      (("2" (expand runfrom -1)
                        (("2" (replace -2)
                          (("2" (expand "chosen")
                            (("2" (lift-if)
                              (("2"
                                (assert)
                                (("2"
                                  (split)
                                  (("1"
                                    (flatten)
                                    (("1"
                                      (expand "good")
                                      (("1"
                                        (flatten)
                                        (("1"
                                          (expand "reflexive?")
                                          (("1"
                                            (inst?)
                                            (("1" (assert) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (flatten)
                                    (("2"
                                      (use epsilon_ax[t])
                                      (("2"
                                        (replace -2)
                                        (("2"
                                          (split)
                                          (("1"
                                            (hide -2)
                                            (("1"
                                              (expand "choice")
                                              (("1"
                                                (expand "good")
                                                (("1"
                                                  (flatten)
                                                  (("1"
                                                    (inst?)
                                                    (("1"
                                                      (expand "<=")
                                                      (("1"
                                                        (hide -5)
                                                        (("1"
                                                          (inst?)
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (expand "empty?")
                                            (("2"
                                              (expand "member")
                                              (("2"
                                                (hide - 3)
                                                (("2"
                                                  (skosimp)
                                                  (("2"
                                                    (inst?)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (expand "weakfair")
          (("2" (skosimp*)
            (("2" (name jj "k!1+n!1+1")
              (("2" (name ii "jj * jj + k!1 - n!1")
                (("2" (case "ii >= 0")
                  (("1" (use sched_schedules (i k!1 j jj))
                    (("1" (assert)
                      (("1" (inst + ii)
                        (("1"
                          (name-replace yy
                           "runfrom(s!1, x!1)(1 + ii + n!1)" nil)
                          (("1" (expand runfrom -1)
                            (("1" (case "jj * jj + k!1 = ii + n!1")
                              (("1"
                                (replaceh -1)
                                (("1"
                                  (replaceh -2)
                                  (("1"
                                    (expand "fw")
                                    (("1"
                                      (flatten)
                                      (("1"
                                        (name-replace
                                         xx
                                         "runfrom(s!1, x!1)(ii + n!1)")
                                        (("1"
                                          (expand "chosen")
                                          (("1"
                                            (lift-if)
                                            (("1"
                                              (split)
                                              (("1"
                                                (flatten)
                                                (("1"
                                                  (expand "empty?")
                                                  (("1"
                                                    (expand "member")
                                                    (("1"
                                                      (expand "choice")
                                                      (("1"
                                                        (expand
                                                         "enabled")
                                                        (("1"
                                                          (skolem!)
                                                          (("1"
                                                            (inst?)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (flatten)
                                                (("2"
                                                  (use epsilon_ax[t])
                                                  (("2"
                                                    (split)
                                                    (("1"
                                                      (replaceh -2)
                                                      (("1"
                                                        (expand
                                                         "choice")
                                                        (("1"
                                                          (propax)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (hide - 3)
                                                      (("2"
                                                        (expand
                                                         "empty?")
                                                        (("2"
                                                          (expand
                                                           "member")
                                                          (("2"
                                                            (skolem!)
                                                            (("2"
                                                              (inst?)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2" (assert) nil nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (hide -3 -4 2)
                    (("2" (expand "ii")
                      (("2" (expand "jj") (("2" (assert) nil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((weakfair const-decl "bool" bdUnity nil)
    (posint nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (enabled const-decl "bool" bdUnity nil)
    (fw const-decl "bool" bdUnity nil)
    (sched_schedules formula-decl nil bdUnity nil)
    (ii skolem-const-decl "int" bdUnity nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (jj skolem-const-decl "posint" bdUnity nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (exec const-decl "bool" bdUnity nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (good const-decl "bool" bdUnity nil)
    (<= const-decl "bool" mucalculus nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (wp const-decl "bool" ownpred nil)
    (xss skolem-const-decl "[nat -> t]" bdUnity nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (reflexive? const-decl "bool" relations nil)
    (epsilon_ax formula-decl nil epsilons nil)
    (choice const-decl "pred[t]" bdUnity nil)
    (sched const-decl "nat" bdUnity nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil)
    (chosen const-decl "t" bdUnity nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (runfrom def-decl "t" bdUnity nil)
    (specification type-eq-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (t formal-type-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (run const-decl "bool" bdUnity nil))
   shostak))
 (run_exists 0
  (run_exists-1 nil 3624347702
   ("" (skosimp)
    (("" (use runfrom_run)
      (("" (assert)
        (("" (inst?)
          (("" (assert)
            (("" (expand "runfrom") (("" (propax) nil nil)) nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((runfrom_run formula-decl nil bdUnity nil)
    (specification type-eq-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (t formal-type-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (runfrom def-decl "t" bdUnity nil))
   shostak))
 (machine_closed 0
  (machine_closed-1 nil 3624347743
   ("" (skosimp)
    (("" (name xx "xs!1(n!1)")
      (("" (use run_exists)
        (("" (assert)
          (("" (split)
            (("1" (skosimp)
              (("1"
                (name yys
                      "lambda i: IF i <= n!1 THEN xs!1(i) ELSE xs!2(i - n!1) ENDIF")
                (("1" (inst + yys)
                  (("1" (expand "run")
                    (("1" (flatten)
                      (("1" (split)
                        (("1" (expand "exec")
                          (("1" (skolem!)
                            (("1" (case "n!2 < n!1")
                              (("1"
                                (expand "yys")
                                (("1"
                                  (assert)
                                  (("1" (inst? -7) nil nil))
                                  nil))
                                nil)
                               ("2"
                                (expand "yys")
                                (("2"
                                  (assert)
                                  (("2"
                                    (inst -2 "n!2-n!1")
                                    (("2"
                                      (assert)
                                      (("2"
                                        (flatten)
                                        (("2"
                                          (assert)
                                          (("2"
                                            (lift-if)
                                            (("2" (assert) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (expand "weakfair")
                          (("2" (skosimp*)
                            (("2" (inst - k!1)
                              (("2"
                                (inst - n!2)
                                (("2"
                                  (skolem!)
                                  (("2"
                                    (inst + "i!1+n!1")
                                    (("2"
                                      (expand "yys")
                                      (("2"
                                        (assert)
                                        (("2"
                                          (lift-if)
                                          (("2" (assert) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("3" (skosimp)
                          (("3" (expand "yys") (("3" (assert) nil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (skosimp) (("2" (assert) nil nil)) nil))
                nil))
              nil)
             ("2" (expand "exec")
              (("2" (inst?) (("2" (assert) nil nil)) nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (t formal-type-decl nil bdUnity nil)
    (weakfair const-decl "bool" bdUnity nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (exec const-decl "bool" bdUnity nil)
    (< const-decl "bool" reals nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (yys skolem-const-decl "[nat -> t]" bdUnity nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (run const-decl "bool" bdUnity nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (<= const-decl "bool" reals nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (specification type-eq-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (run_exists formula-decl nil bdUnity nil))
   shostak))
 (drop_run 0
  (drop_run-1 nil 3589011688
   ("" (expand "run")
    (("" (skosimp)
      (("" (split)
        (("1" (expand "exec")
          (("1" (expand "drop")
            (("1" (skolem!)
              (("1" (inst?) (("1" (assert) nil nil)) nil)) nil))
            nil))
          nil)
         ("2" (skolem!)
          (("2" (inst?)
            (("2" (expand "weakfair")
              (("2" (skolem!)
                (("2" (expand "drop")
                  (("2" (inst - "n!1+n!2")
                    (("2" (skolem!)
                      (("2" (inst?) (("2" (assert) nil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((weakfair const-decl "bool" bdUnity nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (exec const-decl "bool" bdUnity nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (drop const-decl "t" bdUnity nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (run const-decl "bool" bdUnity nil))
   shostak))
 (run_round 0
  (run_round-4 nil 3624353673
   ("" (expand "run")
    (("" (expand "round")
      (("" (skosimp)
        (("" (expand "weakfair")
          (("" (expand "good")
            (("" (flatten)
              (("" (inst -6 "xs!1(0)")
                (("" (split)
                  (("1"
                    (name-replace ena "{k | enabled(s!1)(k)(xs!1(0))}"
                     nil)
                    (("1"
                      (case "EXISTS n:
                                    FORALL k: ena(k) IMPLIES
                            EXISTS i: i < n AND fw(s!1)(k)(xs!1(i), xs!1(1 + i))")
                      (("1" (skosimp)
                        (("1" (inst + "1+n!1")
                          (("1" (skolem!)
                            (("1" (inst? -)
                              (("1"
                                (split)
                                (("1"
                                  (skosimp)
                                  (("1"
                                    (inst? +)
                                    (("1" (assert) nil nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (inst + 0)
                                  (("2"
                                    (expand "ena")
                                    (("2"
                                      (expand "fw")
                                      (("2" (assert) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (hide -1 -3 2)
                        (("2"
                          (name ff
                                "lambda k: min({i | fw(s!1)(k)(xs!1(i), xs!1(i+1))})")
                          (("1" (name nn "maximum(ff, ena)")
                            (("1" (use maximum_prop[nat])
                              (("1"
                                (assert)
                                (("1"
                                  (inst + "1+nn")
                                  (("1"
                                    (skosimp)
                                    (("1"
                                      (replace -2 :hide? t)
                                      (("1"
                                        (inst? -)
                                        (("1"
                                          (assert)
                                          (("1"
                                            (name-replace
                                             fk
                                             "ff(k!1)"
                                             nil)
                                            (("1"
                                              (inst + fk)
                                              (("1" (assert) nil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (propax) nil nil))
                            nil)
                           ("2" (hide -1 2)
                            (("2" (expand "nonempty?")
                              (("2"
                                (expand "empty?")
                                (("2"
                                  (expand "member")
                                  (("2"
                                    (skosimp)
                                    (("2"
                                      (inst? -2)
                                      (("2"
                                        (inst -2 0)
                                        (("2"
                                          (skolem!)
                                          (("2"
                                            (assert)
                                            (("2" (inst?) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (expand "exec")
                    (("2" (inst - 0) (("2" (assert) nil nil)) nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((round const-decl "bool" bdUnity nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (weakfair const-decl "bool" bdUnity nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (< const-decl "bool" reals nil) (fw const-decl "bool" bdUnity nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (ena skolem-const-decl "[nat -> bool]" bdUnity nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (<= const-decl "bool" reals nil) (set type-eq-decl nil sets nil)
    (nonempty? const-decl "bool" sets nil)
    (min const-decl "{a | S(a) AND (FORALL x: S(x) IMPLIES a <= x)}"
         min_nat nil)
    (maximum_prop formula-decl nil maxfinset nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (maximum def-decl "nat" maxfinset nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (member const-decl "bool" sets nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (empty? const-decl "bool" sets nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (pred type-eq-decl nil defined_types nil)
    (specification type-eq-decl nil bdUnity nil)
    (enabled const-decl "bool" bdUnity nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (exec const-decl "bool" bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (t formal-type-decl nil bdUnity nil)
    (good const-decl "bool" bdUnity nil)
    (run const-decl "bool" bdUnity nil))
   nil)
  (run_round-3 nil 3624286690
   ("" (expand "run")
    (("" (expand "round")
      (("" (skosimp)
        (("" (expand "weakfair")
          (("" (expand "locallyfinite")
            (("" (inst -3 "xs!1(0)")
              (("" (split)
                (("1"
                  (name-replace ena "{k | enabled(s!1)(k)(xs!1(0))}"
                   nil)
                  (("1"
                    (case "EXISTS n:
                           FORALL k: ena(k) IMPLIES
                   EXISTS i: i < n AND fw(s!1)(k)(xs!1(i), xs!1(1 + i))")
                    (("1" (skosimp)
                      (("1" (inst + "1+n!1")
                        (("1" (skolem!)
                          (("1" (inst? -)
                            (("1" (split)
                              (("1"
                                (skosimp)
                                (("1"
                                  (inst? +)
                                  (("1" (assert) nil nil))
                                  nil))
                                nil)
                               ("2"
                                (inst + 0)
                                (("2"
                                  (expand "ena")
                                  (("2"
                                    (expand "fw")
                                    (("2" (assert) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide -1 -3 2)
                      (("2"
                        (name ff
                              "lambda k: min({i | fw(s!1)(k)(xs!1(i), xs!1(i+1))})")
                        (("1" (name nn "maximum(ff, ena)")
                          (("1" (use maximum_prop[nat])
                            (("1" (assert)
                              (("1"
                                (inst + "1+nn")
                                (("1"
                                  (skosimp)
                                  (("1"
                                    (replace -2 :hide? t)
                                    (("1"
                                      (inst? -)
                                      (("1"
                                        (assert)
                                        (("1"
                                          (name-replace
                                           fk
                                           "ff(k!1)"
                                           nil)
                                          (("1"
                                            (inst + fk)
                                            (("1" (assert) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (propax) nil nil))
                          nil)
                         ("2" (hide -1 2)
                          (("2" (expand "nonempty?")
                            (("2" (expand "empty?")
                              (("2"
                                (expand "member")
                                (("2"
                                  (skosimp)
                                  (("2"
                                    (inst? -2)
                                    (("2"
                                      (inst -2 0)
                                      (("2"
                                        (skolem!)
                                        (("2"
                                          (assert)
                                          (("2" (inst?) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (expand "exec")
                  (("2" (inst - 0) (("2" (assert) nil nil)) nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((round const-decl "bool" bdUnity nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (weakfair const-decl "bool" bdUnity nil)
    (t formal-type-decl nil bdUnity nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (exec const-decl "bool" bdUnity nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (enabled const-decl "bool" bdUnity nil)
    (specification type-eq-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (empty? const-decl "bool" sets nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (member const-decl "bool" sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (maximum def-decl "nat" maxfinset nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (maximum_prop formula-decl nil maxfinset nil)
    (min const-decl "{a | S(a) AND (FORALL x: S(x) IMPLIES a <= x)}"
         min_nat nil)
    (nonempty? const-decl "bool" sets nil)
    (set type-eq-decl nil sets nil) (<= const-decl "bool" reals nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (fw const-decl "bool" bdUnity nil) (< const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (run const-decl "bool" bdUnity nil))
   nil)
  (run_round-2 nil 3589013264
   ("" (expand "run")
    (("" (expand "round")
      (("" (skosimp)
        (("" (expand "weakfair")
          (("" (expand "locallyfinite")
            (("" (inst -3 "xs!1(0)")
              (("" (split)
                (("1"
                  (name-replace ena
                   "{k | NOT disabled(s!1)(k)(xs!1(0))}" nil)
                  (("1"
                    (case "EXISTS n:
                  FORALL k: ena(k) IMPLIES
          EXISTS i: i < n AND fw(s!1)(k)(xs!1(i), xs!1(1 + i))")
                    (("1" (skosimp)
                      (("1" (inst + "1+n!1")
                        (("1" (skolem!)
                          (("1" (inst? -)
                            (("1" (split)
                              (("1"
                                (skosimp)
                                (("1"
                                  (inst? +)
                                  (("1" (assert) nil nil))
                                  nil))
                                nil)
                               ("2"
                                (inst + 0)
                                (("2"
                                  (expand "ena")
                                  (("2"
                                    (expand "fw")
                                    (("2" (assert) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide -1 -3 2)
                      (("2"
                        (name ff
                              "lambda k: min({i | fw(s!1)(k)(xs!1(i), xs!1(i+1))})")
                        (("1" (name nn "maximum(ff, ena)")
                          (("1" (use maximum_prop[nat])
                            (("1" (assert)
                              (("1"
                                (inst + "1+nn")
                                (("1"
                                  (skosimp)
                                  (("1"
                                    (replace -2 :hide? t)
                                    (("1"
                                      (inst? -)
                                      (("1"
                                        (assert)
                                        (("1"
                                          (name-replace
                                           fk
                                           "ff(k!1)"
                                           nil)
                                          (("1"
                                            (inst + fk)
                                            (("1" (assert) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (propax) nil nil))
                          nil)
                         ("2" (hide -1 2)
                          (("2" (expand "nonempty?")
                            (("2" (expand "empty?")
                              (("2"
                                (expand "member")
                                (("2"
                                  (skosimp)
                                  (("2"
                                    (inst? -2)
                                    (("2"
                                      (inst -2 0)
                                      (("2"
                                        (skolem!)
                                        (("2"
                                          (assert)
                                          (("2" (inst?) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (expand "exec")
                  (("2" (inst - 0) (("2" (assert) nil nil)) nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((round const-decl "bool" bdUnity nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (weakfair const-decl "bool" bdUnity nil)
    (t formal-type-decl nil bdUnity nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (exec const-decl "bool" bdUnity nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (pred type-eq-decl nil defined_types nil)
    (specification type-eq-decl nil bdUnity nil)
    (empty? const-decl "bool" sets nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (member const-decl "bool" sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (maximum def-decl "nat" maxfinset nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (maximum_prop formula-decl nil maxfinset nil)
    (min const-decl "{a | S(a) AND (FORALL x: S(x) IMPLIES a <= x)}"
         min_nat nil)
    (nonempty? const-decl "bool" sets nil)
    (set type-eq-decl nil sets nil) (<= const-decl "bool" reals nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (fw const-decl "bool" bdUnity nil) (< const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (run const-decl "bool" bdUnity nil))
   nil)
  (run_round-1 nil 3589012562
   ("" (expand "run")
    (("" (expand "round")
      (("" (skosimp)
        (("" (expand "weakfair")
          (("" (expand "locallyfinite")
            (("" (inst -3 "xs!1(0)")
              (("" (split)
                (("1"
                  (name-replace ena
                   "{k | NOT disabled(s!1)(k)(xs!1(0))}" nil)
                  (("1"
                    (case "EXISTS n:
        FORALL k: ena(k) IMPLIES 
EXISTS i: i < n AND fw(s!1)(k)(xs!1(i), xs!1(1 + i))")
                    (("1" (skosimp)
                      (("1" (inst + n!1)
                        (("1" (skolem!)
                          (("1" (inst? -)
                            (("1" (split)
                              (("1" (propax) nil nil)
                               ("2"
                                (inst + 0)
                                (("2"
                                  (expand "ena")
                                  (("2"
                                    (expand "fw")
                                    (("2"
                                      (assert)
                                      (("2" (postpone) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (postpone) nil nil))
                    nil))
                  nil)
                 ("2" (postpone) nil nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   nil shostak))
 (rounds_TCC1 0
  (rounds_TCC1-1 nil 3588952490 ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (>= const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (enabled const-decl "bool" bdUnity nil)
    (fw const-decl "bool" bdUnity nil)
    (round const-decl "bool" bdUnity nil))
   nil))
 (rounds_TCC2 0
  (rounds_TCC2-1 nil 3588952490 ("" (termination-tcc) nil nil)
   ((enabled const-decl "bool" bdUnity nil)
    (fw const-decl "bool" bdUnity nil)
    (round const-decl "bool" bdUnity nil))
   nil))
 (rounds_TCC3 0
  (rounds_TCC3-1 nil 3588952490 ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (>= const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (enabled const-decl "bool" bdUnity nil)
    (fw const-decl "bool" bdUnity nil)
    (round const-decl "bool" bdUnity nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil))
   nil))
 (run_rounds 0
  (run_rounds-1 nil 3589016742
   ("" (induct i)
    (("1" (expand "rounds") (("1" (propax) nil nil)) nil)
     ("2" (skosimp*)
      (("2" (expand rounds +)
        (("2" (use run_round)
          (("2" (assert)
            (("2" (skolem!)
              (("2" (inst - "s!1" "drop(n!1)(xs!1)")
                (("2" (assert)
                  (("2" (split)
                    (("1" (skolem!)
                      (("1" (inst + "n!2+n!1" n!1)
                        (("1" (assert) nil nil)) nil))
                      nil)
                     ("2" (use drop_run) (("2" (assert) nil nil)) nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((run_round formula-decl nil bdUnity nil)
    (drop_run formula-decl nil bdUnity nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (drop const-decl "t" bdUnity nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (rounds def-decl "bool" bdUnity nil)
    (good const-decl "bool" bdUnity nil)
    (run const-decl "bool" bdUnity nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (specification type-eq-decl nil bdUnity nil)
    (t formal-type-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (rounds_split_TCC1 0
  (rounds_split_TCC1-1 nil 3588952490 ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (>= const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil))
   nil))
 (rounds_split 0
  (rounds_split-1 nil 3588952890
   ("" (induct j)
    (("1" (skosimp)
      (("1" (inst + 0)
        (("1" (assert)
          (("1" (case "drop(0)(xs!1) = xs!1")
            (("1" (assert)
              (("1" (expand "rounds") (("1" (propax) nil nil)) nil))
              nil)
             ("2" (hide - 2)
              (("2" (apply-extensionality :hide? t)
                (("2" (expand "drop") (("2" (propax) nil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil)
     ("2" (skosimp*)
      (("2" (expand rounds -2)
        (("2" (skosimp)
          (("2" (inst?)
            (("1" (assert)
              (("1" (skosimp)
                (("1" (inst + "i!1+j!2")
                  (("1" (assert)
                    (("1" (split)
                      (("1" (expand rounds +)
                        (("1" (inst?) (("1" (assert) nil nil)) nil))
                        nil)
                       ("2"
                        (case "drop(i!1)(drop(j!2)(xs!1)) = drop(i!1 + j!2)(xs!1)")
                        (("1" (assert) nil nil)
                         ("2" (hide - 2)
                          (("2" (apply-extensionality :hide? t)
                            (("2" (expand "drop")
                              (("2" (propax) nil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (assert) nil nil))
            nil))
          nil))
        nil))
      nil)
     ("3" (hide 2) (("3" (skosimp*) (("3" (assert) nil nil)) nil))
      nil))
    nil)
   ((mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (j!2 skolem-const-decl "nat" bdUnity nil)
    (n!1 skolem-const-decl "nat" bdUnity nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (drop const-decl "t" bdUnity nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (t formal-type-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (specification type-eq-decl nil bdUnity nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (rounds def-decl "bool" bdUnity nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil))
   shostak))
 (rounds_down 0
  (rounds_down-1 nil 3588997970
   ("" (induct i)
    (("1" (expand "rounds") (("1" (propax) nil nil)) nil)
     ("2" (skosimp*)
      (("2" (expand rounds (-3 1))
        (("2" (assert)
          (("2" (skosimp)
            (("2" (inst?)
              (("1" (assert)
                (("1" (inst?) (("1" (assert) nil nil)) nil)) nil)
               ("2" (assert) nil nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (n!1 skolem-const-decl "nat" bdUnity nil)
    (j!3 skolem-const-decl "nat" bdUnity nil)
    (drop const-decl "t" bdUnity nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (rounds def-decl "bool" bdUnity nil)
    (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (specification type-eq-decl nil bdUnity nil)
    (t formal-type-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (rounds_furtheron 0
  (rounds_furtheron-1 nil 3588998257
   ("" (induct j)
    (("1" (expand "rounds") (("1" (propax) nil nil)) nil)
     ("2" (skosimp*)
      (("2" (expand rounds (-2 1))
        (("2" (skosimp)
          (("2" (inst + "i!1+j!2")
            (("2" (assert)
              (("2"
                (case "drop(j!2)(drop(i!1)(xs!1)) = drop(i!1 + j!2)(xs!1)")
                (("1" (assert)
                  (("1" (hide-all-but -4 -)
                    (("1" (expand "round")
                      (("1" (skolem!)
                        (("1" (inst? -)
                          (("1" (skosimp)
                            (("1" (expand "drop")
                              (("1"
                                (inst?)
                                (("1" (assert) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (hide - 2)
                  (("2" (apply-extensionality :hide? t)
                    (("2" (expand "drop") (("2" (propax) nil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (round const-decl "bool" bdUnity nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (drop const-decl "t" bdUnity nil)
    (rounds def-decl "bool" bdUnity nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (specification type-eq-decl nil bdUnity nil)
    (t formal-type-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil))
   shostak))
 (leto_leadsto 0
  (leto_leadsto-1 nil 3589011046
   ("" (expand "leadsto")
    (("" (expand "leto")
      (("" (skosimp*)
        (("" (inst? -)
          (("" (assert)
            (("" (split)
              (("1" (use run_rounds)
                (("1" (assert)
                  (("1" (skolem!)
                    (("1" (inst?)
                      (("1" (assert)
                        (("1" (skosimp) (("1" (inst?) nil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (expand "run") (("2" (assert) nil nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((leto const-decl "bool" bdUnity nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (t formal-type-decl nil bdUnity nil)
    (specification type-eq-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (run_rounds formula-decl nil bdUnity nil)
    (run const-decl "bool" bdUnity nil)
    (leadsto const-decl "bool" bdUnity nil))
   shostak))
 (subset_leto 0
  (subset_leto-1 nil 3589000108
   ("" (expand "leto")
    (("" (skosimp*)
      (("" (inst?)
        (("" (assert)
          (("" (expand "exec")
            (("" (inst?)
              (("" (flatten)
                (("" (expand "<=")
                  (("" (expand "cap")
                    (("" (inst?) (("" (assert) nil nil)) nil)) nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (<= const-decl "bool" mucalculus nil)
    (t formal-type-decl nil bdUnity nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (cap const-decl "bool" ownpred nil)
    (exec const-decl "bool" bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (leto const-decl "bool" bdUnity nil))
   shostak))
 (ensures_leto 0
  (ensures_leto-1 nil 3679324615
   ("" (expand "leto")
    (("" (expand "ensures")
      (("" (expand "co")
        (("" (expand "transient")
          (("" (expand "cap")
            (("" (skosimp*)
              (("" (expand "<=" -)
                (("" (expand "neg")
                  (("" (expand "rounds")
                    (("" (expand "rounds")
                      (("" (expand "round")
                        (("" (skosimp)
                          (("" (inst? -7)
                            (("" (expand "fw")
                              ((""
                                (expand "wp")
                                ((""
                                  (expand "exec")
                                  ((""
                                    (case
                                     "forall n: n <= n!1 implies p!1(xs!1(n))")
                                    (("1"
                                      (skosimp)
                                      (("1"
                                        (split)
                                        (("1"
                                          (inst? -5)
                                          (("1"
                                            (inst? -6)
                                            (("1"
                                              (flatten)
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (inst-cp - i!1)
                                                  (("1"
                                                    (inst - "1+i!1")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (inst-cp + i!1)
                                                        (("1"
                                                          (inst
                                                           +
                                                           "1+i!1")
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (inst? -3)
                                          (("2"
                                            (inst? -5)
                                            (("2"
                                              (flatten)
                                              (("2"
                                                (inst?)
                                                (("2"
                                                  (assert)
                                                  (("2"
                                                    (inst + i!1)
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (induct n)
                                      (("1" (assert) nil nil)
                                       ("2"
                                        (skosimp)
                                        (("2"
                                          (assert)
                                          (("2"
                                            (inst?)
                                            (("2"
                                              (inst? -6)
                                              (("2"
                                                (flatten)
                                                (("2"
                                                  (assert)
                                                  (("2"
                                                    (split)
                                                    (("1"
                                                      (inst?)
                                                      (("1"
                                                        (expand "cup")
                                                        (("1"
                                                          (inst
                                                           +
                                                           "1+j!2")
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (inst + j!2)
                                                      (("2"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((ensures const-decl "bool" bdUnity nil)
    (transient const-decl "bool" bdUnity nil)
    (neg const-decl "bool" ownpred nil)
    (fw const-decl "bool" bdUnity nil)
    (exec const-decl "bool" bdUnity nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (cup const-decl "bool" ownpred nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (pred type-eq-decl nil defined_types nil)
    (t formal-type-decl nil bdUnity nil)
    (<= const-decl "bool" reals nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (wp const-decl "bool" ownpred nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (round const-decl "bool" bdUnity nil)
    (rounds def-decl "bool" bdUnity nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (<= const-decl "bool" mucalculus nil)
    (cap const-decl "bool" ownpred nil)
    (co const-decl "bool" bdUnity nil)
    (leto const-decl "bool" bdUnity nil))
   shostak))
 (leto_union 0
  (leto_union-1 nil 3589002235
   ("" (expand "leto")
    (("" (skosimp*)
      (("" (expand "Union")
        (("" (skosimp)
          (("" (typepred a!1)
            (("" (inst? -)
              (("" (assert)
                (("" (inst?)
                  (("" (assert)
                    (("" (inst? -) (("" (assert) nil nil)) nil)) nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (t formal-type-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (Union const-decl "set" sets nil)
    (leto const-decl "bool" bdUnity nil))
   shostak))
 (leto_transitive 0
  (leto_transitive-2 nil 3624287781
   ("" (expand "leto")
    (("" (skosimp*)
      (("" (use rounds_split (j m!1 m n!1))
        (("" (assert)
          (("" (skosimp)
            (("" (inst? -)
              (("" (assert)
                (("" (inst? -)
                  (("" (assert)
                    (("" (skosimp)
                      (("" (inst - "drop(i!2)(xs!1)")
                        (("" (split)
                          (("1" (inst - "n!2-i!2")
                            (("1" (split)
                              (("1"
                                (skosimp)
                                (("1"
                                  (expand "drop")
                                  (("1"
                                    (inst + "i!2+i!3")
                                    (("1" (assert) nil nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide -2 -8 2)
                                (("2"
                                  (use
                                   rounds_furtheron
                                   (n "n!2-i!1" i "i!1-i!2"))
                                  (("1"
                                    (assert)
                                    (("1"
                                      (case
                                       "drop(i!1 - i!2)(drop(i!2)(xs!1)) = drop(i!1)(xs!1)")
                                      (("1" (assert) nil nil)
                                       ("2"
                                        (hide - 2 3)
                                        (("2"
                                          (apply-extensionality
                                           :hide?
                                           t)
                                          (("2"
                                            (expand "drop")
                                            (("2" (propax) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2" (assert) nil nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (assert) nil nil))
                            nil)
                           ("2" (hide-all-but (-6 1))
                            (("2" (expand "exec")
                              (("2"
                                (expand "drop")
                                (("2"
                                  (skolem!)
                                  (("2"
                                    (inst?)
                                    (("2" (ground) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("3" (expand "drop")
                            (("3" (propax) nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((minus_odd_is_odd application-judgement "odd_int" integers nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (rounds_furtheron formula-decl nil bdUnity nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (i!2 skolem-const-decl "nat" bdUnity nil)
    (n!2 skolem-const-decl "nat" bdUnity nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (exec const-decl "bool" bdUnity nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (drop const-decl "t" bdUnity nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (t formal-type-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (specification type-eq-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (rounds_split formula-decl nil bdUnity nil)
    (leto const-decl "bool" bdUnity nil))
   nil)
  (leto_transitive-1 nil 3589002397
   ("" (expand "leto")
    (("" (skosimp*)
      (("" (use rounds_split (j n!1 m m!1))
        (("" (assert)
          (("" (skosimp)
            (("" (inst? -)
              (("" (assert)
                (("" (inst? -)
                  (("" (assert)
                    (("" (skosimp)
                      (("" (inst - "drop(i!2)(xs!1)")
                        (("" (split)
                          (("1" (inst - "n!2-i!2")
                            (("1" (split)
                              (("1"
                                (skosimp)
                                (("1"
                                  (expand "drop")
                                  (("1"
                                    (inst + "i!2+i!3")
                                    (("1" (assert) nil nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide -2 -8 2)
                                (("2"
                                  (use
                                   rounds_furtheron
                                   (n "n!2-i!1" i "i!1-i!2"))
                                  (("1"
                                    (assert)
                                    (("1"
                                      (case
                                       "drop(i!1 - i!2)(drop(i!2)(xs!1)) = drop(i!1)(xs!1)")
                                      (("1" (assert) nil nil)
                                       ("2"
                                        (hide - 2 3)
                                        (("2"
                                          (apply-extensionality
                                           :hide?
                                           t)
                                          (("2"
                                            (expand "drop")
                                            (("2" (propax) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2" (assert) nil nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (assert) nil nil))
                            nil)
                           ("2" (hide-all-but (-6 1))
                            (("2" (expand "exec")
                              (("2"
                                (expand "drop")
                                (("2"
                                  (skolem!)
                                  (("2"
                                    (inst?)
                                    (("2" (ground) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("3" (expand "drop")
                            (("3" (propax) nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((minus_odd_is_odd application-judgement "odd_int" integers nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (rounds_furtheron formula-decl nil bdUnity nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (exec const-decl "bool" bdUnity nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (drop const-decl "t" bdUnity nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (t formal-type-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (specification type-eq-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (rounds_split formula-decl nil bdUnity nil)
    (leto const-decl "bool" bdUnity nil))
   shostak))
 (PSP_leto 0
  (PSP_leto-1 nil 3616922384
   ("" (expand "leto")
    (("" (skosimp*)
      (("" (inst?)
        (("" (assert)
          (("" (expand "cap")
            (("" (flatten)
              (("" (assert)
                (("" (expand "cup")
                  (("" (inst?)
                    (("" (assert)
                      (("" (skosimp)
                        ((""
                          (case "forall n: n <= n!2 implies pa!1(xs!1(n))")
                          (("1" (inst - i!1)
                            (("1" (inst + i!1) (("1" (assert) nil nil))
                              nil))
                            nil)
                           ("2" (induct n)
                            (("1" (assert) nil nil)
                             ("2" (skosimp)
                              (("2"
                                (assert)
                                (("2"
                                  (expand "unless")
                                  (("2"
                                    (expand "<=" -5)
                                    (("2"
                                      (expand "cap")
                                      (("2"
                                        (expand "wp")
                                        (("2"
                                          (expand "neg")
                                          (("2"
                                            (expand "cup")
                                            (("2"
                                              (inst? -)
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (expand "exec")
                                                  (("2"
                                                    (inst? -)
                                                    (("2"
                                                      (flatten)
                                                      (("2"
                                                        (assert)
                                                        (("2"
                                                          (split)
                                                          (("1"
                                                            (inst
                                                             -
                                                             "xs!1(1 + j!1)")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (inst?)
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (inst
                                                             +
                                                             j!1)
                                                            (("2"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((cup const-decl "bool" ownpred nil)
    (pred type-eq-decl nil defined_types nil)
    (<= const-decl "bool" reals nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (unless const-decl "bool" bdUnity nil)
    (neg const-decl "bool" ownpred nil)
    (exec const-decl "bool" bdUnity nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (wp const-decl "bool" ownpred nil)
    (<= const-decl "bool" mucalculus nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (cap const-decl "bool" ownpred nil)
    (t formal-type-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (leto const-decl "bool" bdUnity nil))
   shostak))
 (PSP0_leto 0
  (PSP0_leto-2 nil 3679111200
   ("" (skosimp)
    (("" (lemma PSP_leto)
      (("" (inst?)
        (("" (inst?)
          (("" (assert)
            (("" (case "cap(fullset, p!1) = p!1")
              (("1" (replaceh -1)
                (("1" (case "cup(cap(neg(pa!1), p!1), q!1) = q!1")
                  (("1" (assert) nil nil)
                   ("2" (hide -1 -2 2)
                    (("2" (apply-extensionality :hide? t)
                      (("2" (iff)
                        (("2" (expand "cup")
                          (("2" (prop)
                            (("2" (expand "cap")
                              (("2"
                                (expand "neg")
                                (("2"
                                  (flatten)
                                  (("2"
                                    (expand "<=")
                                    (("2"
                                      (inst?)
                                      (("2" (assert) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (hide -1 -2 2)
                (("2" (apply-extensionality :hide? t)
                  (("2" (iff)
                    (("2" (expand "cap")
                      (("2" (prop)
                        (("2" (expand "fullset")
                          (("2" (propax) nil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((PSP_leto formula-decl nil bdUnity nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (cap const-decl "bool" ownpred nil)
    (cup const-decl "bool" ownpred nil)
    (<= const-decl "bool" mucalculus nil)
    (specification type-eq-decl nil bdUnity nil)
    (neg const-decl "bool" ownpred nil)
    (fullset const-decl "set" sets nil) (set type-eq-decl nil sets nil)
    (pred type-eq-decl nil defined_types nil)
    (t formal-type-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   nil)
  (PSP0_leto-1 nil 3671098970
   ("" (skosimp)
    (("" (lemma PSP_leto)
      (("" (inst?)
        (("" (inst?)
          (("" (assert)
            (("" (case "cap(pa!1, p!1) = p!1")
              (("1" (replaceh -1)
                (("1" (case "cup(cap(neg(pa!1), p!1), q!1) = q!1")
                  (("1" (assert) nil nil)
                   ("2" (hide -1 -2 2)
                    (("2" (apply-extensionality :hide? t)
                      (("2" (iff)
                        (("2" (expand "cup")
                          (("2" (prop)
                            (("2" (expand "cap")
                              (("2"
                                (expand "neg")
                                (("2"
                                  (flatten)
                                  (("2"
                                    (expand "<=")
                                    (("2"
                                      (inst?)
                                      (("2" (assert) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (hide -1 -2 2)
                (("2" (apply-extensionality :hide? t)
                  (("2" (iff)
                    (("2" (expand "cap")
                      (("2" (prop)
                        (("2" (expand "<=")
                          (("2" (inst?) (("2" (assert) nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((PSP_leto formula-decl nil bdUnity nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (cap const-decl "bool" ownpred nil)
    (cup const-decl "bool" ownpred nil)
    (<= const-decl "bool" mucalculus nil)
    (specification type-eq-decl nil bdUnity nil)
    (neg const-decl "bool" ownpred nil)
    (pred type-eq-decl nil defined_types nil)
    (t formal-type-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (leto_completion 0
  (leto_completion-1 nil 3616918278
   ("" (expand "leto")
    (("" (skosimp*)
      ((""
        (case "FORALL q:
        pset!1(q) IMPLIES
                 (EXISTS i: i <= n!2 AND q(xs!1(i)))
          AND unless(s!1)(q, pm!1)")
        (("1" (hide -2)
          (("1" (expand "cup")
            (("1" (case "EXISTS i: i <= n!2 AND pm!1(xs!1(i))")
              (("1" (skolem!)
                (("1" (flatten)
                  (("1" (inst? +) (("1" (assert) nil nil)) nil)) nil))
                nil)
               ("2" (inst 2 n!2)
                (("2" (assert)
                  (("2" (flatten)
                    (("2" (expand "Intersection")
                      (("2" (skolem!)
                        (("2" (inst - a!1)
                          (("2" (assert)
                            (("2" (flatten)
                              (("2"
                                (skosimp)
                                (("2"
                                  (expand "unless")
                                  (("2"
                                    (expand "<=" -3)
                                    (("2"
                                      (expand "wp")
                                      (("2"
                                        (expand "cup")
                                        (("2"
                                          (expand "cap")
                                          (("2"
                                            (expand "neg")
                                            (("2"
                                              (expand "exec")
                                              (("2"
                                                (case
                                                 "forall n: i!1+n <= n!2 IMPLIES a!1(xs!1(i!1+n))")
                                                (("1"
                                                  (inst - "n!2-i!1")
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil)
                                                   ("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (induct n)
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil)
                                                   ("2"
                                                    (skosimp)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (inst? -)
                                                        (("2"
                                                          (inst? -6)
                                                          (("2"
                                                            (flatten)
                                                            (("2"
                                                              (assert)
                                                              (("2"
                                                                (split)
                                                                (("1"
                                                                  (inst
                                                                   -
                                                                   "xs!1(1 + i!1 + j!1)")
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (inst?
                                                                       2)
                                                                      (("1"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (inst
                                                                   +
                                                                   "i!1 + j!1")
                                                                  (("2"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (hide 2)
          (("2" (skosimp)
            (("2" (inst?)
              (("2" (assert)
                (("2" (flatten)
                  (("2" (inst?)
                    (("2" (assert)
                      (("2" (inst? -2) (("2" (assert) nil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (Intersection const-decl "set" sets nil)
    (wp const-decl "bool" ownpred nil)
    (cap const-decl "bool" ownpred nil)
    (exec const-decl "bool" bdUnity nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (n!2 skolem-const-decl "nat" bdUnity nil)
    (i!1 skolem-const-decl "nat" bdUnity nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (neg const-decl "bool" ownpred nil)
    (<= const-decl "bool" mucalculus nil)
    (cup const-decl "bool" ownpred nil)
    (t formal-type-decl nil bdUnity nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (pred type-eq-decl nil defined_types nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (<= const-decl "bool" reals nil)
    (specification type-eq-decl nil bdUnity nil)
    (unless const-decl "bool" bdUnity nil)
    (leto const-decl "bool" bdUnity nil))
   shostak))
 (stable_conjunction 0
  (stable_conjunction-2 nil 3624287101
   ("" (skosimp)
    (("" (lemma PSP_leto)
      (("" (inst?)
        (("" (inst - pa!1 emptyset)
          (("" (assert)
            (("" (split)
              (("1"
                (case "cup(cap(q!1, pa!1), emptyset) =cap(q!1, pa!1)")
                (("1" (assert) nil nil)
                 ("2" (hide - 2)
                  (("2" (apply-extensionality :hide? t)
                    (("2" (iff)
                      (("2" (expand "cup")
                        (("2" (expand "emptyset")
                          (("2" (propax) nil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (hide -1 2)
                (("2" (expand "unless")
                  (("2" (expand "stable")
                    (("2" (expand "co")
                      (("2" (expand "<=")
                        (("2" (expand "wp")
                          (("2" (expand "cup")
                            (("2" (expand "cap")
                              (("2"
                                (expand "neg")
                                (("2"
                                  (expand "emptyset")
                                  (("2" (propax) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((PSP_leto formula-decl nil bdUnity nil)
    (emptyset const-decl "set" sets nil)
    (set type-eq-decl nil sets nil) (cap const-decl "bool" ownpred nil)
    (cup const-decl "bool" ownpred nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (unless const-decl "bool" bdUnity nil)
    (co const-decl "bool" bdUnity nil)
    (wp const-decl "bool" ownpred nil)
    (neg const-decl "bool" ownpred nil)
    (<= const-decl "bool" mucalculus nil)
    (stable const-decl "bool" bdUnity nil)
    (finite_emptyset name-judgement "finite_set" finite_sets nil)
    (specification type-eq-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (t formal-type-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   nil)
  (stable_conjunction-1 nil 3617510892
   ("" (skosimp)
    (("" (lemma PSP_leadold)
      (("" (inst?)
        (("" (inst - pa!1 emptyset)
          (("" (assert)
            (("" (split)
              (("1"
                (case "cup(cap(q!1, pa!1), emptyset) =cap(q!1, pa!1)")
                (("1" (assert) nil nil)
                 ("2" (hide - 2)
                  (("2" (apply-extensionality :hide? t)
                    (("2" (iff)
                      (("2" (expand "cup")
                        (("2" (expand "emptyset")
                          (("2" (propax) nil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (hide -1 2)
                (("2" (expand "unless")
                  (("2" (expand "stable")
                    (("2" (expand "co")
                      (("2" (expand "<=")
                        (("2" (expand "wp")
                          (("2" (expand "cup")
                            (("2" (expand "cap")
                              (("2"
                                (expand "neg")
                                (("2"
                                  (expand "emptyset")
                                  (("2" (propax) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((emptyset const-decl "set" sets nil)
    (set type-eq-decl nil sets nil) (cap const-decl "bool" ownpred nil)
    (cup const-decl "bool" ownpred nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (unless const-decl "bool" bdUnity nil)
    (co const-decl "bool" bdUnity nil)
    (wp const-decl "bool" ownpred nil)
    (neg const-decl "bool" ownpred nil)
    (<= const-decl "bool" mucalculus nil)
    (stable const-decl "bool" bdUnity nil)
    (finite_emptyset name-judgement "finite_set" finite_sets nil)
    (specification type-eq-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (t formal-type-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (cup_leto 0
  (cup_leto-1 nil 3624287140
   ("" (skosimp)
    (("" (lemma leto_union)
      (("" (name ppset "{p:pred[t] | p = p!1 OR p = pq!1}")
        (("" (inst - m!1 ppset q!1 s!1)
          (("" (case "Union(ppset) = cup(p!1, pq!1)")
            (("1" (replaceh -1)
              (("1" (assert)
                (("1" (skosimp)
                  (("1" (expand "ppset")
                    (("1" (split)
                      (("1" (assert) nil nil) ("2" (assert) nil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (hide - 2)
              (("2" (apply-extensionality :hide? t)
                (("2" (iff)
                  (("2" (prop)
                    (("1" (expand "Union")
                      (("1" (expand "cup")
                        (("1" (flatten)
                          (("1" (skolem!)
                            (("1" (typepred a!1)
                              (("1"
                                (expand "ppset")
                                (("1" (assert) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (expand "Union")
                      (("2" (expand "cup")
                        (("2" (split)
                          (("1" (inst?)
                            (("1" (expand "ppset")
                              (("1" (propax) nil nil)) nil))
                            nil)
                           ("2" (inst?)
                            (("2" (assert)
                              (("2"
                                (expand "ppset")
                                (("2" (propax) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((leto_union formula-decl nil bdUnity nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (specification type-eq-decl nil bdUnity nil)
    (p!1 skolem-const-decl "pred[t]" bdUnity nil)
    (pq!1 skolem-const-decl "pred[t]" bdUnity nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (Union_surjective name-judgement
     "(surjective?[setofsets[T], set[T]])" sets_lemmas nil)
    (ppset skolem-const-decl "[pred[t] -> boolean]" bdUnity nil)
    (cup const-decl "bool" ownpred nil)
    (Union const-decl "set" sets nil)
    (setofsets type-eq-decl nil sets nil)
    (setof type-eq-decl nil defined_types nil)
    (set type-eq-decl nil sets nil)
    (t formal-type-decl nil bdUnity nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (pred type-eq-decl nil defined_types nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil))
   shostak))
 (leto_transitive_2 0
  (leto_transitive_2-1 nil 3624287477
   ("" (skosimp)
    (("" (lemma leto_transitive)
      (("" (inst - m!1 n!1 p!1 "cup(pq!1, pa!1)" "cup(q!1, pa!1)" s!1)
        (("" (assert)
          (("" (hide -1 2)
            (("" (use cup_leto)
              (("" (assert)
                (("" (hide - 2)
                  (("" (use subset_leto)
                    (("" (assert)
                      (("" (hide 2)
                        (("" (expand "<=")
                          (("" (expand "cup")
                            (("" (expand "cap")
                              (("" (skosimp) nil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((leto_transitive formula-decl nil bdUnity nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (cup_leto formula-decl nil bdUnity nil)
    (<= const-decl "bool" mucalculus nil)
    (cap const-decl "bool" ownpred nil)
    (subset_leto formula-decl nil bdUnity nil)
    (specification type-eq-decl nil bdUnity nil)
    (cup const-decl "bool" ownpred nil)
    (pred type-eq-decl nil defined_types nil)
    (t formal-type-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (leto_transitive_1 0
  (leto_transitive_1-1 nil 3624287959
   ("" (skosimp)
    (("" (lemma leto_transitive_2)
      (("" (inst - m!1 n!1 p!1 q!1 pq!1 q!1 s!1)
        (("" (assert)
          (("" (case "cup(q!1, q!1)=q!1")
            (("1" (assert) nil nil)
             ("2" (hide - 2)
              (("2" (apply-extensionality :hide? t)
                (("2" (expand "cup")
                  (("2" (iff) (("2" (prop) nil nil)) nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((leto_transitive_2 formula-decl nil bdUnity nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (cup const-decl "bool" ownpred nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (specification type-eq-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (t formal-type-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (leto_up 0
  (leto_up-1 nil 3624288190
   ("" (skosimp)
    (("" (lemma leto_transitive)
      (("" (inst - i!1 "j!1-i!1" p!1 q!1 q!1 s!1)
        (("1" (assert)
          (("1" (hide -1 2)
            (("1" (use subset_leto)
              (("1" (assert)
                (("1" (hide -1 2)
                  (("1" (expand "<=")
                    (("1" (expand "cap") (("1" (skosimp) nil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (assert) nil nil))
        nil))
      nil))
    nil)
   ((leto_transitive formula-decl nil bdUnity nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (subset_leto formula-decl nil bdUnity nil)
    (cap const-decl "bool" ownpred nil)
    (<= const-decl "bool" mucalculus nil)
    (specification type-eq-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (t formal-type-decl nil bdUnity nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (j!1 skolem-const-decl "nat" bdUnity nil)
    (i!1 skolem-const-decl "nat" bdUnity nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil))
   shostak))
 (sub_leto 0
  (sub_leto-1 nil 3624288385
   ("" (skosimp)
    (("" (lemma leto_transitive)
      (("" (inst - 0 n!1 p!1 pq!1 q!1 s!1)
        (("" (assert)
          (("" (hide -2 2)
            (("" (use subset_leto) (("" (assert) nil nil)) nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((leto_transitive formula-decl nil bdUnity nil)
    (subset_leto formula-decl nil bdUnity nil)
    (specification type-eq-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (t formal-type-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (leto_sub 0
  (leto_sub-1 nil 3624288461
   ("" (skosimp)
    (("" (lemma leto_transitive)
      (("" (inst - n!1 0 p!1 pq!1 q!1 s!1)
        (("" (assert)
          (("" (hide -2 2)
            (("" (use subset_leto) (("" (assert) nil nil)) nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((leto_transitive formula-decl nil bdUnity nil)
    (subset_leto formula-decl nil bdUnity nil)
    (specification type-eq-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (t formal-type-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (shunting_leto 0
  (shunting_leto-1 nil 3624288527
   ("" (skosimp)
    (("" (lemma sub_leto)
      ((""
        (inst - n!1 p!1 "cup(cap(p!1, neg(pq!1)), pq!1)"
         "cup(q!1, pq!1)" s!1)
        (("" (assert)
          (("" (hide 2)
            (("" (split)
              (("1" (hide -)
                (("1" (expand "<=")
                  (("1" (expand "cap")
                    (("1" (expand "cup")
                      (("1" (expand "neg")
                        (("1" (skosimp) (("1" (assert) nil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (use cup_leto)
                (("2" (assert)
                  (("2" (hide 2)
                    (("2" (split)
                      (("1" (lemma leto_sub)
                        (("1"
                          (inst - n!1 "cap(p!1, neg(pq!1))" q!1
                           "cup(q!1, pq!1)" s!1)
                          (("1" (assert)
                            (("1" (hide - 2)
                              (("1"
                                (expand "<=")
                                (("1"
                                  (expand "cap")
                                  (("1"
                                    (expand "cup")
                                    (("1" (skosimp) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (hide -)
                        (("2" (use subset_leto)
                          (("2" (assert)
                            (("2" (hide 2)
                              (("2"
                                (expand "<=")
                                (("2"
                                  (expand "cap")
                                  (("2"
                                    (expand "cup")
                                    (("2" (skosimp) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((sub_leto formula-decl nil bdUnity nil)
    (<= const-decl "bool" mucalculus nil)
    (leto_sub formula-decl nil bdUnity nil)
    (subset_leto formula-decl nil bdUnity nil)
    (cup_leto formula-decl nil bdUnity nil)
    (specification type-eq-decl nil bdUnity nil)
    (neg const-decl "bool" ownpred nil)
    (cap const-decl "bool" ownpred nil)
    (cup const-decl "bool" ownpred nil)
    (pred type-eq-decl nil defined_types nil)
    (t formal-type-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (leto_inv 0
  (leto_inv-1 nil 3624288950
   ("" (skosimp)
    (("" (iff)
      (("" (lemma sub_leto)
        (("" (inst - j!1 _ _ q!1 s!1)
          (("" (prop)
            (("1" (inst - p!1 "cap(p!1, s!1`inv)")
              (("1" (assert)
                (("1" (hide - 1)
                  (("1" (expand "<=") (("1" (skosimp) nil nil)) nil))
                  nil))
                nil))
              nil)
             ("2" (inst - "cap(p!1, s!1`inv)" p!1)
              (("2" (assert)
                (("2" (hide - 1)
                  (("2" (expand "<=")
                    (("2" (expand "cap") (("2" (skosimp) nil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (t formal-type-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (specification type-eq-decl nil bdUnity nil)
    (cap const-decl "bool" ownpred nil)
    (<= const-decl "bool" mucalculus nil)
    (sub_leto formula-decl nil bdUnity nil))
   shostak))
 (distributed_progress_TCC1 0
  (distributed_progress_TCC1-1 nil 3670922272
   ("" (subtype-tcc) nil nil)
   ((exec const-decl "bool" bdUnity nil)
    (leq const-decl "bool" bdUnity nil)
    (cap const-decl "bool" ownpred nil)
    (leto const-decl "bool" bdUnity nil)
    (disgrowth const-decl "bool" bdUnity nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil))
   nil))
 (distributed_progress 0
  (distributed_progress-2 nil 3670927228
   ("" (skosimp)
    ((""
      (case "FORALL n: FORALL z, k: k < n IMPLIES 
leto(s!1)
          (k + mwe!1 - 1, leq(z, vf!1),
           cup(leq(z + k, vf!1), cov!1(0)))")
      (("1" (inst - "n!1+1")
        (("1" (inst?) (("1" (assert) nil nil)) nil)) nil)
       ("2" (hide 2)
        (("2" (induct n)
          (("1" (skosimp) (("1" (assert) nil nil)) nil)
           ("2" (skosimp*)
            (("2" (case "k!1=j!1")
              (("1" (replaceh -1)
                (("1" (hide -2)
                  (("1"
                    (name ppset
                          "{pp: pred[t] | EXISTS i: pp = cap(leq(z!2, vf!1), cov!1(i))}")
                    (("1" (lemma sub_leto)
                      (("1"
                        (inst - "j!1 + mwe!1 - 1" "leq(z!2, vf!1)"
                         "Union(ppset)"
                         "cup(leq(z!2 + j!1, vf!1), cov!1(0))" s!1)
                        (("1" (assert)
                          (("1" (hide -1)
                            (("1" (split)
                              (("1"
                                (hide-all-but (-4 1))
                                (("1"
                                  (expand "<=")
                                  (("1"
                                    (skosimp)
                                    (("1"
                                      (inst?)
                                      (("1"
                                        (expand "cap")
                                        (("1"
                                          (flatten)
                                          (("1"
                                            (assert)
                                            (("1"
                                              (skolem!)
                                              (("1"
                                                (expand "Union")
                                                (("1"
                                                  (inst
                                                   +
                                                   "cap(leq(z!2, vf!1), cov!1(i!1))")
                                                  (("1"
                                                    (expand "cap")
                                                    (("1"
                                                      (propax)
                                                      nil
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (expand "ppset")
                                                    (("2"
                                                      (inst?)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide 2)
                                (("2"
                                  (use leto_union)
                                  (("2"
                                    (assert)
                                    (("2"
                                      (hide 2)
                                      (("2"
                                        (skosimp)
                                        (("2"
                                          (expand "ppset")
                                          (("2"
                                            (skolem!)
                                            (("2"
                                              (replaceh -1)
                                              (("2"
                                                (case "i!1=0")
                                                (("1"
                                                  (replaceh -1)
                                                  (("1"
                                                    (hide -)
                                                    (("1"
                                                      (use subset_leto)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (hide 2)
                                                          (("1"
                                                            (expand
                                                             "<=")
                                                            (("1"
                                                              (expand
                                                               "cup")
                                                              (("1"
                                                                (expand
                                                                 "cap")
                                                                (("1"
                                                                  (skosimp)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (case "j!1=0")
                                                  (("1"
                                                    (replaceh -1)
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (hide -)
                                                        (("1"
                                                          (use
                                                           subset_leto)
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (hide 3)
                                                              (("1"
                                                                (expand
                                                                 "<=")
                                                                (("1"
                                                                  (expand
                                                                   "cup")
                                                                  (("1"
                                                                    (expand
                                                                     "cap")
                                                                    (("1"
                                                                      (skosimp)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (expand
                                                     "disgrowth")
                                                    (("2"
                                                      (inst -2 z!2 i!1)
                                                      (("1"
                                                        (name-replace
                                                         pp0
                                                         "cap(leq(z!2, vf!1), cov!1(i!1))")
                                                        (("1"
                                                          (case
                                                           "j!1 <= we!1(i!1)")
                                                          (("1"
                                                            (hide -2)
                                                            (("1"
                                                              (lemma
                                                               leto_sub)
                                                              (("1"
                                                                (inst
                                                                 -
                                                                 "we!1(i!1)"
                                                                 pp0
                                                                 _
                                                                 "cup(leq(j!1 + z!2, vf!1), cov!1(0))"
                                                                 s!1)
                                                                (("1"
                                                                  (inst?)
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (split)
                                                                      (("1"
                                                                        (hide
                                                                         -3)
                                                                        (("1"
                                                                          (lemma
                                                                           leto_up)
                                                                          (("1"
                                                                            (inst
                                                                             -
                                                                             "we!1(i!1)"
                                                                             "j!1 - 1 + mwe!1"
                                                                             _
                                                                             _
                                                                             s!1)
                                                                            (("1"
                                                                              (inst?)
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (inst?
                                                                                   -3)
                                                                                  (("1"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (hide
                                                                         -2
                                                                         4)
                                                                        (("2"
                                                                          (expand
                                                                           "<="
                                                                           +)
                                                                          (("2"
                                                                            (expand
                                                                             "cup")
                                                                            (("2"
                                                                              (expand
                                                                               "cap")
                                                                              (("2"
                                                                                (expand
                                                                                 "leq")
                                                                                (("2"
                                                                                  (skosimp)
                                                                                  (("2"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (inst
                                                             -
                                                             "z!2 + we!1(i!1)"
                                                             "j!1-we!1(i!1)")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (name-replace
                                                                 pp1
                                                                 "leq(we!1(i!1) + z!2, vf!1)")
                                                                (("1"
                                                                  (name-replace
                                                                   pp2
                                                                   "cup(leq(j!1 + z!2, vf!1), cov!1(0))")
                                                                  (("1"
                                                                    (lemma
                                                                     leto_transitive)
                                                                    (("1"
                                                                      (inst
                                                                       -
                                                                       "we!1(i!1)"
                                                                       "-1 - we!1(i!1) + j!1 + mwe!1"
                                                                       _
                                                                       _
                                                                       _
                                                                       _)
                                                                      (("1"
                                                                        (inst?)
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (inst?)
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (inst?) (("2" (assert) nil nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((cup const-decl "bool" ownpred nil)
    (leq const-decl "bool" bdUnity nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (leto const-decl "bool" bdUnity nil)
    (specification type-eq-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (t formal-type-decl nil bdUnity nil)
    (< const-decl "bool" reals nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (sub_leto formula-decl nil bdUnity nil)
    (Union_surjective name-judgement
     "(surjective?[setofsets[T], set[T]])" sets_lemmas nil)
    (<= const-decl "bool" mucalculus nil)
    (ppset skolem-const-decl "[pred[t] -> boolean]" bdUnity nil)
    (z!2 skolem-const-decl "int" bdUnity nil)
    (vf!1 skolem-const-decl "[t -> int]" bdUnity nil)
    (cov!1 skolem-const-decl "[nat -> pred[t]]" bdUnity nil)
    (i!1 skolem-const-decl "nat" bdUnity nil)
    (leto_union formula-decl nil bdUnity nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (i!1 skolem-const-decl "nat" bdUnity nil)
    (<= const-decl "bool" reals nil)
    (leto_sub formula-decl nil bdUnity nil)
    (leto_up formula-decl nil bdUnity nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (leto_transitive formula-decl nil bdUnity nil)
    (we!1 skolem-const-decl "[posnat -> posnat]" bdUnity nil)
    (j!1 skolem-const-decl "nat" bdUnity nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (disgrowth const-decl "bool" bdUnity nil)
    (subset_leto formula-decl nil bdUnity nil)
    (setof type-eq-decl nil defined_types nil)
    (setofsets type-eq-decl nil sets nil)
    (set type-eq-decl nil sets nil) (Union const-decl "set" sets nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (cap const-decl "bool" ownpred nil))
   nil)
  (distributed_progress-1 nil 3670922293
   ("" (skosimp)
    ((""
      (case "FORALL n: 
FORALL k: k < n IMPLIES leto(s!1)(k + mweight!1 - 1, leq(z1!1, vf!1),
           cup(leq(z1!1 + k, vf!1), cover!1(0)))")
      (("1" (inst - "n!1+1")
        (("1" (inst - n!1) (("1" (assert) nil nil)) nil)) nil)
       ("2" (hide 2)
        (("2" (induct n)
          (("1" (assert) nil nil)
           ("2" (skosimp*)
            (("2" (inst -3 z1!1 _)
              (("2"
                (name ppset
                      "{pp: pred[t] | EXISTS i: pp = cap(leq(z1!1, vf!1), cover!1(i))}")
                (("2" (lemma leto_union)
                  (("2"
                    (inst - "k!1 + mweight!1 - 1" ppset
                     "cup(leq(z1!1 + k!1, vf!1), cover!1(0))" s!1)
                    (("2" (split)
                      (("1" (case "Union(ppset) = leq(z1!1, vf!1)")
                        (("1" (assert) nil nil)
                         ("2" (hide -1 -2 -3 -5 -6 2)
                          (("2" (apply-extensionality :hide? t)
                            (("2" (iff)
                              (("2"
                                (prop)
                                (("1"
                                  (expand "Union")
                                  (("1"
                                    (skolem!)
                                    (("1"
                                      (typepred a!1)
                                      (("1"
                                        (expand "ppset")
                                        (("1"
                                          (skolem!)
                                          (("1"
                                            (replaceh -1)
                                            (("1"
                                              (expand "cap")
                                              (("1" (assert) nil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (inst?)
                                  (("2"
                                    (skolem!)
                                    (("2"
                                      (expand "Union")
                                      (("2"
                                        (inst
                                         +
                                         "cap(leq(z1!1, vf!1), cover!1(i!1))")
                                        (("1"
                                          (expand "cap")
                                          (("1" (assert) nil nil))
                                          nil)
                                         ("2"
                                          (expand "ppset")
                                          (("2" (inst?) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (hide 2 -1)
                        (("2" (skosimp)
                          (("2" (expand "ppset")
                            (("2" (skosimp)
                              (("2"
                                (replaceh -1)
                                (("2"
                                  (case "i!1 = 0")
                                  (("1"
                                    (replace -1)
                                    (("1"
                                      (hide -)
                                      (("1"
                                        (use subset_leto)
                                        (("1"
                                          (assert)
                                          (("1"
                                            (hide 2)
                                            (("1"
                                              (expand "<=")
                                              (("1"
                                                (expand "cup")
                                                (("1"
                                                  (expand "cap")
                                                  (("1"
                                                    (skosimp)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (inst? -3)
                                    (("1"
                                      (case "k!1=0")
                                      (("1"
                                        (replaceh -1)
                                        (("1"
                                          (assert)
                                          (("1"
                                            (hide -)
                                            (("1"
                                              (use subset_leto)
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (hide 3)
                                                  (("1"
                                                    (expand "<=")
                                                    (("1"
                                                      (expand "cup")
                                                      (("1"
                                                        (expand "cap")
                                                        (("1"
                                                          (skosimp)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (name-replace
                                         pp0
                                         "cap(leq(z1!1, vf!1), cover!1(i!1))")
                                        (("2"
                                          (case "k!1 <= weight!1(i!1)")
                                          (("1"
                                            (hide -2)
                                            (("1"
                                              (lemma leto_sub)
                                              (("1"
                                                (inst
                                                 -
                                                 "weight!1(i!1)"
                                                 pp0
                                                 "leq(z1!1 + weight!1(i!1), vf!1)"
                                                 "cup(leq(z1!1 + k!1, vf!1), cover!1(0))"
                                                 s!1)
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (split)
                                                    (("1"
                                                      (lemma leto_up)
                                                      (("1"
                                                        (inst
                                                         -
                                                         "weight!1(i!1)"
                                                         "k!1 - 1 + mweight!1"
                                                         _
                                                         _
                                                         s!1)
                                                        (("1"
                                                          (inst?)
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (inst?
                                                               -5)
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (hide -3 4)
                                                      (("2"
                                                        (expand "<=" +)
                                                        (("2"
                                                          (expand
                                                           "cup")
                                                          (("2"
                                                            (expand
                                                             "leq")
                                                            (("2"
                                                              (expand
                                                               "cap")
                                                              (("2"
                                                                (skosimp)
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2" (postpone) nil nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2" (assert) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   nil shostak))
 (proportional_progress 0
  (proportional_progress-1 nil 3671005404
   ("" (skosimp)
    (("" (inst - "fac!1 * i!1 + delay!1" "fac!1 * z1!1")
      (("" (assert)
        (("" (name-replace nn1 "fac!1 * i!1 + delay!1 + offset!1")
          (("" (name-replace pp0 "leq(z1!1, svf!1)")
            (("" (name-replace pp1 "leq(fac!1 * z1!1, vf!1)")
              ((""
                (name-replace pp2
                 "cup(leq(fac!1 * i!1 + fac!1 * z1!1 + delay!1, vf!1), alt!1)")
                ((""
                  (name-replace pp3
                   "cup(leq(i!1 + z1!1, svf!1), cup(alt!1, exc!1))")
                  (("" (lemma sub_leto)
                    (("" (inst - nn1 pp0 pp1 pp2 s!1)
                      (("" (assert)
                        (("" (split)
                          (("1" (hide -2)
                            (("1" (lemma leto_sub)
                              (("1"
                                (inst - nn1 pp0 pp2 pp3 s!1)
                                (("1"
                                  (assert)
                                  (("1"
                                    (hide -1 2)
                                    (("1"
                                      (expand "<=" +)
                                      (("1"
                                        (expand "pp2")
                                        (("1"
                                          (expand "pp3")
                                          (("1"
                                            (expand "cup")
                                            (("1"
                                              (expand "cap")
                                              (("1"
                                                (expand "leq")
                                                (("1"
                                                  (skosimp)
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (inst? -4)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (lemma
                                                           both_sides_times_pos_le2)
                                                          (("1"
                                                            (inst
                                                             -
                                                             fac!1
                                                             "i!1+z1!1"
                                                             "svf!1(s!2)")
                                                            (("1"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (hide -1 2)
                            (("2" (expand "<=" +)
                              (("2"
                                (expand "pp0")
                                (("2"
                                  (expand "pp1")
                                  (("2"
                                    (expand "cap")
                                    (("2"
                                      (expand "leq")
                                      (("2"
                                        (skosimp)
                                        (("2"
                                          (inst?)
                                          (("2"
                                            (assert)
                                            (("2"
                                              (lemma
                                               both_sides_times_pos_le2)
                                              (("2"
                                                (inst?)
                                                (("2"
                                                  (inst - "svf!1(s!2)")
                                                  (("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (specification type-eq-decl nil bdUnity nil)
    (leto_sub formula-decl nil bdUnity nil)
    (<= const-decl "bool" mucalculus nil)
    (pp3 skolem-const-decl "[t -> bool]" bdUnity nil)
    (cap const-decl "bool" ownpred nil)
    (both_sides_times_pos_le2 formula-decl nil real_props nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (pp2 skolem-const-decl "[t -> bool]" bdUnity nil)
    (pp1 skolem-const-decl "[t -> bool]" bdUnity nil)
    (pp0 skolem-const-decl "[t -> bool]" bdUnity nil)
    (sub_leto formula-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (cup const-decl "bool" ownpred nil)
    (t formal-type-decl nil bdUnity nil)
    (leq const-decl "bool" bdUnity nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil))
   shostak))
 (fwd_measure_ensures 0
  (fwd_measure_ensures-1 nil 3679326125
   ("" (expand "fwd_measure")
    (("" (skosimp)
      (("" (use ensures_leto)
        (("" (assert)
          (("" (hide 2)
            (("" (expand "ensures")
              (("" (expand "transient")
                (("" (expand "co")
                  (("" (expand "<=" +)
                    (("" (expand "wp")
                      (("" (expand "cap")
                        (("" (expand "neg")
                          (("" (expand "cup")
                            (("" (expand "leq")
                              ((""
                                (split)
                                (("1"
                                  (skosimp*)
                                  (("1"
                                    (inst?)
                                    (("1"
                                      (assert)
                                      (("1"
                                        (inst -8 k!1 s!2 y!1)
                                        (("1" (assert) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (inst + k!1)
                                  (("2"
                                    (split)
                                    (("1"
                                      (skosimp)
                                      (("1"
                                        (expand "<=" -5)
                                        (("1"
                                          (inst? -5)
                                          (("1" (assert) nil nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (skosimp)
                                      (("2"
                                        (inst? -9)
                                        (("2" (assert) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((ensures const-decl "bool" bdUnity nil)
    (co const-decl "bool" bdUnity nil)
    (wp const-decl "bool" ownpred nil)
    (neg const-decl "bool" ownpred nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (cup const-decl "bool" ownpred nil)
    (<= const-decl "bool" mucalculus nil)
    (transient const-decl "bool" bdUnity nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (t formal-type-decl nil bdUnity nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (pred type-eq-decl nil defined_types nil)
    (cap const-decl "bool" ownpred nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (leq const-decl "bool" bdUnity nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (specification type-eq-decl nil bdUnity nil)
    (ensures_leto formula-decl nil bdUnity nil)
    (fwd_measure const-decl "bool" bdUnity nil))
   shostak))
 (fwd_measure_leadsto 0
  (fwd_measure_leadsto-2 nil 3679372903
   ("" (skosimp)
    (("" (use shunting_leto)
      (("" (assert)
        (("" (hide 2)
          (("" (lemma leto_union)
            (("" (inst?)
              (("" (inst - 1 _ "leq(1 + z!1, vf!1)")
                ((""
                  (name ppset
                        "{pp: pred[t] | exists k: pp = cap(leq(z!1, vf!1), vena!1(k))}")
                  (("" (inst - ppset)
                    (("" (split)
                      (("1"
                        (case "Union(ppset)=cap(leq(z!1, vf!1), neg(none(vena!1, s!1)))")
                        (("1" (assert) nil nil)
                         ("2" (hide - 2)
                          (("2" (apply-extensionality :hide? t)
                            (("2" (iff)
                              (("2"
                                (prop)
                                (("1"
                                  (expand "Union")
                                  (("1"
                                    (skolem!)
                                    (("1"
                                      (typepred a!1)
                                      (("1"
                                        (expand "ppset")
                                        (("1"
                                          (skolem!)
                                          (("1"
                                            (replaceh -1)
                                            (("1"
                                              (expand "cap")
                                              (("1"
                                                (flatten)
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (expand "neg")
                                                    (("1"
                                                      (expand "none")
                                                      (("1"
                                                        (inst?)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (expand "cap")
                                  (("2"
                                    (flatten)
                                    (("2"
                                      (expand "neg")
                                      (("2"
                                        (expand "none")
                                        (("2"
                                          (expand "Union")
                                          (("2"
                                            (skosimp)
                                            (("2"
                                              (inst
                                               +
                                               "cap(leq(z!1, vf!1), vena!1(k!1))")
                                              (("1"
                                                (expand "cap")
                                                (("1"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil)
                                               ("2"
                                                (expand "ppset")
                                                (("2"
                                                  (inst + k!1)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (hide 2 -1)
                        (("2" (skosimp)
                          (("2" (expand "ppset")
                            (("2" (skolem!)
                              (("2"
                                (use fwd_measure_ensures)
                                (("2" (assert) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((leto_union formula-decl nil bdUnity nil)
    (fwd_measure_ensures formula-decl nil bdUnity nil)
    (neg const-decl "bool" ownpred nil)
    (Union const-decl "set" sets nil)
    (setofsets type-eq-decl nil sets nil)
    (setof type-eq-decl nil defined_types nil)
    (set type-eq-decl nil sets nil)
    (Union_surjective name-judgement
     "(surjective?[setofsets[T], set[T]])" sets_lemmas nil)
    (ppset skolem-const-decl "[pred[t] -> boolean]" bdUnity nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (k!1 skolem-const-decl "nat" bdUnity nil)
    (vena!1 skolem-const-decl "[nat -> pred[t]]" bdUnity nil)
    (vf!1 skolem-const-decl "[t -> int]" bdUnity nil)
    (z!1 skolem-const-decl "int" bdUnity nil)
    (cap const-decl "bool" ownpred nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (t formal-type-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (leq const-decl "bool" bdUnity nil)
    (specification type-eq-decl nil bdUnity nil)
    (none const-decl "bool" bdUnity nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (shunting_leto formula-decl nil bdUnity nil))
   nil)
  (fwd_measure_leadsto-1 nil 3629006572
   ("" (skosimp)
    (("" (use shunting_leto)
      (("" (assert)
        (("" (hide 2)
          (("" (lemma leto_union)
            (("" (inst?)
              (("" (inst - 1 _ "leq(1 + z!1, vf!1)")
                ((""
                  (name ppset
                        "{pp: pred[t] | exists k: pp = cap(leq(z!1, vf!1), vena!1(k))}")
                  (("" (inst - ppset)
                    (("" (split)
                      (("1"
                        (case "Union(ppset)=cap(leq(z!1, vf!1), neg(none(vena!1, s!1)))")
                        (("1" (assert) nil nil)
                         ("2" (hide - 2)
                          (("2" (apply-extensionality :hide? t)
                            (("2" (iff)
                              (("2"
                                (prop)
                                (("1"
                                  (expand "Union")
                                  (("1"
                                    (skolem!)
                                    (("1"
                                      (typepred a!1)
                                      (("1"
                                        (expand "ppset")
                                        (("1"
                                          (skolem!)
                                          (("1"
                                            (replaceh -1)
                                            (("1"
                                              (expand "cap")
                                              (("1"
                                                (flatten)
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (expand "neg")
                                                    (("1"
                                                      (expand "none")
                                                      (("1"
                                                        (inst?)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (expand "cap")
                                  (("2"
                                    (flatten)
                                    (("2"
                                      (expand "neg")
                                      (("2"
                                        (expand "none")
                                        (("2"
                                          (expand "Union")
                                          (("2"
                                            (skosimp)
                                            (("2"
                                              (inst
                                               +
                                               "cap(leq(z!1, vf!1), vena!1(k!1))")
                                              (("1"
                                                (expand "cap")
                                                (("1"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil)
                                               ("2"
                                                (expand "ppset")
                                                (("2"
                                                  (inst + k!1)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (hide 2 -1)
                        (("2" (skosimp)
                          (("2" (expand "ppset")
                            (("2" (skolem!)
                              (("2"
                                (use fwd_measure_ensuresA)
                                (("2" (assert) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((shunting_leto formula-decl nil bdUnity nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (none const-decl "bool" bdUnity nil)
    (specification type-eq-decl nil bdUnity nil)
    (leq const-decl "bool" bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (t formal-type-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (cap const-decl "bool" ownpred nil) nil nil nil nil
    (NOT const-decl "[bool -> bool]" booleans nil) nil
    (Union_surjective name-judgement
     "(surjective?[setofsets[T], set[T]])" sets_lemmas nil)
    (set type-eq-decl nil sets nil)
    (setof type-eq-decl nil defined_types nil)
    (setofsets type-eq-decl nil sets nil)
    (Union const-decl "set" sets nil)
    (neg const-decl "bool" ownpred nil) nil
    (leto_union formula-decl nil bdUnity nil))
   shostak))
 (fwd_measure_leadsto_more 0
  (fwd_measure_leadsto_more-1 nil 3629007165
   ("" (induct n)
    (("1" (skosimp)
      (("1" (use subset_leto)
        (("1" (assert)
          (("1" (hide - 2)
            (("1" (expand "<=")
              (("1" (expand "cap")
                (("1" (expand "cup") (("1" (skosimp) nil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil)
     ("2" (skosimp*)
      (("2" (inst?)
        (("2" (assert)
          (("2" (lemma leto_transitive_2)
            (("2" (inst?)
              (("2" (lemma fwd_measure_leadsto)
                (("2" (inst - _ _ _ z!1)
                  (("2" (inst?)
                    (("2" (assert)
                      (("2" (inst?) (("2" (assert) nil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (fwd_measure_leadsto formula-decl nil bdUnity nil)
    (leto_transitive_2 formula-decl nil bdUnity nil)
    (<= const-decl "bool" mucalculus nil)
    (cap const-decl "bool" ownpred nil)
    (subset_leto formula-decl nil bdUnity nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (none const-decl "bool" bdUnity nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (cup const-decl "bool" ownpred nil)
    (leq const-decl "bool" bdUnity nil)
    (leto const-decl "bool" bdUnity nil)
    (fwd_measure const-decl "bool" bdUnity nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (specification type-eq-decl nil bdUnity nil)
    (t formal-type-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (int_plus_int_is_int application-judgement "int" integers nil))
   shostak))
 (proportional_measure_leadsto 0
  (proportional_measure_leadsto-1 nil 3629009375
   ("" (skosimp)
    (("" (lemma fwd_measure_leadsto_more)
      (("" (inst - n!1 s!1 vena!1 vf!1 _)
        (("" (assert)
          (("" (inst - "fac!1 * z!1")
            (("" (hide -2)
              (("" (name-replace pp0 "leq(z!1, svf!1)")
                (("" (name-replace pp1 "leq(fac!1 * z!1, vf!1)")
                  ((""
                    (name-replace pp2
                     "cup(leq(fac!1 * z!1 + n!1, vf!1), none(vena!1, s!1))")
                    ((""
                      (name-replace pp3
                       "cup(leq(i!1 + z!1, svf!1), none(vena!1, s!1))")
                      (("" (lemma sub_leto)
                        (("" (inst - n!1 pp0 pp1 pp3 s!1)
                          (("" (assert)
                            (("" (hide 2)
                              ((""
                                (split)
                                (("1"
                                  (expand "<=" +)
                                  (("1"
                                    (hide -1)
                                    (("1"
                                      (expand "pp0")
                                      (("1"
                                        (expand "pp1")
                                        (("1"
                                          (expand "cap")
                                          (("1"
                                            (expand "leq")
                                            (("1"
                                              (skosimp)
                                              (("1"
                                                (expand "subset?")
                                                (("1"
                                                  (expand "member")
                                                  (("1"
                                                    (expand
                                                     "proportional")
                                                    (("1"
                                                      (inst?)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (flatten)
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (lemma
                                                               both_sides_times_pos_le2)
                                                              (("1"
                                                                (inst?)
                                                                (("1"
                                                                  (inst
                                                                   -
                                                                   "svf!1(s!2)")
                                                                  (("1"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (lemma leto_sub)
                                  (("2"
                                    (inst - n!1 pp1 pp2 pp3 s!1)
                                    (("2"
                                      (assert)
                                      (("2"
                                        (hide -1 2)
                                        (("2"
                                          (expand "<=" +)
                                          (("2"
                                            (expand "pp2")
                                            (("2"
                                              (expand "pp3")
                                              (("2"
                                                (expand "cap")
                                                (("2"
                                                  (expand "cup")
                                                  (("2"
                                                    (skosimp)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (expand "leq")
                                                        (("2"
                                                          (hide 2)
                                                          (("2"
                                                            (expand
                                                             "subset?")
                                                            (("2"
                                                              (expand
                                                               "member")
                                                              (("2"
                                                                (expand
                                                                 "proportional")
                                                                (("2"
                                                                  (inst?)
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (flatten)
                                                                      (("2"
                                                                        (hide
                                                                         -3
                                                                         -2)
                                                                        (("2"
                                                                          (lemma
                                                                           both_sides_times_pos_le2)
                                                                          (("2"
                                                                            (inst
                                                                             -
                                                                             fac!1
                                                                             "svf!1(s!2)"
                                                                             "i!1 + z!1-1")
                                                                            (("2"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((fwd_measure_leadsto_more formula-decl nil bdUnity nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (subset_is_partial_order name-judgement "(partial_order?[set[T]])"
     sets_lemmas nil)
    (leto_sub formula-decl nil bdUnity nil)
    (pp3 skolem-const-decl "[t -> bool]" bdUnity nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (pp2 skolem-const-decl "[t -> bool]" bdUnity nil)
    (<= const-decl "bool" mucalculus nil)
    (pp0 skolem-const-decl "[t -> bool]" bdUnity nil)
    (cap const-decl "bool" ownpred nil)
    (member const-decl "bool" sets nil)
    (both_sides_times_pos_le2 formula-decl nil real_props nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (proportional const-decl "bool" bdUnity nil)
    (subset? const-decl "bool" sets nil)
    (pp1 skolem-const-decl "[t -> bool]" bdUnity nil)
    (sub_leto formula-decl nil bdUnity nil)
    (cup const-decl "bool" ownpred nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (none const-decl "bool" bdUnity nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (leq const-decl "bool" bdUnity nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (specification type-eq-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (t formal-type-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (proportional_measure_leadsto1 0
  (proportional_measure_leadsto1-1 nil 3669543573
   ("" (skosimp)
    (("" (lemma fwd_measure_leadsto_more)
      (("" (inst - n!1 s!1 vena!1 vf!1 _)
        (("" (inst - "fac!1 * z!1")
          (("" (assert)
            (("" (hide -2)
              (("" (name-replace pp0 "leq(z!1, svf!1)")
                (("" (name-replace pp1 "leq(fac!1 * z!1, vf!1)")
                  ((""
                    (name-replace pp2
                     "cup(leq(fac!1 * z!1 + n!1, vf!1), none(vena!1, s!1))")
                    ((""
                      (name-replace pp3
                       "cup(neg(p!1), cup(leq(i!1 + z!1, svf!1), none(vena!1, s!1)))")
                      (("" (lemma sub_leto)
                        (("" (inst - n!1 pp0 pp1 pp3 s!1)
                          (("" (assert)
                            (("" (hide 2)
                              ((""
                                (split)
                                (("1"
                                  (expand "<=")
                                  (("1"
                                    (expand "pp0")
                                    (("1"
                                      (expand "pp1")
                                      (("1"
                                        (expand "cap")
                                        (("1"
                                          (expand "leq")
                                          (("1"
                                            (expand "subset?")
                                            (("1"
                                              (expand "member")
                                              (("1"
                                                (skosimp)
                                                (("1"
                                                  (inst?)
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (expand
                                                       "proportionA")
                                                      (("1"
                                                        (hide-all-but
                                                         (-1 -4)
                                                         -)
                                                        (("1"
                                                          (lemma
                                                           both_sides_times_pos_le2)
                                                          (("1"
                                                            (inst?)
                                                            (("1"
                                                              (inst
                                                               -
                                                               "svf!1(s!2)")
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (lemma leto_sub)
                                  (("2"
                                    (inst - n!1 pp1 pp2 pp3 s!1)
                                    (("2"
                                      (assert)
                                      (("2"
                                        (hide -1 2)
                                        (("2"
                                          (expand "<=" +)
                                          (("2"
                                            (expand "pp2")
                                            (("2"
                                              (expand "pp3")
                                              (("2"
                                                (expand "subset?")
                                                (("2"
                                                  (expand "member")
                                                  (("2"
                                                    (expand "cap")
                                                    (("2"
                                                      (expand
                                                       "proportionB")
                                                      (("2"
                                                        (expand "cup")
                                                        (("2"
                                                          (expand
                                                           "neg")
                                                          (("2"
                                                            (expand
                                                             "leq")
                                                            (("2"
                                                              (skosimp)
                                                              (("2"
                                                                (replace
                                                                 2)
                                                                (("2"
                                                                  (inst?)
                                                                  (("2"
                                                                    (inst?)
                                                                    (("2"
                                                                      (assert)
                                                                      (("2"
                                                                        (lemma
                                                                         both_sides_times_pos_le2)
                                                                        (("2"
                                                                          (inst
                                                                           -
                                                                           fac!1
                                                                           "svf!1(s!2)"
                                                                           "z!1+i!1-1")
                                                                          (("2"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((fwd_measure_leadsto_more formula-decl nil bdUnity nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (neg const-decl "bool" ownpred nil)
    (leto_sub formula-decl nil bdUnity nil)
    (pp3 skolem-const-decl "[t -> bool]" bdUnity nil)
    (proportionB const-decl "bool" bdUnity nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (pp2 skolem-const-decl "[t -> bool]" bdUnity nil)
    (<= const-decl "bool" reals nil)
    (<= const-decl "bool" mucalculus nil)
    (pp1 skolem-const-decl "[t -> bool]" bdUnity nil)
    (member const-decl "bool" sets nil)
    (proportionA const-decl "bool" bdUnity nil)
    (both_sides_times_pos_le2 formula-decl nil real_props nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (subset? const-decl "bool" sets nil)
    (cap const-decl "bool" ownpred nil)
    (pp0 skolem-const-decl "[t -> bool]" bdUnity nil)
    (sub_leto formula-decl nil bdUnity nil)
    (cup const-decl "bool" ownpred nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (none const-decl "bool" bdUnity nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (leq const-decl "bool" bdUnity nil)
    (subset_is_partial_order name-judgement "(partial_order?[set[T]])"
     sets_lemmas nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (specification type-eq-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (t formal-type-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (subset_leadsto 0
  (subset_leadsto-1 nil 3624290934
   ("" (expand "leadsto")
    (("" (expand "<=")
      (("" (skosimp*)
        (("" (inst?)
          (("" (inst?)
            (("" (expand "cap")
              (("" (assert)
                (("" (expand "run")
                  (("" (expand "exec")
                    (("" (flatten)
                      (("" (inst?) (("" (assert) nil nil)) nil)) nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((<= const-decl "bool" mucalculus nil)
    (t formal-type-decl nil bdUnity nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (cap const-decl "bool" ownpred nil)
    (run const-decl "bool" bdUnity nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (exec const-decl "bool" bdUnity nil)
    (leadsto const-decl "bool" bdUnity nil))
   shostak))
 (ensures_leadsto 0
  (ensures_leadsto-1 nil 3679326644
   ("" (expand "leadsto")
    (("" (expand "ensures")
      (("" (skosimp*)
        (("" (expand "co")
          (("" (expand "transient")
            (("" (expand "<=")
              (("" (expand "wp")
                (("" (expand "cap")
                  (("" (expand "neg")
                    (("" (skosimp)
                      (("" (expand "cup")
                        (("" (expand "run")
                          (("" (flatten)
                            (("" (inst? -5)
                              ((""
                                (expand "exec")
                                ((""
                                  (case "forall n: p!1(xs!1(n))")
                                  (("1"
                                    (expand "weakfair")
                                    (("1"
                                      (expand "fw")
                                      (("1"
                                        (inst -6 0)
                                        (("1"
                                          (assert)
                                          (("1"
                                            (skolem!)
                                            (("1"
                                              (split)
                                              (("1"
                                                (inst? -5)
                                                (("1"
                                                  (inst-cp - i!1)
                                                  (("1"
                                                    (inst-cp + i!1)
                                                    (("1"
                                                      (inst + "1+i!1")
                                                      (("1"
                                                        (inst
                                                         -
                                                         "1+i!1")
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (inst? -6)
                                                            (("1"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (inst? -3)
                                                (("2"
                                                  (inst?)
                                                  (("2"
                                                    (inst? -5)
                                                    (("2"
                                                      (flatten)
                                                      (("2"
                                                        (assert)
                                                        (("2"
                                                          (inst? +)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (induct n)
                                    (("2"
                                      (skosimp)
                                      (("2"
                                        (inst? -)
                                        (("2"
                                          (inst? -5)
                                          (("2"
                                            (flatten)
                                            (("2"
                                              (assert)
                                              (("2"
                                                (split -)
                                                (("1"
                                                  (inst
                                                   -
                                                   "xs!1(j!1+1)")
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (inst + "j!1+1")
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (inst? +)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((ensures const-decl "bool" bdUnity nil)
    (co const-decl "bool" bdUnity nil)
    (<= const-decl "bool" mucalculus nil)
    (cap const-decl "bool" ownpred nil)
    (run const-decl "bool" bdUnity nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (t formal-type-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (fw const-decl "bool" bdUnity nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (weakfair const-decl "bool" bdUnity nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (exec const-decl "bool" bdUnity nil)
    (cup const-decl "bool" ownpred nil)
    (neg const-decl "bool" ownpred nil)
    (wp const-decl "bool" ownpred nil)
    (transient const-decl "bool" bdUnity nil)
    (leadsto const-decl "bool" bdUnity nil))
   shostak))
 (leadsto_union 0
  (leadsto_union-1 nil 3624291802
   ("" (expand "leadsto")
    (("" (skosimp*)
      (("" (expand "Union")
        (("" (skolem!)
          (("" (inst?)
            (("" (assert) (("" (inst?) (("" (assert) nil nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (pred type-eq-decl nil defined_types nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (t formal-type-decl nil bdUnity nil)
    (Union const-decl "set" sets nil)
    (leadsto const-decl "bool" bdUnity nil))
   shostak))
 (leadsto_transitive 0
  (leadsto_transitive-1 nil 3624291868
   ("" (expand "leadsto")
    (("" (skosimp*)
      (("" (inst? -)
        (("" (assert)
          (("" (skolem!)
            (("" (use drop_run)
              (("" (assert)
                (("" (inst - "drop(i!1)(xs!1)")
                  (("" (assert)
                    (("" (expand "drop")
                      (("" (skolem!) (("" (inst + "i!2+i!1") nil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((drop_run formula-decl nil bdUnity nil)
    (specification type-eq-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (drop const-decl "t" bdUnity nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (t formal-type-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (leadsto const-decl "bool" bdUnity nil))
   shostak))
 (PSP_leadsto 0
  (PSP_leadsto-1 nil 3624292063
   ("" (expand "leadsto")
    (("" (skosimp*)
      (("" (expand "cap")
        (("" (expand "cup")
          (("" (flatten)
            (("" (inst?)
              (("" (assert)
                (("" (case "forall i: pa!1(xs!1(i))")
                  (("1" (skolem!)
                    (("1" (inst - i!1)
                      (("1" (inst + i!1) (("1" (assert) nil nil)) nil))
                      nil))
                    nil)
                   ("2" (induct i)
                    (("2" (skosimp)
                      (("2" (expand "unless")
                        (("2" (expand "<=")
                          (("2" (expand "wp")
                            (("2" (expand "cap")
                              (("2"
                                (expand "neg")
                                (("2"
                                  (expand "run")
                                  (("2"
                                    (flatten)
                                    (("2"
                                      (expand "exec")
                                      (("2"
                                        (inst? -)
                                        (("2"
                                          (inst? -)
                                          (("2"
                                            (flatten)
                                            (("2"
                                              (assert)
                                              (("2"
                                                (split)
                                                (("1"
                                                  (inst
                                                   -
                                                   "xs!1(1 + j!1)")
                                                  (("1"
                                                    (expand "cup")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (inst
                                                         +
                                                         "1+j!1")
                                                        (("1"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (inst + j!1)
                                                  (("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((cup const-decl "bool" ownpred nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (t formal-type-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (<= const-decl "bool" mucalculus nil)
    (run const-decl "bool" bdUnity nil)
    (exec const-decl "bool" bdUnity nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (neg const-decl "bool" ownpred nil)
    (wp const-decl "bool" ownpred nil)
    (unless const-decl "bool" bdUnity nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (cap const-decl "bool" ownpred nil)
    (leadsto const-decl "bool" bdUnity nil))
   shostak))
 (cup_leadsto 0
  (cup_leadsto-1 nil 3624292410
   ("" (expand "leadsto")
    (("" (skosimp*)
      (("" (expand "cup")
        (("" (inst?)
          (("" (inst?)
            (("" (assert)
              (("" (replace 1) (("" (assert) nil nil)) nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (t formal-type-decl nil bdUnity nil)
    (cup const-decl "bool" ownpred nil)
    (leadsto const-decl "bool" bdUnity nil))
   shostak))
 (leadsto_transitive_2 0
  (leadsto_transitive_2-1 nil 3624292491
   ("" (skosimp)
    (("" (lemma leadsto_transitive)
      (("" (inst - p!1 "cup(pq!1, pa!1)" "cup(q!1, pa!1)" s!1)
        (("" (assert)
          (("" (hide -1 2)
            (("" (use cup_leadsto)
              (("" (assert)
                (("" (hide - 2)
                  (("" (use subset_leadsto)
                    (("" (assert)
                      (("" (hide 2)
                        (("" (expand "<=")
                          (("" (expand "cap")
                            (("" (expand "cup")
                              (("" (skosimp) nil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((leadsto_transitive formula-decl nil bdUnity nil)
    (cup_leadsto formula-decl nil bdUnity nil)
    (<= const-decl "bool" mucalculus nil)
    (cap const-decl "bool" ownpred nil)
    (subset_leadsto formula-decl nil bdUnity nil)
    (specification type-eq-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (cup const-decl "bool" ownpred nil)
    (pred type-eq-decl nil defined_types nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (t formal-type-decl nil bdUnity nil))
   shostak))
 (leadsto_transitive_1 0
  (leadsto_transitive_1-1 nil 3624292624
   ("" (skosimp)
    (("" (lemma leadsto_transitive_2)
      (("" (inst - p!1 q!1 pq!1 q!1 s!1)
        (("" (assert)
          (("" (case "cup(q!1, q!1) = q!1")
            (("1" (assert) nil nil)
             ("2" (hide - 2)
              (("2" (expand "cup")
                (("2" (apply-extensionality :hide? t)
                  (("2" (iff) (("2" (prop) nil nil)) nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((leadsto_transitive_2 formula-decl nil bdUnity nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (cup const-decl "bool" ownpred nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (specification type-eq-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (t formal-type-decl nil bdUnity nil))
   shostak))
 (sub_leadsto 0
  (sub_leadsto-1 nil 3624292734
   ("" (skosimp)
    (("" (lemma leadsto_transitive)
      (("" (inst - p!1 pq!1 q!1 s!1)
        (("" (assert)
          (("" (hide -2 2)
            (("" (use subset_leadsto) (("" (assert) nil nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((leadsto_transitive formula-decl nil bdUnity nil)
    (subset_leadsto formula-decl nil bdUnity nil)
    (specification type-eq-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (t formal-type-decl nil bdUnity nil))
   shostak))
 (leadsto_sub 0
  (leadsto_sub-1 nil 3624292814
   ("" (skosimp)
    (("" (lemma leadsto_transitive)
      (("" (inst - p!1 pq!1 q!1 s!1)
        (("" (assert)
          (("" (hide -2 2)
            (("" (use subset_leadsto) (("" (assert) nil nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((leadsto_transitive formula-decl nil bdUnity nil)
    (subset_leadsto formula-decl nil bdUnity nil)
    (specification type-eq-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (t formal-type-decl nil bdUnity nil))
   shostak))
 (shunting_leadsto 0
  (shunting_leadsto-1 nil 3624292902
   ("" (skosimp)
    (("" (lemma sub_leadsto)
      ((""
        (inst - p!1 "cup(cap(p!1, neg(pq!1)), pq!1)" "cup(q!1, pq!1)"
         s!1)
        (("" (assert)
          (("" (hide 2)
            (("" (split)
              (("1" (hide -)
                (("1" (expand "<=")
                  (("1" (expand "cap")
                    (("1" (expand "cup")
                      (("1" (expand "neg")
                        (("1" (skosimp) (("1" (assert) nil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (use cup_leadsto)
                (("2" (assert)
                  (("2" (hide 2)
                    (("2" (split)
                      (("1" (lemma leadsto_sub)
                        (("1"
                          (inst - "cap(p!1, neg(pq!1))" q!1
                           "cup(q!1, pq!1)" s!1)
                          (("1" (assert)
                            (("1" (hide - 2)
                              (("1"
                                (expand "<=")
                                (("1"
                                  (expand "cap")
                                  (("1"
                                    (expand "cup")
                                    (("1" (skosimp) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (hide -)
                        (("2" (use subset_leadsto)
                          (("2" (assert)
                            (("2" (hide 2)
                              (("2"
                                (expand "<=")
                                (("2"
                                  (expand "cap")
                                  (("2"
                                    (expand "cup")
                                    (("2" (skosimp) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((sub_leadsto formula-decl nil bdUnity nil)
    (<= const-decl "bool" mucalculus nil)
    (leadsto_sub formula-decl nil bdUnity nil)
    (subset_leadsto formula-decl nil bdUnity nil)
    (cup_leadsto formula-decl nil bdUnity nil)
    (specification type-eq-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (neg const-decl "bool" ownpred nil)
    (cap const-decl "bool" ownpred nil)
    (cup const-decl "bool" ownpred nil)
    (pred type-eq-decl nil defined_types nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (t formal-type-decl nil bdUnity nil))
   shostak))
 (leadsto_inv 0
  (leadsto_inv-1 nil 3624293310
   ("" (skolem!)
    (("" (iff)
      (("" (lemma sub_leadsto)
        (("" (inst - _ _ q!1 s!1)
          (("" (prop)
            (("1" (inst - p!1 "cap(p!1, s!1`inv)")
              (("1" (assert)
                (("1" (hide 1 -)
                  (("1" (expand "<=") (("1" (skosimp) nil nil)) nil))
                  nil))
                nil))
              nil)
             ("2" (inst - "cap(p!1, s!1`inv)" p!1)
              (("2" (assert)
                (("2" (hide 1 -)
                  (("2" (expand "<=")
                    (("2" (expand "cap") (("2" (skosimp) nil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((t formal-type-decl nil bdUnity nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (specification type-eq-decl nil bdUnity nil)
    (cap const-decl "bool" ownpred nil)
    (<= const-decl "bool" mucalculus nil)
    (sub_leadsto formula-decl nil bdUnity nil))
   shostak))
 (bounding_leadsto 0
  (bounding_leadsto-1 nil 3624293638
   ("" (expand "leto")
    (("" (skosimp*)
      (("" (inst?)
        (("" (assert)
          (("" (inst?)
            (("" (assert)
              (("" (expand "cup")
                (("" (skosimp)
                  (("" (split)
                    (("1" (inst?) (("1" (assert) nil nil)) nil)
                     ("2" (expand "leadsto")
                      (("2" (lemma machine_closed)
                        (("2" (inst - i!1 s!1 xs!1)
                          (("2" (assert)
                            (("2" (skosimp)
                              (("2"
                                (inst? -4)
                                (("2"
                                  (assert)
                                  (("2"
                                    (split)
                                    (("1"
                                      (skolem!)
                                      (("1"
                                        (inst + i!2)
                                        (("1"
                                          (case "i!2 <= i!1")
                                          (("1"
                                            (inst - i!2)
                                            (("1" (assert) nil nil))
                                            nil)
                                           ("2"
                                            (inst - i!1)
                                            (("2"
                                              (assert)
                                              (("2"
                                                (replace -3 * rl)
                                                (("2"
                                                  (hide-all-but
                                                   (-1 -2 -4 -6 -7 1))
                                                  (("2"
                                                    (case
                                                     "forall i: pa!1(ys!1(i!1 + i))")
                                                    (("1"
                                                      (inst
                                                       -
                                                       "i!2-i!1")
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (expand
                                                           "empty?")
                                                          (("1"
                                                            (expand
                                                             "member")
                                                            (("1"
                                                              (expand
                                                               "cap")
                                                              (("1"
                                                                (inst?)
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (induct i)
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil)
                                                       ("2"
                                                        (skosimp)
                                                        (("2"
                                                          (expand
                                                           "stable")
                                                          (("2"
                                                            (expand
                                                             "co")
                                                            (("2"
                                                              (expand
                                                               "<="
                                                               -)
                                                              (("2"
                                                                (expand
                                                                 "wp")
                                                                (("2"
                                                                  (expand
                                                                   "cap")
                                                                  (("2"
                                                                    (expand
                                                                     "run")
                                                                    (("2"
                                                                      (flatten)
                                                                      (("2"
                                                                        (expand
                                                                         "exec")
                                                                        (("2"
                                                                          (inst?)
                                                                          (("2"
                                                                            (flatten)
                                                                            (("2"
                                                                              (assert)
                                                                              (("2"
                                                                                (inst?
                                                                                 -7)
                                                                                (("2"
                                                                                  (assert)
                                                                                  (("2"
                                                                                    (inst
                                                                                     -7
                                                                                     "ys!1(1 + i!1 + j!1)")
                                                                                    (("2"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (inst - 0)
                                      (("2" (assert) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((leadsto const-decl "bool" bdUnity nil)
    (specification type-eq-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (<= const-decl "bool" reals nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (stable const-decl "bool" bdUnity nil)
    (<= const-decl "bool" mucalculus nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (exec const-decl "bool" bdUnity nil)
    (run const-decl "bool" bdUnity nil)
    (wp const-decl "bool" ownpred nil)
    (co const-decl "bool" bdUnity nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (empty? const-decl "bool" sets nil)
    (cap const-decl "bool" ownpred nil)
    (member const-decl "bool" sets nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (machine_closed formula-decl nil bdUnity nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (cup const-decl "bool" ownpred nil)
    (t formal-type-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (leto const-decl "bool" bdUnity nil))
   shostak)))


$$$intsum.pvs
% Wim H. Hesselink, October 2013

intsum: THEORY
BEGIN
  n, i, j: VAR nat
  f, g: VAR [nat -> int]
  w: VAR int
  p: VAR pred[nat]

  trunc(n, p): finite_set[nat] =
    {i | i < n AND p(i)} ;

  +(f, g): [nat -> int] =
    LAMBDA n: f(n) + g(n);
 
  *(w, f): [nat -> int] =
    LAMBDA n: w * f(n)

  sum(n, f): RECURSIVE int =
    IF n = 0 THEN 0
    ELSE f(n-1) + sum(n-1, f) ENDIF
    MEASURE n

  sum_natural: LEMMA
    (FORALL i: 0 <= f(i))
    IMPLIES 0 <= sum(n, f)

  sum_leq: LEMMA
    (FORALL i: f(i) <= 1) IMPLIES sum(n, f) <= n

  sum_leq_card: LEMMA
    (FORALL i: f(i) <= 1 AND (f(i) = 1 IMPLIES p(i)))
    IMPLIES sum(n, f) <= card(trunc(n, p))

  delta(i, w)(n): int =
    IF n = i THEN w ELSE 0 ENDIF

  sum_delta: LEMMA
    sum(n, delta(i, w)) = IF i < n THEN w ELSE 0 ENDIF

  sum_homomorphic: LEMMA
    sum(n, f + g) = sum(n, f) + sum(n, g)

  sum_monotonic: LEMMA
    (FORALL i: i < n IMPLIES f(i) <= g(i))
    IMPLIES sum(n, f) <= sum(n, g)

  sum_equal: LEMMA
    (FORALL i: i < n IMPLIES f(i) = g(i))
    IMPLIES sum(n, f) = sum(n, g)

  sum_strict_monotonic: LEMMA
    (FORALL i: i < n IMPLIES f(i) <= g(i))
    AND (EXISTS i: i < n AND f(i) < g(i))
    IMPLIES sum(n, f) < sum(n, g)

  sum_monotonic_delta: LEMMA
    (FORALL i: i < n AND i /= j IMPLIES f(i) <= g(i))
    AND j < n AND f(j) + w <= g(j)
    IMPLIES sum(n, f) + w <= sum(n, g)

  sum_distributive: LEMMA
    sum(n, w * f) = w * sum(n, f) 

  char(p)(i): int =
    IF p(i) THEN 1 ELSE 0 ENDIF

  sum_char: LEMMA
    sum(n, char(p)) = card(trunc(n, p))

  const(w)(n): int = w

  sum_const: LEMMA
    sum(n, const(w)) = w * n 

END intsum

$$$intsum.prf
(intsum
 (trunc_TCC1 0
  (trunc_TCC1-1 nil 3590140721
   ("" (skolem!)
    (("" (expand "is_finite")
      (("" (inst + n!1 id) (("" (grind) nil nil)) nil)) nil))
    nil)
   ((is_finite const-decl "bool" finite_sets nil)
    (injective? const-decl "bool" functions nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (id const-decl "(bijective?[T, T])" identity nil)
    (bijective? const-decl "bool" functions nil)
    (below type-eq-decl nil nat_types nil)
    (pred type-eq-decl nil defined_types nil)
    (< const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   nil))
 (sum_TCC1 0
  (sum_TCC1-1 nil 3590140721 ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (>= const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (sum_TCC2 0
  (sum_TCC2-1 nil 3590140721 ("" (termination-tcc) nil nil) nil nil))
 (sum_natural 0
  (sum_natural-1 nil 3590140722
   ("" (induct n)
    (("1" (expand "sum") (("1" (propax) nil nil)) nil)
     ("2" (skosimp*)
      (("2" (expand sum +)
        (("2" (inst?)
          (("2" (split)
            (("1" (inst?) (("1" (assert) nil nil)) nil)
             ("2" (propax) nil nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (sum def-decl "int" intsum nil) (<= const-decl "bool" reals nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (sum_leq 0
  (sum_leq-1 nil 3590666253
   ("" (induct n)
    (("1" (expand "sum") (("1" (propax) nil nil)) nil)
     ("2" (skosimp*)
      (("2" (expand sum +)
        (("2" (inst?)
          (("2" (replace -2)
            (("2" (inst?) (("2" (assert) nil nil)) nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (sum def-decl "int" intsum nil) (<= const-decl "bool" reals nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (sum_leq_card 0
  (sum_leq_card-1 nil 3590140830
   ("" (induct n)
    (("1" (expand "sum")
      (("1" (skosimp*) (("1" (assert) nil nil)) nil)) nil)
     ("2" (skosimp*)
      (("2" (expand sum +)
        (("2" (inst?)
          (("2" (split)
            (("1" (inst?)
              (("1" (flatten)
                (("1" (case "f!1(j!1) = 1")
                  (("1" (replace -1)
                    (("1"
                      (case "trunc(1 + j!1, p!1) = add(j!1, trunc(j!1, p!1))")
                      (("1" (use card_add[nat])
                        (("1" (case "trunc(j!1, p!1)(j!1)")
                          (("1" (expand "trunc")
                            (("1" (propax) nil nil)) nil)
                           ("2" (assert) nil nil))
                          nil))
                        nil)
                       ("2" (hide -2 2)
                        (("2" (apply-extensionality :hide? t)
                          (("2" (expand "trunc")
                            (("2" (expand "add")
                              (("2"
                                (expand "member")
                                (("2"
                                  (iff)
                                  (("2" (ground) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2"
                    (case "subset?(trunc(j!1, p!1), trunc(1+j!1, p!1))")
                    (("1" (use card_subset[nat])
                      (("1" (assert) nil nil)) nil)
                     ("2" (hide-all-but 1)
                      (("2" (expand "subset?")
                        (("2" (expand "member")
                          (("2" (expand "trunc")
                            (("2" (skosimp) (("2" (assert) nil nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (propax) nil nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nonempty? const-decl "bool" sets nil)
    (add const-decl "(nonempty?)" sets nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (card_add formula-decl nil finite_sets nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (member const-decl "bool" sets nil)
    (card_subset formula-decl nil finite_sets nil)
    (subset_is_partial_order name-judgement "(partial_order?[set[T]])"
     sets_lemmas nil)
    (subset? const-decl "bool" sets nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (trunc const-decl "finite_set[nat]" intsum nil)
    (card const-decl "{n: nat | n = Card(S)}" finite_sets nil)
    (Card const-decl "nat" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (sum def-decl "int" intsum nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (sum_delta 0
  (sum_delta-1 nil 3590141449
   ("" (induct n)
    (("1" (expand "sum") (("1" (propax) nil nil)) nil)
     ("2" (skosimp*)
      (("2" (expand sum +)
        (("2" (inst?)
          (("2" (replace -1 :hide? t)
            (("2" (expand "delta") (("2" (smash) nil nil)) nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((int_plus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (delta const-decl "int" intsum nil) (sum def-decl "int" intsum nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (sum_homomorphic 0
  (sum_homomorphic-1 nil 3590141578
   ("" (induct n)
    (("1" (expand "sum") (("1" (propax) nil nil)) nil)
     ("2" (skosimp*)
      (("2" (expand sum +)
        (("2" (inst?)
          (("2" (expand "+ ") (("2" (propax) nil nil)) nil)) nil))
        nil))
      nil))
    nil)
   ((nat_induction formula-decl nil naturalnumbers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[nat -> int]" intsum nil)
    (sum def-decl "int" intsum nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (sum_monotonic 0
  (sum_monotonic-1 nil 3590141634
   ("" (induct n)
    (("1" (expand "sum") (("1" (propax) nil nil)) nil)
     ("2" (skosimp*)
      (("2" (expand sum +)
        (("2" (inst?)
          (("2" (inst - g!1)
            (("2" (split)
              (("1" (inst?) (("1" (assert) nil nil)) nil)
               ("2" (skosimp)
                (("2" (inst?) (("2" (assert) nil nil)) nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (sum def-decl "int" intsum nil) (<= const-decl "bool" reals nil)
    (< const-decl "bool" reals nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (sum_equal 0
  (sum_equal-1 nil 3590921272
   ("" (induct n)
    (("1" (expand "sum") (("1" (propax) nil nil)) nil)
     ("2" (skosimp*)
      (("2" (expand sum +)
        (("2" (inst?)
          (("2" (inst - g!1)
            (("2" (split)
              (("1" (inst - j!1) (("1" (assert) nil nil)) nil)
               ("2" (skosimp)
                (("2" (inst?) (("2" (assert) nil nil)) nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (sum def-decl "int" intsum nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (< const-decl "bool" reals nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (sum_strict_monotonic 0
  (sum_strict_monotonic-1 nil 3590141766
   ("" (induct n)
    (("1" (skosimp*) (("1" (assert) nil nil)) nil)
     ("2" (skosimp*)
      (("2" (inst?)
        (("2" (inst - g!1)
          (("2" (split)
            (("1" (expand sum +)
              (("1" (inst - j!1) (("1" (assert) nil nil)) nil)) nil)
             ("2" (skosimp)
              (("2" (inst?) (("2" (assert) nil nil)) nil)) nil)
             ("3" (case "i!1=j!1")
              (("1" (expand sum +)
                (("1" (replace -1 :hide? t)
                  (("1" (hide 1)
                    (("1" (use sum_monotonic (n j!1 f f!1 g g!1))
                      (("1" (split)
                        (("1" (assert) nil nil)
                         ("2" (skosimp)
                          (("2" (inst?) (("2" (assert) nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (inst? +) (("2" (assert) nil nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((= const-decl "[T, T -> boolean]" equalities nil)
    (sum_monotonic formula-decl nil intsum nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (sum def-decl "int" intsum nil) (<= const-decl "bool" reals nil)
    (< const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (sum_monotonic_delta 0
  (sum_monotonic_delta-1 nil 3590142172
   ("" (induct n)
    (("1" (skosimp*) (("1" (assert) nil nil)) nil)
     ("2" (skosimp*)
      (("2" (expand sum +)
        (("2" (case "j!2=j!1")
          (("1" (use sum_monotonic (n j!1 f f!1 g g!1))
            (("1" (split)
              (("1" (assert) nil nil)
               ("2" (hide -2)
                (("2" (skosimp)
                  (("2" (inst?) (("2" (assert) nil nil)) nil)) nil))
                nil))
              nil))
            nil)
           ("2" (inst?)
            (("2" (split)
              (("1" (inst - j!1) (("1" (assert) nil nil)) nil)
               ("2" (skosimp)
                (("2" (inst?) (("2" (assert) nil nil)) nil)) nil)
               ("3" (assert) nil nil) ("4" (propax) nil nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((= const-decl "[T, T -> boolean]" equalities nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (sum_monotonic formula-decl nil intsum nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (sum def-decl "int" intsum nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (<= const-decl "bool" reals nil)
    (/= const-decl "boolean" notequal nil)
    (< const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (int_plus_int_is_int application-judgement "int" integers nil))
   shostak))
 (sum_distributive 0
  (sum_distributive-1 nil 3590306666
   ("" (induct n)
    (("1" (expand "sum") (("1" (propax) nil nil)) nil)
     ("2" (skosimp*)
      (("2" (expand sum +)
        (("2" (inst?) (("2" (expand "*") (("2" (assert) nil nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((int_plus_int_is_int application-judgement "int" integers nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (* const-decl "[nat -> int]" intsum nil)
    (sum def-decl "int" intsum nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (sum_char 0
  (sum_char-1 nil 3590919921
   ("" (induct n)
    (("1" (expand "sum")
      (("1" (skosimp)
        (("1" (use empty_card[nat])
          (("1" (assert) (("1" (hide 2) (("1" (grind) nil nil)) nil))
            nil))
          nil))
        nil))
      nil)
     ("2" (skosimp*)
      (("2" (expand sum +)
        (("2" (inst?)
          (("2" (replace -1 :hide? t)
            (("2" (expand "char")
              (("2" (lift-if)
                (("2" (assert)
                  (("2" (prop)
                    (("1"
                      (case "trunc(1 + j!1, p!1)= add(j!1, trunc(j!1, p!1))")
                      (("1" (use card_add[nat])
                        (("1" (replace -2 :hide? t)
                          (("1" (replace -1 :hide? t)
                            (("1" (expand "trunc")
                              (("1" (propax) nil nil)) nil))
                            nil))
                          nil))
                        nil)
                       ("2" (hide 2)
                        (("2" (apply-extensionality :hide? t)
                          (("2" (grind) nil nil)) nil))
                        nil))
                      nil)
                     ("2" (case "trunc(1 + j!1, p!1)=trunc(j!1, p!1)")
                      (("1" (assert) nil nil)
                       ("2" (hide 3)
                        (("2" (apply-extensionality :hide? t)
                          (("2" (grind) nil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nonempty? const-decl "bool" sets nil)
    (add const-decl "(nonempty?)" sets nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (card_add formula-decl nil finite_sets nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (empty_card formula-decl nil finite_sets nil)
    (empty? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (trunc const-decl "finite_set[nat]" intsum nil)
    (card const-decl "{n: nat | n = Card(S)}" finite_sets nil)
    (Card const-decl "nat" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (char const-decl "int" intsum nil)
    (sum def-decl "int" intsum nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (sum_const 0
  (sum_const-1 nil 3628935444
   ("" (induct n)
    (("1" (skolem!) (("1" (expand "sum") (("1" (propax) nil nil)) nil))
      nil)
     ("2" (skosimp*)
      (("2" (expand sum +)
        (("2" (inst?)
          (("2" (assert)
            (("2" (expand "const") (("2" (assert) nil nil)) nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (const const-decl "int" intsum nil) (sum def-decl "int" intsum nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak)))


$$$maxfinset.pvs
maxfinset [ t: TYPE ]: THEORY

BEGIN
  E: VAR finite_set[t]
  f: VAR [t -> nat]
  n: VAR nat
  x: VAR t 

  maximum(f, E): RECURSIVE nat =
    IF empty?(E) THEN 0
    ELSE LET xx = epsilon(E) IN 
      max(f(xx), maximum(f, remove(xx, E))) 
    ENDIF
    MEASURE card(E)

  maximum_prop: LEMMA
    maximum(f, E) <= n IFF FORALL x: E(x) IMPLIES f(x) <= n 

  maximum_prop1: LEMMA
    E(x) IMPLIES f(x) <= maximum(f, E)

  arg_max: LEMMA
    nonempty?(E) IMPLIES EXISTS x: E(x) AND maximum(f, E) = f(x)

END maxfinset

$$$maxfinset.prf
(maxfinset
 (maximum_TCC1 0
  (maximum_TCC1-1 nil 3589618503
   ("" (skosimp*)
    (("" (use epsilon_ax[t])
      (("1" (use card_remove[t])
        (("1" (split)
          (("1" (assert) nil nil)
           ("2" (hide - 3)
            (("2" (expand "empty?")
              (("2" (expand "member")
                (("2" (skosimp) (("2" (inst?) nil nil)) nil)) nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (hide - 3) (("2" (grind) nil nil)) nil))
      nil))
    nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (TRUE const-decl "bool" booleans nil)
    (epsilon_ax formula-decl nil epsilons nil)
    (t formal-type-decl nil maxfinset nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (pred type-eq-decl nil defined_types nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (empty? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil)
    (card_remove formula-decl nil finite_sets nil))
   nil))
 (maximum_TCC2 0
  (maximum_TCC2-1 nil 3589618503 ("" (existence-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (t formal-type-decl nil maxfinset nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (injective? const-decl "bool" functions nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil))
   nil))
 (maximum_prop 0
  (maximum_prop-2 nil 3589619068
   ("" (skolem!)
    ((""
      (case "forall E, n: card(E) <= n IMPLIES (
        maximum(f!1, E) <= n!1 IFF (FORALL x: E(x) IMPLIES f!1(x) <= n!1))")
      (("1" (inst - E!1 "card(E!1)+ 1") (("1" (assert) nil nil)) nil)
       ("2" (hide 2)
        (("2" (induct n)
          (("1" (skosimp)
            (("1" (assert)
              (("1" (use empty_card[t])
                (("1" (assert)
                  (("1" (expand "maximum")
                    (("1" (skosimp)
                      (("1" (expand "empty?")
                        (("1" (expand "member") (("1" (inst?) nil nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (skosimp*)
            (("2" (case "card(E!2) <= j!1")
              (("1" (inst?) (("1" (assert) nil nil)) nil)
               ("2" (use empty_card[t])
                (("2" (assert)
                  (("2" (expand "empty?")
                    (("2" (expand maximum +)
                      (("2" (name-replace ep "epsilon(E!2)" nil)
                        (("1" (use epsilon_ax[t])
                          (("1" (split)
                            (("1" (inst - "remove(ep, E!2)")
                              (("1"
                                (use card_remove[t])
                                (("1"
                                  (assert)
                                  (("1"
                                    (name-replace
                                     mxr
                                     "maximum(f!1, remove(ep, E!2))"
                                     nil)
                                    (("1"
                                      (expand remove -5)
                                      (("1"
                                        (expand "member")
                                        (("1"
                                          (expand "max")
                                          (("1"
                                            (split)
                                            (("1"
                                              (flatten)
                                              (("1"
                                                (lift-if)
                                                (("1"
                                                  (skosimp)
                                                  (("1"
                                                    (case
                                                     "f!1(ep) <= n!1 AND mxr <= n!1")
                                                    (("1"
                                                      (flatten)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (inst -9 x!1)
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (hide-all-but
                                                       (-1 1))
                                                      (("2"
                                                        (grind)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (flatten)
                                              (("2"
                                                (split -7)
                                                (("1"
                                                  (lift-if)
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (inst - ep)
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (skosimp)
                                                  (("2"
                                                    (inst?)
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (expand "member")
                              (("2"
                                (hide-all-but (1 2))
                                (("2"
                                  (skosimp)
                                  (("2" (inst?) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (expand "member")
                            (("2" (hide-all-but (1 2))
                              (("2"
                                (skosimp)
                                (("2" (inst?) nil nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (hide-all-but (1 2))
                          (("2" (skosimp)
                            (("2" (expand "member")
                              (("2" (inst?) nil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((maximum def-decl "nat" maxfinset nil)
    (IFF const-decl "[bool, bool -> bool]" booleans nil)
    (card const-decl "{n: nat | n = Card(S)}" finite_sets nil)
    (Card const-decl "nat" finite_sets nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (<= const-decl "bool" reals nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (t formal-type-decl nil maxfinset nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (pred type-eq-decl nil defined_types nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil)
    (empty_card formula-decl nil finite_sets nil)
    (epsilon_ax formula-decl nil epsilons nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (remove const-decl "set" sets nil)
    (nonneg_rat_max application-judgement
     "{s: nonneg_rat | s >= q AND s >= r}" real_defs nil)
    (nat_max application-judgement "{k: nat | i <= k AND j <= k}"
     real_defs nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (card_remove formula-decl nil finite_sets nil)
    (epsilon const-decl "T" epsilons nil)
    (TRUE const-decl "bool" booleans nil))
   nil)
  (maximum_prop-1 nil 3589618704
   ("" (skolem!)
    ((""
      (case "forall E, n: card(E) < n IMPLIES (
maximum(f!1, E) <= n!1 IFF (FORALL x: E(x) IMPLIES f!1(x) <= n!1))")
      (("1" (inst - E!1 "card(E!1)+ 1") (("1" (assert) nil nil)) nil)
       ("2" (hide 2)
        (("2" (induct n)
          (("1" (skosimp) (("1" (assert) nil nil)) nil)
           ("2" (skosimp*) (("2" (postpone) nil nil)) nil))
          nil))
        nil))
      nil))
    nil)
   nil shostak))
 (maximum_prop1 0
  (maximum_prop1-1 nil 3589622403
   ("" (skosimp)
    (("" (use maximum_prop (n "maximum(f!1, E!1)"))
      (("" (assert) (("" (inst?) (("" (assert) nil nil)) nil)) nil))
      nil))
    nil)
   ((maximum_prop formula-decl nil maxfinset nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (t formal-type-decl nil maxfinset nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (maximum def-decl "nat" maxfinset nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   shostak))
 (arg_max 0
  (arg_max-1 nil 3589621787
   ("" (skosimp)
    (("" (expand "nonempty?")
      (("" (expand "empty?")
        (("" (skosimp)
          (("" (expand "member")
            (("" (inst-cp + x!1)
              (("" (assert)
                (("" (lemma maximum_prop)
                  (("" (inst - E!1 f!1 _)
                    (("" (inst-cp - "maximum(f!1, E!1)")
                      (("" (assert)
                        (("" (inst-cp -2 x!1)
                          (("" (assert)
                            (("" (inst - "maximum(f!1, E!1)-1")
                              ((""
                                (assert)
                                ((""
                                  (skosimp)
                                  ((""
                                    (inst - x!2)
                                    ((""
                                      (inst + x!2)
                                      (("" (assert) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nonempty? const-decl "bool" sets nil)
    (t formal-type-decl nil maxfinset nil)
    (maximum_prop formula-decl nil maxfinset nil)
    (maximum def-decl "nat" maxfinset nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil))
   shostak)))


$$$ctrees.pvs
% Wim H. Hesselink, August 2016
% Proofs for: Tournaments for mutual exclusion: 
% verification and concurrent complexity
% Part 1. Specification of the tree

ctrees  [ degree: posnat, node: type+ ]: THEORY

BEGIN
  IMPORTING maxfinset[node]

  digit: TYPE = below[degree]

  node_finite: AXIOM
    is_finite(fullset[node])

  root: node

% We first give the tree in terms of the functions parent and sibnr.
% In this tree, we define depth, ancestors, and the root path. 

  parent: [node -> node]
  sibnr: [node -> digit]

  n, n1: VAR node
  i, k: VAR nat
  z: VAR int

  anc(n, k): RECURSIVE node =
    IF k = 0 THEN n ELSE parent(anc(n, k-1)) ENDIF 
    MEASURE k

  tree_axiom: AXIOM
    parent(root) = root
    AND nonempty?({ k | anc(n, k) = root })

  anc_root: LEMMA
    anc(root, k) = root

  anc_additive: LEMMA
    anc(anc(n, i), k) = anc(n, i+k)

  c_depth(n): nat =
    min({k | anc(n, k) = root })

  c_depth_root: LEMMA
    c_depth(root) = 0 

  anc_beyond_c_depth: LEMMA 
    c_depth(n) <= k IMPLIES anc(n, k) = root 

  c_depth_anc: LEMMA
    c_depth(anc(n, k)) = 
      IF k < c_depth(n) THEN c_depth(n) - k ELSE 0 ENDIF 

  c_depth_parent: LEMMA 
    c_depth(parent(n)) = IF n = root THEN 0 ELSE c_depth(n) - 1 ENDIF

  c_path(n, z): node =
    IF 0 <= z AND z <= c_depth(n) THEN anc(n, c_depth(n) - z) ELSE n ENDIF 

  c_depth_c_path: LEMMA
    c_depth(c_path(n, k)) = 
      IF k <= c_depth(n) THEN k ELSE c_depth(n) ENDIF 

  equal_c_paths: LEMMA
    c_path(n, i) = c_path(n1, k) AND i <= c_depth(n) AND k <= c_depth(n1) 
    IMPLIES i = k 

  nr_tree_axiom: AXIOM
    FORALL n, n1: parent(n) = parent(n1) AND sibnr(n) = sibnr(n1) 
       IMPLIES n = n1 OR n = root OR n1 = root

  c_sib(n, z): digit = 
    sibnr(c_path(n, z+1))

  joining_c_paths: LEMMA
    k < c_depth(n) AND k < c_depth(n1) 
    AND c_path(n, k) = c_path(n1, k) 
    AND c_sib(n, k) = c_sib(n1, k) 
    IMPLIES c_path(n, k+1) = c_path(n1, k+1)

% We now introduce depth, path, sib, and depthnode axiomatically. 
% The axioms have been proved for the setting above. 

  depth(n): nat   
  path(n, z): node 
  sib(n, z): digit 

  depth_path: AXIOM
    depth(path(n, k)) = 
      IF k <= depth(n) THEN k ELSE depth(n) ENDIF 

  path_zero: AXIOM
    path(n, 0) = root 

  path_depth: AXIOM 
    path(n, depth(n)) = n 

  equal_paths: LEMMA
    path(n, i) = path(n1, k) AND i <= depth(n) AND k <= depth(n1) 
    IMPLIES i = k 

  joining_paths: AXIOM
    k < depth(n) AND k < depth(n1) 
    AND path(n, k) = path(n1, k) 
    AND sib(n, k) = sib(n1, k) 
    IMPLIES path(n, k+1) = path(n1, k+1)

  depthnode: nat =
    maximum(depth, fullset[node])

  upb_depth: LEMMA
    depth(n) <= depthnode
  
  leaf: finite_set[node] =
    { n | FORALL k, n1: path(n1, k) = n AND k <= depth(n1)
          IMPLIES n1 = n }

  depth_maximal_leaf: LEMMA % 
    depth(n) = depthnode IMPLIES leaf(n) 

  exists_leaf: LEMMA
    EXISTS n: leaf(n) AND depth(n) = depthnode

  intNode(n): bool =
    NOT leaf(n)

END ctrees

$$$ctrees.prf
(ctrees
 (sibnr_TCC1 0
  (sibnr_TCC1-1 nil 3678527008
   ("" (inst + "lambda (n:node) : 0") (("" (assert) nil nil)) nil)
   ((digit type-eq-decl nil ctrees nil)
    (degree formal-const-decl "posnat" ctrees nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (node formal-nonempty-type-decl nil ctrees nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   nil))
 (anc_TCC1 0
  (anc_TCC1-1 nil 3678527008 ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (>= const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (anc_TCC2 0
  (anc_TCC2-1 nil 3678527008 ("" (termination-tcc) nil nil) nil nil))
 (anc_root 0
  (anc_root-1 nil 3678528666
   ("" (induct k)
    (("1" (expand "anc") (("1" (propax) nil nil)) nil)
     ("2" (skosimp)
      (("2" (expand anc +)
        (("2" (assert)
          (("2" (use tree_axiom) (("2" (assert) nil nil)) nil)) nil))
        nil))
      nil))
    nil)
   ((tree_axiom formula-decl nil ctrees nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (root const-decl "node" ctrees nil)
    (anc def-decl "node" ctrees nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (node formal-nonempty-type-decl nil ctrees nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (anc_additive 0
  (anc_additive-1 nil 3678527522
   ("" (induct k)
    (("1" (skolem!)
      (("1" (name-replace ank "anc(n!1, i!1)")
        (("1" (expand "anc") (("1" (propax) nil nil)) nil)) nil))
      nil)
     ("2" (skosimp*)
      (("2" (inst?)
        (("2" (name-replace ank "anc(n!1, i!1)")
          (("2" (expand anc +) (("2" (assert) nil nil)) nil)) nil))
        nil))
      nil))
    nil)
   ((nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (anc def-decl "node" ctrees nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (node formal-nonempty-type-decl nil ctrees nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil))
   shostak))
 (c_depth_TCC1 0
  (c_depth_TCC1-1 nil 3678527008
   ("" (skolem!) (("" (use tree_axiom) (("" (assert) nil nil)) nil))
    nil)
   ((tree_axiom formula-decl nil ctrees nil)
    (node formal-nonempty-type-decl nil ctrees nil))
   nil))
 (c_depth_root 0
  (c_depth_root-1 nil 3678533385
   ("" (expand "c_depth")
    (("" (name-replace mn "min({k | anc(root, k) = root})")
      (("1" (typepred mn)
        (("1" (inst - 0)
          (("1" (assert)
            (("1" (expand "anc") (("1" (propax) nil nil)) nil)) nil))
          nil))
        nil)
       ("2" (use tree_axiom) (("2" (assert) nil nil)) nil))
      nil))
    nil)
   ((number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (set type-eq-decl nil sets nil)
    (nonempty? const-decl "bool" sets nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (min const-decl "{a | S(a) AND (FORALL x: S(x) IMPLIES a <= x)}"
         min_nat nil)
    (node formal-nonempty-type-decl nil ctrees nil)
    (anc def-decl "node" ctrees nil)
    (root const-decl "node" ctrees nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (tree_axiom formula-decl nil ctrees nil)
    (c_depth const-decl "nat" ctrees nil))
   shostak))
 (anc_beyond_c_depth 0
  (anc_beyond_c_depth-1 nil 3678528717
   ("" (skosimp)
    (("" (expand "c_depth")
      (("" (name-replace mn "min({k | anc(n!1, k) = root})")
        (("1" (typepred mn)
          (("1" (hide -2)
            (("1" (lemma anc_additive)
              (("1" (inst - mn "k!1-mn" n!1)
                (("1" (replaceh -2)
                  (("1" (assert)
                    (("1" (lemma anc_root)
                      (("1" (inst - "k!1-mn") (("1" (assert) nil nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (assert) nil nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (use tree_axiom) (("2" (assert) nil nil)) nil))
        nil))
      nil))
    nil)
   ((c_depth const-decl "nat" ctrees nil)
    (tree_axiom formula-decl nil ctrees nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (anc_additive formula-decl nil ctrees nil)
    (anc_root formula-decl nil ctrees nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (mn skolem-const-decl "{a |
         anc(n!1, a) = root AND
          (FORALL (x: nat): anc(n!1, x) = root IMPLIES a <= x)}" ctrees
     nil)
    (n!1 skolem-const-decl "node" ctrees nil)
    (k!1 skolem-const-decl "nat" ctrees nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (root const-decl "node" ctrees nil)
    (anc def-decl "node" ctrees nil)
    (node formal-nonempty-type-decl nil ctrees nil)
    (min const-decl "{a | S(a) AND (FORALL x: S(x) IMPLIES a <= x)}"
         min_nat nil)
    (<= const-decl "bool" reals nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (nonempty? const-decl "bool" sets nil)
    (set type-eq-decl nil sets nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (c_depth_anc 0
  (c_depth_anc-1 nil 3678527070
   ("" (skolem!)
    (("" (lift-if)
      (("" (split)
        (("1" (flatten)
          (("1" (name-replace ank "anc(n!1, k!1)" nil)
            (("1" (expand "c_depth")
              (("1" (name-replace mn "min({k | anc(n!1, k) = root})")
                (("1"
                  (name-replace mnank "min({k | anc(ank, k) = root})")
                  (("1" (typepred mn)
                    (("1" (typepred mnank)
                      (("1" (lemma anc_additive)
                        (("1" (inst - k!1 mnank n!1)
                          (("1" (replace -6)
                            (("1" (replace -2)
                              (("1"
                                (inst -5 "k!1+ mnank")
                                (("1"
                                  (assert)
                                  (("1"
                                    (inst - "mn - k!1")
                                    (("1"
                                      (assert)
                                      (("1"
                                        (lemma anc_additive)
                                        (("1"
                                          (inst - k!1 "mn-k!1" n!1)
                                          (("1" (assert) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (use tree_axiom) (("2" (flatten) nil nil))
                    nil))
                  nil)
                 ("2" (use tree_axiom) (("2" (assert) nil nil)) nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (flatten)
          (("2" (use anc_beyond_c_depth)
            (("2" (assert)
              (("2" (replaceh -1) (("2" (use c_depth_root) nil nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((c_depth_root formula-decl nil ctrees nil)
    (anc_beyond_c_depth formula-decl nil ctrees nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (c_depth const-decl "nat" ctrees nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (anc_additive formula-decl nil ctrees nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (tree_axiom formula-decl nil ctrees nil)
    (root const-decl "node" ctrees nil)
    (min const-decl "{a | S(a) AND (FORALL x: S(x) IMPLIES a <= x)}"
         min_nat nil)
    (<= const-decl "bool" reals nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (nonempty? const-decl "bool" sets nil)
    (set type-eq-decl nil sets nil) (anc def-decl "node" ctrees nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil ctrees nil))
   shostak))
 (c_depth_parent 0
  (c_depth_parent-2 nil 3678593957
   ("" (skosimp)
    (("" (lift-if)
      (("" (split)
        (("1" (flatten)
          (("1" (use c_depth_root)
            (("1" (use tree_axiom)
              (("1" (flatten) (("1" (assert) nil nil)) nil)) nil))
            nil))
          nil)
         ("2" (flatten)
          (("2" (use c_depth_anc (n n!1 k 1))
            (("2" (expand anc -)
              (("2" (expand anc -)
                (("2" (lift-if)
                  (("2" (assert)
                    (("2" (ground)
                      (("2" (replaceh -1)
                        (("2" (use anc_beyond_c_depth (n n!1 k 0))
                          (("2" (assert)
                            (("2" (expand "anc")
                              (("2" (propax) nil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((anc def-decl "node" ctrees nil)
    (anc_beyond_c_depth formula-decl nil ctrees nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (c_depth_anc formula-decl nil ctrees nil)
    (tree_axiom formula-decl nil ctrees nil)
    (root const-decl "node" ctrees nil)
    (node formal-nonempty-type-decl nil ctrees nil)
    (c_depth_root formula-decl nil ctrees nil))
   nil)
  (c_depth_parent-1 nil 3678550629
   ("" (skosimp)
    (("" (lift-if)
      (("" (split)
        (("1" (flatten)
          (("1" (use c_depth_root)
            (("1" (use tree_axiom)
              (("1" (flatten) (("1" (assert) nil nil)) nil)) nil))
            nil))
          nil)
         ("2" (flatten)
          (("2"
            (case "forall k: c_depth(n!1) = k IMPLIES c_depth(parent(n!1)) = k-1")
            (("1" (inst - "c_depth(n!1)") nil nil)
             ("2" (hide 3)
              (("2" (induct k)
                (("1" (flatten)
                  (("1" (expand "c_depth")
                    (("1" (hide 1)
                      (("1"
                        (name-replace mn
                         "min({k | anc(n!1, k) = root})")
                        (("1" (typepred mn)
                          (("1" (expand "anc") (("1" (assert) nil nil))
                            nil))
                          nil)
                         ("2" (use tree_axiom) (("2" (assert) nil nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (skosimp) (("2" (postpone) nil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   nil shostak))
 (c_path_TCC1 0
  (c_path_TCC1-1 nil 3678527008 ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (c_depth const-decl "nat" ctrees nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil))
   nil))
 (c_depth_c_path 0
  (c_depth_c_path-1 nil 3678533615
   ("" (skosimp)
    (("" (expand "c_path")
      (("" (lift-if)
        (("" (split)
          (("1" (flatten)
            (("1" (lemma c_depth_anc)
              (("1" (inst - "c_depth(n!1) - k!1" n!1)
                (("1" (assert)
                  (("1" (lift-if) (("1" (assert) nil nil)) nil)) nil)
                 ("2" (assert) nil nil))
                nil))
              nil))
            nil)
           ("2" (propax) nil nil))
          nil))
        nil))
      nil))
    nil)
   ((minus_odd_is_odd application-judgement "odd_int" integers nil)
    (c_path const-decl "node" ctrees nil)
    (c_depth_anc formula-decl nil ctrees nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (node formal-nonempty-type-decl nil ctrees nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (c_depth const-decl "nat" ctrees nil)
    (n!1 skolem-const-decl "node" ctrees nil)
    (k!1 skolem-const-decl "nat" ctrees nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   shostak))
 (equal_c_paths 0
  (equal_c_paths-1 nil 3678600377
   ("" (skosimp)
    (("" (lemma c_depth_c_path)
      (("" (inst-cp - i!1 n!1)
        (("" (inst - k!1 n1!1) (("" (assert) nil nil)) nil)) nil))
      nil))
    nil)
   ((c_depth_c_path formula-decl nil ctrees nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (node formal-nonempty-type-decl nil ctrees nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (joining_c_paths 0
  (joining_c_paths-1 nil 3678535471
   ("" (skosimp)
    (("" (expand "c_sib")
      (("" (name-replace nn0 "c_path(n!1, k!1 + 1)" nil)
        (("" (name-replace nn1 "c_path(n1!1, k!1 + 1)" nil)
          (("" (lemma nr_tree_axiom)
            (("" (inst - nn0 nn1)
              (("" (assert)
                (("" (expand "c_path")
                  (("" (expand anc -6)
                    (("" (assert)
                      (("" (hide -6 -7 1)
                        (("" (lemma c_depth_anc)
                          (("" (use c_depth_root)
                            (("" (split)
                              (("1"
                                (hide -4)
                                (("1"
                                  (inst?)
                                  (("1" (assert) nil nil))
                                  nil))
                                nil)
                               ("2"
                                (hide -5)
                                (("2"
                                  (inst?)
                                  (("2" (assert) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((c_sib const-decl "digit" ctrees nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (c_depth_anc formula-decl nil ctrees nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (c_depth const-decl "nat" ctrees nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (c_depth_root formula-decl nil ctrees nil)
    (anc def-decl "node" ctrees nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nr_tree_axiom formula-decl nil ctrees nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (c_path const-decl "node" ctrees nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil ctrees nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil))
   shostak))
 (equal_paths 0
  (equal_paths-1 nil 3678949994
   ("" (skosimp)
    (("" (lemma depth_path)
      (("" (inst-cp - i!1 n!1)
        (("" (assert)
          (("" (inst - k!1 n1!1) (("" (assert) nil nil)) nil)) nil))
        nil))
      nil))
    nil)
   ((depth_path formula-decl nil ctrees nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (node formal-nonempty-type-decl nil ctrees nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (depthnode_TCC1 0
  (depthnode_TCC1-1 nil 3679380015 ("" (use node_finite) nil nil)
   ((node_finite formula-decl nil ctrees nil)) nil))
 (upb_depth 0
  (upb_depth-1 nil 3679380018
   ("" (skosimp)
    (("" (expand "depthnode")
      (("" (use maximum_prop1)
        (("" (assert)
          (("" (expand "fullset") (("" (propax) nil nil)) nil)) nil))
        nil))
      nil))
    nil)
   ((depthnode const-decl "nat" ctrees nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (fullset const-decl "set" sets nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (depth const-decl "nat" ctrees nil)
    (node formal-nonempty-type-decl nil ctrees nil)
    (maximum_prop1 formula-decl nil maxfinset nil))
   shostak))
 (leaf_TCC1 0
  (leaf_TCC1-1 nil 3678544530
   ("" (lemma finite_subset[node])
    (("" (inst - fullset _)
      (("1" (inst?)
        (("1" (assert) (("1" (hide 2) (("1" (grind) nil nil)) nil))
          nil))
        nil)
       ("2" (use node_finite) nil nil))
      nil))
    nil)
   ((fullset const-decl "set" sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (subset_is_partial_order name-judgement "(partial_order?[set[T]])"
     sets_lemmas nil)
    (member const-decl "bool" sets nil)
    (subset? const-decl "bool" sets nil)
    (depth const-decl "nat" ctrees nil)
    (<= const-decl "bool" reals nil)
    (path const-decl "node" ctrees nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (node_finite formula-decl nil ctrees nil)
    (finite_subset formula-decl nil finite_sets nil)
    (node formal-nonempty-type-decl nil ctrees nil))
   nil))
 (depth_maximal_leaf 0
  (depth_maximal_leaf-1 nil 3679380092
   ("" (expand "leaf")
    (("" (skosimp*)
      (("" (use upb_depth (n n1!1))
        (("" (use depth_path)
          (("" (lift-if)
            (("" (replace -4)
              (("" (replace -3)
                (("" (case "k!1 = depth(n1!1)")
                  (("1" (use path_depth) (("1" (assert) nil nil)) nil)
                   ("2" (assert) nil nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((depth_path formula-decl nil ctrees nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (depth const-decl "nat" ctrees nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (path_depth formula-decl nil ctrees nil)
    (node formal-nonempty-type-decl nil ctrees nil)
    (upb_depth formula-decl nil ctrees nil)
    (leaf const-decl "finite_set[node]" ctrees nil))
   shostak))
 (exists_leaf 0
  (exists_leaf-1 nil 3679381072
   ("" (name-replace hn depthnode nil)
    (("" (copy -1)
      (("" (expand depthnode -1)
        (("" (use arg_max[node])
          (("" (split)
            (("1" (skosimp)
              (("1" (replaceh -3)
                (("1" (inst?)
                  (("1" (assert)
                    (("1" (use depth_maximal_leaf)
                      (("1" (assert) nil nil)) nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (hide - 2)
              (("2" (expand "nonempty?")
                (("2" (expand "empty?")
                  (("2" (inst - root)
                    (("2" (expand "member")
                      (("2" (expand "fullset") (("2" (propax) nil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((node formal-nonempty-type-decl nil ctrees nil)
    (arg_max formula-decl nil maxfinset nil)
    (depth const-decl "nat" ctrees nil)
    (fullset const-decl "set" sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (empty? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil)
    (root const-decl "node" ctrees nil)
    (nonempty? const-decl "bool" sets nil)
    (depth_maximal_leaf formula-decl nil ctrees nil)
    (depthnode const-decl "nat" ctrees nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak)))


$$$tournamentSafe0.pvs
% Wim H. Hesselink, May-August 2016
% Proofs for: Tournaments for mutual exclusion: 
% verification and concurrent complexity
% Part 2. The transition system for the case that MXd satisfies FCFS
% Mutual exclusion and the invariants Iq* and Kq*

tournamentSafe0[degree: posnat, node: TYPE+]: THEORY
BEGIN
   IMPORTING ctrees[degree, node]

   thread: finite_set[node] =
     leaf

   N: posnat = % 
     card(thread)

   K: posnat % upper bound of number of competing threads

   count_thread: (bijective?[(thread), below[N]]) % 

   edigit: TYPE = ({z: int | -1 <= z AND z < degree})

   enum_thread: (bijective?[below[N], (thread)]) =
     inverse(count_thread)    % 

   state: TYPE = [#
     mu: [node -> edigit],
     occ: [node -> (thread)], % ghost variable: the occupying thread
     bock: [node, digit -> (thread)], % ghost variable for lq2
     competing: finite_set[node], % ghost
     cur: [node -> finite_set[digit]],     
     prio: [node, digit -> finite_set[digit]],     
     % private
     pc: [(thread) -> nat],
     level: [(thread) -> int], 
     cnt: [(thread) -> nat]  % ghost variable for progress
   #]

  x, y: VAR state
  p, q, r: VAR (thread)
  j, k, kk: VAR nat
  dig: VAR digit 
  n: VAR node

  thread_depth: LEMMA % 
    depth(q) <= depthnode

% 11   NCS ; // level = p`length - 1 ; 
% 12   while level >= 0 do 
% 13     prio(curnode(p), curbranch(p)) := cur(curnode(p)) ;
% 14     add sib(p, level) to cur(path(p, level)) ; 
%        bock(curnode(p), curbranch(p)) := p ;
% 15     await (empty?(prio(take(level, p), p(level)))
%               and mu(take(level, p)) = -1
%               or mu(take(level, p)) = p(level) ;
%        mu(take(level, p)) := p(level) ; level -- ;
%        remove curbranch(p) from cur(curnode(p));
%        for all j do remove curbranch(p) from prio(curnode(p), j) ;
%        occ(curnode(p)) := p ;
%      endwhile ;
% 16   CS ;
% 17   while level < p`length - 1 do
% 18     level ++ ; 
%        mu(curnode(p)) := -1
%      endwhile ; 
% 19   { cnt ++ } goto 11 .

% Thread q has reached the nodes take(k, q) with 
%    level.q <= k <= q`length
% It occupies the nodes take(k, q) with 
%    level.q < k <= q`length

goto(p, k, x): state =
  x WITH [ `pc(p) := k ]

next11(p, x): state =
  x WITH [
    `competing := add(p, x`competing),
    `pc(p) := 12 
  ]

step11(p, x, y): bool =
  y = next11(p, x) AND x`pc(p) = 11 AND card(x`competing) /= K

step12(p, x, y): bool =
  y = goto(p, IF x`level(p) < 0 THEN 16 ELSE 13 ENDIF, x) 
  AND x`pc(p) = 12

curnode(p, x): node =
  path(p, x`level(p))

curbranch(p, x): digit = 
  sib(p, x`level(p))

next13(p, x): state =
  x WITH [
    `prio(curnode(p, x), curbranch(p, x)) := x`cur(curnode(p, x)),
    `pc(p) := 14
  ]

step13(p, x, y): bool =
  y = next13(p, x) AND x`pc(p) = 13

next14(p, x): state =
  x WITH [
    `cur(curnode(p, x)) := add(curbranch(p, x), x`cur(curnode(p, x))), 
    `bock(curnode(p, x), curbranch(p, x)) := p, 
    `pc(p) := 15
  ]

step14(p, x, y): bool =
  y = next14(p, x) AND x`pc(p) = 14

next15(p, x): state = % 
  x WITH [
    `mu(curnode(p, x)) := curbranch(p, x), 
    `occ(curnode(p, x)) := p, 
    `cur(curnode(p, x)) := remove(curbranch(p, x), x`cur(curnode(p, x))), 
    `prio := (LAMBDA n, dig: IF n = curnode(p, x) THEN 
                remove(curbranch(p, x), x`prio(n, dig))
              ELSE x`prio(n, dig) ENDIF ), 
    `level(p) := x`level(p) - 1,
    `pc(p) := 12 
  ] 

step15F(p, x, y): bool =
  y = next15(p, x) AND x`pc(p) = 15 
  AND x`mu(curnode(p, x)) < 0 
  AND empty?(x`prio(curnode(p, x), curbranch(p, x)))
  
step15G(p, x, y): bool =
  y = next15(p, x) AND x`pc(p) = 15 
  AND x`level(p) >= 0 
  AND x`mu(curnode(p, x)) = curbranch(p, x)

step16(p, x, y): bool = % CS
  y = goto(p, 17, x) AND x`pc(p) = 16 

step17(p, x, y): bool =
  y = goto(p, IF x`level(p) < depth(p) - 1 THEN 18 ELSE 19 ENDIF, x) 
  AND x`pc(p) = 17

next18(p, x): state = % 
  x WITH [
    `mu(path(p, x`level(p) + 1)) := -1,
    `level(p) := x`level(p) + 1, 
    `pc(p) := 17
  ] 

step18(p, x, y): bool =
  y = next18(p, x) AND x`pc(p) = 18

next19(p, x): state =
  x WITH [
    `cnt(p) := x`cnt(p) + 1, 
    `competing := remove(p, x`competing),
    `pc(p) := 11
  ]

step19(p, x, y): bool =
  y = next19(p, x) AND x`pc(p) = 19 

step(p, x, y): bool =
  step11(p, x, y) OR step12(p, x, y) OR step13(p, x, y) 
  OR step14(p, x, y) OR step15F(p, x, y) 
  OR step15G(p, x, y) OR step16(p, x, y) OR step17(p, x, y) 
  OR step18(p, x, y) OR step19(p, x, y) 

iq0(q, x): bool = % 
  -1 <= x`level(q) AND x`level(q) <= depth(q) - 1

iq1(q, x): bool = % 
  13 <= x`pc(q) AND x`pc(q) <= 15 IMPLIES 0 <= x`level(q)

iq3(q, x): bool = % 
  x`pc(q) = 18 IMPLIES x`level(q) < depth(q) - 1

iq0_rest: LEMMA % 
  iq0(q, x) AND step(p, x, y) 
  IMPLIES iq0(q, y) OR step15F(p, x, y) OR step18(p, x, y)
    
iq0_15F: LEMMA 
  iq0(q, x) AND step15F(p, x, y) AND iq1(q, x)
  IMPLIES iq0(q, y)

iq0_18: LEMMA 
  iq0(q, x) AND step18(p, x, y) AND iq3(q, x)
  IMPLIES iq0(q, y)

iq0_step: LEMMA 
  iq0(q, x) AND step(p, x, y) AND iq3(q, x) AND iq1(q, x)
  IMPLIES iq0(q, y)

iq1_step: LEMMA % 
  iq1(q, x) AND step(p, x, y) 
  IMPLIES iq1(q, y)

iq2(q, x): bool = % 
  x`pc(q) = 16 IMPLIES x`level(q) = -1

iq2_rest: LEMMA % 
  iq2(q, x) AND step(p, x, y) 
  IMPLIES iq2(q, y) OR step12(p, x, y)

iq2_12: LEMMA 
  iq2(q, x) AND step12(p, x, y) AND iq0(q, x)
  IMPLIES iq2(q, y)

iq2_step: LEMMA 
  iq2(q, x) AND step(p, x, y) AND iq0(q, x)
  IMPLIES iq2(q, y)

iq3_step: LEMMA % 
  iq3(q, x) AND step(p, x, y) 
  IMPLIES iq3(q, y)

iq4(q, x): bool = %
  x`pc(q) = 11 OR x`pc(q) = 19
  IMPLIES x`level(q) = depth(q) - 1 

iq4_rest: LEMMA % 
  iq4(q, x) AND step(p, x, y) 
  IMPLIES iq4(q, y) OR step15F(p, x, y) OR step15G(p, x, y) 
  OR step17(p, x, y)

iq4_15F: LEMMA % 
  iq4(q, x) AND step15F(p, x, y) 
  IMPLIES iq4(q, y) 

iq4_15G: LEMMA % 
  iq4(q, x) AND step15G(p, x, y) 
  IMPLIES iq4(q, y) 

iq4_17: LEMMA % 
  iq4(q, x) AND step17(p, x, y) AND iq0(q, x)
  IMPLIES iq4(q, y) 

iq4_step: LEMMA % 
  iq4(q, x) AND step(p, x, y) AND iq0(q, x)
  IMPLIES iq4(q, y)

iq5(q, j, x): bool =
  x`level(q) < j AND j < depth(q) 
  IMPLIES x`mu(path(q, j)) = sib(q, j)

mx(q, r, j, x): bool =
  x`level(q) < j AND j <= depth(q) 
  AND x`level(r) < j AND j <= depth(r) 
  AND path(q, j) = path(r, j) 
  IMPLIES q = r 

iq5_rest: LEMMA % 
  iq5(q, j, x) AND step(p, x, y) 
  IMPLIES iq5(q, j, y) OR step15F(p, x, y) 
  OR step15G(p, x, y) OR step18(p, x, y)

iq5_15F: LEMMA % 
  iq5(q, j, x) AND step15F(p, x, y) 
  IMPLIES iq5(q, j, y)

iq5_15G: LEMMA % 
  iq5(q, j, x) AND step15G(p, x, y) 
  IMPLIES iq5(q, j, y)

iq5_18: LEMMA % 
  iq5(q, j, x) AND step18(p, x, y) 
  AND iq0(p, x) AND iq3(p, x) 
  AND mx(p, q, j, x)
  IMPLIES iq5(q, j, y)

iq5_step: LEMMA
  iq5(q, j, x) AND step(p, x, y) 
  AND iq0(p, x) AND iq3(p, x) AND mx(p, q, j, x)
  IMPLIES iq5(q, j, y)

mx_down: LEMMA % 
  mx(q, r, j+1, x) AND iq5(q, j, x) AND iq5(r, j, x) 
  IMPLIES mx(q, r, j, x)

iqall(x): bool =
  (FORALL q: iq0(q, x) AND iq1(q, x) AND iq2(q, x) 
     AND iq3(q, x) AND iq4(q, x) )
  AND (FORALL q, j: iq5(q, j, x))

mx_j_implied: LEMMA % 
  iqall(x) IMPLIES mx(q, r, j, x)

init(x): bool =
  (FORALL q: x`pc(q) = 11 AND x`level(q) = depth(q) - 1)
  AND (FORALL (n: node): x`mu(n) = -1 AND empty?(x`cur(n))
       AND FORALL dig: empty?(x`prio(n, dig)) )
  AND x`competing = emptyset

iqall_step: LEMMA
  iqall(x) AND step(p, x, y)
  IMPLIES iqall(y)

init_iqall: LEMMA
  init(x) IMPLIES iqall(x)

mx(q, r, x): bool =
  x`pc(q) = 16 AND x`pc(r) = 16 IMPLIES q = r 

mx_implied: LEMMA % 
  iqall(x) IMPLIES mx(q, r, x)

kq0(q, x): bool =
  11 <= x`pc(q) AND x`pc(q) <= 19

kq0_step: LEMMA 
  kq0(q, x) AND step(p, x, y) 
  IMPLIES kq0(q, y)

kq1(n, x): bool =
  x`mu(n) >= 0 IMPLIES x`level(x`occ(n)) < depth(n) 
  AND n = path(x`occ(n), depth(n)) AND depth(n) < depth(x`occ(n))

kq1_11: LEMMA
  kq1(n, x) AND step11(p, x, y) 
  IMPLIES kq1(n, y)

kq1_12: LEMMA
  kq1(n, x) AND step12(p, x, y) 
  IMPLIES kq1(n, y)

kq1_14: LEMMA
  kq1(n, x) AND step14(p, x, y) 
  IMPLIES kq1(n, y)

kq1_13: LEMMA
  kq1(n, x) AND step13(p, x, y) 
  IMPLIES kq1(n, y)

kq1_15F: LEMMA % 
  kq1(n, x) AND step15F(p, x, y) 
  AND iq0(p, x) AND iq1(p, x)
  IMPLIES kq1(n, y)

kq1_15G: LEMMA % % 
  kq1(n, x) AND step15G(p, x, y) AND iq0(p, x) 
  IMPLIES kq1(n, y)

kq1_16: LEMMA
  kq1(n, x) AND step16(p, x, y) 
  IMPLIES kq1(n, y)

kq1_17: LEMMA
  kq1(n, x) AND step17(p, x, y) 
  IMPLIES kq1(n, y)

kq1_18: LEMMA % 
  kq1(n, x) AND step18(p, x, y) 
  IMPLIES kq1(n, y)

kq1_19: LEMMA
  kq1(n, x) AND step19(p, x, y) 
  IMPLIES kq1(n, y)

kq1_step: LEMMA % 
  kq1(n, x) AND step(p, x, y) 
  AND iq0(p, x) AND iq1(p, x)
  IMPLIES kq1(n, y)

kq4(x): bool =
  card(x`competing) <= K

kq4_rest: LEMMA % 
  kq4(x) AND step(p, x, y)
  IMPLIES kq4(y) OR step11(p, x, y) OR step19(p, x, y)

kq4_11: LEMMA % 
  kq4(x) AND step11(p, x, y)
  IMPLIES kq4(y)

kq4_19: LEMMA % 
  kq4(x) AND step19(p, x, y)
  IMPLIES kq4(y)

kq4_step: LEMMA
  kq4(x) AND step(p, x, y)
  IMPLIES kq4(y)

kq5(q, x): bool =
  x`competing(q) = (x`pc(q) /= 11)

kq5_step: LEMMA % 
  kq5(q, x) AND step(p, x, y) 
  IMPLIES kq5(q, y) 

kqall(x): bool =
  (FORALL q: kq0(q, x) AND kq5(q, x))
  AND (FORALL n: kq1(n, x)) 
  AND kq4(x) 

kqall_step: LEMMA
  kqall(x) AND step(p, x, y) AND iqall(x)
  IMPLIES kqall(y)

init_kqall: LEMMA % 
  init(x) IMPLIES kqall(x)

END tournamentSafe0

$$$tournamentSafe0.prf
(tournamentSafe0
 (N_TCC1 0
  (N_TCC1-1 nil 3669471055
   ("" (use empty_card[node])
    (("" (assert)
      (("" (expand "empty?")
        (("" (expand "member")
          (("" (use exists_leaf)
            (("" (skosimp)
              (("" (inst?)
                (("" (expand "thread") (("" (propax) nil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (member const-decl "bool" sets nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (exists_leaf formula-decl nil ctrees nil)
    (empty? const-decl "bool" sets nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (empty_card formula-decl nil finite_sets nil))
   nil))
 (count_thread_TCC1 0
  (count_thread_TCC1-2 nil 3678595162
   ("" (lemma Card_bijection[node])
    (("" (inst - thread N)
      (("" (flatten)
        (("" (hide -2)
          (("" (split)
            (("1" (skolem!) (("1" (inst?) nil nil)) nil)
             ("2" (expand "N")
              (("2" (hide 2)
                (("2" (typepred "card(thread)")
                  (("2" (assert) nil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (N const-decl "posnat" tournamentSafe0 nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (Card const-decl "nat" finite_sets nil)
    (card const-decl "{n: nat | n = Card(S)}" finite_sets nil)
    (< const-decl "bool" reals nil)
    (below type-eq-decl nil nat_types nil)
    (bijective? const-decl "bool" functions nil) nil
    (Card_bijection formula-decl nil finite_sets nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil))
   nil)
  (count_thread_TCC1-1 nil 3669471603
   ("" (lemma Card_bijection[digseq])
    (("" (inst - thread N)
      (("" (flatten)
        (("" (hide -2)
          (("" (split)
            (("1" (skolem!) (("1" (inst?) nil nil)) nil)
             ("2" (expand "N")
              (("2" (hide 2)
                (("2" (typepred "card(thread)")
                  (("2" (assert) nil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (N const-decl "posnat" tournamentSafe0 nil)
    (card const-decl "{n: nat | n = Card(S)}" finite_sets nil)
    (Card const-decl "nat" finite_sets nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bijective? const-decl "bool" functions nil)
    (Card_bijection formula-decl nil finite_sets nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil) (< const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil))
   nil))
 (enum_thread_TCC1 0
  (enum_thread_TCC1-2 nil 3678595219
   ("" (use exists_leaf)
    (("" (skosimp)
      (("" (inst + n!1)
        (("" (expand "thread") (("" (propax) nil nil)) nil)) nil))
      nil))
    nil)
   (nil (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (exists_leaf formula-decl nil ctrees nil))
   nil)
  (enum_thread_TCC1-1 nil 3670513754
   ("" (use tree_has_leaves)
    (("" (inst - pp)
      (("" (split)
        (("1" (skosimp)
          (("1" (inst + bs!1)
            (("1" (expand "thread") (("1" (propax) nil nil)) nil))
            nil))
          nil)
         ("2" (typepred pp) (("2" (propax) nil nil)) nil))
        nil))
      nil))
    nil)
   ((nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (< const-decl "bool" reals nil) (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   nil))
 (thread_depth 0
  (thread_depth-3 nil 3678594690
   ("" (skolem!) (("" (use upb_depth) nil nil)) nil)
   ((set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (upb_depth formula-decl nil ctrees nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil))
   nil)
  (thread_depth-2 nil 3678594612
   ("" (skolem!)
    (("" (expand "depth")
      (("" (lemma maximum_prop1[node])
        (("" (inst?)
          (("" (inst - q!1)
            (("" (expand "len")
              (("" (assert)
                (("" (typepred q!1)
                  (("" (expand "thread")
                    (("" (expand "leaves")
                      (("" (propax) nil))))))))))))))))))))
    nil)
   nil nil)
  (thread_depth-1 nil 3669522465
   ("" (skolem!)
    (("" (expand "depth")
      (("" (lemma maximum_prop1[digseq])
        (("" (inst?)
          (("" (inst - q!1)
            (("" (expand "len")
              (("" (assert)
                (("" (typepred q!1)
                  (("" (expand "thread")
                    (("" (expand "leaves") (("" (propax) nil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (maximum_prop1 formula-decl nil maxfinset nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil) (< const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil))
   shostak))
 (next15_TCC1 0
  (next15_TCC1-1 nil 3670317107 ("" (subtype-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (digit type-eq-decl nil ctrees nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil) nil nil
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (leaf const-decl "finite_set[node]" ctrees nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (curbranch const-decl "digit" tournamentSafe0 nil))
   nil))
 (next18_TCC1 0
  (next18_TCC1-1 nil 3670050174
   ("" (skolem!) (("" (ground) nil nil)) nil)
   ((real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (iq0_rest 0
  (iq0_rest-1 nil 3669290464
   ("" (skosimp)
    (("" (expand "step")
      (("" (assert)
        (("" (hide-all-but (1) +)
          (("" (split)
            (("1" (grind) nil nil) ("2" (grind) nil nil)
             ("3" (grind) nil nil) ("4" (grind) nil nil)
             ("5" (grind) nil nil) ("6" (grind) nil nil)
             ("7" (grind) nil nil) ("8" (grind) nil nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((step const-decl "bool" tournamentSafe0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (iq0 const-decl "bool" tournamentSafe0 nil))
   shostak))
 (iq0_15F 0
  (iq0_15F-1 nil 3669290495
   ("" (expand "step15F")
    (("" (expand "iq0")
      (("" (skosimp)
        (("" (expand "next15")
          (("" (case "q!1=p!1")
            (("1" (assert)
              (("1" (expand "iq1") (("1" (propax) nil nil)) nil)) nil)
             ("2" (assert) nil nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((iq0 const-decl "bool" tournamentSafe0 nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (iq1 const-decl "bool" tournamentSafe0 nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (boolean nonempty-type-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (step15F const-decl "bool" tournamentSafe0 nil))
   shostak))
 (iq0_18 0
  (iq0_18-1 nil 3669619720
   ("" (expand "step18")
    (("" (expand "iq0")
      (("" (skosimp)
        (("" (replaceh -3)
          (("" (expand "next18")
            (("" (case "q!1=p!1")
              (("1" (assert)
                (("1" (expand "iq3") (("1" (propax) nil nil)) nil))
                nil)
               ("2" (assert) nil nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((iq0 const-decl "bool" tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (iq3 const-decl "bool" tournamentSafe0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil))
   shostak))
 (iq0_step 0
  (iq0_step-2 nil 3669619828
   ("" (skosimp)
    (("" (use iq0_rest (y y!1))
      (("" (use iq0_15F (y y!1))
        (("" (use iq0_18 (y y!1)) (("" (assert) nil nil)) nil)) nil))
      nil))
    nil)
   ((iq0_rest formula-decl nil tournamentSafe0 nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (digit type-eq-decl nil ctrees nil) (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (iq0_18 formula-decl nil tournamentSafe0 nil)
    (iq0_15F formula-decl nil tournamentSafe0 nil))
   nil)
  (iq0_step-1 nil 3669290658
   ("" (skosimp)
    (("" (use iq0_rest (y y!1))
      (("" (use iq0_15F (y y!1)) (("" (assert) nil nil)) nil)) nil))
    nil)
   ((iq0_rest formula-decl nil tournamentSafe0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil) (< const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (iq0_15F formula-decl nil tournamentSafe0 nil))
   shostak))
 (iq1_step 0
  (iq1_step-1 nil 3669290751
   ("" (skosimp)
    (("" (expand "step")
      (("" (assert)
        (("" (split)
          (("1" (grind) nil nil) ("2" (grind) nil nil)
           ("3" (grind) nil nil) ("4" (grind) nil nil)
           ("5" (grind) nil nil) ("6" (grind) nil nil)
           ("7" (grind) nil nil) ("8" (grind) nil nil)
           ("9" (grind) nil nil) ("10" (grind) nil nil))
          nil))
        nil))
      nil))
    nil)
   ((step const-decl "bool" tournamentSafe0 nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (iq1 const-decl "bool" tournamentSafe0 nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (p!1 skolem-const-decl "(thread)" tournamentSafe0 nil)
    (x!1 skolem-const-decl "state" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (digit type-eq-decl nil ctrees nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (>= const-decl "bool" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil))
   shostak))
 (iq2_rest 0
  (iq2_rest-1 nil 3669476856
   ("" (skosimp)
    (("" (expand "step")
      (("" (assert)
        (("" (hide-all-but (1) +)
          (("" (split)
            (("1" (grind) nil nil) ("2" (grind) nil nil)
             ("3" (grind) nil nil) ("4" (grind) nil nil)
             ("5" (grind) nil nil) ("6" (grind) nil nil)
             ("7" (grind) nil nil) ("8" (grind) nil nil)
             ("9" (grind) nil nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((step const-decl "bool" tournamentSafe0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (empty? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (>= const-decl "bool" reals nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (digit type-eq-decl nil ctrees nil) (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (x!1 skolem-const-decl "state" tournamentSafe0 nil)
    (p!1 skolem-const-decl "(thread)" tournamentSafe0 nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (iq2 const-decl "bool" tournamentSafe0 nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (next11 const-decl "state" tournamentSafe0 nil))
   shostak))
 (iq2_12 0
  (iq2_12-1 nil 3669476927
   ("" (expand "step12")
    (("" (expand "iq2")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "goto")
            (("" (case "q!1=p!1")
              (("1" (assert)
                (("1" (lift-if)
                  (("1" (split -5)
                    (("1" (expand "iq0") (("1" (assert) nil nil)) nil)
                     ("2" (flatten) (("2" (assert) nil nil)) nil))
                    nil))
                  nil))
                nil)
               ("2" (assert) nil nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((iq2 const-decl "bool" tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil))
   shostak))
 (iq2_step 0
  (iq2_step-1 nil 3669301181
   ("" (skosimp)
    (("" (use iq2_rest (y y!1))
      (("" (use iq2_12 (y y!1)) (("" (assert) nil nil)) nil)) nil))
    nil)
   ((iq2_rest formula-decl nil tournamentSafe0 nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (digit type-eq-decl nil ctrees nil) (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (iq2_12 formula-decl nil tournamentSafe0 nil))
   shostak))
 (iq3_step 0
  (iq3_step-1 nil 3669290721
   ("" (skosimp)
    (("" (expand "step")
      (("" (assert)
        (("" (split)
          (("1" (grind) nil nil) ("2" (grind) nil nil)
           ("3" (grind) nil nil) ("4" (grind) nil nil)
           ("5" (grind) nil nil) ("6" (grind) nil nil)
           ("7" (grind) nil nil) ("8" (grind) nil nil)
           ("9" (grind) nil nil) ("10" (grind) nil nil))
          nil))
        nil))
      nil))
    nil)
   ((step const-decl "bool" tournamentSafe0 nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (iq3 const-decl "bool" tournamentSafe0 nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (p!1 skolem-const-decl "(thread)" tournamentSafe0 nil)
    (x!1 skolem-const-decl "state" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (digit type-eq-decl nil ctrees nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (>= const-decl "bool" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil))
   shostak))
 (iq4_rest 0
  (iq4_rest-1 nil 3678423233
   ("" (skosimp)
    (("" (expand "step")
      (("" (assert)
        (("" (hide-all-but (1) +)
          (("" (split)
            (("1" (grind) nil nil) ("2" (grind) nil nil)
             ("3" (grind) nil nil) ("4" (grind) nil nil)
             ("5" (grind) nil nil) ("6" (grind) nil nil)
             ("7" (grind) nil nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((step const-decl "bool" tournamentSafe0 nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (iq4 const-decl "bool" tournamentSafe0 nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (next11 const-decl "state" tournamentSafe0 nil))
   shostak))
 (iq4_15F 0
  (iq4_15F-1 nil 3678423289
   ("" (expand "step15F")
    (("" (expand "iq4")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "next15")
            (("" (case "q!1=p!1")
              (("1" (assert) nil nil) ("2" (assert) nil nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((iq4 const-decl "bool" tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (step15F const-decl "bool" tournamentSafe0 nil))
   shostak))
 (iq4_15G 0
  (iq4_15G-1 nil 3678423352
   ("" (expand "step15G")
    (("" (expand "iq4")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "next15")
            (("" (case "q!1=p!1")
              (("1" (assert) nil nil) ("2" (assert) nil nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((iq4 const-decl "bool" tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil))
   shostak))
 (iq4_17 0
  (iq4_17-1 nil 3678423419
   ("" (expand "step17")
    (("" (expand "iq4")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "goto")
            (("" (case "q!1=p!1")
              (("1" (assert)
                (("1" (lift-if)
                  (("1" (assert)
                    (("1" (expand "iq0")
                      (("1" (flatten) (("1" (assert) nil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (assert) nil nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((iq4 const-decl "bool" tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil))
   shostak))
 (iq4_step 0
  (iq4_step-1 nil 3669363905
   ("" (skosimp)
    (("" (use iq4_rest (y y!1))
      (("" (use iq4_15F (y y!1))
        (("" (use iq4_15G (y y!1))
          (("" (use iq4_17 (y y!1)) (("" (assert) nil nil)) nil)) nil))
        nil))
      nil))
    nil)
   ((iq4_rest formula-decl nil tournamentSafe0 nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (digit type-eq-decl nil ctrees nil) (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (iq4_15G formula-decl nil tournamentSafe0 nil)
    (iq4_17 formula-decl nil tournamentSafe0 nil)
    (iq4_15F formula-decl nil tournamentSafe0 nil))
   shostak))
 (iq5_rest 0
  (iq5_rest-1 nil 3669286747
   ("" (skosimp)
    (("" (expand "step")
      (("" (assert)
        (("" (hide-all-but (1) +)
          (("" (split)
            (("1" (grind) nil nil) ("2" (grind) nil nil)
             ("3" (grind) nil nil) ("4" (grind) nil nil)
             ("5" (grind) nil nil) ("6" (grind) nil nil)
             ("7" (grind) nil nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((step const-decl "bool" tournamentSafe0 nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (iq5 const-decl "bool" tournamentSafe0 nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (next11 const-decl "state" tournamentSafe0 nil))
   shostak))
 (iq5_15F 0
  (iq5_15F-2 nil 3678601060
   ("" (expand "step15F")
    (("" (expand "iq5")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "next15")
            (("" (case "q!1=p!1")
              (("1" (replaceh -1)
                (("1" (assert)
                  (("1" (case "curnode(p!1, x!1) = path(p!1, j!1)")
                    (("1" (assert)
                      (("1" (expand "curnode")
                        (("1" (use equal_paths)
                          (("1" (assert)
                            (("1" (expand "curbranch")
                              (("1" (assert) nil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (assert)
                      (("2" (expand "curnode") (("2" (assert) nil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (assert)
                (("2" (case "curnode(p!1, x!1) = path(q!1, j!1)")
                  (("1" (assert) nil nil) ("2" (assert) nil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((iq5 const-decl "bool" tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (equal_paths formula-decl nil ctrees nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (digit type-eq-decl nil ctrees nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (path const-decl "node" ctrees nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (step15F const-decl "bool" tournamentSafe0 nil))
   nil)
  (iq5_15F-1 nil 3669287465
   ("" (expand "step15F")
    (("" (expand "iq5")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "next15")
            (("" (case "q!1=p!1")
              (("1" (replaceh -1)
                (("1" (assert)
                  (("1" (case "curnode(p!1, x!1) = path(p!1, j!1)")
                    (("1" (assert)
                      (("1" (expand "curnode")
                        (("1" (lemma depth_path)
                          (("1" (inst - _ p!1)
                            (("1" (inst-cp - "x!1`level(p!1)")
                              (("1"
                                (inst - j!1)
                                (("1"
                                  (assert)
                                  (("1"
                                    (expand "curbranch")
                                    (("1" (assert) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (assert)
                      (("2" (expand "curnode") (("2" (assert) nil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (assert)
                (("2" (case "curnode(p!1, x!1) = path(q!1, j!1)")
                  (("1" (assert) nil nil) ("2" (assert) nil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((step15F const-decl "bool" tournamentSafe0 nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (boolean nonempty-type-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (iq5 const-decl "bool" tournamentSafe0 nil))
   shostak))
 (iq5_15G 0
  (iq5_15G-2 nil 3678601124
   ("" (expand "step15G")
    (("" (expand "iq5")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "next15")
            (("" (case "q!1=p!1")
              (("1" (assert)
                (("1" (replaceh -1)
                  (("1" (case "curnode(p!1, x!1) = path(p!1, j!1)")
                    (("1" (assert)
                      (("1" (expand "curnode")
                        (("1" (use equal_paths)
                          (("1" (assert)
                            (("1" (expand "curbranch")
                              (("1" (assert) nil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (assert)
                      (("2" (expand "curnode") (("2" (assert) nil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (assert)
                (("2" (case "curnode(p!1, x!1) = path(q!1, j!1)")
                  (("1" (assert) nil nil) ("2" (assert) nil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((iq5 const-decl "bool" tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (equal_paths formula-decl nil ctrees nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (digit type-eq-decl nil ctrees nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (path const-decl "node" ctrees nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil))
   nil)
  (iq5_15G-1 nil 3669287981
   ("" (expand "step15G")
    (("" (expand "iq5")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "next15")
            (("" (case "q!1=p!1")
              (("1" (assert)
                (("1" (replaceh -1)
                  (("1" (case "curnode(p!1, x!1) = path(p!1, j!1)")
                    (("1" (assert)
                      (("1" (expand "curnode")
                        (("1" (lemma depth_path)
                          (("1" (inst - _ p!1)
                            (("1" (inst-cp - "x!1`level(p!1)")
                              (("1"
                                (inst - j!1)
                                (("1"
                                  (assert)
                                  (("1"
                                    (expand "curbranch")
                                    (("1" (assert) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (assert)
                      (("2" (expand "curnode") (("2" (assert) nil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (assert)
                (("2" (case "curnode(p!1, x!1) = path(q!1, j!1)")
                  (("1" (assert) nil nil) ("2" (assert) nil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((step15G const-decl "bool" tournamentSafe0 nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (boolean nonempty-type-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (iq5 const-decl "bool" tournamentSafe0 nil))
   shostak))
 (iq5_18 0
  (iq5_18-1 nil 3669288291
   ("" (expand "step18")
    (("" (expand "iq5")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "next18")
            (("" (case "q!1=p!1")
              (("1" (assert)
                (("1" (replaceh -1)
                  (("1"
                    (case "path(p!1, 1 + x!1`level(p!1)) = path(p!1, j!1)")
                    (("1" (assert)
                      (("1" (lemma depth_path)
                        (("1" (inst - _ p!1)
                          (("1" (inst-cp - "1 + x!1`level(p!1)")
                            (("1" (inst - j!1) (("1" (assert) nil nil))
                              nil)
                             ("2" (use equal_paths)
                              (("1" (assert) nil nil)
                               ("2"
                                (expand "iq0")
                                (("2" (assert) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (assert) nil nil))
                    nil))
                  nil))
                nil)
               ("2"
                (case "path(p!1, 1 + x!1`level(p!1)) = path(q!1, j!1)")
                (("1" (assert)
                  (("1" (use equal_paths)
                    (("1" (assert)
                      (("1" (expand "iq3")
                        (("1" (assert)
                          (("1" (expand "mx") (("1" (propax) nil nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (assert)
                      (("2" (expand "iq0") (("2" (propax) nil nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (assert) nil nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((iq5 const-decl "bool" tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (equal_paths formula-decl nil ctrees nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (p!1 skolem-const-decl "(thread)" tournamentSafe0 nil)
    (x!1 skolem-const-decl "state" tournamentSafe0 nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (depth_path formula-decl nil ctrees nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (path const-decl "node" ctrees nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (digit type-eq-decl nil ctrees nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (mx const-decl "bool" tournamentSafe0 nil)
    (iq3 const-decl "bool" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil))
   shostak))
 (iq5_step 0
  (iq5_step-1 nil 3669290307
   ("" (skosimp)
    (("" (use iq5_rest (y y!1))
      (("" (use iq5_15F (y y!1))
        (("" (use iq5_15G (y y!1))
          (("" (use iq5_18 (y y!1)) (("" (assert) nil nil)) nil)) nil))
        nil))
      nil))
    nil)
   ((iq5_rest formula-decl nil tournamentSafe0 nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (digit type-eq-decl nil ctrees nil) (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (iq5_15G formula-decl nil tournamentSafe0 nil)
    (iq5_18 formula-decl nil tournamentSafe0 nil)
    (iq5_15F formula-decl nil tournamentSafe0 nil))
   shostak))
 (mx_down 0
  (mx_down-1 nil 3669290908
   ("" (expand "mx")
    (("" (expand "iq5")
      (("" (skosimp)
        (("" (assert)
          ((""
            (case "1 + j!1 <= depth(q!1) AND
       1 + j!1 <= depth(r!1)")
            (("1" (flatten)
              (("1" (assert)
                (("1" (lemma joining_paths)
                  (("1" (inst - j!1 q!1 r!1) (("1" (assert) nil nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (hide 2)
              (("2" (hide -1 -2)
                (("2" (typepred q!1)
                  (("2" (typepred r!1)
                    (("2" (expand "thread")
                      (("2" (assert)
                        (("2" (split)
                          (("1" (use path_depth (n q!1))
                            (("1" (case "depth(q!1) = j!1")
                              (("1"
                                (replaceh -1)
                                (("1"
                                  (replaceh -1)
                                  (("1"
                                    (expand "leaf")
                                    (("1"
                                      (inst -2 j!1 r!1)
                                      (("1" (assert) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2" (assert) nil nil))
                              nil))
                            nil)
                           ("2" (case "depth(r!1)=j!1")
                            (("1" (use path_depth)
                              (("1"
                                (replaceh -2)
                                (("1"
                                  (replaceh -1)
                                  (("1"
                                    (expand "leaf")
                                    (("1"
                                      (inst - j!1 q!1)
                                      (("1" (assert) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (assert) nil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((iq5 const-decl "bool" tournamentSafe0 nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (leaf const-decl "finite_set[node]" ctrees nil)
    (path_depth formula-decl nil ctrees nil)
    (joining_paths formula-decl nil ctrees nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (<= const-decl "bool" reals nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (depth const-decl "nat" ctrees nil) (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (mx const-decl "bool" tournamentSafe0 nil))
   shostak))
 (mx_j_implied 0
  (mx_j_implied-3 nil 3678602540
   ("" (skosimp)
    (("" (case "j!1 <= depth(q!1)")
      (("1"
        (case "FORALL k: k <= depth(q!1) IMPLIES mx(q!1, r!1, depth(q!1) - k, x!1)")
        (("1" (inst - "depth(q!1) - j!1")
          (("1" (assert) nil nil) ("2" (assert) nil nil)) nil)
         ("2" (hide 2)
          (("2" (induct k)
            (("1" (flatten)
              (("1" (expand "mx")
                (("1" (flatten)
                  (("1" (assert)
                    (("1" (typepred q!1)
                      (("1" (expand "thread")
                        (("1" (use path_depth)
                          (("1" (replaceh -1)
                            (("1" (expand "leaf")
                              (("1"
                                (inst?)
                                (("1" (assert) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (skosimp)
              (("2" (assert)
                (("2" (lemma mx_down)
                  (("2" (inst - "depth(q!1) - 1 - j!2" q!1 r!1 x!1)
                    (("2" (assert)
                      (("2" (expand "iqall")
                        (("2" (flatten)
                          (("2" (hide -4)
                            (("2" (inst - _ "depth(q!1) - 1 - j!2")
                              (("2"
                                (split)
                                (("1" (inst?) nil nil)
                                 ("2" (inst?) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("3" (hide - 2) (("3" (grind) nil nil)) nil))
            nil))
          nil)
         ("3" (hide - 2) (("3" (grind) nil nil)) nil))
        nil)
       ("2" (expand "mx") (("2" (assert) nil nil)) nil))
      nil))
    nil)
   ((thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (depth const-decl "nat" ctrees nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (<= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (mx_down formula-decl nil tournamentSafe0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (path_depth formula-decl nil ctrees nil)
    (leaf const-decl "finite_set[node]" ctrees nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (q!1 skolem-const-decl "(thread)" tournamentSafe0 nil)
    (j!1 skolem-const-decl "nat" tournamentSafe0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (digit type-eq-decl nil ctrees nil) (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (mx const-decl "bool" tournamentSafe0 nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields
       nil))
   nil)
  (mx_j_implied-2 nil 3670046000
   ("" (skosimp)
    (("" (case "j!1 <= q!1`length")
      (("1"
        (case "FORALL k: k <= q!1`length IMPLIES mx(q!1, r!1, q!1`length - k, x!1)")
        (("1" (inst - "q!1`length - j!1")
          (("1" (assert) nil nil) ("2" (assert) nil nil)) nil)
         ("2" (hide 2)
          (("2" (induct k)
            (("1" (flatten)
              (("1" (expand "mx")
                (("1" (flatten)
                  (("1" (assert)
                    (("1" (use leaves_separate)
                      (("1" (assert)
                        (("1" (inst - pp)
                          (("1" (assert)
                            (("1" (typepred q!1)
                              (("1"
                                (typepred r!1)
                                (("1"
                                  (expand "thread")
                                  (("1" (assert) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (skosimp)
              (("2" (assert)
                (("2" (lemma mx_down)
                  (("2" (inst - "q!1`length - 1 - j!2" q!1 r!1 x!1)
                    (("2" (assert)
                      (("2" (expand "iqall")
                        (("2" (flatten)
                          (("2" (hide -4)
                            (("2" (inst - _ "q!1`length - 1 - j!2")
                              (("2"
                                (split)
                                (("1" (inst?) nil nil)
                                 ("2" (inst?) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("3" (hide - 2) (("3" (grind) nil nil)) nil))
            nil))
          nil)
         ("3" (hide - 2) (("3" (grind) nil nil)) nil))
        nil)
       ("2" (expand "mx") (("2" (assert) nil nil)) nil))
      nil))
    nil)
   ((thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (<= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (mx_down formula-decl nil tournamentSafe0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields
       nil))
   nil)
  (mx_j_implied-1 nil 3669291972
   ("" (skosimp)
    (("" (case "j!1 < q!1`length")
      (("1"
        (case "FORALL k: k <= q!1`length IMPLIES mx(q!1, r!1, q!1`length - k, x!1)")
        (("1" (inst - "q!1`length - j!1")
          (("1" (assert) nil nil) ("2" (assert) nil nil)) nil)
         ("2" (hide 2)
          (("2" (induct k)
            (("1" (flatten)
              (("1" (expand "mx") (("1" (propax) nil nil)) nil)) nil)
             ("2" (skosimp)
              (("2" (assert)
                (("2" (lemma mx_down)
                  (("2" (inst - "q!1`length - 1 - j!2" q!1 r!1 x!1)
                    (("2" (assert)
                      (("2" (expand "iqall")
                        (("2" (flatten)
                          (("2" (hide -4)
                            (("2" (inst - _ "q!1`length - 1 - j!2")
                              (("2"
                                (split)
                                (("1" (inst?) nil nil)
                                 ("2" (inst?) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("3" (hide - 2) (("3" (grind) nil nil)) nil))
            nil))
          nil)
         ("3" (hide - 2) (("3" (grind) nil nil)) nil))
        nil)
       ("2" (expand "mx") (("2" (assert) nil nil)) nil))
      nil))
    nil)
   ((thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (< const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (mx_down formula-decl nil tournamentSafe0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (pred type-eq-decl nil defined_types nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields
       nil))
   shostak))
 (iqall_step 0
  (iqall_step-4 nil 3678424505
   ("" (skosimp)
    (("" (expand iqall +)
      (("" (split)
        (("1" (skolem!)
          (("1" (expand "iqall")
            (("1" (flatten)
              (("1" (inst?)
                (("1" (use iq0_step (p p!1 x x!1 y y!1))
                  (("1" (use iq1_step (p p!1 x x!1 y y!1))
                    (("1" (use iq2_step (p p!1 x x!1 y y!1))
                      (("1" (use iq3_step (p p!1 x x!1 y y!1))
                        (("1" (use iq4_step (p p!1 x x!1 y y!1))
                          (("1" (assert)
                            (("1" (flatten) (("1" (assert) nil nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (skolem!)
          (("2" (use iq5_step (p p!1 x x!1 y y!1))
            (("2" (assert)
              (("2" (use mx_j_implied)
                (("2" (assert)
                  (("2" (expand "iqall")
                    (("2" (flatten)
                      (("2" (inst?)
                        (("2" (inst?)
                          (("2" (assert)
                            (("2" (flatten) (("2" (assert) nil nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((iqall const-decl "bool" tournamentSafe0 nil)
    (mx_j_implied formula-decl nil tournamentSafe0 nil)
    (iq5_step formula-decl nil tournamentSafe0 nil)
    (iq0_step formula-decl nil tournamentSafe0 nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (digit type-eq-decl nil ctrees nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (iq2_step formula-decl nil tournamentSafe0 nil)
    (iq4_step formula-decl nil tournamentSafe0 nil)
    (iq3_step formula-decl nil tournamentSafe0 nil)
    (iq1_step formula-decl nil tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil))
   nil)
  (iqall_step-3 nil 3669301233
   ("" (skosimp)
    (("" (expand iqall +)
      (("" (split)
        (("1" (skolem!)
          (("1" (expand "iqall")
            (("1" (flatten)
              (("1" (inst?)
                (("1" (use iq0_step (p p!1 x x!1 y y!1))
                  (("1" (use iq3_step (p p!1 x x!1 y y!1))
                    (("1" (use iq1_step (p p!1 x x!1 y y!1))
                      (("1" (use iq2_step (p p!1 x x!1 y y!1))
                        (("1" (assert)
                          (("1" (flatten) (("1" (assert) nil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (skolem!)
          (("2" (use iq5_step (p p!1 x x!1 y y!1))
            (("2" (assert)
              (("2" (use mx_j_implied)
                (("2" (assert)
                  (("2" (expand "iqall")
                    (("2" (flatten)
                      (("2" (inst?)
                        (("2" (inst?)
                          (("2" (assert)
                            (("2" (flatten) (("2" (assert) nil nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((iqall const-decl "bool" tournamentSafe0 nil)
    (mx_j_implied formula-decl nil tournamentSafe0 nil)
    (iq5_step formula-decl nil tournamentSafe0 nil)
    (iq0_step formula-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (iq1_step formula-decl nil tournamentSafe0 nil)
    (iq2_step formula-decl nil tournamentSafe0 nil)
    (iq3_step formula-decl nil tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil))
   nil)
  (iqall_step-2 nil 3669292929
   ("" (skosimp)
    (("" (expand iqall +)
      (("" (split)
        (("1" (skolem!)
          (("1" (expand "iqall")
            (("1" (flatten)
              (("1" (inst?)
                (("1" (use iq0_step (p p!1 x x!1 y y!1))
                  (("1" (use iq3_step (p p!1 x x!1 y y!1))
                    (("1" (use iq1_step (p p!1 x x!1 y y!1))
                      (("1" (assert)
                        (("1" (flatten) (("1" (assert) nil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (skolem!)
          (("2" (use iq5_step (p p!1 x x!1 y y!1))
            (("2" (assert)
              (("2" (use mx_j_implied)
                (("2" (assert)
                  (("2" (expand "iqall")
                    (("2" (flatten)
                      (("2" (inst?)
                        (("2" (inst?)
                          (("2" (assert)
                            (("2" (flatten) (("2" (assert) nil nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil) (< const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (pred type-eq-decl nil defined_types nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (iq3_step formula-decl nil tournamentSafe0 nil)
    (iq1_step formula-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (iq0_step formula-decl nil tournamentSafe0 nil)
    (iq5_step formula-decl nil tournamentSafe0 nil)
    (mx_j_implied formula-decl nil tournamentSafe0 nil)
    (iqall const-decl "bool" tournamentSafe0 nil))
   nil)
  (iqall_step-1 nil 3669292787
   ("" (skosimp)
    (("" (expand iqall +)
      (("" (split)
        (("1" (skolem!)
          (("1" (expand "iqall")
            (("1" (flatten)
              (("1" (inst?)
                (("1" (use iq0_step (p p!1 x x!1 y y!1))
                  (("1" (use iq3_step (p p!1 x x!1 y y!1))
                    (("1" (assert)
                      (("1" (flatten)
                        (("1" (assert) (("1" (postpone) nil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (postpone) nil nil))
        nil))
      nil))
    nil)
   nil shostak))
 (init_iqall 0
  (init_iqall-1 nil 3669299869
   ("" (expand "iqall")
    (("" (expand "init")
      (("" (skosimp)
        (("" (split)
          (("1" (skolem!)
            (("1" (inst?)
              (("1" (flatten)
                (("1" (expand "iq0")
                  (("1" (assert)
                    (("1" (expand "iq3")
                      (("1" (expand "iq1")
                        (("1" (expand "iq2")
                          (("1" (expand "iq4") (("1" (propax) nil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (skolem!)
            (("2" (expand "iq5")
              (("2" (flatten)
                (("2" (assert)
                  (("2" (inst?)
                    (("2" (flatten) (("2" (assert) nil nil)) nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((init const-decl "bool" tournamentSafe0 nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (iq3 const-decl "bool" tournamentSafe0 nil)
    (iq2 const-decl "bool" tournamentSafe0 nil)
    (iq4 const-decl "bool" tournamentSafe0 nil)
    (iq1 const-decl "bool" tournamentSafe0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (finite_emptyset name-judgement "finite_set" finite_sets nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (iq5 const-decl "bool" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (iqall const-decl "bool" tournamentSafe0 nil))
   shostak))
 (mx_implied 0
  (mx_implied-2 nil 3678602950
   ("" (expand "mx")
    (("" (skosimp)
      (("" (lemma mx_j_implied)
        (("" (inst - 0 q!1 r!1 x!1)
          (("" (assert)
            (("" (expand "mx")
              (("" (case "path(q!1, 0) = path(r!1, 0)")
                (("1" (assert)
                  (("1" (case "iq2(q!1, x!1) AND iq2(r!1, x!1)")
                    (("1" (flatten)
                      (("1" (expand "iq2")
                        (("1" (assert)
                          (("1" (typepred q!1)
                            (("1" (typepred r!1)
                              (("1"
                                (expand "thread")
                                (("1"
                                  (assert)
                                  (("1"
                                    (assert)
                                    (("1" (assert) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (expand "iqall")
                      (("2" (flatten)
                        (("2" (hide-all-but (-2 1))
                          (("2" (split)
                            (("1" (inst?) (("1" (assert) nil nil)) nil)
                             ("2" (inst?) (("2" (assert) nil nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (hide - 2 3)
                  (("2" (lemma path_zero)
                    (("2" (inst-cp - q!1)
                      (("2" (replaceh -2)
                        (("2" (inst?) (("2" (assert) nil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (digit type-eq-decl nil ctrees nil) (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (mx const-decl "bool" tournamentSafe0 nil)
    (path_zero formula-decl nil ctrees nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (iq2 const-decl "bool" tournamentSafe0 nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (path const-decl "node" ctrees nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (mx_j_implied formula-decl nil tournamentSafe0 nil)
    (mx const-decl "bool" tournamentSafe0 nil))
   nil)
  (mx_implied-1 nil 3669301291
   ("" (expand "mx")
    (("" (skosimp)
      (("" (lemma mx_j_implied)
        (("" (inst - 0 q!1 r!1 x!1)
          (("" (assert)
            (("" (expand "mx")
              (("" (case "take(0, q!1) = take(0, r!1)")
                (("1" (assert)
                  (("1" (case "iq2(q!1, x!1) AND iq2(r!1, x!1)")
                    (("1" (flatten)
                      (("1" (expand "iq2")
                        (("1" (assert)
                          (("1" (use leaves_separate)
                            (("1" (typepred q!1)
                              (("1"
                                (typepred r!1)
                                (("1"
                                  (expand "thread")
                                  (("1"
                                    (inst?)
                                    (("1"
                                      (assert)
                                      (("1"
                                        (flatten)
                                        (("1" (assert) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (expand "iqall")
                      (("2" (flatten)
                        (("2" (hide-all-but (-2 1))
                          (("2" (split)
                            (("1" (inst?) (("1" (assert) nil nil)) nil)
                             ("2" (inst?) (("2" (assert) nil nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (hide - 2 3)
                  (("2" (expand "take")
                    (("2" (split)
                      (("1" (grind) nil nil)
                       ("2" (apply-extensionality :hide? t)
                        (("1" (typepred x!2) (("1" (grind) nil nil))
                          nil)
                         ("2" (grind) nil nil) ("3" (grind) nil nil)
                         ("4" (grind) nil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (< const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (min const-decl "{p: real | p <= m AND p <= n}" real_defs nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (nat_min application-judgement "{k: nat | k <= i AND k <= j}"
     real_defs nil)
    (nat_max application-judgement "{k: nat | i <= k AND j <= k}"
     real_defs nil)
    (int_max application-judgement "{k: int | i <= k AND j <= k}"
     real_defs nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (IFF const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (iq2 const-decl "bool" tournamentSafe0 nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (mx_j_implied formula-decl nil tournamentSafe0 nil))
   shostak))
 (kq0_step 0
  (kq0_step-1 nil 3669355216 ("" (grind) nil nil)
   ((thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (leaf const-decl "finite_set[node]" ctrees nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (digit type-eq-decl nil ctrees nil) (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (x!1 skolem-const-decl "state" tournamentSafe0 nil)
    (p!1 skolem-const-decl "(thread)" tournamentSafe0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (kq0 const-decl "bool" tournamentSafe0 nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (step const-decl "bool" tournamentSafe0 nil))
   shostak))
 (kq1_11 0
  (kq1_11-1 nil 3669360959
   ("" (expand "step11")
    (("" (expand "kq1")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (assert)
            (("" (expand "next11") (("" (assert) nil nil)) nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((kq1 const-decl "bool" tournamentSafe0 nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (step11 const-decl "bool" tournamentSafe0 nil))
   shostak))
 (kq1_12 0
  (kq1_12-1 nil 3669361028
   ("" (expand "step12")
    (("" (expand "kq1")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "goto") (("" (assert) nil nil)) nil)) nil))
        nil))
      nil))
    nil)
   ((kq1 const-decl "bool" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil))
   shostak))
 (kq1_14 0
  (kq1_14-1 nil 3669820638
   ("" (expand "step14")
    (("" (expand "kq1")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "next14") (("" (assert) nil nil)) nil)) nil))
        nil))
      nil))
    nil)
   ((kq1 const-decl "bool" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil))
   shostak))
 (kq1_13 0
  (kq1_13-1 nil 3669820677
   ("" (expand "step13")
    (("" (expand "kq1")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "next13") (("" (assert) nil nil)) nil)) nil))
        nil))
      nil))
    nil)
   ((kq1 const-decl "bool" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil))
   shostak))
 (kq1_15F 0
  (kq1_15F-2 nil 3678605979
   ("" (expand "step15F")
    (("" (expand "kq1")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "next15")
            (("" (case "n!1 = curnode(p!1, x!1)")
              (("1" (assert)
                (("1" (expand "curnode")
                  (("1" (case "depth(n!1) = x!1`level(p!1)")
                    (("1" (assert)
                      (("1" (expand "iq0") (("1" (propax) nil nil))
                        nil))
                      nil)
                     ("2" (expand "iq1")
                      (("2" (replaceh -1)
                        (("2" (expand "iq0")
                          (("2" (hide-all-but (-4 -5 1))
                            (("2" (flatten)
                              (("2"
                                (use depth_path)
                                (("1" (assert) nil nil)
                                 ("2" (assert) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (assert)
                (("2" (flatten)
                  (("2" (assert)
                    (("2" (case "x!1`occ(n!1)= p!1")
                      (("1" (assert) nil nil) ("2" (assert) nil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((kq1 const-decl "bool" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (digit type-eq-decl nil ctrees nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (iq1 const-decl "bool" tournamentSafe0 nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (x!1 skolem-const-decl "state" tournamentSafe0 nil)
    (p!1 skolem-const-decl "(thread)" tournamentSafe0 nil)
    (depth_path formula-decl nil ctrees nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (depth const-decl "nat" ctrees nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (step15F const-decl "bool" tournamentSafe0 nil))
   nil)
  (kq1_15F-1 nil 3669819869
   ("" (expand "step15F")
    (("" (expand "kq1")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "next15")
            (("" (case "n!1 = curnode(p!1, x!1)")
              (("1" (assert)
                (("1" (expand "curnode")
                  (("1" (case "n!1`length = x!1`level(p!1)")
                    (("1" (assert)
                      (("1" (expand "iq0") (("1" (propax) nil nil))
                        nil))
                      nil)
                     ("2" (expand "iq1")
                      (("2" (replaceh -1)
                        (("2" (expand "iq0")
                          (("2" (hide-all-but (-4 -5 1))
                            (("2" (flatten)
                              (("2"
                                (expand "take")
                                (("2"
                                  (expand "max")
                                  (("2"
                                    (assert)
                                    (("2"
                                      (expand "min")
                                      (("2" (propax) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (assert)
                (("2" (flatten)
                  (("2" (assert)
                    (("2" (case "x!1`occ(n!1)= p!1")
                      (("1" (assert) nil nil) ("2" (assert) nil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((kq1 const-decl "bool" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (iq1 const-decl "bool" tournamentSafe0 nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (min const-decl "{p: real | p <= m AND p <= n}" real_defs nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_min application-judgement "{k: int | k <= i AND k <= j}"
     real_defs nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (step15F const-decl "bool" tournamentSafe0 nil))
   shostak))
 (kq1_15G 0
  (kq1_15G-2 nil 3678606158
   ("" (expand "step15G")
    (("" (expand "kq1")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "next15")
            (("" (case "n!1 = curnode(p!1, x!1)")
              (("1" (assert)
                (("1" (expand "curnode")
                  (("1" (case "depth(n!1)=  x!1`level(p!1)")
                    (("1" (flatten)
                      (("1" (assert)
                        (("1" (expand "curbranch")
                          (("1" (assert)
                            (("1" (expand "iq0")
                              (("1" (propax) nil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide 2)
                      (("2" (expand "curbranch")
                        (("2" (assert)
                          (("2" (flatten)
                            (("2" (assert)
                              (("2"
                                (lemma depth_path)
                                (("2"
                                  (inst?)
                                  (("2"
                                    (expand "iq0")
                                    (("2" (assert) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (assert)
                (("2" (flatten)
                  (("2" (case "x!1`occ(n!1)=p!1")
                    (("1" (assert) nil nil) ("2" (assert) nil nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((kq1 const-decl "bool" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (digit type-eq-decl nil ctrees nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (depth_path formula-decl nil ctrees nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (depth const-decl "nat" ctrees nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil))
   nil)
  (kq1_15G-1 nil 3669361070
   ("" (expand "step15G")
    (("" (expand "kq1")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "next15")
            (("" (case "n!1 = curnode(p!1, x!1)")
              (("1" (assert)
                (("1" (expand "curnode")
                  (("1" (case "n!1`length=  x!1`level(p!1)")
                    (("1" (flatten)
                      (("1" (assert)
                        (("1" (expand "curbranch")
                          (("1" (assert)
                            (("1" (expand "iq0")
                              (("1" (propax) nil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide 2)
                      (("2" (expand "curbranch")
                        (("2" (lift-if)
                          (("2" (assert)
                            (("2" (split -5)
                              (("1"
                                (flatten)
                                (("1"
                                  (assert)
                                  (("1"
                                    (hide -4 -5 -8)
                                    (("1"
                                      (replaceh -3)
                                      (("1"
                                        (expand "take")
                                        (("1"
                                          (expand "max")
                                          (("1"
                                            (expand "min")
                                            (("1" (propax) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (flatten)
                                (("2"
                                  (assert)
                                  (("2"
                                    (expand "iq0")
                                    (("2" (propax) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (assert)
                (("2" (flatten)
                  (("2" (case "x!1`occ(n!1)=p!1")
                    (("1" (assert) nil nil) ("2" (assert) nil nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((kq1 const-decl "bool" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (min const-decl "{p: real | p <= m AND p <= n}" real_defs nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil))
   shostak))
 (kq1_16 0
  (kq1_16-1 nil 3669361799
   ("" (expand "step16")
    (("" (expand "kq1")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "goto") (("" (assert) nil nil)) nil)) nil))
        nil))
      nil))
    nil)
   ((kq1 const-decl "bool" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil))
   shostak))
 (kq1_17 0
  (kq1_17-1 nil 3669361837
   ("" (expand "step17")
    (("" (expand "kq1")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "goto") (("" (assert) nil nil)) nil)) nil))
        nil))
      nil))
    nil)
   ((kq1 const-decl "bool" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil))
   shostak))
 (kq1_18 0
  (kq1_18-2 nil 3678606723
   ("" (expand "step18")
    (("" (expand "kq1")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "next18")
            (("" (case "n!1 = path(p!1, 1 + x!1`level(p!1))")
              (("1" (assert) nil nil)
               ("2" (assert)
                (("2" (flatten)
                  (("2" (case "x!1`occ(n!1) = p!1")
                    (("1" (assert) nil nil) ("2" (assert) nil nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((kq1 const-decl "bool" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (digit type-eq-decl nil ctrees nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (path const-decl "node" ctrees nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil))
   nil)
  (kq1_18-1 nil 3669361874
   ("" (expand "step18")
    (("" (expand "kq1")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "next18")
            (("" (case "n!1 = take(1 + x!1`level(p!1), p!1)")
              (("1" (assert) nil nil)
               ("2" (assert)
                (("2" (flatten)
                  (("2" (case "x!1`occ(n!1) = p!1")
                    (("1" (assert) nil nil) ("2" (assert) nil nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((kq1 const-decl "bool" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil))
   shostak))
 (kq1_19 0
  (kq1_19-1 nil 3669361829
   ("" (expand "step19")
    (("" (expand "kq1")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "next19") (("" (assert) nil nil)) nil)) nil))
        nil))
      nil))
    nil)
   ((kq1 const-decl "bool" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil))
   shostak))
 (kq1_step 0
  (kq1_step-2 nil 3669820732
   ("" (expand "step")
    (("" (skosimp)
      (("" (use kq1_11)
        (("" (use kq1_12)
          (("" (use kq1_13)
            (("" (use kq1_14)
              (("" (use kq1_15F)
                (("" (use kq1_15G)
                  (("" (use kq1_16)
                    (("" (use kq1_17)
                      (("" (use kq1_18)
                        (("" (use kq1_19) (("" (assert) nil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((kq1_12 formula-decl nil tournamentSafe0 nil)
    (kq1_14 formula-decl nil tournamentSafe0 nil)
    (kq1_15G formula-decl nil tournamentSafe0 nil)
    (kq1_17 formula-decl nil tournamentSafe0 nil)
    (kq1_19 formula-decl nil tournamentSafe0 nil)
    (kq1_18 formula-decl nil tournamentSafe0 nil)
    (kq1_16 formula-decl nil tournamentSafe0 nil)
    (kq1_15F formula-decl nil tournamentSafe0 nil)
    (kq1_13 formula-decl nil tournamentSafe0 nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (digit type-eq-decl nil ctrees nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (kq1_11 formula-decl nil tournamentSafe0 nil)
    (step const-decl "bool" tournamentSafe0 nil))
   nil)
  (kq1_step-1 nil 3669361886
   ("" (expand "step")
    (("" (skosimp)
      (("" (use kq1_11)
        (("" (use kq1_12)
          (("" (use kq1_15)
            (("" (use kq1_15G)
              (("" (use kq1_16)
                (("" (use kq1_17)
                  (("" (use kq1_18)
                    (("" (use kq1_19) (("" (assert) nil nil)) nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((kq1_12 formula-decl nil tournamentSafe0 nil)
    (kq1_15G formula-decl nil tournamentSafe0 nil)
    (kq1_17 formula-decl nil tournamentSafe0 nil)
    (kq1_19 formula-decl nil tournamentSafe0 nil)
    (kq1_18 formula-decl nil tournamentSafe0 nil)
    (kq1_16 formula-decl nil tournamentSafe0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil) (< const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (kq1_11 formula-decl nil tournamentSafe0 nil)
    (step const-decl "bool" tournamentSafe0 nil))
   shostak))
 (kq4_rest 0
  (kq4_rest-1 nil 3669528442
   ("" (skosimp)
    (("" (expand "step")
      (("" (assert)
        (("" (hide-all-but (1) +)
          (("" (split)
            (("1" (grind) nil nil) ("2" (grind) nil nil)
             ("3" (grind) nil nil) ("4" (grind) nil nil)
             ("5" (grind) nil nil) ("6" (grind) nil nil)
             ("7" (grind) nil nil) ("8" (grind) nil nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((step const-decl "bool" tournamentSafe0 nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (empty? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (kq4 const-decl "bool" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (goto const-decl "state" tournamentSafe0 nil))
   shostak))
 (kq4_11 0
  (kq4_11-2 nil 3678606793
   ("" (expand "step11")
    (("" (expand "kq4")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "next11")
            (("" (use card_add[node])
              (("" (lift-if)
                (("" (split)
                  (("1" (flatten) (("1" (assert) nil nil)) nil)
                   ("2" (flatten) (("2" (assert) nil nil)) nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((kq4 const-decl "bool" tournamentSafe0 nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (card_add formula-decl nil finite_sets nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (digit type-eq-decl nil ctrees nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (step11 const-decl "bool" tournamentSafe0 nil))
   nil)
  (kq4_11-1 nil 3669528473
   ("" (expand "step11")
    (("" (expand "kq4")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "next11")
            (("" (use card_add[digseq])
              (("" (lift-if)
                (("" (split)
                  (("1" (flatten) (("1" (assert) nil nil)) nil)
                   ("2" (flatten) (("2" (assert) nil nil)) nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((kq4 const-decl "bool" tournamentSafe0 nil)
    (card_add formula-decl nil finite_sets nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil) (< const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (step11 const-decl "bool" tournamentSafe0 nil))
   shostak))
 (kq4_19 0
  (kq4_19-2 nil 3678606821
   ("" (expand "step19")
    (("" (expand "kq4")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "next19")
            (("" (use card_remove[node])
              (("" (replaceh -1)
                (("" (lift-if) (("" (assert) nil nil)) nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((kq4 const-decl "bool" tournamentSafe0 nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (card_remove formula-decl nil finite_sets nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (digit type-eq-decl nil ctrees nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil))
   nil)
  (kq4_19-1 nil 3669528861
   ("" (expand "step19")
    (("" (expand "kq4")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "next19")
            (("" (use card_remove[digseq])
              (("" (replaceh -1)
                (("" (lift-if) (("" (assert) nil nil)) nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((kq4 const-decl "bool" tournamentSafe0 nil)
    (card_remove formula-decl nil finite_sets nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil) (< const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil))
   shostak))
 (kq4_step 0
  (kq4_step-1 nil 3669528922
   ("" (skosimp)
    (("" (use kq4_rest)
      (("" (use kq4_11) (("" (use kq4_19) (("" (assert) nil nil)) nil))
        nil))
      nil))
    nil)
   ((kq4_rest formula-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (digit type-eq-decl nil ctrees nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (kq4_19 formula-decl nil tournamentSafe0 nil)
    (kq4_11 formula-decl nil tournamentSafe0 nil))
   shostak))
 (kq5_step 0
  (kq5_step-1 nil 3669529125
   ("" (skosimp)
    (("" (expand "step")
      (("" (assert)
        (("" (split)
          (("1" (grind) nil nil) ("2" (grind) nil nil)
           ("3" (grind) nil nil) ("4" (grind) nil nil)
           ("5" (grind) nil nil) ("6" (grind) nil nil)
           ("7" (grind) nil nil) ("8" (grind) nil nil)
           ("9" (grind) nil nil) ("10" (grind) nil nil))
          nil))
        nil))
      nil))
    nil)
   ((step const-decl "bool" tournamentSafe0 nil)
    (member const-decl "bool" sets nil)
    (add const-decl "(nonempty?)" sets nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (kq5 const-decl "bool" tournamentSafe0 nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (p!1 skolem-const-decl "(thread)" tournamentSafe0 nil)
    (x!1 skolem-const-decl "state" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (digit type-eq-decl nil ctrees nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (>= const-decl "bool" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (empty? const-decl "bool" sets nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (remove const-decl "set" sets nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil))
   shostak))
 (kqall_step 0
  (kqall_step-7 nil 3678424617
   ("" (expand "kqall")
    (("" (skosimp)
      (("" (split)
        (("1" (skolem!)
          (("1" (use kq0_step (p p!1 x x!1 y y!1))
            (("1" (use kq5_step (p p!1 x x!1 y y!1))
              (("1" (inst?)
                (("1" (flatten) (("1" (assert) nil nil)) nil)) nil))
              nil))
            nil))
          nil)
         ("2" (skolem!)
          (("2" (inst? -2)
            (("2" (use kq1_step)
              (("2" (assert)
                (("2" (expand "iqall")
                  (("2" (flatten)
                    (("2" (inst? -5)
                      (("2" (flatten) (("2" (assert) nil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("3" (use kq4_step) (("3" (assert) nil nil)) nil))
        nil))
      nil))
    nil)
   ((kq4_step formula-decl nil tournamentSafe0 nil)
    (kq1_step formula-decl nil tournamentSafe0 nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (kq5_step formula-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (digit type-eq-decl nil ctrees nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (kq0_step formula-decl nil tournamentSafe0 nil)
    (kqall const-decl "bool" tournamentSafe0 nil))
   nil)
  (kqall_step-6 nil 3669529199
   ("" (expand "kqall")
    (("" (skosimp)
      (("" (split)
        (("1" (skolem!)
          (("1" (use kq0_step (p p!1 x x!1 y y!1))
            (("1" (use iq4_step (p p!1 x x!1 y y!1))
              (("1" (use kq5_step (p p!1 x x!1 y y!1))
                (("1" (inst?)
                  (("1" (flatten) (("1" (assert) nil nil)) nil)) nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (skolem!)
          (("2" (inst? -2)
            (("2" (use kq1_step)
              (("2" (assert)
                (("2" (expand "iqall")
                  (("2" (flatten)
                    (("2" (inst? -5)
                      (("2" (flatten) (("2" (assert) nil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("3" (use kq4_step) (("3" (assert) nil nil)) nil))
        nil))
      nil))
    nil)
   ((kq4_step formula-decl nil tournamentSafe0 nil)
    (kq1_step formula-decl nil tournamentSafe0 nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (iq4_step formula-decl nil tournamentSafe0 nil)
    (kq5_step formula-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (kq0_step formula-decl nil tournamentSafe0 nil)
    (kqall const-decl "bool" tournamentSafe0 nil))
   nil)
  (kqall_step-5 nil 3669364853
   ("" (expand "kqall")
    (("" (skosimp)
      (("" (split)
        (("1" (skolem!)
          (("1" (use kq0_step (p p!1 x x!1 y y!1))
            (("1" (use iq4_step (p p!1 x x!1 y y!1))
              (("1" (use kq3_step (p p!1 x x!1 y y!1))
                (("1" (inst?)
                  (("1" (flatten)
                    (("1" (assert)
                      (("1" (assert)
                        (("1" (expand "iqall")
                          (("1" (flatten)
                            (("1" (inst? -8) (("1" (assert) nil nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (skolem!)
          (("2" (inst? -2)
            (("2" (use kq1_step) (("2" (assert) nil nil)) nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((kq1_step formula-decl nil tournamentSafe0 nil)
    (iq4_step formula-decl nil tournamentSafe0 nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (kq0_step formula-decl nil tournamentSafe0 nil)
    (kqall const-decl "bool" tournamentSafe0 nil))
   nil)
  (kqall_step-4 nil 3669364060
   ("" (expand "kqall")
    (("" (skosimp)
      (("" (split)
        (("1" (skolem!)
          (("1" (use kq0_step (p p!1 x x!1 y y!1))
            (("1" (use iq4_step (p p!1 x x!1 y y!1))
              (("1" (inst?)
                (("1" (flatten) (("1" (assert) nil nil)) nil)) nil))
              nil))
            nil))
          nil)
         ("2" (skolem!)
          (("2" (inst? -2)
            (("2" (use kq1_step) (("2" (assert) nil nil)) nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((kqall const-decl "bool" tournamentSafe0 nil)
    (kq0_step formula-decl nil tournamentSafe0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil) (< const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (pred type-eq-decl nil defined_types nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (iq4_step formula-decl nil tournamentSafe0 nil)
    (kq1_step formula-decl nil tournamentSafe0 nil))
   nil)
  (kqall_step-3 nil 3669363995
   ("" (expand "kqall")
    (("" (skosimp)
      (("" (split)
        (("1" (skolem!)
          (("1" (use kq0_step (p p!1 x x!1 y y!1))
            (("1" (use kq1_step (p p!1 x x!1 y y!1))
              (("1" (inst?)
                (("1" (flatten)
                  (("1" (assert) (("1" (postpone) nil nil)) nil)) nil))
                nil)
               ("2" (postpone) nil nil))
              nil))
            nil))
          nil)
         ("2" (skolem!)
          (("2" (inst? -2)
            (("2" (use kq1_step) (("2" (assert) nil nil)) nil)) nil))
          nil))
        nil))
      nil))
    nil)
   nil nil)
  (kqall_step-2 nil 3669362083
   ("" (expand "kqall")
    (("" (skosimp)
      (("" (split)
        (("1" (skolem!)
          (("1" (use kq0_step (p p!1 x x!1 y y!1))
            (("1" (inst?) (("1" (assert) nil nil)) nil)) nil))
          nil)
         ("2" (skolem!)
          (("2" (inst? -2)
            (("2" (use kq1_step) (("2" (assert) nil nil)) nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((kq1_step formula-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (pred type-eq-decl nil defined_types nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (kq0_step formula-decl nil tournamentSafe0 nil)
    (kqall const-decl "bool" tournamentSafe0 nil))
   nil)
  (kqall_step-1 nil 3669355303
   ("" (expand "kqall")
    (("" (skosimp*)
      (("" (use kq0_step (p p!1 x x!1 y y!1))
        (("" (inst?) (("" (assert) nil nil)) nil)) nil))
      nil))
    nil)
   ((state type-eq-decl nil tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (pred type-eq-decl nil defined_types nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (kq0_step formula-decl nil tournamentSafe0 nil)
    (kqall const-decl "bool" tournamentSafe0 nil))
   shostak))
 (init_kqall 0
  (init_kqall-2 nil 3678606908
   ("" (expand "kqall")
    (("" (expand "init")
      (("" (skosimp)
        (("" (split)
          (("1" (skolem!)
            (("1" (inst?)
              (("1" (flatten)
                (("1" (expand "kq0")
                  (("1" (assert)
                    (("1" (expand "kq5")
                      (("1" (replaceh -5)
                        (("1" (expand "emptyset")
                          (("1" (propax) nil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (expand "kq1")
            (("2" (skosimp)
              (("2" (inst? -3) (("2" (assert) nil nil)) nil)) nil))
            nil)
           ("3" (expand "kq4")
            (("3" (use card_emptyset[node]) (("3" (assert) nil nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((init const-decl "bool" tournamentSafe0 nil)
    (node formal-nonempty-type-decl nil tournamentSafe0 nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (kq0 const-decl "bool" tournamentSafe0 nil)
    (kq5 const-decl "bool" tournamentSafe0 nil)
    (emptyset const-decl "set" sets nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (finite_emptyset name-judgement "finite_set" finite_sets nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (kq1 const-decl "bool" tournamentSafe0 nil)
    (card_emptyset formula-decl nil finite_sets nil)
    (kq4 const-decl "bool" tournamentSafe0 nil)
    (kqall const-decl "bool" tournamentSafe0 nil))
   nil)
  (init_kqall-1 nil 3669355370
   ("" (expand "kqall")
    (("" (expand "init")
      (("" (skosimp)
        (("" (split)
          (("1" (skolem!)
            (("1" (inst?)
              (("1" (flatten)
                (("1" (expand "kq0")
                  (("1" (assert)
                    (("1" (expand "iq4")
                      (("1" (assert)
                        (("1" (expand "kq5")
                          (("1" (replace -6)
                            (("1" (expand "emptyset")
                              (("1" (propax) nil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (expand "kq1")
            (("2" (skosimp)
              (("2" (inst? -3) (("2" (assert) nil nil)) nil)) nil))
            nil)
           ("3" (expand "kq4")
            (("3" (use card_emptyset[digseq]) (("3" (assert) nil nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((init const-decl "bool" tournamentSafe0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil) (< const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe0 nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (kq0 const-decl "bool" tournamentSafe0 nil)
    (kq5 const-decl "bool" tournamentSafe0 nil)
    (emptyset const-decl "set" sets nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (finite_emptyset name-judgement "finite_set" finite_sets nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (kq1 const-decl "bool" tournamentSafe0 nil)
    (card_emptyset formula-decl nil finite_sets nil)
    (kq4 const-decl "bool" tournamentSafe0 nil)
    (kqall const-decl "bool" tournamentSafe0 nil))
   shostak)))


$$$tournamentSafe1.pvs
% Wim H. Hesselink, May-August 2016
% Proofs for: Tournaments for mutual exclusion: 
% verification and concurrent complexity. 
% Part 3.  The invariants Lq* 

tournamentSafe1  [ degree: posnat, node: TYPE+ ] : THEORY
BEGIN
  IMPORTING tournamentSafe0[degree, node]

  x, y: VAR state
  p, q, r: VAR (thread)
  j, k, kk: VAR nat
  n: VAR node
  dig: VAR digit

  no_step15G: LEMMA % 
    x`mu(curnode(p, x)) = curbranch(p, x) 
    AND iqall(x) AND kqall(x) 
    IMPLIES x`level(p) < 0 

  mx_used: LEMMA
    13 <= x`pc(q) AND x`pc(q) <= 15 
    AND 13 <= x`pc(r) AND x`pc(r) <= 15 
    AND path(q, x`level(q)) = path(r, x`level(r))
    AND sib(q, x`level(q)) = sib(r, x`level(r))
    AND iqall(x) IMPLIES q = r

  lq0(q, x): bool =
    14 <= x`pc(q) AND x`pc(q) <= 15 IMPLIES 
      NOT x`prio(curnode(q, x), curbranch(q, x))(curbranch(q, x))

  lq2(n, dig, x): bool =
    x`cur(n)(dig) IMPLIES x`pc(x`bock(n, dig)) = 15 
    AND curnode(x`bock(n, dig), x) = n AND curbranch(x`bock(n, dig), x) = dig

  lq0_rest: LEMMA
    lq0(q, x) AND step(p, x, y) 
    IMPLIES lq0(q, y) OR step13(p, x, y)

  lq0_13: LEMMA % 
    lq0(q, x) AND step13(p, x, y) 
    AND iqall(x) % use mx_used
    AND lq2(curnode(q, x), curbranch(q, x), x)
    IMPLIES lq0(q, y)

  lq0_step: LEMMA
    lq0(q, x) AND step(p, x, y) 
    AND iqall(x)
    AND lq2(curnode(q, x), curbranch(q, x), x)
    IMPLIES lq0(q, y)

  lq1(q, x): bool = 
    x`pc(q) = 15 IMPLIES x`cur(curnode(q, x))(curbranch(q, x))

  lq1_rest: LEMMA % 
    lq1(q, x) AND step(p, x, y) 
    IMPLIES lq1(q, y) OR step15F(p, x, y) OR step15G(p, x, y) 

  lq1_15F: LEMMA
    lq1(q, x) AND step15F(p, x, y) AND iqall(x)
    IMPLIES lq1(q, y)

  lq1_15G: LEMMA
    lq1(q, x) AND step15G(p, x, y) AND iqall(x)
    IMPLIES lq1(q, y)

  lq1_step: LEMMA
    lq1(q, x) AND step(p, x, y)  AND iqall(x)
    IMPLIES lq1(q, y)

  lq2_step: LEMMA
    lq2(n, dig, x) AND step(p, x, y) 
    IMPLIES lq2(n, dig, y) 
  
  lqall(x): bool =
    (FORALL n, dig: lq2(n, dig, x))
    AND (FORALL q: lq1(q, x) AND lq0(q, x))

  lqall_step: LEMMA 
    lqall(x) AND step(p, x, y) AND iqall(x)
    IMPLIES lqall(y)

  init_lqall: LEMMA
    init(x) IMPLIES lqall(x)

  globinv(x): bool =
    iqall(x) AND kqall(x) AND lqall(x) 

  globinv_step: LEMMA
    globinv(x) AND step(p, x, y)
    IMPLIES globinv(y)

  init_globinv: LEMMA
    init(x) IMPLIES globinv(x)

END tournamentSafe1

$$$tournamentSafe1.prf
(tournamentSafe1
 (no_step15G 0
  (no_step15G-2 nil 3678801794
   ("" (skosimp)
    (("" (expand "curbranch")
      (("" (expand "curnode")
        (("" (assert)
          (("" (case "iq0(p!1, x!1)")
            (("1" (expand "iq0")
              (("1" (assert)
                (("1" (name-replace nn "path(p!1, x!1`level(p!1))" nil)
                  (("1" (case "kq1(nn, x!1)")
                    (("1" (expand "kq1")
                      (("1" (assert)
                        (("1" (flatten)
                          (("1" (name-replace jj "x!1`level(p!1)" nil)
                            (("1" (case "depth(nn)=jj")
                              (("1"
                                (replace -1)
                                (("1"
                                  (name-replace qq "x!1`occ(nn)")
                                  (("1"
                                    (case "iq5(qq, jj, x!1)")
                                    (("1"
                                      (expand "iq5")
                                      (("1"
                                        (assert)
                                        (("1"
                                          (replaceh -5)
                                          (("1"
                                            (replace -1)
                                            (("1"
                                              (assert)
                                              (("1"
                                                (case
                                                 "mx(p!1, qq, jj + 1, x!1)")
                                                (("1"
                                                  (expand "mx")
                                                  (("1"
                                                    (use joining_paths)
                                                    (("1"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (use mx_j_implied)
                                                  (("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (expand "iqall")
                                      (("2"
                                        (flatten)
                                        (("2"
                                          (inst? -10)
                                          (("2" (assert) nil nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("3" (assert) nil nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide-all-but (-5 -6) -)
                                (("2"
                                  (replace -1 + rl)
                                  (("2"
                                    (use depth_path)
                                    (("1" (assert) nil nil)
                                     ("2" (assert) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (expand "kqall")
                      (("2" (flatten) (("2" (inst? -6) nil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (expand "iqall")
              (("2" (flatten)
                (("2" (inst?) (("2" (assert) nil nil)) nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((curnode const-decl "node" tournamentSafe0 nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (digit type-eq-decl nil ctrees nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentSafe1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentSafe1 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (kq1 const-decl "bool" tournamentSafe0 nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (depth_path formula-decl nil ctrees nil)
    (iq5 const-decl "bool" tournamentSafe0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (mx const-decl "bool" tournamentSafe0 nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (joining_paths formula-decl nil ctrees nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (mx_j_implied formula-decl nil tournamentSafe0 nil)
    (jj skolem-const-decl "int" tournamentSafe1 nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (depth const-decl "nat" ctrees nil)
    (kqall const-decl "bool" tournamentSafe0 nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (path const-decl "node" ctrees nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (curbranch const-decl "digit" tournamentSafe0 nil))
   nil)
  (no_step15G-1 nil 3670064870
   ("" (skosimp)
    (("" (expand "curbranch")
      (("" (expand "curnode")
        (("" (assert)
          (("" (case "iq0(p!1, x!1)")
            (("1" (expand "iq0")
              (("1" (assert)
                (("1" (name-replace nn "take(x!1`level(p!1), p!1)" nil)
                  (("1" (case "kq1(nn, x!1)")
                    (("1" (expand "kq1")
                      (("1" (assert)
                        (("1" (flatten)
                          (("1" (name-replace jj "x!1`level(p!1)" nil)
                            (("1" (case "nn`length=jj")
                              (("1"
                                (replace -1)
                                (("1"
                                  (name-replace qq "x!1`occ(nn)")
                                  (("1"
                                    (case "iq5(qq, jj, x!1)")
                                    (("1"
                                      (expand "iq5")
                                      (("1"
                                        (assert)
                                        (("1"
                                          (replaceh -5)
                                          (("1"
                                            (replace -1)
                                            (("1"
                                              (use inductive_eq)
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (case
                                                   "mx(p!1, qq, jj + 1, x!1)")
                                                  (("1"
                                                    (expand "mx")
                                                    (("1"
                                                      (propax)
                                                      nil
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (use mx_j_implied)
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (expand "iqall")
                                      (("2"
                                        (flatten)
                                        (("2"
                                          (inst? -10)
                                          (("2" (assert) nil nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("3" (assert) nil nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide-all-but (-5 -6) -)
                                (("2"
                                  (replace -1 + rl)
                                  (("2"
                                    (expand "take")
                                    (("2"
                                      (expand "max")
                                      (("2"
                                        (assert)
                                        (("2"
                                          (expand "min")
                                          (("2" (propax) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (expand "kqall")
                      (("2" (flatten) (("2" (inst? -6) nil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (expand "iqall")
              (("2" (flatten)
                (("2" (inst?) (("2" (assert) nil nil)) nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((curbranch const-decl "digit" tournamentSafe0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (kqall const-decl "bool" tournamentSafe0 nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (mx_j_implied formula-decl nil tournamentSafe0 nil)
    (iq5 const-decl "bool" tournamentSafe0 nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (min const-decl "{p: real | p <= m AND p <= n}" real_defs nil)
    (int_min application-judgement "{k: int | k <= i AND k <= j}"
     real_defs nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (kq1 const-decl "bool" tournamentSafe0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil) (< const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe1 nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil))
   shostak))
 (mx_used 0
  (mx_used-1 nil 3678800879
   ("" (skosimp)
    ((""
      (case "iq0(q!1, x!1) AND iq0(r!1, x!1) AND iq1(q!1, x!1) 
AND iq1(r!1, x!1)")
      (("1" (flatten)
        (("1" (expand "iq0")
          (("1" (expand "iq1")
            (("1" (flatten)
              (("1" (assert)
                (("1" (use equal_paths)
                  (("1" (assert)
                    (("1" (use joining_paths)
                      (("1" (assert)
                        (("1"
                          (case "mx(q!1, r!1, 1+x!1`level(q!1), x!1)")
                          (("1" (expand "mx") (("1" (propax) nil nil))
                            nil)
                           ("2" (use mx_j_implied)
                            (("2" (assert) nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (expand "iqall")
        (("2" (flatten)
          (("2" (inst-cp - q!1)
            (("2" (inst - r!1)
              (("2" (flatten) (("2" (assert) nil nil)) nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((iq1 const-decl "bool" tournamentSafe0 nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (digit type-eq-decl nil ctrees nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentSafe1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (node formal-nonempty-type-decl nil tournamentSafe1 nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (equal_paths formula-decl nil ctrees nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (joining_paths formula-decl nil ctrees nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (mx const-decl "bool" tournamentSafe0 nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (mx_j_implied formula-decl nil tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (iqall const-decl "bool" tournamentSafe0 nil))
   shostak))
 (lq0_rest 0
  (lq0_rest-1 nil 3671258428
   ("" (skosimp)
    (("" (expand "step")
      (("" (assert)
        (("" (hide-all-but (1) +)
          (("" (split)
            (("1" (grind) nil nil) ("2" (grind) nil nil)
             ("3" (grind) nil nil) ("4" (grind) nil nil)
             ("5" (grind) nil nil) ("6" (grind) nil nil)
             ("7" (grind) nil nil) ("8" (grind) nil nil)
             ("9" (grind) nil nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((step const-decl "bool" tournamentSafe0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (empty? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (remove const-decl "set" sets nil)
    (p!1 skolem-const-decl "(thread)" tournamentSafe1 nil)
    (x!1 skolem-const-decl "state[degree, node]" tournamentSafe1 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (digit type-eq-decl nil ctrees nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (lq0 const-decl "bool" tournamentSafe1 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe1 nil)
    (node formal-nonempty-type-decl nil tournamentSafe1 nil))
   shostak))
 (lq0_13 0
  (lq0_13-2 nil 3678801121
   ("" (expand "step13")
    (("" (expand "lq0")
      (("" (skosimp)
        (("" (expand "next13")
          (("" (case "q!1=p!1")
            (("1" (replaceh -1)
              (("1" (assert)
                (("1" (expand "curnode")
                  (("1" (expand "curbranch")
                    (("1" (replaceh -2)
                      (("1" (assert)
                        (("1" (expand "lq2")
                          (("1"
                            (name-replace bk
                             "x!1`bock(path(p!1, x!1`level(p!1)), sib(p!1, x!1`level(p!1)))")
                            (("1" (flatten)
                              (("1"
                                (expand "curnode")
                                (("1"
                                  (expand "curbranch")
                                  (("1"
                                    (use mx_used)
                                    (("1" (assert) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (assert)
              (("2" (replaceh -1)
                (("2" (assert)
                  (("2" (expand "curnode")
                    (("2" (expand "curbranch")
                      (("2" (lift-if)
                        (("2" (assert)
                          (("2" (split -)
                            (("1" (flatten)
                              (("1"
                                (case
                                 "iq0(p!1, x!1) AND iq0(q!1, x!1) AND iq1(p!1, x!1)
            AND iq1(q!1, x!1)")
                                (("1"
                                  (flatten)
                                  (("1"
                                    (expand "iq0")
                                    (("1"
                                      (expand "iq1")
                                      (("1"
                                        (flatten)
                                        (("1"
                                          (use equal_paths)
                                          (("1"
                                            (assert)
                                            (("1"
                                              (use joining_paths)
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (case
                                                   "mx(p!1, q!1, 1+ x!1`level(q!1), x!1)")
                                                  (("1"
                                                    (expand "mx")
                                                    (("1"
                                                      (propax)
                                                      nil
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (use mx_j_implied)
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2" (assert) nil nil)
                                           ("3" (assert) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (expand "iqall")
                                  (("2"
                                    (flatten)
                                    (("2"
                                      (inst-cp - p!1)
                                      (("2"
                                        (inst - q!1)
                                        (("2"
                                          (flatten)
                                          (("2" (assert) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (propax) nil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((lq0 const-decl "bool" tournamentSafe1 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (equal_paths formula-decl nil ctrees nil)
    (p!1 skolem-const-decl "(thread)" tournamentSafe1 nil)
    (q!1 skolem-const-decl "(thread)" tournamentSafe1 nil)
    (x!1 skolem-const-decl "state[degree, node]" tournamentSafe1 nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (joining_paths formula-decl nil ctrees nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (mx const-decl "bool" tournamentSafe0 nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (mx_j_implied formula-decl nil tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (iq1 const-decl "bool" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (lq2 const-decl "bool" tournamentSafe1 nil)
    (mx_used formula-decl nil tournamentSafe1 nil)
    (sib const-decl "digit" ctrees nil)
    (path const-decl "node" ctrees nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (digit type-eq-decl nil ctrees nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (node formal-nonempty-type-decl nil tournamentSafe1 nil)
    (boolean nonempty-type-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe1 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil))
   nil)
  (lq0_13-1 nil 3671261990
   ("" (expand "step13")
    (("" (expand "lq0")
      (("" (skosimp)
        (("" (expand "next13")
          (("" (case "q!1=p!1")
            (("1" (replaceh -1)
              (("1" (assert)
                (("1" (expand "curnode")
                  (("1" (expand "curbranch")
                    (("1" (replaceh -2)
                      (("1" (assert)
                        (("1" (expand "lq2")
                          (("1"
                            (name-replace bk
                             "x!1`bock(path(p!1, x!1`level(p!1)), sib(p!1, x!1`level(p!1)))")
                            (("1" (flatten)
                              (("1"
                                (expand "curnode")
                                (("1"
                                  (expand "curbranch")
                                  (("1"
                                    (case
                                     "iq0(p!1, x!1) AND iq0(bk, x!1) AND iq1(p!1, x!1) 
AND iq1(bk, x!1)")
                                    (("1"
                                      (flatten)
                                      (("1"
                                        (expand "iq0")
                                        (("1"
                                          (expand "iq1")
                                          (("1"
                                            (flatten)
                                            (("1"
                                              (assert)
                                              (("1"
                                                (use equal_paths)
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (use joining_paths)
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (case
                                                         "mx(p!1, bk, 1 + x!1`level(bk), x!1)")
                                                        (("1"
                                                          (expand "mx")
                                                          (("1"
                                                            (propax)
                                                            nil
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (use
                                                           mx_j_implied)
                                                          (("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (expand "iqall")
                                      (("2"
                                        (flatten)
                                        (("2"
                                          (inst-cp - p!1)
                                          (("2"
                                            (inst - bk)
                                            (("2"
                                              (flatten)
                                              (("2" (assert) nil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (assert)
              (("2" (replaceh -1)
                (("2" (assert)
                  (("2" (expand "curnode")
                    (("2" (expand "curbranch")
                      (("2" (lift-if)
                        (("2" (assert)
                          (("2" (split -)
                            (("1" (flatten)
                              (("1"
                                (case
                                 "iq0(p!1, x!1) AND iq0(q!1, x!1) AND iq1(p!1, x!1) 
AND iq1(q!1, x!1)")
                                (("1"
                                  (flatten)
                                  (("1"
                                    (expand "iq0")
                                    (("1"
                                      (expand "iq1")
                                      (("1"
                                        (flatten)
                                        (("1"
                                          (use equal_paths)
                                          (("1"
                                            (assert)
                                            (("1"
                                              (use joining_paths)
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (case
                                                   "mx(p!1, q!1, 1+ x!1`level(q!1), x!1)")
                                                  (("1"
                                                    (expand "mx")
                                                    (("1"
                                                      (propax)
                                                      nil
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (use mx_j_implied)
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2" (assert) nil nil)
                                           ("3" (assert) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (expand "iqall")
                                  (("2"
                                    (flatten)
                                    (("2"
                                      (inst-cp - p!1)
                                      (("2"
                                        (inst - q!1)
                                        (("2"
                                          (flatten)
                                          (("2" (assert) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (propax) nil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((lq0 const-decl "bool" tournamentSafe1 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (lq2 const-decl "bool" tournamentSafe1 nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (mx_j_implied formula-decl nil tournamentSafe0 nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (iq1 const-decl "bool" tournamentSafe0 nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (node formal-nonempty-type-decl nil tournamentSafe1 nil)
    (boolean nonempty-type-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe1 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil))
   shostak))
 (lq0_step 0
  (lq0_step-2 nil 3678795894
   ("" (skosimp)
    (("" (use lq0_rest (y y!1))
      (("" (use lq0_13 (y y!1)) (("" (assert) nil nil)) nil)) nil))
    nil)
   ((lq0_rest formula-decl nil tournamentSafe1 nil)
    (node formal-nonempty-type-decl nil tournamentSafe1 nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe1 nil)
    (digit type-eq-decl nil ctrees nil) (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (lq0_13 formula-decl nil tournamentSafe1 nil))
   nil)
  (lq0_step-1 nil 3671262307
   ("" (skosimp)
    (("" (use lq0_rest (y y!1))
      (("" (use lq0_13 (y y!1)) (("" (assert) nil nil)) nil)) nil))
    nil)
   ((lq0_rest formula-decl nil tournamentSafe1 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil) (< const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe1 nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (lq0_13 formula-decl nil tournamentSafe1 nil))
   shostak))
 (lq1_rest 0
  (lq1_rest-1 nil 3678796249
   ("" (skosimp)
    (("" (expand "step")
      (("" (assert)
        (("" (hide-all-but (1) +)
          (("" (split)
            (("1" (grind) nil nil) ("2" (grind) nil nil)
             ("3" (grind) nil nil) ("4" (grind) nil nil)
             ("5" (grind) nil nil) ("6" (grind) nil nil)
             ("7" (grind) nil nil) ("8" (grind) nil nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((step const-decl "bool" tournamentSafe0 nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (add const-decl "(nonempty?)" sets nil)
    (member const-decl "bool" sets nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (lq1 const-decl "bool" tournamentSafe1 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe1 nil)
    (node formal-nonempty-type-decl nil tournamentSafe1 nil))
   shostak))
 (lq1_15F 0
  (lq1_15F-3 nil 3671264104
   ("" (expand "step15F")
    (("" (expand "lq1")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "next15")
            (("" (expand curnode)
              (("" (case "q!1=p!1")
                (("1" (assert) nil nil)
                 ("2" (assert)
                  (("2" (expand "curbranch")
                    (("2" (lift-if)
                      (("2" (assert)
                        (("2" (split)
                          (("1" (flatten)
                            (("1" (expand "remove")
                              (("1"
                                (expand "member")
                                (("1"
                                  (assert)
                                  (("1"
                                    (flatten)
                                    (("1"
                                      (use mx_used)
                                      (("1" (assert) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (propax) nil nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((lq1 const-decl "bool" tournamentSafe1 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (remove const-decl "set" sets nil)
    (mx_used formula-decl nil tournamentSafe1 nil)
    (digit type-eq-decl nil ctrees nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (member const-decl "bool" sets nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (node formal-nonempty-type-decl nil tournamentSafe1 nil)
    (boolean nonempty-type-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe1 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (step15F const-decl "bool" tournamentSafe0 nil))
   nil)
  (lq1_15F-2 nil 3671263854
   ("" (expand "step15F")
    (("" (expand "lq1")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "next15")
            (("" (expand curnode)
              (("" (case "q!1=p!1")
                (("1" (assert) nil nil)
                 ("2" (assert)
                  (("2"
                    (case "curnode(p!1, x!1)= take(x!1`level(q!1), q!1)")
                    (("1" (assert)
                      (("1" (expand "remove")
                        (("1" (expand "member")
                          (("1" (assert)
                            (("1"
                              (case "take(x!1`level(q!1), q!1) = take(x!1`level(p!1), p!1)")
                              (("1" (assert) nil nil)
                               ("2" (assert) nil nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (assert)
                      (("2" (expand "curnode") (("2" (assert) nil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((step15F const-decl "bool" tournamentSafe0 nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (degree formal-const-decl "posnat" tournamentSafe1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (remove const-decl "set" sets nil)
    (member const-decl "bool" sets nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (lq1 const-decl "bool" tournamentSafe1 nil))
   nil)
  (lq1_15F-1 nil 3669885247
   ("" (expand "step15F")
    (("" (expand "lq1")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "next15")
            (("" (case "q!1=p!1")
              (("1" (assert) nil nil)
               ("2" (assert)
                (("2"
                  (case "curnode(p!1, x!1)= take(x!1`level(q!1), q!1)")
                  (("1" (assert)
                    (("1" (expand "remove")
                      (("1" (expand "member") (("1" (assert) nil nil))
                        nil))
                      nil))
                    nil)
                   ("2" (assert) nil nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (degree formal-const-decl "posnat" tournamentSafe1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (remove const-decl "set" sets nil)
    (member const-decl "bool" sets nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (step15F const-decl "bool" tournamentSafe0 nil))
   shostak))
 (lq1_15G 0
  (lq1_15G-2 nil 3671264007
   ("" (expand "step15G")
    (("" (expand "lq1")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "next15")
            (("" (expand curnode)
              (("" (case "q!1=p!1")
                (("1" (assert) nil nil)
                 ("2" (assert)
                  (("2" (expand "curbranch")
                    (("2" (lift-if)
                      (("2" (assert)
                        (("2" (split)
                          (("1" (flatten)
                            (("1" (expand "remove")
                              (("1"
                                (expand "member")
                                (("1"
                                  (assert)
                                  (("1"
                                    (flatten)
                                    (("1"
                                      (use mx_used)
                                      (("1" (assert) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (propax) nil nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((lq1 const-decl "bool" tournamentSafe1 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (remove const-decl "set" sets nil)
    (mx_used formula-decl nil tournamentSafe1 nil)
    (digit type-eq-decl nil ctrees nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (member const-decl "bool" sets nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (node formal-nonempty-type-decl nil tournamentSafe1 nil)
    (boolean nonempty-type-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe1 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil))
   nil)
  (lq1_15G-1 nil 3669885347
   ("" (expand "step15G")
    (("" (expand "lq1")
      (("" (skosimp)
        (("" (replaceh -2)
          (("" (expand "next15")
            (("" (case "q!1=p!1")
              (("1" (assert) nil nil)
               ("2" (assert)
                (("2"
                  (case "curnode(p!1, x!1)=take(x!1`level(q!1), q!1)")
                  (("1" (assert)
                    (("1" (expand "remove")
                      (("1" (expand "member") (("1" (assert) nil nil))
                        nil))
                      nil))
                    nil)
                   ("2" (assert) nil nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (degree formal-const-decl "posnat" tournamentSafe1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (remove const-decl "set" sets nil)
    (member const-decl "bool" sets nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil))
   shostak))
 (lq1_step 0
  (lq1_step-2 nil 3669885705
   ("" (skosimp)
    (("" (use lq1_rest (y y!1))
      (("" (use lq1_15F (y y!1))
        (("" (use lq1_15G (y y!1)) (("" (assert) nil nil)) nil)) nil))
      nil))
    nil)
   ((lq1_rest formula-decl nil tournamentSafe1 nil)
    (node formal-nonempty-type-decl nil tournamentSafe1 nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe1 nil)
    (digit type-eq-decl nil ctrees nil) (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (lq1_15G formula-decl nil tournamentSafe1 nil)
    (lq1_15F formula-decl nil tournamentSafe1 nil))
   nil)
  (lq1_step-1 nil 3669885622
   ("" (skosimp)
    (("" (use lq1_11 (y y!1))
      (("" (use lq1_12 (y y!1))
        (("" (use lq1_13 (y y!1))
          (("" (use lq1_14 (y y!1))
            (("" (use lq1_15F (y y!1))
              (("" (use lq1_15G (y y!1))
                (("" (use lq1_16 (y y!1))
                  (("" (use lq1_17 (y y!1))
                    (("" (use lq1_18 (y y!1))
                      (("" (use lq1_19 (y y!1))
                        (("" (postpone) nil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   nil shostak))
 (lq2_step 0
  (lq2_step-2 nil 3669884824
   ("" (skosimp)
    (("" (expand "step")
      (("" (assert)
        (("" (split)
          (("1" (grind) nil nil) ("2" (grind) nil nil)
           ("3" (grind) nil nil) ("4" (grind) nil nil)
           ("5" (grind) nil nil) ("6" (grind) nil nil)
           ("7" (grind) nil nil) ("8" (grind) nil nil)
           ("9" (grind) nil nil) ("10" (grind) nil nil))
          nil))
        nil))
      nil))
    nil)
   ((step const-decl "bool" tournamentSafe0 nil)
    (node formal-nonempty-type-decl nil tournamentSafe1 nil)
    (degree formal-const-decl "posnat" tournamentSafe1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (lq2 const-decl "bool" tournamentSafe1 nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (member const-decl "bool" sets nil)
    (add const-decl "(nonempty?)" sets nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (p!1 skolem-const-decl "(thread)" tournamentSafe1 nil)
    (x!1 skolem-const-decl "state[degree, node]" tournamentSafe1 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (digit type-eq-decl nil ctrees nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (remove const-decl "set" sets nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (empty? const-decl "bool" sets nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil))
   nil)
  (lq2_step-1 nil 3669884671
   ("" (skosimp)
    (("" (expand "step")
      (("" (use lq2_11 (y y!1))
        (("" (use lq2_12 (y y!1))
          (("" (use lq2_13 (y y!1))
            (("" (use lq2_14 (y y!1))
              (("" (use lq2_15F (y y!1))
                (("" (use lq2_15G (y y!1))
                  (("" (use lq2_16 (y y!1))
                    (("" (use lq2_17 (y y!1))
                      (("" (use lq2_18 (y y!1))
                        (("" (assert) (("" (postpone) nil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   nil shostak))
 (lqall_step 0
  (lqall_step-3 nil 3671264301
   ("" (skosimp)
    (("" (expand lqall +)
      (("" (split)
        (("1" (skolem!)
          (("1" (use lq2_step (p p!1 x x!1 y y!1))
            (("1" (assert)
              (("1" (expand "lqall")
                (("1" (flatten) (("1" (inst?) nil nil)) nil)) nil))
              nil))
            nil))
          nil)
         ("2" (skolem!)
          (("2" (use lq1_step (p p!1 x x!1 y y!1))
            (("2" (use lq0_step (p p!1 x x!1 y y!1))
              (("2" (assert)
                (("2" (expand "lqall")
                  (("2" (flatten)
                    (("2" (inst? -4)
                      (("2" (flatten)
                        (("2" (assert)
                          (("2" (assert) (("2" (inst?) nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((lqall const-decl "bool" tournamentSafe1 nil)
    (lq0_step formula-decl nil tournamentSafe1 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (lq1_step formula-decl nil tournamentSafe1 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (digit type-eq-decl nil ctrees nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentSafe1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentSafe1 nil)
    (lq2_step formula-decl nil tournamentSafe1 nil))
   nil)
  (lqall_step-2 nil 3670216948
   ("" (skosimp)
    (("" (expand lqall +)
      (("" (split)
        (("1" (skolem!)
          (("1" (use lq2_step (p p!1 x x!1 y y!1))
            (("1" (assert)
              (("1" (expand "lqall")
                (("1" (flatten) (("1" (inst?) nil nil)) nil)) nil))
              nil))
            nil))
          nil)
         ("2" (skolem!)
          (("2" (use lq3_step (p p!1 x x!1 y y!1))
            (("2" (use lq4_step (p p!1 x x!1 y y!1))
              (("2" (assert)
                (("2" (expand "lqall")
                  (("2" (flatten)
                    (("2" (inst? -4)
                      (("2" (flatten) (("2" (assert) nil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("3" (use lq2_step (p p!1 x x!1 y y!1))
          (("3" (assert)
            (("3" (use prio_in15_implied)
              (("3" (assert)
                (("3" (expand "lqall")
                  (("3" (flatten)
                    (("3" (assert) (("3" (inst?) nil nil)) nil)) nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("4" (skolem!)
          (("4" (use lq1_step (p p!1 x x!1 y y!1))
            (("4" (assert)
              (("4" (expand "lqall")
                (("4" (flatten) (("4" (inst? -4) nil nil)) nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((lq1_step formula-decl nil tournamentSafe1 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentSafe1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (lq2_step formula-decl nil tournamentSafe1 nil))
   nil)
  (lqall_step-1 nil 3670127604
   ("" (expand "lqall")
    (("" (skosimp)
      (("" (split)
        (("1" (skolem!)
          (("1" (use lq2_step (p p!1 x x!1 y y!1))
            (("1" (inst?) (("1" (assert) nil nil)) nil)) nil))
          nil)
         ("2" (skolem!)
          (("2" (use lq3_step (p p!1 x x!1 y y!1))
            (("2" (inst? -3)
              (("2" (flatten)
                (("2" (assert)
                  (("2" (use lq4_step (p p!1 x x!1 y y!1))
                    (("2" (assert) nil nil)) nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("3" (use lq2_step (p p!1 x x!1 y y!1))
          (("3" (assert)
            (("3" (use prio_in15_implied)
              (("3" (split)
                (("1" (assert) (("1" (inst?) nil nil)) nil)
                 ("2" (expand "lqall") (("2" (replaceh -1) nil nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((curnode const-decl "node" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentSafe1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (lq2_step formula-decl nil tournamentSafe1 nil))
   shostak))
 (init_lqall 0
  (init_lqall-2 nil 3671264418
   ("" (expand "init")
    (("" (expand "lqall")
      (("" (skosimp)
        (("" (split)
          (("1" (skolem!)
            (("1" (expand "lq2")
              (("1" (flatten)
                (("1" (inst? -3)
                  (("1" (flatten)
                    (("1" (hide-all-but (-1 -4))
                      (("1" (grind) nil nil)) nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (skolem!)
            (("2" (inst?)
              (("2" (flatten)
                (("2" (expand "lq1")
                  (("2" (assert)
                    (("2" (expand "lq0")
                      (("2" (expand "empty?")
                        (("2" (expand "member") (("2" (inst?) nil nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((lqall const-decl "bool" tournamentSafe1 nil)
    (lq2 const-decl "bool" tournamentSafe1 nil)
    (node formal-nonempty-type-decl nil tournamentSafe1 nil)
    (digit type-eq-decl nil ctrees nil)
    (degree formal-const-decl "posnat" tournamentSafe1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (empty? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil) (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (lq1 const-decl "bool" tournamentSafe1 nil)
    (lq0 const-decl "bool" tournamentSafe1 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (finite_emptyset name-judgement "finite_set" finite_sets nil)
    (init const-decl "bool" tournamentSafe0 nil))
   nil)
  (init_lqall-1 nil 3670127952
   ("" (expand "init")
    (("" (expand "lqall")
      (("" (skosimp)
        (("" (split)
          (("1" (skolem!)
            (("1" (expand "lq2")
              (("1" (flatten)
                (("1" (inst? -3)
                  (("1" (flatten)
                    (("1" (hide-all-but (-1 -4))
                      (("1" (grind) nil nil)) nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (skolem!)
            (("2" (hide -2 -3)
              (("2" (inst?)
                (("2" (flatten)
                  (("2" (expand "empty?")
                    (("2" (expand "member")
                      (("2" (inst - r!1)
                        (("2" (expand "lq3")
                          (("2" (assert)
                            (("2" (expand "lq4")
                              (("2" (propax) nil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("3" (expand "lq2")
            (("3" (expand "well_founded?")
              (("3" (skosimp*)
                (("3" (inst + y!1)
                  (("3" (skosimp)
                    (("3" (expand "prior")
                      (("3" (inst?)
                        (("3" (flatten)
                          (("3" (hide-all-but (-2 -5))
                            (("3" (grind) nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("4" (skolem!)
            (("4" (expand "lq1")
              (("4" (inst?)
                (("4" (flatten) (("4" (assert) nil nil)) nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil) (< const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentSafe1 nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (empty? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (well_founded? const-decl "bool" orders nil)
    (pred type-eq-decl nil defined_types nil)
    (init const-decl "bool" tournamentSafe0 nil))
   shostak))
 (globinv_step 0
  (globinv_step-1 nil 3670133139
   ("" (expand "globinv")
    (("" (skosimp)
      (("" (use iqall_step)
        (("" (use kqall_step)
          (("" (use lqall_step) (("" (assert) nil nil)) nil)) nil))
        nil))
      nil))
    nil)
   ((kqall_step formula-decl nil tournamentSafe0 nil)
    (lqall_step formula-decl nil tournamentSafe1 nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (digit type-eq-decl nil ctrees nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (node formal-nonempty-type-decl nil tournamentSafe1 nil)
    (degree formal-const-decl "posnat" tournamentSafe1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (iqall_step formula-decl nil tournamentSafe0 nil)
    (globinv const-decl "bool" tournamentSafe1 nil))
   shostak))
 (init_globinv 0
  (init_globinv-1 nil 3670133170
   ("" (expand "globinv")
    (("" (skosimp)
      (("" (use init_iqall)
        (("" (use init_kqall)
          (("" (use init_lqall) (("" (assert) nil nil)) nil)) nil))
        nil))
      nil))
    nil)
   ((init_kqall formula-decl nil tournamentSafe0 nil)
    (init_lqall formula-decl nil tournamentSafe1 nil)
    (digit type-eq-decl nil ctrees nil) (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (node formal-nonempty-type-decl nil tournamentSafe1 nil)
    (degree formal-const-decl "posnat" tournamentSafe1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (init_iqall formula-decl nil tournamentSafe0 nil)
    (globinv const-decl "bool" tournamentSafe1 nil))
   shostak)))


$$$tournamentUnity0.pvs
% Wim H. Hesselink, May-August 2016
% Proofs for: Tournaments for mutual exclusion: 
% verification and concurrent complexity. 
% Part 4.  Individual progress

tournamentUnity0[ degree: posnat, node: TYPE+ ]: THEORY % 
BEGIN
  IMPORTING tournamentSafe1[degree, node], intsum, bdUnity[state]

  Thread: TYPE = (thread)

  p, q, r: VAR Thread
  x, y: VAR state

  degree_gt_1: AXIOM 
    degree > 1

  D: posnat % duration of doorway in MXd
  W: posnat % duration of waiting section in MXd
  exi: posnat % duration of exit in MXd
  cs: posnat % duration of critical section 
% positive for the sake of the covering theorem 
  exi1: posnat = exi + 1

  i, n, k, kk, m: VAR nat
  b: VAR bool
  se: VAR finite_set[Thread]
  z: VAR int
  nn: VAR node

  step(x, y): bool =
    x = y OR EXISTS p: step(p, x, y)

  sinc(x): int = %
    LET g = LAMBDA n: IF n < N THEN x`cnt(enum_thread(n)) ELSE 0 ENDIF
    IN sum(N, g)

  competing_leq(kk)(x): bool = % 
    card(x`competing) <= kk

  allidle(x): bool =
    FORALL q: x`pc(q) = 11 

%%%%%%%  Individual progress   %%%%%%%

  forward1(p)(x, y): bool =
    step12(p, x, y) OR step17(p, x, y) OR step19(p, x, y) 

  enabled1(q)(x): bool =
    x`pc(q) = 12 OR x`pc(q) = 17 OR x`pc(q) = 19

  enabled1_necessary: LEMMA
    forward1(q)(x, y) IMPLIES enabled1(q)(x)

  enabled1_sufficient: LEMMA % 
    enabled1(q)(x) IMPLIES EXISTS y: forward1(q)(x, y)

  E1: specification[state] = (#
    inv := globinv,
    step := step,
    fwd := LAMBDA i: IF i < N THEN forward1(enum_thread(i)) 
                     ELSE emptyset ENDIF
  #)

  enabled_E1: LEMMA
    E1`inv(x) IMPLIES enabled(E1)(i)(x) 
    = (i < N AND enabled1(enum_thread(i))(x))

  good_E1: LEMMA
    good(E1)

  at(q, k)(x): bool =
    x`pc(q) = k 

  between(q, i, k)(x): bool =
    i <= x`pc(q) AND x`pc(q) <= k 

  out(q)(x): bool =
    x`pc(q) = 17 AND x`level(q) = depth(q) - 1

  out_to19: LEMMA % ensures
    leto(E1)(1, out(q), at(q, 19))

  from19to11: LEMMA % ensures
    leto(E1)(1, at(q, 19), at(q, 11))

  out_to11: LEMMA
    leto(E1)(2, out(q), at(q, 11))

  ass_exit: bool =
    FORALL q: leto(E1)(exi, fullset, neg(at(q, 18)))

  ass_cs: bool =
    FORALL q: leto(E1)(cs, fullset, neg(at(q, 16)))

  atlev(q, m, z)(x): bool =
    x`pc(q) = m AND x`level(q) = z

  leveq_betw(q, i, m, k)(x): bool =
    i <= x`pc(q) AND x`pc(q) <= m AND x`level(q) = k 

  from17to18: LEMMA % 
    z < depth(q) - 1 IMPLIES 
      leto(E1)(1, atlev(q, 17, z), atlev(q, 18, z))

  from18to17: LEMMA % 
    ass_exit IMPLIES 
      leto(E1)(exi, atlev(q, 18, z), atlev(q, 17, z + 1))

  from17to17: LEMMA
    ass_exit AND z < depth(q) - 1 IMPLIES 
      leto(E1)(exi1, atlev(q, 17, z), atlev(q, 17, z + 1))

  levleq(q, k)(x): bool = % RENAME levless
    x`level(q) < k AND 12 <= x`pc(q) AND x`pc(q) <= 18

  from12Eto16: LEMMA % 
    leto(E1)(1, atlev(q, 12, -1), atlev(q, 16, -1))

  from16to17: LEMMA % 
    ass_cs IMPLIES 
      leto(E1)(cs, atlev(q, 16, -1), atlev(q, 17, -1))

  levleq_0_out: LEMMA % 
    ass_exit AND ass_cs AND depth(q) > 0 IMPLIES
      leto(E1)(exi + cs + 2, levleq(q, 0), atlev(q, 17, 0))

  levleq_to_out(k, m): bool = % induction hypothesis 
    FORALL q: k < depth(q) IMPLIES 
      leto(E1)(m, levleq(q, k), atlev(q, 17, k))
% NB needed for all threads q, for the sake of at15levri_down 

  mubot(nn)(x): bool =
    x`mu(nn) = -1 

  occ(q, nn)(x): bool =
    x`level(q) < depth(nn) AND nn = path(q, depth(nn)) 
    AND depth(nn) < depth(q) 

  occ_unless_mubot: LEMMA
    unless(E1)(occ(q, nn), mubot(nn))

  mu_to_bot: LEMMA %
    depth(nn) = k AND levleq_to_out(k, m) 
    IMPLIES leto(E1)(m, fullset, mubot(nn))

  inbranches(nn, x): finite_set[Thread] =  % fan(nn)
    { q | x`level(q) <= depth(nn) AND depth(nn) < depth(q) 
          AND path(q, depth(nn)) = nn }

  card_inbranches: LEMMA % uses MXN 
    globinv(x) IMPLIES 
      card(inbranches(nn, x)) <= degree

  cprio(q, x): finite_set[Thread] =
    { r | curnode(r, x) = curnode(q, x) 
          AND NOT x`prio(curnode(r, x), curbranch(r, x))(curbranch(q, x))
          AND 14 <= x`pc(r) AND x`pc(r) <= 15 }

  cprio_sub_inbranches: LEMMA % uses iq0 and iq1 
    x`pc(q) = 15 AND cprio(q, x)(r) AND globinv(x)
    IMPLIES inbranches(curnode(q, x), x)(r)

  level_cprio: LEMMA % 
    cprio(q, x)(r) AND x`pc(q) = 15 AND globinv(x) 
    IMPLIES x`level(r) = x`level(q) AND x`level(q) < depth(r) 

  cprio_shrinks_at15: LEMMA % 
    x`pc(q) = 15 AND cprio(q, y)(r) AND step(p, x, y) 
    AND iqall(x) AND lq1(q, x)
    IMPLIES cprio(q, x)(r) OR q = p 

  card_cprio_shrinks: LEMMA % 
    x`pc(q) = 15 AND step(p, x, y) AND globinv(x) 
    IMPLIES card(cprio(q, y)) <= card(cprio(q, x)) OR q = p

  card_cprio: LEMMA % uses card_inbranches, cprio_sub_inbranches
    x`pc(q) = 15 AND globinv(x) 
    IMPLIES card(cprio(q, x)) <= degree 

  card_cprio_mu: LEMMA % 
    x`pc(q) = 15 AND x`mu(curnode(q, x)) >= 0 AND globinv(x) 
    IMPLIES card(cprio(q, x)) < degree 

  at15levpri(q, k, m)(x): bool =
    x`pc(q) = 15 AND x`level(q) = k AND card(cprio(q, x)) <= m

  ass_waiting: bool = % 
    FORALL q, k: leto(E1)(W, atlev(q, 15, k), neg(mubot(path(q, k))) )

  at15levpri_unless: LEMMA % use mx_used
       unless(E1)(cap(at15levpri(q, k, m+1), mubot(path(q, k))),
    		cup(at15levpri(q, k, m), atlev(q, 12, k-1)) )

  leadsto_at15levpri: LEMMA  % 
    ass_waiting IMPLIES 
       leto(E1)(W, cap(at15levpri(q, k, m+1), mubot(path(q, k))),
    		cup(at15levpri(q, k, m), atlev(q, 12, k-1)) )

  unless_mubot: LEMMA 
    unless(E1)(at15levpri(q, k, i+1), 
               cap(at15levpri(q, k, i+1), mubot(path(q, k))) )

  at15_mubot: LEMMA % 
    levleq_to_out(k, m) IMPLIES 
      leto(E1)(m, at15levpri(q, k, i+1), 
    	       cap(at15levpri(q, k, i+1), mubot(path(q, k))) )

  at15levpri_down: LEMMA % 
    levleq_to_out(k, m) AND ass_waiting IMPLIES 
      leto(E1)(m + W, at15levpri(q, k, i+1), 
    	       cup(at15levpri(q, k, i), atlev(q, 12, k - 1)) )

  at15levpri_induct: LEMMA % use lq0 for the base case 
    levleq_to_out(k, m) AND ass_waiting  IMPLIES 
      leto(E1)(i * (m + W), at15levpri(q, k, i), 
    	       atlev(q, 12, k - 1) )

  degW(m): nat = % 
     (degree - 1) * (W + m)

  at15levpri_degree: LEMMA % 
  % use at15levpri_induct and leadsto_at15levpri
    levleq_to_out(k, m) AND ass_waiting  IMPLIES 
      leto(E1)(degW(m) + W, at15levpri(q, k, degree), 
    	       atlev(q, 12, k - 1) )

  atlev15_to12: LEMMA % 
    levleq_to_out(k, m) AND ass_waiting  IMPLIES 
      leto(E1)(degW(m) + W, atlev(q, 15, k), 
    	       atlev(q, 12, k - 1) )

  ass_doorway: bool =
    FORALL q: 
      leto(E1)(D, fullset, neg(between(q, 13, 14)))

  ass_doorway_extended: LEMMA % 
    ass_doorway  IMPLIES 
      leto(E1)(D + 1, leveq_betw(q, 12, 15, k), atlev(q, 15, k))

  level_step: LEMMA % 
    levleq_to_out(k, m) AND ass_waiting AND ass_doorway  IMPLIES 
      leto(E1)((D + 1) + degree * (m + W), leveq_betw(q, 12, 15, k), 
      	       atlev(q, 17, k) )

  level_step_1: LEMMA % 
    levleq_to_out(k, m) AND ass_waiting AND ass_doorway AND ass_exit
    AND k < depth(q) - 1 
    IMPLIES 
      leto(E1)((D + 1) + degree * (m + W) + exi1, leveq_betw(q, 12, 18, k), 
      	       atlev(q, 17, k + 1) )

  level_step_2: LEMMA % 
    levleq_to_out(k, m) AND ass_waiting AND ass_doorway AND ass_exit
    AND k = depth(q) - 1 
    IMPLIES 
      leto(E1)((D + 1) + degree * (m + W), leveq_betw(q, 12, 18, k), 
      	       atlev(q, 17, k) )

  addend: posnat = D + 1 + degree * W + exi1

  levleq_to_out_step: LEMMA % 
    levleq_to_out(k, m) AND ass_waiting AND ass_doorway AND ass_exit
    IMPLIES levleq_to_out(k + 1, degree * m + addend)

  fun(k): RECURSIVE nat = % 
    IF k = 0 THEN cs + exi + 2
    ELSE degree * fun(k - 1) + addend ENDIF 
    MEASURE k

  power(k, z): RECURSIVE int =
    IF k = 0 THEN 1 ELSE z * power(k-1, z) ENDIF 
    MEASURE k 

  fun_eq: LEMMA
     fun(k) = power(k, degree) 
     * (cs + exi + 2 + addend / (degree-1)) - addend / (degree-1)

  levleq_to_out_all: LEMMA % 
    ass_cs AND ass_waiting AND ass_doorway AND ass_exit
    IMPLIES
      levleq_to_out(k, fun(k))

  from12_18to_out: LEMMA % 
    ass_cs AND ass_waiting AND ass_doorway AND ass_exit AND k = depth(q) - 1
    IMPLIES
      leto(E1)(degree * (fun(k) + W) + D + 1, 
               between(q, 12, 18), atlev(q, 17, k))

  fun1(k): nat =
    degree * (fun(k) + W) + D + 1

  individual_progress: THEOREM % 
    ass_cs AND ass_waiting AND ass_doorway AND ass_exit AND k = depth(q) - 1
    IMPLIES
      leto(E1)(fun1(k) + 2, fullset, at(q, 11))

   factor: real = 
     cs + exi + 2 + addend / (degree-1)

   term0: real =
     degree * W + D + 1 - addend / (degree-1) * degree

   fun1_equals0: LEMMA % 
     fun1(k) = power(k+1, degree) * factor + term0

   constant0: real =
     (D + degree * (W + exi + 2)) / (degree -1)

   factor_equals: LEMMA 
     factor = cs + constant0

   term0_equals: LEMMA
     term0 = 1 - constant0

   fun1_equals: LEMMA % 
     fun1(k) = power(k+1, degree) * (cs + constant0) + 1 - constant0

END tournamentUnity0

$$$tournamentUnity0.prf
(tournamentUnity0
 (enabled1_necessary 0
  (enabled1_necessary-1 nil 3670301093 ("" (grind) nil nil)
   ((Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (leaf const-decl "finite_set[node]" ctrees nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (forward1 const-decl "bool" tournamentUnity0 nil)
    (enabled1 const-decl "bool" tournamentUnity0 nil))
   shostak))
 (enabled1_sufficient 0
  (enabled1_sufficient-1 nil 3670301105
   ("" (expand "enabled1")
    (("" (skosimp)
      (("" (case "x!1`pc(q!1) = 12")
        (("1" (expand "forward1")
          (("1" (expand "step12")
            (("1" (assert)
              (("1"
                (inst +
                 "goto(q!1, IF x!1`level(q!1) < 0 THEN 16 ELSE 13 ENDIF, x!1)")
                nil nil))
              nil))
            nil))
          nil)
         ("2" (expand "forward1")
          (("2" (case "x!1`pc(q!1) = 15")
            (("1" (assert) nil nil)
             ("2" (assert)
              (("2" (case "x!1`pc(q!1) = 16")
                (("1" (assert) nil nil)
                 ("2" (case "x!1`pc(q!1) = 17")
                  (("1" (expand "step17")
                    (("1"
                      (inst + "goto(q!1,
               IF x!1`level(q!1) < depth(q!1) - 1 THEN 18 ELSE 19 ENDIF,
               x!1)")
                      (("1" (assert) nil nil)) nil))
                    nil)
                   ("2" (case "x!1`pc(q!1) = 18")
                    (("1" (assert) nil nil)
                     ("2" (case "x!1`pc(q!1) = 19")
                      (("1" (expand "step19")
                        (("1" (assert)
                          (("1" (inst + "next19(q!1, x!1)") nil nil))
                          nil))
                        nil)
                       ("2" (assert) nil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((int_minus_int_is_int application-judgement "int" integers nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (depth const-decl "nat" ctrees nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (forward1 const-decl "bool" tournamentUnity0 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (digit type-eq-decl nil ctrees nil) (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (enabled1 const-decl "bool" tournamentUnity0 nil))
   shostak))
 (enabled_E1 0
  (enabled_E1-1 nil 3670303653
   ("" (skosimp)
    (("" (iff)
      (("" (prop)
        (("1" (expand "enabled")
          (("1" (skolem!)
            (("1" (expand "E1")
              (("1" (assert)
                (("1" (expand "emptyset") (("1" (propax) nil nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (expand "enabled")
          (("2" (skolem!)
            (("2" (expand "E1")
              (("2" (split)
                (("1" (flatten)
                  (("1" (use enabled1_necessary)
                    (("1" (assert) nil nil)) nil))
                  nil)
                 ("2" (flatten)
                  (("2" (expand "emptyset") (("2" (propax) nil nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("3" (expand "enabled")
          (("3" (expand "E1")
            (("3" (assert)
              (("3" (use enabled1_sufficient) (("3" (assert) nil nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((enabled1_sufficient formula-decl nil tournamentUnity0 nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (N const-decl "posnat" tournamentSafe0 nil)
    (below type-eq-decl nil nat_types nil)
    (bijective? const-decl "bool" functions nil)
    (enum_thread const-decl "(bijective?[below[N], (thread)])"
     tournamentSafe0 nil)
    (digit type-eq-decl nil ctrees nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (enabled1_necessary formula-decl nil tournamentUnity0 nil)
    (enabled const-decl "bool" bdUnity nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (emptyset const-decl "set" sets nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (finite_emptyset name-judgement "finite_set" finite_sets nil))
   shostak))
 (good_E1 0
  (good_E1-1 nil 3670303825
   ("" (expand "good")
    (("" (split)
      (("1" (expand "reflexive?")
        (("1" (expand "E1")
          (("1" (expand "step") (("1" (propax) nil nil)) nil)) nil))
        nil)
       ("2" (expand "<=")
        (("2" (expand "wp")
          (("2" (skosimp*)
            (("2" (expand "E1")
              (("2" (expand "step")
                (("2" (assert)
                  (("2" (skolem!)
                    (("2" (use globinv_step) (("2" (assert) nil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("3" (expand "<=")
        (("3" (skosimp*)
          (("3" (expand "E1")
            (("3" (split)
              (("1" (flatten)
                (("1" (expand "step")
                  (("1" (flatten)
                    (("1" (inst?)
                      (("1" (expand "step")
                        (("1" (flatten)
                          (("1" (expand "forward1")
                            (("1" (assert) nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (expand "emptyset") (("2" (propax) nil nil)) nil))
              nil))
            nil))
          nil))
        nil)
       ("4" (skosimp)
        (("4" (expand "is_finite")
          (("4" (inst + N id)
            (("1" (hide -) (("1" (grind) nil nil)) nil)
             ("2" (skolem!)
              (("2" (expand "id")
                (("2" (typepred x1!1)
                  (("2" (use enabled_E1) (("2" (assert) nil nil)) nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((E1 const-decl "specification[state]" tournamentUnity0 nil)
    (step const-decl "bool" tournamentUnity0 nil)
    (reflexive? const-decl "bool" relations nil)
    (wp const-decl "bool" ownpred nil)
    (globinv_step formula-decl nil tournamentSafe1 nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (digit type-eq-decl nil ctrees nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (<= const-decl "bool" mucalculus nil)
    (N const-decl "posnat" tournamentSafe0 nil)
    (below type-eq-decl nil nat_types nil)
    (bijective? const-decl "bool" functions nil)
    (enum_thread const-decl "(bijective?[below[N], (thread)])"
     tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (forward1 const-decl "bool" tournamentUnity0 nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (emptyset const-decl "set" sets nil)
    (enabled_E1 formula-decl nil tournamentUnity0 nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (injective? const-decl "bool" functions nil)
    (pred type-eq-decl nil defined_types nil)
    (specification type-eq-decl nil bdUnity nil)
    (enabled const-decl "bool" bdUnity nil)
    (x!1 skolem-const-decl "state[degree, node]" tournamentUnity0 nil)
    (id const-decl "(bijective?[T, T])" identity nil)
    (good const-decl "bool" bdUnity nil))
   shostak))
 (out_to19 0
  (out_to19-1 nil 3670305467
   ("" (s-ensures)
    (("" (split)
      (("1" (skosimp*)
        (("1" (expand "E1")
          (("1" (expand "step")
            (("1" (assert)
              (("1" (skolem!)
                (("1" (expand "out")
                  (("1" (flatten)
                    (("1" (case "q!1=p!1")
                      (("1" (replaceh -1)
                        (("1" (expand "step")
                          (("1" (case "step17(p!1, s!1, y!1)")
                            (("1" (hide -5)
                              (("1"
                                (expand "step17")
                                (("1"
                                  (flatten)
                                  (("1"
                                    (replaceh -1)
                                    (("1"
                                      (expand "goto")
                                      (("1" (assert) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (assert)
                              (("2"
                                (hide-all-but (-1 -4))
                                (("2" (grind) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2"
                        (case "y!1`pc(q!1) = s!1`pc(q!1) AND y!1`level(q!1) = s!1`level(q!1)")
                        (("1" (flatten)
                          (("1" (replace* -1 -2)
                            (("1" (assert) nil nil)) nil))
                          nil)
                         ("2" (hide-all-but (-4 1 2))
                          (("2" (split)
                            (("1" (grind) nil nil)
                             ("2" (grind) nil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (typepred enum_thread)
        (("2" (expand "bijective?")
          (("2" (flatten)
            (("2" (expand "surjective?")
              (("2" (hide -1)
                (("2" (inst - q!1)
                  (("2" (skolem!)
                    (("2" (name-replace kq x!1)
                      (("2" (inst + kq)
                        (("2" (split)
                          (("1" (skosimp)
                            (("1" (use enabled_E1)
                              (("1"
                                (assert)
                                (("1"
                                  (replaceh -3)
                                  (("1"
                                    (hide 3)
                                    (("1"
                                      (expand "out")
                                      (("1"
                                        (expand "enabled1")
                                        (("1" (flatten) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (skosimp)
                            (("2" (expand "E1")
                              (("2"
                                (expand "emptyset")
                                (("2"
                                  (assert)
                                  (("2"
                                    (replaceh -5)
                                    (("2"
                                      (expand "out")
                                      (("2"
                                        (hide -3 -4 1)
                                        (("2"
                                          (flatten)
                                          (("2" (grind) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((= const-decl "[T, T -> boolean]" equalities nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (empty? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (step const-decl "bool" tournamentUnity0 nil)
    (surjective? const-decl "bool" functions nil)
    (enabled_E1 formula-decl nil tournamentUnity0 nil)
    (enabled1 const-decl "bool" tournamentUnity0 nil)
    (forward1 const-decl "bool" tournamentUnity0 nil)
    (emptyset const-decl "set" sets nil)
    (enum_thread const-decl "(bijective?[below[N], (thread)])"
     tournamentSafe0 nil)
    (bijective? const-decl "bool" functions nil)
    (below type-eq-decl nil nat_types nil)
    (N const-decl "posnat" tournamentSafe0 nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (neg const-decl "bool" ownpred nil)
    (cup const-decl "bool" ownpred nil)
    (cap const-decl "bool" ownpred nil)
    (wp const-decl "bool" ownpred nil)
    (<= const-decl "bool" mucalculus nil)
    (transient const-decl "bool" bdUnity nil)
    (co const-decl "bool" bdUnity nil)
    (ensures const-decl "bool" bdUnity nil)
    (ensures_leto formula-decl nil bdUnity nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (digit type-eq-decl nil ctrees nil) (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (at const-decl "bool" tournamentUnity0 nil)
    (out const-decl "bool" tournamentUnity0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil))
   shostak))
 (from19to11 0
  (from19to11-1 nil 3670307449
   ("" (s-ensures)
    (("" (split)
      (("1" (skosimp*)
        (("1" (expand "E1")
          (("1" (expand "step")
            (("1" (assert)
              (("1" (skolem!)
                (("1" (case "q!1=p!1")
                  (("1" (replaceh -1)
                    (("1" (hide -2) (("1" (grind) nil nil)) nil)) nil)
                   ("2" (hide -2) (("2" (grind) nil nil)) nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (typepred enum_thread)
        (("2" (expand "bijective?")
          (("2" (flatten)
            (("2" (hide -1)
              (("2" (expand "surjective?")
                (("2" (inst - q!1)
                  (("2" (skolem!)
                    (("2" (name-replace kq x!1)
                      (("2" (inst + kq)
                        (("2" (split)
                          (("1" (skosimp)
                            (("1" (use enabled_E1)
                              (("1"
                                (assert)
                                (("1"
                                  (hide 3)
                                  (("1"
                                    (replaceh -3)
                                    (("1"
                                      (expand "enabled1")
                                      (("1" (propax) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (skosimp)
                            (("2" (expand "E1")
                              (("2"
                                (expand "emptyset")
                                (("2"
                                  (assert)
                                  (("2"
                                    (replaceh -5)
                                    (("2"
                                      (hide -3 +)
                                      (("2" (grind) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((= const-decl "[T, T -> boolean]" equalities nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (empty? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (step const-decl "bool" tournamentUnity0 nil)
    (enabled_E1 formula-decl nil tournamentUnity0 nil)
    (enabled1 const-decl "bool" tournamentUnity0 nil)
    (forward1 const-decl "bool" tournamentUnity0 nil)
    (emptyset const-decl "set" sets nil)
    (surjective? const-decl "bool" functions nil)
    (enum_thread const-decl "(bijective?[below[N], (thread)])"
     tournamentSafe0 nil)
    (bijective? const-decl "bool" functions nil)
    (below type-eq-decl nil nat_types nil)
    (N const-decl "posnat" tournamentSafe0 nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (neg const-decl "bool" ownpred nil)
    (cup const-decl "bool" ownpred nil)
    (cap const-decl "bool" ownpred nil)
    (wp const-decl "bool" ownpred nil)
    (<= const-decl "bool" mucalculus nil)
    (transient const-decl "bool" bdUnity nil)
    (co const-decl "bool" bdUnity nil)
    (ensures const-decl "bool" bdUnity nil)
    (ensures_leto formula-decl nil bdUnity nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (digit type-eq-decl nil ctrees nil) (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (at const-decl "bool" tournamentUnity0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil))
   shostak))
 (out_to11 0
  (out_to11-1 nil 3670307784
   ("" (skolem!)
    (("" (use out_to19)
      (("" (use from19to11)
        (("" (lemma leto_transitive)
          (("" (inst - 1 1 "out(q!1)" "at(q!1, 19)" "at(q!1, 11)" E1)
            (("" (assert) nil nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((out_to19 formula-decl nil tournamentUnity0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (digit type-eq-decl nil ctrees nil)
    (leto_transitive formula-decl nil bdUnity nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (at const-decl "bool" tournamentUnity0 nil)
    (out const-decl "bool" tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil)
    (from19to11 formula-decl nil tournamentUnity0 nil))
   shostak))
 (from17to18 0
  (from17to18-1 nil 3670653251
   ("" (s-ensures)
    (("" (split)
      (("1" (skosimp*)
        (("1" (expand "E1")
          (("1" (expand "step")
            (("1" (assert)
              (("1" (skolem!)
                (("1" (expand "atlev")
                  (("1" (flatten)
                    (("1" (assert)
                      (("1" (hide -3 1)
                        (("1" (case "q!1=p!1")
                          (("1" (replaceh -1)
                            (("1" (hide 1)
                              (("1"
                                (expand "step")
                                (("1"
                                  (expand "step11")
                                  (("1"
                                    (assert)
                                    (("1"
                                      (expand "step12")
                                      (("1"
                                        (expand "step13")
                                        (("1"
                                          (expand "step14")
                                          (("1"
                                            (expand "step15F")
                                            (("1"
                                              (expand "step15G")
                                              (("1"
                                                (expand "step16")
                                                (("1"
                                                  (expand "step18")
                                                  (("1"
                                                    (expand "step19")
                                                    (("1"
                                                      (expand "step17")
                                                      (("1"
                                                        (replaceh -3)
                                                        (("1"
                                                          (expand
                                                           "goto")
                                                          (("1"
                                                            (propax)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (hide 3) (("2" (grind) nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (typepred enum_thread)
        (("2" (expand "bijective?")
          (("2" (flatten)
            (("2" (hide -1)
              (("2" (expand "surjective?")
                (("2" (inst - q!1)
                  (("2" (skolem!)
                    (("2" (name-replace kq x!1)
                      (("2" (inst + kq)
                        (("2" (split)
                          (("1" (skosimp)
                            (("1" (use enabled_E1)
                              (("1"
                                (assert)
                                (("1"
                                  (hide 3)
                                  (("1"
                                    (replaceh -3)
                                    (("1"
                                      (expand "atlev")
                                      (("1"
                                        (flatten)
                                        (("1"
                                          (expand "enabled1")
                                          (("1" (assert) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (skosimp)
                            (("2" (expand "E1")
                              (("2"
                                (assert)
                                (("2"
                                  (expand "atlev")
                                  (("2"
                                    (flatten)
                                    (("2"
                                      (replaceh -7)
                                      (("2"
                                        (expand "forward1")
                                        (("2"
                                          (expand "step12")
                                          (("2"
                                            (assert)
                                            (("2"
                                              (expand "step19")
                                              (("2"
                                                (expand "step17")
                                                (("2"
                                                  (replaceh -3)
                                                  (("2"
                                                    (expand "goto")
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((= const-decl "[T, T -> boolean]" equalities nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (empty? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (step const-decl "bool" tournamentUnity0 nil)
    (enabled_E1 formula-decl nil tournamentUnity0 nil)
    (enabled1 const-decl "bool" tournamentUnity0 nil)
    (forward1 const-decl "bool" tournamentUnity0 nil)
    (surjective? const-decl "bool" functions nil)
    (enum_thread const-decl "(bijective?[below[N], (thread)])"
     tournamentSafe0 nil)
    (bijective? const-decl "bool" functions nil)
    (below type-eq-decl nil nat_types nil)
    (N const-decl "posnat" tournamentSafe0 nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (neg const-decl "bool" ownpred nil)
    (cup const-decl "bool" ownpred nil)
    (cap const-decl "bool" ownpred nil)
    (wp const-decl "bool" ownpred nil)
    (<= const-decl "bool" mucalculus nil)
    (transient const-decl "bool" bdUnity nil)
    (co const-decl "bool" bdUnity nil)
    (ensures const-decl "bool" bdUnity nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (ensures_leto formula-decl nil bdUnity nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (digit type-eq-decl nil ctrees nil) (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil))
   shostak))
 (from18to17 0
  (from18to17-2 nil 3670659507
   ("" (skosimp)
    (("" (expand "ass_exit")
      (("" (inst?)
        (("" (lemma PSP0_leto)
          ((""
            (inst - exi "atlev(q!1, 18, z!1)" "at(q!1, 18)"
             "atlev(q!1, 17, z!1 + 1)" E1)
            (("" (assert)
              (("" (hide - 2)
                (("" (split)
                  (("1" (expand "unless")
                    (("1" (expand "<=")
                      (("1" (expand "wp")
                        (("1" (expand "cap")
                          (("1" (expand "atlev")
                            (("1" (expand "cup")
                              (("1"
                                (expand "neg")
                                (("1"
                                  (skosimp*)
                                  (("1"
                                    (expand "E1")
                                    (("1"
                                      (expand "step")
                                      (("1"
                                        (split -)
                                        (("1" (assert) nil nil)
                                         ("2"
                                          (skolem!)
                                          (("2"
                                            (hide 1)
                                            (("2"
                                              (case "q!1=p!1")
                                              (("1"
                                                (replaceh -1)
                                                (("1"
                                                  (expand "step")
                                                  (("1"
                                                    (expand "step11")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (expand
                                                         "step12")
                                                        (("1"
                                                          (expand
                                                           "step13")
                                                          (("1"
                                                            (expand
                                                             "step14")
                                                            (("1"
                                                              (expand
                                                               "step15F")
                                                              (("1"
                                                                (expand
                                                                 "step15G")
                                                                (("1"
                                                                  (expand
                                                                   "step16")
                                                                  (("1"
                                                                    (expand
                                                                     "step17")
                                                                    (("1"
                                                                      (expand
                                                                       "step19")
                                                                      (("1"
                                                                        (expand
                                                                         "step18")
                                                                        (("1"
                                                                          (replaceh
                                                                           -1)
                                                                          (("1"
                                                                            (expand
                                                                             "next18")
                                                                            (("1"
                                                                              (propax)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (hide 3 -4)
                                                (("2"
                                                  (split)
                                                  (("1"
                                                    (hide -3)
                                                    (("1"
                                                      (grind)
                                                      nil
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (hide -2)
                                                    (("2"
                                                      (grind)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (expand "<=")
                    (("2" (expand "atlev")
                      (("2" (expand "at") (("2" (skosimp) nil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((ass_exit const-decl "bool" tournamentUnity0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (digit type-eq-decl nil ctrees nil)
    (PSP0_leto formula-decl nil bdUnity nil)
    (<= const-decl "bool" mucalculus nil)
    (cap const-decl "bool" ownpred nil)
    (cup const-decl "bool" ownpred nil)
    (step const-decl "bool" tournamentUnity0 nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (neg const-decl "bool" ownpred nil)
    (wp const-decl "bool" ownpred nil)
    (unless const-decl "bool" bdUnity nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (at const-decl "bool" tournamentUnity0 nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil)
    (exi const-decl "posnat" tournamentUnity0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil))
   nil)
  (from18to17-1 nil 3670655806
   ("" (skosimp)
    (("" (expand "ass_exit")
      (("" (inst?)
        (("" (lemma PSP_leto)
          (("" (inst?)
            (("" (assert)
              (("" (name-replace pp0 " atlev(q!1, 18, k!1)")
                (("" (name-replace pp1 "atlev(q!1, 17, 1 + k!1)")
                  (("" (inst - pp0 pp1)
                    (("" (split)
                      (("1" (case "cap(at(q!1, 18), pp0)=pp0")
                        (("1" (replaceh -1)
                          (("1"
                            (case "cup(cap(at(q!1, 17), pp0), pp1) = pp1")
                            (("1" (assert) nil nil)
                             ("2" (hide - 2)
                              (("2"
                                (apply-extensionality :hide? t)
                                (("2"
                                  (iff)
                                  (("2"
                                    (expand "cup")
                                    (("2"
                                      (prop)
                                      (("2"
                                        (expand "pp1")
                                        (("2"
                                          (expand "cap")
                                          (("2"
                                            (expand "pp0")
                                            (("2"
                                              (expand "atlev")
                                              (("2"
                                                (expand "at")
                                                (("2"
                                                  (flatten)
                                                  (("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (hide - 2)
                          (("2" (apply-extensionality :hide? t)
                            (("2" (iff)
                              (("2"
                                (expand "cap")
                                (("2"
                                  (prop)
                                  (("2"
                                    (expand "pp0")
                                    (("2"
                                      (expand "atlev")
                                      (("2"
                                        (expand "at")
                                        (("2" (assert) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (hide - 2)
                        (("2" (expand "unless")
                          (("2" (expand "<=")
                            (("2" (expand "wp")
                              (("2"
                                (expand "cap")
                                (("2"
                                  (expand "pp0")
                                  (("2"
                                    (expand "pp1")
                                    (("2"
                                      (expand "cup")
                                      (("2"
                                        (expand "atlev")
                                        (("2"
                                          (skosimp*)
                                          (("2"
                                            (expand "neg")
                                            (("2"
                                              (assert)
                                              (("2"
                                                (expand "E1")
                                                (("2"
                                                  (expand "step")
                                                  (("2"
                                                    (split -)
                                                    (("1"
                                                      (assert)
                                                      nil
                                                      nil)
                                                     ("2"
                                                      (skolem!)
                                                      (("2"
                                                        (case
                                                         "q!1=p!1")
                                                        (("1"
                                                          (replaceh -1)
                                                          (("1"
                                                            (expand
                                                             "step")
                                                            (("1"
                                                              (expand
                                                               "step11")
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (expand
                                                                   "step12")
                                                                  (("1"
                                                                    (expand
                                                                     "step13")
                                                                    (("1"
                                                                      (expand
                                                                       "step14")
                                                                      (("1"
                                                                        (expand
                                                                         "step15F")
                                                                        (("1"
                                                                          (expand
                                                                           "step15G")
                                                                          (("1"
                                                                            (expand
                                                                             "step16")
                                                                            (("1"
                                                                              (expand
                                                                               "step17")
                                                                              (("1"
                                                                                (expand
                                                                                 "step19")
                                                                                (("1"
                                                                                  (expand
                                                                                   "step18")
                                                                                  (("1"
                                                                                    (replaceh
                                                                                     -1)
                                                                                    (("1"
                                                                                      (expand
                                                                                       "next18")
                                                                                      (("1"
                                                                                        (propax)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (hide -4 2 4)
                                                          (("2"
                                                            (split)
                                                            (("1"
                                                              (hide -3)
                                                              (("1"
                                                                (grind)
                                                                nil
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (hide -2)
                                                              (("2"
                                                                (grind)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((ass_exit const-decl "bool" tournamentUnity0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (PSP_leto formula-decl nil bdUnity nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (cup const-decl "bool" ownpred nil)
    (cap const-decl "bool" ownpred nil)
    (unless const-decl "bool" bdUnity nil)
    (wp const-decl "bool" ownpred nil)
    (step const-decl "bool" tournamentUnity0 nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (min const-decl "{p: real | p <= m AND p <= n}" real_defs nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nat_min application-judgement "{k: nat | k <= i AND k <= j}"
     real_defs nil)
    (int_max application-judgement "{k: int | i <= k AND j <= k}"
     real_defs nil)
    (rat_max application-judgement "{s: rat | s >= q AND s >= r}"
     real_defs nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (neg const-decl "bool" ownpred nil)
    (<= const-decl "bool" mucalculus nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (at const-decl "bool" tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil)
    (exi const-decl "posnat" tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil))
   shostak))
 (from17to17 0
  (from17to17-1 nil 3671437829
   ("" (skosimp)
    (("" (use from17to18)
      (("" (use from18to17)
        (("" (assert)
          (("" (lemma leto_transitive)
            (("" (inst - 1 exi _ _ _ _)
              (("" (inst?)
                (("" (assert)
                  (("" (inst?)
                    (("" (assert)
                      (("" (expand "exi1") (("" (propax) nil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((from17to18 formula-decl nil tournamentUnity0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (exi const-decl "posnat" tournamentUnity0 nil)
    (exi1 const-decl "posnat" tournamentUnity0 nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (pred type-eq-decl nil defined_types nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (leto_transitive formula-decl nil bdUnity nil)
    (digit type-eq-decl nil ctrees nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (from18to17 formula-decl nil tournamentUnity0 nil))
   shostak))
 (from12Eto16 0
  (from12Eto16-2 nil 3670326452
   ("" (s-ensures)
    (("" (split)
      (("1" (skosimp*)
        (("1" (expand "E1")
          (("1" (expand "step")
            (("1" (assert)
              (("1" (skolem!)
                (("1" (hide 1)
                  (("1" (case "q!1=p!1")
                    (("1" (replaceh -1)
                      (("1" (expand "atlev")
                        (("1" (flatten)
                          (("1" (expand "step")
                            (("1" (expand "step11")
                              (("1"
                                (assert)
                                (("1"
                                  (expand "step13")
                                  (("1"
                                    (expand "step14")
                                    (("1"
                                      (expand "step15F")
                                      (("1"
                                        (expand "step15G")
                                        (("1"
                                          (expand "step16")
                                          (("1"
                                            (expand "step19")
                                            (("1"
                                              (expand "step18")
                                              (("1"
                                                (expand "step17")
                                                (("1"
                                                  (expand "step12")
                                                  (("1"
                                                    (replaceh -4)
                                                    (("1"
                                                      (expand "goto")
                                                      (("1"
                                                        (propax)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide -2 3)
                      (("2" (expand "atlev")
                        (("2" (flatten) (("2" (grind) nil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (typepred enum_thread)
        (("2" (expand "bijective?")
          (("2" (flatten)
            (("2" (expand "surjective?")
              (("2" (inst?)
                (("2" (skolem!)
                  (("2" (inst + x!1)
                    (("2" (split)
                      (("1" (skosimp)
                        (("1" (use enabled_E1)
                          (("1" (assert)
                            (("1" (hide 3)
                              (("1"
                                (replaceh -4)
                                (("1"
                                  (expand "atlev")
                                  (("1"
                                    (expand "enabled1")
                                    (("1" (flatten) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (skosimp)
                        (("2" (expand "E1")
                          (("2" (expand "atlev")
                            (("2" (flatten)
                              (("2"
                                (expand "forward1")
                                (("2"
                                  (replaceh -8)
                                  (("2"
                                    (expand "step17")
                                    (("2"
                                      (assert)
                                      (("2"
                                        (expand "step19")
                                        (("2"
                                          (expand "step12")
                                          (("2"
                                            (replaceh -3)
                                            (("2"
                                              (expand "goto")
                                              (("2" (assert) nil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (step const-decl "bool" tournamentUnity0 nil)
    (surjective? const-decl "bool" functions nil)
    (enabled_E1 formula-decl nil tournamentUnity0 nil)
    (enabled1 const-decl "bool" tournamentUnity0 nil)
    (forward1 const-decl "bool" tournamentUnity0 nil)
    (enum_thread const-decl "(bijective?[below[N], (thread)])"
     tournamentSafe0 nil)
    (bijective? const-decl "bool" functions nil)
    (below type-eq-decl nil nat_types nil)
    (N const-decl "posnat" tournamentSafe0 nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (neg const-decl "bool" ownpred nil)
    (cup const-decl "bool" ownpred nil)
    (cap const-decl "bool" ownpred nil)
    (wp const-decl "bool" ownpred nil)
    (<= const-decl "bool" mucalculus nil)
    (transient const-decl "bool" bdUnity nil)
    (co const-decl "bool" bdUnity nil)
    (ensures const-decl "bool" bdUnity nil)
    (ensures_leto formula-decl nil bdUnity nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (digit type-eq-decl nil ctrees nil) (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil))
   nil)
  (from12Eto16-1 nil 3670313050
   ("" (s-ensures)
    (("" (split)
      (("1" (skosimp*)
        (("1" (expand "E1")
          (("1" (expand "step")
            (("1" (assert)
              (("1" (skolem!)
                (("1" (case "q!1=p!1")
                  (("1" (replaceh -1)
                    (("1" (expand "loop12")
                      (("1" (flatten)
                        (("1" (hide -3)
                          (("1" (expand "step")
                            (("1" (case "step12(p!1, s!1, y!1)")
                              (("1"
                                (hide -4)
                                (("1"
                                  (expand "step12")
                                  (("1"
                                    (assert)
                                    (("1"
                                      (replaceh -1)
                                      (("1"
                                        (expand "goto")
                                        (("1" (propax) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (assert)
                                (("2"
                                  (hide-all-but (-1 -3))
                                  (("2" (grind) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (hide -2 2 4)
                    (("2" (expand "loop12")
                      (("2" (flatten)
                        (("2" (split)
                          (("1" (grind) nil nil) ("2" (grind) nil nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (typepred enum_thread)
        (("2" (expand "bijective?")
          (("2" (flatten)
            (("2" (hide -1)
              (("2" (expand "surjective?")
                (("2" (inst - q!1)
                  (("2" (skolem!)
                    (("2" (name-replace kq x!1)
                      (("2" (inst + kq)
                        (("2" (split)
                          (("1" (skosimp)
                            (("1" (use enabled_E1)
                              (("1"
                                (assert)
                                (("1"
                                  (hide 3)
                                  (("1"
                                    (expand "loop12")
                                    (("1"
                                      (expand "enabled1")
                                      (("1"
                                        (flatten)
                                        (("1" (assert) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (skosimp)
                            (("2" (expand "E1")
                              (("2"
                                (assert)
                                (("2"
                                  (replaceh -4)
                                  (("2"
                                    (expand "loop12")
                                    (("2"
                                      (flatten)
                                      (("2"
                                        (assert)
                                        (("2"
                                          (hide -3)
                                          (("2" (grind) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((= const-decl "[T, T -> boolean]" equalities nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (min const-decl "{p: real | p <= m AND p <= n}" real_defs nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (rat_max application-judgement "{s: rat | s >= q AND s >= r}"
     real_defs nil)
    (int_max application-judgement "{k: int | i <= k AND j <= k}"
     real_defs nil)
    (nat_min application-judgement "{k: nat | k <= i AND k <= j}"
     real_defs nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (step const-decl "bool" tournamentUnity0 nil)
    (enabled_E1 formula-decl nil tournamentUnity0 nil)
    (enabled1 const-decl "bool" tournamentUnity0 nil)
    (forward1 const-decl "bool" tournamentUnity0 nil)
    (surjective? const-decl "bool" functions nil)
    (enum_thread const-decl "(bijective?[below[N], (thread)])"
     tournamentSafe0 nil)
    (bijective? const-decl "bool" functions nil)
    (N const-decl "posnat" tournamentSafe0 nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (neg const-decl "bool" ownpred nil)
    (cup const-decl "bool" ownpred nil)
    (cap const-decl "bool" ownpred nil)
    (wp const-decl "bool" ownpred nil)
    (<= const-decl "bool" mucalculus nil)
    (cobar const-decl "bool" bdUnity nil)
    (co const-decl "bool" bdUnity nil)
    (ensures const-decl "bool" bdUnity nil)
    (ensures_leto formula-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil) (< const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (at const-decl "bool" tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil))
   shostak))
 (from16to17 0
  (from16to17-1 nil 3670312241
   ("" (skosimp)
    (("" (lemma PSP0_leto)
      (("" (expand "ass_cs")
        (("" (inst?)
          (("" (assert)
            (("" (inst? -2)
              (("" (hide +)
                (("" (inst?)
                  (("" (assert)
                    (("" (hide -)
                      (("" (split)
                        (("1" (expand "unless")
                          (("1" (expand "<=")
                            (("1" (expand "wp")
                              (("1"
                                (expand "cap")
                                (("1"
                                  (expand "cup")
                                  (("1"
                                    (expand "atlev")
                                    (("1"
                                      (expand "neg")
                                      (("1"
                                        (skosimp*)
                                        (("1"
                                          (expand "E1")
                                          (("1"
                                            (expand "step")
                                            (("1"
                                              (assert)
                                              (("1"
                                                (hide 1)
                                                (("1"
                                                  (split)
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil)
                                                   ("2"
                                                    (skolem!)
                                                    (("2"
                                                      (case "q!1=p!1")
                                                      (("1"
                                                        (replaceh -1)
                                                        (("1"
                                                          (expand
                                                           "step")
                                                          (("1"
                                                            (expand
                                                             "step11")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (expand
                                                                 "step12")
                                                                (("1"
                                                                  (expand
                                                                   "step13")
                                                                  (("1"
                                                                    (expand
                                                                     "step14")
                                                                    (("1"
                                                                      (expand
                                                                       "step15F")
                                                                      (("1"
                                                                        (expand
                                                                         "step15G")
                                                                        (("1"
                                                                          (expand
                                                                           "step17")
                                                                          (("1"
                                                                            (expand
                                                                             "step18")
                                                                            (("1"
                                                                              (expand
                                                                               "step19")
                                                                              (("1"
                                                                                (expand
                                                                                 "step16")
                                                                                (("1"
                                                                                  (replaceh
                                                                                   -1)
                                                                                  (("1"
                                                                                    (expand
                                                                                     "goto")
                                                                                    (("1"
                                                                                      (propax)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (hide -4 3)
                                                        (("2"
                                                          (grind)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (expand "<=")
                          (("2" (expand "atlev")
                            (("2" (expand "at")
                              (("2" (skosimp) nil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (digit type-eq-decl nil ctrees nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (PSP0_leto formula-decl nil bdUnity nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (cs const-decl "posnat" tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (specification type-eq-decl nil bdUnity nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (at const-decl "bool" tournamentUnity0 nil)
    (unless const-decl "bool" bdUnity nil)
    (wp const-decl "bool" ownpred nil)
    (cup const-decl "bool" ownpred nil)
    (neg const-decl "bool" ownpred nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (empty? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (step const-decl "bool" tournamentUnity0 nil)
    (cap const-decl "bool" ownpred nil)
    (<= const-decl "bool" mucalculus nil)
    (ass_cs const-decl "bool" tournamentUnity0 nil))
   shostak))
 (levleq_0_out 0
  (levleq_0_out-9 nil 3671639161
   ("" (skosimp)
    (("" (lemma sub_leto)
      ((""
        (inst - "exi + cs + 2" "levleq(q!1, 0)" "cup(atlev(q!1, 18, -1),
         cup(atlev(q!1, 17, -1), cup(atlev(q!1, 16, -1), atlev(q!1, 12, -1))))"
         "atlev(q!1, 17, 0)" E1)
        (("" (assert)
          (("" (hide 2)
            (("" (split)
              (("1" (expand "<=")
                (("1" (expand "cap")
                  (("1" (expand "cup")
                    (("1" (expand "levleq")
                      (("1" (expand "atlev")
                        (("1" (skosimp)
                          (("1"
                            (case "iq0(q!1, s!1) AND iq1(q!1, s!1)")
                            (("1" (flatten)
                              (("1"
                                (expand "iq0")
                                (("1"
                                  (flatten)
                                  (("1"
                                    (expand "iq1")
                                    (("1"
                                      (assert)
                                      (("1" (ground) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (expand "E1")
                              (("2"
                                (expand "globinv")
                                (("2"
                                  (expand "iqall")
                                  (("2"
                                    (flatten)
                                    (("2"
                                      (inst?)
                                      (("2"
                                        (flatten)
                                        (("2" (assert) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (use cup_leto)
                (("2" (assert)
                  (("2" (hide 2)
                    (("2" (use from18to17)
                      (("2" (assert)
                        (("2" (lemma leto_up)
                          (("2" (split)
                            (("1" (inst - exi "2+cs+exi" _ _ _)
                              (("1"
                                (inst?)
                                (("1" (assert) nil nil))
                                nil))
                              nil)
                             ("2" (use cup_leto)
                              (("2"
                                (assert)
                                (("2"
                                  (hide 2)
                                  (("2"
                                    (hide -2)
                                    (("2"
                                      (use from17to17)
                                      (("2"
                                        (assert)
                                        (("2"
                                          (split)
                                          (("1"
                                            (inst?)
                                            (("1"
                                              (assert)
                                              (("1"
                                                (expand "exi1")
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (inst - "1+exi")
                                                    (("1"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (use cup_leto)
                                            (("2"
                                              (assert)
                                              (("2"
                                                (hide 2)
                                                (("2"
                                                  (case
                                                   "leto(E1)(cs + exi1, atlev(q!1, 16, -1), atlev(q!1, 17, 0))")
                                                  (("1"
                                                    (hide -2)
                                                    (("1"
                                                      (split)
                                                      (("1"
                                                        (inst
                                                         -
                                                         "cs+exi1"
                                                         "2+cs+exi"
                                                         _
                                                         _
                                                         _)
                                                        (("1"
                                                          (inst?)
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (expand
                                                               "exi1")
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (use
                                                         from12Eto16)
                                                        (("2"
                                                          (hide -3)
                                                          (("2"
                                                            (lemma
                                                             leto_transitive)
                                                            (("2"
                                                              (inst
                                                               -
                                                               1
                                                               "cs+exi1"
                                                               _
                                                               _
                                                               _
                                                               _)
                                                              (("2"
                                                                (inst?)
                                                                (("2"
                                                                  (assert)
                                                                  (("2"
                                                                    (inst?)
                                                                    (("2"
                                                                      (assert)
                                                                      (("2"
                                                                        (expand
                                                                         "exi1")
                                                                        (("2"
                                                                          (propax)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (hide 2 -2)
                                                    (("2"
                                                      (use from16to17)
                                                      (("2"
                                                        (lemma
                                                         leto_transitive)
                                                        (("2"
                                                          (inst
                                                           -
                                                           cs
                                                           exi1
                                                           _
                                                           _
                                                           _
                                                           _)
                                                          (("2"
                                                            (inst?)
                                                            (("2"
                                                              (inst?)
                                                              (("2"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (digit type-eq-decl nil ctrees nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (sub_leto formula-decl nil bdUnity nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (cap const-decl "bool" ownpred nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (iq1 const-decl "bool" tournamentSafe0 nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" mucalculus nil)
    (from18to17 formula-decl nil tournamentUnity0 nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (leto_up formula-decl nil bdUnity nil)
    (from17to17 formula-decl nil tournamentUnity0 nil)
    (exi1 const-decl "posnat" tournamentUnity0 nil)
    (leto const-decl "bool" bdUnity nil)
    (leto_transitive formula-decl nil bdUnity nil)
    (from12Eto16 formula-decl nil tournamentUnity0 nil)
    (from16to17 formula-decl nil tournamentUnity0 nil)
    (cup_leto formula-decl nil bdUnity nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (cup const-decl "bool" ownpred nil)
    (levleq const-decl "bool" tournamentUnity0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil)
    (cs const-decl "posnat" tournamentUnity0 nil)
    (exi const-decl "posnat" tournamentUnity0 nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil))
   nil)
  (levleq_0_out-8 nil 3671638733
   ("" (skosimp)
    (("" (lemma sub_leto)
      ((""
        (inst - "exi + cs + 2" "levleq(q!1, 0)" "cup(atlev(q!1, 18, -1),
       cup(atlev(q!1, 17, -1), cup(atlev(q!1, 16, -1), atlev(q!1, 12, -1))))"
         "atlev(q!1, 17, 0)" E1)
        (("" (assert)
          (("" (hide 2)
            (("" (split)
              (("1" (expand "<=")
                (("1" (expand "cap")
                  (("1" (expand "cup")
                    (("1" (expand "levleq")
                      (("1" (expand "atlev")
                        (("1" (skosimp)
                          (("1"
                            (case "iq0(q!1, s!1) AND iq1(q!1, s!1)")
                            (("1" (flatten)
                              (("1"
                                (expand "iq0")
                                (("1"
                                  (flatten)
                                  (("1"
                                    (expand "iq1")
                                    (("1"
                                      (assert)
                                      (("1" (ground) nil)))))))))))
                             ("2" (expand "E1")
                              (("2"
                                (expand "globinv")
                                (("2"
                                  (expand "iqall")
                                  (("2"
                                    (flatten)
                                    (("2"
                                      (inst?)
                                      (("2"
                                        (flatten)
                                        (("2"
                                          (assert)
                                          nil)))))))))))))))))))))))))))
               ("2" (use cup_leto)
                (("2" (assert)
                  (("2" (hide 2)
                    (("2" (use from18to17)
                      (("2" (assert)
                        (("2" (lemma leto_up)
                          (("2" (split)
                            (("1" (inst - exi "2+cs+exi" _ _ _)
                              (("1" (inst?) (("1" (assert) nil)))))
                             ("2" (use cup_leto)
                              (("2"
                                (assert)
                                (("2"
                                  (hide 2)
                                  (("2"
                                    (hide -2)
                                    (("2"
                                      (use from17to17)
                                      (("2"
                                        (assert)
                                        (("2"
                                          (split)
                                          (("1"
                                            (inst
                                             -
                                             exi1
                                             "2 + cs + +exi"
                                             _
                                             _
                                             _)
                                            (("1"
                                              (inst?)
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (expand "exi1")
                                                  (("1"
                                                    (assert)
                                                    nil)))))))))
                                           ("2"
                                            (use cup_leto)
                                            (("2"
                                              (assert)
                                              (("2"
                                                (hide 2)
                                                (("2"
                                                  (case
                                                   "leto(E1)(2 + exi, atlev(q!1, 16, -1), atlev(q!1, 17, 0))")
                                                  (("1"
                                                    (hide -2)
                                                    (("1"
                                                      (split)
                                                      (("1"
                                                        (inst
                                                         -
                                                         "2+exi"
                                                         "3+exi"
                                                         _
                                                         _
                                                         _)
                                                        (("1"
                                                          (inst?)
                                                          (("1"
                                                            (assert)
                                                            nil)))))
                                                       ("2"
                                                        (use
                                                         from12Eto16)
                                                        (("2"
                                                          (hide -3)
                                                          (("2"
                                                            (lemma
                                                             leto_transitive)
                                                            (("2"
                                                              (inst
                                                               -
                                                               1
                                                               "2+exi"
                                                               _
                                                               _
                                                               _
                                                               _)
                                                              (("2"
                                                                (inst?)
                                                                (("2"
                                                                  (assert)
                                                                  (("2"
                                                                    (inst?)
                                                                    (("2"
                                                                      (assert)
                                                                      nil)))))))))))))))))))
                                                   ("2"
                                                    (hide 2 -2)
                                                    (("2"
                                                      (use from16to17)
                                                      (("2"
                                                        (lemma
                                                         leto_transitive)
                                                        (("2"
                                                          (inst
                                                           -
                                                           cs
                                                           exi1
                                                           _
                                                           _
                                                           _
                                                           _)
                                                          (("2"
                                                            (inst?)
                                                            (("2"
                                                              (inst?)
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (expand
                                                                   "exi1")
                                                                  (("2"
                                                                    (propax)
                                                                    nil))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
    nil)
   nil nil)
  (levleq_0_out-7 nil 3671638611
   ("" (skosimp)
    (("" (lemma sub_leto)
      ((""
        (inst - "exi + cs + 2" "levleq(q!1, 0)" "cup(atlev(q!1, 18, -1),
     cup(atlev(q!1, 17, -1), cup(atlev(q!1, 16, -1), atlev(q!1, 12, -1))))"
         "atlev(q!1, 17, 0)" E1)
        (("" (assert)
          (("" (hide 2)
            (("" (split)
              (("1" (expand "<=")
                (("1" (expand "cap")
                  (("1" (expand "cup")
                    (("1" (expand "levleq")
                      (("1" (expand "atlev")
                        (("1" (skosimp)
                          (("1"
                            (case "iq0(q!1, s!1) AND iq1(q!1, s!1)")
                            (("1" (flatten)
                              (("1"
                                (expand "iq0")
                                (("1"
                                  (flatten)
                                  (("1"
                                    (expand "iq1")
                                    (("1"
                                      (assert)
                                      (("1" (ground) nil)))))))))))
                             ("2" (expand "E1")
                              (("2"
                                (expand "globinv")
                                (("2"
                                  (expand "iqall")
                                  (("2"
                                    (flatten)
                                    (("2"
                                      (inst?)
                                      (("2"
                                        (flatten)
                                        (("2"
                                          (assert)
                                          nil)))))))))))))))))))))))))))
               ("2" (use cup_leto)
                (("2" (assert)
                  (("2" (hide 2)
                    (("2" (use from18to17)
                      (("2" (assert)
                        (("2" (lemma leto_up)
                          (("2" (split)
                            (("1" (inst - exi "3+exi" _ _ _)
                              (("1" (inst?) (("1" (assert) nil)))))
                             ("2" (use cup_leto)
                              (("2"
                                (assert)
                                (("2"
                                  (hide 2)
                                  (("2"
                                    (hide -2)
                                    (("2"
                                      (use from17to17)
                                      (("2"
                                        (assert)
                                        (("2"
                                          (split)
                                          (("1"
                                            (inst
                                             -
                                             exi1
                                             "2 + cs + +exi"
                                             _
                                             _
                                             _)
                                            (("1"
                                              (inst?)
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (expand "exi1")
                                                  (("1"
                                                    (assert)
                                                    nil)))))))))
                                           ("2"
                                            (use cup_leto)
                                            (("2"
                                              (assert)
                                              (("2"
                                                (hide 2)
                                                (("2"
                                                  (case
                                                   "leto(E1)(2 + exi, atlev(q!1, 16, -1), atlev(q!1, 17, 0))")
                                                  (("1"
                                                    (hide -2)
                                                    (("1"
                                                      (split)
                                                      (("1"
                                                        (inst
                                                         -
                                                         "2+exi"
                                                         "3+exi"
                                                         _
                                                         _
                                                         _)
                                                        (("1"
                                                          (inst?)
                                                          (("1"
                                                            (assert)
                                                            nil)))))
                                                       ("2"
                                                        (use
                                                         from12Eto16)
                                                        (("2"
                                                          (hide -3)
                                                          (("2"
                                                            (lemma
                                                             leto_transitive)
                                                            (("2"
                                                              (inst
                                                               -
                                                               1
                                                               "2+exi"
                                                               _
                                                               _
                                                               _
                                                               _)
                                                              (("2"
                                                                (inst?)
                                                                (("2"
                                                                  (assert)
                                                                  (("2"
                                                                    (inst?)
                                                                    (("2"
                                                                      (assert)
                                                                      nil)))))))))))))))))))
                                                   ("2"
                                                    (hide 2 -2)
                                                    (("2"
                                                      (use from16to17)
                                                      (("2"
                                                        (lemma
                                                         leto_transitive)
                                                        (("2"
                                                          (inst
                                                           -
                                                           cs
                                                           exi1
                                                           _
                                                           _
                                                           _
                                                           _)
                                                          (("2"
                                                            (inst?)
                                                            (("2"
                                                              (inst?)
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (expand
                                                                   "exi1")
                                                                  (("2"
                                                                    (propax)
                                                                    nil))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
    nil)
   nil nil)
  (levleq_0_out-6 nil 3671450631
   ("" (skosimp)
    (("" (lemma sub_leto)
      ((""
        (inst - "exi + 3" "levleq(q!1, 0)" "cup(atlev(q!1, 18, -1),
   cup(atlev(q!1, 17, -1), cup(atlev(q!1, 16, -1), atlev(q!1, 12, -1))))"
         "atlev(q!1, 17, 0)" E1)
        (("" (assert)
          (("" (hide 2)
            (("" (split)
              (("1" (expand "<=")
                (("1" (expand "cap")
                  (("1" (expand "cup")
                    (("1" (expand "levleq")
                      (("1" (expand "atlev")
                        (("1" (skosimp)
                          (("1"
                            (case "iq0(q!1, s!1) AND iq1(q!1, s!1)")
                            (("1" (flatten)
                              (("1"
                                (expand "iq0")
                                (("1"
                                  (flatten)
                                  (("1"
                                    (expand "iq1")
                                    (("1"
                                      (assert)
                                      (("1" (ground) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (expand "E1")
                              (("2"
                                (expand "globinv")
                                (("2"
                                  (expand "iqall")
                                  (("2"
                                    (flatten)
                                    (("2"
                                      (inst?)
                                      (("2"
                                        (flatten)
                                        (("2" (assert) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (use cup_leto)
                (("2" (assert)
                  (("2" (hide 2)
                    (("2" (use from18to17)
                      (("2" (assert)
                        (("2" (lemma leto_up)
                          (("2" (split)
                            (("1" (inst - exi "3+exi" _ _ _)
                              (("1"
                                (inst?)
                                (("1" (assert) nil nil))
                                nil))
                              nil)
                             ("2" (use cup_leto)
                              (("2"
                                (assert)
                                (("2"
                                  (hide 2)
                                  (("2"
                                    (hide -2)
                                    (("2"
                                      (use from17to17)
                                      (("2"
                                        (assert)
                                        (("2"
                                          (split)
                                          (("1"
                                            (inst - exi1 "3+exi" _ _ _)
                                            (("1"
                                              (inst?)
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (expand "exi1")
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (use cup_leto)
                                            (("2"
                                              (assert)
                                              (("2"
                                                (hide 2)
                                                (("2"
                                                  (case
                                                   "leto(E1)(2 + exi, atlev(q!1, 16, -1), atlev(q!1, 17, 0))")
                                                  (("1"
                                                    (hide -2)
                                                    (("1"
                                                      (split)
                                                      (("1"
                                                        (inst
                                                         -
                                                         "2+exi"
                                                         "3+exi"
                                                         _
                                                         _
                                                         _)
                                                        (("1"
                                                          (inst?)
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (use
                                                         from12Eto16)
                                                        (("2"
                                                          (hide -3)
                                                          (("2"
                                                            (lemma
                                                             leto_transitive)
                                                            (("2"
                                                              (inst
                                                               -
                                                               1
                                                               "2+exi"
                                                               _
                                                               _
                                                               _
                                                               _)
                                                              (("2"
                                                                (inst?)
                                                                (("2"
                                                                  (assert)
                                                                  (("2"
                                                                    (inst?)
                                                                    (("2"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (hide 2 -2)
                                                    (("2"
                                                      (use from16to17)
                                                      (("2"
                                                        (lemma
                                                         leto_transitive)
                                                        (("2"
                                                          (inst
                                                           -
                                                           1
                                                           exi1
                                                           _
                                                           _
                                                           _
                                                           _)
                                                          (("2"
                                                            (inst?)
                                                            (("2"
                                                              (inst?)
                                                              (("2"
                                                                (assert)
                                                                (("2"
                                                                  (expand
                                                                   "exi1")
                                                                  (("2"
                                                                    (propax)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (sub_leto formula-decl nil bdUnity nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (cap const-decl "bool" ownpred nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (iq1 const-decl "bool" tournamentSafe0 nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" mucalculus nil)
    (from18to17 formula-decl nil tournamentUnity0 nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (leto_up formula-decl nil bdUnity nil)
    (from17to17 formula-decl nil tournamentUnity0 nil)
    (exi1 const-decl "posnat" tournamentUnity0 nil)
    (leto const-decl "bool" bdUnity nil)
    (even_minus_even_is_even application-judgement "even_int" integers
     nil)
    (leto_transitive formula-decl nil bdUnity nil)
    (from12Eto16 formula-decl nil tournamentUnity0 nil)
    (from16to17 formula-decl nil tournamentUnity0 nil)
    (cup_leto formula-decl nil bdUnity nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (cup const-decl "bool" ownpred nil)
    (levleq const-decl "bool" tournamentUnity0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil)
    (exi const-decl "posnat" tournamentUnity0 nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil))
   nil)
  (levleq_0_out-5 nil 3670685854
   ("" (skosimp)
    (("" (lemma sub_leto)
      ((""
        (inst - "exi + 3" "levleq(q!1, 0)" "cup(atlev(q!1, 12, -1), 
cup(atlev(q!1, 16, -1), cup(atlev(q!1, 17, -1), atlev(q!1, 18, -1))))"
         "atlev(q!1, 17, 0)" E1)
        (("" (assert)
          (("" (hide 2)
            (("" (split)
              (("1" (expand "<=")
                (("1" (expand "cap")
                  (("1" (expand "cup")
                    (("1" (expand "levleq")
                      (("1" (expand "atlev")
                        (("1" (skosimp)
                          (("1"
                            (case "iq0(q!1, s!1) AND iq1(q!1, s!1) AND iq4(q!1, s!1)")
                            (("1" (flatten)
                              (("1"
                                (expand "iq0")
                                (("1"
                                  (flatten)
                                  (("1"
                                    (expand "iq1")
                                    (("1"
                                      (assert)
                                      (("1" (ground) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (expand "E1")
                              (("2"
                                (expand "globinv")
                                (("2"
                                  (expand "iqall")
                                  (("2"
                                    (flatten)
                                    (("2"
                                      (inst?)
                                      (("2"
                                        (flatten)
                                        (("2"
                                          (assert)
                                          (("2"
                                            (expand "kqall")
                                            (("2"
                                              (flatten)
                                              (("2"
                                                (inst? -9)
                                                (("2"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (postpone) nil nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (sub_leto formula-decl nil bdUnity nil)
    (cup const-decl "bool" ownpred nil)
    (cap const-decl "bool" ownpred nil)
    (at const-decl "bool" tournamentUnity0 nil)
    (between const-decl "bool" tournamentUnity0 nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (kqall const-decl "bool" tournamentSafe0 nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (iq4 const-decl "bool" tournamentSafe0 nil)
    (iq1 const-decl "bool" tournamentSafe0 nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" mucalculus nil)
    (leto_transitive formula-decl nil bdUnity nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (from12Eto16 formula-decl nil tournamentUnity0 nil)
    (leto_up formula-decl nil bdUnity nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (cup_leto formula-decl nil bdUnity nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (exi1 const-decl "posnat" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (out const-decl "bool" tournamentUnity0 nil)
    (levleq const-decl "bool" tournamentUnity0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil))
   nil)
  (levleq_0_out-4 nil 3670682342
   ("" (skosimp)
    (("" (lemma sub_leto)
      (("" (inst - _ "levleq(q!1, 0)" _ "out(q!1)" _)
        ((""
          (inst - _
           "cup(cap(levleq(q!1, 0), at(q!1, 12)), between(q!1, 16, 18))"
           _)
          (("" (inst?)
            (("" (assert)
              (("" (hide 2)
                (("" (split)
                  (("1" (expand "<=")
                    (("1" (expand "cap")
                      (("1" (expand "cup")
                        (("1" (expand "levleq")
                          (("1" (expand "between")
                            (("1" (skosimp)
                              (("1"
                                (case
                                 "iq1(q!1, s!1) AND iq4(q!1, s!1)")
                                (("1"
                                  (flatten)
                                  (("1"
                                    (expand "iq1")
                                    (("1"
                                      (expand "iq4")
                                      (("1"
                                        (assert)
                                        (("1"
                                          (expand "at")
                                          (("1" (assert) nil)))))))))))
                                 ("2"
                                  (expand "E1")
                                  (("2"
                                    (expand "globinv")
                                    (("2"
                                      (expand "kqall")
                                      (("2"
                                        (flatten)
                                        (("2"
                                          (inst?)
                                          (("2"
                                            (flatten)
                                            (("2"
                                              (assert)
                                              (("2"
                                                (expand "iqall")
                                                (("2"
                                                  (flatten)
                                                  (("2"
                                                    (inst?)
                                                    (("2"
                                                      (assert)
                                                      nil)))))))))))))))))))))))))))))))))))
                   ("2" (use cup_leto)
                    (("2" (assert)
                      (("2" (hide 2)
                        (("2" (split)
                          (("1" (use from12Eto16)
                            (("1" (use at16_to_out)
                              (("1"
                                (lemma leto_transitive)
                                (("1"
                                  (inst
                                   -
                                   1
                                   "2 * depth(pp) + 1"
                                   _
                                   _
                                   _
                                   _)
                                  (("1"
                                    (inst?)
                                    (("1"
                                      (assert)
                                      (("1"
                                        (inst?)
                                        (("1"
                                          (assert)
                                          (("1"
                                            (hide -2 2)
                                            (("1"
                                              (lemma leto_up)
                                              (("1"
                                                (inst
                                                 -
                                                 "1 + 2 * q!1`length"
                                                 "1 + 2 * depth(pp)"
                                                 _
                                                 _
                                                 _)
                                                (("1"
                                                  (inst?)
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (hide - 2)
                                                      (("1"
                                                        (use
                                                         thread_length_upb)
                                                        (("1"
                                                          (assert)
                                                          nil)))))))))))))))))))))))))))))))
                           ("2" (use between16_18_out_1)
                            (("2" (assert)
                              nil))))))))))))))))))))))))))
    nil)
   nil nil)
  (levleq_0_out-3 nil 3670598786
   ("" (skolem!)
    (("" (lemma sub_leto)
      (("" (inst - _ "levleq(q!1, 0)" _ "out(q!1)" _)
        ((""
          (inst - _
           "cup(cap(levleq(q!1, 0), at(q!1, 12)), between(q!1, 16, 18))"
           _)
          (("" (inst?)
            (("" (assert)
              (("" (hide 2)
                (("" (split)
                  (("1" (expand "<=")
                    (("1" (expand "cap")
                      (("1" (expand "cup")
                        (("1" (expand "levleq")
                          (("1" (expand "between")
                            (("1" (skosimp)
                              (("1"
                                (case
                                 "iq1(q!1, s!1) AND iq4(q!1, s!1)")
                                (("1"
                                  (flatten)
                                  (("1"
                                    (expand "iq1")
                                    (("1"
                                      (expand "iq4")
                                      (("1"
                                        (assert)
                                        (("1"
                                          (expand "at")
                                          (("1" (assert) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (expand "E1")
                                  (("2"
                                    (expand "globinv")
                                    (("2"
                                      (expand "kqall")
                                      (("2"
                                        (flatten)
                                        (("2"
                                          (inst?)
                                          (("2"
                                            (flatten)
                                            (("2"
                                              (assert)
                                              (("2"
                                                (expand "iqall")
                                                (("2"
                                                  (flatten)
                                                  (("2"
                                                    (inst?)
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (use cup_leto)
                    (("2" (assert)
                      (("2" (hide 2)
                        (("2" (split)
                          (("1" (use from12Eto16)
                            (("1" (use at16_to_out)
                              (("1"
                                (lemma leto_transitive)
                                (("1"
                                  (inst
                                   -
                                   1
                                   "2 * depth(pp) + 1"
                                   _
                                   _
                                   _
                                   _)
                                  (("1"
                                    (inst?)
                                    (("1"
                                      (assert)
                                      (("1"
                                        (inst?)
                                        (("1"
                                          (assert)
                                          (("1"
                                            (hide -2 2)
                                            (("1"
                                              (lemma leto_up)
                                              (("1"
                                                (inst
                                                 -
                                                 "1 + 2 * q!1`length"
                                                 "1 + 2 * depth(pp)"
                                                 _
                                                 _
                                                 _)
                                                (("1"
                                                  (inst?)
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (hide - 2)
                                                      (("1"
                                                        (use
                                                         thread_length_upb)
                                                        (("1"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (use between16_18_out_1)
                            (("2" (assert) nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (sub_leto formula-decl nil bdUnity nil)
    (cup const-decl "bool" ownpred nil)
    (cap const-decl "bool" ownpred nil)
    (at const-decl "bool" tournamentUnity0 nil)
    (between const-decl "bool" tournamentUnity0 nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (kqall const-decl "bool" tournamentSafe0 nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (iq4 const-decl "bool" tournamentSafe0 nil)
    (iq1 const-decl "bool" tournamentSafe0 nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" mucalculus nil)
    (even_plus_odd_is_odd application-judgement "odd_int" integers nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (leto_up formula-decl nil bdUnity nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (leto_transitive formula-decl nil bdUnity nil)
    (from12Eto16 formula-decl nil tournamentUnity0 nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (cup_leto formula-decl nil bdUnity nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (specification type-eq-decl nil bdUnity nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (even_plus_even_is_even application-judgement "even_int" integers
     nil)
    (out const-decl "bool" tournamentUnity0 nil)
    (levleq const-decl "bool" tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil))
   nil)
  (levleq_0_out-2 nil 3670595034
   ("" (skolem!)
    (("" (lemma sub_leto)
      (("" (inst - _ "levleq(q!1, 0)" _ "out(q!1)" _)
        ((""
          (inst - _
           "cup(cap(levleq(q!1, 0), at(q!1, 12)), between(q!1, 16, 18))"
           _)
          (("" (inst?)
            (("" (assert)
              (("" (hide 2)
                (("" (split)
                  (("1" (expand "<=")
                    (("1" (expand "cap")
                      (("1" (expand "cup")
                        (("1" (expand "levleq")
                          (("1" (expand "between")
                            (("1" (skosimp)
                              (("1"
                                (case
                                 "iq1(q!1, s!1) AND iq4(q!1, s!1)")
                                (("1"
                                  (flatten)
                                  (("1"
                                    (expand "iq1")
                                    (("1"
                                      (expand "iq4")
                                      (("1"
                                        (assert)
                                        (("1"
                                          (expand "at")
                                          (("1" (assert) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (expand "E1")
                                  (("2"
                                    (expand "globinv")
                                    (("2"
                                      (expand "kqall")
                                      (("2"
                                        (flatten)
                                        (("2"
                                          (inst?)
                                          (("2"
                                            (flatten)
                                            (("2"
                                              (assert)
                                              (("2"
                                                (expand "iqall")
                                                (("2"
                                                  (flatten)
                                                  (("2"
                                                    (inst?)
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (use cup_leto)
                    (("2" (assert)
                      (("2" (hide 2)
                        (("2" (split)
                          (("1" (use from12Eto16)
                            (("1" (use at16_to_out)
                              (("1"
                                (lemma leto_transitive)
                                (("1"
                                  (inst
                                   -
                                   1
                                   "2 * depth(pp) + 1"
                                   _
                                   _
                                   _
                                   _)
                                  (("1"
                                    (inst?)
                                    (("1"
                                      (assert)
                                      (("1"
                                        (inst?)
                                        (("1"
                                          (assert)
                                          (("1"
                                            (hide -2 2)
                                            (("1"
                                              (lemma leto_up)
                                              (("1"
                                                (inst
                                                 -
                                                 "1 + 2 * q!1`length"
                                                 "1 + 2 * depth(pp)"
                                                 _
                                                 _
                                                 _)
                                                (("1"
                                                  (inst?)
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (hide - 2)
                                                      (("1"
                                                        (expand
                                                         "depth")
                                                        (("1"
                                                          (lemma
                                                           maximum_prop1[digseq])
                                                          (("1"
                                                            (inst
                                                             -
                                                             pp
                                                             len
                                                             q!1)
                                                            (("1"
                                                              (split)
                                                              (("1"
                                                                (name-replace
                                                                 mx
                                                                 "maximum(len, pp)")
                                                                (("1"
                                                                  (expand
                                                                   "len")
                                                                  (("1"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (typepred
                                                                 q!1)
                                                                (("2"
                                                                  (expand
                                                                   "thread")
                                                                  (("2"
                                                                    (expand
                                                                     "leaves")
                                                                    (("2"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (use between16_18_out_1)
                            (("2" (assert) nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((pred type-eq-decl nil defined_types nil)
    (levleq const-decl "bool" tournamentUnity0 nil)
    (out const-decl "bool" tournamentUnity0 nil)
    (even_plus_even_is_even application-judgement "even_int" integers
     nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (cup_leto formula-decl nil bdUnity nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (from12Eto16 formula-decl nil tournamentUnity0 nil)
    (leto_transitive formula-decl nil bdUnity nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (maximum def-decl "nat" maxfinset nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (maximum_prop1 formula-decl nil maxfinset nil)
    (leto_up formula-decl nil bdUnity nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (even_plus_odd_is_odd application-judgement "odd_int" integers nil)
    (<= const-decl "bool" mucalculus nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (iq1 const-decl "bool" tournamentSafe0 nil)
    (iq4 const-decl "bool" tournamentSafe0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (kqall const-decl "bool" tournamentSafe0 nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (between const-decl "bool" tournamentUnity0 nil)
    (at const-decl "bool" tournamentUnity0 nil)
    (cap const-decl "bool" ownpred nil)
    (cup const-decl "bool" ownpred nil)
    (sub_leto formula-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil) (< const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil))
   nil)
  (levleq_0_out-1 nil 3670339839
   ("" (skolem!)
    (("" (lemma sub_leto)
      (("" (inst - _ "levleq(q!1, 0)" _ "out(q!1)" _)
        ((""
          (inst - _
           "cup(cap(levleq(q!1, 0), at(q!1, 12)), between(q!1, 16, 18))"
           _)
          (("" (inst?)
            (("" (assert)
              (("" (hide 2)
                (("" (split)
                  (("1" (expand "<=")
                    (("1" (expand "cap")
                      (("1" (expand "cup")
                        (("1" (expand "levleq")
                          (("1" (expand "between")
                            (("1" (skosimp)
                              (("1"
                                (case
                                 "iq1(q!1, s!1) AND iq4(q!1, s!1)")
                                (("1"
                                  (flatten)
                                  (("1"
                                    (expand "iq1")
                                    (("1"
                                      (expand "iq4")
                                      (("1"
                                        (assert)
                                        (("1"
                                          (expand "at")
                                          (("1" (assert) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (expand "E1")
                                  (("2"
                                    (expand "globinv")
                                    (("2"
                                      (expand "kqall")
                                      (("2"
                                        (flatten)
                                        (("2"
                                          (inst?)
                                          (("2"
                                            (flatten)
                                            (("2"
                                              (assert)
                                              (("2"
                                                (expand "iqall")
                                                (("2"
                                                  (flatten)
                                                  (("2"
                                                    (inst?)
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (use cup_leto)
                    (("2" (assert)
                      (("2" (hide 2)
                        (("2" (split)
                          (("1" (use from12Eto16)
                            (("1" (use at16_to_out)
                              (("1"
                                (lemma leto_transitive)
                                (("1"
                                  (inst
                                   -
                                   1
                                   "2 * q!1`length + 1"
                                   _
                                   _
                                   _
                                   _)
                                  (("1"
                                    (inst?)
                                    (("1"
                                      (assert)
                                      (("1"
                                        (inst?)
                                        (("1" (assert) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (use between16_18_out)
                            (("2" (assert) nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (sub_leto formula-decl nil bdUnity nil)
    (cup const-decl "bool" ownpred nil)
    (cap const-decl "bool" ownpred nil)
    (at const-decl "bool" tournamentUnity0 nil)
    (between const-decl "bool" tournamentUnity0 nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (kqall const-decl "bool" tournamentSafe0 nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (iq4 const-decl "bool" tournamentSafe0 nil)
    (iq1 const-decl "bool" tournamentSafe0 nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" mucalculus nil)
    (even_plus_odd_is_odd application-judgement "odd_int" integers nil)
    (odd_plus_even_is_odd application-judgement "odd_int" integers nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (leto_transitive formula-decl nil bdUnity nil)
    (from12Eto16 formula-decl nil tournamentUnity0 nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (cup_leto formula-decl nil bdUnity nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (specification type-eq-decl nil bdUnity nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (even_plus_even_is_even application-judgement "even_int" integers
     nil)
    (out const-decl "bool" tournamentUnity0 nil)
    (levleq const-decl "bool" tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil))
   shostak))
 (occ_unless_mubot 0
  (occ_unless_mubot-1 nil 3670325469
   ("" (expand "unless")
    (("" (expand "<=")
      (("" (expand "wp")
        (("" (expand "cap")
          (("" (expand "cup")
            (("" (expand "neg")
              (("" (expand "occ")
                (("" (skosimp*)
                  (("" (expand "E1")
                    (("" (expand "step")
                      (("" (assert)
                        (("" (assert)
                          (("" (skolem!)
                            (("" (expand "step")
                              ((""
                                (case "step18(p!1, s!1, y!1)")
                                (("1"
                                  (hide -6)
                                  (("1"
                                    (expand "step18")
                                    (("1"
                                      (flatten)
                                      (("1"
                                        (expand "mubot")
                                        (("1"
                                          (replaceh -1)
                                          (("1"
                                            (expand "next18")
                                            (("1"
                                              (case "q!1=p!1")
                                              (("1" (assert) nil nil)
                                               ("2" (assert) nil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (assert)
                                  (("2"
                                    (hide-all-but (-1 -5 3))
                                    (("2"
                                      (split)
                                      (("1" (grind) nil nil)
                                       ("2" (grind) nil nil)
                                       ("3" (grind) nil nil)
                                       ("4" (grind) nil nil)
                                       ("5" (grind) nil nil)
                                       ("6" (grind) nil nil)
                                       ("7" (grind) nil nil)
                                       ("8" (grind) nil nil)
                                       ("9" (grind) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((<= const-decl "bool" mucalculus nil)
    (cap const-decl "bool" ownpred nil)
    (neg const-decl "bool" ownpred nil)
    (step const-decl "bool" tournamentUnity0 nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (s!1 skolem-const-decl "state[degree, node]" tournamentUnity0 nil)
    (p!1 skolem-const-decl "Thread" tournamentUnity0 nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (empty? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (mubot const-decl "bool" tournamentUnity0 nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (digit type-eq-decl nil ctrees nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (occ const-decl "bool" tournamentUnity0 nil)
    (cup const-decl "bool" ownpred nil)
    (wp const-decl "bool" ownpred nil)
    (unless const-decl "bool" bdUnity nil))
   shostak))
 (mu_to_bot 0
  (mu_to_bot-4 nil 3671446253
   ("" (skosimp)
    (("" (expand "levleq_to_out")
      (("" (lemma sub_leto)
        (("" (inst - m!1 _ _ _ E1)
          (("" (lemma leto_union)
            (("" (inst -2 fullset _ "mubot(nn!1)")
              (("" (assert)
                (("" (inst - m!1 _ "mubot(nn!1)" E1)
                  ((""
                    (name ppset
                          "{pp : pred[state] | EXISTS q: pp = occ(q, nn!1)}")
                    (("" (inst -3 "cup(mubot(nn!1), Union(ppset))")
                      (("" (split)
                        (("1" (hide-all-but (-3 1))
                          (("1" (expand "<=" +)
                            (("1" (expand "cap")
                              (("1"
                                (expand "fullset")
                                (("1"
                                  (expand "cup")
                                  (("1"
                                    (skosimp)
                                    (("1"
                                      (expand "mubot")
                                      (("1"
                                        (expand "Union")
                                        (("1"
                                          (expand "E1")
                                          (("1"
                                            (case "kq1(nn!1, s!1)")
                                            (("1"
                                              (expand "kq1")
                                              (("1"
                                                (split)
                                                (("1"
                                                  (flatten)
                                                  (("1"
                                                    (inst
                                                     +
                                                     "occ(s!1`occ(nn!1), nn!1)")
                                                    (("1"
                                                      (expand "occ")
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (expand "ppset")
                                                      (("2"
                                                        (inst
                                                         +
                                                         "s!1`occ(nn!1)")
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (typepred
                                                   "s!1`mu(nn!1)")
                                                  (("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (expand "globinv")
                                              (("2"
                                                (expand "kqall")
                                                (("2"
                                                  (flatten)
                                                  (("2"
                                                    (inst? -3)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (use cup_leto)
                          (("2" (assert)
                            (("2" (hide 2 3)
                              (("2"
                                (split)
                                (("1"
                                  (hide -)
                                  (("1"
                                    (use subset_leto)
                                    (("1"
                                      (assert)
                                      (("1"
                                        (hide 2)
                                        (("1"
                                          (expand "<=")
                                          (("1"
                                            (expand "cap")
                                            (("1" (skosimp) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (inst?)
                                  (("2"
                                    (assert)
                                    (("2"
                                      (hide -1 1)
                                      (("2"
                                        (skosimp)
                                        (("2"
                                          (expand "ppset")
                                          (("2"
                                            (skolem!)
                                            (("2"
                                              (replaceh -1)
                                              (("2"
                                                (inst - q!1)
                                                (("2"
                                                  (lemma PSP_leto)
                                                  (("2"
                                                    (inst
                                                     -
                                                     m!1
                                                     "levleq(q!1, k!1)"
                                                     _
                                                     _
                                                     "atlev(q!1, 17, k!1)"
                                                     E1)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (use
                                                         occ_unless_mubot)
                                                        (("2"
                                                          (inst?)
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (split
                                                               -4)
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (hide
                                                                   -1
                                                                   -4)
                                                                  (("1"
                                                                    (case
                                                                     "cup(cap(atlev(q!1, 17, k!1), occ(q!1, nn!1)), mubot(nn!1)) = mubot(nn!1)")
                                                                    (("1"
                                                                      (replaceh
                                                                       -1)
                                                                      (("1"
                                                                        (lemma
                                                                         sub_leto)
                                                                        (("1"
                                                                          (inst
                                                                           -
                                                                           m!1
                                                                           "occ(q!1, nn!1)"
                                                                           "cap(levleq(q!1, k!1), occ(q!1, nn!1))"
                                                                           "mubot(nn!1)"
                                                                           E1)
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (hide
                                                                               -
                                                                               2)
                                                                              (("1"
                                                                                (expand
                                                                                 "<=")
                                                                                (("1"
                                                                                  (expand
                                                                                   "cap")
                                                                                  (("1"
                                                                                    (expand
                                                                                     "levleq")
                                                                                    (("1"
                                                                                      (expand
                                                                                       "occ")
                                                                                      (("1"
                                                                                        (skosimp)
                                                                                        (("1"
                                                                                          (assert)
                                                                                          (("1"
                                                                                            (case
                                                                                             "iq4(q!1, s!1) AND kq0(q!1, s!1)")
                                                                                            (("1"
                                                                                              (flatten)
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "kq0")
                                                                                                (("1"
                                                                                                  (expand
                                                                                                   "iq4")
                                                                                                  (("1"
                                                                                                    (flatten)
                                                                                                    (("1"
                                                                                                      (assert)
                                                                                                      nil
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil)
                                                                                             ("2"
                                                                                              (expand
                                                                                               "E1")
                                                                                              (("2"
                                                                                                (expand
                                                                                                 "globinv")
                                                                                                (("2"
                                                                                                  (expand
                                                                                                   "kqall")
                                                                                                  (("2"
                                                                                                    (flatten)
                                                                                                    (("2"
                                                                                                      (inst?)
                                                                                                      (("2"
                                                                                                        (expand
                                                                                                         "iqall")
                                                                                                        (("2"
                                                                                                          (flatten)
                                                                                                          (("2"
                                                                                                            (inst?)
                                                                                                            (("2"
                                                                                                              (flatten)
                                                                                                              (("2"
                                                                                                                (assert)
                                                                                                                nil
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (hide
                                                                       -
                                                                       2)
                                                                      (("2"
                                                                        (apply-extensionality
                                                                         :hide?
                                                                         t)
                                                                        (("2"
                                                                          (iff)
                                                                          (("2"
                                                                            (expand
                                                                             "cup")
                                                                            (("2"
                                                                              (prop)
                                                                              (("2"
                                                                                (expand
                                                                                 "cap")
                                                                                (("2"
                                                                                  (expand
                                                                                   "occ")
                                                                                  (("2"
                                                                                    (flatten)
                                                                                    (("2"
                                                                                      (assert)
                                                                                      (("2"
                                                                                        (expand
                                                                                         "atlev")
                                                                                        (("2"
                                                                                          (propax)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (hide
                                                                 -1
                                                                 -2)
                                                                (("2"
                                                                  (use
                                                                   subset_leto)
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (hide
                                                                       3)
                                                                      (("2"
                                                                        (expand
                                                                         "<=")
                                                                        (("2"
                                                                          (expand
                                                                           "cap")
                                                                          (("2"
                                                                            (expand
                                                                             "occ")
                                                                            (("2"
                                                                              (propax)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((levleq_to_out const-decl "bool" tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil)
    (specification type-eq-decl nil bdUnity nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (mubot const-decl "bool" tournamentUnity0 nil)
    (fullset const-decl "set" sets nil)
    (Union const-decl "set" sets nil)
    (setofsets type-eq-decl nil sets nil)
    (setof type-eq-decl nil defined_types nil)
    (cup const-decl "bool" ownpred nil)
    (cup_leto formula-decl nil bdUnity nil)
    (PSP_leto formula-decl nil bdUnity nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (kq0 const-decl "bool" tournamentSafe0 nil)
    (iq4 const-decl "bool" tournamentSafe0 nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (occ_unless_mubot formula-decl nil tournamentUnity0 nil)
    (levleq const-decl "bool" tournamentUnity0 nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (subset_leto formula-decl nil bdUnity nil)
    (Union_surjective name-judgement
     "(surjective?[setofsets[T], set[T]])" sets_lemmas nil)
    (cap const-decl "bool" ownpred nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (kqall const-decl "bool" tournamentSafe0 nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (nn!1 skolem-const-decl "node" tournamentUnity0 nil)
    (s!1 skolem-const-decl "state[degree, node]" tournamentUnity0 nil)
    (ppset skolem-const-decl "[pred[state] -> boolean]"
     tournamentUnity0 nil)
    (kq1 const-decl "bool" tournamentSafe0 nil)
    (<= const-decl "bool" mucalculus nil)
    (occ const-decl "bool" tournamentUnity0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (leto_union formula-decl nil bdUnity nil)
    (sub_leto formula-decl nil bdUnity nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (digit type-eq-decl nil ctrees nil) (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil))
   nil)
  (mu_to_bot-3 nil 3671433121
   ("" (skosimp)
    (("" (expand "levleq_to_out")
      (("" (lemma sub_leto)
        (("" (inst - m!1 _ _ _ E1)
          (("" (lemma leto_union)
            (("" (inst -2 fullset _ "mubot(nn!1)")
              (("" (assert)
                (("" (inst - m!1 _ "mubot(nn!1)" E1)
                  ((""
                    (name ppset
                          "{pp : pred[state] | EXISTS q: pp = occ(q, nn!1)}")
                    (("" (inst -3 "cup(mubot(nn!1), Union(ppset))")
                      (("" (split)
                        (("1" (hide-all-but (-3 1))
                          (("1" (expand "<=" +)
                            (("1" (expand "cap")
                              (("1"
                                (expand "fullset")
                                (("1"
                                  (expand "cup")
                                  (("1"
                                    (skosimp)
                                    (("1"
                                      (expand "mubot")
                                      (("1"
                                        (expand "Union")
                                        (("1"
                                          (expand "E1")
                                          (("1"
                                            (case "kq1(nn!1, s!1)")
                                            (("1"
                                              (expand "kq1")
                                              (("1"
                                                (split)
                                                (("1"
                                                  (flatten)
                                                  (("1"
                                                    (inst
                                                     +
                                                     "occ(s!1`occ(nn!1), nn!1)")
                                                    (("1"
                                                      (expand "occ")
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (expand "ppset")
                                                      (("2"
                                                        (inst
                                                         +
                                                         "s!1`occ(nn!1)")
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (typepred
                                                   "s!1`mu(nn!1)")
                                                  (("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (expand "globinv")
                                              (("2"
                                                (expand "kqall")
                                                (("2"
                                                  (flatten)
                                                  (("2"
                                                    (inst? -3)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (use cup_leto)
                          (("2" (assert)
                            (("2" (hide 2 3)
                              (("2"
                                (split)
                                (("1"
                                  (hide -)
                                  (("1"
                                    (use subset_leto)
                                    (("1"
                                      (assert)
                                      (("1"
                                        (hide 2)
                                        (("1"
                                          (expand "<=")
                                          (("1"
                                            (expand "cap")
                                            (("1" (skosimp) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (inst?)
                                  (("2"
                                    (assert)
                                    (("2"
                                      (hide -1 1)
                                      (("2"
                                        (skosimp)
                                        (("2"
                                          (expand "ppset")
                                          (("2"
                                            (skolem!)
                                            (("2"
                                              (replaceh -1)
                                              (("2"
                                                (inst - q!1)
                                                (("2"
                                                  (lemma PSP_leto)
                                                  (("2"
                                                    (inst
                                                     -
                                                     m!1
                                                     "levleq(q!1, k!1)"
                                                     _
                                                     _
                                                     "atlev(q!1, 17, k!1)"
                                                     E1)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (use
                                                         occ_unless_mubot)
                                                        (("2"
                                                          (inst?)
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (hide
                                                               -1
                                                               -4)
                                                              (("2"
                                                                (case
                                                                 "cup(cap(atlev(q!1, 17, k!1), occ(q!1, nn!1)), mubot(nn!1)) = mubot(nn!1)")
                                                                (("1"
                                                                  (replaceh
                                                                   -1)
                                                                  (("1"
                                                                    (lemma
                                                                     sub_leto)
                                                                    (("1"
                                                                      (inst
                                                                       -
                                                                       m!1
                                                                       "occ(q!1, nn!1)"
                                                                       "cap(levleq(q!1, k!1), occ(q!1, nn!1))"
                                                                       "mubot(nn!1)"
                                                                       E1)
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (hide
                                                                           -1
                                                                           2)
                                                                          (("1"
                                                                            (expand
                                                                             "<="
                                                                             +)
                                                                            (("1"
                                                                              (expand
                                                                               "cap")
                                                                              (("1"
                                                                                (expand
                                                                                 "occ")
                                                                                (("1"
                                                                                  (expand
                                                                                   "levleq")
                                                                                  (("1"
                                                                                    (skosimp)
                                                                                    (("1"
                                                                                      (assert)
                                                                                      (("1"
                                                                                        (expand
                                                                                         "E1")
                                                                                        (("1"
                                                                                          (case
                                                                                           "iq4(q!1, s!1)")
                                                                                          (("1"
                                                                                            (expand
                                                                                             "iq4")
                                                                                            (("1"
                                                                                              (propax)
                                                                                              nil
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (expand
                                                                                             "globinv")
                                                                                            (("2"
                                                                                              (expand
                                                                                               "kqall")
                                                                                              (("2"
                                                                                                (flatten)
                                                                                                (("2"
                                                                                                  (inst?)
                                                                                                  (("2"
                                                                                                    (assert)
                                                                                                    nil
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (hide
                                                                   -
                                                                   2)
                                                                  (("2"
                                                                    (apply-extensionality
                                                                     :hide?
                                                                     t)
                                                                    (("2"
                                                                      (iff)
                                                                      (("2"
                                                                        (expand
                                                                         "cup")
                                                                        (("2"
                                                                          (prop)
                                                                          (("2"
                                                                            (expand
                                                                             "cap")
                                                                            (("2"
                                                                              (expand
                                                                               "occ")
                                                                              (("2"
                                                                                (flatten)
                                                                                (("2"
                                                                                  (assert)
                                                                                  (("2"
                                                                                    (expand
                                                                                     "atlev")
                                                                                    (("2"
                                                                                      (propax)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (sub_leto formula-decl nil bdUnity nil)
    (leto_union formula-decl nil bdUnity nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (occ const-decl "bool" tournamentUnity0 nil)
    (<= const-decl "bool" mucalculus nil)
    (kq1 const-decl "bool" tournamentSafe0 nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (<= const-decl "bool" reals nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (kqall const-decl "bool" tournamentSafe0 nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (cap const-decl "bool" ownpred nil)
    (Union_surjective name-judgement
     "(surjective?[setofsets[T], set[T]])" sets_lemmas nil)
    (subset_leto formula-decl nil bdUnity nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (levleq const-decl "bool" tournamentUnity0 nil)
    (occ_unless_mubot formula-decl nil tournamentUnity0 nil)
    (iq4 const-decl "bool" tournamentSafe0 nil)
    (PSP_leto formula-decl nil bdUnity nil)
    (cup_leto formula-decl nil bdUnity nil)
    (cup const-decl "bool" ownpred nil)
    (setof type-eq-decl nil defined_types nil)
    (setofsets type-eq-decl nil sets nil)
    (Union const-decl "set" sets nil)
    (fullset const-decl "set" sets nil)
    (mubot const-decl "bool" tournamentUnity0 nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (levleq_to_out const-decl "bool" tournamentUnity0 nil))
   nil)
  (mu_to_bot-2 nil 3671432955
   ("" (skosimp)
    (("" (expand "levleq_to_out")
      (("" (lemma sub_leto)
        (("" (inst - m!1 _ _ _ E1)
          (("" (lemma leto_union)
            (("" (inst -2 fullset _ "mubot(nn!1)")
              (("" (assert)
                (("" (inst - m!1 _ "mubot(nn!1)" E1)
                  ((""
                    (name ppset
                          "{pp : pred[state] | EXISTS q: pp = occ(q, nn!1)}")
                    (("" (inst -3 "cup(mubot(nn!1), Union(ppset))")
                      (("" (split)
                        (("1" (hide-all-but (-3 1))
                          (("1" (expand "<=" +)
                            (("1" (expand "cap")
                              (("1"
                                (expand "fullset")
                                (("1"
                                  (expand "cup")
                                  (("1"
                                    (skosimp)
                                    (("1"
                                      (expand "mubot")
                                      (("1"
                                        (expand "Union")
                                        (("1"
                                          (expand "E1")
                                          (("1"
                                            (case "kq1(nn!1, s!1)")
                                            (("1"
                                              (expand "kq1")
                                              (("1"
                                                (split)
                                                (("1"
                                                  (flatten)
                                                  (("1"
                                                    (inst
                                                     +
                                                     "occ(s!1`occ(nn!1), nn!1)")
                                                    (("1"
                                                      (expand "occ")
                                                      (("1"
                                                        (assert)
                                                        nil)))
                                                     ("2"
                                                      (expand "ppset")
                                                      (("2"
                                                        (inst
                                                         +
                                                         "s!1`occ(nn!1)")
                                                        nil)))))))
                                                 ("2"
                                                  (typepred
                                                   "s!1`mu(nn!1)")
                                                  (("2"
                                                    (assert)
                                                    nil)))))))
                                             ("2"
                                              (expand "globinv")
                                              (("2"
                                                (expand "kqall")
                                                (("2"
                                                  (flatten)
                                                  (("2"
                                                    (inst? -3)
                                                    nil)))))))))))))))))))))))))))
                         ("2" (use cup_leto)
                          (("2" (assert)
                            (("2" (hide 2 3)
                              (("2"
                                (split)
                                (("1"
                                  (hide -)
                                  (("1"
                                    (use subset_leto)
                                    (("1"
                                      (assert)
                                      (("1"
                                        (hide 2)
                                        (("1"
                                          (expand "<=")
                                          (("1"
                                            (expand "cap")
                                            (("1"
                                              (skosimp)
                                              nil)))))))))))))
                                 ("2"
                                  (inst?)
                                  (("2"
                                    (assert)
                                    (("2"
                                      (hide -1 1)
                                      (("2"
                                        (skosimp)
                                        (("2"
                                          (expand "ppset")
                                          (("2"
                                            (skolem!)
                                            (("2"
                                              (replaceh -1)
                                              (("2"
                                                (inst - q!1)
                                                (("2"
                                                  (lemma PSP_leto)
                                                  (("2"
                                                    (inst
                                                     -
                                                     m!1
                                                     "levleq(q!1, k!1)"
                                                     _
                                                     _
                                                     "atlev(q!1, 17, k!1)"
                                                     E1)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (use
                                                         occ_unless_mubot)
                                                        (("2"
                                                          (inst?)
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (hide
                                                               -1
                                                               -4)
                                                              (("2"
                                                                (case
                                                                 "cup(cap(out(q!1), occ(q!1, nn!1)), mubot(nn!1)) = mubot(nn!1)")
                                                                (("1"
                                                                  (replaceh
                                                                   -1)
                                                                  (("1"
                                                                    (lemma
                                                                     sub_leto)
                                                                    (("1"
                                                                      (inst
                                                                       -
                                                                       m!1
                                                                       "occ(q!1, nn!1)"
                                                                       "cap(levleq(q!1, k!1), occ(q!1, nn!1))"
                                                                       "mubot(nn!1)"
                                                                       E1)
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (hide
                                                                           -1
                                                                           2)
                                                                          (("1"
                                                                            (expand
                                                                             "<="
                                                                             +)
                                                                            (("1"
                                                                              (expand
                                                                               "cap")
                                                                              (("1"
                                                                                (expand
                                                                                 "occ")
                                                                                (("1"
                                                                                  (expand
                                                                                   "levleq")
                                                                                  (("1"
                                                                                    (skosimp)
                                                                                    (("1"
                                                                                      (assert)
                                                                                      (("1"
                                                                                        (expand
                                                                                         "E1")
                                                                                        (("1"
                                                                                          (case
                                                                                           "iq4(q!1, s!1)")
                                                                                          (("1"
                                                                                            (expand
                                                                                             "iq4")
                                                                                            (("1"
                                                                                              (propax)
                                                                                              nil)))
                                                                                           ("2"
                                                                                            (expand
                                                                                             "globinv")
                                                                                            (("2"
                                                                                              (expand
                                                                                               "kqall")
                                                                                              (("2"
                                                                                                (flatten)
                                                                                                (("2"
                                                                                                  (inst?)
                                                                                                  (("2"
                                                                                                    (assert)
                                                                                                    nil)))))))))))))))))))))))))))))))))))
                                                                 ("2"
                                                                  (hide
                                                                   -
                                                                   2)
                                                                  (("2"
                                                                    (apply-extensionality
                                                                     :hide?
                                                                     t)
                                                                    (("2"
                                                                      (iff)
                                                                      (("2"
                                                                        (expand
                                                                         "cup")
                                                                        (("2"
                                                                          (prop)
                                                                          (("2"
                                                                            (expand
                                                                             "cap")
                                                                            (("2"
                                                                              (expand
                                                                               "out")
                                                                              (("2"
                                                                                (expand
                                                                                 "occ")
                                                                                (("2"
                                                                                  (flatten)
                                                                                  (("2"
                                                                                    (assert)
                                                                                    nil))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
    nil)
   nil nil)
  (mu_to_bot-1 nil 3670314852
   ("" (skosimp)
    (("" (expand "levleq_to_out")
      (("" (lemma sub_leto)
        (("" (inst - m!1 _ _ _ E1)
          (("" (lemma leto_union)
            (("" (inst -2 fullset _ "mubot(nn!1)")
              (("" (assert)
                (("" (inst - m!1 _ "mubot(nn!1)" E1)
                  ((""
                    (name ppset
                          "{pp : pred[state] | EXISTS q: pp = occ(q, nn!1)}")
                    (("" (inst -3 "cup(mubot(nn!1), Union(ppset))")
                      (("" (split)
                        (("1" (hide-all-but (-3 1))
                          (("1" (expand "<=" +)
                            (("1" (expand "cap")
                              (("1"
                                (expand "fullset")
                                (("1"
                                  (expand "cup")
                                  (("1"
                                    (skosimp)
                                    (("1"
                                      (expand "mubot")
                                      (("1"
                                        (expand "Union")
                                        (("1"
                                          (expand "E1")
                                          (("1"
                                            (case "kq1(nn!1, s!1)")
                                            (("1"
                                              (expand "kq1")
                                              (("1"
                                                (split)
                                                (("1"
                                                  (flatten)
                                                  (("1"
                                                    (inst
                                                     +
                                                     "occ(s!1`occ(nn!1), nn!1)")
                                                    (("1"
                                                      (expand "occ")
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (expand "ppset")
                                                      (("2"
                                                        (inst
                                                         +
                                                         "s!1`occ(nn!1)")
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (typepred
                                                   "s!1`mu(nn!1)")
                                                  (("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (expand "globinv")
                                              (("2"
                                                (expand "kqall")
                                                (("2"
                                                  (flatten)
                                                  (("2"
                                                    (inst? -3)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (use cup_leto)
                          (("2" (assert)
                            (("2" (hide 2 3)
                              (("2"
                                (split)
                                (("1"
                                  (hide -)
                                  (("1"
                                    (use subset_leto)
                                    (("1"
                                      (assert)
                                      (("1"
                                        (hide 2)
                                        (("1"
                                          (expand "<=")
                                          (("1"
                                            (expand "cap")
                                            (("1" (skosimp) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (inst?)
                                  (("2"
                                    (assert)
                                    (("2"
                                      (hide -1 1)
                                      (("2"
                                        (skosimp)
                                        (("2"
                                          (expand "ppset")
                                          (("2"
                                            (skolem!)
                                            (("2"
                                              (replaceh -1)
                                              (("2"
                                                (inst - q!1)
                                                (("2"
                                                  (lemma PSP_leto)
                                                  (("2"
                                                    (inst
                                                     -
                                                     m!1
                                                     "levleq(q!1, k!1)"
                                                     _
                                                     _
                                                     "out(q!1)"
                                                     E1)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (use
                                                         occ_unless_mubot)
                                                        (("2"
                                                          (inst?)
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (hide
                                                               -1
                                                               -4)
                                                              (("2"
                                                                (case
                                                                 "cup(cap(out(q!1), occ(q!1, nn!1)), mubot(nn!1)) = mubot(nn!1)")
                                                                (("1"
                                                                  (replaceh
                                                                   -1)
                                                                  (("1"
                                                                    (lemma
                                                                     sub_leto)
                                                                    (("1"
                                                                      (inst
                                                                       -
                                                                       m!1
                                                                       "occ(q!1, nn!1)"
                                                                       "cap(levleq(q!1, k!1), occ(q!1, nn!1))"
                                                                       "mubot(nn!1)"
                                                                       E1)
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (hide
                                                                           -1
                                                                           2)
                                                                          (("1"
                                                                            (expand
                                                                             "<="
                                                                             +)
                                                                            (("1"
                                                                              (expand
                                                                               "cap")
                                                                              (("1"
                                                                                (expand
                                                                                 "occ")
                                                                                (("1"
                                                                                  (expand
                                                                                   "levleq")
                                                                                  (("1"
                                                                                    (skosimp)
                                                                                    (("1"
                                                                                      (assert)
                                                                                      (("1"
                                                                                        (expand
                                                                                         "E1")
                                                                                        (("1"
                                                                                          (case
                                                                                           "iq4(q!1, s!1)")
                                                                                          (("1"
                                                                                            (expand
                                                                                             "iq4")
                                                                                            (("1"
                                                                                              (propax)
                                                                                              nil
                                                                                              nil))
                                                                                            nil)
                                                                                           ("2"
                                                                                            (expand
                                                                                             "globinv")
                                                                                            (("2"
                                                                                              (expand
                                                                                               "kqall")
                                                                                              (("2"
                                                                                                (flatten)
                                                                                                (("2"
                                                                                                  (inst?)
                                                                                                  (("2"
                                                                                                    (assert)
                                                                                                    nil
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (hide
                                                                   -
                                                                   2)
                                                                  (("2"
                                                                    (apply-extensionality
                                                                     :hide?
                                                                     t)
                                                                    (("2"
                                                                      (iff)
                                                                      (("2"
                                                                        (expand
                                                                         "cup")
                                                                        (("2"
                                                                          (prop)
                                                                          (("2"
                                                                            (expand
                                                                             "cap")
                                                                            (("2"
                                                                              (expand
                                                                               "out")
                                                                              (("2"
                                                                                (expand
                                                                                 "occ")
                                                                                (("2"
                                                                                  (flatten)
                                                                                  (("2"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((levleq_to_out const-decl "bool" tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil)
    (specification type-eq-decl nil bdUnity nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (mubot const-decl "bool" tournamentUnity0 nil)
    (fullset const-decl "set" sets nil)
    (Union const-decl "set" sets nil)
    (setofsets type-eq-decl nil sets nil)
    (setof type-eq-decl nil defined_types nil)
    (cup const-decl "bool" ownpred nil)
    (cup_leto formula-decl nil bdUnity nil)
    (PSP_leto formula-decl nil bdUnity nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (iq4 const-decl "bool" tournamentSafe0 nil)
    (occ_unless_mubot formula-decl nil tournamentUnity0 nil)
    (levleq const-decl "bool" tournamentUnity0 nil)
    (out const-decl "bool" tournamentUnity0 nil)
    (subset_leto formula-decl nil bdUnity nil)
    (Union_surjective name-judgement
     "(surjective?[setofsets[T], set[T]])" sets_lemmas nil)
    (cap const-decl "bool" ownpred nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (kqall const-decl "bool" tournamentSafe0 nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (kq1 const-decl "bool" tournamentSafe0 nil)
    (<= const-decl "bool" mucalculus nil)
    (occ const-decl "bool" tournamentUnity0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (leto_union formula-decl nil bdUnity nil)
    (sub_leto formula-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil) (< const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil))
   shostak))
 (inbranches_TCC1 0
  (inbranches_TCC1-1 nil 3671283495
   ("" (skolem!)
    (("" (lemma finite_subset[Thread])
      (("" (inst - thread _)
        (("" (inst?)
          (("" (assert)
            (("" (hide 2)
              (("" (expand "subset?")
                (("" (expand "member")
                  (("" (expand "restrict") (("" (propax) nil nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (finite_subset formula-decl nil finite_sets nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (digit type-eq-decl nil ctrees nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (depth const-decl "nat" ctrees nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (path const-decl "node" ctrees nil)
    (member const-decl "bool" sets nil)
    (subset? const-decl "bool" sets nil)
    (subset_is_partial_order name-judgement "(partial_order?[set[T]])"
     sets_lemmas nil)
    (restrict const-decl "R" restrict nil)
    (finite_restrict application-judgement "finite_set[S]"
     restrict_set_props nil))
   nil))
 (card_inbranches 0
  (card_inbranches-2 nil 3678615233
   ("" (skosimp)
    (("" (lemma Card_injection[Thread])
      (("" (inst - "inbranches(nn!1, x!1)" degree)
        (("" (name kl "depth(nn!1)")
          (("" (assert)
            (("" (hide 2)
              ((""
                (inst + "lambda (q: (inbranches(nn!1, x!1))):
   IF kl < depth(q) THEN sib(q, kl) ELSE 0 ENDIF")
                (("" (expand "injective?")
                  (("" (skosimp)
                    (("" (name-replace qq x1!1)
                      (("" (name-replace rr x2!1)
                        (("" (typepred qq)
                          (("" (typepred rr)
                            (("" (expand "inbranches")
                              ((""
                                (flatten)
                                ((""
                                  (assert)
                                  ((""
                                    (replace -9)
                                    ((""
                                      (case "mx(qq, rr, kl+1, x!1)")
                                      (("1"
                                        (expand "mx")
                                        (("1"
                                          (lemma joining_paths)
                                          (("1"
                                            (inst?)
                                            (("1" (assert) nil nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (use mx_j_implied)
                                        (("2"
                                          (assert)
                                          (("2"
                                            (expand "globinv")
                                            (("2" (propax) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (Card_injection formula-decl nil finite_sets nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (depth const-decl "nat" ctrees nil)
    (injective? const-decl "bool" functions nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (mx const-decl "bool" tournamentSafe0 nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (joining_paths formula-decl nil ctrees nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (mx_j_implied formula-decl nil tournamentSafe0 nil)
    (sib const-decl "digit" ctrees nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (below type-eq-decl nil nat_types nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (inbranches const-decl "finite_set[Thread]" tournamentUnity0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (digit type-eq-decl nil ctrees nil))
   nil)
  (card_inbranches-1 nil 3671283496
   ("" (skosimp)
    (("" (lemma Card_injection[Thread])
      (("" (inst - "inbranches(nn!1, x!1)" degree)
        (("" (name kl "nn!1`length")
          (("" (assert)
            (("" (hide 2)
              ((""
                (inst + "lambda (q: (inbranches(nn!1, x!1))): 
IF kl < q`length THEN q`seq(kl) ELSE 0 ENDIF")
                (("" (expand "injective?")
                  (("" (skosimp)
                    (("" (name-replace qq x1!1)
                      (("" (name-replace rr x2!1)
                        (("" (typepred qq)
                          (("" (typepred rr)
                            (("" (expand "inbranches")
                              ((""
                                (flatten)
                                ((""
                                  (assert)
                                  ((""
                                    (replace -9)
                                    ((""
                                      (use inductive_eq)
                                      ((""
                                        (assert)
                                        ((""
                                          (case
                                           "mx(qq, rr, kl+1, x!1)")
                                          (("1"
                                            (expand "mx")
                                            (("1" (propax) nil nil))
                                            nil)
                                           ("2"
                                            (use mx_j_implied)
                                            (("2"
                                              (assert)
                                              (("2"
                                                (expand "globinv")
                                                (("2"
                                                  (propax)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (Card_injection formula-decl nil finite_sets nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (injective? const-decl "bool" functions nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (mx_j_implied formula-decl nil tournamentSafe0 nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (inbranches const-decl "finite_set[Thread]" tournamentUnity0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil))
   shostak))
 (cprio_TCC1 0
  (cprio_TCC1-1 nil 3670228151
   ("" (skosimp)
    (("" (lemma finite_subset[Thread])
      (("" (inst - thread _)
        (("" (assert)
          (("" (inst?)
            (("" (assert) (("" (hide 2) (("" (grind) nil nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (finite_subset formula-decl nil finite_sets nil)
    (subset_is_partial_order name-judgement "(partial_order?[set[T]])"
     sets_lemmas nil)
    (member const-decl "bool" sets nil)
    (leaf const-decl "finite_set[node]" ctrees nil)
    (subset? const-decl "bool" sets nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (<= const-decl "bool" reals nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (digit type-eq-decl nil ctrees nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (restrict const-decl "R" restrict nil)
    (finite_restrict application-judgement "finite_set[S]"
     restrict_set_props nil))
   nil))
 (cprio_sub_inbranches 0
  (cprio_sub_inbranches-1 nil 3671284268
   ("" (expand "inbranches")
    (("" (expand "cprio")
      (("" (skosimp)
        (("" (expand "curnode")
          (("" (lemma depth_path)
            (("" (inst-cp - _ q!1)
              ((""
                (case "iq0(q!1, x!1) AND iq1(q!1, x!1) AND iq0(r!1, x!1) 
AND iq1(r!1, x!1)")
                (("1" (flatten)
                  (("1" (inst? -6)
                    (("1" (inst - _ r!1)
                      (("1" (inst?)
                        (("1" (expand "iq0")
                          (("1" (flatten) (("1" (assert) nil nil))
                            nil))
                          nil)
                         ("2" (expand "iq1") (("2" (assert) nil nil))
                          nil))
                        nil))
                      nil)
                     ("2" (expand "iq1") (("2" (assert) nil nil)) nil))
                    nil))
                  nil)
                 ("2" (expand "globinv")
                  (("2" (expand "iqall")
                    (("2" (flatten)
                      (("2" (hide-all-but (-7 1))
                        (("2" (inst-cp - q!1)
                          (("2" (inst - r!1)
                            (("2" (flatten) (("2" (assert) nil nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((cprio const-decl "finite_set[Thread]" tournamentUnity0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (r!1 skolem-const-decl "Thread" tournamentUnity0 nil)
    (q!1 skolem-const-decl "Thread" tournamentUnity0 nil)
    (x!1 skolem-const-decl "state[degree, node]" tournamentUnity0 nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (digit type-eq-decl nil ctrees nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (iq1 const-decl "bool" tournamentSafe0 nil)
    (depth_path formula-decl nil ctrees nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (inbranches const-decl "finite_set[Thread]" tournamentUnity0 nil))
   shostak))
 (level_cprio 0
  (level_cprio-1 nil 3671279021
   ("" (skosimp)
    (("" (expand "cprio")
      (("" (flatten)
        (("" (assert)
          (("" (expand "globinv")
            (("" (flatten)
              (("" (assert)
                (("" (expand "curnode")
                  (("" (hide 1)
                    ((""
                      (case "iq0(q!1, x!1) AND iq0(r!1, x!1) AND iq1(q!1, x!1) 
AND iq1(r!1, x!1)")
                      (("1" (flatten)
                        (("1" (expand "iq0")
                          (("1" (expand "iq1")
                            (("1" (flatten)
                              (("1"
                                (use equal_paths)
                                (("1" (assert) nil nil)
                                 ("2" (assert) nil nil)
                                 ("3" (assert) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (expand "iqall")
                        (("2" (flatten)
                          (("2" (inst-cp - q!1)
                            (("2" (inst - r!1)
                              (("2"
                                (flatten)
                                (("2" (assert) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((cprio const-decl "finite_set[Thread]" tournamentUnity0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (iq1 const-decl "bool" tournamentSafe0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (digit type-eq-decl nil ctrees nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (x!1 skolem-const-decl "state[degree, node]" tournamentUnity0 nil)
    (r!1 skolem-const-decl "Thread" tournamentUnity0 nil)
    (q!1 skolem-const-decl "Thread" tournamentUnity0 nil)
    (equal_paths formula-decl nil ctrees nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (globinv const-decl "bool" tournamentSafe1 nil))
   shostak))
 (cprio_shrinks_at15 0
  (cprio_shrinks_at15-6 nil 3678801276
   ("" (expand "cprio")
    (("" (skosimp)
      (("" (assert)
        (("" (expand "curnode")
          (("" (case "y!1`level(q!1) = x!1`level(q!1)")
            (("1" (expand "curbranch")
              (("1" (replaceh -1)
                (("1" (case "r!1=p!1")
                  (("1" (replaceh -1)
                    (("1"
                      (case "step13(p!1, x!1, y!1) OR step14(p!1, x!1, y!1)")
                      (("1" (hide -6)
                        (("1" (split)
                          (("1" (expand "step13")
                            (("1" (flatten)
                              (("1"
                                (replaceh -1)
                                (("1"
                                  (expand "next13")
                                  (("1"
                                    (assert)
                                    (("1"
                                      (lift-if)
                                      (("1"
                                        (assert)
                                        (("1"
                                          (expand "curnode")
                                          (("1"
                                            (expand "curbranch")
                                            (("1"
                                              (expand "lq1")
                                              (("1"
                                                (expand "curnode")
                                                (("1"
                                                  (expand "curbranch")
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (expand "step14")
                            (("2" (flatten)
                              (("2"
                                (replaceh -1)
                                (("2"
                                  (expand "next14")
                                  (("2" (assert) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (flatten)
                        (("2" (expand "step")
                          (("2" (assert)
                            (("2" (hide-all-but (-3 -4 -5))
                              (("2"
                                (split)
                                (("1" (grind) nil nil)
                                 ("2" (grind) nil nil)
                                 ("3" (grind) nil nil)
                                 ("4" (grind) nil nil)
                                 ("5" (grind) nil nil)
                                 ("6" (grind) nil nil)
                                 ("7" (grind) nil nil)
                                 ("8" (grind) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2"
                    (case "y!1`pc(r!1) = x!1`pc(r!1) AND y!1`level(r!1) = x!1`level(r!1)")
                    (("1" (flatten)
                      (("1" (replaceh -1)
                        (("1" (replaceh -1)
                          (("1" (assert)
                            (("1" (case "step13(p!1, x!1, y!1)")
                              (("1"
                                (hide -6)
                                (("1"
                                  (expand "step13")
                                  (("1"
                                    (flatten)
                                    (("1"
                                      (replaceh -1)
                                      (("1"
                                        (expand "next13")
                                        (("1"
                                          (case
                                           "(curnode(p!1, x!1), curbranch(p!1, x!1)) = (path(r!1, x!1`level(r!1)), sib(r!1, x!1`level(r!1)))")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (flatten)
                                              (("1"
                                                (expand "curnode")
                                                (("1"
                                                  (expand "curbranch")
                                                  (("1"
                                                    (use mx_used)
                                                    (("1"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (lift-if)
                                            (("2"
                                              (assert)
                                              (("2"
                                                (hide -)
                                                (("2"
                                                  (ground)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (case
                                 "x!1`pc(p!1) = 15 AND y!1 = next15(p!1, x!1)")
                                (("1"
                                  (flatten)
                                  (("1"
                                    (hide -7 1)
                                    (("1"
                                      (replaceh -2)
                                      (("1"
                                        (expand "next15")
                                        (("1"
                                          (assert)
                                          (("1"
                                            (split +)
                                            (("1"
                                              (flatten)
                                              (("1"
                                                (expand "remove")
                                                (("1"
                                                  (expand "member")
                                                  (("1"
                                                    (flatten)
                                                    (("1"
                                                      (expand
                                                       "curnode")
                                                      (("1"
                                                        (expand
                                                         "curbranch")
                                                        (("1"
                                                          (replaceh -5)
                                                          (("1"
                                                            (use
                                                             mx_used)
                                                            (("1"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2" (propax) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (expand "step")
                                  (("2"
                                    (case
                                     "step15F(p!1, x!1, y!1) OR step15G(p!1, x!1, y!1)")
                                    (("1"
                                      (hide-all-but (-1 1))
                                      (("1"
                                        (expand "step15F")
                                        (("1"
                                          (expand "step15G")
                                          (("1" (ground) nil nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (flatten)
                                      (("2"
                                        (assert)
                                        (("2"
                                          (hide-all-but (-5 -9 6))
                                          (("2"
                                            (split -)
                                            (("1" (grind) nil nil)
                                             ("2" (grind) nil nil)
                                             ("3" (grind) nil nil)
                                             ("4" (grind) nil nil)
                                             ("5" (grind) nil nil)
                                             ("6" (grind) nil nil)
                                             ("7" (grind) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide-all-but (-5 1 2))
                      (("2" (split)
                        (("1" (grind) nil nil) ("2" (grind) nil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (hide-all-but (-5 1 4)) (("2" (grind) nil nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((curnode const-decl "node" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (lq1 const-decl "bool" tournamentSafe1 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (path const-decl "node" ctrees nil)
    (sib const-decl "digit" ctrees nil)
    (mx_used formula-decl nil tournamentSafe1 nil)
    (remove const-decl "set" sets nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (digit type-eq-decl nil ctrees nil) (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (cprio const-decl "finite_set[Thread]" tournamentUnity0 nil))
   nil)
  (cprio_shrinks_at15-5 nil 3678618106
   ("" (expand "cprio")
    (("" (skosimp)
      (("" (assert)
        (("" (expand "curnode")
          (("" (case "y!1`level(q!1) = x!1`level(q!1)")
            (("1" (expand "curbranch")
              (("1" (replaceh -1)
                (("1" (case "r!1=p!1")
                  (("1" (replaceh -1)
                    (("1"
                      (case "step13(p!1, x!1, y!1) OR step14(p!1, x!1, y!1)")
                      (("1" (hide -6)
                        (("1" (split)
                          (("1" (expand "step13")
                            (("1" (flatten)
                              (("1"
                                (replaceh -1)
                                (("1"
                                  (expand "next13")
                                  (("1"
                                    (assert)
                                    (("1"
                                      (lift-if)
                                      (("1"
                                        (assert)
                                        (("1"
                                          (expand "curnode")
                                          (("1"
                                            (expand "curbranch")
                                            (("1"
                                              (expand "lq1")
                                              (("1"
                                                (expand "curnode")
                                                (("1"
                                                  (expand "curbranch")
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (expand "step14")
                            (("2" (flatten)
                              (("2"
                                (replaceh -1)
                                (("2"
                                  (expand "next14")
                                  (("2" (assert) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (flatten)
                        (("2" (expand "step")
                          (("2" (assert)
                            (("2" (hide-all-but (-3 -4 -5))
                              (("2"
                                (split)
                                (("1" (grind) nil nil)
                                 ("2" (grind) nil nil)
                                 ("3" (grind) nil nil)
                                 ("4" (grind) nil nil)
                                 ("5" (grind) nil nil)
                                 ("6" (grind) nil nil)
                                 ("7" (grind) nil nil)
                                 ("8" (grind) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2"
                    (case "y!1`pc(r!1) = x!1`pc(r!1) AND y!1`level(r!1) = x!1`level(r!1)")
                    (("1" (flatten)
                      (("1" (replaceh -1)
                        (("1" (replaceh -1)
                          (("1" (assert)
                            (("1" (case "step13(p!1, x!1, y!1)")
                              (("1"
                                (hide -6)
                                (("1"
                                  (expand "step13")
                                  (("1"
                                    (flatten)
                                    (("1"
                                      (replaceh -1)
                                      (("1"
                                        (expand "next13")
                                        (("1"
                                          (case
                                           "(curnode(p!1, x!1), curbranch(p!1, x!1)) = (path(r!1, x!1`level(r!1)), sib(r!1, x!1`level(r!1)))")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (flatten)
                                              (("1"
                                                (expand "curnode")
                                                (("1"
                                                  (expand "curbranch")
                                                  (("1"
                                                    (case
                                                     "iq0(p!1, x!1) AND iq1(p!1, x!1) AND iq0(r!1, x!1) AND iq1(r!1, x!1)")
                                                    (("1"
                                                      (use equal_paths)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (flatten)
                                                          (("1"
                                                            (expand
                                                             "iq0")
                                                            (("1"
                                                              (flatten)
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (use
                                                                   joining_paths)
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (case
                                                                       "mx(p!1, r!1, 1 + x!1`level(p!1), x!1)")
                                                                      (("1"
                                                                        (expand
                                                                         "mx")
                                                                        (("1"
                                                                          (propax)
                                                                          nil
                                                                          nil))
                                                                        nil)
                                                                       ("2"
                                                                        (use
                                                                         mx_j_implied)
                                                                        (("2"
                                                                          (assert)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (expand
                                                                     "iq1")
                                                                    (("2"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (flatten)
                                                        (("2"
                                                          (expand
                                                           "iq1")
                                                          (("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("3"
                                                        (flatten)
                                                        (("3"
                                                          (expand
                                                           "iq1")
                                                          (("3"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (hide-all-but
                                                       (-8 1))
                                                      (("2"
                                                        (expand
                                                         "iqall")
                                                        (("2"
                                                          (flatten)
                                                          (("2"
                                                            (inst-cp
                                                             -
                                                             p!1)
                                                            (("2"
                                                              (inst
                                                               -
                                                               r!1)
                                                              (("2"
                                                                (flatten)
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (lift-if)
                                            (("2"
                                              (assert)
                                              (("2"
                                                (hide -)
                                                (("2"
                                                  (ground)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (case
                                 "x!1`pc(p!1) = 15 AND y!1 = next15(p!1, x!1)")
                                (("1"
                                  (flatten)
                                  (("1"
                                    (hide -7 1)
                                    (("1"
                                      (replaceh -2)
                                      (("1"
                                        (expand "next15")
                                        (("1"
                                          (assert)
                                          (("1"
                                            (split +)
                                            (("1"
                                              (flatten)
                                              (("1"
                                                (expand "remove")
                                                (("1"
                                                  (expand "member")
                                                  (("1"
                                                    (flatten)
                                                    (("1"
                                                      (expand
                                                       "curnode")
                                                      (("1"
                                                        (expand
                                                         "curbranch")
                                                        (("1"
                                                          (replaceh -5)
                                                          (("1"
                                                            (case
                                                             "iq0(p!1, x!1) AND iq0(q!1, x!1) AND iq1(p!1, x!1) AND iq1(q!1, x!1)")
                                                            (("1"
                                                              (flatten)
                                                              (("1"
                                                                (use
                                                                 equal_paths)
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (expand
                                                                     "iq0")
                                                                    (("1"
                                                                      (flatten)
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (use
                                                                           joining_paths)
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (case
                                                                               "mx(p!1, q!1, x!1`level(p!1) + 1 , x!1)")
                                                                              (("1"
                                                                                (expand
                                                                                 "mx")
                                                                                (("1"
                                                                                  (propax)
                                                                                  nil
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (use
                                                                                 mx_j_implied)
                                                                                (("2"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (expand
                                                                             "iq1")
                                                                            (("2"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (expand
                                                                   "iq1")
                                                                  (("2"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil)
                                                                 ("3"
                                                                  (expand
                                                                   "iq1")
                                                                  (("3"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (hide-all-but
                                                               (-7 1))
                                                              (("2"
                                                                (expand
                                                                 "iqall")
                                                                (("2"
                                                                  (flatten)
                                                                  (("2"
                                                                    (inst-cp
                                                                     -
                                                                     p!1)
                                                                    (("2"
                                                                      (inst
                                                                       -
                                                                       q!1)
                                                                      (("2"
                                                                        (flatten)
                                                                        (("2"
                                                                          (assert)
                                                                          nil
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2" (propax) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (expand "step")
                                  (("2"
                                    (case
                                     "step15F(p!1, x!1, y!1) OR step15G(p!1, x!1, y!1)")
                                    (("1"
                                      (hide-all-but (-1 1))
                                      (("1"
                                        (expand "step15F")
                                        (("1"
                                          (expand "step15G")
                                          (("1" (ground) nil nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (flatten)
                                      (("2"
                                        (assert)
                                        (("2"
                                          (hide-all-but (-5 -9 6))
                                          (("2"
                                            (split -)
                                            (("1" (grind) nil nil)
                                             ("2" (grind) nil nil)
                                             ("3" (grind) nil nil)
                                             ("4" (grind) nil nil)
                                             ("5" (grind) nil nil)
                                             ("6" (grind) nil nil)
                                             ("7" (grind) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide-all-but (-5 1 2))
                      (("2" (split)
                        (("1" (grind) nil nil) ("2" (grind) nil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (hide-all-but (-5 1 4)) (("2" (grind) nil nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((curnode const-decl "node" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (lq1 const-decl "bool" tournamentSafe1 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (mx_j_implied formula-decl nil tournamentSafe0 nil)
    (iq1 const-decl "bool" tournamentSafe0 nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (remove const-decl "set" sets nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (cprio const-decl "finite_set[Thread]" tournamentUnity0 nil))
   nil)
  (cprio_shrinks_at15-4 nil 3678618016
   ("" (expand "cprio")
    (("" (skosimp)
      (("" (assert)
        (("" (expand "curnode")
          (("" (case "y!1`level(q!1) = x!1`level(q!1)")
            (("1" (expand "curbranch")
              (("1" (replaceh -1)
                (("1" (case "r!1=p!1")
                  (("1" (postpone) nil nil)
                   ("2"
                    (case "y!1`pc(r!1) = x!1`pc(r!1) AND y!1`level(r!1) = x!1`level(r!1)")
                    (("1" (flatten)
                      (("1" (replaceh -1)
                        (("1" (replaceh -1)
                          (("1" (assert)
                            (("1" (case "step13(p!1, x!1, y!1)")
                              (("1"
                                (hide -6)
                                (("1"
                                  (expand "step13")
                                  (("1"
                                    (flatten)
                                    (("1"
                                      (replaceh -1)
                                      (("1"
                                        (expand "next13")
                                        (("1"
                                          (case
                                           "(curnode(p!1, x!1), curbranch(p!1, x!1)) = (path(r!1, x!1`level(r!1)), sib(r!1, x!1`level(r!1)))")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (flatten)
                                              (("1"
                                                (expand "curnode")
                                                (("1"
                                                  (expand "curbranch")
                                                  (("1"
                                                    (case
                                                     "iq0(p!1, x!1) AND iq1(p!1, x!1) AND iq0(r!1, x!1)")
                                                    (("1"
                                                      (use equal_paths)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (flatten)
                                                          (("1"
                                                            (expand
                                                             "iq0")
                                                            (("1"
                                                              (flatten)
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (use
                                                                   joining_paths)
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (expand
                                                                       "mx")
                                                                      (("1"
                                                                        (propax)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (expand
                                                                     "iq1")
                                                                    (("2"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (flatten)
                                                        (("2"
                                                          (postpone)
                                                          nil
                                                          nil))
                                                        nil)
                                                       ("3"
                                                        (postpone)
                                                        nil
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (postpone)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2" (postpone) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2" (postpone) nil nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (postpone) nil nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (postpone) nil nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   nil nil)
  (cprio_shrinks_at15-3 nil 3678617837
   ("" (expand "cprio")
    (("" (skosimp)
      (("" (assert)
        (("" (expand "curnode")
          (("" (case "y!1`level(q!1) = x!1`level(q!1)")
            (("1" (expand "curbranch")
              (("1" (replaceh -1)
                (("1" (case "r!1=p!1")
                  (("1" (postpone) nil)
                   ("2"
                    (case "y!1`pc(r!1) = x!1`pc(r!1) AND y!1`level(r!1) = x!1`level(r!1)")
                    (("1" (flatten)
                      (("1" (replaceh -1)
                        (("1" (replaceh -1)
                          (("1" (assert)
                            (("1" (case "step13(p!1, x!1, y!1)")
                              (("1"
                                (hide -6)
                                (("1"
                                  (expand "step13")
                                  (("1"
                                    (flatten)
                                    (("1"
                                      (replaceh -1)
                                      (("1"
                                        (expand "next13")
                                        (("1"
                                          (case
                                           "(curnode(p!1, x!1), curbranch(p!1, x!1)) = (path(r!1, x!1`level(r!1)), sib(r!1, x!1`level(r!1)))")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (flatten)
                                              (("1"
                                                (expand "curnode")
                                                (("1"
                                                  (expand "curbranch")
                                                  (("1"
                                                    (use equal_paths)
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (case
                                                         "iq0(p!1, x!1) AND iq1(p!1, x!1) AND iq0(r!1, x!1)")
                                                        (("1"
                                                          (flatten)
                                                          (("1"
                                                            (expand
                                                             "iq0")
                                                            (("1"
                                                              (flatten)
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (use
                                                                   joining_paths)
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (postpone)
                                                                      nil)))
                                                                   ("2"
                                                                    (postpone)
                                                                    nil)))))))))))
                                                         ("2"
                                                          (postpone)
                                                          nil)))))
                                                     ("2"
                                                      (postpone)
                                                      nil)
                                                     ("3"
                                                      (postpone)
                                                      nil)))))))))))
                                           ("2"
                                            (postpone)
                                            nil)))))))))))))
                               ("2" (postpone) nil)))))))))))
                     ("2" (postpone) nil)))))))))
             ("2" (postpone) nil))))))))))
    nil)
   nil nil)
  (cprio_shrinks_at15-2 nil 3671265025
   ("" (expand "cprio")
    (("" (skosimp)
      (("" (assert)
        (("" (expand "curnode")
          (("" (case "y!1`level(q!1) = x!1`level(q!1)")
            (("1" (expand "curbranch")
              (("1" (replaceh -1)
                (("1" (case "r!1=p!1")
                  (("1" (postpone) nil nil)
                   ("2"
                    (case "y!1`pc(r!1) = x!1`pc(r!1) AND y!1`level(r!1) = x!1`level(r!1)")
                    (("1" (flatten)
                      (("1" (replaceh -1)
                        (("1" (replaceh -1)
                          (("1" (assert)
                            (("1" (case "step13(p!1, x!1, y!1)")
                              (("1"
                                (hide -6)
                                (("1"
                                  (expand "step13")
                                  (("1"
                                    (flatten)
                                    (("1"
                                      (replaceh -1)
                                      (("1"
                                        (expand "next13")
                                        (("1"
                                          (case
                                           "(curnode(p!1, x!1), curbranch(p!1, x!1)) = (path(r!1, x!1`level(r!1)), sib(r!1, x!1`level(r!1)))")
                                          (("1"
                                            (assert)
                                            (("1"
                                              (flatten)
                                              (("1"
                                                (expand "curnode")
                                                (("1"
                                                  (expand "curbranch")
                                                  (("1"
                                                    (use equal_paths)
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (case
                                                         "iq0(p!1, x!1) AND iq0(r!1, x!1)")
                                                        (("1"
                                                          (flatten)
                                                          (("1"
                                                            (expand
                                                             "iq0")
                                                            (("1"
                                                              (flatten)
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (use
                                                                   joining_paths)
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (postpone)
                                                                      nil
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (postpone)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (postpone)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (postpone)
                                                      nil
                                                      nil)
                                                     ("3"
                                                      (postpone)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2" (postpone) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2" (postpone) nil nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (postpone) nil nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (postpone) nil nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (rat_max application-judgement "{s: rat | s >= q AND s >= r}"
     real_defs nil)
    (int_max application-judgement "{k: int | i <= k AND j <= k}"
     real_defs nil)
    (nat_min application-judgement "{k: nat | k <= i AND k <= j}"
     real_defs nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (min const-decl "{p: real | p <= m AND p <= n}" real_defs nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (lq1 const-decl "bool" tournamentSafe1 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (remove const-decl "set" sets nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (cprio const-decl "finite_set[Thread]" tournamentUnity0 nil))
   nil)
  (cprio_shrinks_at15-1 nil 3670229725
   ("" (expand "cprio")
    (("" (skosimp)
      (("" (assert)
        (("" (case "r!1=p!1")
          (("1" (replaceh -1)
            (("1" (expand "step")
              (("1"
                (case "step13(p!1, x!1, y!1) OR step14(p!1, x!1, y!1)")
                (("1" (hide -6)
                  (("1" (split -)
                    (("1" (expand "step13")
                      (("1" (flatten)
                        (("1" (replaceh -1)
                          (("1" (expand "curnode")
                            (("1" (expand "next13")
                              (("1"
                                (assert)
                                (("1"
                                  (case "lq1(q!1, x!1)")
                                  (("1"
                                    (expand "lq1")
                                    (("1" (propax) nil nil))
                                    nil)
                                   ("2" (propax) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (expand "step14")
                      (("2" (flatten)
                        (("2" (replaceh -1)
                          (("2" (expand "curnode")
                            (("2" (expand "next14")
                              (("2" (assert) nil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (flatten)
                  (("2" (assert)
                    (("2" (hide-all-but (-3 -4 -5))
                      (("2" (grind) nil nil)) nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (expand "curnode")
            (("2"
              (case " y!1`level(q!1) = x!1`level(q!1) AND 
y!1`pc(r!1) = x!1`pc(r!1) AND y!1`level(r!1) = x!1`level(r!1) 
AND y!1`prio(r!1)(q!1) = x!1`prio(r!1)(q!1)")
              (("1" (flatten) (("1" (assert) nil nil)) nil)
               ("2" (hide-all-but (-5 1 2 6))
                (("2" (split)
                  (("1" (grind) nil nil) ("2" (grind) nil nil)
                   ("3" (grind) nil nil) ("4" (grind) nil nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (rat_max application-judgement "{s: rat | s >= q AND s >= r}"
     real_defs nil)
    (int_max application-judgement "{k: int | i <= k AND j <= k}"
     real_defs nil)
    (nat_min application-judgement "{k: nat | k <= i AND k <= j}"
     real_defs nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (min const-decl "{p: real | p <= m AND p <= n}" real_defs nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (remove const-decl "set" sets nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (cprio const-decl "finite_set[Thread]" tournamentUnity0 nil))
   shostak))
 (card_cprio_shrinks 0
  (card_cprio_shrinks-1 nil 3670395986
   ("" (skosimp)
    (("" (case "subset?(cprio(q!1, y!1), cprio(q!1, x!1))")
      (("1" (use card_subset[Thread]) (("1" (assert) nil nil)) nil)
       ("2" (hide 2)
        (("2" (expand "subset?")
          (("2" (expand "member")
            (("2" (skosimp)
              (("2" (lemma cprio_shrinks_at15)
                (("2" (inst - p!1 q!1 x!2 x!1 y!1)
                  (("2" (assert)
                    (("2" (expand "globinv")
                      (("2" (expand "lqall")
                        (("2" (flatten)
                          (("2" (inst? -7) (("2" (assert) nil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((cprio const-decl "finite_set[Thread]" tournamentUnity0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (digit type-eq-decl nil ctrees nil)
    (subset? const-decl "bool" sets nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (subset_is_partial_order name-judgement "(partial_order?[set[T]])"
     sets_lemmas nil)
    (card_subset formula-decl nil finite_sets nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (lqall const-decl "bool" tournamentSafe1 nil)
    (cprio_shrinks_at15 formula-decl nil tournamentUnity0 nil)
    (member const-decl "bool" sets nil))
   shostak))
 (card_cprio 0
  (card_cprio-3 nil 3671285202
   ("" (skosimp)
    (("" (use card_inbranches (nn "curnode(q!1, x!1)"))
      (("" (assert)
        (("" (lemma card_subset[Thread])
          ((""
            (inst - "cprio(q!1, x!1)"
             "inbranches(curnode(q!1, x!1), x!1)")
            (("" (assert)
              (("" (hide -1 2)
                (("" (expand "subset?")
                  (("" (expand "member")
                    (("" (skosimp)
                      (("" (use cprio_sub_inbranches)
                        (("" (assert) nil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((card_inbranches formula-decl nil tournamentUnity0 nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (digit type-eq-decl nil ctrees nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (card_subset formula-decl nil finite_sets nil)
    (subset_is_partial_order name-judgement "(partial_order?[set[T]])"
     sets_lemmas nil)
    (subset? const-decl "bool" sets nil)
    (cprio_sub_inbranches formula-decl nil tournamentUnity0 nil)
    (member const-decl "bool" sets nil)
    (cprio const-decl "finite_set[Thread]" tournamentUnity0 nil)
    (inbranches const-decl "finite_set[Thread]" tournamentUnity0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil)
  (card_cprio-2 nil 3671285138
   ("" (skosimp)
    (("" (use card_inbranches (nn "curnode(q!1, x!1)"))
      (("1" (assert)
        (("1" (lemma card_subset[Thread])
          (("1" (inst - "cprio(q!1, x!1)" "inbranches(q!1, x!1)")
            (("1" (assert)
              (("1" (hide -1 2)
                (("1" (expand "subset?")
                  (("1" (expand "member")
                    (("1" (skosimp)
                      (("1" (use cprio_sub_inbranches)
                        (("1" (assert)
                          (("1" (postpone) nil)))))))))))))))))))))
       ("2" (postpone) nil))))
    nil)
   nil nil)
  (card_cprio-1 nil 3670230697
   ("" (skosimp)
    (("" (use card_inbranches)
      (("1" (assert)
        (("1" (lemma card_subset[Thread])
          (("1" (inst - "cprio(q!1, x!1)" "inbranches(q!1, x!1)")
            (("1" (assert)
              (("1" (hide -1 2)
                (("1" (expand "subset?")
                  (("1" (expand "member")
                    (("1" (skosimp)
                      (("1" (use cprio_sub_inbranches)
                        (("1" (assert) (("1" (postpone) nil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (postpone) nil nil))
      nil))
    nil)
   ((Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (Card_injection formula-decl nil finite_sets nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (cprio const-decl "finite_set[Thread]" tournamentUnity0 nil)
    (injective? const-decl "bool" functions nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (mx_j_implied formula-decl nil tournamentSafe0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   shostak))
 (card_cprio_mu 0
  (card_cprio_mu-1 nil 3671276128
   ("" (skosimp)
    (("" (name-replace nn1 "curnode(q!1, x!1)" nil)
      (("" (case "kq1(nn1, x!1)")
        (("1" (expand "kq1")
          (("1" (assert)
            (("1" (flatten)
              (("1" (name-replace rr "x!1`occ(nn1)")
                (("1" (assert)
                  (("1"
                    (case "card(add(rr, cprio(q!1, x!1))) <= degree")
                    (("1" (use card_add[Thread])
                      (("1" (replaceh -1)
                        (("1" (lift-if)
                          (("1" (assert)
                            (("1" (split)
                              (("1"
                                (flatten)
                                (("1"
                                  (hide -2 1)
                                  (("1"
                                    (expand "cprio")
                                    (("1"
                                      (flatten)
                                      (("1"
                                        (expand "curnode")
                                        (("1"
                                          (case
                                           "iq0(rr, x!1) AND iq0(q!1, x!1) AND iq1(rr, x!1) AND iq1(q!1, x!1)")
                                          (("1"
                                            (flatten)
                                            (("1"
                                              (use equal_paths)
                                              (("1"
                                                (expand "iq0")
                                                (("1"
                                                  (flatten)
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (lemma
                                                       depth_path)
                                                      (("1"
                                                        (inst - _ q!1)
                                                        (("1"
                                                          (inst?)
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil)
                                                           ("2"
                                                            (expand
                                                             "iq1")
                                                            (("2"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (expand "iq1")
                                                (("2"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil)
                                               ("3"
                                                (expand "iq1")
                                                (("3"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (expand "globinv")
                                            (("2"
                                              (expand "iqall")
                                              (("2"
                                                (flatten)
                                                (("2"
                                                  (inst-cp - rr)
                                                  (("2"
                                                    (inst - q!1)
                                                    (("2"
                                                      (flatten)
                                                      (("2"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2" (propax) nil nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide 2)
                      (("2" (use card_inbranches (nn nn1))
                        (("2" (assert)
                          (("2"
                            (case "subset?(add(rr, cprio(q!1, x!1)), inbranches(nn1, x!1))")
                            (("1" (use card_subset[Thread])
                              (("1" (assert) nil nil)) nil)
                             ("2" (hide -1 2)
                              (("2"
                                (expand "subset?")
                                (("2"
                                  (expand "add")
                                  (("2"
                                    (expand "member")
                                    (("2"
                                      (skosimp)
                                      (("2"
                                        (split)
                                        (("1"
                                          (expand "inbranches")
                                          (("1" (assert) nil nil))
                                          nil)
                                         ("2"
                                          (use cprio_sub_inbranches)
                                          (("2" (assert) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (expand "globinv")
          (("2" (expand "kqall")
            (("2" (flatten) (("2" (inst? -6) nil nil)) nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (boolean nonempty-type-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (digit type-eq-decl nil ctrees nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (kqall const-decl "bool" tournamentSafe0 nil)
    (cprio_sub_inbranches formula-decl nil tournamentUnity0 nil)
    (member const-decl "bool" sets nil)
    (card_subset formula-decl nil finite_sets nil)
    (subset_is_partial_order name-judgement "(partial_order?[set[T]])"
     sets_lemmas nil)
    (inbranches const-decl "finite_set[Thread]" tournamentUnity0 nil)
    (subset? const-decl "bool" sets nil)
    (card_inbranches formula-decl nil tournamentUnity0 nil)
    (card_add formula-decl nil finite_sets nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (iq1 const-decl "bool" tournamentSafe0 nil)
    (equal_paths formula-decl nil ctrees nil)
    (q!1 skolem-const-decl "Thread" tournamentUnity0 nil)
    (rr skolem-const-decl "(thread[degree, node])" tournamentUnity0
     nil)
    (x!1 skolem-const-decl "state[degree, node]" tournamentUnity0 nil)
    (depth_path formula-decl nil ctrees nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (<= const-decl "bool" reals nil)
    (Card const-decl "nat" finite_sets nil)
    (card const-decl "{n: nat | n = Card(S)}" finite_sets nil)
    (nonempty? const-decl "bool" sets nil)
    (add const-decl "(nonempty?)" sets nil)
    (cprio const-decl "finite_set[Thread]" tournamentUnity0 nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (kq1 const-decl "bool" tournamentSafe0 nil))
   shostak))
 (at15levpri_unless 0
  (at15levpri_unless-5 nil 3678801407
   ("" (expand "unless")
    (("" (expand "<=")
      (("" (expand "wp")
        (("" (expand "cap")
          (("" (expand "neg")
            (("" (expand "cup")
              (("" (expand "at15levpri")
                (("" (skosimp*)
                  (("" (expand "E1")
                    (("" (expand "step")
                      (("" (split)
                        (("1" (propax) nil nil) ("2" (propax) nil nil)
                         ("3" (split)
                          (("1" (assert) nil nil)
                           ("2" (skolem!)
                            (("2" (case "q!1=p!1")
                              (("1"
                                (replaceh -1)
                                (("1"
                                  (hide-all-but 5 +)
                                  (("1"
                                    (case
                                     "step15F(p!1, s!1, y!1) OR step15G(p!1, s!1, y!1)")
                                    (("1"
                                      (hide -2)
                                      (("1"
                                        (hide -4 -5 -6)
                                        (("1"
                                          (split)
                                          (("1" (grind) nil nil)
                                           ("2" (grind) nil nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (flatten)
                                      (("2"
                                        (expand "step")
                                        (("2"
                                          (assert)
                                          (("2"
                                            (hide-all-but (-1 -2))
                                            (("2" (grind) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide 3 6)
                                (("2"
                                  (use card_cprio_shrinks)
                                  (("2"
                                    (assert)
                                    (("2"
                                      (hide -1 2)
                                      (("2"
                                        (case "s!1`pc(p!1) = 15")
                                        (("1"
                                          (expand "step")
                                          (("1"
                                            (expand "step11")
                                            (("1"
                                              (assert)
                                              (("1"
                                                (expand "step12")
                                                (("1"
                                                  (expand "step13")
                                                  (("1"
                                                    (expand "step14")
                                                    (("1"
                                                      (expand "step16")
                                                      (("1"
                                                        (expand
                                                         "step17")
                                                        (("1"
                                                          (expand
                                                           "step18")
                                                          (("1"
                                                            (expand
                                                             "step19")
                                                            (("1"
                                                              (case
                                                               "y!1= next15(p!1, s!1)")
                                                              (("1"
                                                                (expand
                                                                 "step15F")
                                                                (("1"
                                                                  (expand
                                                                   "step15G")
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (replaceh
                                                                       -1)
                                                                      (("1"
                                                                        (expand
                                                                         "mubot")
                                                                        (("1"
                                                                          (expand
                                                                           "curnode")
                                                                          (("1"
                                                                            (case
                                                                             "path(p!1, s!1`level(p!1))= path(q!1, k!1)")
                                                                            (("1"
                                                                              (hide
                                                                               2)
                                                                              (("1"
                                                                                (split
                                                                                 +)
                                                                                (("1"
                                                                                  (expand
                                                                                   "next15")
                                                                                  (("1"
                                                                                    (propax)
                                                                                    nil
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (expand
                                                                                   "next15")
                                                                                  (("2"
                                                                                    (propax)
                                                                                    nil
                                                                                    nil))
                                                                                  nil)
                                                                                 ("3"
                                                                                  (assert)
                                                                                  (("3"
                                                                                    (case
                                                                                     "cprio(q!1, s!1)(p!1)")
                                                                                    (("1"
                                                                                      (case
                                                                                       "subset?(cprio(q!1, next15(p!1, s!1)),
                        remove(p!1, cprio(q!1, s!1)))")
                                                                                      (("1"
                                                                                        (use
                                                                                         card_subset[Thread])
                                                                                        (("1"
                                                                                          (assert)
                                                                                          (("1"
                                                                                            (use
                                                                                             card_remove[Thread])
                                                                                            (("1"
                                                                                              (assert)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (hide
                                                                                         2
                                                                                         -7
                                                                                         -1)
                                                                                        (("2"
                                                                                          (expand
                                                                                           "subset?")
                                                                                          (("2"
                                                                                            (expand
                                                                                             "remove")
                                                                                            (("2"
                                                                                              (expand
                                                                                               "member")
                                                                                              (("2"
                                                                                                (skosimp)
                                                                                                (("2"
                                                                                                  (case
                                                                                                   "x!1=p!1")
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    (("1"
                                                                                                      (replaceh
                                                                                                       -1)
                                                                                                      (("1"
                                                                                                        (expand
                                                                                                         "cprio")
                                                                                                        (("1"
                                                                                                          (expand
                                                                                                           "curnode")
                                                                                                          (("1"
                                                                                                            (expand
                                                                                                             "curbranch")
                                                                                                            (("1"
                                                                                                              (expand
                                                                                                               "next15")
                                                                                                              (("1"
                                                                                                                (propax)
                                                                                                                nil
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil)
                                                                                                   ("2"
                                                                                                    (assert)
                                                                                                    (("2"
                                                                                                      (expand
                                                                                                       "cprio")
                                                                                                      (("2"
                                                                                                        (expand
                                                                                                         "curnode")
                                                                                                        (("2"
                                                                                                          (expand
                                                                                                           "curbranch")
                                                                                                          (("2"
                                                                                                            (flatten)
                                                                                                            (("2"
                                                                                                              (expand
                                                                                                               "next15")
                                                                                                              (("2"
                                                                                                                (expand
                                                                                                                 "curnode")
                                                                                                                (("2"
                                                                                                                  (assert)
                                                                                                                  (("2"
                                                                                                                    (expand
                                                                                                                     "remove")
                                                                                                                    (("2"
                                                                                                                      (expand
                                                                                                                       "member")
                                                                                                                      (("2"
                                                                                                                        (flatten)
                                                                                                                        (("2"
                                                                                                                          (expand
                                                                                                                           "curbranch")
                                                                                                                          (("2"
                                                                                                                            (hide
                                                                                                                             -1)
                                                                                                                            (("2"
                                                                                                                              (use
                                                                                                                               mx_used)
                                                                                                                              (("2"
                                                                                                                                (assert)
                                                                                                                                (("2"
                                                                                                                                  (expand
                                                                                                                                   "globinv")
                                                                                                                                  (("2"
                                                                                                                                    (propax)
                                                                                                                                    nil
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (hide
                                                                                       2
                                                                                       -6)
                                                                                      (("2"
                                                                                        (expand
                                                                                         "cprio")
                                                                                        (("2"
                                                                                          (expand
                                                                                           "curnode")
                                                                                          (("2"
                                                                                            (hide-all-but
                                                                                             (-1
                                                                                              -4))
                                                                                            (("2"
                                                                                              (expand
                                                                                               "empty?")
                                                                                              (("2"
                                                                                                (expand
                                                                                                 "member")
                                                                                                (("2"
                                                                                                  (inst?)
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (hide
                                                                               4)
                                                                              (("2"
                                                                                (expand
                                                                                 "next15")
                                                                                (("2"
                                                                                  (expand
                                                                                   "curnode")
                                                                                  (("2"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (expand
                                                                 "step15F")
                                                                (("2"
                                                                  (expand
                                                                   "step15G")
                                                                  (("2"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (hide -6 -4 4)
                                          (("2"
                                            (split)
                                            (("1"
                                              (hide-all-but
                                               (-1 -2 1 3))
                                              (("1" (grind) nil nil))
                                              nil)
                                             ("2"
                                              (hide-all-but
                                               (-1 -3 1 3))
                                              (("2" (grind) nil nil))
                                              nil)
                                             ("3"
                                              (expand "mubot")
                                              (("3"
                                                (hide -2 -3)
                                                (("3" (grind) nil nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((<= const-decl "bool" mucalculus nil)
    (cap const-decl "bool" ownpred nil)
    (cup const-decl "bool" ownpred nil)
    (step const-decl "bool" tournamentUnity0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (k!1 skolem-const-decl "nat" tournamentUnity0 nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (empty? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (digit type-eq-decl nil ctrees nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (card_cprio_shrinks formula-decl nil tournamentUnity0 nil)
    (subset? const-decl "bool" sets nil)
    (remove const-decl "set" sets nil)
    (subset_is_partial_order name-judgement "(partial_order?[set[T]])"
     sets_lemmas nil)
    (card_remove formula-decl nil finite_sets nil)
    (card_subset formula-decl nil finite_sets nil)
    (mx_used formula-decl nil tournamentSafe1 nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (cprio const-decl "finite_set[Thread]" tournamentUnity0 nil)
    (path const-decl "node" ctrees nil)
    (mubot const-decl "bool" tournamentUnity0 nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (at15levpri const-decl "bool" tournamentUnity0 nil)
    (neg const-decl "bool" ownpred nil)
    (wp const-decl "bool" ownpred nil)
    (unless const-decl "bool" bdUnity nil))
   nil)
  (at15levpri_unless-4 nil 3678782683
   ("" (expand "unless")
    (("" (expand "<=")
      (("" (expand "wp")
        (("" (expand "cap")
          (("" (expand "neg")
            (("" (expand "cup")
              (("" (expand "at15levpri")
                (("" (skosimp*)
                  (("" (expand "E1")
                    (("" (expand "step")
                      (("" (split)
                        (("1" (propax) nil nil) ("2" (propax) nil nil)
                         ("3" (split)
                          (("1" (assert) nil nil)
                           ("2" (skolem!)
                            (("2" (case "q!1=p!1")
                              (("1"
                                (replaceh -1)
                                (("1"
                                  (hide-all-but 5 +)
                                  (("1"
                                    (case
                                     "step15F(p!1, s!1, y!1) OR step15G(p!1, s!1, y!1)")
                                    (("1"
                                      (hide -2)
                                      (("1"
                                        (hide -4 -5 -6)
                                        (("1"
                                          (split)
                                          (("1" (grind) nil nil)
                                           ("2" (grind) nil nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (flatten)
                                      (("2"
                                        (expand "step")
                                        (("2"
                                          (assert)
                                          (("2"
                                            (hide-all-but (-1 -2))
                                            (("2" (grind) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide 3 6)
                                (("2"
                                  (use card_cprio_shrinks)
                                  (("2"
                                    (assert)
                                    (("2"
                                      (hide -1 2)
                                      (("2"
                                        (case "s!1`pc(p!1) = 15")
                                        (("1"
                                          (expand "step")
                                          (("1"
                                            (expand "step11")
                                            (("1"
                                              (assert)
                                              (("1"
                                                (expand "step12")
                                                (("1"
                                                  (expand "step13")
                                                  (("1"
                                                    (expand "step14")
                                                    (("1"
                                                      (expand "step16")
                                                      (("1"
                                                        (expand
                                                         "step17")
                                                        (("1"
                                                          (expand
                                                           "step18")
                                                          (("1"
                                                            (expand
                                                             "step19")
                                                            (("1"
                                                              (case
                                                               "y!1= next15(p!1, s!1)")
                                                              (("1"
                                                                (expand
                                                                 "step15F")
                                                                (("1"
                                                                  (expand
                                                                   "step15G")
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (replaceh
                                                                       -1)
                                                                      (("1"
                                                                        (expand
                                                                         "mubot")
                                                                        (("1"
                                                                          (expand
                                                                           "curnode")
                                                                          (("1"
                                                                            (case
                                                                             "path(p!1, s!1`level(p!1))= path(q!1, k!1)")
                                                                            (("1"
                                                                              (hide
                                                                               2)
                                                                              (("1"
                                                                                (split
                                                                                 +)
                                                                                (("1"
                                                                                  (expand
                                                                                   "next15")
                                                                                  (("1"
                                                                                    (propax)
                                                                                    nil
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (expand
                                                                                   "next15")
                                                                                  (("2"
                                                                                    (propax)
                                                                                    nil
                                                                                    nil))
                                                                                  nil)
                                                                                 ("3"
                                                                                  (assert)
                                                                                  (("3"
                                                                                    (case
                                                                                     "cprio(q!1, s!1)(p!1)")
                                                                                    (("1"
                                                                                      (case
                                                                                       "subset?(cprio(q!1, next15(p!1, s!1)), 
remove(p!1, cprio(q!1, s!1)))")
                                                                                      (("1"
                                                                                        (use
                                                                                         card_subset[Thread])
                                                                                        (("1"
                                                                                          (assert)
                                                                                          (("1"
                                                                                            (use
                                                                                             card_remove[Thread])
                                                                                            (("1"
                                                                                              (assert)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (hide
                                                                                         2
                                                                                         -7
                                                                                         -1)
                                                                                        (("2"
                                                                                          (expand
                                                                                           "subset?")
                                                                                          (("2"
                                                                                            (expand
                                                                                             "remove")
                                                                                            (("2"
                                                                                              (expand
                                                                                               "member")
                                                                                              (("2"
                                                                                                (skosimp)
                                                                                                (("2"
                                                                                                  (case
                                                                                                   "x!1=p!1")
                                                                                                  (("1"
                                                                                                    (assert)
                                                                                                    (("1"
                                                                                                      (replaceh
                                                                                                       -1)
                                                                                                      (("1"
                                                                                                        (expand
                                                                                                         "cprio")
                                                                                                        (("1"
                                                                                                          (expand
                                                                                                           "curnode")
                                                                                                          (("1"
                                                                                                            (expand
                                                                                                             "curbranch")
                                                                                                            (("1"
                                                                                                              (expand
                                                                                                               "next15")
                                                                                                              (("1"
                                                                                                                (propax)
                                                                                                                nil
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil)
                                                                                                   ("2"
                                                                                                    (assert)
                                                                                                    (("2"
                                                                                                      (expand
                                                                                                       "cprio")
                                                                                                      (("2"
                                                                                                        (expand
                                                                                                         "curnode")
                                                                                                        (("2"
                                                                                                          (expand
                                                                                                           "curbranch")
                                                                                                          (("2"
                                                                                                            (flatten)
                                                                                                            (("2"
                                                                                                              (expand
                                                                                                               "next15")
                                                                                                              (("2"
                                                                                                                (expand
                                                                                                                 "curnode")
                                                                                                                (("2"
                                                                                                                  (assert)
                                                                                                                  (("2"
                                                                                                                    (expand
                                                                                                                     "remove")
                                                                                                                    (("2"
                                                                                                                      (expand
                                                                                                                       "member")
                                                                                                                      (("2"
                                                                                                                        (flatten)
                                                                                                                        (("2"
                                                                                                                          (expand
                                                                                                                           "curbranch")
                                                                                                                          (("2"
                                                                                                                            (lemma
                                                                                                                             equal_paths)
                                                                                                                            (("2"
                                                                                                                              (case
                                                                                                                               "iq0(p!1, s!1) AND iq0(q!1, s!1) AND iq1(p!1, s!1) 
AND iq1(q!1, s!1)")
                                                                                                                              (("1"
                                                                                                                                (flatten)
                                                                                                                                (("1"
                                                                                                                                  (inst
                                                                                                                                   -
                                                                                                                                   _
                                                                                                                                   _
                                                                                                                                   p!1
                                                                                                                                   q!1)
                                                                                                                                  (("1"
                                                                                                                                    (inst
                                                                                                                                     -
                                                                                                                                     "s!1`level(p!1)"
                                                                                                                                     "s!1`level(q!1)")
                                                                                                                                    (("1"
                                                                                                                                      (expand
                                                                                                                                       "iq1")
                                                                                                                                      (("1"
                                                                                                                                        (assert)
                                                                                                                                        (("1"
                                                                                                                                          (expand
                                                                                                                                           "iq0")
                                                                                                                                          (("1"
                                                                                                                                            (assert)
                                                                                                                                            (("1"
                                                                                                                                              (use
                                                                                                                                               joining_paths)
                                                                                                                                              (("1"
                                                                                                                                                (assert)
                                                                                                                                                (("1"
                                                                                                                                                  (case
                                                                                                                                                   "mx(p!1, q!1, k!1+1, s!1)")
                                                                                                                                                  (("1"
                                                                                                                                                    (expand
                                                                                                                                                     "mx")
                                                                                                                                                    (("1"
                                                                                                                                                      (propax)
                                                                                                                                                      nil
                                                                                                                                                      nil))
                                                                                                                                                    nil)
                                                                                                                                                   ("2"
                                                                                                                                                    (use
                                                                                                                                                     mx_j_implied)
                                                                                                                                                    (("2"
                                                                                                                                                      (assert)
                                                                                                                                                      (("2"
                                                                                                                                                        (expand
                                                                                                                                                         "globinv")
                                                                                                                                                        (("2"
                                                                                                                                                          (propax)
                                                                                                                                                          nil
                                                                                                                                                          nil))
                                                                                                                                                        nil))
                                                                                                                                                      nil))
                                                                                                                                                    nil))
                                                                                                                                                  nil))
                                                                                                                                                nil))
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil)
                                                                                                                                     ("2"
                                                                                                                                      (expand
                                                                                                                                       "iq1")
                                                                                                                                      (("2"
                                                                                                                                        (assert)
                                                                                                                                        nil
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil)
                                                                                                                               ("2"
                                                                                                                                (hide-all-but
                                                                                                                                 (-13
                                                                                                                                  1))
                                                                                                                                (("2"
                                                                                                                                  (expand
                                                                                                                                   "globinv")
                                                                                                                                  (("2"
                                                                                                                                    (expand
                                                                                                                                     "iqall")
                                                                                                                                    (("2"
                                                                                                                                      (flatten)
                                                                                                                                      (("2"
                                                                                                                                        (inst-cp
                                                                                                                                         -
                                                                                                                                         p!1)
                                                                                                                                        (("2"
                                                                                                                                          (inst
                                                                                                                                           -
                                                                                                                                           q!1)
                                                                                                                                          (("2"
                                                                                                                                            (flatten)
                                                                                                                                            (("2"
                                                                                                                                              (assert)
                                                                                                                                              nil
                                                                                                                                              nil))
                                                                                                                                            nil))
                                                                                                                                          nil))
                                                                                                                                        nil))
                                                                                                                                      nil))
                                                                                                                                    nil))
                                                                                                                                  nil))
                                                                                                                                nil))
                                                                                                                              nil))
                                                                                                                            nil))
                                                                                                                          nil))
                                                                                                                        nil))
                                                                                                                      nil))
                                                                                                                    nil))
                                                                                                                  nil))
                                                                                                                nil))
                                                                                                              nil))
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (hide
                                                                                       2
                                                                                       -6)
                                                                                      (("2"
                                                                                        (expand
                                                                                         "cprio")
                                                                                        (("2"
                                                                                          (expand
                                                                                           "curnode")
                                                                                          (("2"
                                                                                            (hide-all-but
                                                                                             (-1
                                                                                              -4))
                                                                                            (("2"
                                                                                              (expand
                                                                                               "empty?")
                                                                                              (("2"
                                                                                                (expand
                                                                                                 "member")
                                                                                                (("2"
                                                                                                  (inst?)
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (hide
                                                                               4)
                                                                              (("2"
                                                                                (expand
                                                                                 "next15")
                                                                                (("2"
                                                                                  (expand
                                                                                   "curnode")
                                                                                  (("2"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (expand
                                                                 "step15F")
                                                                (("2"
                                                                  (expand
                                                                   "step15G")
                                                                  (("2"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (hide -6 -4 4)
                                          (("2"
                                            (split)
                                            (("1"
                                              (hide-all-but
                                               (-1 -2 1 3))
                                              (("1" (grind) nil nil))
                                              nil)
                                             ("2"
                                              (hide-all-but
                                               (-1 -3 1 3))
                                              (("2" (grind) nil nil))
                                              nil)
                                             ("3"
                                              (expand "mubot")
                                              (("3"
                                                (hide -2 -3)
                                                (("3" (grind) nil nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((<= const-decl "bool" mucalculus nil)
    (cap const-decl "bool" ownpred nil)
    (cup const-decl "bool" ownpred nil)
    (step const-decl "bool" tournamentUnity0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (empty? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (card_cprio_shrinks formula-decl nil tournamentUnity0 nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (subset? const-decl "bool" sets nil)
    (remove const-decl "set" sets nil)
    (subset_is_partial_order name-judgement "(partial_order?[set[T]])"
     sets_lemmas nil)
    (card_remove formula-decl nil finite_sets nil)
    (card_subset formula-decl nil finite_sets nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (iq1 const-decl "bool" tournamentSafe0 nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (mx_j_implied formula-decl nil tournamentSafe0 nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (cprio const-decl "finite_set[Thread]" tournamentUnity0 nil)
    (mubot const-decl "bool" tournamentUnity0 nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (at15levpri const-decl "bool" tournamentUnity0 nil)
    (neg const-decl "bool" ownpred nil)
    (wp const-decl "bool" ownpred nil)
    (unless const-decl "bool" bdUnity nil))
   nil)
  (at15levpri_unless-3 nil 3678633863
   ("" (expand "unless")
    (("" (expand "<=")
      (("" (expand "wp")
        (("" (expand "cap")
          (("" (expand "neg")
            (("" (expand "cup")
              (("" (expand "at15levpri")
                (("" (skosimp*)
                  (("" (expand "E1")
                    (("" (expand "step")
                      (("" (split)
                        (("1" (propax) nil nil) ("2" (propax) nil nil)
                         ("3" (split)
                          (("1" (assert) nil nil)
                           ("2" (skolem!)
                            (("2" (case "q!1=p!1")
                              (("1"
                                (replaceh -1)
                                (("1"
                                  (hide-all-but 5 +)
                                  (("1"
                                    (case
                                     "step15F(p!1, s!1, y!1) OR step15G(p!1, s!1, y!1)")
                                    (("1"
                                      (hide -2)
                                      (("1"
                                        (hide -4 -5 -6)
                                        (("1"
                                          (split)
                                          (("1" (grind) nil nil)
                                           ("2" (grind) nil nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (flatten)
                                      (("2"
                                        (expand "step")
                                        (("2"
                                          (assert)
                                          (("2"
                                            (hide-all-but (-1 -2))
                                            (("2" (grind) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide 3 6)
                                (("2"
                                  (use card_cprio_shrinks)
                                  (("2"
                                    (assert)
                                    (("2"
                                      (hide -1 2)
                                      (("2"
                                        (case "s!1`pc(p!1) = 15")
                                        (("1"
                                          (case
                                           "y!1 = next15(p!1, s!1)")
                                          (("1"
                                            (hide -3)
                                            (("1"
                                              (split)
                                              (("1"
                                                (expand "mubot")
                                                (("1"
                                                  (replaceh -1)
                                                  (("1"
                                                    (case
                                                     "curnode(p!1, s!1) = path(q!1, k!1)")
                                                    (("1"
                                                      (hide 2)
                                                      (("1"
                                                        (split)
                                                        (("1"
                                                          (expand
                                                           "next15")
                                                          (("1"
                                                            (propax)
                                                            nil
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (expand
                                                           "next15")
                                                          (("2"
                                                            (propax)
                                                            nil
                                                            nil))
                                                          nil)
                                                         ("3"
                                                          (case
                                                           "subset?(cprio(q!1, next15(p!1, s!1)), remove(p!1, cprio(q!1, s!1)))")
                                                          (("1"
                                                            (use
                                                             card_subset[Thread])
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (use
                                                                 card_remove[Thread])
                                                                (("1"
                                                                  (replaceh
                                                                   -1)
                                                                  (("1"
                                                                    (lift-if)
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (split)
                                                                        (("1"
                                                                          (propax)
                                                                          nil
                                                                          nil)
                                                                         ("2"
                                                                          (flatten)
                                                                          (("2"
                                                                            (hide
                                                                             -1
                                                                             -2
                                                                             2
                                                                             -10)
                                                                            (("2"
                                                                              (expand
                                                                               "cprio")
                                                                              (("2"
                                                                                (split)
                                                                                (("1"
                                                                                  (replaceh
                                                                                   -1)
                                                                                  (("1"
                                                                                    (expand
                                                                                     "curnode")
                                                                                    (("1"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (expand
                                                                                   "next15")
                                                                                  (("2"
                                                                                    (propax)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (expand
                                                             "subset?")
                                                            (("2"
                                                              (expand
                                                               "remove")
                                                              (("2"
                                                                (expand
                                                                 "member")
                                                                (("2"
                                                                  (skosimp)
                                                                  (("2"
                                                                    (hide
                                                                     -9
                                                                     2)
                                                                    (("2"
                                                                      (expand
                                                                       "cprio")
                                                                      (("2"
                                                                        (expand
                                                                         "curnode")
                                                                        (("2"
                                                                          (expand
                                                                           "curbranch")
                                                                          (("2"
                                                                            (flatten)
                                                                            (("2"
                                                                              (assert)
                                                                              (("2"
                                                                                (case
                                                                                 "x!1=p!1")
                                                                                (("1"
                                                                                  (replaceh
                                                                                   -1)
                                                                                  (("1"
                                                                                    (expand
                                                                                     "next15")
                                                                                    (("1"
                                                                                      (propax)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil)
                                                                                 ("2"
                                                                                  (assert)
                                                                                  (("2"
                                                                                    (expand
                                                                                     "next15")
                                                                                    (("2"
                                                                                      (propax)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (expand "next15")
                                                      (("2"
                                                        (propax)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (replaceh -1)
                                                (("2"
                                                  (expand "next15")
                                                  (("2"
                                                    (propax)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil)
                                               ("3"
                                                (expand "mubot")
                                                (("3"
                                                  (replaceh -1)
                                                  (("3"
                                                    (split)
                                                    (("1"
                                                      (expand "next15")
                                                      (("1"
                                                        (propax)
                                                        nil
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (expand "next15")
                                                      (("2"
                                                        (propax)
                                                        nil
                                                        nil))
                                                      nil)
                                                     ("3"
                                                      (case
                                                       "cprio(q!1, s!1)(p!1)")
                                                      (("1"
                                                        (case
                                                         "subset?(cprio(q!1, next15(p!1, s!1)), remove(p!1, cprio(q!1, s!1)))")
                                                        (("1"
                                                          (use
                                                           card_subset[Thread])
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (use
                                                               card_remove[Thread])
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (hide -5 2)
                                                          (("2"
                                                            (expand
                                                             "subset?")
                                                            (("2"
                                                              (expand
                                                               "remove")
                                                              (("2"
                                                                (expand
                                                                 "member")
                                                                (("2"
                                                                  (skosimp)
                                                                  (("2"
                                                                    (expand
                                                                     "cprio")
                                                                    (("2"
                                                                      (expand
                                                                       "curnode")
                                                                      (("2"
                                                                        (expand
                                                                         "curbranch")
                                                                        (("2"
                                                                          (case
                                                                           "x!1=p!1")
                                                                          (("1"
                                                                            (assert)
                                                                            (("1"
                                                                              (flatten)
                                                                              (("1"
                                                                                (expand
                                                                                 "next15")
                                                                                (("1"
                                                                                  (assert)
                                                                                  nil
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (flatten)
                                                                            (("2"
                                                                              (assert)
                                                                              (("2"
                                                                                (expand
                                                                                 "next15")
                                                                                (("2"
                                                                                  (assert)
                                                                                  (("2"
                                                                                    (expand
                                                                                     "curbranch")
                                                                                    (("2"
                                                                                      (split)
                                                                                      (("1"
                                                                                        (flatten)
                                                                                        (("1"
                                                                                          (expand
                                                                                           "remove")
                                                                                          (("1"
                                                                                            (expand
                                                                                             "member")
                                                                                            (("1"
                                                                                              (flatten)
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "curnode")
                                                                                                (("1"
                                                                                                  (assert)
                                                                                                  (("1"
                                                                                                    (postpone)
                                                                                                    nil
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (propax)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (hide 2 -4)
                                                        (("2"
                                                          (expand
                                                           "cprio")
                                                          (("2"
                                                            (expand
                                                             "curnode")
                                                            (("2"
                                                              (assert)
                                                              (("2"
                                                                (expand
                                                                 "next15")
                                                                (("2"
                                                                  (expand
                                                                   "curnode")
                                                                  (("2"
                                                                    (case
                                                                     "path(p!1, s!1`level(p!1)) = path(q!1, s!1`level(q!1))")
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (postpone)
                                                                        nil
                                                                        nil))
                                                                      nil)
                                                                     ("2"
                                                                      (postpone)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2" (postpone) nil nil))
                                          nil)
                                         ("2" (postpone) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   nil nil)
  (at15levpri_unless-2 nil 3678630706
   ("" (expand "unless")
    (("" (expand "<=")
      (("" (expand "wp")
        (("" (expand "cap")
          (("" (expand "neg")
            (("" (expand "cup")
              (("" (expand "at15levpri")
                (("" (skosimp*)
                  (("" (expand "E1")
                    (("" (expand "step")
                      (("" (split)
                        (("1" (propax) nil nil) ("2" (propax) nil nil)
                         ("3" (split)
                          (("1" (assert) nil nil)
                           ("2" (skolem!)
                            (("2" (case "q!1=p!1")
                              (("1"
                                (replaceh -1)
                                (("1"
                                  (hide-all-but 5 +)
                                  (("1"
                                    (case
                                     "step15F(p!1, s!1, y!1) OR step15G(p!1, s!1, y!1)")
                                    (("1"
                                      (hide -2)
                                      (("1"
                                        (hide -4 -5 -6)
                                        (("1"
                                          (split)
                                          (("1" (grind) nil nil)
                                           ("2" (grind) nil nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (flatten)
                                      (("2"
                                        (expand "step")
                                        (("2"
                                          (assert)
                                          (("2"
                                            (hide-all-but (-1 -2))
                                            (("2" (grind) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide 3 6)
                                (("2"
                                  (use card_cprio_shrinks)
                                  (("2"
                                    (assert)
                                    (("2"
                                      (hide -1 2)
                                      (("2"
                                        (case "s!1`pc(p!1) = 15")
                                        (("1"
                                          (case
                                           "step15F(p!1, s!1, y!1) OR step15G(p!1, s!1, y!1)")
                                          (("1"
                                            (hide -3)
                                            (("1"
                                              (split)
                                              (("1"
                                                (expand "step15F")
                                                (("1"
                                                  (flatten)
                                                  (("1"
                                                    (expand "mubot")
                                                    (("1"
                                                      (replaceh -1)
                                                      (("1"
                                                        (case
                                                         "curnode(p!1, s!1) = path(q!1, k!1)")
                                                        (("1"
                                                          (hide 2)
                                                          (("1"
                                                            (split)
                                                            (("1"
                                                              (expand
                                                               "next15")
                                                              (("1"
                                                                (propax)
                                                                nil
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (expand
                                                               "next15")
                                                              (("2"
                                                                (propax)
                                                                nil
                                                                nil))
                                                              nil)
                                                             ("3"
                                                              (case
                                                               "subset?(cprio(q!1, next15(p!1, s!1)), remove(p!1, cprio(q!1, s!1)))")
                                                              (("1"
                                                                (use
                                                                 card_subset[Thread])
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (use
                                                                     card_remove[Thread])
                                                                    (("1"
                                                                      (replaceh
                                                                       -1)
                                                                      (("1"
                                                                        (lift-if)
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (split)
                                                                            (("1"
                                                                              (propax)
                                                                              nil
                                                                              nil)
                                                                             ("2"
                                                                              (flatten)
                                                                              (("2"
                                                                                (hide
                                                                                 -1
                                                                                 -2
                                                                                 2
                                                                                 -10)
                                                                                (("2"
                                                                                  (expand
                                                                                   "cprio")
                                                                                  (("2"
                                                                                    (split)
                                                                                    (("1"
                                                                                      (replaceh
                                                                                       -1)
                                                                                      (("1"
                                                                                        (expand
                                                                                         "curnode")
                                                                                        (("1"
                                                                                          (assert)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (hide-all-but
                                                                                       (-1
                                                                                        -5))
                                                                                      (("2"
                                                                                        (expand
                                                                                         "empty?")
                                                                                        (("2"
                                                                                          (expand
                                                                                           "member")
                                                                                          (("2"
                                                                                            (inst?)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (expand
                                                                 "subset?")
                                                                (("2"
                                                                  (expand
                                                                   "remove")
                                                                  (("2"
                                                                    (expand
                                                                     "member")
                                                                    (("2"
                                                                      (skosimp)
                                                                      (("2"
                                                                        (hide
                                                                         -9
                                                                         2)
                                                                        (("2"
                                                                          (expand
                                                                           "cprio")
                                                                          (("2"
                                                                            (expand
                                                                             "curnode")
                                                                            (("2"
                                                                              (expand
                                                                               "curbranch")
                                                                              (("2"
                                                                                (flatten)
                                                                                (("2"
                                                                                  (assert)
                                                                                  (("2"
                                                                                    (case
                                                                                     "x!1=p!1")
                                                                                    (("1"
                                                                                      (replaceh
                                                                                       -1)
                                                                                      (("1"
                                                                                        (expand
                                                                                         "next15")
                                                                                        (("1"
                                                                                          (expand
                                                                                           "curnode")
                                                                                          (("1"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (assert)
                                                                                      (("2"
                                                                                        (expand
                                                                                         "next15")
                                                                                        (("2"
                                                                                          (assert)
                                                                                          (("2"
                                                                                            (expand
                                                                                             "remove")
                                                                                            (("2"
                                                                                              (expand
                                                                                               "member")
                                                                                              (("2"
                                                                                                (split
                                                                                                 +)
                                                                                                (("1"
                                                                                                  (flatten)
                                                                                                  (("1"
                                                                                                    (expand
                                                                                                     "curnode")
                                                                                                    (("1"
                                                                                                      (expand
                                                                                                       "curbranch")
                                                                                                      (("1"
                                                                                                        (replaceh
                                                                                                         -1)
                                                                                                        (("1"
                                                                                                          (postpone)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil)
                                                                                                 ("2"
                                                                                                  (propax)
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (expand
                                                           "next15")
                                                          (("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (postpone)
                                                nil
                                                nil))
                                              nil))
                                            nil)
                                           ("2" (postpone) nil nil))
                                          nil)
                                         ("2" (postpone) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   nil nil)
  (at15levpri_unless-1 nil 3670558672
   ("" (expand "unless")
    (("" (expand "<=")
      (("" (expand "wp")
        (("" (expand "cap")
          (("" (expand "neg")
            (("" (expand "cup")
              (("" (expand "at15levpri")
                (("" (skosimp*)
                  (("" (expand "E1")
                    (("" (expand "step")
                      (("" (split)
                        (("1" (propax) nil nil) ("2" (propax) nil nil)
                         ("3" (split)
                          (("1" (assert) nil nil)
                           ("2" (skolem!)
                            (("2" (case "q!1=p!1")
                              (("1"
                                (replaceh -1)
                                (("1"
                                  (hide-all-but 5 +)
                                  (("1"
                                    (case
                                     "step15F(p!1, s!1, y!1) OR step15G(p!1, s!1, y!1)")
                                    (("1"
                                      (hide -2)
                                      (("1"
                                        (expand "at12levmin")
                                        (("1"
                                          (hide -4 -5 -6)
                                          (("1"
                                            (split)
                                            (("1" (grind) nil nil)
                                             ("2" (grind) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (flatten)
                                      (("2"
                                        (expand "step")
                                        (("2"
                                          (assert)
                                          (("2"
                                            (hide-all-but (-1 -2))
                                            (("2" (grind) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide 3 6)
                                (("2"
                                  (use card_cprio_shrinks)
                                  (("2"
                                    (assert)
                                    (("2"
                                      (hide -1 2)
                                      (("2"
                                        (case "s!1`pc(p!1) = 15")
                                        (("1"
                                          (case
                                           "step15F(p!1, s!1, y!1) OR step15G(p!1, s!1, y!1)")
                                          (("1"
                                            (hide -3)
                                            (("1"
                                              (split)
                                              (("1"
                                                (expand "step15F")
                                                (("1"
                                                  (flatten)
                                                  (("1"
                                                    (expand "mubot")
                                                    (("1"
                                                      (replaceh -1)
                                                      (("1"
                                                        (case
                                                         "curnode(p!1, s!1) = take(k!1, q!1)")
                                                        (("1"
                                                          (hide 2)
                                                          (("1"
                                                            (split)
                                                            (("1"
                                                              (expand
                                                               "next15")
                                                              (("1"
                                                                (propax)
                                                                nil
                                                                nil))
                                                              nil)
                                                             ("2"
                                                              (expand
                                                               "next15")
                                                              (("2"
                                                                (propax)
                                                                nil
                                                                nil))
                                                              nil)
                                                             ("3"
                                                              (case
                                                               "subset?(cprio(q!1, next15(p!1, s!1)), remove(p!1, cprio(q!1, s!1)))")
                                                              (("1"
                                                                (use
                                                                 card_subset[Thread])
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (use
                                                                     card_remove[Thread])
                                                                    (("1"
                                                                      (replaceh
                                                                       -1)
                                                                      (("1"
                                                                        (lift-if)
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (split)
                                                                            (("1"
                                                                              (propax)
                                                                              nil
                                                                              nil)
                                                                             ("2"
                                                                              (flatten)
                                                                              (("2"
                                                                                (hide
                                                                                 -1
                                                                                 -2
                                                                                 2
                                                                                 -10)
                                                                                (("2"
                                                                                  (expand
                                                                                   "cprio")
                                                                                  (("2"
                                                                                    (split)
                                                                                    (("1"
                                                                                      (replaceh
                                                                                       -1)
                                                                                      (("1"
                                                                                        (expand
                                                                                         "curnode")
                                                                                        (("1"
                                                                                          (assert)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (hide-all-but
                                                                                       (-1
                                                                                        -5))
                                                                                      (("2"
                                                                                        (grind)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (hide
                                                                 -8
                                                                 2)
                                                                (("2"
                                                                  (expand
                                                                   "subset?")
                                                                  (("2"
                                                                    (expand
                                                                     "remove")
                                                                    (("2"
                                                                      (expand
                                                                       "member")
                                                                      (("2"
                                                                        (skosimp)
                                                                        (("2"
                                                                          (expand
                                                                           "cprio")
                                                                          (("2"
                                                                            (flatten)
                                                                            (("2"
                                                                              (expand
                                                                               "curnode")
                                                                              (("2"
                                                                                (expand
                                                                                 "next15")
                                                                                (("2"
                                                                                  (expand
                                                                                   "remove")
                                                                                  (("2"
                                                                                    (expand
                                                                                     "member")
                                                                                    (("2"
                                                                                      (case
                                                                                       "x!1=p!1")
                                                                                      (("1"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil)
                                                                                       ("2"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (hide 4)
                                                          (("2"
                                                            (expand
                                                             "next15")
                                                            (("2"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (expand "step15G")
                                                (("2"
                                                  (flatten)
                                                  (("2"
                                                    (use no_step15G)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (expand
                                                         "globinv")
                                                        (("2"
                                                          (flatten)
                                                          (("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (flatten)
                                            (("2"
                                              (expand "step")
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (hide-all-but
                                                   (-1 -2))
                                                  (("2"
                                                    (expand "step11")
                                                    (("2"
                                                      (expand "step12")
                                                      (("2"
                                                        (expand
                                                         "step13")
                                                        (("2"
                                                          (expand
                                                           "step14")
                                                          (("2"
                                                            (expand
                                                             "step16")
                                                            (("2"
                                                              (expand
                                                               "step17")
                                                              (("2"
                                                                (expand
                                                                 "step18")
                                                                (("2"
                                                                  (expand
                                                                   "step19")
                                                                  (("2"
                                                                    (propax)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (hide 4 -4 -6)
                                          (("2"
                                            (expand "mubot")
                                            (("2" (grind) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((<= const-decl "bool" mucalculus nil)
    (cap const-decl "bool" ownpred nil)
    (cup const-decl "bool" ownpred nil)
    (step const-decl "bool" tournamentUnity0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (empty? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (min const-decl "{p: real | p <= m AND p <= n}" real_defs nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (nat_min application-judgement "{k: nat | k <= i AND k <= j}"
     real_defs nil)
    (int_max application-judgement "{k: int | i <= k AND j <= k}"
     real_defs nil)
    (rat_max application-judgement "{s: rat | s >= q AND s >= r}"
     real_defs nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (card_cprio_shrinks formula-decl nil tournamentUnity0 nil)
    (nat_max application-judgement "{k: nat | i <= k AND j <= k}"
     real_defs nil)
    (nonneg_rat_max application-judgement
     "{s: nonneg_rat | s >= q AND s >= r}" real_defs nil)
    (subset? const-decl "bool" sets nil)
    (cprio const-decl "finite_set[Thread]" tournamentUnity0 nil)
    (remove const-decl "set" sets nil)
    (subset_is_partial_order name-judgement "(partial_order?[set[T]])"
     sets_lemmas nil)
    (card_remove formula-decl nil finite_sets nil)
    (card_subset formula-decl nil finite_sets nil)
    (mubot const-decl "bool" tournamentUnity0 nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (no_step15G formula-decl nil tournamentSafe1 nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (at15levpri const-decl "bool" tournamentUnity0 nil)
    (neg const-decl "bool" ownpred nil)
    (wp const-decl "bool" ownpred nil)
    (unless const-decl "bool" bdUnity nil))
   shostak))
 (leadsto_at15levpri 0
  (leadsto_at15levpri-3 nil 3678784962
   ("" (skosimp)
    (("" (expand "ass_waiting")
      (("" (inst?)
        (("" (lemma PSP_leto)
          (("" (inst?)
            (("" (assert)
              (("" (hide -2)
                (("" (use at15levpri_unless)
                  (("" (inst?)
                    (("" (assert)
                      (("" (hide -1)
                        ((""
                          (name-replace pp0
                           "cap(at15levpri(q!1, k!1, 1 + m!1), mubot(path(q!1, k!1)))")
                          ((""
                            (name-replace pp1
                             "cup(at15levpri(q!1, k!1, m!1), atlev(q!1, 12, k!1 - 1))")
                            ((""
                              (case "cap(atlev(q!1, 15, k!1), pp0) = pp0")
                              (("1"
                                (replaceh -1)
                                (("1"
                                  (case
                                   "cup(cap(neg(mubot(path(q!1, k!1))), pp0), pp1)=pp1")
                                  (("1" (assert) nil nil)
                                   ("2"
                                    (hide - 2)
                                    (("2"
                                      (apply-extensionality :hide? t)
                                      (("2"
                                        (expand "cup")
                                        (("2"
                                          (expand "cap")
                                          (("2"
                                            (expand "neg")
                                            (("2"
                                              (expand "pp0")
                                              (("2"
                                                (expand "cap")
                                                (("2"
                                                  (iff)
                                                  (("2"
                                                    (prop)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide - 2)
                                (("2"
                                  (apply-extensionality :hide? t)
                                  (("2"
                                    (iff)
                                    (("2"
                                      (expand "cap")
                                      (("2"
                                        (prop)
                                        (("2"
                                          (expand "pp0")
                                          (("2"
                                            (expand "cap")
                                            (("2"
                                              (expand "atlev")
                                              (("2"
                                                (expand "at15levpri")
                                                (("2"
                                                  (flatten)
                                                  (("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((ass_waiting const-decl "bool" tournamentUnity0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil) (digit type-eq-decl nil ctrees nil)
    (PSP_leto formula-decl nil bdUnity nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (at15levpri_unless formula-decl nil tournamentUnity0 nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (pp0 skolem-const-decl "[state[degree, node] -> bool]"
     tournamentUnity0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (cap const-decl "bool" ownpred nil)
    (at15levpri const-decl "bool" tournamentUnity0 nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (cup const-decl "bool" ownpred nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (path const-decl "node" ctrees nil)
    (mubot const-decl "bool" tournamentUnity0 nil)
    (neg const-decl "bool" ownpred nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil))
   nil)
  (leadsto_at15levpri-2 nil 3670733973
   ("" (skosimp)
    (("" (expand "ass_waiting")
      (("" (inst?)
        (("" (lemma PSP_leto)
          (("" (inst?)
            (("" (assert)
              (("" (hide -2)
                (("" (use at15levpri_unless)
                  (("" (inst?)
                    (("" (assert)
                      (("" (hide -1)
                        ((""
                          (name-replace pp0
                           "cap(at15levpri(q!1, k!1, 1 + m!1), mubot(take(k!1, q!1)))")
                          ((""
                            (name-replace pp1
                             "cup(at15levpri(q!1, k!1, m!1), atlev(q!1, 12, k!1 - 1))")
                            ((""
                              (case "cap(cap(atlev(q!1, 15, k!1), mubot(take(k!1, q!1))), pp0) = pp0")
                              (("1"
                                (replaceh -1)
                                (("1"
                                  (case
                                   "cup(cap(neg(mubot(take(k!1, q!1))), pp0), pp1)=pp1")
                                  (("1" (assert) nil nil)
                                   ("2"
                                    (hide - 2)
                                    (("2"
                                      (apply-extensionality :hide? t)
                                      (("2"
                                        (iff)
                                        (("2"
                                          (expand "cup")
                                          (("2"
                                            (prop)
                                            (("2"
                                              (expand "pp1")
                                              (("2"
                                                (expand "cup")
                                                (("2"
                                                  (expand "cap")
                                                  (("2"
                                                    (expand "pp0")
                                                    (("2"
                                                      (expand "cap")
                                                      (("2"
                                                        (expand
                                                         "at15levpri")
                                                        (("2"
                                                          (expand
                                                           "mubot")
                                                          (("2"
                                                            (expand
                                                             "neg")
                                                            (("2"
                                                              (flatten)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide - 2)
                                (("2"
                                  (apply-extensionality :hide? t)
                                  (("2"
                                    (iff)
                                    (("2"
                                      (expand "pp0")
                                      (("2"
                                        (expand "cap")
                                        (("2"
                                          (prop)
                                          (("2"
                                            (expand "at15levpri")
                                            (("2"
                                              (expand "atlev")
                                              (("2"
                                                (flatten)
                                                (("2"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((ass_waiting const-decl "bool" tournamentUnity0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (PSP_leto formula-decl nil bdUnity nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (at15levpri_unless formula-decl nil tournamentUnity0 nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (at15levpri const-decl "bool" tournamentUnity0 nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (cup const-decl "bool" ownpred nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (neg const-decl "bool" ownpred nil)
    (mubot const-decl "bool" tournamentUnity0 nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (cap const-decl "bool" ownpred nil)
    (pred type-eq-decl nil defined_types nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil))
   nil)
  (leadsto_at15levpri-1 nil 3670402226
   ("" (skosimp)
    (("" (expand "ass_waiting")
      (("" (inst?)
        (("" (lemma PSP_leto)
          (("" (inst?)
            (("" (assert)
              (("" (hide -2)
                (("" (use at15levpri_unless)
                  (("" (inst?)
                    (("" (assert)
                      (("" (hide -1)
                        ((""
                          (name-replace pp0
                           "cap(at15levpri(q!1, k!1, 1 + m!1), mubot(take(k!1, q!1)))")
                          ((""
                            (name-replace pp1
                             "cup(at15levpri(q!1, k!1, m!1), at12levmin(q!1, k!1))")
                            ((""
                              (case "cap(cap(at15lev(q!1, k!1), mubot(take(k!1, q!1))), pp0) = pp0")
                              (("1"
                                (replaceh -1)
                                (("1"
                                  (case
                                   "cup(cap(neg(mubot(take(k!1, q!1))), pp0), pp1)=pp1")
                                  (("1" (assert) nil nil)
                                   ("2"
                                    (hide - 2)
                                    (("2"
                                      (apply-extensionality :hide? t)
                                      (("2"
                                        (iff)
                                        (("2"
                                          (expand "cup")
                                          (("2"
                                            (prop)
                                            (("2"
                                              (expand "pp1")
                                              (("2"
                                                (expand "cup")
                                                (("2"
                                                  (expand "cap")
                                                  (("2"
                                                    (expand "pp0")
                                                    (("2"
                                                      (expand "cap")
                                                      (("2"
                                                        (expand
                                                         "at15levpri")
                                                        (("2"
                                                          (expand
                                                           "mubot")
                                                          (("2"
                                                            (expand
                                                             "neg")
                                                            (("2"
                                                              (flatten)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide - 2)
                                (("2"
                                  (apply-extensionality :hide? t)
                                  (("2"
                                    (iff)
                                    (("2"
                                      (expand "pp0")
                                      (("2"
                                        (expand "cap")
                                        (("2"
                                          (prop)
                                          (("2"
                                            (expand "at15levpri")
                                            (("2"
                                              (expand "at15lev")
                                              (("2"
                                                (flatten)
                                                (("2"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((ass_waiting const-decl "bool" tournamentUnity0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (PSP_leto formula-decl nil bdUnity nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (at15levpri_unless formula-decl nil tournamentUnity0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (at15levpri const-decl "bool" tournamentUnity0 nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (cup const-decl "bool" ownpred nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (neg const-decl "bool" ownpred nil)
    (mubot const-decl "bool" tournamentUnity0 nil)
    (cap const-decl "bool" ownpred nil)
    (pred type-eq-decl nil defined_types nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil))
   shostak))
 (unless_mubot 0
  (unless_mubot-1 nil 3670411687
   ("" (expand "unless")
    (("" (expand "<=")
      (("" (expand "wp")
        (("" (expand "cap")
          (("" (expand "neg")
            (("" (expand "cup")
              (("" (expand "E1")
                (("" (skosimp*)
                  (("" (assert)
                    (("" (expand "step")
                      (("" (skolem!)
                        (("" (hide 3)
                          (("" (expand "at15levpri")
                            (("" (flatten)
                              ((""
                                (use card_cprio_shrinks)
                                ((""
                                  (assert)
                                  ((""
                                    (case "q!1=p!1")
                                    (("1"
                                      (replaceh -1)
                                      (("1"
                                        (expand "mubot")
                                        (("1"
                                          (hide 2 -3)
                                          (("1"
                                            (case
                                             "step15F(p!1, s!1, y!1) OR step15G(p!1, s!1, y!1)")
                                            (("1"
                                              (hide -5)
                                              (("1"
                                                (split)
                                                (("1"
                                                  (expand "step15F")
                                                  (("1"
                                                    (flatten)
                                                    (("1"
                                                      (expand
                                                       "curnode")
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (expand "step15G")
                                                  (("2"
                                                    (flatten)
                                                    (("2"
                                                      (use no_step15G)
                                                      (("2"
                                                        (assert)
                                                        (("2"
                                                          (expand
                                                           "globinv")
                                                          (("2"
                                                            (flatten)
                                                            (("2"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (flatten)
                                              (("2"
                                                (expand "step")
                                                (("2"
                                                  (assert)
                                                  (("2"
                                                    (hide-all-but
                                                     (-1 -4))
                                                    (("2"
                                                      (expand "step11")
                                                      (("2"
                                                        (expand
                                                         "step12")
                                                        (("2"
                                                          (expand
                                                           "step13")
                                                          (("2"
                                                            (expand
                                                             "step14")
                                                            (("2"
                                                              (expand
                                                               "step16")
                                                              (("2"
                                                                (expand
                                                                 "step17")
                                                                (("2"
                                                                  (expand
                                                                   "step18")
                                                                  (("2"
                                                                    (expand
                                                                     "step19")
                                                                    (("2"
                                                                      (propax)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (assert)
                                      (("2"
                                        (hide-all-but (-2 -3 -6 1 3))
                                        (("2" (grind) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((<= const-decl "bool" mucalculus nil)
    (cap const-decl "bool" ownpred nil)
    (cup const-decl "bool" ownpred nil)
    (step const-decl "bool" tournamentUnity0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (empty? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (no_step15G formula-decl nil tournamentSafe1 nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (mubot const-decl "bool" tournamentUnity0 nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (digit type-eq-decl nil ctrees nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (card_cprio_shrinks formula-decl nil tournamentUnity0 nil)
    (at15levpri const-decl "bool" tournamentUnity0 nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (neg const-decl "bool" ownpred nil)
    (wp const-decl "bool" ownpred nil)
    (unless const-decl "bool" bdUnity nil))
   shostak))
 (at15_mubot 0
  (at15_mubot-4 nil 3678785097
   ("" (skosimp)
    (("" (use mu_to_bot)
      (("" (assert)
        (("" (split)
          (("1" (lemma PSP_leto)
            (("1" (inst?)
              (("1" (use unless_mubot)
                (("1" (inst?)
                  (("1" (assert)
                    (("1" (hide -1 -3 -4)
                      (("1"
                        (name-replace pp1
                         "at15levpri(q!1, k!1, 1 + i!1)")
                        (("1"
                          (name-replace pp2 "mubot(path(q!1, k!1))")
                          (("1" (case "cap(fullset, pp1) = pp1")
                            (("1" (replaceh -1)
                              (("1"
                                (case
                                 "cup(cap(pp2, pp1), cap(pp1, pp2)) = cap(pp1, pp2)")
                                (("1" (assert) nil nil)
                                 ("2"
                                  (hide - 2)
                                  (("2"
                                    (apply-extensionality :hide? t)
                                    (("2"
                                      (iff)
                                      (("2"
                                        (expand "cap")
                                        (("2"
                                          (expand "cup")
                                          (("2" (prop) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (hide - 2)
                              (("2"
                                (apply-extensionality :hide? t)
                                (("2"
                                  (iff)
                                  (("2"
                                    (expand "cap")
                                    (("2"
                                      (expand "fullset")
                                      (("2" (propax) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (hide -)
            (("2" (use depth_path)
              (("2" (lift-if)
                (("2" (assert)
                  (("2" (split)
                    (("1" (propax) nil nil)
                     ("2" (flatten)
                      (("2" (hide -1 2)
                        (("2" (use subset_leto)
                          (("2" (assert)
                            (("2" (hide 3)
                              (("2"
                                (expand "<=" 1)
                                (("2"
                                  (expand "cap")
                                  (("2"
                                    (expand "at15levpri")
                                    (("2"
                                      (skosimp)
                                      (("2"
                                        (case "iq0(q!1, s!1)")
                                        (("1"
                                          (expand "iq0")
                                          (("1"
                                            (flatten)
                                            (("1" (assert) nil nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (expand "E1")
                                          (("2"
                                            (expand "globinv")
                                            (("2"
                                              (expand "iqall")
                                              (("2"
                                                (flatten)
                                                (("2"
                                                  (inst?)
                                                  (("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((mu_to_bot formula-decl nil tournamentUnity0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (path const-decl "node" ctrees nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil)
    (fullset const-decl "set" sets nil)
    (mubot const-decl "bool" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (cap const-decl "bool" ownpred nil)
    (at15levpri const-decl "bool" tournamentUnity0 nil)
    (cup const-decl "bool" ownpred nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (unless_mubot formula-decl nil tournamentUnity0 nil)
    (PSP_leto formula-decl nil bdUnity nil)
    (digit type-eq-decl nil ctrees nil) (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (depth_path formula-decl nil ctrees nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (subset_leto formula-decl nil bdUnity nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (<= const-decl "bool" mucalculus nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil))
   nil)
  (at15_mubot-3 nil 3678785060
   ("" (skosimp)
    (("" (use mu_to_bot)
      (("" (assert)
        (("" (split)
          (("1" (lemma PSP_leto)
            (("1" (inst?)
              (("1" (use unless_mubot)
                (("1" (inst?)
                  (("1" (assert)
                    (("1" (hide -1 -3 -4)
                      (("1"
                        (name-replace pp1
                         "at15levpri(q!1, k!1, 1 + i!1)")
                        (("1"
                          (name-replace pp2 "mubot(path(q!1, k!1))")
                          (("1" (case "cap(fullset, pp1) = pp1")
                            (("1" (replaceh -1)
                              (("1"
                                (case
                                 "cup(cap(pp2, pp1), cap(pp1, pp2)) = cap(pp1, pp2)")
                                (("1" (assert) nil)
                                 ("2"
                                  (hide - 2)
                                  (("2"
                                    (apply-extensionality :hide? t)
                                    (("2"
                                      (iff)
                                      (("2"
                                        (expand "cap")
                                        (("2"
                                          (expand "cup")
                                          (("2"
                                            (prop)
                                            nil)))))))))))))))
                             ("2" (hide - 2)
                              (("2"
                                (apply-extensionality :hide? t)
                                (("2"
                                  (iff)
                                  (("2"
                                    (expand "cap")
                                    (("2"
                                      (expand "fullset")
                                      (("2"
                                        (propax)
                                        nil)))))))))))))))))))))))))))))
           ("2" (hide -)
            (("2" (case "k!1 < q!1`length")
              (("1" (hide 2)
                (("1" (expand "take")
                  (("1" (expand "max")
                    (("1" (expand "min") (("1" (assert) nil)))))))))
               ("2" (hide 2)
                (("2"
                  (name-replace goal
                   "cap(at15levpri(q!1, k!1, 1 + i!1), mubot(path(q!1, k!1)))")
                  (("2" (use subset_leto)
                    (("2" (assert)
                      (("2" (hide 3)
                        (("2" (expand "<=")
                          (("2" (expand "cap")
                            (("2" (expand "at15levpri")
                              (("2"
                                (skosimp)
                                (("2"
                                  (case "iq0(q!1, s!1)")
                                  (("1"
                                    (expand "iq0")
                                    (("1"
                                      (flatten)
                                      (("1" (assert) nil)))))
                                   ("2"
                                    (expand "E1")
                                    (("2"
                                      (expand "globinv")
                                      (("2"
                                        (expand "iqall")
                                        (("2"
                                          (flatten)
                                          (("2"
                                            (inst?)
                                            (("2"
                                              (assert)
                                              nil))))))))))))))))))))))))))))))))))))))))))
    nil)
   nil nil)
  (at15_mubot-2 nil 3671446719
   ("" (skosimp)
    (("" (use mu_to_bot)
      (("" (assert)
        (("" (split)
          (("1" (lemma PSP_leto)
            (("1" (inst?)
              (("1" (use unless_mubot)
                (("1" (inst?)
                  (("1" (assert)
                    (("1" (hide -1 -3 -4)
                      (("1"
                        (name-replace pp1
                         "at15levpri(q!1, k!1, 1 + i!1)")
                        (("1"
                          (name-replace pp2 "mubot(take(k!1, q!1))")
                          (("1" (case "cap(fullset, pp1) = pp1")
                            (("1" (replaceh -1)
                              (("1"
                                (case
                                 "cup(cap(pp2, pp1), cap(pp1, pp2)) = cap(pp1, pp2)")
                                (("1" (assert) nil nil)
                                 ("2"
                                  (hide - 2)
                                  (("2"
                                    (apply-extensionality :hide? t)
                                    (("2"
                                      (iff)
                                      (("2"
                                        (expand "cap")
                                        (("2"
                                          (expand "cup")
                                          (("2" (prop) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (hide - 2)
                              (("2"
                                (apply-extensionality :hide? t)
                                (("2"
                                  (iff)
                                  (("2"
                                    (expand "cap")
                                    (("2"
                                      (expand "fullset")
                                      (("2" (propax) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (hide -)
            (("2" (case "k!1 < q!1`length")
              (("1" (hide 2)
                (("1" (expand "take")
                  (("1" (expand "max")
                    (("1" (expand "min") (("1" (assert) nil nil)) nil))
                    nil))
                  nil))
                nil)
               ("2" (hide 2)
                (("2"
                  (name-replace goal
                   "cap(at15levpri(q!1, k!1, 1 + i!1), mubot(take(k!1, q!1)))")
                  (("2" (use subset_leto)
                    (("2" (assert)
                      (("2" (hide 3)
                        (("2" (expand "<=")
                          (("2" (expand "cap")
                            (("2" (expand "at15levpri")
                              (("2"
                                (skosimp)
                                (("2"
                                  (case "iq0(q!1, s!1)")
                                  (("1"
                                    (expand "iq0")
                                    (("1"
                                      (flatten)
                                      (("1" (assert) nil nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (expand "E1")
                                    (("2"
                                      (expand "globinv")
                                      (("2"
                                        (expand "iqall")
                                        (("2"
                                          (flatten)
                                          (("2"
                                            (inst?)
                                            (("2" (assert) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((mu_to_bot formula-decl nil tournamentUnity0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil)
    (below type-eq-decl nil nat_types nil)
    (pred type-eq-decl nil defined_types nil)
    (fullset const-decl "set" sets nil)
    (mubot const-decl "bool" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (cap const-decl "bool" ownpred nil)
    (at15levpri const-decl "bool" tournamentUnity0 nil)
    (cup const-decl "bool" ownpred nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (unless_mubot formula-decl nil tournamentUnity0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (PSP_leto formula-decl nil bdUnity nil)
    (min const-decl "{p: real | p <= m AND p <= n}" real_defs nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (<= const-decl "bool" mucalculus nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (subset_leto formula-decl nil bdUnity nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil))
   nil)
  (at15_mubot-1 nil 3670411345
   ("" (skosimp)
    (("" (use mu_to_bot)
      (("" (assert)
        (("" (split)
          (("1" (lemma PSP_leto)
            (("1" (inst?)
              (("1" (use unless_mubot)
                (("1" (inst?)
                  (("1" (assert)
                    (("1" (hide -1 -3 -4)
                      (("1"
                        (name-replace pp1
                         "at15levpri(q!1, k!1, 1 + i!1)")
                        (("1"
                          (name-replace pp2 "mubot(take(k!1, q!1))")
                          (("1" (case "cap(fullset, pp1) = pp1")
                            (("1" (replaceh -1)
                              (("1"
                                (case
                                 "cup(cap(pp2, pp1), cap(pp1, pp2)) = cap(pp1, pp2)")
                                (("1" (assert) nil nil)
                                 ("2"
                                  (hide - 2)
                                  (("2"
                                    (apply-extensionality :hide? t)
                                    (("2"
                                      (iff)
                                      (("2"
                                        (expand "cap")
                                        (("2"
                                          (expand "cup")
                                          (("2" (prop) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (hide - 2)
                              (("2"
                                (apply-extensionality :hide? t)
                                (("2"
                                  (iff)
                                  (("2"
                                    (expand "cap")
                                    (("2"
                                      (expand "fullset")
                                      (("2" (propax) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (hide - 2)
            (("2" (expand "take")
              (("2" (expand "max")
                (("2" (expand "min")
                  (("2" (lift-if) (("2" (assert) nil nil)) nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((mu_to_bot formula-decl nil tournamentUnity0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil)
    (below type-eq-decl nil nat_types nil)
    (pred type-eq-decl nil defined_types nil)
    (fullset const-decl "set" sets nil)
    (mubot const-decl "bool" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (cap const-decl "bool" ownpred nil)
    (at15levpri const-decl "bool" tournamentUnity0 nil)
    (cup const-decl "bool" ownpred nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (unless_mubot formula-decl nil tournamentUnity0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (PSP_leto formula-decl nil bdUnity nil)
    (min const-decl "{p: real | p <= m AND p <= n}" real_defs nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   shostak))
 (at15levpri_down 0
  (at15levpri_down-4 nil 3678788457
   ("" (skosimp)
    (("" (use at15_mubot)
      (("" (assert)
        (("" (use leadsto_at15levpri)
          (("" (lemma leto_transitive)
            (("" (name-replace pp1 "at15levpri(q!1, k!1, 1 + i!1)")
              ((""
                (name-replace goal
                 "cup(at15levpri(q!1, k!1, i!1), atlev(q!1, 12, k!1-1))")
                ((""
                  (name-replace pp2 "cap(pp1, mubot(path(q!1, k!1)))")
                  (("" (inst - m!1 W _ _ _ E1)
                    (("" (inst?)
                      (("" (assert)
                        (("" (inst?) (("" (assert) nil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((at15_mubot formula-decl nil tournamentUnity0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (leadsto_at15levpri formula-decl nil tournamentUnity0 nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (at15levpri const-decl "bool" tournamentUnity0 nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (path const-decl "node" ctrees nil)
    (mubot const-decl "bool" tournamentUnity0 nil)
    (cap const-decl "bool" ownpred nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil)
    (cup const-decl "bool" ownpred nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil) (digit type-eq-decl nil ctrees nil)
    (leto_transitive formula-decl nil bdUnity nil))
   nil)
  (at15levpri_down-3 nil 3671100243
   ("" (skosimp)
    (("" (use at15_mubot)
      (("" (assert)
        (("" (use leadsto_at15levpri)
          (("" (lemma leto_transitive)
            (("" (name-replace pp1 "at15levpri(q!1, k!1, 1 + i!1)")
              ((""
                (name-replace goal
                 "cup(at15levpri(q!1, k!1, i!1), atlev(q!1, 12, k!1-1))")
                ((""
                  (name-replace pp2 "cap(pp1, mubot(take(k!1, q!1)))")
                  (("" (inst - m!1 W _ _ _ E1)
                    (("" (inst?)
                      (("" (assert)
                        (("" (inst?) (("" (assert) nil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((at15_mubot formula-decl nil tournamentUnity0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (leadsto_at15levpri formula-decl nil tournamentUnity0 nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (at15levpri const-decl "bool" tournamentUnity0 nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (mubot const-decl "bool" tournamentUnity0 nil)
    (cap const-decl "bool" ownpred nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil)
    (cup const-decl "bool" ownpred nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (leto_transitive formula-decl nil bdUnity nil))
   nil)
  (at15levpri_down-2 nil 3670564248
   ("" (skosimp)
    (("" (use at15_mubot)
      (("" (assert)
        (("" (use leadsto_at15levpri)
          (("" (lemma leto_transitive)
            (("" (name-replace pp1 "at15levpri(q!1, k!1, 1 + i!1)")
              ((""
                (name-replace goal
                 "cup(at15levpri(q!1, k!1, i!1), at12levmin(q!1, k!1))")
                ((""
                  (name-replace pp2 "cap(pp1, mubot(take(k!1, q!1)))")
                  (("" (inst - m!1 W _ _ _ E1)
                    (("" (inst?)
                      (("" (assert)
                        (("" (inst?) (("" (assert) nil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((at15_mubot formula-decl nil tournamentUnity0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (leadsto_at15levpri formula-decl nil tournamentUnity0 nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (at15levpri const-decl "bool" tournamentUnity0 nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (mubot const-decl "bool" tournamentUnity0 nil)
    (cap const-decl "bool" ownpred nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil)
    (cup const-decl "bool" ownpred nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (leto_transitive formula-decl nil bdUnity nil))
   nil)
  (at15levpri_down-1 nil 3670412493
   ("" (skosimp)
    (("" (use at15_mubot)
      (("" (assert)
        (("" (use leadsto_at15levpri)
          (("" (lemma leto_transitive)
            (("" (name-replace pp1 "at15levpri(q!1, k!1, 1 + i!1)")
              ((""
                (name-replace goal
                 "cup(at15levpri(q!1, k!1, i!1), at12levmin(q!1, k!1))")
                ((""
                  (name-replace pp2 "cap(pp1, mubot(take(k!1, q!1)))")
                  (("" (inst - m!1 1 _ _ _ E1)
                    (("" (inst?)
                      (("" (assert)
                        (("" (inst?) (("" (assert) nil nil)) nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((at15_mubot formula-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (leadsto_at15levpri formula-decl nil tournamentUnity0 nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (at15levpri const-decl "bool" tournamentUnity0 nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (mubot const-decl "bool" tournamentUnity0 nil)
    (cap const-decl "bool" ownpred nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (specification type-eq-decl nil bdUnity nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil)
    (cup const-decl "bool" ownpred nil)
    (leto_transitive formula-decl nil bdUnity nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil))
   shostak))
 (at15levpri_induct 0
  (at15levpri_induct-5 nil 3671264654
   ("" (induct i)
    (("1" (assert)
      (("1" (skosimp)
        (("1" (use subset_leto)
          (("1" (assert)
            (("1" (hide - 2)
              (("1" (expand "<=")
                (("1" (expand "cap")
                  (("1" (expand "at15levpri")
                    (("1" (skosimp)
                      (("1" (use empty_card[Thread])
                        (("1" (assert)
                          (("1" (expand "empty?")
                            (("1" (expand "member")
                              (("1"
                                (inst - q!1)
                                (("1"
                                  (expand "cprio")
                                  (("1"
                                    (hide -4 +)
                                    (("1"
                                      (expand "E1")
                                      (("1"
                                        (case "lq0(q!1, s!1)")
                                        (("1"
                                          (expand "lq0")
                                          (("1" (propax) nil nil))
                                          nil)
                                         ("2"
                                          (expand "globinv")
                                          (("2"
                                            (expand "lqall")
                                            (("2"
                                              (flatten)
                                              (("2"
                                                (inst? -7)
                                                (("2"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil)
     ("2" (skosimp*)
      (("2" (inst?)
        (("2" (inst - m!1)
          (("2" (assert)
            (("2" (lemma at15levpri_down)
              (("2" (inst - j!1 k!1 m!1 q!1)
                (("2" (assert)
                  (("2" (name-replace jm "W * j!1 + j!1 * m!1")
                    (("2" (name-replace m1 "W + m!1")
                      (("2"
                        (name-replace pp0
                         "at15levpri(q!1, k!1, 1 + j!1)")
                        (("2"
                          (name-replace pp1
                           "at15levpri(q!1, k!1, j!1)")
                          (("2"
                            (name-replace goal
                             "atlev(q!1, 12, k!1 - 1)")
                            (("2" (lemma leto_transitive_1)
                              (("2"
                                (inst - m1 jm _ _ _ E1)
                                (("2"
                                  (inst?)
                                  (("2" (assert) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((at15levpri_down formula-decl nil tournamentUnity0 nil)
    (posint nonempty-type-eq-decl nil integers nil)
    (leto_transitive_1 formula-decl nil bdUnity nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (subset_leto formula-decl nil bdUnity nil)
    (cap const-decl "bool" ownpred nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (member const-decl "bool" sets nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (lqall const-decl "bool" tournamentSafe1 nil)
    (lq0 const-decl "bool" tournamentSafe1 nil)
    (empty? const-decl "bool" sets nil)
    (cprio const-decl "finite_set[Thread]" tournamentUnity0 nil)
    (empty_card formula-decl nil finite_sets nil)
    (<= const-decl "bool" mucalculus nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (at15levpri const-decl "bool" tournamentUnity0 nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (leto const-decl "bool" bdUnity nil)
    (specification type-eq-decl nil bdUnity nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil) (digit type-eq-decl nil ctrees nil)
    (ass_waiting const-decl "bool" tournamentUnity0 nil)
    (levleq_to_out const-decl "bool" tournamentUnity0 nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (int_minus_int_is_int application-judgement "int" integers nil))
   nil)
  (at15levpri_induct-4 nil 3671100307
   ("" (induct i)
    (("1" (assert)
      (("1" (skosimp)
        (("1" (use subset_leto)
          (("1" (assert)
            (("1" (hide - 2)
              (("1" (expand "<=")
                (("1" (expand "cap")
                  (("1" (expand "at15levpri")
                    (("1" (skosimp)
                      (("1" (use empty_card[Thread])
                        (("1" (assert)
                          (("1" (expand "empty?")
                            (("1" (expand "member")
                              (("1"
                                (inst - q!1)
                                (("1"
                                  (expand "cprio")
                                  (("1"
                                    (hide -4 +)
                                    (("1"
                                      (expand "E1")
                                      (("1"
                                        (use prio_irreflexive)
                                        (("1"
                                          (expand "globinv")
                                          (("1" (assert) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil)
     ("2" (skosimp*)
      (("2" (inst?)
        (("2" (inst - m!1)
          (("2" (assert)
            (("2" (lemma at15levpri_down)
              (("2" (inst - j!1 k!1 m!1 q!1)
                (("2" (assert)
                  (("2" (name-replace jm "W * j!1 + j!1 * m!1")
                    (("2" (name-replace m1 "W + m!1")
                      (("2"
                        (name-replace pp0
                         "at15levpri(q!1, k!1, 1 + j!1)")
                        (("2"
                          (name-replace pp1
                           "at15levpri(q!1, k!1, j!1)")
                          (("2"
                            (name-replace goal
                             "atlev(q!1, 12, k!1 - 1)")
                            (("2" (lemma leto_transitive_1)
                              (("2"
                                (inst - m1 jm _ _ _ E1)
                                (("2"
                                  (inst?)
                                  (("2" (assert) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((at15levpri_down formula-decl nil tournamentUnity0 nil)
    (posint nonempty-type-eq-decl nil integers nil)
    (leto_transitive_1 formula-decl nil bdUnity nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (subset_leto formula-decl nil bdUnity nil)
    (cap const-decl "bool" ownpred nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (member const-decl "bool" sets nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (empty? const-decl "bool" sets nil)
    (cprio const-decl "finite_set[Thread]" tournamentUnity0 nil)
    (empty_card formula-decl nil finite_sets nil)
    (<= const-decl "bool" mucalculus nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (at15levpri const-decl "bool" tournamentUnity0 nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (leto const-decl "bool" bdUnity nil)
    (specification type-eq-decl nil bdUnity nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (ass_waiting const-decl "bool" tournamentUnity0 nil)
    (levleq_to_out const-decl "bool" tournamentUnity0 nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil)
    (below type-eq-decl nil nat_types nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (int_minus_int_is_int application-judgement "int" integers nil))
   nil)
  (at15levpri_induct-3 nil 3670564795
   ("" (induct i)
    (("1" (assert)
      (("1" (skosimp)
        (("1" (use subset_leto)
          (("1" (assert)
            (("1" (hide - 2)
              (("1" (expand "<=")
                (("1" (expand "cap")
                  (("1" (expand "at15levpri")
                    (("1" (skosimp)
                      (("1" (use empty_card[Thread])
                        (("1" (assert)
                          (("1" (expand "empty?")
                            (("1" (expand "member")
                              (("1"
                                (inst - q!1)
                                (("1"
                                  (expand "cprio")
                                  (("1"
                                    (hide -4 +)
                                    (("1"
                                      (expand "E1")
                                      (("1"
                                        (use prio_irreflexive)
                                        (("1"
                                          (expand "globinv")
                                          (("1" (assert) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil)
     ("2" (skosimp*)
      (("2" (inst?)
        (("2" (inst - m!1)
          (("2" (assert)
            (("2" (lemma at15levpri_down)
              (("2" (inst - j!1 k!1 m!1 q!1)
                (("2" (assert)
                  (("2" (name-replace jm "W * j!1 + j!1 * m!1")
                    (("2" (name-replace m1 "W + m!1")
                      (("2"
                        (name-replace pp0
                         "at15levpri(q!1, k!1, 1 + j!1)")
                        (("2"
                          (name-replace pp1
                           "at15levpri(q!1, k!1, j!1)")
                          (("2"
                            (name-replace goal "at12levmin(q!1, k!1)")
                            (("2" (lemma leto_transitive_1)
                              (("2"
                                (inst - m1 jm _ _ _ E1)
                                (("2"
                                  (inst?)
                                  (("2" (assert) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((at15levpri_down formula-decl nil tournamentUnity0 nil)
    (posint nonempty-type-eq-decl nil integers nil)
    (leto_transitive_1 formula-decl nil bdUnity nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (subset_leto formula-decl nil bdUnity nil)
    (cap const-decl "bool" ownpred nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (member const-decl "bool" sets nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (empty? const-decl "bool" sets nil)
    (cprio const-decl "finite_set[Thread]" tournamentUnity0 nil)
    (empty_card formula-decl nil finite_sets nil)
    (<= const-decl "bool" mucalculus nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (at15levpri const-decl "bool" tournamentUnity0 nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (leto const-decl "bool" bdUnity nil)
    (specification type-eq-decl nil bdUnity nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (ass_waiting const-decl "bool" tournamentUnity0 nil)
    (levleq_to_out const-decl "bool" tournamentUnity0 nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil)
    (below type-eq-decl nil nat_types nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (int_minus_int_is_int application-judgement "int" integers nil))
   nil)
  (at15levpri_induct-2 nil 3670564560
   ("" (induct i)
    (("1" (assert)
      (("1" (skosimp)
        (("1" (use subset_leto)
          (("1" (assert)
            (("1" (hide - 2)
              (("1" (expand "<=")
                (("1" (expand "cap")
                  (("1" (expand "at15levpri")
                    (("1" (skosimp)
                      (("1" (use empty_card[Thread])
                        (("1" (assert)
                          (("1" (expand "empty?")
                            (("1" (expand "member")
                              (("1"
                                (inst - q!1)
                                (("1"
                                  (expand "cprio")
                                  (("1"
                                    (hide -4 +)
                                    (("1"
                                      (expand "E1")
                                      (("1"
                                        (use prio_irreflexive)
                                        (("1"
                                          (expand "globinv")
                                          (("1"
                                            (assert)
                                            nil)))))))))))))))))))))))))))))))))))))))
     ("2" (skosimp*)
      (("2" (inst?)
        (("2" (inst - m!1)
          (("2" (assert)
            (("2" (lemma at15levpri_down)
              (("2" (inst - j!1 k!1 m!1 q!1)
                (("2" (assert)
                  (("2" (name-replace jm "j!1 * m!1 + j!1")
                    (("2" (name-replace m1 "m!1 + W")
                      (("2"
                        (name-replace pp0
                         "at15levpri(q!1, k!1, 1 + j!1)")
                        (("2"
                          (name-replace pp1
                           "at15levpri(q!1, k!1, j!1)")
                          (("2"
                            (name-replace goal "at12levmin(q!1, k!1)")
                            (("2" (lemma leto_transitive_1)
                              (("2"
                                (inst - m1 jm _ _ _ E1)
                                (("2"
                                  (inst?)
                                  (("2"
                                    (assert)
                                    nil))))))))))))))))))))))))))))))))
    nil)
   nil nil)
  (at15levpri_induct-1 nil 3670412904
   ("" (induct i)
    (("1" (assert)
      (("1" (skosimp)
        (("1" (use subset_leto)
          (("1" (assert)
            (("1" (hide - 2)
              (("1" (expand "<=")
                (("1" (expand "cap")
                  (("1" (expand "at15levpri")
                    (("1" (skosimp)
                      (("1" (use empty_card[Thread])
                        (("1" (assert)
                          (("1" (expand "empty?")
                            (("1" (expand "member")
                              (("1"
                                (inst - q!1)
                                (("1"
                                  (expand "cprio")
                                  (("1"
                                    (hide -4 +)
                                    (("1"
                                      (expand "E1")
                                      (("1"
                                        (use prio_irreflexive)
                                        (("1"
                                          (expand "globinv")
                                          (("1" (assert) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil)
     ("2" (skosimp*)
      (("2" (inst?)
        (("2" (inst - m!1)
          (("2" (assert)
            (("2" (lemma at15levpri_down)
              (("2" (inst - j!1 k!1 m!1 q!1)
                (("2" (assert)
                  (("2" (name-replace jm "j!1 * m!1 + j!1")
                    (("2" (name-replace m1 "1+m!1")
                      (("2"
                        (name-replace pp0
                         "at15levpri(q!1, k!1, 1 + j!1)")
                        (("2"
                          (name-replace pp1
                           "at15levpri(q!1, k!1, j!1)")
                          (("2"
                            (name-replace goal "at12levmin(q!1, k!1)")
                            (("2" (lemma leto_transitive_1)
                              (("2"
                                (inst - m1 jm _ _ _ E1)
                                (("2"
                                  (inst?)
                                  (("2" (assert) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((at15levpri_down formula-decl nil tournamentUnity0 nil)
    (posint nonempty-type-eq-decl nil integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (leto_transitive_1 formula-decl nil bdUnity nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (subset_leto formula-decl nil bdUnity nil)
    (cap const-decl "bool" ownpred nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (member const-decl "bool" sets nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (empty? const-decl "bool" sets nil)
    (cprio const-decl "finite_set[Thread]" tournamentUnity0 nil)
    (empty_card formula-decl nil finite_sets nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (<= const-decl "bool" mucalculus nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (at15levpri const-decl "bool" tournamentUnity0 nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (leto const-decl "bool" bdUnity nil)
    (specification type-eq-decl nil bdUnity nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (levleq_to_out const-decl "bool" tournamentUnity0 nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil)
    (below type-eq-decl nil nat_types nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil))
   shostak))
 (degW_TCC1 0
  (degW_TCC1-1 nil 3671292455
   ("" (skolem!) (("" (use pos_times_le) (("" (assert) nil nil)) nil))
    nil)
   ((pos_times_le formula-decl nil real_props nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (nzint_times_nzint_is_nzint application-judgement "nzint" integers
     nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (at15levpri_degree 0
  (at15levpri_degree-5 nil 3678788626
   ("" (skosimp)
    (("" (lemma sub_leto)
      (("" (use at15levpri_induct (i "degree - 1" m m!1))
        (("1" (assert)
          (("1" (use leadsto_at15levpri (m "degree-1"))
            (("1" (assert)
              (("1" (name-replace pp0 "at15levpri(q!1, k!1, degree)")
                (("1" (name-replace goal "atlev(q!1, 12, k!1 - 1)")
                  (("1"
                    (name-replace pp1
                     "at15levpri(q!1, k!1, degree - 1)")
                    (("1"
                      (case "-1 * W - m!1 + (W * degree + degree * m!1) = degW(m!1)")
                      (("1" (replaceh -1)
                        (("1"
                          (name-replace pp2
                           "cap(pp0, mubot(path(q!1, k!1)))")
                          (("1" (assert)
                            (("1"
                              (inst - "degW(m!1) + W" pp0
                               "cup(pp1, pp2)" goal E1)
                              (("1"
                                (assert)
                                (("1"
                                  (hide 2)
                                  (("1"
                                    (split)
                                    (("1"
                                      (hide -)
                                      (("1"
                                        (expand "<=")
                                        (("1"
                                          (expand "pp2")
                                          (("1"
                                            (expand "pp0")
                                            (("1"
                                              (expand "pp1")
                                              (("1"
                                                (expand "cap")
                                                (("1"
                                                  (expand "cup")
                                                  (("1"
                                                    (expand
                                                     "at15levpri")
                                                    (("1"
                                                      (skosimp)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (expand
                                                           "mubot")
                                                          (("1"
                                                            (expand
                                                             "E1")
                                                            (("1"
                                                              (use
                                                               card_cprio_mu)
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (expand
                                                                   "curnode")
                                                                  (("1"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (use cup_leto)
                                      (("2"
                                        (assert)
                                        (("2"
                                          (hide 2)
                                          (("2"
                                            (split)
                                            (("1"
                                              (hide -1)
                                              (("1"
                                                (lemma leto_up)
                                                (("1"
                                                  (inst
                                                   -
                                                   "degW(m!1)"
                                                   "degW(m!1)+W"
                                                   _
                                                   _
                                                   _)
                                                  (("1"
                                                    (inst?)
                                                    (("1"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (lemma leto_transitive_1)
                                              (("2"
                                                (inst
                                                 -
                                                 W
                                                 "degW(m!1)"
                                                 _
                                                 _
                                                 _
                                                 _)
                                                (("2"
                                                  (inst?)
                                                  (("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (expand "degW") (("2" (propax) nil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (assert) nil nil))
        nil))
      nil))
    nil)
   ((state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (digit type-eq-decl nil ctrees nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (sub_leto formula-decl nil bdUnity nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (nzint_times_nzint_is_nzint application-judgement "nzint" integers
     nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (degW const-decl "nat" tournamentUnity0 nil)
    (path const-decl "node" ctrees nil)
    (mubot const-decl "bool" tournamentUnity0 nil)
    (cap const-decl "bool" ownpred nil)
    (pred type-eq-decl nil defined_types nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (cup const-decl "bool" ownpred nil)
    (cup_leto formula-decl nil bdUnity nil)
    (leto_transitive_1 formula-decl nil bdUnity nil)
    (leto_up formula-decl nil bdUnity nil)
    (pp2 skolem-const-decl "[state[degree, node] -> bool]"
     tournamentUnity0 nil)
    (pp1 skolem-const-decl "[state[degree, node] -> bool]"
     tournamentUnity0 nil)
    (card_cprio_mu formula-decl nil tournamentUnity0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (pp0 skolem-const-decl "[state[degree, node] -> bool]"
     tournamentUnity0 nil)
    (<= const-decl "bool" mucalculus nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (at15levpri const-decl "bool" tournamentUnity0 nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (leadsto_at15levpri formula-decl nil tournamentUnity0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (at15levpri_induct formula-decl nil tournamentUnity0 nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil)
  (at15levpri_degree-4 nil 3671341828
   ("" (skosimp)
    (("" (lemma sub_leto)
      (("" (use at15levpri_induct (i "degree - 1" m m!1))
        (("1" (assert)
          (("1" (use leadsto_at15levpri (m "degree-1"))
            (("1" (assert)
              (("1" (name-replace pp0 "at15levpri(q!1, k!1, degree)")
                (("1" (name-replace goal "atlev(q!1, 12, k!1 - 1)")
                  (("1"
                    (name-replace pp1
                     "at15levpri(q!1, k!1, degree - 1)")
                    (("1"
                      (case "-1 * W - m!1 + (W * degree + degree * m!1) = degW(m!1)")
                      (("1" (replaceh -1)
                        (("1"
                          (name-replace pp2
                           "cap(pp0, mubot(take(k!1, q!1)))")
                          (("1" (assert)
                            (("1"
                              (inst - "degW(m!1) + W" pp0
                               "cup(pp1, pp2)" goal E1)
                              (("1"
                                (assert)
                                (("1"
                                  (hide 2)
                                  (("1"
                                    (split)
                                    (("1"
                                      (hide -)
                                      (("1"
                                        (expand "<=")
                                        (("1"
                                          (expand "pp2")
                                          (("1"
                                            (expand "pp0")
                                            (("1"
                                              (expand "pp1")
                                              (("1"
                                                (expand "cap")
                                                (("1"
                                                  (expand "cup")
                                                  (("1"
                                                    (expand
                                                     "at15levpri")
                                                    (("1"
                                                      (skosimp)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (expand
                                                           "mubot")
                                                          (("1"
                                                            (expand
                                                             "E1")
                                                            (("1"
                                                              (use
                                                               card_cprio_mu)
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (expand
                                                                   "curnode")
                                                                  (("1"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (use cup_leto)
                                      (("2"
                                        (assert)
                                        (("2"
                                          (hide 2)
                                          (("2"
                                            (split)
                                            (("1"
                                              (hide -1)
                                              (("1"
                                                (lemma leto_up)
                                                (("1"
                                                  (inst
                                                   -
                                                   "degW(m!1)"
                                                   "degW(m!1)+W"
                                                   _
                                                   _
                                                   _)
                                                  (("1"
                                                    (inst?)
                                                    (("1"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (lemma leto_transitive_1)
                                              (("2"
                                                (inst
                                                 -
                                                 W
                                                 "degW(m!1)"
                                                 _
                                                 _
                                                 _
                                                 _)
                                                (("2"
                                                  (inst?)
                                                  (("2"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (expand "degW") (("2" (propax) nil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (assert) nil nil))
        nil))
      nil))
    nil)
   ((state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (sub_leto formula-decl nil bdUnity nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (nzint_times_nzint_is_nzint application-judgement "nzint" integers
     nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (degW const-decl "nat" tournamentUnity0 nil)
    (mubot const-decl "bool" tournamentUnity0 nil)
    (cap const-decl "bool" ownpred nil)
    (pred type-eq-decl nil defined_types nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (cup const-decl "bool" ownpred nil)
    (cup_leto formula-decl nil bdUnity nil)
    (leto_transitive_1 formula-decl nil bdUnity nil)
    (leto_up formula-decl nil bdUnity nil)
    (card_cprio_mu formula-decl nil tournamentUnity0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (<= const-decl "bool" mucalculus nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (at15levpri const-decl "bool" tournamentUnity0 nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (leadsto_at15levpri formula-decl nil tournamentUnity0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (at15levpri_induct formula-decl nil tournamentUnity0 nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil)
  (at15levpri_degree-3 nil 3671341558
   ("" (skosimp)
    (("" (lemma sub_leto)
      (("" (use at15levpri_induct (i "degree - 1" m m!1))
        (("1" (assert)
          (("1" (use leadsto_at15levpri (m "degree-1"))
            (("1" (assert)
              (("1" (name-replace pp0 "at15levpri(q!1, k!1, degree)")
                (("1" (name-replace goal "atlev(q!1, 12, k!1 - 1)")
                  (("1"
                    (name-replace pp1
                     "at15levpri(q!1, k!1, degree - 1)")
                    (("1"
                      (case "-1 * W - m!1 + (W * degree + degree * m!1) = degW(m!1)")
                      (("1" (replaceh -1)
                        (("1"
                          (name-replace pp2
                           "cap(pp0, mubot(take(k!1, q!1)))")
                          (("1" (case "nn1 >= 0")
                            (("1"
                              (inst - nn1 pp0 "cup(pp1, pp2)" goal E1)
                              (("1"
                                (assert)
                                (("1"
                                  (hide 2)
                                  (("1"
                                    (split)
                                    (("1"
                                      (hide -)
                                      (("1"
                                        (expand "<=")
                                        (("1"
                                          (expand "pp2")
                                          (("1"
                                            (expand "pp1")
                                            (("1"
                                              (expand "pp0")
                                              (("1"
                                                (expand "cup")
                                                (("1"
                                                  (expand "cap")
                                                  (("1"
                                                    (expand
                                                     "at15levpri")
                                                    (("1"
                                                      (skosimp)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (expand
                                                           "mubot")
                                                          (("1"
                                                            (use
                                                             card_cprio_mu)
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (expand
                                                                 "E1")
                                                                (("1"
                                                                  (assert)
                                                                  (("1"
                                                                    (expand
                                                                     "curnode")
                                                                    (("1"
                                                                      (assert)
                                                                      nil)))))))))))))))))))))))))))))))))
                                     ("2"
                                      (use cup_leto)
                                      (("2"
                                        (assert)
                                        (("2"
                                          (hide 2)
                                          (("2"
                                            (split)
                                            (("1"
                                              (hide -1)
                                              (("1"
                                                (lemma leto_up)
                                                (("1"
                                                  (postpone)
                                                  (("1"
                                                    (inst?)
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (expand "nn1")
                                                        (("1"
                                                          (assert)
                                                          nil)))))))
                                                   ("2"
                                                    (hide - 2)
                                                    (("2"
                                                      (lemma
                                                       pos_times_le)
                                                      (("2"
                                                        (inst
                                                         -
                                                         "degree-1"
                                                         "W + m!1")
                                                        (("2"
                                                          (assert)
                                                          nil)))))))))))))
                                             ("2"
                                              (expand "pp2")
                                              (("2"
                                                (name-replace
                                                 pp3
                                                 "cap(pp0, mubot(take(k!1, q!1)))")
                                                (("2"
                                                  (lemma
                                                   leto_transitive_1)
                                                  (("2"
                                                    (inst
                                                     -
                                                     W
                                                     _
                                                     pp3
                                                     pp1
                                                     goal
                                                     E1)
                                                    (("2"
                                                      (inst
                                                       -
                                                       "-1 * W - m!1 + (W * degree + degree * m!1)")
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (expand
                                                           "nn1")
                                                          (("1"
                                                            (assert)
                                                            nil)))))
                                                       ("2"
                                                        (hide - 2)
                                                        (("2"
                                                          (lemma
                                                           pos_times_le)
                                                          (("2"
                                                            (inst
                                                             -
                                                             "degree-1"
                                                             "W + m!1")
                                                            (("2"
                                                              (assert)
                                                              nil)))))))))))))))))))))))))))))))))
                             ("2" (hide - 2)
                              (("2"
                                (expand "nn1")
                                (("2"
                                  (lemma pos_times_le)
                                  (("2"
                                    (inst - "degree-1" m!1)
                                    (("2"
                                      (assert)
                                      nil)))))))))))))))))))))))))))))
         ("2" (assert) nil))))))
    nil)
   nil nil)
  (at15levpri_degree-2 nil 3671290527
   ("" (skosimp)
    (("" (lemma sub_leto)
      (("" (use at15levpri_induct (i "degree - 1" m m!1))
        (("1" (assert)
          (("1" (use leadsto_at15levpri (m "degree-1"))
            (("1" (assert)
              (("1" (name-replace pp0 "at15levpri(q!1, k!1, degree)")
                (("1" (name-replace goal "atlev(q!1, 12, k!1 - 1)")
                  (("1"
                    (name-replace pp1
                     "at15levpri(q!1, k!1, degree - 1)")
                    (("1"
                      (name-replace nn1
                       "degree * W - m!1 + degree * m!1")
                      (("1"
                        (name-replace pp2
                         "cap(pp0, mubot(take(k!1, q!1)))")
                        (("1" (case "nn1 >= 0")
                          (("1"
                            (inst - nn1 pp0 "cup(pp1, pp2)" goal E1)
                            (("1" (assert)
                              (("1"
                                (hide 2)
                                (("1"
                                  (split)
                                  (("1"
                                    (hide -)
                                    (("1"
                                      (expand "<=")
                                      (("1"
                                        (expand "pp2")
                                        (("1"
                                          (expand "pp1")
                                          (("1"
                                            (expand "pp0")
                                            (("1"
                                              (expand "cup")
                                              (("1"
                                                (expand "cap")
                                                (("1"
                                                  (expand "at15levpri")
                                                  (("1"
                                                    (skosimp)
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (expand
                                                         "mubot")
                                                        (("1"
                                                          (use
                                                           card_cprio_mu)
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (expand
                                                               "E1")
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (expand
                                                                   "curnode")
                                                                  (("1"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (use cup_leto)
                                    (("2"
                                      (assert)
                                      (("2"
                                        (hide 2)
                                        (("2"
                                          (split)
                                          (("1"
                                            (hide -1)
                                            (("1"
                                              (lemma leto_up)
                                              (("1"
                                                (inst
                                                 -
                                                 "-1 * W - m!1 + (W * degree + degree * m!1)"
                                                 nn1
                                                 _
                                                 _
                                                 E1)
                                                (("1"
                                                  (inst?)
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (expand "nn1")
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (hide - 2)
                                                  (("2"
                                                    (lemma
                                                     pos_times_le)
                                                    (("2"
                                                      (inst
                                                       -
                                                       "degree-1"
                                                       "W + m!1")
                                                      (("2"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (expand "pp2")
                                            (("2"
                                              (name-replace
                                               pp3
                                               "cap(pp0, mubot(take(k!1, q!1)))")
                                              (("2"
                                                (lemma
                                                 leto_transitive_1)
                                                (("2"
                                                  (inst
                                                   -
                                                   W
                                                   _
                                                   pp3
                                                   pp1
                                                   goal
                                                   E1)
                                                  (("2"
                                                    (inst
                                                     -
                                                     "-1 * W - m!1 + (W * degree + degree * m!1)")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (expand "nn1")
                                                        (("1"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (hide - 2)
                                                      (("2"
                                                        (lemma
                                                         pos_times_le)
                                                        (("2"
                                                          (inst
                                                           -
                                                           "degree-1"
                                                           "W + m!1")
                                                          (("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (hide - 2)
                            (("2" (expand "nn1")
                              (("2"
                                (lemma pos_times_le)
                                (("2"
                                  (inst - "degree-1" m!1)
                                  (("2" (assert) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (assert) nil nil))
        nil))
      nil))
    nil)
   ((state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (sub_leto formula-decl nil bdUnity nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nzint_times_nzint_is_nzint application-judgement "nzint" integers
     nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (<= const-decl "bool" mucalculus nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (card_cprio_mu formula-decl nil tournamentUnity0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (leto_up formula-decl nil bdUnity nil)
    (pos_times_le formula-decl nil real_props nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (leto_transitive_1 formula-decl nil bdUnity nil)
    (cup_leto formula-decl nil bdUnity nil)
    (cup const-decl "bool" ownpred nil)
    (specification type-eq-decl nil bdUnity nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil)
    (cap const-decl "bool" ownpred nil)
    (mubot const-decl "bool" tournamentUnity0 nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (at15levpri const-decl "bool" tournamentUnity0 nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (leadsto_at15levpri formula-decl nil tournamentUnity0 nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (at15levpri_induct formula-decl nil tournamentUnity0 nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil)
  (at15levpri_degree-1 nil 3671286988
   ("" (skosimp)
    (("" (lemma sub_leto)
      (("" (use at15levpri_induct (i "degree - 1" m m!1))
        (("1" (assert)
          (("1" (use leadsto_at15levpri (m "degree-1"))
            (("1" (assert)
              (("1" (name-replace pp0 "at15levpri(q!1, k!1, degree)")
                (("1" (name-replace goal "atlev(q!1, 12, k!1 - 1)")
                  (("1"
                    (name-replace pp1
                     "at15levpri(q!1, k!1, degree - 1)")
                    (("1"
                      (name-replace nn1
                       "degree * W - m!1 + degree * m!1")
                      (("1"
                        (name-replace pp2
                         "cap(pp0, mubot(take(k!1, q!1)))")
                        (("1" (inst - nn1 pp0 "cup(pp1, pp2)" goal E1)
                          (("1" (assert)
                            (("1" (hide 2)
                              (("1"
                                (split)
                                (("1"
                                  (hide -)
                                  (("1"
                                    (expand "<=")
                                    (("1"
                                      (expand "pp2")
                                      (("1"
                                        (expand "pp1")
                                        (("1"
                                          (expand "pp0")
                                          (("1"
                                            (expand "cup")
                                            (("1"
                                              (expand "cap")
                                              (("1"
                                                (expand "at15levpri")
                                                (("1"
                                                  (skosimp)
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (expand "mubot")
                                                      (("1"
                                                        (use
                                                         card_cprio_mu)
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (expand
                                                             "E1")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (expand
                                                                 "curnode")
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (use cup_leto)
                                  (("1"
                                    (assert)
                                    (("1"
                                      (hide 2)
                                      (("1"
                                        (split)
                                        (("1"
                                          (hide -1)
                                          (("1"
                                            (lemma leto_up)
                                            (("1"
                                              (inst
                                               -
                                               "-1 * W - m!1 + (W * degree + degree * m!1)"
                                               nn1
                                               _
                                               _
                                               E1)
                                              (("1"
                                                (inst?)
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (expand "nn1")
                                                    (("1"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (expand "nn1")
                                                (("2"
                                                  (hide - 2)
                                                  (("2"
                                                    (lemma
                                                     pos_times_le)
                                                    (("2"
                                                      (inst
                                                       -
                                                       "degree -1"
                                                       m!1)
                                                      (("2"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("3"
                                                (hide - 2)
                                                (("3"
                                                  (lemma pos_times_le)
                                                  (("3"
                                                    (inst
                                                     -
                                                     "degree -1"
                                                     "W+m!1")
                                                    (("3"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (expand "pp2")
                                          (("2"
                                            (name-replace
                                             pp3
                                             "cap(pp0, mubot(take(k!1, q!1)))")
                                            (("2"
                                              (lemma leto_transitive_1)
                                              (("2"
                                                (inst
                                                 -
                                                 W
                                                 _
                                                 pp3
                                                 pp1
                                                 goal
                                                 E1)
                                                (("2"
                                                  (inst
                                                   -
                                                   "-1 * W - m!1 + (W * degree + degree * m!1)")
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (expand "nn1")
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (hide - 2)
                                                    (("2"
                                                      (lemma
                                                       pos_times_le)
                                                      (("2"
                                                        (inst
                                                         -
                                                         "degree-1"
                                                         "W + m!1")
                                                        (("2"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (hide - 2)
                                    (("2"
                                      (expand "nn1")
                                      (("2"
                                        (lemma pos_times_le)
                                        (("2"
                                          (inst - "degree-1" m!1)
                                          (("2" (assert) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (postpone) nil nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (postpone) nil nil))
        nil))
      nil))
    nil)
   nil shostak))
 (atlev15_to12 0
  (atlev15_to12-4 nil 3671291000
   ("" (skosimp)
    (("" (use at15levpri_degree)
      (("" (assert)
        (("" (lemma sub_leto)
          ((""
            (inst - _ "atlev(q!1, 15, k!1)"
             "at15levpri(q!1, k!1, degree)" _ _)
            (("" (inst?)
              (("" (assert)
                (("" (hide - 2)
                  (("" (expand "<=")
                    (("" (expand "cap")
                      (("" (expand "at15levpri")
                        (("" (expand "atlev")
                          (("" (skosimp)
                            (("" (assert)
                              ((""
                                (use card_cprio)
                                ((""
                                  (assert)
                                  ((""
                                    (expand "E1")
                                    (("" (propax) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((at15levpri_degree formula-decl nil tournamentUnity0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil) (digit type-eq-decl nil ctrees nil)
    (sub_leto formula-decl nil bdUnity nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (degW const-decl "nat" tournamentUnity0 nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (specification type-eq-decl nil bdUnity nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (cap const-decl "bool" ownpred nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (card_cprio formula-decl nil tournamentUnity0 nil)
    (<= const-decl "bool" mucalculus nil)
    (pred type-eq-decl nil defined_types nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (at15levpri const-decl "bool" tournamentUnity0 nil))
   nil)
  (atlev15_to12-3 nil 3670734079
   ("" (skosimp)
    (("" (use at15levpri_induct)
      (("" (assert)
        (("" (lemma sub_leto)
          ((""
            (inst - _ "atlev(q!1, 15, k!1)"
             "at15levpri(q!1, k!1, degree)" _ _)
            (("" (inst?)
              (("" (assert)
                (("" (hide - 2)
                  (("" (expand "<=")
                    (("" (expand "cap")
                      (("" (expand "at15levpri")
                        (("" (expand "atlev")
                          (("" (skosimp)
                            (("" (assert)
                              ((""
                                (use card_cprio)
                                ((""
                                  (expand "E1")
                                  (("" (assert) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((at15levpri_induct formula-decl nil tournamentUnity0 nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (< const-decl "bool" reals nil)
    (below type-eq-decl nil nat_types nil)
    (sub_leto formula-decl nil bdUnity nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (cap const-decl "bool" ownpred nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (card_cprio formula-decl nil tournamentUnity0 nil)
    (<= const-decl "bool" mucalculus nil)
    (pred type-eq-decl nil defined_types nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (at15levpri const-decl "bool" tournamentUnity0 nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil))
   nil)
  (atlev15_to12-2 nil 3670414608
   ("" (skosimp)
    (("" (use at15levpri_induct)
      (("" (assert)
        (("" (lemma sub_leto)
          ((""
            (inst - _ "at15lev(q!1, k!1)"
             "at15levpri(q!1, k!1, degree)" _ _)
            (("" (inst?)
              (("" (assert)
                (("" (hide - 2)
                  (("" (expand "<=")
                    (("" (expand "cap")
                      (("" (expand "at15levpri")
                        (("" (expand "at15lev")
                          (("" (skosimp)
                            (("" (assert)
                              ((""
                                (use card_cprio)
                                ((""
                                  (expand "E1")
                                  (("" (assert) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((at15levpri_induct formula-decl nil tournamentUnity0 nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (< const-decl "bool" reals nil)
    (below type-eq-decl nil nat_types nil)
    (sub_leto formula-decl nil bdUnity nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (cap const-decl "bool" ownpred nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (card_cprio formula-decl nil tournamentUnity0 nil)
    (<= const-decl "bool" mucalculus nil)
    (pred type-eq-decl nil defined_types nil)
    (at15levpri const-decl "bool" tournamentUnity0 nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil))
   nil)
  (atlev15_to12-1 nil 3670414392
   ("" (skosimp)
    (("" (use at15levpri_induct)
      (("" (assert)
        (("" (lemma sub_leto)
          ((""
            (inst - _ "at15lev(q!1, k!1)"
             "at15levpri(q!1, k!1, degree)" _ _)
            (("" (inst?)
              (("" (assert)
                (("" (hide - 2)
                  (("" (expand "<=")
                    (("" (expand "cap")
                      (("" (expand "at15levpri")
                        (("" (expand "at15lev")
                          (("" (skosimp)
                            (("" (assert)
                              ((""
                                (use card_prio)
                                ((""
                                  (expand "E1")
                                  ((""
                                    (assert)
                                    (("" (postpone) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   nil shostak))
 (ass_doorway_extended 0
  (ass_doorway_extended-5 nil 3670734501
   ("" (skosimp)
    ((""
      (case "leto(E1)(D, leveq_betw(q!1, 13, 14, k!1), atlev(q!1, 15, k!1))")
      (("1" (hide -2)
        (("1"
          (case "leveq_betw(q!1, 12, 15, k!1) = cup(leveq_betw(q!1, 13, 14, k!1),
cup(atlev(q!1, 15, k!1), atlev(q!1, 12, k!1)))")
          (("1" (replaceh -1)
            (("1" (use cup_leto)
              (("1" (assert)
                (("1" (hide 2)
                  (("1" (split)
                    (("1" (use leto_up (i D j "1+D"))
                      (("1" (assert) nil nil)) nil)
                     ("2" (use cup_leto)
                      (("2" (assert)
                        (("2" (hide 2)
                          (("2" (split)
                            (("1" (hide -1)
                              (("1"
                                (use subset_leto)
                                (("1"
                                  (assert)
                                  (("1"
                                    (hide 2)
                                    (("1"
                                      (expand "<=")
                                      (("1"
                                        (expand "cap")
                                        (("1" (skosimp) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (lemma leto_transitive)
                              (("2"
                                (inst - 1 D _ _ _ E1)
                                (("2"
                                  (inst?)
                                  (("2"
                                    (assert)
                                    (("2"
                                      (inst?)
                                      (("2"
                                        (assert)
                                        (("2"
                                          (hide -1 2)
                                          (("2"
                                            (s-ensures)
                                            (("2"
                                              (split)
                                              (("1"
                                                (skosimp*)
                                                (("1"
                                                  (expand "E1")
                                                  (("1"
                                                    (expand "step")
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (skolem!)
                                                        (("1"
                                                          (case
                                                           "q!1=p!1")
                                                          (("1"
                                                            (replaceh
                                                             -1)
                                                            (("1"
                                                              (expand
                                                               "atlev")
                                                              (("1"
                                                                (flatten)
                                                                (("1"
                                                                  (expand
                                                                   "step")
                                                                  (("1"
                                                                    (expand
                                                                     "step11")
                                                                    (("1"
                                                                      (expand
                                                                       "step14")
                                                                      (("1"
                                                                        (assert)
                                                                        (("1"
                                                                          (expand
                                                                           "step15F")
                                                                          (("1"
                                                                            (expand
                                                                             "step15G")
                                                                            (("1"
                                                                              (expand
                                                                               "step16")
                                                                              (("1"
                                                                                (expand
                                                                                 "step17")
                                                                                (("1"
                                                                                  (expand
                                                                                   "step13")
                                                                                  (("1"
                                                                                    (expand
                                                                                     "step18")
                                                                                    (("1"
                                                                                      (expand
                                                                                       "step19")
                                                                                      (("1"
                                                                                        (expand
                                                                                         "step12")
                                                                                        (("1"
                                                                                          (replaceh
                                                                                           -4)
                                                                                          (("1"
                                                                                            (expand
                                                                                             "leveq_betw")
                                                                                            (("1"
                                                                                              (expand
                                                                                               "goto")
                                                                                              (("1"
                                                                                                (propax)
                                                                                                nil
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (hide
                                                             2
                                                             4
                                                             -2)
                                                            (("2"
                                                              (expand
                                                               "atlev")
                                                              (("2"
                                                                (flatten)
                                                                (("2"
                                                                  (grind)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (typepred enum_thread)
                                                (("2"
                                                  (expand "bijective?")
                                                  (("2"
                                                    (flatten)
                                                    (("2"
                                                      (expand
                                                       "surjective?")
                                                      (("2"
                                                        (inst?)
                                                        (("2"
                                                          (skolem!)
                                                          (("2"
                                                            (inst
                                                             +
                                                             x!1)
                                                            (("2"
                                                              (split)
                                                              (("1"
                                                                (skosimp)
                                                                (("1"
                                                                  (use
                                                                   enabled_E1)
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (hide
                                                                       3)
                                                                      (("1"
                                                                        (expand
                                                                         "enabled1")
                                                                        (("1"
                                                                          (expand
                                                                           "atlev")
                                                                          (("1"
                                                                            (flatten)
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (skosimp)
                                                                (("2"
                                                                  (expand
                                                                   "E1")
                                                                  (("2"
                                                                    (expand
                                                                     "atlev")
                                                                    (("2"
                                                                      (flatten)
                                                                      (("2"
                                                                        (replaceh
                                                                         -8)
                                                                        (("2"
                                                                          (expand
                                                                           "forward1")
                                                                          (("2"
                                                                            (expand
                                                                             "step17")
                                                                            (("2"
                                                                              (assert)
                                                                              (("2"
                                                                                (expand
                                                                                 "step19")
                                                                                (("2"
                                                                                  (expand
                                                                                   "step12")
                                                                                  (("2"
                                                                                    (replaceh
                                                                                     -3)
                                                                                    (("2"
                                                                                      (expand
                                                                                       "goto")
                                                                                      (("2"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (hide 2 -1)
            (("2" (apply-extensionality :hide? t)
              (("2" (expand "cup")
                (("2" (expand "leveq_betw")
                  (("2" (expand "atlev")
                    (("2" (iff) (("2" (ground) nil nil)) nil)) nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (hide 2)
        (("2" (expand "ass_doorway")
          (("2" (inst?)
            (("2" (lemma PSP_leto)
              (("2"
                (inst - D "between(q!1, 13, 14)"
                 "leveq_betw(q!1, 13, 14, k!1)" "atlev(q!1, 15, k!1)"
                 "neg(between(q!1, 13, 14))" E1)
                (("2" (assert)
                  (("2" (split)
                    (("1"
                      (case "cap(between(q!1, 13, 14), leveq_betw(q!1, 13, 14, k!1)) = 
leveq_betw(q!1, 13, 14, k!1)")
                      (("1" (replaceh -1)
                        (("1"
                          (case "cup(cap(neg(between(q!1, 13, 14)),
                   leveq_betw(q!1, 13, 14, k!1)),
               atlev(q!1, 15, k!1)) = atlev(q!1, 15, k!1)")
                          (("1" (assert) nil nil)
                           ("2" (hide - 2)
                            (("2" (apply-extensionality :hide? t)
                              (("2"
                                (iff)
                                (("2"
                                  (expand "cup")
                                  (("2"
                                    (expand "cap")
                                    (("2"
                                      (prop)
                                      (("2"
                                        (expand "neg")
                                        (("2"
                                          (expand "leveq_betw")
                                          (("2"
                                            (flatten)
                                            (("2"
                                              (expand "between")
                                              (("2" (assert) nil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (hide - 2)
                        (("2" (apply-extensionality :hide? t)
                          (("2" (iff)
                            (("2" (expand "cap")
                              (("2"
                                (prop)
                                (("2"
                                  (expand "leveq_betw")
                                  (("2"
                                    (expand "between")
                                    (("2"
                                      (flatten)
                                      (("2" (assert) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide 2)
                      (("2" (lemma sub_leto)
                        (("2"
                          (inst - D "between(q!1, 13, 14)" fullset
                           "neg(between(q!1, 13, 14))" E1)
                          (("2" (assert)
                            (("2" (hide - 2)
                              (("2"
                                (expand "<=")
                                (("2"
                                  (expand "fullset")
                                  (("2" (propax) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("3" (hide - 2)
                      (("3" (expand "unless")
                        (("3" (expand "<=")
                          (("3" (expand "wp")
                            (("3" (expand "cup")
                              (("3"
                                (expand "leveq_betw")
                                (("3"
                                  (expand "cap")
                                  (("3"
                                    (expand "neg")
                                    (("3"
                                      (expand "atlev")
                                      (("3"
                                        (expand "E1")
                                        (("3"
                                          (skosimp*)
                                          (("3"
                                            (expand "step")
                                            (("3"
                                              (split -)
                                              (("1" (assert) nil nil)
                                               ("2"
                                                (skolem!)
                                                (("2"
                                                  (assert)
                                                  (("2"
                                                    (case "q!1=p!1")
                                                    (("1"
                                                      (replaceh -1)
                                                      (("1"
                                                        (expand "step")
                                                        (("1"
                                                          (expand
                                                           "step11")
                                                          (("1"
                                                            (assert)
                                                            (("1"
                                                              (expand
                                                               "step12")
                                                              (("1"
                                                                (expand
                                                                 "step15F")
                                                                (("1"
                                                                  (expand
                                                                   "step15G")
                                                                  (("1"
                                                                    (expand
                                                                     "step16")
                                                                    (("1"
                                                                      (expand
                                                                       "step17")
                                                                      (("1"
                                                                        (expand
                                                                         "step18")
                                                                        (("1"
                                                                          (expand
                                                                           "step19")
                                                                          (("1"
                                                                            (split
                                                                             -)
                                                                            (("1"
                                                                              (expand
                                                                               "step13")
                                                                              (("1"
                                                                                (flatten)
                                                                                (("1"
                                                                                  (replaceh
                                                                                   -1)
                                                                                  (("1"
                                                                                    (expand
                                                                                     "next13")
                                                                                    (("1"
                                                                                      (propax)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (expand
                                                                               "step14")
                                                                              (("2"
                                                                                (flatten)
                                                                                (("2"
                                                                                  (replaceh
                                                                                   -1)
                                                                                  (("2"
                                                                                    (expand
                                                                                     "next14")
                                                                                    (("2"
                                                                                      (propax)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (hide-all-but
                                                       (-1
                                                        -2
                                                        -3
                                                        -4
                                                        1
                                                        3))
                                                      (("2"
                                                        (split)
                                                        (("1"
                                                          (grind)
                                                          nil
                                                          nil)
                                                         ("2"
                                                          (grind)
                                                          nil
                                                          nil)
                                                         ("3"
                                                          (grind)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((atlev const-decl "bool" tournamentUnity0 nil)
    (leveq_betw const-decl "bool" tournamentUnity0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (D const-decl "posnat" tournamentUnity0 nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (leto const-decl "bool" bdUnity nil)
    (specification type-eq-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (digit type-eq-decl nil ctrees nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (cup const-decl "bool" ownpred nil)
    (cup_leto formula-decl nil bdUnity nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (leto_transitive formula-decl nil bdUnity nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (empty? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (step const-decl "bool" tournamentUnity0 nil)
    (surjective? const-decl "bool" functions nil)
    (enabled_E1 formula-decl nil tournamentUnity0 nil)
    (enabled1 const-decl "bool" tournamentUnity0 nil)
    (forward1 const-decl "bool" tournamentUnity0 nil)
    (enum_thread const-decl "(bijective?[below[N], (thread)])"
     tournamentSafe0 nil)
    (bijective? const-decl "bool" functions nil)
    (below type-eq-decl nil nat_types nil)
    (N const-decl "posnat" tournamentSafe0 nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (neg const-decl "bool" ownpred nil)
    (wp const-decl "bool" ownpred nil)
    (transient const-decl "bool" bdUnity nil)
    (co const-decl "bool" bdUnity nil)
    (ensures const-decl "bool" bdUnity nil)
    (ensures_leto formula-decl nil bdUnity nil)
    (<= const-decl "bool" mucalculus nil)
    (cap const-decl "bool" ownpred nil)
    (subset_leto formula-decl nil bdUnity nil)
    (leto_up formula-decl nil bdUnity nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (ass_doorway const-decl "bool" tournamentUnity0 nil)
    (PSP_leto formula-decl nil bdUnity nil)
    (unless const-decl "bool" bdUnity nil)
    (fullset const-decl "set" sets nil)
    (sub_leto formula-decl nil bdUnity nil)
    (between const-decl "bool" tournamentUnity0 nil))
   nil)
  (ass_doorway_extended-4 nil 3670734223
   ("" (skosimp)
    (("" (lemma PSP_leto)
      ((""
        (case "leto(E1)(1 + D, cup(at12body(q!1), between(q!1, 13, 15)), at(q!1, 15))")
        (("1" (inst?)
          (("1" (name-replace pp0 "leveq_betw(q!1, 12, 15, k!1)")
            (("1" (name-replace pp1 "atlev(q!1, 15, k!1)")
              (("1" (inst - pp0 pp1)
                (("1" (assert)
                  (("1" (split)
                    (("1" (hide -2 -3)
                      (("1"
                        (case "cap(cup(at12body(q!1), between(q!1, 13, 15)), pp0)=pp0")
                        (("1" (replaceh -1)
                          (("1"
                            (case " cup(cap(at(q!1, 15), pp0), pp1) = pp1")
                            (("1" (replaceh -1) nil nil)
                             ("2" (hide - 2)
                              (("2"
                                (apply-extensionality :hide? t)
                                (("2"
                                  (iff)
                                  (("2"
                                    (expand "cup")
                                    (("2"
                                      (prop)
                                      (("2"
                                        (expand "pp1")
                                        (("2"
                                          (expand "pp0")
                                          (("2"
                                            (expand "cap")
                                            (("2"
                                              (expand "leveq_betw")
                                              (("2"
                                                (flatten)
                                                (("2"
                                                  (expand "atlev")
                                                  (("2"
                                                    (expand "at")
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (hide - 2)
                          (("2" (apply-extensionality :hide? t)
                            (("2" (iff)
                              (("2"
                                (prop)
                                (("1"
                                  (expand "pp0")
                                  (("1"
                                    (expand "leveq_betw")
                                    (("1"
                                      (expand "cap")
                                      (("1"
                                        (expand "between")
                                        (("1"
                                          (flatten)
                                          (("1" (assert) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (expand "pp0")
                                  (("2"
                                    (expand "cap")
                                    (("2"
                                      (assert)
                                      (("2"
                                        (expand "leveq_betw")
                                        (("2"
                                          (expand "between")
                                          (("2"
                                            (flatten)
                                            (("2"
                                              (assert)
                                              (("2"
                                                (expand "cup")
                                                (("2"
                                                  (expand "at12body")
                                                  (("2"
                                                    (flatten)
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide - 2)
                      (("2" (expand "pp0")
                        (("2" (expand "pp1")
                          (("2" (expand "unless")
                            (("2" (expand "<=")
                              (("2"
                                (expand "wp")
                                (("2"
                                  (expand "cup")
                                  (("2"
                                    (expand "cap")
                                    (("2"
                                      (expand "neg")
                                      (("2"
                                        (expand "leveq_betw")
                                        (("2"
                                          (skosimp*)
                                          (("2"
                                            (expand "atlev")
                                            (("2"
                                              (expand "E1")
                                              (("2"
                                                (expand "step")
                                                (("2"
                                                  (split -)
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil)
                                                   ("2"
                                                    (skolem!)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (case
                                                         "q!1=p!1")
                                                        (("1"
                                                          (replaceh -1)
                                                          (("1"
                                                            (hide 3 -5)
                                                            (("1"
                                                              (grind)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (case
                                                           "y!1`pc(q!1) = s!1`pc(q!1) AND y!1`level(q!1) = s!1`level(q!1)")
                                                          (("1"
                                                            (flatten)
                                                            (("1"
                                                              (replaceh
                                                               -1)
                                                              (("1"
                                                                (replaceh
                                                                 -1)
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (hide-all-but
                                                             (-1 1 2))
                                                            (("2"
                                                              (split)
                                                              (("1"
                                                                (grind)
                                                                nil
                                                                nil)
                                                               ("2"
                                                                (grind)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (hide -1 2)
          (("2" (expand "ass_doorway")
            (("2" (inst?)
              (("2" (use cup_leto)
                (("2" (assert)
                  (("2" (hide 2)
                    (("2" (split)
                      (("1" (lemma leto_transitive)
                        (("1" (inst - 1 D _ _ _ E1)
                          (("1" (inst?)
                            (("1" (assert)
                              (("1"
                                (inst?)
                                (("1"
                                  (assert)
                                  (("1"
                                    (hide - 2)
                                    (("1"
                                      (s-ensures)
                                      (("1"
                                        (expand "at12body")
                                        (("1"
                                          (expand "between")
                                          (("1"
                                            (split)
                                            (("1"
                                              (skosimp*)
                                              (("1"
                                                (expand "E1")
                                                (("1"
                                                  (expand "step")
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (split -)
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil)
                                                       ("2"
                                                        (skolem!)
                                                        (("2"
                                                          (case
                                                           "q!1=p!1")
                                                          (("1"
                                                            (replaceh
                                                             -1)
                                                            (("1"
                                                              (hide
                                                               -4
                                                               1)
                                                              (("1"
                                                                (grind)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (hide
                                                             2
                                                             4
                                                             -4)
                                                            (("2"
                                                              (grind)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (typepred enum_thread)
                                              (("2"
                                                (expand "bijective?")
                                                (("2"
                                                  (flatten)
                                                  (("2"
                                                    (hide -1)
                                                    (("2"
                                                      (expand
                                                       "surjective?")
                                                      (("2"
                                                        (inst - q!1)
                                                        (("2"
                                                          (skolem!)
                                                          (("2"
                                                            (name-replace
                                                             kq
                                                             x!1)
                                                            (("2"
                                                              (inst
                                                               +
                                                               kq)
                                                              (("2"
                                                                (split)
                                                                (("1"
                                                                  (skosimp)
                                                                  (("1"
                                                                    (use
                                                                     enabled_E1)
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (replaceh
                                                                         -4)
                                                                        (("1"
                                                                          (hide
                                                                           2)
                                                                          (("1"
                                                                            (expand
                                                                             "enabled1")
                                                                            (("1"
                                                                              (propax)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (skosimp)
                                                                  (("2"
                                                                    (expand
                                                                     "E1")
                                                                    (("2"
                                                                      (assert)
                                                                      (("2"
                                                                        (replaceh
                                                                         -5)
                                                                        (("2"
                                                                          (hide
                                                                           -3)
                                                                          (("2"
                                                                            (expand
                                                                             "forward1")
                                                                            (("2"
                                                                              (expand
                                                                               "step16")
                                                                              (("2"
                                                                                (expand
                                                                                 "step17")
                                                                                (("2"
                                                                                  (expand
                                                                                   "step18")
                                                                                  (("2"
                                                                                    (expand
                                                                                     "step19")
                                                                                    (("2"
                                                                                      (expand
                                                                                       "step12")
                                                                                      (("2"
                                                                                        (replaceh
                                                                                         -3)
                                                                                        (("2"
                                                                                          (expand
                                                                                           "goto")
                                                                                          (("2"
                                                                                            (propax)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2"
                        (case "between(q!1, 13, 15) = cup(at(q!1, 15), between(q!1, 13, 14))")
                        (("1" (replaceh -1)
                          (("1" (use cup_leto)
                            (("1" (assert)
                              (("1"
                                (hide 2)
                                (("1"
                                  (split)
                                  (("1"
                                    (hide -)
                                    (("1"
                                      (use subset_leto)
                                      (("1"
                                        (assert)
                                        (("1"
                                          (hide 2)
                                          (("1"
                                            (expand "<=")
                                            (("1"
                                              (expand "cap")
                                              (("1" (skosimp) nil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (lemma leto_up)
                                    (("2"
                                      (inst - D "1+D" _ _ _)
                                      (("2"
                                        (inst?)
                                        (("2" (assert) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (hide - 2)
                          (("2" (apply-extensionality :hide? t)
                            (("2" (iff)
                              (("2"
                                (expand "between")
                                (("2"
                                  (expand "cup")
                                  (("2"
                                    (expand "at")
                                    (("2" (ground) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((at const-decl "bool" tournamentUnity0 nil)
    (between const-decl "bool" tournamentUnity0 nil)
    (cup const-decl "bool" ownpred nil)
    (D const-decl "posnat" tournamentUnity0 nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (leto const-decl "bool" bdUnity nil)
    (specification type-eq-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (leveq_betw const-decl "bool" tournamentUnity0 nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (cap const-decl "bool" ownpred nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (unless const-decl "bool" bdUnity nil)
    (wp const-decl "bool" ownpred nil)
    (step const-decl "bool" tournamentUnity0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (rat_max application-judgement "{s: rat | s >= q AND s >= r}"
     real_defs nil)
    (int_max application-judgement "{k: int | i <= k AND j <= k}"
     real_defs nil)
    (nat_min application-judgement "{k: nat | k <= i AND k <= j}"
     real_defs nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (min const-decl "{p: real | p <= m AND p <= n}" real_defs nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (neg const-decl "bool" ownpred nil)
    (<= const-decl "bool" mucalculus nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (ass_doorway const-decl "bool" tournamentUnity0 nil)
    (cup_leto formula-decl nil bdUnity nil)
    (leto_up formula-decl nil bdUnity nil)
    (subset_leto formula-decl nil bdUnity nil)
    (leto_transitive formula-decl nil bdUnity nil)
    (enabled_E1 formula-decl nil tournamentUnity0 nil)
    (enabled1 const-decl "bool" tournamentUnity0 nil)
    (forward1 const-decl "bool" tournamentUnity0 nil)
    (surjective? const-decl "bool" functions nil)
    (enum_thread const-decl "(bijective?[below[N], (thread)])"
     tournamentSafe0 nil)
    (bijective? const-decl "bool" functions nil)
    (N const-decl "posnat" tournamentSafe0 nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (cobar const-decl "bool" bdUnity nil)
    (co const-decl "bool" bdUnity nil)
    (ensures const-decl "bool" bdUnity nil)
    (ensures_leto formula-decl nil bdUnity nil)
    (PSP_leto formula-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil) (< const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil))
   nil)
  (ass_doorway_extended-3 nil 3670585200
   ("" (skosimp)
    (("" (lemma PSP_leto)
      ((""
        (case "leto(E1)(1 + D, cup(at12body(q!1), between(q!1, 13, 15)), at(q!1, 15))")
        (("1" (inst?)
          (("1" (name-replace pp0 "leveq_betw(q!1, 12, 15, k!1)")
            (("1" (name-replace pp1 "at15lev(q!1, k!1)")
              (("1" (inst - pp0 pp1)
                (("1" (assert)
                  (("1" (split)
                    (("1" (hide -2 -3)
                      (("1"
                        (case "cap(cup(at12body(q!1), between(q!1, 13, 15)), pp0)=pp0")
                        (("1" (replaceh -1)
                          (("1"
                            (case " cup(cap(at(q!1, 15), pp0), pp1) = pp1")
                            (("1" (replaceh -1) nil nil)
                             ("2" (hide - 2)
                              (("2"
                                (apply-extensionality :hide? t)
                                (("2"
                                  (iff)
                                  (("2"
                                    (expand "cup")
                                    (("2"
                                      (prop)
                                      (("2"
                                        (expand "pp1")
                                        (("2"
                                          (expand "pp0")
                                          (("2"
                                            (expand "cap")
                                            (("2"
                                              (expand "leveq_betw")
                                              (("2"
                                                (flatten)
                                                (("2"
                                                  (expand "at15lev")
                                                  (("2"
                                                    (expand "at")
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (hide - 2)
                          (("2" (apply-extensionality :hide? t)
                            (("2" (iff)
                              (("2"
                                (prop)
                                (("1"
                                  (expand "pp0")
                                  (("1"
                                    (expand "leveq_betw")
                                    (("1"
                                      (expand "cap")
                                      (("1"
                                        (expand "between")
                                        (("1"
                                          (flatten)
                                          (("1" (assert) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (expand "pp0")
                                  (("2"
                                    (expand "cap")
                                    (("2"
                                      (assert)
                                      (("2"
                                        (expand "leveq_betw")
                                        (("2"
                                          (expand "between")
                                          (("2"
                                            (flatten)
                                            (("2"
                                              (assert)
                                              (("2"
                                                (expand "cup")
                                                (("2"
                                                  (expand "at12body")
                                                  (("2"
                                                    (flatten)
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide - 2)
                      (("2" (expand "pp0")
                        (("2" (expand "pp1")
                          (("2" (expand "unless")
                            (("2" (expand "<=")
                              (("2"
                                (expand "wp")
                                (("2"
                                  (expand "cup")
                                  (("2"
                                    (expand "cap")
                                    (("2"
                                      (expand "neg")
                                      (("2"
                                        (expand "leveq_betw")
                                        (("2"
                                          (skosimp*)
                                          (("2"
                                            (expand "at15lev")
                                            (("2"
                                              (expand "E1")
                                              (("2"
                                                (expand "step")
                                                (("2"
                                                  (split -)
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil)
                                                   ("2"
                                                    (skolem!)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (case
                                                         "q!1=p!1")
                                                        (("1"
                                                          (replaceh -1)
                                                          (("1"
                                                            (hide 3 -5)
                                                            (("1"
                                                              (grind)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (case
                                                           "y!1`pc(q!1) = s!1`pc(q!1) AND y!1`level(q!1) = s!1`level(q!1)")
                                                          (("1"
                                                            (flatten)
                                                            (("1"
                                                              (replaceh
                                                               -1)
                                                              (("1"
                                                                (replaceh
                                                                 -1)
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (hide-all-but
                                                             (-1 1 2))
                                                            (("2"
                                                              (split)
                                                              (("1"
                                                                (grind)
                                                                nil
                                                                nil)
                                                               ("2"
                                                                (grind)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (hide -1 2)
          (("2" (expand "ass_doorway")
            (("2" (inst?)
              (("2" (use cup_leto)
                (("2" (assert)
                  (("2" (hide 2)
                    (("2" (split)
                      (("1" (lemma leto_transitive)
                        (("1" (inst - 1 D _ _ _ E1)
                          (("1" (inst?)
                            (("1" (assert)
                              (("1"
                                (inst?)
                                (("1"
                                  (assert)
                                  (("1"
                                    (hide - 2)
                                    (("1"
                                      (s-ensures)
                                      (("1"
                                        (expand "at12body")
                                        (("1"
                                          (expand "between")
                                          (("1"
                                            (split)
                                            (("1"
                                              (skosimp*)
                                              (("1"
                                                (expand "E1")
                                                (("1"
                                                  (expand "step")
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (split -)
                                                      (("1"
                                                        (assert)
                                                        nil
                                                        nil)
                                                       ("2"
                                                        (skolem!)
                                                        (("2"
                                                          (case
                                                           "q!1=p!1")
                                                          (("1"
                                                            (replaceh
                                                             -1)
                                                            (("1"
                                                              (hide
                                                               -4
                                                               1)
                                                              (("1"
                                                                (grind)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (hide
                                                             2
                                                             4
                                                             -4)
                                                            (("2"
                                                              (grind)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (typepred enum_thread)
                                              (("2"
                                                (expand "bijective?")
                                                (("2"
                                                  (flatten)
                                                  (("2"
                                                    (hide -1)
                                                    (("2"
                                                      (expand
                                                       "surjective?")
                                                      (("2"
                                                        (inst - q!1)
                                                        (("2"
                                                          (skolem!)
                                                          (("2"
                                                            (name-replace
                                                             kq
                                                             x!1)
                                                            (("2"
                                                              (inst
                                                               +
                                                               kq)
                                                              (("2"
                                                                (split)
                                                                (("1"
                                                                  (skosimp)
                                                                  (("1"
                                                                    (use
                                                                     enabled_E1)
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (replaceh
                                                                         -4)
                                                                        (("1"
                                                                          (hide
                                                                           2)
                                                                          (("1"
                                                                            (expand
                                                                             "enabled1")
                                                                            (("1"
                                                                              (propax)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil)
                                                                 ("2"
                                                                  (skosimp)
                                                                  (("2"
                                                                    (expand
                                                                     "E1")
                                                                    (("2"
                                                                      (assert)
                                                                      (("2"
                                                                        (replaceh
                                                                         -5)
                                                                        (("2"
                                                                          (hide
                                                                           -3)
                                                                          (("2"
                                                                            (expand
                                                                             "forward1")
                                                                            (("2"
                                                                              (expand
                                                                               "step16")
                                                                              (("2"
                                                                                (expand
                                                                                 "step17")
                                                                                (("2"
                                                                                  (expand
                                                                                   "step18")
                                                                                  (("2"
                                                                                    (expand
                                                                                     "step19")
                                                                                    (("2"
                                                                                      (expand
                                                                                       "step12")
                                                                                      (("2"
                                                                                        (replaceh
                                                                                         -3)
                                                                                        (("2"
                                                                                          (expand
                                                                                           "goto")
                                                                                          (("2"
                                                                                            (propax)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2"
                        (case "between(q!1, 13, 15) = cup(at(q!1, 15), between(q!1, 13, 14))")
                        (("1" (replaceh -1)
                          (("1" (use cup_leto)
                            (("1" (assert)
                              (("1"
                                (hide 2)
                                (("1"
                                  (split)
                                  (("1"
                                    (hide -)
                                    (("1"
                                      (use subset_leto)
                                      (("1"
                                        (assert)
                                        (("1"
                                          (hide 2)
                                          (("1"
                                            (expand "<=")
                                            (("1"
                                              (expand "cap")
                                              (("1" (skosimp) nil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (lemma leto_up)
                                    (("2"
                                      (inst - D "1+D" _ _ _)
                                      (("2"
                                        (inst?)
                                        (("2" (assert) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (hide - 2)
                          (("2" (apply-extensionality :hide? t)
                            (("2" (iff)
                              (("2"
                                (expand "between")
                                (("2"
                                  (expand "cup")
                                  (("2"
                                    (expand "at")
                                    (("2" (ground) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (PSP_leto formula-decl nil bdUnity nil)
    (ensures_leto formula-decl nil bdUnity nil)
    (ensures const-decl "bool" bdUnity nil)
    (co const-decl "bool" bdUnity nil)
    (cobar const-decl "bool" bdUnity nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (N const-decl "posnat" tournamentSafe0 nil)
    (bijective? const-decl "bool" functions nil)
    (enum_thread const-decl "(bijective?[below[N], (thread)])"
     tournamentSafe0 nil)
    (surjective? const-decl "bool" functions nil)
    (forward1 const-decl "bool" tournamentUnity0 nil)
    (enabled1 const-decl "bool" tournamentUnity0 nil)
    (enabled_E1 formula-decl nil tournamentUnity0 nil)
    (leto_transitive formula-decl nil bdUnity nil)
    (subset_leto formula-decl nil bdUnity nil)
    (leto_up formula-decl nil bdUnity nil)
    (cup_leto formula-decl nil bdUnity nil)
    (ass_doorway const-decl "bool" tournamentUnity0 nil)
    (<= const-decl "bool" mucalculus nil)
    (neg const-decl "bool" ownpred nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (empty? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (min const-decl "{p: real | p <= m AND p <= n}" real_defs nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nat_min application-judgement "{k: nat | k <= i AND k <= j}"
     real_defs nil)
    (int_max application-judgement "{k: int | i <= k AND j <= k}"
     real_defs nil)
    (rat_max application-judgement "{s: rat | s >= q AND s >= r}"
     real_defs nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (step const-decl "bool" tournamentUnity0 nil)
    (wp const-decl "bool" ownpred nil)
    (unless const-decl "bool" bdUnity nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (cap const-decl "bool" ownpred nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (leveq_betw const-decl "bool" tournamentUnity0 nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (pred type-eq-decl nil defined_types nil)
    (specification type-eq-decl nil bdUnity nil)
    (leto const-decl "bool" bdUnity nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (D const-decl "posnat" tournamentUnity0 nil)
    (cup const-decl "bool" ownpred nil)
    (between const-decl "bool" tournamentUnity0 nil)
    (at const-decl "bool" tournamentUnity0 nil))
   nil)
  (ass_doorway_extended-2 nil 3670565809
   ("" (skosimp)
    (("" (lemma PSP_leto)
      (("" (case "leto(E1)(1 + D, between(q!1, 12, 15), at(q!1, 15))")
        (("1" (inst?)
          (("1" (name-replace pp0 "leveq_betw(q!1, 12, 15, k!1)")
            (("1" (name-replace pp1 "at15lev(q!1, k!1)")
              (("1" (inst - pp0 pp1)
                (("1" (assert)
                  (("1" (split)
                    (("1" (hide -2 -3)
                      (("1" (case "cap(between(q!1, 12, 15), pp0)=pp0")
                        (("1" (replaceh -1)
                          (("1"
                            (case " cup(cap(at(q!1, 15), pp0), pp1) = pp1")
                            (("1" (replaceh -1) nil nil)
                             ("2" (hide - 2)
                              (("2"
                                (apply-extensionality :hide? t)
                                (("2"
                                  (iff)
                                  (("2"
                                    (expand "cup")
                                    (("2"
                                      (prop)
                                      (("2"
                                        (expand "pp1")
                                        (("2"
                                          (expand "pp0")
                                          (("2"
                                            (expand "cap")
                                            (("2"
                                              (expand "leveq_betw")
                                              (("2"
                                                (flatten)
                                                (("2"
                                                  (expand "at15lev")
                                                  (("2"
                                                    (expand "at")
                                                    (("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (hide - 2)
                          (("2" (apply-extensionality :hide? t)
                            (("2" (iff)
                              (("2"
                                (prop)
                                (("1"
                                  (expand "pp0")
                                  (("1"
                                    (expand "leveq_betw")
                                    (("1"
                                      (expand "cap")
                                      (("1"
                                        (expand "between")
                                        (("1"
                                          (flatten)
                                          (("1" (assert) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (expand "pp0")
                                  (("2"
                                    (expand "cap")
                                    (("2"
                                      (assert)
                                      (("2"
                                        (expand "leveq_betw")
                                        (("2"
                                          (expand "between")
                                          (("2"
                                            (flatten)
                                            (("2" (assert) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide - 2)
                      (("2" (expand "pp0")
                        (("2" (expand "pp1")
                          (("2" (expand "unless")
                            (("2" (expand "<=")
                              (("2"
                                (expand "wp")
                                (("2"
                                  (expand "cup")
                                  (("2"
                                    (expand "cap")
                                    (("2"
                                      (expand "neg")
                                      (("2"
                                        (expand "leveq_betw")
                                        (("2"
                                          (skosimp*)
                                          (("2"
                                            (expand "at15lev")
                                            (("2"
                                              (expand "E1")
                                              (("2"
                                                (expand "step")
                                                (("2"
                                                  (split -)
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil)
                                                   ("2"
                                                    (skolem!)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (case
                                                         "q!1=p!1")
                                                        (("1"
                                                          (replaceh -1)
                                                          (("1"
                                                            (hide 3 -5)
                                                            (("1"
                                                              (grind)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (case
                                                           "y!1`pc(q!1) = s!1`pc(q!1) AND y!1`level(q!1) = s!1`level(q!1)")
                                                          (("1"
                                                            (flatten)
                                                            (("1"
                                                              (replaceh
                                                               -1)
                                                              (("1"
                                                                (replaceh
                                                                 -1)
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (hide-all-but
                                                             (-1 1 2))
                                                            (("2"
                                                              (split)
                                                              (("1"
                                                                (grind)
                                                                nil
                                                                nil)
                                                               ("2"
                                                                (grind)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (hide -1 2)
          (("2" (expand "ass_doorway")
            (("2" (inst?)
              (("2"
                (case "between(q!1, 12, 15) = cup(at(q!1, 15), between(q!1, 12, 14))")
                (("1" (replaceh -1)
                  (("1" (use cup_leto)
                    (("1" (assert)
                      (("1" (split)
                        (("1" (hide - 2)
                          (("1" (use subset_leto)
                            (("1" (assert)
                              (("1"
                                (hide 2)
                                (("1"
                                  (expand "<=")
                                  (("1"
                                    (expand "cap")
                                    (("1" (skosimp) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (hide 2)
                          (("2"
                            (case "between(q!1, 12, 14) = cup(at(q!1, 12), between(q!1, 13, 14))")
                            (("1" (replaceh -1)
                              (("1"
                                (use cup_leto)
                                (("1"
                                  (assert)
                                  (("1"
                                    (hide 2)
                                    (("1"
                                      (split)
                                      (("1" (postpone) nil nil)
                                       ("2" (postpone) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (hide - 2)
                              (("2"
                                (apply-extensionality :hide? t)
                                (("2"
                                  (iff)
                                  (("2"
                                    (expand "cup")
                                    (("2"
                                      (expand "between")
                                      (("2"
                                        (expand "at")
                                        (("2" (ground) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (hide - 2)
                  (("2" (apply-extensionality :hide? t)
                    (("2" (iff)
                      (("2" (expand "cup")
                        (("2" (expand "between")
                          (("2" (expand "at") (("2" (grind) nil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   nil nil)
  (ass_doorway_extended-1 nil 3670415248
   ("" (skosimp)
    (("" (lemma PSP_leto)
      (("" (case "leto(E1)(D, between(q!1, 12, 15), at(q!1, 15))")
        (("1" (inst?)
          (("1" (name-replace pp0 "leveq_betw(q!1, 12, 15, k!1)")
            (("1" (name-replace pp1 "at15lev(q!1, k!1)")
              (("1" (inst - pp0 pp1)
                (("1" (assert)
                  (("1" (split)
                    (("1" (hide -2 -3)
                      (("1" (case "cap(between(q!1, 12, 15), pp0)=pp0")
                        (("1" (replaceh -1)
                          (("1"
                            (case " cup(cap(at(q!1, 15), pp0), pp1) = pp1")
                            (("1" (replaceh -1)
                              (("1" (postpone) nil nil)) nil)
                             ("2" (postpone) nil nil))
                            nil))
                          nil)
                         ("2" (hide - 2)
                          (("2" (apply-extensionality :hide? t)
                            (("2" (iff)
                              (("2"
                                (prop)
                                (("1"
                                  (expand "pp0")
                                  (("1"
                                    (expand "leveq_betw")
                                    (("1"
                                      (expand "cap")
                                      (("1"
                                        (expand "between")
                                        (("1"
                                          (flatten)
                                          (("1" (assert) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (expand "pp0")
                                  (("2"
                                    (expand "cap")
                                    (("2"
                                      (assert)
                                      (("2"
                                        (expand "leveq_betw")
                                        (("2"
                                          (expand "between")
                                          (("2"
                                            (flatten)
                                            (("2" (assert) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide - 2)
                      (("2" (expand "pp0")
                        (("2" (expand "pp1")
                          (("2" (expand "unless")
                            (("2" (expand "<=")
                              (("2"
                                (expand "wp")
                                (("2"
                                  (expand "cup")
                                  (("2"
                                    (expand "cap")
                                    (("2"
                                      (expand "neg")
                                      (("2"
                                        (expand "leveq_betw")
                                        (("2"
                                          (skosimp*)
                                          (("2"
                                            (expand "at15lev")
                                            (("2"
                                              (expand "E1")
                                              (("2"
                                                (expand "step")
                                                (("2"
                                                  (split -)
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil)
                                                   ("2"
                                                    (skolem!)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (case
                                                         "q!1=p!1")
                                                        (("1"
                                                          (replaceh -1)
                                                          (("1"
                                                            (hide 3 -5)
                                                            (("1"
                                                              (grind)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (case
                                                           "y!1`pc(q!1) = s!1`pc(q!1) AND y!1`level(q!1) = s!1`level(q!1)")
                                                          (("1"
                                                            (flatten)
                                                            (("1"
                                                              (replaceh
                                                               -1)
                                                              (("1"
                                                                (replaceh
                                                                 -1)
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (hide-all-but
                                                             (-1 1 2))
                                                            (("2"
                                                              (split)
                                                              (("1"
                                                                (grind)
                                                                nil
                                                                nil)
                                                               ("2"
                                                                (grind)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (postpone) nil nil))
        nil))
      nil))
    nil)
   nil shostak))
 (level_step 0
  (level_step-8 nil 3678788762
   ("" (skosimp)
    (("" (case "k!1 < depth(q!1)")
      (("1" (use ass_doorway_extended)
        (("1" (assert)
          (("1" (use atlev15_to12 (m m!1))
            (("1" (assert)
              (("1" (lemma leto_transitive)
                (("1" (name-replace D1 "1 +D")
                  (("1" (name-replace mid "degW(m!1) + W")
                    (("1"
                      (name-replace pp0 "leveq_betw(q!1, 12, 15, k!1)")
                      (("1" (name-replace pp1 "atlev(q!1, 15, k!1)")
                        (("1"
                          (name-replace pp2 "atlev(q!1, 12, k!1 - 1)")
                          (("1" (case "mid >= 0")
                            (("1" (inst-cp - D1 mid pp0 pp1 pp2 E1)
                              (("1"
                                (assert)
                                (("1"
                                  (hide -3 -4)
                                  (("1"
                                    (inst
                                     -
                                     "D1 + mid"
                                     m!1
                                     pp0
                                     pp2
                                     "atlev(q!1, 17, k!1)"
                                     E1)
                                    (("1"
                                      (assert)
                                      (("1"
                                        (split)
                                        (("1"
                                          (case
                                           "D1 + m!1 + mid = D1 + W * degree + degree * m!1")
                                          (("1" (assert) nil nil)
                                           ("2"
                                            (hide - 2)
                                            (("2"
                                              (expand "mid")
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (expand "degW")
                                                  (("2"
                                                    (propax)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (hide -1 2)
                                          (("2"
                                            (expand "levleq_to_out")
                                            (("2"
                                              (lemma sub_leto)
                                              (("2"
                                                (inst
                                                 -
                                                 m!1
                                                 pp2
                                                 "levleq(q!1, k!1)"
                                                 _
                                                 _)
                                                (("2"
                                                  (inst?)
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (split)
                                                      (("1"
                                                        (hide - 2)
                                                        (("1"
                                                          (expand "<=")
                                                          (("1"
                                                            (expand
                                                             "pp2")
                                                            (("1"
                                                              (expand
                                                               "cap")
                                                              (("1"
                                                                (expand
                                                                 "levleq")
                                                                (("1"
                                                                  (expand
                                                                   "atlev")
                                                                  (("1"
                                                                    (skosimp)
                                                                    (("1"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (inst?)
                                                        (("2"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (hide - 2)
                              (("2"
                                (expand "mid")
                                (("2"
                                  (lemma pos_times_le)
                                  (("2"
                                    (inst - "degree-1" m!1)
                                    (("2" (assert) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (hide -)
        (("2" (use subset_leto)
          (("2" (assert)
            (("2" (expand "<=")
              (("2" (hide 3)
                (("2" (expand "cap")
                  (("2" (expand "leveq_betw")
                    (("2" (skosimp)
                      (("2" (case "iq0(q!1, s!1)")
                        (("1" (expand "iq0") (("1" (assert) nil nil))
                          nil)
                         ("2" (expand "E1")
                          (("2" (expand "globinv")
                            (("2" (expand "iqall")
                              (("2"
                                (flatten)
                                (("2"
                                  (inst?)
                                  (("2" (assert) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (depth const-decl "nat" ctrees nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (< const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (posint nonempty-type-eq-decl nil integers nil)
    (D const-decl "posnat" tournamentUnity0 nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (leveq_betw const-decl "bool" tournamentUnity0 nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (pos_times_le formula-decl nil real_props nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (sub_leto formula-decl nil bdUnity nil)
    (<= const-decl "bool" mucalculus nil)
    (cap const-decl "bool" ownpred nil)
    (pp2 skolem-const-decl "[state[degree, node] -> bool]"
     tournamentUnity0 nil)
    (levleq const-decl "bool" tournamentUnity0 nil)
    (levleq_to_out const-decl "bool" tournamentUnity0 nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (mid skolem-const-decl "posint" tournamentUnity0 nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (nzint_times_nzint_is_nzint application-judgement "nzint" integers
     nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (degW const-decl "nat" tournamentUnity0 nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (digit type-eq-decl nil ctrees nil)
    (leto_transitive formula-decl nil bdUnity nil)
    (atlev15_to12 formula-decl nil tournamentUnity0 nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (ass_doorway_extended formula-decl nil tournamentUnity0 nil)
    (subset_leto formula-decl nil bdUnity nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (iq0 const-decl "bool" tournamentSafe0 nil))
   nil)
  (level_step-7 nil 3671447383
   ("" (skosimp)
    (("" (case "k!1 < q!1`length")
      (("1" (use ass_doorway_extended)
        (("1" (assert)
          (("1" (use atlev15_to12 (m m!1))
            (("1" (assert)
              (("1" (lemma leto_transitive)
                (("1" (name-replace D1 "1 +D")
                  (("1" (name-replace mid "degW(m!1) + W")
                    (("1"
                      (name-replace pp0 "leveq_betw(q!1, 12, 15, k!1)")
                      (("1" (name-replace pp1 "atlev(q!1, 15, k!1)")
                        (("1"
                          (name-replace pp2 "atlev(q!1, 12, k!1 - 1)")
                          (("1" (case "mid >= 0")
                            (("1" (inst-cp - D1 mid pp0 pp1 pp2 E1)
                              (("1"
                                (assert)
                                (("1"
                                  (hide -3 -4)
                                  (("1"
                                    (inst
                                     -
                                     "D1 + mid"
                                     m!1
                                     pp0
                                     pp2
                                     "atlev(q!1, 17, k!1)"
                                     E1)
                                    (("1"
                                      (assert)
                                      (("1"
                                        (split)
                                        (("1"
                                          (case
                                           "D1 + m!1 + mid = D1 + W * degree + degree * m!1")
                                          (("1" (assert) nil nil)
                                           ("2"
                                            (hide - 2)
                                            (("2"
                                              (expand "mid")
                                              (("2"
                                                (assert)
                                                (("2"
                                                  (expand "degW")
                                                  (("2"
                                                    (propax)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (hide -1 2)
                                          (("2"
                                            (expand "levleq_to_out")
                                            (("2"
                                              (lemma sub_leto)
                                              (("2"
                                                (inst
                                                 -
                                                 m!1
                                                 pp2
                                                 "levleq(q!1, k!1)"
                                                 _
                                                 _)
                                                (("2"
                                                  (inst?)
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (split)
                                                      (("1"
                                                        (hide - 2)
                                                        (("1"
                                                          (expand "<=")
                                                          (("1"
                                                            (expand
                                                             "pp2")
                                                            (("1"
                                                              (expand
                                                               "cap")
                                                              (("1"
                                                                (expand
                                                                 "levleq")
                                                                (("1"
                                                                  (expand
                                                                   "atlev")
                                                                  (("1"
                                                                    (skosimp)
                                                                    (("1"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (inst?)
                                                        (("2"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (hide - 2)
                              (("2"
                                (expand "mid")
                                (("2"
                                  (lemma pos_times_le)
                                  (("2"
                                    (inst - "degree-1" m!1)
                                    (("2" (assert) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (hide -)
        (("2" (use subset_leto)
          (("2" (assert)
            (("2" (expand "<=")
              (("2" (hide 3)
                (("2" (expand "cap")
                  (("2" (expand "leveq_betw")
                    (("2" (skosimp)
                      (("2" (case "iq0(q!1, s!1)")
                        (("1" (expand "iq0") (("1" (assert) nil nil))
                          nil)
                         ("2" (expand "E1")
                          (("2" (expand "globinv")
                            (("2" (expand "iqall")
                              (("2"
                                (flatten)
                                (("2"
                                  (inst?)
                                  (("2" (assert) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (< const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (posint nonempty-type-eq-decl nil integers nil)
    (D const-decl "posnat" tournamentUnity0 nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (leveq_betw const-decl "bool" tournamentUnity0 nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (pos_times_le formula-decl nil real_props nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (sub_leto formula-decl nil bdUnity nil)
    (<= const-decl "bool" mucalculus nil)
    (cap const-decl "bool" ownpred nil)
    (levleq const-decl "bool" tournamentUnity0 nil)
    (levleq_to_out const-decl "bool" tournamentUnity0 nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (nzint_times_nzint_is_nzint application-judgement "nzint" integers
     nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (degW const-decl "nat" tournamentUnity0 nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (leto_transitive formula-decl nil bdUnity nil)
    (atlev15_to12 formula-decl nil tournamentUnity0 nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (ass_doorway_extended formula-decl nil tournamentUnity0 nil)
    (subset_leto formula-decl nil bdUnity nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (iq0 const-decl "bool" tournamentSafe0 nil))
   nil)
  (level_step-6 nil 3671433584
   ("" (skosimp)
    (("" (use ass_doorway_extended)
      (("" (assert)
        (("" (use atlev15_to12 (m m!1))
          (("" (assert)
            (("" (lemma leto_transitive)
              (("" (name-replace D1 "1 +D")
                (("" (name-replace mid "degW(m!1) + W")
                  ((""
                    (name-replace pp0 "leveq_betw(q!1, 12, 15, k!1)")
                    (("" (name-replace pp1 "atlev(q!1, 15, k!1)")
                      (("" (name-replace pp2 "atlev(q!1, 12, k!1 - 1)")
                        (("" (case "mid >= 0")
                          (("1" (inst-cp - D1 mid pp0 pp1 pp2 E1)
                            (("1" (assert)
                              (("1"
                                (hide -3 -4)
                                (("1"
                                  (inst
                                   -
                                   "D1 + mid"
                                   m!1
                                   pp0
                                   pp2
                                   "atlev(q!1, 17, k!1)"
                                   E1)
                                  (("1"
                                    (assert)
                                    (("1"
                                      (split)
                                      (("1"
                                        (case
                                         "D1 + m!1 + mid = D1 + W * degree + degree * m!1")
                                        (("1" (assert) nil nil)
                                         ("2"
                                          (hide - 2)
                                          (("2"
                                            (expand "mid")
                                            (("2"
                                              (assert)
                                              (("2"
                                                (expand "degW")
                                                (("2"
                                                  (propax)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (hide -1 2)
                                        (("2"
                                          (expand "levleq_to_out")
                                          (("2"
                                            (lemma sub_leto)
                                            (("2"
                                              (inst
                                               -
                                               m!1
                                               pp2
                                               "levleq(q!1, k!1)"
                                               _
                                               _)
                                              (("2"
                                                (inst?)
                                                (("2"
                                                  (assert)
                                                  (("2"
                                                    (split)
                                                    (("1"
                                                      (hide - 2)
                                                      (("1"
                                                        (expand "<=")
                                                        (("1"
                                                          (expand
                                                           "pp2")
                                                          (("1"
                                                            (expand
                                                             "cap")
                                                            (("1"
                                                              (expand
                                                               "levleq")
                                                              (("1"
                                                                (expand
                                                                 "atlev")
                                                                (("1"
                                                                  (skosimp)
                                                                  (("1"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (inst?)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (hide - 2)
                            (("2" (expand "mid")
                              (("2"
                                (lemma pos_times_le)
                                (("2"
                                  (inst - "degree-1" m!1)
                                  (("2" (assert) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (posint nonempty-type-eq-decl nil integers nil)
    (D const-decl "posnat" tournamentUnity0 nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (leveq_betw const-decl "bool" tournamentUnity0 nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (pos_times_le formula-decl nil real_props nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (sub_leto formula-decl nil bdUnity nil)
    (<= const-decl "bool" mucalculus nil)
    (cap const-decl "bool" ownpred nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (levleq const-decl "bool" tournamentUnity0 nil)
    (levleq_to_out const-decl "bool" tournamentUnity0 nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (nzint_times_nzint_is_nzint application-judgement "nzint" integers
     nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (degW const-decl "nat" tournamentUnity0 nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (leto_transitive formula-decl nil bdUnity nil)
    (atlev15_to12 formula-decl nil tournamentUnity0 nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (< const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (ass_doorway_extended formula-decl nil tournamentUnity0 nil))
   nil)
  (level_step-5 nil 3671348476
   ("" (skosimp)
    (("" (use ass_doorway_extended)
      (("" (assert)
        (("" (use atlev15_to12 (m m!1))
          (("" (assert)
            (("" (lemma leto_transitive)
              (("" (name-replace D1 "1 +D")
                (("" (name-replace mid "degW(m!1) + W")
                  ((""
                    (name-replace pp0 "leveq_betw(q!1, 12, 15, k!1)")
                    (("" (name-replace pp1 "atlev(q!1, 15, k!1)")
                      (("" (name-replace pp2 "atlev(q!1, 12, k!1 - 1)")
                        (("" (case "mid >= 0")
                          (("1" (inst-cp - D1 mid pp0 pp1 pp2 E1)
                            (("1" (assert)
                              (("1"
                                (hide -3 -4)
                                (("1"
                                  (inst
                                   -
                                   "D1 + mid"
                                   m!1
                                   pp0
                                   pp2
                                   "out(q!1)"
                                   E1)
                                  (("1"
                                    (assert)
                                    (("1"
                                      (split)
                                      (("1"
                                        (case
                                         "D1 + m!1 + mid = D1 + W * degree + degree * m!1")
                                        (("1" (assert) nil nil)
                                         ("2"
                                          (hide - 2)
                                          (("2"
                                            (expand "mid")
                                            (("2"
                                              (assert)
                                              (("2"
                                                (expand "degW")
                                                (("2"
                                                  (propax)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (hide -1 2)
                                        (("2"
                                          (expand "levleq_to_out")
                                          (("2"
                                            (lemma sub_leto)
                                            (("2"
                                              (inst
                                               -
                                               m!1
                                               pp2
                                               "levleq(q!1, k!1)"
                                               _
                                               _)
                                              (("2"
                                                (inst?)
                                                (("2"
                                                  (assert)
                                                  (("2"
                                                    (split)
                                                    (("1"
                                                      (hide - 2)
                                                      (("1"
                                                        (expand "<=")
                                                        (("1"
                                                          (expand
                                                           "pp2")
                                                          (("1"
                                                            (expand
                                                             "cap")
                                                            (("1"
                                                              (expand
                                                               "levleq")
                                                              (("1"
                                                                (expand
                                                                 "atlev")
                                                                (("1"
                                                                  (skosimp)
                                                                  (("1"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (inst?)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (hide - 2)
                            (("2" (expand "mid")
                              (("2"
                                (lemma pos_times_le)
                                (("2"
                                  (inst - "degree-1" m!1)
                                  (("2" (assert) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((ass_doorway_extended formula-decl nil tournamentUnity0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (atlev15_to12 formula-decl nil tournamentUnity0 nil)
    (leto_transitive formula-decl nil bdUnity nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (degW const-decl "nat" tournamentUnity0 nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (out const-decl "bool" tournamentUnity0 nil)
    (nzint_times_nzint_is_nzint application-judgement "nzint" integers
     nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (levleq_to_out const-decl "bool" tournamentUnity0 nil)
    (levleq const-decl "bool" tournamentUnity0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (cap const-decl "bool" ownpred nil)
    (<= const-decl "bool" mucalculus nil)
    (sub_leto formula-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (specification type-eq-decl nil bdUnity nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (pos_times_le formula-decl nil real_props nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (leveq_betw const-decl "bool" tournamentUnity0 nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (D const-decl "posnat" tournamentUnity0 nil)
    (posint nonempty-type-eq-decl nil integers nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil))
   nil)
  (level_step-4 nil 3671291668
   ("" (skosimp)
    (("" (use ass_doorway_extended)
      (("" (assert)
        (("" (use atlev15_to12 (m m!1))
          (("" (assert)
            (("" (lemma leto_transitive)
              (("" (name-replace D1 "1 +D")
                ((""
                  (name-replace mid "degree * W - m!1 + degree * m!1")
                  ((""
                    (name-replace pp0 "leveq_betw(q!1, 12, 15, k!1)")
                    (("" (name-replace pp1 "atlev(q!1, 15, k!1)")
                      (("" (name-replace pp2 "atlev(q!1, 12, k!1 - 1)")
                        (("" (case "mid >= 0")
                          (("1" (inst-cp - D1 mid pp0 pp1 pp2 E1)
                            (("1" (assert)
                              (("1"
                                (hide -3 -4)
                                (("1"
                                  (inst
                                   -
                                   "D1 + mid"
                                   m!1
                                   pp0
                                   pp2
                                   "out(q!1)"
                                   E1)
                                  (("1"
                                    (assert)
                                    (("1"
                                      (split)
                                      (("1"
                                        (case
                                         "D1 + m!1 + mid = D1 + W * degree + degree * m!1")
                                        (("1" (assert) nil nil)
                                         ("2"
                                          (hide - 2)
                                          (("2"
                                            (expand "mid")
                                            (("2" (assert) nil nil))
                                            nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (hide -1 2)
                                        (("2"
                                          (expand "levleq_to_out")
                                          (("2"
                                            (lemma sub_leto)
                                            (("2"
                                              (inst
                                               -
                                               m!1
                                               pp2
                                               "levleq(q!1, k!1)"
                                               _
                                               _)
                                              (("2"
                                                (inst?)
                                                (("2"
                                                  (assert)
                                                  (("2"
                                                    (split)
                                                    (("1"
                                                      (hide - 2)
                                                      (("1"
                                                        (expand "<=")
                                                        (("1"
                                                          (expand
                                                           "pp2")
                                                          (("1"
                                                            (expand
                                                             "cap")
                                                            (("1"
                                                              (expand
                                                               "levleq")
                                                              (("1"
                                                                (expand
                                                                 "atlev")
                                                                (("1"
                                                                  (skosimp)
                                                                  (("1"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (inst?)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (hide - 2)
                            (("2" (expand "mid")
                              (("2"
                                (lemma pos_times_le)
                                (("2"
                                  (inst - "degree-1" m!1)
                                  (("2" (assert) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (posint nonempty-type-eq-decl nil integers nil)
    (D const-decl "posnat" tournamentUnity0 nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (leveq_betw const-decl "bool" tournamentUnity0 nil)
    (pos_times_le formula-decl nil real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (sub_leto formula-decl nil bdUnity nil)
    (<= const-decl "bool" mucalculus nil)
    (cap const-decl "bool" ownpred nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (levleq const-decl "bool" tournamentUnity0 nil)
    (levleq_to_out const-decl "bool" tournamentUnity0 nil)
    (out const-decl "bool" tournamentUnity0 nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (leto_transitive formula-decl nil bdUnity nil)
    (atlev15_to12 formula-decl nil tournamentUnity0 nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (< const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (ass_doorway_extended formula-decl nil tournamentUnity0 nil))
   nil)
  (level_step-3 nil 3671291356
   ("" (skosimp)
    (("" (use ass_doorway_extended)
      (("" (assert)
        (("" (use atlev15_to12 (m m!1))
          (("" (assert)
            (("" (lemma leto_transitive)
              (("" (name-replace D1 "1 +D")
                ((""
                  (name-replace mid "degree * W - m!1 + degree * m!1")
                  ((""
                    (name-replace pp0 "leveq_betw(q!1, 12, 15, k!1)")
                    (("" (name-replace pp1 "atlev(q!1, 15, k!1)")
                      (("" (name-replace pp2 "atlev(q!1, 12, k!1 - 1)")
                        (("" (inst-cp - D1 mid pp0 pp1 pp2 E1)
                          (("" (assert)
                            (("" (hide -3 -4)
                              ((""
                                (inst
                                 -
                                 "D1 + mid"
                                 m!1
                                 pp0
                                 pp2
                                 "out(q!1)"
                                 E1)
                                ((""
                                  (assert)
                                  ((""
                                    (split)
                                    (("1"
                                      (case
                                       "D1 + m!1 + mid = D1 + W * degree + degree * m!1 + m!1")
                                      (("1" (assert) nil)
                                       ("2"
                                        (hide - 2)
                                        (("2"
                                          (expand "mid")
                                          (("2" (propax) nil)))))))
                                     ("2"
                                      (hide -1 2)
                                      (("2"
                                        (expand "levleq_to_out")
                                        (("2"
                                          (lemma sub_leto)
                                          (("2"
                                            (inst -2 q!1)
                                            (("2"
                                              (inst
                                               -
                                               m!1
                                               pp2
                                               "levleq(q!1, k!1)"
                                               _
                                               _)
                                              (("2"
                                                (inst?)
                                                (("2"
                                                  (assert)
                                                  (("2"
                                                    (hide - 2)
                                                    (("2"
                                                      (expand "<=")
                                                      (("2"
                                                        (expand "pp2")
                                                        (("2"
                                                          (expand
                                                           "cap")
                                                          (("2"
                                                            (expand
                                                             "atlev")
                                                            (("2"
                                                              (expand
                                                               "levleq")
                                                              (("2"
                                                                (skosimp)
                                                                (("2"
                                                                  (assert)
                                                                  nil))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
    nil)
   nil nil)
  (level_step-2 nil 3670734833
   ("" (skosimp)
    (("" (use ass_doorway_extended)
      (("" (assert)
        (("" (use atlev15_to12 (m m!1))
          (("" (assert)
            (("" (lemma leto_transitive)
              (("" (name-replace D1 "1 +D")
                (("" (name-replace mid "W * degree + degree * m!1")
                  ((""
                    (name-replace pp0 "leveq_betw(q!1, 12, 15, k!1)")
                    (("" (name-replace pp1 "atlev(q!1, 15, k!1)")
                      (("" (name-replace pp2 "atlev(q!1, 12, k!1 - 1)")
                        (("" (inst-cp - D1 mid pp0 pp1 pp2 E1)
                          (("" (assert)
                            (("" (hide -3 -4)
                              ((""
                                (inst
                                 -
                                 "D1 + mid"
                                 m!1
                                 pp0
                                 pp2
                                 "out(q!1)"
                                 E1)
                                ((""
                                  (assert)
                                  ((""
                                    (split)
                                    (("1"
                                      (case
                                       "D1 + m!1 + mid = D1 + W * degree + degree * m!1 + m!1")
                                      (("1" (assert) nil nil)
                                       ("2"
                                        (hide - 2)
                                        (("2"
                                          (expand "mid")
                                          (("2" (propax) nil nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (hide -1 2)
                                      (("2"
                                        (expand "levleq_to_out")
                                        (("2"
                                          (lemma sub_leto)
                                          (("2"
                                            (inst -2 q!1)
                                            (("2"
                                              (inst
                                               -
                                               m!1
                                               pp2
                                               "levleq(q!1, k!1)"
                                               _
                                               _)
                                              (("2"
                                                (inst?)
                                                (("2"
                                                  (assert)
                                                  (("2"
                                                    (hide - 2)
                                                    (("2"
                                                      (expand "<=")
                                                      (("2"
                                                        (expand "pp2")
                                                        (("2"
                                                          (expand
                                                           "cap")
                                                          (("2"
                                                            (expand
                                                             "atlev")
                                                            (("2"
                                                              (expand
                                                               "levleq")
                                                              (("2"
                                                                (skosimp)
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((ass_doorway_extended formula-decl nil tournamentUnity0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (atlev15_to12 formula-decl nil tournamentUnity0 nil)
    (leto_transitive formula-decl nil bdUnity nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (sub_leto formula-decl nil bdUnity nil)
    (levleq const-decl "bool" tournamentUnity0 nil)
    (<= const-decl "bool" mucalculus nil)
    (cap const-decl "bool" ownpred nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (levleq_to_out const-decl "bool" tournamentUnity0 nil)
    (out const-decl "bool" tournamentUnity0 nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (leveq_betw const-decl "bool" tournamentUnity0 nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (D const-decl "posnat" tournamentUnity0 nil)
    (posint nonempty-type-eq-decl nil integers nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil))
   nil)
  (level_step-1 nil 3670587082
   ("" (skosimp)
    (("" (use ass_doorway_extended)
      (("" (assert)
        (("" (use atlev15_to12 (m m!1))
          (("" (assert)
            (("" (lemma leto_transitive)
              (("" (name-replace D1 "1 +D")
                (("" (name-replace mid "W * degree + degree * m!1")
                  ((""
                    (name-replace pp0 "leveq_betw(q!1, 12, 15, k!1)")
                    (("" (name-replace pp1 "at15lev(q!1, k!1)")
                      (("" (name-replace pp2 "at12levmin(q!1, k!1)")
                        (("" (inst-cp - D1 mid pp0 pp1 pp2 E1)
                          (("" (assert)
                            (("" (hide -3 -4)
                              ((""
                                (inst
                                 -
                                 "D1 + mid"
                                 m!1
                                 pp0
                                 pp2
                                 "out(q!1)"
                                 E1)
                                ((""
                                  (assert)
                                  ((""
                                    (split)
                                    (("1"
                                      (case
                                       "D1 + m!1 + mid = D1 + W * degree + degree * m!1 + m!1")
                                      (("1" (assert) nil nil)
                                       ("2"
                                        (hide - 2)
                                        (("2"
                                          (expand "mid")
                                          (("2" (propax) nil nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (hide -1 2)
                                      (("2"
                                        (expand "levleq_to_out")
                                        (("2"
                                          (lemma sub_leto)
                                          (("2"
                                            (inst -2 q!1)
                                            (("2"
                                              (inst
                                               -
                                               m!1
                                               pp2
                                               "levleq(q!1, k!1)"
                                               _
                                               _)
                                              (("2"
                                                (inst?)
                                                (("2"
                                                  (assert)
                                                  (("2"
                                                    (hide - 2)
                                                    (("2"
                                                      (expand "<=")
                                                      (("2"
                                                        (expand "pp2")
                                                        (("2"
                                                          (expand
                                                           "cap")
                                                          (("2"
                                                            (expand
                                                             "at12levmin")
                                                            (("2"
                                                              (expand
                                                               "levleq")
                                                              (("2"
                                                                (skosimp)
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((ass_doorway_extended formula-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (atlev15_to12 formula-decl nil tournamentUnity0 nil)
    (leto_transitive formula-decl nil bdUnity nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (sub_leto formula-decl nil bdUnity nil)
    (levleq const-decl "bool" tournamentUnity0 nil)
    (<= const-decl "bool" mucalculus nil)
    (cap const-decl "bool" ownpred nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (levleq_to_out const-decl "bool" tournamentUnity0 nil)
    (out const-decl "bool" tournamentUnity0 nil)
    (leveq_betw const-decl "bool" tournamentUnity0 nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (D const-decl "posnat" tournamentUnity0 nil)
    (posint nonempty-type-eq-decl nil integers nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil))
   shostak))
 (level_step_1 0
  (level_step_1-2 nil 3671439136
   ("" (skosimp)
    ((""
      (case "leveq_betw(q!1, 12, 18, k!1) = cup(
        leveq_betw(q!1, 12, 15, k!1), leveq_betw(q!1, 16, 18, k!1))")
      (("1" (replaceh -1)
        (("1" (use cup_leto)
          (("1" (assert)
            (("1" (hide 2)
              (("1" (split)
                (("1" (use level_step (m m!1))
                  (("1" (assert)
                    (("1" (use from17to17)
                      (("1" (assert)
                        (("1" (lemma leto_transitive)
                          (("1"
                            (inst - "1 + D + W * degree + degree * m!1"
                             exi1 _ _ _ _)
                            (("1" (inst?)
                              (("1"
                                (inst?)
                                (("1" (assert) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (hide -1 -2 -3)
                  (("2" (lemma leto_up)
                    (("2"
                      (inst - exi1
                       "1 + D + W * degree + degree * m!1 + exi1" _ _
                       _)
                      (("2" (inst?)
                        (("2" (assert)
                          (("2" (hide 2)
                            (("2"
                              (case "leveq_betw(q!1, 16, 18, k!1) = cup(atlev(q!1, 16, k!1),
            cup(atlev(q!1, 17, k!1), atlev(q!1, 18, k!1)) )")
                              (("1"
                                (replaceh -1)
                                (("1"
                                  (use cup_leto)
                                  (("1"
                                    (assert)
                                    (("1"
                                      (hide 2)
                                      (("1"
                                        (split)
                                        (("1"
                                          (use subset_leto)
                                          (("1"
                                            (assert)
                                            (("1"
                                              (hide 2)
                                              (("1"
                                                (expand "<=")
                                                (("1"
                                                  (expand "cap")
                                                  (("1"
                                                    (expand "atlev")
                                                    (("1"
                                                      (skosimp)
                                                      (("1"
                                                        (case
                                                         "iq2(q!1, s!1)")
                                                        (("1"
                                                          (expand
                                                           "iq2")
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (expand "E1")
                                                          (("2"
                                                            (expand
                                                             "globinv")
                                                            (("2"
                                                              (expand
                                                               "iqall")
                                                              (("2"
                                                                (flatten)
                                                                (("2"
                                                                  (inst?)
                                                                  (("2"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (use cup_leto)
                                          (("2"
                                            (assert)
                                            (("2"
                                              (hide 2)
                                              (("2"
                                                (split)
                                                (("1"
                                                  (use from17to17)
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (use from18to17)
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (lemma leto_up)
                                                      (("2"
                                                        (inst
                                                         -
                                                         exi
                                                         exi1
                                                         _
                                                         _
                                                         _)
                                                        (("2"
                                                          (inst?)
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (expand
                                                               "exi1")
                                                              (("2"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (hide 2)
                                (("2"
                                  (apply-extensionality :hide? t)
                                  (("2"
                                    (iff)
                                    (("2"
                                      (expand "leveq_betw")
                                      (("2"
                                        (expand "cup")
                                        (("2"
                                          (expand "atlev")
                                          (("2" (ground) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (hide 2)
        (("2" (apply-extensionality :hide? t)
          (("2" (iff)
            (("2" (expand "cup")
              (("2" (expand "leveq_betw") (("2" (ground) nil nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((cup const-decl "bool" ownpred nil)
    (pred type-eq-decl nil defined_types nil)
    (leveq_betw const-decl "bool" tournamentUnity0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (digit type-eq-decl nil ctrees nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (cup_leto formula-decl nil bdUnity nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (exi1 const-decl "posnat" tournamentUnity0 nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (D const-decl "posnat" tournamentUnity0 nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (from18to17 formula-decl nil tournamentUnity0 nil)
    (exi const-decl "posnat" tournamentUnity0 nil)
    (subset_leto formula-decl nil bdUnity nil)
    (cap const-decl "bool" ownpred nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (iq2 const-decl "bool" tournamentSafe0 nil)
    (<= const-decl "bool" mucalculus nil)
    (leto_up formula-decl nil bdUnity nil)
    (level_step formula-decl nil tournamentUnity0 nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (from17to17 formula-decl nil tournamentUnity0 nil)
    (leto_transitive formula-decl nil bdUnity nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil))
   nil)
  (level_step_1-1 nil 3671438246
   ("" (skosimp)
    ((""
      (case "leveq_betw(q!1, 12, 18, k!1) = cup(
leveq_betw(q!1, 12, 15, k!1), leveq_betw(q!1, 16, 18, k!1))")
      (("1" (replaceh -1)
        (("1" (use cup_leto)
          (("1" (assert)
            (("1" (hide 2)
              (("1" (split)
                (("1" (use level_step (m m!1))
                  (("1" (assert)
                    (("1" (use from17to17)
                      (("1" (assert)
                        (("1" (lemma leto_transitive)
                          (("1"
                            (inst - "1 + D + W * degree + degree * m!1"
                             exi1 _ _ _ _)
                            (("1" (inst?)
                              (("1"
                                (inst?)
                                (("1" (assert) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (hide -1 -2 -3)
                  (("2" (lemma leto_up)
                    (("2"
                      (inst - exi1
                       "1 + D + W * degree + degree * m!1 + exi1" _ _
                       _)
                      (("2" (inst?)
                        (("2" (assert)
                          (("2" (hide 2)
                            (("2"
                              (case "leveq_betw(q!1, 16, 18, k!1) = cup(atlev(q!1, 16, k!1), 
cup(atlev(q!1, 16, k!1), atlev(q!1, 16, k!1)) )")
                              (("1"
                                (replaceh -1)
                                (("1"
                                  (use cup_leto)
                                  (("1"
                                    (assert)
                                    (("1"
                                      (hide 2)
                                      (("1"
                                        (split)
                                        (("1"
                                          (use subset_leto)
                                          (("1"
                                            (assert)
                                            (("1"
                                              (hide 2)
                                              (("1"
                                                (expand "<=")
                                                (("1"
                                                  (expand "cap")
                                                  (("1"
                                                    (expand "atlev")
                                                    (("1"
                                                      (skosimp)
                                                      (("1"
                                                        (case
                                                         "iq2(q!1, s!1)")
                                                        (("1"
                                                          (expand
                                                           "iq2")
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil)
                                                         ("2"
                                                          (expand "E1")
                                                          (("2"
                                                            (expand
                                                             "globinv")
                                                            (("2"
                                                              (expand
                                                               "iqall")
                                                              (("2"
                                                                (flatten)
                                                                (("2"
                                                                  (inst?)
                                                                  (("2"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (use cup_leto)
                                          (("2"
                                            (assert)
                                            (("2"
                                              (hide 2)
                                              (("2"
                                                (split)
                                                (("1"
                                                  (postpone)
                                                  nil
                                                  nil)
                                                 ("2"
                                                  (postpone)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2" (postpone) nil nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (postpone) nil nil))
      nil))
    nil)
   nil shostak))
 (level_step_2 0
  (level_step_2-3 nil 3671461901
   ("" (skosimp)
    (("" (use level_step)
      (("" (assert)
        (("" (lemma sub_leto)
          ((""
            (inst - "1 + D + W * degree + degree * m!1"
             "leveq_betw(q!1, 12, 18, k!1)"
             "cup(leveq_betw(q!1, 12, 15, k!1), atlev(q!1, 17, k!1))"
             "atlev(q!1, 17, k!1)" E1)
            (("" (assert)
              (("" (hide 2)
                (("" (split)
                  (("1" (hide -)
                    (("1" (expand "<=")
                      (("1" (expand "cap")
                        (("1" (expand "cup")
                          (("1" (expand "leveq_betw")
                            (("1" (expand "atlev")
                              (("1"
                                (skosimp)
                                (("1"
                                  (assert)
                                  (("1"
                                    (case
                                     "iq3(q!1, s!1) AND iq2(q!1, s!1)")
                                    (("1"
                                      (flatten)
                                      (("1"
                                        (expand "iq3")
                                        (("1"
                                          (expand "iq2")
                                          (("1" (assert) nil nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (expand "E1")
                                      (("2"
                                        (expand "globinv")
                                        (("2"
                                          (expand "iqall")
                                          (("2"
                                            (flatten)
                                            (("2"
                                              (inst?)
                                              (("2"
                                                (flatten)
                                                (("2"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (use cup_leto)
                    (("2" (assert)
                      (("2" (hide - 2)
                        (("2" (use subset_leto)
                          (("2" (assert)
                            (("2" (hide 2)
                              (("2"
                                (expand "<=")
                                (("2"
                                  (expand "cap")
                                  (("2" (skosimp) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((level_step formula-decl nil tournamentUnity0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (sub_leto formula-decl nil bdUnity nil)
    (digit type-eq-decl nil ctrees nil) (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (<= const-decl "bool" mucalculus nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (iq2 const-decl "bool" tournamentSafe0 nil)
    (iq3 const-decl "bool" tournamentSafe0 nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (cap const-decl "bool" ownpred nil)
    (subset_leto formula-decl nil bdUnity nil)
    (cup_leto formula-decl nil bdUnity nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (cup const-decl "bool" ownpred nil)
    (leveq_betw const-decl "bool" tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (D const-decl "posnat" tournamentUnity0 nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil))
   nil)
  (level_step_2-2 nil 3671461799
   ("" (skosimp)
    (("" (use level_step)
      (("" (assert)
        (("" (lemma sub_leto)
          ((""
            (inst - "1 + D + W * degree + degree * m!1"
             "leveq_betw(q!1, 12, 18, k!1)"
             "cup(leveq_betw(q!1, 12, 15, k!1), cup(atlev(q!1, 17, k!1)))"
             "atlev(q!1, 17, k!1)" E1)
            (("" (assert)
              (("" (hide 2)
                (("" (split)
                  (("1" (hide -)
                    (("1" (expand "<=")
                      (("1" (expand "cap")
                        (("1" (expand "cup")
                          (("1" (expand "leveq_betw")
                            (("1" (expand "atlev")
                              (("1"
                                (skosimp)
                                (("1"
                                  (assert)
                                  (("1"
                                    (case "iq3(q!1, s!1)")
                                    (("1"
                                      (expand "iq3")
                                      (("1" (propax) nil)))
                                     ("2"
                                      (expand "E1")
                                      (("2"
                                        (expand "globinv")
                                        (("2"
                                          (expand "iqall")
                                          (("2"
                                            (flatten)
                                            (("2"
                                              (inst?)
                                              (("2"
                                                (assert)
                                                nil)))))))))))))))))))))))))))))
                   ("2" (use cup_leto)
                    (("2" (assert)
                      (("2" (hide 2)
                        (("2" (hide -1)
                          (("2" (use cup_leto)
                            (("2" (assert)
                              (("2"
                                (hide 2)
                                (("2"
                                  (split)
                                  (("1" (postpone) nil)
                                   ("2"
                                    (postpone)
                                    nil))))))))))))))))))))))))))))))))
    nil)
   nil nil)
  (level_step_2-1 nil 3671461275
   ("" (skosimp)
    (("" (use level_step)
      (("" (assert)
        (("" (lemma sub_leto)
          ((""
            (inst - "1 + D + W * degree + degree * m!1"
             "leveq_betw(q!1, 12, 18, k!1)"
             "cup(leveq_betw(q!1, 12, 15, k!1), cup(atlev(q!1, 16, k!1), 
atlev(q!1, 17, k!1)))" "atlev(q!1, 17, k!1)" E1)
            (("" (assert)
              (("" (hide 2)
                (("" (split)
                  (("1" (hide -)
                    (("1" (expand "<=")
                      (("1" (expand "cap")
                        (("1" (expand "cup")
                          (("1" (expand "leveq_betw")
                            (("1" (expand "atlev")
                              (("1"
                                (skosimp)
                                (("1"
                                  (assert)
                                  (("1"
                                    (case "iq3(q!1, s!1)")
                                    (("1"
                                      (expand "iq3")
                                      (("1" (propax) nil nil))
                                      nil)
                                     ("2"
                                      (expand "E1")
                                      (("2"
                                        (expand "globinv")
                                        (("2"
                                          (expand "iqall")
                                          (("2"
                                            (flatten)
                                            (("2"
                                              (inst?)
                                              (("2" (assert) nil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (use cup_leto)
                    (("2" (assert)
                      (("2" (hide 2)
                        (("2" (hide -1)
                          (("2" (use cup_leto)
                            (("2" (assert)
                              (("2"
                                (hide 2)
                                (("2"
                                  (split)
                                  (("1" (postpone) nil nil)
                                   ("2" (postpone) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   nil shostak))
 (levleq_to_out_step 0
  (levleq_to_out_step-9 nil 3671448648
   ("" (skosimp)
    (("" (expand levleq_to_out +)
      (("" (skolem!)
        (("" (use level_step_1)
          (("" (ground)
            ((""
              (case "1 + D + W * degree + degree * m!1 + exi1 = degree * m!1 + addend")
              (("1" (replaceh -1)
                (("1" (lemma sub_leto)
                  (("1" (name-replace nn1 "degree * m!1 + addend")
                    (("1"
                      (inst - nn1 "levleq(q!1, 1 + k!1)" _
                       "atlev(q!1, 17, 1 + k!1)" E1)
                      (("1"
                        (inst -
                         "cup(leveq_betw(q!1, 12, 18, k!1), levleq(q!1, k!1)) ")
                        (("1" (assert)
                          (("1" (hide 2)
                            (("1" (split)
                              (("1"
                                (hide -)
                                (("1"
                                  (expand "<=")
                                  (("1"
                                    (expand "cup")
                                    (("1"
                                      (expand "cap")
                                      (("1"
                                        (expand "levleq")
                                        (("1"
                                          (expand "leveq_betw")
                                          (("1"
                                            (skosimp)
                                            (("1" (assert) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (use cup_leto)
                                (("2"
                                  (assert)
                                  (("2"
                                    (hide 2)
                                    (("2"
                                      (use cup_leto)
                                      (("2"
                                        (assert)
                                        (("2"
                                          (hide -1)
                                          (("2"
                                            (case "m!1 <= nn1")
                                            (("1"
                                              (expand "levleq_to_out")
                                              (("1"
                                                (inst?)
                                                (("1"
                                                  (hide -2)
                                                  (("1"
                                                    (split)
                                                    (("1"
                                                      (use from17to17)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (lemma
                                                           leto_transitive)
                                                          (("1"
                                                            (inst
                                                             -
                                                             m!1
                                                             exi1
                                                             _
                                                             _
                                                             _
                                                             _)
                                                            (("1"
                                                              (inst?)
                                                              (("1"
                                                                (assert)
                                                                (("1"
                                                                  (inst?)
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (hide
                                                                       -2
                                                                       -3)
                                                                      (("1"
                                                                        (lemma
                                                                         leto_up)
                                                                        (("1"
                                                                          (inst
                                                                           -
                                                                           "exi1 + m!1"
                                                                           nn1
                                                                           _
                                                                           _
                                                                           _)
                                                                          (("1"
                                                                            (inst?)
                                                                            (("1"
                                                                              (assert)
                                                                              (("1"
                                                                                (expand
                                                                                 "nn1")
                                                                                (("1"
                                                                                  (expand
                                                                                   "addend")
                                                                                  (("1"
                                                                                    (hide
                                                                                     -
                                                                                     2)
                                                                                    (("1"
                                                                                      (lemma
                                                                                       pos_times_le)
                                                                                      (("1"
                                                                                        (inst
                                                                                         -
                                                                                         "degree -1 "
                                                                                         m!1)
                                                                                        (("1"
                                                                                          (assert)
                                                                                          nil
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2"
                                              (hide 2)
                                              (("2"
                                                (expand "nn1")
                                                (("2"
                                                  (lemma
                                                   both_sides_times_pos_le1)
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (expand "addend")
                                                      (("2"
                                                        (hide -)
                                                        (("2"
                                                          (lemma
                                                           pos_times_le)
                                                          (("2"
                                                            (inst
                                                             -
                                                             "degree-1"
                                                             m!1)
                                                            (("2"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (hide - 2)
                (("2" (expand "addend") (("2" (assert) nil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (levleq_to_out const-decl "bool" tournamentUnity0 nil)
    (level_step_1 formula-decl nil tournamentUnity0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (D const-decl "posnat" tournamentUnity0 nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (exi1 const-decl "posnat" tournamentUnity0 nil)
    (addend const-decl "posnat" tournamentUnity0 nil)
    (sub_leto formula-decl nil bdUnity nil)
    (digit type-eq-decl nil ctrees nil) (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (levleq const-decl "bool" tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil)
    (<= const-decl "bool" mucalculus nil)
    (cap const-decl "bool" ownpred nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (both_sides_times_pos_le1 formula-decl nil real_props nil)
    (from17to17 formula-decl nil tournamentUnity0 nil)
    (leto_transitive formula-decl nil bdUnity nil)
    (pos_times_le formula-decl nil real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (nn1 skolem-const-decl "posint" tournamentUnity0 nil)
    (leto_up formula-decl nil bdUnity nil)
    (<= const-decl "bool" reals nil)
    (cup_leto formula-decl nil bdUnity nil)
    (cup const-decl "bool" ownpred nil)
    (leveq_betw const-decl "bool" tournamentUnity0 nil)
    (posint nonempty-type-eq-decl nil integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil))
   nil)
  (levleq_to_out_step-8 nil 3671448201
   ("" (skosimp)
    (("" (expand levleq_to_out +)
      (("" (skolem!)
        (("" (use level_step_1)
          (("" (ground)
            ((""
              (case "1 + D + W * degree + degree * m!1 + exi1 = degree * m!1 + addend")
              (("1" (replaceh -1)
                (("1" (lemma sub_leto)
                  (("1" (name-replace nn1 "degree * m!1 + addend")
                    (("1"
                      (inst - nn1 "levleq(q!1, 1 + k!1)" _
                       "atlev(q!1, 17, 1 + k!1)" E1)
                      (("1"
                        (inst -
                         "cup(leveq_betw(q!1, 12, 15, k!1), cup(levleq(q!1, k!1), between(q!1, 16, 18)))")
                        (("1" (assert)
                          (("1" (hide 2)
                            (("1" (split)
                              (("1"
                                (hide -)
                                (("1"
                                  (expand "<=")
                                  (("1"
                                    (expand "cup")
                                    (("1"
                                      (expand "cap")
                                      (("1"
                                        (expand "levleq")
                                        (("1"
                                          (expand "leveq_betw")
                                          (("1"
                                            (expand "between")
                                            (("1"
                                              (skosimp)
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (assert)
                                                  nil)))))))))))))))))))
                               ("2"
                                (use cup_leto)
                                (("2"
                                  (assert)
                                  (("2"
                                    (hide 2)
                                    (("2"
                                      (use cup_leto)
                                      (("2"
                                        (assert)
                                        (("2"
                                          (hide 2)
                                          (("2"
                                            (hide -1)
                                            (("2"
                                              (case "m!1 <= nn1")
                                              (("1"
                                                (split)
                                                (("1"
                                                  (expand
                                                   "levleq_to_out")
                                                  (("1"
                                                    (inst?)
                                                    (("1"
                                                      (lemma leto_up)
                                                      (("1"
                                                        (inst
                                                         -
                                                         m!1
                                                         nn1
                                                         _
                                                         _
                                                         E1)
                                                        (("1"
                                                          (inst?)
                                                          (("1"
                                                            (assert)
                                                            nil)))))))))))
                                                 ("2"
                                                  (use from16_18_out)
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (lemma leto_up)
                                                      (("2"
                                                        (inst
                                                         -
                                                         "1 + exi1 * depth(pp)"
                                                         nn1
                                                         _
                                                         _
                                                         _)
                                                        (("2"
                                                          (inst?)
                                                          (("2"
                                                            (assert)
                                                            nil)))))))))))))
                                               ("2"
                                                (hide 2)
                                                (("2"
                                                  (expand "nn1")
                                                  (("2"
                                                    (lemma
                                                     both_sides_times_pos_le1)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (expand
                                                         "addend")
                                                        (("2"
                                                          (hide -)
                                                          (("2"
                                                            (lemma
                                                             pos_times_le)
                                                            (("2"
                                                              (inst
                                                               -
                                                               "degree-1"
                                                               m!1)
                                                              (("2"
                                                                (assert)
                                                                nil)))))))))))))))))))))))))))))))))))))))))))))))))
               ("2" (hide - 2)
                (("2" (expand "addend")
                  (("2" (assert) nil))))))))))))))))
    nil)
   nil nil)
  (levleq_to_out_step-7 nil 3671447753
   ("" (skosimp)
    (("" (expand levleq_to_out +)
      (("" (skolem!)
        (("" (use level_step_1)
          (("" (ground)
            ((""
              (case "1 + D + W * degree + degree * m!1 + exi1 = degree * m!1 + addend")
              (("1" (replaceh -1)
                (("1" (lemma sub_leto)
                  (("1" (name-replace nn1 "degree * m!1 + addend")
                    (("1"
                      (inst - nn1 "levleq(q!1, 1 + k!1)" _
                       "atlev(q!1, 1 + k!1)" E1)
                      (("1"
                        (inst -
                         "cup(leveq_betw(q!1, 12, 15, k!1), cup(levleq(q!1, k!1), between(q!1, 16, 18)))")
                        (("1" (assert)
                          (("1" (hide 2)
                            (("1" (split)
                              (("1"
                                (hide -)
                                (("1"
                                  (expand "<=")
                                  (("1"
                                    (expand "cup")
                                    (("1"
                                      (expand "cap")
                                      (("1"
                                        (expand "levleq")
                                        (("1"
                                          (expand "leveq_betw")
                                          (("1"
                                            (expand "between")
                                            (("1"
                                              (skosimp)
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (assert)
                                                  nil)))))))))))))))))))
                               ("2"
                                (use cup_leto)
                                (("2"
                                  (assert)
                                  (("2"
                                    (hide 2)
                                    (("2"
                                      (use cup_leto)
                                      (("2"
                                        (assert)
                                        (("2"
                                          (hide 2)
                                          (("2"
                                            (hide -1)
                                            (("2"
                                              (case "m!1 <= nn1")
                                              (("1"
                                                (split)
                                                (("1"
                                                  (expand
                                                   "levleq_to_out")
                                                  (("1"
                                                    (inst?)
                                                    (("1"
                                                      (lemma leto_up)
                                                      (("1"
                                                        (inst
                                                         -
                                                         m!1
                                                         nn1
                                                         _
                                                         _
                                                         E1)
                                                        (("1"
                                                          (inst?)
                                                          (("1"
                                                            (assert)
                                                            nil)))))))))))
                                                 ("2"
                                                  (use from16_18_out)
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (lemma leto_up)
                                                      (("2"
                                                        (inst
                                                         -
                                                         "1 + exi1 * depth(pp)"
                                                         nn1
                                                         _
                                                         _
                                                         _)
                                                        (("2"
                                                          (inst?)
                                                          (("2"
                                                            (assert)
                                                            nil)))))))))))))
                                               ("2"
                                                (hide 2)
                                                (("2"
                                                  (expand "nn1")
                                                  (("2"
                                                    (lemma
                                                     both_sides_times_pos_le1)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (expand
                                                         "addend")
                                                        (("2"
                                                          (hide -)
                                                          (("2"
                                                            (lemma
                                                             pos_times_le)
                                                            (("2"
                                                              (inst
                                                               -
                                                               "degree-1"
                                                               m!1)
                                                              (("2"
                                                                (assert)
                                                                nil)))))))))))))))))))))))))))))))))))))))))))))))))
               ("2" (hide - 2)
                (("2" (expand "addend")
                  (("2" (assert) nil))))))))))))))))
    nil)
   nil nil)
  (levleq_to_out_step-6 nil 3671440061
   ("" (skosimp)
    (("" (expand levleq_to_out +)
      (("" (skolem!)
        (("" (use level_step_1)
          (("" (assert)
            ((""
              (case "1 + D + W * degree + degree * m!1 + exi1 = degree * m!1 + addend")
              (("1" (replaceh -1)
                (("1" (lemma sub_leto)
                  (("1" (name-replace nn1 "degree * m!1 + addend")
                    (("1"
                      (inst - nn1 "levleq(q!1, 1 + k!1)" _
                       "atlev(q!1, 1 + k!1)" E1)
                      (("1"
                        (inst -
                         "cup(leveq_betw(q!1, 12, 15, k!1), cup(levleq(q!1, k!1), between(q!1, 16, 18)))")
                        (("1" (assert)
                          (("1" (hide 2)
                            (("1" (split)
                              (("1"
                                (hide -)
                                (("1"
                                  (expand "<=")
                                  (("1"
                                    (expand "cup")
                                    (("1"
                                      (expand "cap")
                                      (("1"
                                        (expand "levleq")
                                        (("1"
                                          (expand "leveq_betw")
                                          (("1"
                                            (expand "between")
                                            (("1"
                                              (skosimp)
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (assert)
                                                  nil)))))))))))))))))))
                               ("2"
                                (use cup_leto)
                                (("2"
                                  (assert)
                                  (("2"
                                    (hide 2)
                                    (("2"
                                      (use cup_leto)
                                      (("2"
                                        (assert)
                                        (("2"
                                          (hide 2)
                                          (("2"
                                            (hide -1)
                                            (("2"
                                              (case "m!1 <= nn1")
                                              (("1"
                                                (split)
                                                (("1"
                                                  (expand
                                                   "levleq_to_out")
                                                  (("1"
                                                    (inst?)
                                                    (("1"
                                                      (lemma leto_up)
                                                      (("1"
                                                        (inst
                                                         -
                                                         m!1
                                                         nn1
                                                         _
                                                         _
                                                         E1)
                                                        (("1"
                                                          (inst?)
                                                          (("1"
                                                            (assert)
                                                            nil)))))))))))
                                                 ("2"
                                                  (use from16_18_out)
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (lemma leto_up)
                                                      (("2"
                                                        (inst
                                                         -
                                                         "1 + exi1 * depth(pp)"
                                                         nn1
                                                         _
                                                         _
                                                         _)
                                                        (("2"
                                                          (inst?)
                                                          (("2"
                                                            (assert)
                                                            nil)))))))))))))
                                               ("2"
                                                (hide 2)
                                                (("2"
                                                  (expand "nn1")
                                                  (("2"
                                                    (lemma
                                                     both_sides_times_pos_le1)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (expand
                                                         "addend")
                                                        (("2"
                                                          (hide -)
                                                          (("2"
                                                            (lemma
                                                             pos_times_le)
                                                            (("2"
                                                              (inst
                                                               -
                                                               "degree-1"
                                                               m!1)
                                                              (("2"
                                                                (assert)
                                                                nil)))))))))))))))))))))))))))))))))))))))))))))))))
               ("2" (hide - 2)
                (("2" (expand "addend")
                  (("2" (assert) nil))))))))))))))))
    nil)
   nil nil)
  (levleq_to_out_step-5 nil 3671439910
   ("" (skosimp)
    (("" (expand levleq_to_out +)
      (("" (skolem!)
        (("" (use level_step_1)
          (("" (assert)
            ((""
              (case "1 + D + W * degree + degree * m!1 + exi1 = degree * m!1 + addend")
              (("1" (replaceh -1)
                (("1" (lemma sub_leto)
                  (("1" (name-replace nn1 "degree * m!1 + addend")
                    (("1"
                      (inst - nn1 "levleq(q!1, 1 + k!1)" _ "out(q!1)"
                       E1)
                      (("1"
                        (inst -
                         "cup(leveq_betw(q!1, 12, 15, k!1), cup(levleq(q!1, k!1), between(q!1, 16, 18)))")
                        (("1" (assert)
                          (("1" (hide 2)
                            (("1" (split)
                              (("1"
                                (hide -)
                                (("1"
                                  (expand "<=")
                                  (("1"
                                    (expand "cup")
                                    (("1"
                                      (expand "cap")
                                      (("1"
                                        (expand "levleq")
                                        (("1"
                                          (expand "leveq_betw")
                                          (("1"
                                            (expand "between")
                                            (("1"
                                              (skosimp)
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (assert)
                                                  nil)))))))))))))))))))
                               ("2"
                                (use cup_leto)
                                (("2"
                                  (assert)
                                  (("2"
                                    (hide 2)
                                    (("2"
                                      (use cup_leto)
                                      (("2"
                                        (assert)
                                        (("2"
                                          (hide 2)
                                          (("2"
                                            (hide -1)
                                            (("2"
                                              (case "m!1 <= nn1")
                                              (("1"
                                                (split)
                                                (("1"
                                                  (expand
                                                   "levleq_to_out")
                                                  (("1"
                                                    (inst?)
                                                    (("1"
                                                      (lemma leto_up)
                                                      (("1"
                                                        (inst
                                                         -
                                                         m!1
                                                         nn1
                                                         _
                                                         _
                                                         E1)
                                                        (("1"
                                                          (inst?)
                                                          (("1"
                                                            (assert)
                                                            nil)))))))))))
                                                 ("2"
                                                  (use from16_18_out)
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (lemma leto_up)
                                                      (("2"
                                                        (inst
                                                         -
                                                         "1 + exi1 * depth(pp)"
                                                         nn1
                                                         _
                                                         _
                                                         _)
                                                        (("2"
                                                          (inst?)
                                                          (("2"
                                                            (assert)
                                                            nil)))))))))))))
                                               ("2"
                                                (hide 2)
                                                (("2"
                                                  (expand "nn1")
                                                  (("2"
                                                    (lemma
                                                     both_sides_times_pos_le1)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (expand
                                                         "addend")
                                                        (("2"
                                                          (hide -)
                                                          (("2"
                                                            (lemma
                                                             pos_times_le)
                                                            (("2"
                                                              (inst
                                                               -
                                                               "degree-1"
                                                               m!1)
                                                              (("2"
                                                                (assert)
                                                                nil)))))))))))))))))))))))))))))))))))))))))))))))))
               ("2" (hide - 2)
                (("2" (expand "addend")
                  (("2" (assert) nil))))))))))))))))
    nil)
   nil nil)
  (levleq_to_out_step-4 nil 3671439781
   ("" (skosimp)
    (("" (expand levleq_to_out +)
      (("" (skolem!)
        (("" (use level_step_1)
          (("" (assert)
            ((""
              (case "1 + D + W * degree + degree * m!1 = degree * m!1 + addend")
              (("1" (replaceh -1)
                (("1" (lemma sub_leto)
                  (("1" (name-replace nn1 "degree * m!1 + addend")
                    (("1"
                      (inst - nn1 "levleq(q!1, 1 + k!1)" _ "out(q!1)"
                       E1)
                      (("1"
                        (inst -
                         "cup(leveq_betw(q!1, 12, 15, k!1), cup(levleq(q!1, k!1), between(q!1, 16, 18)))")
                        (("1" (assert)
                          (("1" (hide 2)
                            (("1" (split)
                              (("1"
                                (hide -)
                                (("1"
                                  (expand "<=")
                                  (("1"
                                    (expand "cup")
                                    (("1"
                                      (expand "cap")
                                      (("1"
                                        (expand "levleq")
                                        (("1"
                                          (expand "leveq_betw")
                                          (("1"
                                            (expand "between")
                                            (("1"
                                              (skosimp)
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (assert)
                                                  nil)))))))))))))))))))
                               ("2"
                                (use cup_leto)
                                (("2"
                                  (assert)
                                  (("2"
                                    (hide 2)
                                    (("2"
                                      (use cup_leto)
                                      (("2"
                                        (assert)
                                        (("2"
                                          (hide 2)
                                          (("2"
                                            (hide -1)
                                            (("2"
                                              (case "m!1 <= nn1")
                                              (("1"
                                                (split)
                                                (("1"
                                                  (expand
                                                   "levleq_to_out")
                                                  (("1"
                                                    (inst?)
                                                    (("1"
                                                      (lemma leto_up)
                                                      (("1"
                                                        (inst
                                                         -
                                                         m!1
                                                         nn1
                                                         _
                                                         _
                                                         E1)
                                                        (("1"
                                                          (inst?)
                                                          (("1"
                                                            (assert)
                                                            nil)))))))))))
                                                 ("2"
                                                  (use from16_18_out)
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (lemma leto_up)
                                                      (("2"
                                                        (inst
                                                         -
                                                         "1 + exi1 * depth(pp)"
                                                         nn1
                                                         _
                                                         _
                                                         _)
                                                        (("2"
                                                          (inst?)
                                                          (("2"
                                                            (assert)
                                                            nil)))))))))))))
                                               ("2"
                                                (hide 2)
                                                (("2"
                                                  (expand "nn1")
                                                  (("2"
                                                    (lemma
                                                     both_sides_times_pos_le1)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (expand
                                                         "addend")
                                                        (("2"
                                                          (hide -)
                                                          (("2"
                                                            (lemma
                                                             pos_times_le)
                                                            (("2"
                                                              (inst
                                                               -
                                                               "degree-1"
                                                               m!1)
                                                              (("2"
                                                                (assert)
                                                                nil)))))))))))))))))))))))))))))))))))))))))))))))))
               ("2" (hide - 2)
                (("2" (expand "addend")
                  (("2" (assert) nil))))))))))))))))
    nil)
   nil nil)
  (levleq_to_out_step-3 nil 3671348729
   ("" (skosimp)
    (("" (expand levleq_to_out +)
      (("" (skolem!)
        (("" (use level_step)
          (("" (assert)
            ((""
              (case "1 + D + W * degree + degree * m!1 = degree * m!1 + addend")
              (("1" (replaceh -1)
                (("1" (lemma sub_leto)
                  (("1" (name-replace nn1 "degree * m!1 + addend")
                    (("1"
                      (inst - nn1 "levleq(q!1, 1 + k!1)" _ "out(q!1)"
                       E1)
                      (("1"
                        (inst -
                         "cup(leveq_betw(q!1, 12, 15, k!1), cup(levleq(q!1, k!1), between(q!1, 16, 18)))")
                        (("1" (assert)
                          (("1" (hide 2)
                            (("1" (split)
                              (("1"
                                (hide -)
                                (("1"
                                  (expand "<=")
                                  (("1"
                                    (expand "cup")
                                    (("1"
                                      (expand "cap")
                                      (("1"
                                        (expand "levleq")
                                        (("1"
                                          (expand "leveq_betw")
                                          (("1"
                                            (expand "between")
                                            (("1"
                                              (skosimp)
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (use cup_leto)
                                (("2"
                                  (assert)
                                  (("2"
                                    (hide 2)
                                    (("2"
                                      (use cup_leto)
                                      (("2"
                                        (assert)
                                        (("2"
                                          (hide 2)
                                          (("2"
                                            (hide -1)
                                            (("2"
                                              (case "m!1 <= nn1")
                                              (("1"
                                                (split)
                                                (("1"
                                                  (expand
                                                   "levleq_to_out")
                                                  (("1"
                                                    (inst?)
                                                    (("1"
                                                      (lemma leto_up)
                                                      (("1"
                                                        (inst
                                                         -
                                                         m!1
                                                         nn1
                                                         _
                                                         _
                                                         E1)
                                                        (("1"
                                                          (inst?)
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (use from16_18_out)
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (lemma leto_up)
                                                      (("2"
                                                        (inst
                                                         -
                                                         "1 + exi1 * depth(pp)"
                                                         nn1
                                                         _
                                                         _
                                                         _)
                                                        (("2"
                                                          (inst?)
                                                          (("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (hide 2)
                                                (("2"
                                                  (expand "nn1")
                                                  (("2"
                                                    (lemma
                                                     both_sides_times_pos_le1)
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (expand
                                                         "addend")
                                                        (("2"
                                                          (hide -)
                                                          (("2"
                                                            (lemma
                                                             pos_times_le)
                                                            (("2"
                                                              (inst
                                                               -
                                                               "degree-1"
                                                               m!1)
                                                              (("2"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (hide - 2)
                (("2" (expand "addend") (("2" (assert) nil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (levleq_to_out const-decl "bool" tournamentUnity0 nil)
    (level_step formula-decl nil tournamentUnity0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil)
    (below type-eq-decl nil nat_types nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (D const-decl "posnat" tournamentUnity0 nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (addend const-decl "posnat" tournamentUnity0 nil)
    (sub_leto formula-decl nil bdUnity nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (out const-decl "bool" tournamentUnity0 nil)
    (levleq const-decl "bool" tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil)
    (<= const-decl "bool" mucalculus nil)
    (cap const-decl "bool" ownpred nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (<= const-decl "bool" reals nil)
    (exi1 const-decl "posnat" tournamentUnity0 nil)
    (leto_up formula-decl nil bdUnity nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (pos_times_le formula-decl nil real_props nil)
    (both_sides_times_pos_le1 formula-decl nil real_props nil)
    (cup_leto formula-decl nil bdUnity nil)
    (cup const-decl "bool" ownpred nil)
    (leveq_betw const-decl "bool" tournamentUnity0 nil)
    (between const-decl "bool" tournamentUnity0 nil)
    (posint nonempty-type-eq-decl nil integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil)
  (levleq_to_out_step-2 nil 3670595318
   ("" (skosimp)
    (("" (expand levleq_to_out +)
      (("" (skolem!)
        (("" (use level_step)
          (("" (assert)
            ((""
              (case "1 + D + W * degree + degree * m!1 + m!1= degree1 * m!1 + addend")
              (("1" (replaceh -1)
                (("1" (lemma sub_leto)
                  (("1" (name-replace nn1 "degree1 * m!1 + addend")
                    (("1"
                      (inst - nn1 "levleq(q!1, 1 + k!1)" _ "out(q!1)"
                       E1)
                      (("1"
                        (inst -
                         "cup(leveq_betw(q!1, 12, 15, k!1), cup(levleq(q!1, k!1), between(q!1, 16, 18)))")
                        (("1" (assert)
                          (("1" (hide 2)
                            (("1" (split)
                              (("1"
                                (hide -)
                                (("1"
                                  (expand "<=")
                                  (("1"
                                    (expand "cup")
                                    (("1"
                                      (expand "cap")
                                      (("1"
                                        (expand "levleq")
                                        (("1"
                                          (expand "leveq_betw")
                                          (("1"
                                            (expand "between")
                                            (("1"
                                              (skosimp)
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (use cup_leto)
                                (("2"
                                  (assert)
                                  (("2"
                                    (hide 2)
                                    (("2"
                                      (use cup_leto)
                                      (("2"
                                        (assert)
                                        (("2"
                                          (hide 2)
                                          (("2"
                                            (hide -1)
                                            (("2"
                                              (case "m!1 <= nn1")
                                              (("1"
                                                (split)
                                                (("1"
                                                  (expand
                                                   "levleq_to_out")
                                                  (("1"
                                                    (inst?)
                                                    (("1"
                                                      (lemma leto_up)
                                                      (("1"
                                                        (inst
                                                         -
                                                         m!1
                                                         nn1
                                                         _
                                                         _
                                                         E1)
                                                        (("1"
                                                          (inst?)
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (use from16_18_out)
                                                  (("2"
                                                    (assert)
                                                    (("2"
                                                      (lemma leto_up)
                                                      (("2"
                                                        (inst
                                                         -
                                                         "1 + exi1 * depth(pp)"
                                                         nn1
                                                         _
                                                         _
                                                         _)
                                                        (("2"
                                                          (inst?)
                                                          (("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (hide 2)
                                                (("2"
                                                  (expand "nn1")
                                                  (("2"
                                                    (lemma
                                                     both_sides_times_pos_le1)
                                                    (("2"
                                                      (inst
                                                       -
                                                       m!1
                                                       1
                                                       degree1)
                                                      (("2"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (hide - 2)
                (("2" (expand "degree1")
                  (("2" (expand "addend") (("2" (assert) nil nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (levleq_to_out const-decl "bool" tournamentUnity0 nil)
    (level_step formula-decl nil tournamentUnity0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil)
    (below type-eq-decl nil nat_types nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (D const-decl "posnat" tournamentUnity0 nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (addend const-decl "posnat" tournamentUnity0 nil)
    (sub_leto formula-decl nil bdUnity nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (out const-decl "bool" tournamentUnity0 nil)
    (levleq const-decl "bool" tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil)
    (<= const-decl "bool" mucalculus nil)
    (cap const-decl "bool" ownpred nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (<= const-decl "bool" reals nil)
    (exi1 const-decl "posnat" tournamentUnity0 nil)
    (leto_up formula-decl nil bdUnity nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (both_sides_times_pos_le1 formula-decl nil real_props nil)
    (cup_leto formula-decl nil bdUnity nil)
    (cup const-decl "bool" ownpred nil)
    (leveq_betw const-decl "bool" tournamentUnity0 nil)
    (between const-decl "bool" tournamentUnity0 nil)
    (posint nonempty-type-eq-decl nil integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil)
  (levleq_to_out_step-1 nil 3670588615
   ("" (skosimp)
    (("" (expand levleq_to_out +)
      (("" (skolem!)
        (("" (use level_step)
          (("" (assert)
            ((""
              (case "1 + D + W * degree + degree * m!1 + m!1= degree1 * m!1 + addend")
              (("1" (replaceh -1)
                (("1" (lemma sub_leto)
                  (("1" (name-replace nn1 "degree1 * m!1 + addend")
                    (("1"
                      (inst - nn1 "levleq(q!1, 1 + k!1)" _ "out(q!1)"
                       E1)
                      (("1"
                        (inst -
                         "cup(leveq_betw(q!1, 12, 15, k!1), cup(levleq(q!1, k!1), between(q!1, 16, 18)))")
                        (("1" (assert)
                          (("1" (hide 2)
                            (("1" (split)
                              (("1"
                                (hide -)
                                (("1"
                                  (expand "<=")
                                  (("1"
                                    (expand "cup")
                                    (("1"
                                      (expand "cap")
                                      (("1"
                                        (expand "levleq")
                                        (("1"
                                          (expand "leveq_betw")
                                          (("1"
                                            (expand "between")
                                            (("1"
                                              (skosimp)
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (assert)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (use cup_leto)
                                (("2"
                                  (assert)
                                  (("2"
                                    (hide 2)
                                    (("2"
                                      (use cup_leto)
                                      (("2"
                                        (assert)
                                        (("2"
                                          (hide 2)
                                          (("2"
                                            (hide -1)
                                            (("2"
                                              (case "m!1 <= nn1")
                                              (("1"
                                                (split)
                                                (("1"
                                                  (expand
                                                   "levleq_to_out")
                                                  (("1"
                                                    (inst?)
                                                    (("1"
                                                      (lemma leto_up)
                                                      (("1"
                                                        (inst
                                                         -
                                                         m!1
                                                         nn1
                                                         _
                                                         _
                                                         E1)
                                                        (("1"
                                                          (inst?)
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (use
                                                   between16_18_out)
                                                  (("2"
                                                    (postpone)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (postpone)
                                                nil
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (hide - 2)
                (("2" (expand "degree1")
                  (("2" (expand "addend") (("2" (assert) nil nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   nil shostak))
 (fun_TCC1 0
  (fun_TCC1-1 nil 3670595930 ("" (termination-tcc) nil nil)
   ((boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (>= const-decl "bool" reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil))
 (fun_TCC2 0
  (fun_TCC2-1 nil 3670597687 ("" (termination-tcc) nil nil) nil nil))
 (fun_eq_TCC1 0
  (fun_eq_TCC1-1 nil 3671348239
   ("" (use degree_gt_1) (("" (assert) nil nil)) nil)
   ((int_minus_int_is_int application-judgement "int" integers nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (degree_gt_1 formula-decl nil tournamentUnity0 nil))
   nil))
 (fun_eq 0
  (fun_eq-1 nil 3670743239
   ("" (induct k)
    (("1" (expand "power")
      (("1" (expand "fun") (("1" (propax) nil nil)) nil)) nil)
     ("2" (skosimp)
      (("2" (expand fun +)
        (("2" (expand power +)
          (("2" (replaceh -1)
            (("2" (assert)
              (("2" (assert)
                (("2"
                  (name-replace gg "2 * (power(j!1, degree) * degree)")
                  (("2" (name deg1 "degree - 1")
                    (("2" (case "degree = deg1 + 1")
                      (("1" (replaceh -1) (("1" (assert) nil nil)) nil)
                       ("2" (assert) nil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil)
     ("3" (assert)
      (("3" (use degree_gt_1) (("3" (assert) nil nil)) nil)) nil))
    nil)
   ((real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (degree_gt_1 formula-decl nil tournamentUnity0 nil)
    (rat_times_rat_is_rat application-judgement "rat" rationals nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (nzrat_times_nzrat_is_nzrat application-judgement "nzrat" rationals
     nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (even_int nonempty-type-eq-decl nil integers nil)
    (even? const-decl "bool" integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (rat_minus_rat_is_rat application-judgement "rat" rationals nil)
    (rat_plus_rat_is_rat application-judgement "rat" rationals nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (nzrat_div_nzrat_is_nzrat application-judgement "nzrat" rationals
     nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (addend const-decl "posnat" tournamentUnity0 nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (exi const-decl "posnat" tournamentUnity0 nil)
    (cs const-decl "posnat" tournamentUnity0 nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (power def-decl "int" tournamentUnity0 nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (fun def-decl "nat" tournamentUnity0 nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (/= const-decl "boolean" notequal nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil))
   shostak))
 (levleq_to_out_all 0
  (levleq_to_out_all-3 nil 3670735352
   ("" (induct k)
    (("1" (flatten)
      (("1" (expand "levleq_to_out")
        (("1" (expand "fun")
          (("1" (skolem!)
            (("1" (use levleq_0_out)
              (("1" (assert)
                (("1" (flatten) (("1" (assert) nil nil)) nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil)
     ("2" (skosimp)
      (("2" (assert)
        (("2" (expand fun +)
          (("2" (use levleq_to_out_step) (("2" (assert) nil nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (levleq_to_out_step formula-decl nil tournamentUnity0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (levleq_0_out formula-decl nil tournamentUnity0 nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (fun def-decl "nat" tournamentUnity0 nil)
    (levleq_to_out const-decl "bool" tournamentUnity0 nil)
    (ass_exit const-decl "bool" tournamentUnity0 nil)
    (ass_doorway const-decl "bool" tournamentUnity0 nil)
    (ass_waiting const-decl "bool" tournamentUnity0 nil)
    (ass_cs const-decl "bool" tournamentUnity0 nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   nil)
  (levleq_to_out_all-2 nil 3670596182
   ("" (induct k)
    (("1" (flatten)
      (("1" (expand "levleq_to_out")
        (("1" (expand "fun")
          (("1" (skolem!)
            (("1" (use levleq_0_out) (("1" (assert) nil nil)) nil))
            nil))
          nil))
        nil))
      nil)
     ("2" (skosimp)
      (("2" (assert)
        (("2" (expand fun +)
          (("2" (use levleq_to_out_step)
            (("2" (assert)
              (("2" (assert)
                (("2" (hide - 2)
                  (("2"
                    (case "forall k: 2 + 2 * depth(pp) <= fun (k)")
                    (("1" (inst?) nil nil)
                     ("2" (hide 2)
                      (("2" (induct k)
                        (("1" (expand "fun") (("1" (assert) nil nil))
                          nil)
                         ("2" (skosimp)
                          (("2" (expand fun +)
                            (("2" (lemma both_sides_times_pos_le1)
                              (("2"
                                (inst - "fun(j!2)" 1 degree1)
                                (("1" (assert) nil nil)
                                 ("2" (assert) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (both_sides_times_pos_le1 formula-decl nil real_props nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (<= const-decl "bool" reals nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (levleq_to_out_step formula-decl nil tournamentUnity0 nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (levleq_0_out formula-decl nil tournamentUnity0 nil)
    (below type-eq-decl nil nat_types nil)
    (< const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (even_plus_even_is_even application-judgement "even_int" integers
     nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (nat_induction formula-decl nil naturalnumbers nil)
    (fun def-decl "nat" tournamentUnity0 nil)
    (levleq_to_out const-decl "bool" tournamentUnity0 nil)
    (ass_doorway const-decl "bool" tournamentUnity0 nil)
    (ass_waiting const-decl "bool" tournamentUnity0 nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (pred type-eq-decl nil defined_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   nil)
  (levleq_to_out_all-1 nil 3670595931
   ("" (induct k)
    (("1" (expand "levleq_to_out")
      (("1" (expand "fun")
        (("1" (skolem!)
          (("1" (use levleq_0_out) (("1" (assert) nil nil)) nil)) nil))
        nil))
      nil)
     ("2" (skosimp) (("2" (postpone) nil nil)) nil))
    nil)
   nil shostak))
 (from12_18to_out 0
  (from12_18to_out-1 nil 3670599536
   ("" (skosimp)
    (("" (lemma sub_leto)
      (("" (use levleq_to_out_all)
        (("" (assert)
          (("" (use level_step_2 (m "fun(k!1)"))
            (("" (assert)
              ((""
                (name-replace nn1
                 "1 + D + fun(k!1) * degree + W * degree")
                (("" (expand "levleq_to_out")
                  (("" (inst?)
                    (("" (assert)
                      (("" (name-replace goal "atlev(q!1, 17, k!1)")
                        ((""
                          (inst - nn1 "between(q!1, 12, 18)"
                           "cup(leveq_betw(q!1, 12, 18, k!1), levleq(q!1, k!1))"
                           goal E1)
                          (("" (assert)
                            (("" (hide 2)
                              ((""
                                (split)
                                (("1"
                                  (hide-all-but -6 -)
                                  (("1"
                                    (expand "<=")
                                    (("1"
                                      (expand "cap")
                                      (("1"
                                        (expand "cup")
                                        (("1"
                                          (expand "between")
                                          (("1"
                                            (expand "leveq_betw")
                                            (("1"
                                              (expand "levleq")
                                              (("1"
                                                (skosimp)
                                                (("1"
                                                  (assert)
                                                  (("1"
                                                    (case
                                                     "iq0(q!1, s!1)")
                                                    (("1"
                                                      (expand "iq0")
                                                      (("1"
                                                        (propax)
                                                        nil
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (assert)
                                                      (("2"
                                                        (expand "E1")
                                                        (("2"
                                                          (expand
                                                           "globinv")
                                                          (("2"
                                                            (expand
                                                             "iqall")
                                                            (("2"
                                                              (flatten)
                                                              (("2"
                                                                (inst?)
                                                                (("2"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (use cup_leto)
                                  (("2"
                                    (assert)
                                    (("2"
                                      (hide -1 2)
                                      (("2"
                                        (lemma leto_up)
                                        (("2"
                                          (inst - "fun(k!1)" nn1 _ _ _)
                                          (("2"
                                            (inst?)
                                            (("2"
                                              (assert)
                                              (("2"
                                                (hide -1 2)
                                                (("2"
                                                  (expand "nn1")
                                                  (("2"
                                                    (lemma
                                                     pos_times_le)
                                                    (("2"
                                                      (inst
                                                       -
                                                       "degree - 1"
                                                       "fun(k!1)")
                                                      (("2"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (digit type-eq-decl nil ctrees nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (sub_leto formula-decl nil bdUnity nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (levleq_to_out const-decl "bool" tournamentUnity0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (levleq const-decl "bool" tournamentUnity0 nil)
    (leveq_betw const-decl "bool" tournamentUnity0 nil)
    (cup const-decl "bool" ownpred nil)
    (between const-decl "bool" tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil)
    (cup_leto formula-decl nil bdUnity nil)
    (nn1 skolem-const-decl "posint" tournamentUnity0 nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (pos_times_le formula-decl nil real_props nil)
    (leto_up formula-decl nil bdUnity nil)
    (cap const-decl "bool" ownpred nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (<= const-decl "bool" mucalculus nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (D const-decl "posnat" tournamentUnity0 nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (posint nonempty-type-eq-decl nil integers nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (level_step_2 formula-decl nil tournamentUnity0 nil)
    (fun def-decl "nat" tournamentUnity0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (levleq_to_out_all formula-decl nil tournamentUnity0 nil))
   shostak))
 (individual_progress 0
  (individual_progress-6 nil 3671515538
   ("" (skosimp)
    (("" (lemma sub_leto)
      (("" (inst - "fun1(k!1) + 2" fullset _ "at(q!1, 11)" E1)
        ((""
          (inst -
           "cup(at(q!1, 11), cup(between(q!1, 12, 18), at(q!1, 19)))")
          (("" (assert)
            (("" (hide 2)
              (("" (split)
                (("1" (hide -)
                  (("1" (expand "<=")
                    (("1" (expand "cap")
                      (("1" (expand "fullset")
                        (("1" (expand "cup")
                          (("1" (expand "at")
                            (("1" (expand "between")
                              (("1"
                                (skosimp)
                                (("1"
                                  (case "kq0(q!1, s!1)")
                                  (("1"
                                    (expand "kq0")
                                    (("1"
                                      (flatten)
                                      (("1" (assert) nil nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (expand "E1")
                                    (("2"
                                      (expand "globinv")
                                      (("2"
                                        (expand "kqall")
                                        (("2"
                                          (flatten)
                                          (("2"
                                            (inst?)
                                            (("2" (assert) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (use cup_leto)
                  (("2" (assert)
                    (("2" (hide 2)
                      (("2" (split)
                        (("1" (hide -)
                          (("1" (use subset_leto)
                            (("1" (assert)
                              (("1"
                                (hide 2)
                                (("1"
                                  (expand "<=")
                                  (("1"
                                    (expand "cap")
                                    (("1" (skosimp) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (use cup_leto)
                          (("2" (assert)
                            (("2" (hide 2)
                              (("2"
                                (split)
                                (("1"
                                  (use from12_18to_out)
                                  (("1"
                                    (use out_to11)
                                    (("1"
                                      (assert)
                                      (("1"
                                        (case
                                         "atlev(q!1, 17, k!1) = out(q!1)")
                                        (("1"
                                          (replaceh -1)
                                          (("1"
                                            (lemma leto_transitive)
                                            (("1"
                                              (inst
                                               -
                                               "1 + D + fun(k!1) * degree + W * degree"
                                               2
                                               _
                                               _
                                               _
                                               _)
                                              (("1"
                                                (inst?)
                                                (("1"
                                                  (inst?)
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (expand "fun1")
                                                      (("1"
                                                        (propax)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (hide -1 -2 2)
                                          (("2"
                                            (apply-extensionality
                                             :hide?
                                             t)
                                            (("2"
                                              (iff)
                                              (("2"
                                                (expand "atlev")
                                                (("2"
                                                  (expand "out")
                                                  (("2"
                                                    (ground)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (use from19to11)
                                  (("2"
                                    (lemma leto_up)
                                    (("2"
                                      (inst - 1 "2 + fun1(k!1)" _ _ _)
                                      (("2"
                                        (inst?)
                                        (("2" (assert) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (digit type-eq-decl nil ctrees nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (node formal-nonempty-type-decl nil tournamentUnity0 nil)
    (sub_leto formula-decl nil bdUnity nil)
    (between const-decl "bool" tournamentUnity0 nil)
    (cup const-decl "bool" ownpred nil)
    (cup_leto formula-decl nil bdUnity nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (from19to11 formula-decl nil tournamentUnity0 nil)
    (odd_minus_even_is_odd application-judgement "odd_int" integers
     nil)
    (leto_up formula-decl nil bdUnity nil)
    (from12_18to_out formula-decl nil tournamentUnity0 nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (fun def-decl "nat" tournamentUnity0 nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (D const-decl "posnat" tournamentUnity0 nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (leto_transitive formula-decl nil bdUnity nil)
    (out const-decl "bool" tournamentUnity0 nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (out_to11 formula-decl nil tournamentUnity0 nil)
    (subset_leto formula-decl nil bdUnity nil)
    (cap const-decl "bool" ownpred nil)
    (kq0 const-decl "bool" tournamentSafe0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (kqall const-decl "bool" tournamentSafe0 nil)
    (<= const-decl "bool" mucalculus nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (at const-decl "bool" tournamentUnity0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (fullset const-decl "set" sets nil)
    (pred type-eq-decl nil defined_types nil)
    (fun1 const-decl "nat" tournamentUnity0 nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil))
   nil)
  (individual_progress-5 nil 3671515333
   ("" (skosimp)
    (("" (lemma sub_leto)
      (("" (inst - "fun1(k!1) + 2" fullset _ "at(q!1, 11)" E1)
        ((""
          (inst -
           "cup(at(q!1, 11), cup(between(q!1, 12, 18), at(q!1, 19)))")
          (("" (assert)
            (("" (hide 2)
              (("" (split)
                (("1" (hide -)
                  (("1" (expand "<=")
                    (("1" (expand "cap")
                      (("1" (expand "fullset")
                        (("1" (expand "cup")
                          (("1" (expand "at")
                            (("1" (expand "between")
                              (("1"
                                (skosimp)
                                (("1"
                                  (case "kq0(q!1, s!1)")
                                  (("1"
                                    (expand "kq0")
                                    (("1"
                                      (flatten)
                                      (("1" (assert) nil nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (expand "E1")
                                    (("2"
                                      (expand "globinv")
                                      (("2"
                                        (expand "kqall")
                                        (("2"
                                          (flatten)
                                          (("2"
                                            (inst?)
                                            (("2" (assert) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (use cup_leto)
                  (("2" (assert)
                    (("2" (hide 2)
                      (("2" (split)
                        (("1" (hide -)
                          (("1" (use subset_leto)
                            (("1" (assert)
                              (("1"
                                (hide 2)
                                (("1"
                                  (expand "<=")
                                  (("1"
                                    (expand "cap")
                                    (("1" (skosimp) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (use cup_leto)
                          (("2" (assert)
                            (("2" (hide 2)
                              (("2"
                                (split)
                                (("1"
                                  (use from12_18to_out)
                                  (("1"
                                    (use out_to11)
                                    (("1"
                                      (assert)
                                      (("1"
                                        (case
                                         "atlev(q!1, 17, k!1) = out(q!1)")
                                        (("1"
                                          (replaceh -1)
                                          (("1"
                                            (lemma leto_transitive)
                                            (("1"
                                              (inst
                                               -
                                               "1 + D + fun(k!1) * degree + W * degree"
                                               2
                                               _
                                               _
                                               _
                                               _)
                                              (("1"
                                                (inst?)
                                                (("1"
                                                  (inst?)
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (expand "fun1")
                                                      (("1"
                                                        (propax)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil)
                                         ("2"
                                          (hide -1 -2 2)
                                          (("2"
                                            (apply-extensionality
                                             :hide?
                                             t)
                                            (("2"
                                              (iff)
                                              (("2"
                                                (expand "atlev")
                                                (("2"
                                                  (expand "out")
                                                  (("2"
                                                    (ground)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (use from19to11)
                                  (("2"
                                    (lemma leto_up)
                                    (("2"
                                      (inst
                                       -
                                       1
                                       "2 + fun(depth(pp))"
                                       _
                                       _
                                       _)
                                      (("2"
                                        (inst?)
                                        (("2"
                                          (assert)
                                          (("2"
                                            (assert)
                                            (("2" (postpone) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   nil nil)
  (individual_progress-4 nil 3671515250
   ("" (skosimp)
    (("" (lemma sub_leto)
      (("" (inst - "fun1(k!1) + 2" fullset _ "at(q!1, 11)" E1)
        ((""
          (inst -
           "cup(at(q!1, 11), cup(between(q!1, 12, 18), at(q!1, 19)))")
          (("" (assert)
            (("" (hide 2)
              (("" (split)
                (("1" (hide -)
                  (("1" (expand "<=")
                    (("1" (expand "cap")
                      (("1" (expand "fullset")
                        (("1" (expand "cup")
                          (("1" (expand "at")
                            (("1" (expand "between")
                              (("1"
                                (skosimp)
                                (("1"
                                  (case "kq0(q!1, s!1)")
                                  (("1"
                                    (expand "kq0")
                                    (("1"
                                      (flatten)
                                      (("1" (assert) nil)))))
                                   ("2"
                                    (expand "E1")
                                    (("2"
                                      (expand "globinv")
                                      (("2"
                                        (expand "kqall")
                                        (("2"
                                          (flatten)
                                          (("2"
                                            (inst?)
                                            (("2"
                                              (assert)
                                              nil)))))))))))))))))))))))))))))
                 ("2" (use cup_leto)
                  (("2" (assert)
                    (("2" (hide 2)
                      (("2" (split)
                        (("1" (hide -)
                          (("1" (use subset_leto)
                            (("1" (assert)
                              (("1"
                                (hide 2)
                                (("1"
                                  (expand "<=")
                                  (("1"
                                    (expand "cap")
                                    (("1" (skosimp) nil)))))))))))))
                         ("2" (use cup_leto)
                          (("2" (assert)
                            (("2" (hide 2)
                              (("2"
                                (split)
                                (("1"
                                  (use from12_18to_out)
                                  (("1"
                                    (use out_to11)
                                    (("1"
                                      (assert)
                                      (("1"
                                        (case
                                         "atlev(q!1, 17, k!1) = out(q!1)")
                                        (("1"
                                          (name-replaceh -1)
                                          (("1"
                                            (lemma leto_transitive)
                                            (("1"
                                              (inst
                                               -
                                               "1 + D + fun(k!1) * degree + W * degree"
                                               2
                                               _
                                               _
                                               _
                                               _)
                                              (("1"
                                                (inst?)
                                                (("1"
                                                  (inst?)
                                                  (("1"
                                                    (assert)
                                                    nil)))))))))))))))))))
                                 ("2"
                                  (use from19to11)
                                  (("2"
                                    (lemma leto_up)
                                    (("2"
                                      (inst
                                       -
                                       1
                                       "2 + fun(depth(pp))"
                                       _
                                       _
                                       _)
                                      (("2"
                                        (inst?)
                                        (("2"
                                          (assert)
                                          nil))))))))))))))))))))))))))))))))))))))
    nil)
   nil nil)
  (individual_progress-3 nil 3671515093
   ("" (skosimp)
    (("" (lemma sub_leto)
      (("" (inst - "fun1(k!1) + 2" fullset _ "at(q!1, 11)" E1)
        ((""
          (inst -
           "cup(at(q!1, 11), cup(between(q!1, 12, 18), at(q!1, 19)))")
          (("" (assert)
            (("" (hide 2)
              (("" (split)
                (("1" (hide -)
                  (("1" (expand "<=")
                    (("1" (expand "cap")
                      (("1" (expand "fullset")
                        (("1" (expand "cup")
                          (("1" (expand "at")
                            (("1" (expand "between")
                              (("1"
                                (skosimp)
                                (("1"
                                  (case "kq0(q!1, s!1)")
                                  (("1"
                                    (expand "kq0")
                                    (("1"
                                      (flatten)
                                      (("1" (assert) nil)))))
                                   ("2"
                                    (expand "E1")
                                    (("2"
                                      (expand "globinv")
                                      (("2"
                                        (expand "kqall")
                                        (("2"
                                          (flatten)
                                          (("2"
                                            (inst?)
                                            (("2"
                                              (assert)
                                              nil)))))))))))))))))))))))))))))
                 ("2" (use cup_leto)
                  (("2" (assert)
                    (("2" (hide 2)
                      (("2" (split)
                        (("1" (hide -)
                          (("1" (use subset_leto)
                            (("1" (assert)
                              (("1"
                                (hide 2)
                                (("1"
                                  (expand "<=")
                                  (("1"
                                    (expand "cap")
                                    (("1" (skosimp) nil)))))))))))))
                         ("2" (use cup_leto)
                          (("2" (assert)
                            (("2" (hide 2)
                              (("2"
                                (split)
                                (("1"
                                  (use from12_18to_out)
                                  (("1"
                                    (use out_to11)
                                    (("1"
                                      (assert)
                                      (("1"
                                        (case
                                         "atlev(q!1, 17, k!1) = out(q!1)")
                                        (("1"
                                          (name-replaceh -1)
                                          (("1"
                                            (lemma leto_transitive)
                                            (("1"
                                              (inst
                                               -
                                               "fun(depth(pp))"
                                               2
                                               _
                                               _
                                               _
                                               _)
                                              (("1"
                                                (inst?)
                                                (("1"
                                                  (inst?)
                                                  (("1"
                                                    (assert)
                                                    nil)))))))))))))))))))
                                 ("2"
                                  (use from19to11)
                                  (("2"
                                    (lemma leto_up)
                                    (("2"
                                      (inst
                                       -
                                       1
                                       "2 + fun(depth(pp))"
                                       _
                                       _
                                       _)
                                      (("2"
                                        (inst?)
                                        (("2"
                                          (assert)
                                          nil))))))))))))))))))))))))))))))))))))))
    nil)
   nil nil)
  (individual_progress-2 nil 3671514732
   ("" (skosimp)
    (("" (lemma sub_leto)
      (("" (inst - "fun1(k!1) + 2" fullset _ "at(q!1, 11)" E1)
        ((""
          (inst -
           "cup(at(q!1, 11), cup(between(q!1, 12, 18), at(q!1, 19)))")
          (("" (assert)
            (("" (hide 2)
              (("" (split)
                (("1" (hide -)
                  (("1" (expand "<=")
                    (("1" (expand "cap")
                      (("1" (expand "fullset")
                        (("1" (expand "cup")
                          (("1" (expand "at")
                            (("1" (expand "between")
                              (("1"
                                (skosimp)
                                (("1"
                                  (case "kq0(q!1, s!1)")
                                  (("1"
                                    (expand "kq0")
                                    (("1"
                                      (flatten)
                                      (("1" (assert) nil)))))
                                   ("2"
                                    (expand "E1")
                                    (("2"
                                      (expand "globinv")
                                      (("2"
                                        (expand "kqall")
                                        (("2"
                                          (flatten)
                                          (("2"
                                            (inst?)
                                            (("2"
                                              (assert)
                                              nil)))))))))))))))))))))))))))))
                 ("2" (use cup_leto)
                  (("2" (assert)
                    (("2" (hide 2)
                      (("2" (split)
                        (("1" (hide -)
                          (("1" (use subset_leto)
                            (("1" (assert)
                              (("1"
                                (hide 2)
                                (("1"
                                  (expand "<=")
                                  (("1"
                                    (expand "cap")
                                    (("1" (skosimp) nil)))))))))))))
                         ("2" (use cup_leto)
                          (("2" (assert)
                            (("2" (hide 2)
                              (("2"
                                (split)
                                (("1"
                                  (use from12_18to_out)
                                  (("1"
                                    (use out_to11)
                                    (("1"
                                      (assert)
                                      (("1"
                                        (lemma leto_transitive)
                                        (("1"
                                          (inst
                                           -
                                           "fun(depth(pp))"
                                           2
                                           _
                                           _
                                           _
                                           _)
                                          (("1"
                                            (inst?)
                                            (("1"
                                              (inst?)
                                              (("1"
                                                (assert)
                                                nil)))))))))))))))
                                 ("2"
                                  (use from19to11)
                                  (("2"
                                    (lemma leto_up)
                                    (("2"
                                      (inst
                                       -
                                       1
                                       "2 + fun(depth(pp))"
                                       _
                                       _
                                       _)
                                      (("2"
                                        (inst?)
                                        (("2"
                                          (assert)
                                          nil))))))))))))))))))))))))))))))))))))))
    nil)
   nil nil)
  (individual_progress-1 nil 3670643881
   ("" (skosimp)
    (("" (lemma sub_leto)
      (("" (inst - "fun(depth(pp)) + 2" fullset _ "at(q!1, 11)" E1)
        ((""
          (inst -
           "cup(at(q!1, 11), cup(between(q!1, 12, 18), at(q!1, 19)))")
          (("" (assert)
            (("" (hide 2)
              (("" (split)
                (("1" (hide -)
                  (("1" (expand "<=")
                    (("1" (expand "cap")
                      (("1" (expand "fullset")
                        (("1" (expand "cup")
                          (("1" (expand "at")
                            (("1" (expand "between")
                              (("1"
                                (skosimp)
                                (("1"
                                  (case "kq0(q!1, s!1)")
                                  (("1"
                                    (expand "kq0")
                                    (("1"
                                      (flatten)
                                      (("1" (assert) nil nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (expand "E1")
                                    (("2"
                                      (expand "globinv")
                                      (("2"
                                        (expand "kqall")
                                        (("2"
                                          (flatten)
                                          (("2"
                                            (inst?)
                                            (("2" (assert) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (use cup_leto)
                  (("2" (assert)
                    (("2" (hide 2)
                      (("2" (split)
                        (("1" (hide -)
                          (("1" (use subset_leto)
                            (("1" (assert)
                              (("1"
                                (hide 2)
                                (("1"
                                  (expand "<=")
                                  (("1"
                                    (expand "cap")
                                    (("1" (skosimp) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (use cup_leto)
                          (("2" (assert)
                            (("2" (hide 2)
                              (("2"
                                (split)
                                (("1"
                                  (use from12_18to_out)
                                  (("1"
                                    (use out_to11)
                                    (("1"
                                      (assert)
                                      (("1"
                                        (lemma leto_transitive)
                                        (("1"
                                          (inst
                                           -
                                           "fun(depth(pp))"
                                           2
                                           _
                                           _
                                           _
                                           _)
                                          (("1"
                                            (inst?)
                                            (("1"
                                              (inst?)
                                              (("1" (assert) nil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (use from19to11)
                                  (("2"
                                    (lemma leto_up)
                                    (("2"
                                      (inst
                                       -
                                       1
                                       "2 + fun(depth(pp))"
                                       _
                                       _
                                       _)
                                      (("2"
                                        (inst?)
                                        (("2" (assert) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (sub_leto formula-decl nil bdUnity nil)
    (between const-decl "bool" tournamentUnity0 nil)
    (cup const-decl "bool" ownpred nil)
    (cup_leto formula-decl nil bdUnity nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (from19to11 formula-decl nil tournamentUnity0 nil)
    (odd_minus_even_is_odd application-judgement "odd_int" integers
     nil)
    (leto_up formula-decl nil bdUnity nil)
    (from12_18to_out formula-decl nil tournamentUnity0 nil)
    (out const-decl "bool" tournamentUnity0 nil)
    (even_minus_even_is_even application-judgement "even_int" integers
     nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (leto_transitive formula-decl nil bdUnity nil)
    (out_to11 formula-decl nil tournamentUnity0 nil)
    (subset_leto formula-decl nil bdUnity nil)
    (cap const-decl "bool" ownpred nil)
    (kq0 const-decl "bool" tournamentSafe0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (kqall const-decl "bool" tournamentSafe0 nil)
    (<= const-decl "bool" mucalculus nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (at const-decl "bool" tournamentUnity0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (fullset const-decl "set" sets nil)
    (pred type-eq-decl nil defined_types nil)
    (fun def-decl "nat" tournamentUnity0 nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil))
   shostak))
 (fun1_equals0 0
  (fun1_equals0-1 nil 3671694156
   ("" (skosimp)
    (("" (expand power)
      (("" (expand "fun1")
        (("" (use fun_eq)
          (("" (case "cs + exi + 2 + addend / (degree - 1)= factor")
            (("1" (replaceh -1)
              (("1" (assert)
                (("1" (replaceh -1)
                  (("1" (assert)
                    (("1" (expand "term0") (("1" (assert) nil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (expand "factor") (("2" (propax) nil nil)) nil)
             ("3" (assert) nil nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (power def-decl "int" tournamentUnity0 nil)
    (fun_eq formula-decl nil tournamentUnity0 nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nzrat_div_nzrat_is_nzrat application-judgement "nzrat" rationals
     nil)
    (rat_plus_rat_is_rat application-judgement "rat" rationals nil)
    (rat_times_rat_is_rat application-judgement "rat" rationals nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (term0 const-decl "real" tournamentUnity0 nil)
    (nzrat_times_nzrat_is_nzrat application-judgement "nzrat" rationals
     nil)
    (rat_minus_rat_is_rat application-judgement "rat" rationals nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (factor const-decl "real" tournamentUnity0 nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (addend const-decl "posnat" tournamentUnity0 nil)
    (/ const-decl "[numfield, nznum -> numfield]" number_fields nil)
    (nznum nonempty-type-eq-decl nil number_fields nil)
    (/= const-decl "boolean" notequal nil)
    (exi const-decl "posnat" tournamentUnity0 nil)
    (cs const-decl "posnat" tournamentUnity0 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (fun1 const-decl "nat" tournamentUnity0 nil))
   shostak))
 (factor_equals 0
  (factor_equals-1 nil 3671696936
   ("" (expand "factor")
    (("" (expand "addend")
      (("" (expand "constant0")
        (("" (expand "exi1")
          (("" (name deg1 "degree - 1")
            (("" (case "degree = deg1 + 1")
              (("1" (replaceh -1) (("1" (assert) nil nil)) nil)
               ("2" (assert) nil nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (addend const-decl "posnat" tournamentUnity0 nil)
    (exi1 const-decl "posnat" tournamentUnity0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (rat_div_nzrat_is_rat application-judgement "rat" rationals nil)
    (nzrat_div_nzrat_is_nzrat application-judgement "nzrat" rationals
     nil)
    (rat_plus_rat_is_rat application-judgement "rat" rationals nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (constant0 const-decl "real" tournamentUnity0 nil)
    (factor const-decl "real" tournamentUnity0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil))
   shostak))
 (term0_equals 0
  (term0_equals-1 nil 3671697250
   ("" (expand "term0")
    (("" (expand "addend")
      (("" (expand "constant0")
        (("" (expand "exi1")
          (("" (name deg1 "degree -1 ")
            (("" (case "degree = deg1 + 1")
              (("1" (replaceh -1) (("1" (assert) nil nil)) nil)
               ("2" (assert) nil nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (addend const-decl "posnat" tournamentUnity0 nil)
    (exi1 const-decl "posnat" tournamentUnity0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (rat_div_nzrat_is_rat application-judgement "rat" rationals nil)
    (rat_times_rat_is_rat application-judgement "rat" rationals nil)
    (rat_plus_rat_is_rat application-judgement "rat" rationals nil)
    (rat_minus_rat_is_rat application-judgement "rat" rationals nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity0 nil)
    (constant0 const-decl "real" tournamentUnity0 nil)
    (term0 const-decl "real" tournamentUnity0 nil)
    (nzrat_times_nzrat_is_nzrat application-judgement "nzrat" rationals
     nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (nzrat_div_nzrat_is_nzrat application-judgement "nzrat" rationals
     nil)
    (int_minus_int_is_int application-judgement "int" integers nil))
   shostak))
 (fun1_equals 0
  (fun1_equals-1 nil 3671697861
   ("" (skolem!)
    (("" (use fun1_equals0)
      (("" (use factor_equals)
        (("" (use term0_equals)
          (("" (replace* -1 -2) (("" (assert) nil nil)) nil)) nil))
        nil))
      nil))
    nil)
   ((fun1_equals0 formula-decl nil tournamentUnity0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (real_minus_real_is_real application-judgement "real" reals nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (term0_equals formula-decl nil tournamentUnity0 nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (factor_equals formula-decl nil tournamentUnity0 nil))
   shostak)))


$$$tournamentUnity1.pvs
% Wim H. Hesselink, May-August 2016
% Proofs for: Tournaments for mutual exclusion: 
% verification and concurrent complexity. 
% Part 5.   Throughput (general progress)

tournamentUnity1  [ degree: posnat, node: TYPE+ ]: THEORY

BEGIN
  IMPORTING tournamentUnity0[degree, node]

  p, q, r: VAR Thread
  x, y: VAR state
  i, n, k, kk, m: VAR nat
  b: VAR bool
  se: VAR finite_set[(thread)]
  z: VAR int
  nn: VAR node

  col(q, x): int =
    depth(q) - 1 - x`level(q) 

  lev1(q, x): int =
    x`level(q) + 1

  DW1: posnat = D + W + 1

  lvf(q, x): int = % 
    IF x`pc(q) < 16 THEN
       col(q, x) * DW1
       + IF x`pc(q) = 15 THEN D + 1 
         ELSIF 13 <= x`pc(q) THEN 1
         ELSE 0 ENDIF 
     ELSIF x`pc(q) = 16 THEN  depth(q) * DW1 + 1
     ELSIF x`pc(q) < 19 THEN 
       depth(q) * DW1 + exi1 * lev1(q, x) 
       + x`pc(q) - 16 + cs
     ELSE depth(q) * (DW1 + exi1) + cs + 2 ENDIF 

  lvf_at_12: LEMMA
     step12(q, x, y) AND iq0(q, x) IMPLIES 
       lvf(q, y) = lvf(q, x) + 1

  lvf_at_16: LEMMA
     step16(q, x, y) AND iq2(q, x) IMPLIES 
       lvf(q, y) = lvf(q, x) + cs

  lvf_at_17: LEMMA
     step17(q, x, y) AND iq0(q, x) IMPLIES 
       lvf(q, y) = lvf(q, x) + 1

  AA: posnat = 
    depthnode * (DW1 + exi1) + cs + 3

  lvf_bounded: LEMMA % 
    globinv(x) IMPLIES 
      0 <= lvf(q, x) AND lvf(q, x) < AA

  avf(q, x): int =
    lvf(q, x) + AA * x`cnt(q) 

  avf_bounded: LEMMA 
    globinv(x) IMPLIES 
      AA * x`cnt(q) <= avf(q, x) AND avf(q, x) < AA * x`cnt(q) + AA

  avf_increases_fwd: LEMMA
    forward1(q)(x, y) AND globinv(x)
    IMPLIES avf(q, x) < avf(q, y)

  avf_at_14: LEMMA
    step14(q, x, y) IMPLIES 
      avf(q, y) = avf(q, x) + D

  avf_at_15: LEMMA
    step15F(q, x, y) OR step15G(q, x, y) IMPLIES 
      avf(q, y) = avf(q, x) + W

  avf_at_16: LEMMA
    step16(q, x, y) AND globinv(x) IMPLIES 
      avf(q, y) = avf(q, x) + cs

  avf_at_18: LEMMA
    step18(q, x, y) IMPLIES 
      avf(q, y) = avf(q, x) + exi

  avf_at_11_or_13: LEMMA
    step11(q, x, y) OR step13(q, x, y) IMPLIES 
      avf(q, y) = avf(q, x) 

  avf_constant_dif: LEMMA
    step(p, x, y) AND q /= p 
    IMPLIES avf(q, y) = avf(q, x)	 

  avf_ascends: LEMMA % 
    step(p, x, y) AND globinv(x) 
    IMPLIES avf(q, x) <= avf(q, y)

  savf(x): int =
    LET f = LAMBDA n: IF n < N THEN avf(enum_thread(n), x) ELSE 0 ENDIF
    IN sum(N, f)

  savf_LWB: LEMMA
    globinv(x) IMPLIES AA * sinc(x) <= savf(x)

  savf_UPB: LEMMA % 
    globinv(x) AND competing_leq(kk)(x)
    IMPLIES savf(x) <= AA * sinc(x) + kk * (AA - 1) 

  savf_ascends: LEMMA % 
    step(p, x, y) AND globinv(x)
    IMPLIES savf(x) <= savf(y) 

  savf_increases_fwd: LEMMA % 
    forward1(p)(x, y) AND globinv(x)
    IMPLIES savf(x) < savf(y) 

  savf_at_14: LEMMA
    step14(p, x, y) IMPLIES 
      savf(y) = savf(x) + D

  savf_at_15: LEMMA
    step15F(p, x, y) OR step15G(p, x, y) IMPLIES 
      savf(y) = savf(x) + W

  savf_at_16: LEMMA
    step16(p, x, y) AND globinv(x) IMPLIES 
      savf(y) = savf(x) + cs

  savf_at_18: LEMMA
    step18(p, x, y) IMPLIES 
      savf(y) = savf(x) + exi

  at_fwd(q)(x): bool =
    x`pc(q) = 12 OR x`pc(q) = 17 OR x`pc(q) = 19

  at_fwd_ensures: LEMMA % 
    leto(E1)(1, cap(leq(z, savf), at_fwd(q)), leq(z + 1, savf))

  some_at_fwd(x): bool =
    EXISTS q: at_fwd(q)(x)

  some_fwd_progress: LEMMA
    leto(E1)(1, cap(leq(z, savf), some_at_fwd), leq(z + 1, savf))

  savf_13_14_unless: LEMMA %
    unless(E1)(cap(leq(z, savf), between(q, 13, 14)), leq(z + D, savf))

  doorway_progress: LEMMA % use PSP0-rule % fails 
    ass_doorway IMPLIES 
      leto(E1)(D, cap(leq(z, savf), between(q, 13, 14)), leq(z + D, savf))

  some_doorway(x): bool =
    EXISTS q: 13 <= x`pc(q) AND x`pc(q) <= 14

  doorway_progress_1: LEMMA
    ass_doorway IMPLIES 
      leto(E1)(D, cap(leq(z, savf), some_doorway), leq(z + D, savf))

  cs_unless: LEMMA
    unless(E1)(cap(leq(z, savf), at(q, 16)), leq(z + cs, savf))

  cs_progress: LEMMA % use PSP0-rule
    ass_cs IMPLIES 
      leto(E1)(cs, cap(leq(z, savf), at(q, 16)), leq(z + cs, savf))

  some_cs(x): bool =
    EXISTS q: x`pc(q) = 16

  cs_progress_1: LEMMA
    ass_cs IMPLIES 
      leto(E1)(cs, cap(leq(z, savf), some_cs), leq(z + cs, savf))

  exi_unless: LEMMA
    unless(E1)(cap(leq(z, savf), at(q, 18)), leq(z + exi, savf))

  exi_progress: LEMMA % use PSP0-rule
    ass_exit IMPLIES 
      leto(E1)(exi, cap(leq(z, savf), at(q, 18)), leq(z + exi, savf))

  some_exit(x): bool =
    EXISTS q: x`pc(q) = 18

  exi_progress_1: LEMMA
    ass_exit IMPLIES 
      leto(E1)(exi, cap(leq(z, savf), some_exit), leq(z + exi, savf))

  waiting_unless: LEMMA
    unless(E1)(cap(leq(z, savf), cap(atlev(q, 15, k), mubot(path(q, k)))),
               leq(z + W, savf))

  waiting_progress_lev_mu: LEMMA % 
    ass_waiting IMPLIES 
      leto(E1)(W, cap(leq(z, savf), cap(atlev(q, 15, k), mubot(path(q, k)))),
               leq(z + W, savf))

  only_some_waiting(x): bool =
     (FORALL q: x`pc(q) = 11 OR x`pc(q) = 15)
     AND (EXISTS q: x`pc(q) = 15)

  waiting_progress: LEMMA  % sub-leto, disjunction rule, % 
      % minimum of levels at 15, kq1, iq4, iq1
    ass_waiting IMPLIES 
      leto(E1)(W, cap(leq(z, savf), only_some_waiting), leq(z + W, savf))

  allidle(x): bool =
    FORALL q: x`pc(q) = 11

  cover(i): set[state] =
    IF i = 0 THEN allidle 
    ELSIF i = 1 THEN some_doorway
    ELSIF i = 2 THEN only_some_waiting
    ELSIF i = 3 THEN some_exit
    ELSIF i = 4 THEN some_cs
    ELSE some_at_fwd ENDIF

  weight(r: posnat): posnat =
    IF r = 1 THEN D 
    ELSIF r = 2 THEN W
    ELSIF r = 3 THEN exi
    ELSIF r = 4 THEN cs
    ELSE 1 ENDIF 

  covering: LEMMA
    globinv(x) IMPLIES EXISTS i: cover(i)(x)

  disgrowth_cover: LEMMA % 
    ass_doorway AND ass_waiting AND ass_cs AND ass_exit 
    IMPLIES disgrowth(E1, savf, weight, cover)

  maxDWE: posnat =
    max(D, max(W, max(cs, exi)))

  eventual_growth_savf: LEMMA
    ass_doorway AND ass_waiting AND ass_cs AND ass_exit IMPLIES
      leto(E1)(n + maxDWE - 1, leq(z, savf), 
               cup(leq(z + n, savf), allidle) )

  eventual_growth_sinc: LEMMA
    ass_doorway AND ass_waiting AND ass_cs AND ass_exit IMPLIES
      leto(E1)(AA * i + kk * (AA - 1) + maxDWE - 1, 
               leq(z, sinc), 
               cup(leq(z + i, sinc), cup(allidle, neg(competing_leq(kk)))) )

END tournamentUnity1

$$$tournamentUnity1.prf
(tournamentUnity1
 (lvf_at_12 0
  (lvf_at_12-1 nil 3670745796
   ("" (expand "step12")
    (("" (skosimp)
      (("" (replaceh -1)
        (("" (lift-if)
          (("" (split)
            (("1" (flatten)
              (("1" (expand "lvf")
                (("1" (expand "goto")
                  (("1" (assert)
                    (("1" (expand "col")
                      (("1" (expand "iq0")
                        (("1" (case "x!1`level(q!1)=-1")
                          (("1" (replaceh -1) (("1" (assert) nil nil))
                            nil)
                           ("2" (assert) nil nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (flatten)
              (("2" (expand "lvf")
                (("2" (expand "goto")
                  (("2" (assert)
                    (("2" (expand "col") (("2" (propax) nil nil)) nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((goto const-decl "state" tournamentSafe0 nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (col const-decl "int" tournamentUnity1 nil)
    (- const-decl "[numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (digit type-eq-decl nil ctrees nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nzint_times_nzint_is_nzint application-judgement "nzint" integers
     nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (lvf const-decl "int" tournamentUnity1 nil)
    (step12 const-decl "bool" tournamentSafe0 nil))
   shostak))
 (lvf_at_16 0
  (lvf_at_16-1 nil 3670746215
   ("" (expand "step16")
    (("" (skosimp)
      (("" (replaceh -1)
        (("" (expand "lvf")
          (("" (expand "goto")
            (("" (assert)
              (("" (expand "lev1")
                (("" (assert)
                  (("" (expand "iq2") (("" (propax) nil nil)) nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((lvf const-decl "int" tournamentUnity1 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (iq2 const-decl "bool" tournamentSafe0 nil)
    (lev1 const-decl "int" tournamentUnity1 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil))
   shostak))
 (lvf_at_17 0
  (lvf_at_17-1 nil 3670746320
   ("" (expand "step17")
    (("" (skosimp)
      (("" (replaceh -1)
        (("" (lift-if)
          (("" (split)
            (("1" (flatten)
              (("1" (expand "lvf")
                (("1" (expand "goto")
                  (("1" (assert)
                    (("1" (expand "lev1") (("1" (assert) nil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (flatten)
              (("2" (expand "lvf")
                (("2" (expand "goto")
                  (("2" (assert)
                    (("2" (expand "iq0")
                      (("2" (assert)
                        (("2" (expand "lev1") (("2" (assert) nil nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((iq0 const-decl "bool" tournamentSafe0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (lev1 const-decl "int" tournamentUnity1 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (lvf const-decl "int" tournamentUnity1 nil)
    (step17 const-decl "bool" tournamentSafe0 nil))
   shostak))
 (lvf_bounded 0
  (lvf_bounded-5 nil 3678789736
   ("" (skosimp)
    (("" (split)
      (("1" (expand "lvf")
        (("1" (lift-if)
          (("1" (case "iq0(q!1, x!1)")
            (("1" (expand "iq0")
              (("1" (flatten)
                (("1" (lemma pos_times_le)
                  (("1" (split)
                    (("1" (flatten)
                      (("1" (inst?)
                        (("1" (assert)
                          (("1" (case "0 <= col(q!1, x!1)")
                            (("1" (assert)
                              (("1"
                                (assert)
                                (("1"
                                  (split)
                                  (("1"
                                    (flatten)
                                    (("1" (assert) nil nil))
                                    nil)
                                   ("2" (propax) nil nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (expand "col")
                              (("2" (assert) nil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (flatten)
                      (("2" (case "0 <= depth(q!1) * DW1")
                        (("1" (case "0 <= exi1 * lev1(q!1, x!1)")
                          (("1" (assert)
                            (("1" (split)
                              (("1" (propax) nil nil)
                               ("2"
                                (flatten)
                                (("2"
                                  (split)
                                  (("1"
                                    (flatten)
                                    (("1" (assert) nil nil))
                                    nil)
                                   ("2"
                                    (assert)
                                    (("2"
                                      (flatten)
                                      (("2" (assert) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (case "0 <= lev1(q!1, x!1)")
                            (("1" (inst?) (("1" (assert) nil nil)) nil)
                             ("2" (expand "lev1")
                              (("2" (assert) nil nil)) nil))
                            nil))
                          nil)
                         ("2" (hide-all-but (-1 1))
                          (("2" (inst?) (("2" (assert) nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (hide 2)
              (("2" (expand "globinv")
                (("2" (expand "iqall")
                  (("2" (flatten)
                    (("2" (inst?) (("2" (assert) nil nil)) nil)) nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (expand "AA")
        (("2" (expand "lvf")
          (("2" (lift-if)
            (("2" (split)
              (("1" (flatten)
                (("1" (split)
                  (("1" (flatten)
                    (("1" (case "col(q!1, x!1) <= depthnode - 1")
                      (("1" (lemma both_sides_times_pos_le1)
                        (("1" (inst?)
                          (("1" (inst - "depthnode - 1")
                            (("1" (assert)
                              (("1"
                                (case "1 + D <= DW1")
                                (("1" (assert) nil nil)
                                 ("2"
                                  (expand "DW1")
                                  (("2" (assert) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (expand "col")
                        (("2" (hide 2)
                          (("2" (use thread_depth)
                            (("2" (case "iq1(q!1, x!1)")
                              (("1"
                                (expand "iq1")
                                (("1" (assert) nil nil))
                                nil)
                               ("2"
                                (expand "globinv")
                                (("2"
                                  (expand "iqall")
                                  (("2"
                                    (flatten)
                                    (("2"
                                      (inst?)
                                      (("2" (assert) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (flatten)
                    (("2"
                      (case "col(q!1, x!1) * DW1 <= depthnode * DW1")
                      (("1" (split)
                        (("1" (flatten) (("1" (assert) nil nil)) nil)
                         ("2" (flatten) (("2" (assert) nil nil)) nil))
                        nil)
                       ("2" (hide 3)
                        (("2" (use both_sides_times_pos_le1)
                          (("2" (assert)
                            (("2" (use thread_depth)
                              (("2"
                                (case "iq0(q!1, x!1)")
                                (("1"
                                  (expand "iq0")
                                  (("1"
                                    (flatten)
                                    (("1"
                                      (hide 2 3)
                                      (("1"
                                        (expand "col")
                                        (("1" (assert) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (expand "globinv")
                                  (("2"
                                    (expand "iqall")
                                    (("2"
                                      (flatten)
                                      (("2"
                                        (inst?)
                                        (("2" (assert) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (flatten)
                (("2" (use thread_depth)
                  (("2" (lemma both_sides_times_pos_le2)
                    (("2" (split)
                      (("1" (flatten)
                        (("1" (inst - DW1 "depth(q!1)" " depthnode")
                          (("1" (assert) nil nil)) nil))
                        nil)
                       ("2" (flatten)
                        (("2" (split)
                          (("1" (flatten)
                            (("1" (case "lev1(q!1, x!1) <= depthnode")
                              (("1"
                                (inst-cp
                                 -
                                 exi1
                                 "lev1(q!1, x!1)"
                                 "depthnode")
                                (("1"
                                  (inst
                                   -
                                   DW1
                                   "depth(q!1)"
                                   "depthnode")
                                  (("1" (assert) nil nil))
                                  nil))
                                nil)
                               ("2"
                                (hide -2 2)
                                (("2"
                                  (expand "lev1")
                                  (("2"
                                    (case "iq0(q!1, x!1)")
                                    (("1"
                                      (expand "iq0")
                                      (("1"
                                        (flatten)
                                        (("1" (assert) nil nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (expand "globinv")
                                      (("2"
                                        (expand "iqall")
                                        (("2"
                                          (flatten)
                                          (("2"
                                            (inst?)
                                            (("2" (assert) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (flatten)
                            (("2"
                              (inst - "DW1 + exi1" "depth(q!1)"
                               "depthnode")
                              (("2" (assert) nil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((iqall const-decl "bool" tournamentSafe0 nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (pos_times_le formula-decl nil real_props nil)
    (exi1 const-decl "posnat" tournamentUnity0 nil)
    (lev1 const-decl "int" tournamentUnity1 nil)
    (depth const-decl "nat" ctrees nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (<= const-decl "bool" reals nil)
    (col const-decl "int" tournamentUnity1 nil)
    (DW1 const-decl "posnat" tournamentUnity1 nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (digit type-eq-decl nil ctrees nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (lvf const-decl "int" tournamentUnity1 nil)
    (depthnode const-decl "nat" ctrees nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (D const-decl "posnat" tournamentUnity0 nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (both_sides_times_pos_le1 formula-decl nil real_props nil)
    (iq1 const-decl "bool" tournamentSafe0 nil)
    (thread_depth formula-decl nil tournamentSafe0 nil)
    (both_sides_times_pos_le2 formula-decl nil real_props nil)
    (AA const-decl "posnat" tournamentUnity1 nil))
   nil)
  (lvf_bounded-4 nil 3678789708
   ("" (skosimp)
    (("" (split)
      (("1" (expand "lvf")
        (("1" (lift-if)
          (("1" (case "iq0(q!1, x!1)")
            (("1" (expand "iq0")
              (("1" (flatten)
                (("1" (lemma pos_times_le)
                  (("1" (split)
                    (("1" (flatten)
                      (("1" (inst?)
                        (("1" (assert)
                          (("1" (case "0 <= col(q!1, x!1)")
                            (("1" (assert)
                              (("1"
                                (assert)
                                (("1"
                                  (split)
                                  (("1" (flatten) (("1" (assert) nil)))
                                   ("2" (propax) nil)))))))
                             ("2" (expand "col")
                              (("2" (assert) nil)))))))))))
                     ("2" (flatten)
                      (("2" (case "0 <= depth(q!1) * DW1")
                        (("1" (case "0 <= exi1 * lev1(q!1, x!1)")
                          (("1" (assert)
                            (("1" (split)
                              (("1" (propax) nil)
                               ("2"
                                (flatten)
                                (("2"
                                  (split)
                                  (("1" (flatten) (("1" (assert) nil)))
                                   ("2"
                                    (assert)
                                    (("2"
                                      (flatten)
                                      (("2" (assert) nil)))))))))))))
                           ("2" (case "0 <= lev1(q!1, x!1)")
                            (("1" (inst?) (("1" (assert) nil)))
                             ("2" (expand "lev1")
                              (("2" (assert) nil)))))))
                         ("2" (hide-all-but (-1 1))
                          (("2" (inst?)
                            (("2" (assert) nil)))))))))))))))))
             ("2" (hide 2)
              (("2" (expand "globinv")
                (("2" (expand "iqall")
                  (("2" (flatten)
                    (("2" (inst?) (("2" (assert) nil)))))))))))))))))
       ("2" (expand "AA")
        (("2" (expand "lvf")
          (("2" (lift-if)
            (("2" (split)
              (("1" (flatten)
                (("1" (split)
                  (("1" (flatten)
                    (("1" (case "col(q!1, x!1) <= depthnode - 1")
                      (("1" (lemma both_sides_times_pos_le1)
                        (("1" (inst?)
                          (("1" (inst - "depth(pp) - 1")
                            (("1" (assert)
                              (("1"
                                (case "1 + D <= DW1")
                                (("1" (assert) nil)
                                 ("2"
                                  (expand "DW1")
                                  (("2" (assert) nil)))))))))))))
                       ("2" (expand "col")
                        (("2" (hide 2)
                          (("2" (use thread_depth)
                            (("2" (case "iq1(q!1, x!1)")
                              (("1"
                                (expand "iq1")
                                (("1" (assert) nil)))
                               ("2"
                                (expand "globinv")
                                (("2"
                                  (expand "iqall")
                                  (("2"
                                    (flatten)
                                    (("2"
                                      (inst?)
                                      (("2"
                                        (assert)
                                        nil)))))))))))))))))))))
                   ("2" (flatten)
                    (("2"
                      (case "col(q!1, x!1) * DW1 <= depthnode * DW1")
                      (("1" (split)
                        (("1" (flatten) (("1" (assert) nil)))
                         ("2" (flatten) (("2" (assert) nil)))))
                       ("2" (hide 3)
                        (("2" (use both_sides_times_pos_le1)
                          (("2" (assert)
                            (("2" (use thread_depth)
                              (("2"
                                (case "iq0(q!1, x!1)")
                                (("1"
                                  (expand "iq0")
                                  (("1"
                                    (flatten)
                                    (("1"
                                      (hide 2 3)
                                      (("1"
                                        (expand "col")
                                        (("1" (assert) nil)))))))))
                                 ("2"
                                  (expand "globinv")
                                  (("2"
                                    (expand "iqall")
                                    (("2"
                                      (flatten)
                                      (("2"
                                        (inst?)
                                        (("2"
                                          (assert)
                                          nil)))))))))))))))))))))))))))
               ("2" (flatten)
                (("2" (use thread_length_upb)
                  (("2" (case "depth(q!1) * DW1 <= depthnode * DW1")
                    (("1" (split)
                      (("1" (flatten)
                        (("1"
                          (case "exi1 * lev1(q!1, x!1) <= depthnode * exi1")
                          (("1" (assert) nil)
                           ("2" (hide 2 3 -2 -1)
                            (("2" (lemma both_sides_times_pos_le1)
                              (("2"
                                (inst
                                 -
                                 exi1
                                 "lev1(q!1, x!1)"
                                 "depthnode")
                                (("2"
                                  (assert)
                                  (("2"
                                    (expand "lev1")
                                    (("2"
                                      (case "iq0(q!1, x!1)")
                                      (("1"
                                        (expand "iq0")
                                        (("1"
                                          (flatten)
                                          (("1" (assert) nil)))))
                                       ("2"
                                        (expand "globinv")
                                        (("2"
                                          (expand "iqall")
                                          (("2"
                                            (flatten)
                                            (("2"
                                              (inst?)
                                              (("2"
                                                (assert)
                                                nil)))))))))))))))))))))))))
                       ("2" (flatten)
                        (("2" (split)
                          (("1" (flatten)
                            (("1" (case "lev1(q!1, x!1) <= depthnode")
                              (("1"
                                (lemma both_sides_times_pos_le1)
                                (("1"
                                  (inst
                                   -
                                   exi1
                                   "lev1(q!1, x!1)"
                                   "depthnode")
                                  (("1" (assert) nil)))))
                               ("2"
                                (case "iq0(q!1, x!1)")
                                (("1"
                                  (expand "iq0")
                                  (("1"
                                    (flatten)
                                    (("1"
                                      (expand "lev1")
                                      (("1" (assert) nil)))))))
                                 ("2"
                                  (expand "globinv")
                                  (("2"
                                    (expand "iqall")
                                    (("2"
                                      (flatten)
                                      (("2"
                                        (inst? -4)
                                        (("2"
                                          (assert)
                                          nil)))))))))))))))
                           ("2" (flatten)
                            (("2" (lemma both_sides_times_pos_le1)
                              (("2"
                                (inst - exi1 _ _)
                                (("2"
                                  (inst - "depth(q!1)" "depthnode")
                                  (("2" (assert) nil)))))))))))))))
                     ("2" (hide 2 3 -2)
                      (("2" (use both_sides_times_pos_le1)
                        (("2" (assert) nil))))))))))))))))))))))
    nil)
   nil nil)
  (lvf_bounded-3 nil 3678789542
   ("" (skosimp)
    (("" (split)
      (("1" (expand "lvf")
        (("1" (lift-if)
          (("1" (case "iq0(q!1, x!1)")
            (("1" (expand "iq0")
              (("1" (flatten)
                (("1" (lemma pos_times_le)
                  (("1" (split)
                    (("1" (flatten)
                      (("1" (inst?)
                        (("1" (assert)
                          (("1" (case "0 <= col(q!1, x!1)")
                            (("1" (assert)
                              (("1"
                                (assert)
                                (("1"
                                  (split)
                                  (("1" (flatten) (("1" (assert) nil)))
                                   ("2" (propax) nil)))))))
                             ("2" (expand "col")
                              (("2" (assert) nil)))))))))))
                     ("2" (flatten)
                      (("2" (case "0 <= depth(q!1) * DW1")
                        (("1" (case "0 <= exi1 * lev1(q!1, x!1)")
                          (("1" (assert)
                            (("1" (split)
                              (("1" (propax) nil)
                               ("2"
                                (flatten)
                                (("2"
                                  (split)
                                  (("1" (flatten) (("1" (assert) nil)))
                                   ("2"
                                    (assert)
                                    (("2"
                                      (flatten)
                                      (("2" (assert) nil)))))))))))))
                           ("2" (case "0 <= lev1(q!1, x!1)")
                            (("1" (inst?) (("1" (assert) nil)))
                             ("2" (expand "lev1")
                              (("2" (assert) nil)))))))
                         ("2" (hide-all-but (-1 1))
                          (("2" (inst?)
                            (("2" (assert) nil)))))))))))))))))
             ("2" (hide 2)
              (("2" (expand "globinv")
                (("2" (expand "iqall")
                  (("2" (flatten)
                    (("2" (inst?) (("2" (assert) nil)))))))))))))))))
       ("2" (expand "AA")
        (("2" (expand "lvf")
          (("2" (lift-if)
            (("2" (split)
              (("1" (flatten)
                (("1" (split)
                  (("1" (flatten)
                    (("1" (case "col(q!1, x!1) <= depth(pp) - 1")
                      (("1" (lemma both_sides_times_pos_le1)
                        (("1" (inst?)
                          (("1" (inst - "depth(pp) - 1")
                            (("1" (assert)
                              (("1"
                                (case "1 + D <= DW1")
                                (("1" (assert) nil)
                                 ("2"
                                  (expand "DW1")
                                  (("2" (assert) nil)))))))))))))
                       ("2" (expand "col")
                        (("2" (hide 2)
                          (("2" (use thread_depth)
                            (("2" (case "iq1(q!1, x!1)")
                              (("1"
                                (expand "iq1")
                                (("1" (assert) nil)))
                               ("2"
                                (expand "globinv")
                                (("2"
                                  (expand "iqall")
                                  (("2"
                                    (flatten)
                                    (("2"
                                      (inst?)
                                      (("2"
                                        (assert)
                                        nil)))))))))))))))))))))
                   ("2" (flatten)
                    (("2"
                      (case "col(q!1, x!1) * DW1 <= depth(pp) * DW1")
                      (("1" (split)
                        (("1" (flatten) (("1" (assert) nil)))
                         ("2" (flatten) (("2" (assert) nil)))))
                       ("2" (hide 3)
                        (("2" (use both_sides_times_pos_le1)
                          (("2" (assert)
                            (("2" (use thread_length_upb)
                              (("2"
                                (case "iq0(q!1, x!1)")
                                (("1"
                                  (expand "iq0")
                                  (("1"
                                    (flatten)
                                    (("1"
                                      (hide 2 3)
                                      (("1"
                                        (expand "col")
                                        (("1" (assert) nil)))))))))
                                 ("2"
                                  (expand "globinv")
                                  (("2"
                                    (expand "iqall")
                                    (("2"
                                      (flatten)
                                      (("2"
                                        (inst?)
                                        (("2"
                                          (assert)
                                          nil)))))))))))))))))))))))))))
               ("2" (flatten)
                (("2" (use thread_length_upb)
                  (("2" (case "depth(q!1) * DW1 <= depth(pp) * DW1")
                    (("1" (split)
                      (("1" (flatten)
                        (("1"
                          (case "exi1 * lev1(q!1, x!1) <= depth(pp) * exi1")
                          (("1" (assert) nil)
                           ("2" (hide 2 3 -2 -1)
                            (("2" (lemma both_sides_times_pos_le1)
                              (("2"
                                (inst
                                 -
                                 exi1
                                 "lev1(q!1, x!1)"
                                 "depth(pp)")
                                (("2"
                                  (assert)
                                  (("2"
                                    (expand "lev1")
                                    (("2"
                                      (case "iq0(q!1, x!1)")
                                      (("1"
                                        (expand "iq0")
                                        (("1"
                                          (flatten)
                                          (("1" (assert) nil)))))
                                       ("2"
                                        (expand "globinv")
                                        (("2"
                                          (expand "iqall")
                                          (("2"
                                            (flatten)
                                            (("2"
                                              (inst?)
                                              (("2"
                                                (assert)
                                                nil)))))))))))))))))))))))))
                       ("2" (flatten)
                        (("2" (split)
                          (("1" (flatten)
                            (("1" (case "lev1(q!1, x!1) <= depth(pp)")
                              (("1"
                                (lemma both_sides_times_pos_le1)
                                (("1"
                                  (inst
                                   -
                                   exi1
                                   "lev1(q!1, x!1)"
                                   "depth(pp)")
                                  (("1" (assert) nil)))))
                               ("2"
                                (case "iq0(q!1, x!1)")
                                (("1"
                                  (expand "iq0")
                                  (("1"
                                    (flatten)
                                    (("1"
                                      (expand "lev1")
                                      (("1" (assert) nil)))))))
                                 ("2"
                                  (expand "globinv")
                                  (("2"
                                    (expand "iqall")
                                    (("2"
                                      (flatten)
                                      (("2"
                                        (inst? -4)
                                        (("2"
                                          (assert)
                                          nil)))))))))))))))
                           ("2" (flatten)
                            (("2" (lemma both_sides_times_pos_le1)
                              (("2"
                                (inst - exi1 _ _)
                                (("2"
                                  (inst - "depth(q!1)" "depth(pp)")
                                  (("2" (assert) nil)))))))))))))))
                     ("2" (hide 2 3 -2)
                      (("2" (use both_sides_times_pos_le1)
                        (("2" (assert) nil))))))))))))))))))))))
    nil)
   nil nil)
  (lvf_bounded-2 nil 3678789401
   ("" (skosimp)
    (("" (split)
      (("1" (expand "lvf")
        (("1" (lift-if)
          (("1" (case "iq0(q!1, x!1)")
            (("1" (expand "iq0")
              (("1" (flatten)
                (("1" (lemma pos_times_le)
                  (("1" (split)
                    (("1" (flatten)
                      (("1" (inst?)
                        (("1" (assert)
                          (("1" (case "0 <= col(q!1, x!1)")
                            (("1" (assert)
                              (("1"
                                (assert)
                                (("1"
                                  (split)
                                  (("1" (flatten) (("1" (assert) nil)))
                                   ("2" (propax) nil)))))))
                             ("2" (expand "col")
                              (("2" (assert) nil)))))))))))
                     ("2" (flatten)
                      (("2" (case "0 <= depth(q!1) * DW1")
                        (("1" (case "0 <= exi1 * lev1(q!1, x!1)")
                          (("1" (assert)
                            (("1" (split)
                              (("1" (propax) nil)
                               ("2"
                                (flatten)
                                (("2"
                                  (split)
                                  (("1" (flatten) (("1" (assert) nil)))
                                   ("2"
                                    (assert)
                                    (("2"
                                      (flatten)
                                      (("2" (assert) nil)))))))))))))
                           ("2" (case "0 <= lev1(q!1, x!1)")
                            (("1" (inst?) (("1" (assert) nil)))
                             ("2" (expand "lev1")
                              (("2" (assert) nil)))))))
                         ("2" (hide-all-but (-1 1))
                          (("2" (inst?)
                            (("2" (assert) nil)))))))))))))))))
             ("2" (hide 2)
              (("2" (expand "globinv")
                (("2" (expand "iqall")
                  (("2" (flatten)
                    (("2" (inst?) (("2" (assert) nil)))))))))))))))))
       ("2" (expand "AA")
        (("2" (expand "lvf")
          (("2" (lift-if)
            (("2" (split)
              (("1" (flatten)
                (("1" (split)
                  (("1" (flatten)
                    (("1" (case "col(q!1, x!1) <= depth(pp) - 1")
                      (("1" (lemma both_sides_times_pos_le1)
                        (("1" (inst?)
                          (("1" (inst - "depth(pp) - 1")
                            (("1" (assert)
                              (("1"
                                (case "1 + D <= DW1")
                                (("1" (assert) nil)
                                 ("2"
                                  (expand "DW1")
                                  (("2" (assert) nil)))))))))))))
                       ("2" (expand "col")
                        (("2" (hide 2)
                          (("2" (use thread_length_upb)
                            (("2" (case "iq1(q!1, x!1)")
                              (("1"
                                (expand "iq1")
                                (("1" (assert) nil)))
                               ("2"
                                (expand "globinv")
                                (("2"
                                  (expand "iqall")
                                  (("2"
                                    (flatten)
                                    (("2"
                                      (inst?)
                                      (("2"
                                        (assert)
                                        nil)))))))))))))))))))))
                   ("2" (flatten)
                    (("2"
                      (case "col(q!1, x!1) * DW1 <= depth(pp) * DW1")
                      (("1" (split)
                        (("1" (flatten) (("1" (assert) nil)))
                         ("2" (flatten) (("2" (assert) nil)))))
                       ("2" (hide 3)
                        (("2" (use both_sides_times_pos_le1)
                          (("2" (assert)
                            (("2" (use thread_length_upb)
                              (("2"
                                (case "iq0(q!1, x!1)")
                                (("1"
                                  (expand "iq0")
                                  (("1"
                                    (flatten)
                                    (("1"
                                      (hide 2 3)
                                      (("1"
                                        (expand "col")
                                        (("1" (assert) nil)))))))))
                                 ("2"
                                  (expand "globinv")
                                  (("2"
                                    (expand "iqall")
                                    (("2"
                                      (flatten)
                                      (("2"
                                        (inst?)
                                        (("2"
                                          (assert)
                                          nil)))))))))))))))))))))))))))
               ("2" (flatten)
                (("2" (use thread_length_upb)
                  (("2" (case "depth(q!1) * DW1 <= depth(pp) * DW1")
                    (("1" (split)
                      (("1" (flatten)
                        (("1"
                          (case "exi1 * lev1(q!1, x!1) <= depth(pp) * exi1")
                          (("1" (assert) nil)
                           ("2" (hide 2 3 -2 -1)
                            (("2" (lemma both_sides_times_pos_le1)
                              (("2"
                                (inst
                                 -
                                 exi1
                                 "lev1(q!1, x!1)"
                                 "depth(pp)")
                                (("2"
                                  (assert)
                                  (("2"
                                    (expand "lev1")
                                    (("2"
                                      (case "iq0(q!1, x!1)")
                                      (("1"
                                        (expand "iq0")
                                        (("1"
                                          (flatten)
                                          (("1" (assert) nil)))))
                                       ("2"
                                        (expand "globinv")
                                        (("2"
                                          (expand "iqall")
                                          (("2"
                                            (flatten)
                                            (("2"
                                              (inst?)
                                              (("2"
                                                (assert)
                                                nil)))))))))))))))))))))))))
                       ("2" (flatten)
                        (("2" (split)
                          (("1" (flatten)
                            (("1" (case "lev1(q!1, x!1) <= depth(pp)")
                              (("1"
                                (lemma both_sides_times_pos_le1)
                                (("1"
                                  (inst
                                   -
                                   exi1
                                   "lev1(q!1, x!1)"
                                   "depth(pp)")
                                  (("1" (assert) nil)))))
                               ("2"
                                (case "iq0(q!1, x!1)")
                                (("1"
                                  (expand "iq0")
                                  (("1"
                                    (flatten)
                                    (("1"
                                      (expand "lev1")
                                      (("1" (assert) nil)))))))
                                 ("2"
                                  (expand "globinv")
                                  (("2"
                                    (expand "iqall")
                                    (("2"
                                      (flatten)
                                      (("2"
                                        (inst? -4)
                                        (("2"
                                          (assert)
                                          nil)))))))))))))))
                           ("2" (flatten)
                            (("2" (lemma both_sides_times_pos_le1)
                              (("2"
                                (inst - exi1 _ _)
                                (("2"
                                  (inst - "depth(q!1)" "depth(pp)")
                                  (("2" (assert) nil)))))))))))))))
                     ("2" (hide 2 3 -2)
                      (("2" (use both_sides_times_pos_le1)
                        (("2" (assert) nil))))))))))))))))))))))
    nil)
   nil nil)
  (lvf_bounded-1 nil 3670746925
   ("" (skosimp)
    (("" (split)
      (("1" (expand "lvf")
        (("1" (lift-if)
          (("1" (case "iq0(q!1, x!1)")
            (("1" (expand "iq0")
              (("1" (flatten)
                (("1" (lemma pos_times_le)
                  (("1" (split)
                    (("1" (flatten)
                      (("1" (inst?)
                        (("1" (assert)
                          (("1" (case "0 <= col(q!1, x!1)")
                            (("1" (assert)
                              (("1"
                                (assert)
                                (("1"
                                  (split)
                                  (("1"
                                    (flatten)
                                    (("1" (assert) nil nil))
                                    nil)
                                   ("2" (propax) nil nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (expand "col")
                              (("2" (assert) nil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (flatten)
                      (("2" (case "0 <= q!1`length * DW1")
                        (("1" (case "0 <= exi1 * lev1(q!1, x!1)")
                          (("1" (assert)
                            (("1" (split)
                              (("1" (propax) nil nil)
                               ("2"
                                (flatten)
                                (("2"
                                  (split)
                                  (("1"
                                    (flatten)
                                    (("1" (assert) nil nil))
                                    nil)
                                   ("2"
                                    (assert)
                                    (("2"
                                      (flatten)
                                      (("2" (assert) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (case "0 <= lev1(q!1, x!1)")
                            (("1" (inst?) (("1" (assert) nil nil)) nil)
                             ("2" (expand "lev1")
                              (("2" (assert) nil nil)) nil))
                            nil))
                          nil)
                         ("2" (hide-all-but (-1 1))
                          (("2" (inst?) (("2" (assert) nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (hide 2)
              (("2" (expand "globinv")
                (("2" (expand "iqall")
                  (("2" (flatten)
                    (("2" (inst?) (("2" (assert) nil nil)) nil)) nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (expand "AA")
        (("2" (expand "lvf")
          (("2" (lift-if)
            (("2" (split)
              (("1" (flatten)
                (("1" (split)
                  (("1" (flatten)
                    (("1" (case "col(q!1, x!1) <= depth(pp) - 1")
                      (("1" (lemma both_sides_times_pos_le1)
                        (("1" (inst?)
                          (("1" (inst - "depth(pp) - 1")
                            (("1" (assert)
                              (("1"
                                (case "1 + D <= DW1")
                                (("1" (assert) nil nil)
                                 ("2"
                                  (expand "DW1")
                                  (("2" (assert) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (expand "col")
                        (("2" (hide 2)
                          (("2" (use thread_length_upb)
                            (("2" (case "iq1(q!1, x!1)")
                              (("1"
                                (expand "iq1")
                                (("1" (assert) nil nil))
                                nil)
                               ("2"
                                (expand "globinv")
                                (("2"
                                  (expand "iqall")
                                  (("2"
                                    (flatten)
                                    (("2"
                                      (inst?)
                                      (("2" (assert) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("2" (flatten)
                    (("2"
                      (case "col(q!1, x!1) * DW1 <= depth(pp) * DW1")
                      (("1" (split)
                        (("1" (flatten) (("1" (assert) nil nil)) nil)
                         ("2" (flatten) (("2" (assert) nil nil)) nil))
                        nil)
                       ("2" (hide 3)
                        (("2" (use both_sides_times_pos_le1)
                          (("2" (assert)
                            (("2" (use thread_length_upb)
                              (("2"
                                (case "iq0(q!1, x!1)")
                                (("1"
                                  (expand "iq0")
                                  (("1"
                                    (flatten)
                                    (("1"
                                      (hide 2 3)
                                      (("1"
                                        (expand "col")
                                        (("1" (assert) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (expand "globinv")
                                  (("2"
                                    (expand "iqall")
                                    (("2"
                                      (flatten)
                                      (("2"
                                        (inst?)
                                        (("2" (assert) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (flatten)
                (("2" (use thread_length_upb)
                  (("2" (case "q!1`length * DW1 <= depth(pp) * DW1")
                    (("1" (split)
                      (("1" (flatten)
                        (("1"
                          (case "exi1 * lev1(q!1, x!1) <= depth(pp) * exi1")
                          (("1" (assert) nil nil)
                           ("2" (hide 2 3 -2 -1)
                            (("2" (lemma both_sides_times_pos_le1)
                              (("2"
                                (inst
                                 -
                                 exi1
                                 "lev1(q!1, x!1)"
                                 "depth(pp)")
                                (("2"
                                  (assert)
                                  (("2"
                                    (expand "lev1")
                                    (("2"
                                      (case "iq0(q!1, x!1)")
                                      (("1"
                                        (expand "iq0")
                                        (("1"
                                          (flatten)
                                          (("1" (assert) nil nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (expand "globinv")
                                        (("2"
                                          (expand "iqall")
                                          (("2"
                                            (flatten)
                                            (("2"
                                              (inst?)
                                              (("2" (assert) nil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (flatten)
                        (("2" (split)
                          (("1" (flatten)
                            (("1" (case "lev1(q!1, x!1) <= depth(pp)")
                              (("1"
                                (lemma both_sides_times_pos_le1)
                                (("1"
                                  (inst
                                   -
                                   exi1
                                   "lev1(q!1, x!1)"
                                   "depth(pp)")
                                  (("1" (assert) nil nil))
                                  nil))
                                nil)
                               ("2"
                                (case "iq0(q!1, x!1)")
                                (("1"
                                  (expand "iq0")
                                  (("1"
                                    (flatten)
                                    (("1"
                                      (expand "lev1")
                                      (("1" (assert) nil nil))
                                      nil))
                                    nil))
                                  nil)
                                 ("2"
                                  (expand "globinv")
                                  (("2"
                                    (expand "iqall")
                                    (("2"
                                      (flatten)
                                      (("2"
                                        (inst? -4)
                                        (("2" (assert) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (flatten)
                            (("2" (lemma both_sides_times_pos_le1)
                              (("2"
                                (inst - exi1 _ _)
                                (("2"
                                  (inst - "q!1`length" "depth(pp)")
                                  (("2" (assert) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide 2 3 -2)
                      (("2" (use both_sides_times_pos_le1)
                        (("2" (assert) nil nil)) nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((iqall const-decl "bool" tournamentSafe0 nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (pos_times_le formula-decl nil real_props nil)
    (exi1 const-decl "posnat" tournamentUnity0 nil)
    (lev1 const-decl "int" tournamentUnity1 nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (<= const-decl "bool" reals nil)
    (col const-decl "int" tournamentUnity1 nil)
    (DW1 const-decl "posnat" tournamentUnity1 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil) (< const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (lvf const-decl "int" tournamentUnity1 nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (D const-decl "posnat" tournamentUnity0 nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (both_sides_times_pos_le1 formula-decl nil real_props nil)
    (iq1 const-decl "bool" tournamentSafe0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (AA const-decl "posnat" tournamentUnity1 nil))
   shostak))
 (avf_bounded 0
  (avf_bounded-1 nil 3670767349
   ("" (skosimp)
    (("" (expand "avf")
      (("" (use lvf_bounded)
        (("" (assert) (("" (flatten) (("" (assert) nil nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (avf const-decl "int" tournamentUnity1 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (digit type-eq-decl nil ctrees nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (lvf_bounded formula-decl nil tournamentUnity1 nil))
   shostak))
 (avf_increases_fwd 0
  (avf_increases_fwd-1 nil 3670757985
   ("" (skosimp)
    (("" (case "step19(q!1, x!1, y!1)")
      (("1" (expand "avf")
        (("1" (use lvf_bounded)
          (("1" (use lvf_bounded (x y!1))
            (("1" (assert)
              (("1" (split)
                (("1" (flatten)
                  (("1" (hide -2 -3)
                    (("1" (case "y!1`cnt(q!1) = 1 + x!1`cnt(q!1)")
                      (("1" (replaceh -1) (("1" (assert) nil nil)) nil)
                       ("2" (expand "step19")
                        (("2" (flatten)
                          (("2" (replaceh -3)
                            (("2" (hide-all-but 1)
                              (("2"
                                (expand "next19")
                                (("2" (propax) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (case "step(q!1, x!1, y!1)")
                  (("1" (hide -2 -3 -4 2)
                    (("1" (use globinv_step) (("1" (assert) nil nil))
                      nil))
                    nil)
                   ("2" (expand "step") (("2" (propax) nil nil)) nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (expand "forward1")
        (("2" (assert)
          (("2" (hide 1)
            (("2" (expand "avf")
              (("2" (case "y!1`cnt(q!1) = x!1`cnt(q!1)")
                (("1" (replaceh -1)
                  (("1" (case "iq0(q!1, x!1)")
                    (("1" (use lvf_at_12)
                      (("1" (use lvf_at_16)
                        (("1" (use lvf_at_17) (("1" (assert) nil nil))
                          nil))
                        nil))
                      nil)
                     ("2" (expand "globinv")
                      (("2" (expand "iqall")
                        (("2" (flatten)
                          (("2" (inst?) (("2" (assert) nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (hide -2 2) (("2" (grind) nil nil)) nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((Thread type-eq-decl nil tournamentUnity0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (digit type-eq-decl nil ctrees nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (lvf_bounded formula-decl nil tournamentUnity1 nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (globinv_step formula-decl nil tournamentSafe1 nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (avf const-decl "int" tournamentUnity1 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (lvf_at_12 formula-decl nil tournamentUnity1 nil)
    (lvf_at_17 formula-decl nil tournamentUnity1 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (lvf_at_16 formula-decl nil tournamentUnity1 nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (forward1 const-decl "bool" tournamentUnity0 nil))
   shostak))
 (avf_at_14 0
  (avf_at_14-1 nil 3670758575
   ("" (expand "step14")
    (("" (expand "avf")
      (("" (expand "lvf")
        (("" (skosimp)
          (("" (replaceh -1)
            (("" (expand "next14")
              (("" (expand "col") (("" (assert) nil nil)) nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (avf const-decl "int" tournamentUnity1 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (col const-decl "int" tournamentUnity1 nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (lvf const-decl "int" tournamentUnity1 nil)
    (step14 const-decl "bool" tournamentSafe0 nil))
   shostak))
 (avf_at_15 0
  (avf_at_15-1 nil 3670758716
   ("" (skosimp)
    (("" (case "y!1 = next15(q!1, x!1) AND x!1`pc(q!1) = 15")
      (("1" (flatten)
        (("1" (hide -3)
          (("1" (expand "avf")
            (("1" (replaceh -1)
              (("1" (expand "lvf")
                (("1" (expand "next15")
                  (("1" (assert)
                    (("1" (expand "col")
                      (("1" (expand "DW1") (("1" (propax) nil nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (hide 2)
        (("2" (split)
          (("1" (expand "step15F")
            (("1" (assert)
              (("1" (expand "step15G") (("1" (propax) nil nil)) nil))
              nil))
            nil)
           ("2" (expand "step15F")
            (("2" (expand "step15G") (("2" (assert) nil nil)) nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((Thread type-eq-decl nil tournamentUnity0 nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (digit type-eq-decl nil ctrees nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (col const-decl "int" tournamentUnity1 nil)
    (DW1 const-decl "posnat" tournamentUnity1 nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (lvf const-decl "int" tournamentUnity1 nil)
    (avf const-decl "int" tournamentUnity1 nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (step15F const-decl "bool" tournamentSafe0 nil))
   shostak))
 (avf_at_16 0
  (avf_at_16-1 nil 3671700636
   ("" (skosimp)
    (("" (expand "avf")
      (("" (case "y!1`cnt(q!1) = x!1`cnt(q!1)")
        (("1" (replaceh -1)
          (("1" (use lvf_at_16)
            (("1" (assert)
              (("1" (expand "globinv")
                (("1" (expand "iqall")
                  (("1" (flatten)
                    (("1" (inst?) (("1" (assert) nil nil)) nil)) nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (expand "step16")
          (("2" (flatten)
            (("2" (replaceh -1)
              (("2" (expand "goto") (("2" (propax) nil nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((avf const-decl "int" tournamentUnity1 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (lvf_at_16 formula-decl nil tournamentUnity1 nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (digit type-eq-decl nil ctrees nil) (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil))
   shostak))
 (avf_at_18 0
  (avf_at_18-1 nil 3670758920
   ("" (expand "step18")
    (("" (skosimp)
      (("" (replaceh -1)
        (("" (expand "avf")
          (("" (expand "lvf")
            (("" (expand "next18")
              (("" (expand "lev1")
                (("" (assert)
                  (("" (expand "exi1") (("" (assert) nil nil)) nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((avf const-decl "int" tournamentUnity1 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (exi1 const-decl "posnat" tournamentUnity0 nil)
    (lev1 const-decl "int" tournamentUnity1 nil)
    (lvf const-decl "int" tournamentUnity1 nil)
    (step18 const-decl "bool" tournamentSafe0 nil))
   shostak))
 (avf_at_11_or_13 0
  (avf_at_11_or_13-1 nil 3670759044
   ("" (skosimp)
    (("" (split)
      (("1" (expand "step11")
        (("1" (flatten)
          (("1" (replaceh -1)
            (("1" (expand "avf")
              (("1" (expand "next11")
                (("1" (expand "lvf")
                  (("1" (expand "col") (("1" (assert) nil nil)) nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (expand "step13")
        (("2" (flatten)
          (("2" (replaceh -1)
            (("2" (expand "avf")
              (("2" (expand "lvf")
                (("2" (expand "next13")
                  (("2" (expand "col") (("2" (assert) nil nil)) nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((avf const-decl "int" tournamentUnity1 nil)
    (lvf const-decl "int" tournamentUnity1 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (col const-decl "int" tournamentUnity1 nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (step13 const-decl "bool" tournamentSafe0 nil))
   shostak))
 (avf_constant_dif 0
  (avf_constant_dif-1 nil 3670759215
   ("" (skosimp)
    (("" (expand "avf")
      (("" (expand "lvf")
        ((""
          (case "col(q!1, y!1) = col(q!1, x!1) AND lev1(q!1, y!1) = lev1(q!1, x!1)
AND y!1`pc(q!1) = x!1`pc(q!1)")
          (("1" (flatten)
            (("1" (replace* -1 -2 -3)
              (("1" (assert)
                (("1" (hide -1 -2 -3) (("1" (grind) nil nil)) nil))
                nil))
              nil))
            nil)
           ("2" (hide 3)
            (("2" (split)
              (("1" (expand "col") (("1" (grind) nil nil)) nil)
               ("2" (expand "lev1") (("2" (grind) nil nil)) nil)
               ("3" (grind) nil nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((avf const-decl "int" tournamentUnity1 nil)
    (lev1 const-decl "int" tournamentUnity1 nil)
    (col const-decl "int" tournamentUnity1 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (digit type-eq-decl nil ctrees nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (number nonempty-type-decl nil numbers nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (real_times_real_is_real application-judgement "real" reals nil)
    (real_plus_real_is_real application-judgement "real" reals nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (fullset const-decl "set" sets nil)
    (remove const-decl "set" sets nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (maximum def-decl "nat" maxfinset nil)
    (depthnode const-decl "nat" ctrees nil)
    (DW1 const-decl "posnat" tournamentUnity1 nil)
    (exi1 const-decl "posnat" tournamentUnity0 nil)
    (AA const-decl "posnat" tournamentUnity1 nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (nat_max application-judgement "{k: nat | i <= k AND j <= k}"
     real_defs nil)
    (nonneg_rat_max application-judgement
     "{s: nonneg_rat | s >= q AND s >= r}" real_defs nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (lvf const-decl "int" tournamentUnity1 nil))
   shostak))
 (avf_ascends 0
  (avf_ascends-2 nil 3671700764
   ("" (skosimp)
    (("" (use avf_constant_dif)
      (("" (assert)
        (("" (flatten)
          (("" (replaceh -1)
            (("" (use avf_increases_fwd (y y!1))
              (("" (assert)
                (("" (expand "forward1")
                  (("" (expand "step")
                    (("" (flatten)
                      (("" (assert)
                        (("" (hide-all-but 5 +)
                          (("" (use avf_at_11_or_13)
                            (("" (use avf_at_14)
                              ((""
                                (use avf_at_15)
                                ((""
                                  (use avf_at_16)
                                  ((""
                                    (use avf_at_18)
                                    (("" (ground) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((avf_constant_dif formula-decl nil tournamentUnity1 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (digit type-eq-decl nil ctrees nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (avf_increases_fwd formula-decl nil tournamentUnity1 nil)
    (forward1 const-decl "bool" tournamentUnity0 nil)
    (avf_at_14 formula-decl nil tournamentUnity1 nil)
    (avf_at_16 formula-decl nil tournamentUnity1 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (avf_at_18 formula-decl nil tournamentUnity1 nil)
    (avf_at_15 formula-decl nil tournamentUnity1 nil)
    (avf_at_11_or_13 formula-decl nil tournamentUnity1 nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   nil)
  (avf_ascends-1 nil 3670759512
   ("" (skosimp)
    (("" (use avf_constant_dif)
      (("" (assert)
        (("" (flatten)
          (("" (replaceh -1)
            (("" (use avf_increases_fwd (y y!1))
              (("" (assert)
                (("" (expand "forward1")
                  (("" (expand "step")
                    (("" (flatten)
                      (("" (assert)
                        (("" (hide-all-but 5 +)
                          (("" (use avf_at_11_or_13)
                            (("" (use avf_at_14)
                              ((""
                                (use avf_at_15)
                                ((""
                                  (use avf_at_18)
                                  (("" (ground) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((avf_constant_dif formula-decl nil tournamentUnity1 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (avf_increases_fwd formula-decl nil tournamentUnity1 nil)
    (forward1 const-decl "bool" tournamentUnity0 nil)
    (avf_at_14 formula-decl nil tournamentUnity1 nil)
    (avf_at_18 formula-decl nil tournamentUnity1 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (avf_at_15 formula-decl nil tournamentUnity1 nil)
    (avf_at_11_or_13 formula-decl nil tournamentUnity1 nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil))
   shostak))
 (savf_LWB 0
  (savf_LWB-1 nil 3670767419
   ("" (skosimp)
    (("" (expand "sinc")
      (("" (expand "savf")
        ((""
          (name-replace ff
           "LAMBDA n: IF n < N THEN x!1`cnt(enum_thread(n)) ELSE 0 ENDIF")
          ((""
            (name-replace gg
             "LAMBDA n: IF n < N THEN avf(enum_thread(n), x!1) ELSE 0 ENDIF")
            (("" (use sum_distributive)
              (("" (replace -1 + rl)
                (("" (hide -1)
                  (("" (use sum_monotonic)
                    (("" (assert)
                      (("" (hide 2)
                        (("" (skosimp)
                          (("" (expand "*")
                            (("" (expand "ff")
                              ((""
                                (expand "gg")
                                ((""
                                  (assert)
                                  ((""
                                    (use avf_bounded)
                                    (("" (assert) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((sinc const-decl "int" tournamentUnity0 nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (< const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (N const-decl "posnat" tournamentSafe0 nil)
    (digit type-eq-decl nil ctrees nil) (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (below type-eq-decl nil nat_types nil)
    (bijective? const-decl "bool" functions nil)
    (enum_thread const-decl "(bijective?[below[N], (thread)])"
     tournamentSafe0 nil)
    (sum_distributive formula-decl nil intsum nil)
    (AA const-decl "posnat" tournamentUnity1 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (ff skolem-const-decl "[nat -> nat]" tournamentUnity1 nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (avf_bounded formula-decl nil tournamentUnity1 nil)
    (gg skolem-const-decl "[nat -> int]" tournamentUnity1 nil)
    (* const-decl "[nat -> int]" intsum nil)
    (sum_monotonic formula-decl nil intsum nil)
    (avf const-decl "int" tournamentUnity1 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (savf const-decl "int" tournamentUnity1 nil))
   shostak))
 (savf_UPB 0
  (savf_UPB-5 nil 3678791159
   ("" (skosimp)
    (("" (expand "savf")
      (("" (expand "competing_leq")
        (("" (expand "sinc")
          ((""
            (name-replace ff
             "LAMBDA n: IF n < N THEN avf(enum_thread(n), x!1) ELSE 0 ENDIF")
            ((""
              (name-replace gg
               "LAMBDA n: IF n < N THEN x!1`cnt(enum_thread(n)) ELSE 0 ENDIF")
              ((""
                (name ecomp
                      "{k | k < N AND x!1`competing(enum_thread(k)) }")
                (("" (name hh "AA * gg + (AA-1) * char(ecomp)")
                  ((""
                    (case "sum(N, hh) <= AA * sum(N, gg) + AA * kk!1 - kk!1 ")
                    (("1" (case "sum(N, ff) <= sum(N, hh)")
                      (("1" (assert) nil nil)
                       ("2" (hide -1 2)
                        (("2" (use sum_monotonic)
                          (("2" (assert)
                            (("2" (hide 2)
                              (("2"
                                (skosimp)
                                (("2"
                                  (hide -2)
                                  (("2"
                                    (expand "ff")
                                    (("2"
                                      (expand "hh")
                                      (("2"
                                        (assert)
                                        (("2"
                                          (expand "+ ")
                                          (("2"
                                            (expand "gg")
                                            (("2"
                                              (expand "*")
                                              (("2"
                                                (expand "char")
                                                (("2"
                                                  (lift-if)
                                                  (("2"
                                                    (split)
                                                    (("1"
                                                      (flatten)
                                                      (("1"
                                                        (hide -3)
                                                        (("1"
                                                          (expand
                                                           "ecomp")
                                                          (("1"
                                                            (name-replace
                                                             qq
                                                             "enum_thread(i!1)")
                                                            (("1"
                                                              (use
                                                               avf_bounded)
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (flatten)
                                                      (("2"
                                                        (expand
                                                         "ecomp")
                                                        (("2"
                                                          (hide -2)
                                                          (("2"
                                                            (name-replace
                                                             qq
                                                             "enum_thread(i!1)")
                                                            (("2"
                                                              (case
                                                               "kq5(qq, x!1)")
                                                              (("1"
                                                                (expand
                                                                 "kq5")
                                                                (("1"
                                                                  (replaceh
                                                                   -1)
                                                                  (("1"
                                                                    (flatten)
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (expand
                                                                         "avf")
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (expand
                                                                             "lvf")
                                                                            (("1"
                                                                              (case
                                                                               "col(qq, x!1)=0")
                                                                              (("1"
                                                                                (assert)
                                                                                nil
                                                                                nil)
                                                                               ("2"
                                                                                (hide
                                                                                 2)
                                                                                (("2"
                                                                                  (expand
                                                                                   "col")
                                                                                  (("2"
                                                                                    (case
                                                                                     "iq0(qq, x!1) AND iq4(qq, x!1)")
                                                                                    (("1"
                                                                                      (flatten)
                                                                                      (("1"
                                                                                        (expand
                                                                                         "iq0")
                                                                                        (("1"
                                                                                          (expand
                                                                                           "iq4")
                                                                                          (("1"
                                                                                            (flatten)
                                                                                            (("1"
                                                                                              (assert)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (expand
                                                                                       "globinv")
                                                                                      (("2"
                                                                                        (expand
                                                                                         "kqall")
                                                                                        (("2"
                                                                                          (flatten)
                                                                                          (("2"
                                                                                            (inst?)
                                                                                            (("2"
                                                                                              (flatten)
                                                                                              (("2"
                                                                                                (assert)
                                                                                                (("2"
                                                                                                  (expand
                                                                                                   "iqall")
                                                                                                  (("2"
                                                                                                    (flatten)
                                                                                                    (("2"
                                                                                                      (inst?)
                                                                                                      (("2"
                                                                                                        (assert)
                                                                                                        (("2"
                                                                                                          (flatten)
                                                                                                          (("2"
                                                                                                            (assert)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (expand
                                                                 "globinv")
                                                                (("2"
                                                                  (expand
                                                                   "kqall")
                                                                  (("2"
                                                                    (flatten)
                                                                    (("2"
                                                                      (inst?)
                                                                      (("2"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide 2)
                      (("2" (expand "hh")
                        (("2" (hide -1)
                          (("2" (use sum_homomorphic)
                            (("2" (replaceh -1)
                              (("2"
                                (use sum_distributive)
                                (("2"
                                  (replaceh -1)
                                  (("2"
                                    (assert)
                                    (("2"
                                      (use sum_distributive)
                                      (("2"
                                        (replaceh -1)
                                        (("2"
                                          (use sum_char)
                                          (("2"
                                            (use sum_char)
                                            (("2"
                                              (replaceh -1)
                                              (("2"
                                                (case
                                                 "(AA - 1) * card(trunc(N, ecomp)) <= AA * kk!1 - kk!1")
                                                (("1" (assert) nil nil)
                                                 ("2"
                                                  (hide 2)
                                                  (("2"
                                                    (lemma
                                                     both_sides_times_pos_le2)
                                                    (("2"
                                                      (inst
                                                       -
                                                       "AA-1"
                                                       "card(trunc(N, ecomp))"
                                                       kk!1)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (hide 2)
                                                          (("1"
                                                            (hide
                                                             -1
                                                             -2)
                                                            (("1"
                                                              (name
                                                               NC
                                                               "card(x!1`competing)")
                                                              (("1"
                                                                (lemma
                                                                 inj_Card[node])
                                                                (("1"
                                                                  (inst?)
                                                                  (("1"
                                                                    (inst
                                                                     -
                                                                     NC)
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (skolem!)
                                                                        (("1"
                                                                          (lemma
                                                                           Card_injection[nat])
                                                                          (("1"
                                                                            (inst
                                                                             -
                                                                             _
                                                                             NC)
                                                                            (("1"
                                                                              (inst
                                                                               -
                                                                               "trunc(N, ecomp)")
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (hide
                                                                                   2)
                                                                                  (("1"
                                                                                    (inst
                                                                                     +
                                                                                     "lambda (i: (trunc(N, ecomp))): f!1(enum_thread(i))")
                                                                                    (("1"
                                                                                      (expand
                                                                                       "injective?")
                                                                                      (("1"
                                                                                        (skosimp)
                                                                                        (("1"
                                                                                          (inst?)
                                                                                          (("1"
                                                                                            (assert)
                                                                                            (("1"
                                                                                              (typepred
                                                                                               enum_thread)
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "bijective?")
                                                                                                (("1"
                                                                                                  (flatten)
                                                                                                  (("1"
                                                                                                    (expand
                                                                                                     "injective?")
                                                                                                    (("1"
                                                                                                      (hide
                                                                                                       -2
                                                                                                       -3)
                                                                                                      (("1"
                                                                                                        (inst?)
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (skosimp)
                                                                                      (("2"
                                                                                        (typepred
                                                                                         i!1)
                                                                                        (("2"
                                                                                          (expand
                                                                                           "trunc")
                                                                                          (("2"
                                                                                            (expand
                                                                                             "ecomp")
                                                                                            (("2"
                                                                                              (assert)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("3"
                                                                                      (skosimp)
                                                                                      (("3"
                                                                                        (typepred
                                                                                         i!1)
                                                                                        (("3"
                                                                                          (expand
                                                                                           "trunc")
                                                                                          (("3"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((minus_odd_is_odd application-judgement "odd_int" integers nil)
    (savf const-decl "int" tournamentUnity1 nil)
    (sinc const-decl "int" tournamentUnity0 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (+ const-decl "[nat -> int]" intsum nil)
    (* const-decl "[nat -> int]" intsum nil)
    (AA const-decl "posnat" tournamentUnity1 nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (pred type-eq-decl nil defined_types nil)
    (char const-decl "int" intsum nil)
    (sum_char formula-decl nil intsum nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (Card_injection formula-decl nil finite_sets nil)
    (injective? const-decl "bool" functions nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (x!1 skolem-const-decl "state[degree, node]" tournamentUnity1 nil)
    (inj_Card formula-decl nil finite_sets nil)
    (both_sides_times_pos_le2 formula-decl nil real_props nil)
    (trunc const-decl "finite_set[nat]" intsum nil)
    (card const-decl "{n: nat | n = Card(S)}" finite_sets nil)
    (Card const-decl "nat" finite_sets nil)
    (sum_distributive formula-decl nil intsum nil)
    (sum_homomorphic formula-decl nil intsum nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (sum_monotonic formula-decl nil intsum nil)
    (hh skolem-const-decl "[nat -> int]" tournamentUnity1 nil)
    (kq5 const-decl "bool" tournamentSafe0 nil)
    (int_times_even_is_even application-judgement "even_int" integers
     nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (col const-decl "int" tournamentUnity1 nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (kqall const-decl "bool" tournamentSafe0 nil)
    (iq4 const-decl "bool" tournamentSafe0 nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (lvf const-decl "int" tournamentUnity1 nil)
    (ecomp skolem-const-decl "[nat -> boolean]" tournamentUnity1 nil)
    (avf_bounded formula-decl nil tournamentUnity1 nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (gg skolem-const-decl "[nat -> nat]" tournamentUnity1 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (ff skolem-const-decl "[nat -> int]" tournamentUnity1 nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (sum def-decl "int" intsum nil) (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (enum_thread const-decl "(bijective?[below[N], (thread)])"
     tournamentSafe0 nil)
    (bijective? const-decl "bool" functions nil)
    (below type-eq-decl nil nat_types nil)
    (avf const-decl "int" tournamentUnity1 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (digit type-eq-decl nil ctrees nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (N const-decl "posnat" tournamentSafe0 nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (competing_leq const-decl "bool" tournamentUnity0 nil))
   nil)
  (savf_UPB-4 nil 3670773043
   ("" (skosimp)
    (("" (expand "savf")
      (("" (expand "competing_leq")
        (("" (expand "sinc")
          ((""
            (name-replace ff
             "LAMBDA n: IF n < N THEN avf(enum_thread(n), x!1) ELSE 0 ENDIF")
            ((""
              (name-replace gg
               "LAMBDA n: IF n < N THEN x!1`cnt(enum_thread(n)) ELSE 0 ENDIF")
              ((""
                (name ecomp
                      "{k | k < N AND x!1`competing(enum_thread(k)) }")
                (("" (name hh "AA * gg + (AA-1) * char(ecomp)")
                  ((""
                    (case "sum(N, hh) <= AA * sum(N, gg) + AA * kk!1 - kk!1 ")
                    (("1" (case "sum(N, ff) <= sum(N, hh)")
                      (("1" (assert) nil nil)
                       ("2" (hide -1 2)
                        (("2" (use sum_monotonic)
                          (("2" (assert)
                            (("2" (hide 2)
                              (("2"
                                (skosimp)
                                (("2"
                                  (hide -2)
                                  (("2"
                                    (expand "ff")
                                    (("2"
                                      (expand "hh")
                                      (("2"
                                        (assert)
                                        (("2"
                                          (expand "+ ")
                                          (("2"
                                            (expand "gg")
                                            (("2"
                                              (expand "*")
                                              (("2"
                                                (expand "char")
                                                (("2"
                                                  (lift-if)
                                                  (("2"
                                                    (split)
                                                    (("1"
                                                      (flatten)
                                                      (("1"
                                                        (hide -3)
                                                        (("1"
                                                          (expand
                                                           "ecomp")
                                                          (("1"
                                                            (name-replace
                                                             qq
                                                             "enum_thread(i!1)")
                                                            (("1"
                                                              (use
                                                               avf_bounded)
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (flatten)
                                                      (("2"
                                                        (expand
                                                         "ecomp")
                                                        (("2"
                                                          (hide -2)
                                                          (("2"
                                                            (name-replace
                                                             qq
                                                             "enum_thread(i!1)")
                                                            (("2"
                                                              (case
                                                               "kq5(qq, x!1)")
                                                              (("1"
                                                                (expand
                                                                 "kq5")
                                                                (("1"
                                                                  (replaceh
                                                                   -1)
                                                                  (("1"
                                                                    (flatten)
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (expand
                                                                         "avf")
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (expand
                                                                             "lvf")
                                                                            (("1"
                                                                              (case
                                                                               "col(qq, x!1)=0")
                                                                              (("1"
                                                                                (assert)
                                                                                nil
                                                                                nil)
                                                                               ("2"
                                                                                (hide
                                                                                 2)
                                                                                (("2"
                                                                                  (expand
                                                                                   "col")
                                                                                  (("2"
                                                                                    (case
                                                                                     "iq0(qq, x!1) AND iq4(qq, x!1)")
                                                                                    (("1"
                                                                                      (flatten)
                                                                                      (("1"
                                                                                        (expand
                                                                                         "iq0")
                                                                                        (("1"
                                                                                          (expand
                                                                                           "iq4")
                                                                                          (("1"
                                                                                            (flatten)
                                                                                            (("1"
                                                                                              (assert)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (expand
                                                                                       "globinv")
                                                                                      (("2"
                                                                                        (expand
                                                                                         "kqall")
                                                                                        (("2"
                                                                                          (flatten)
                                                                                          (("2"
                                                                                            (inst?)
                                                                                            (("2"
                                                                                              (flatten)
                                                                                              (("2"
                                                                                                (assert)
                                                                                                (("2"
                                                                                                  (expand
                                                                                                   "iqall")
                                                                                                  (("2"
                                                                                                    (flatten)
                                                                                                    (("2"
                                                                                                      (inst?)
                                                                                                      (("2"
                                                                                                        (assert)
                                                                                                        (("2"
                                                                                                          (flatten)
                                                                                                          (("2"
                                                                                                            (assert)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (expand
                                                                 "globinv")
                                                                (("2"
                                                                  (expand
                                                                   "kqall")
                                                                  (("2"
                                                                    (flatten)
                                                                    (("2"
                                                                      (inst?)
                                                                      (("2"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide 2)
                      (("2" (expand "hh")
                        (("2" (hide -1)
                          (("2" (use sum_homomorphic)
                            (("2" (replaceh -1)
                              (("2"
                                (use sum_distributive)
                                (("2"
                                  (replaceh -1)
                                  (("2"
                                    (assert)
                                    (("2"
                                      (use sum_distributive)
                                      (("2"
                                        (replaceh -1)
                                        (("2"
                                          (use sum_char)
                                          (("2"
                                            (use sum_char)
                                            (("2"
                                              (replaceh -1)
                                              (("2"
                                                (case
                                                 "(AA - 1) * card(trunc(N, ecomp)) <= AA * kk!1 - kk!1")
                                                (("1" (assert) nil nil)
                                                 ("2"
                                                  (hide 2)
                                                  (("2"
                                                    (lemma
                                                     both_sides_times_pos_le2)
                                                    (("2"
                                                      (inst
                                                       -
                                                       "AA-1"
                                                       "card(trunc(N, ecomp))"
                                                       kk!1)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (hide 2)
                                                          (("1"
                                                            (hide
                                                             -1
                                                             -2)
                                                            (("1"
                                                              (name
                                                               NC
                                                               "card(x!1`competing)")
                                                              (("1"
                                                                (lemma
                                                                 inj_Card[digseq])
                                                                (("1"
                                                                  (inst?)
                                                                  (("1"
                                                                    (inst
                                                                     -
                                                                     NC)
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (skolem!)
                                                                        (("1"
                                                                          (lemma
                                                                           Card_injection[nat])
                                                                          (("1"
                                                                            (inst
                                                                             -
                                                                             _
                                                                             NC)
                                                                            (("1"
                                                                              (inst
                                                                               -
                                                                               "trunc(N, ecomp)")
                                                                              (("1"
                                                                                (assert)
                                                                                (("1"
                                                                                  (hide
                                                                                   2)
                                                                                  (("1"
                                                                                    (inst
                                                                                     +
                                                                                     "lambda (i: (trunc(N, ecomp))): f!1(enum_thread(i))")
                                                                                    (("1"
                                                                                      (expand
                                                                                       "injective?")
                                                                                      (("1"
                                                                                        (skosimp)
                                                                                        (("1"
                                                                                          (inst?)
                                                                                          (("1"
                                                                                            (assert)
                                                                                            (("1"
                                                                                              (typepred
                                                                                               enum_thread)
                                                                                              (("1"
                                                                                                (expand
                                                                                                 "bijective?")
                                                                                                (("1"
                                                                                                  (flatten)
                                                                                                  (("1"
                                                                                                    (expand
                                                                                                     "injective?")
                                                                                                    (("1"
                                                                                                      (hide
                                                                                                       -2
                                                                                                       -3)
                                                                                                      (("1"
                                                                                                        (inst?)
                                                                                                        (("1"
                                                                                                          (assert)
                                                                                                          nil
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (skosimp)
                                                                                      (("2"
                                                                                        (typepred
                                                                                         i!1)
                                                                                        (("2"
                                                                                          (expand
                                                                                           "trunc")
                                                                                          (("2"
                                                                                            (expand
                                                                                             "ecomp")
                                                                                            (("2"
                                                                                              (assert)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("3"
                                                                                      (skosimp)
                                                                                      (("3"
                                                                                        (typepred
                                                                                         i!1)
                                                                                        (("3"
                                                                                          (expand
                                                                                           "trunc")
                                                                                          (("3"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (assert)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((competing_leq const-decl "bool" tournamentUnity0 nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (< const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (N const-decl "posnat" tournamentSafe0 nil)
    (below type-eq-decl nil nat_types nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (avf const-decl "int" tournamentUnity1 nil)
    (bijective? const-decl "bool" functions nil)
    (enum_thread const-decl "(bijective?[below[N], (thread)])"
     tournamentSafe0 nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil) (sum def-decl "int" intsum nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (posint_times_posint_is_posint application-judgement "posint"
     integers nil)
    (posint_plus_nnint_is_posint application-judgement "posint"
     integers nil)
    (avf_bounded formula-decl nil tournamentUnity1 nil)
    (lvf const-decl "int" tournamentUnity1 nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (iq4 const-decl "bool" tournamentSafe0 nil)
    (kqall const-decl "bool" tournamentSafe0 nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (col const-decl "int" tournamentUnity1 nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (int_times_even_is_even application-judgement "even_int" integers
     nil)
    (kq5 const-decl "bool" tournamentSafe0 nil)
    (sum_monotonic formula-decl nil intsum nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (sum_homomorphic formula-decl nil intsum nil)
    (sum_distributive formula-decl nil intsum nil)
    (Card const-decl "nat" finite_sets nil)
    (card const-decl "{n: nat | n = Card(S)}" finite_sets nil)
    (trunc const-decl "finite_set[nat]" intsum nil)
    (both_sides_times_pos_le2 formula-decl nil real_props nil)
    (inj_Card formula-decl nil finite_sets nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (injective? const-decl "bool" functions nil)
    (Card_injection formula-decl nil finite_sets nil)
    (nonneg_real nonempty-type-eq-decl nil real_types nil)
    (posreal nonempty-type-eq-decl nil real_types nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (real_gt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (sum_char formula-decl nil intsum nil)
    (char const-decl "int" intsum nil)
    (pred type-eq-decl nil defined_types nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (AA const-decl "posnat" tournamentUnity1 nil)
    (* const-decl "[nat -> int]" intsum nil)
    (+ const-decl "[nat -> int]" intsum nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (sinc const-decl "int" tournamentUnity0 nil)
    (savf const-decl "int" tournamentUnity1 nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil))
   nil)
  (savf_UPB-3 nil 3670771023
   ("" (skosimp)
    (("" (expand "savf")
      (("" (expand "competing_leq")
        (("" (expand "sinc")
          ((""
            (name-replace ff
             "LAMBDA n: IF n < N THEN avf(enum_thread(n), x!1) ELSE 0 ENDIF")
            ((""
              (name-replace gg
               "LAMBDA n: IF n < N THEN x!1`cnt(enum_thread(n)) ELSE 0 ENDIF")
              ((""
                (name ecomp
                      "{k | k < N AND x!1`competing(enum_thread(k)) }")
                (("" (name hh "AA * gg + (AA-1) * char(ecomp)")
                  ((""
                    (case "sum(N, hh) <= AA * sum(N, gg) + AA * kk!1 - kk!1 ")
                    (("1" (case "sum(N, ff) <= sum(N, hh)")
                      (("1" (assert) nil nil)
                       ("2" (hide -1 2)
                        (("2" (use sum_monotonic)
                          (("2" (assert)
                            (("2" (hide 2)
                              (("2"
                                (skosimp)
                                (("2"
                                  (hide -2)
                                  (("2"
                                    (expand "ff")
                                    (("2"
                                      (expand "hh")
                                      (("2"
                                        (assert)
                                        (("2"
                                          (expand "+ ")
                                          (("2"
                                            (expand "gg")
                                            (("2"
                                              (expand "*")
                                              (("2"
                                                (expand "char")
                                                (("2"
                                                  (lift-if)
                                                  (("2"
                                                    (split)
                                                    (("1"
                                                      (flatten)
                                                      (("1"
                                                        (hide -3)
                                                        (("1"
                                                          (expand
                                                           "ecomp")
                                                          (("1"
                                                            (name-replace
                                                             qq
                                                             "enum_thread(i!1)")
                                                            (("1"
                                                              (use
                                                               avf_bounded)
                                                              (("1"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (flatten)
                                                      (("2"
                                                        (expand
                                                         "ecomp")
                                                        (("2"
                                                          (hide -2)
                                                          (("2"
                                                            (name-replace
                                                             qq
                                                             "enum_thread(i!1)")
                                                            (("2"
                                                              (case
                                                               "kq5(qq, x!1)")
                                                              (("1"
                                                                (expand
                                                                 "kq5")
                                                                (("1"
                                                                  (replaceh
                                                                   -1)
                                                                  (("1"
                                                                    (flatten)
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (expand
                                                                         "avf")
                                                                        (("1"
                                                                          (assert)
                                                                          (("1"
                                                                            (expand
                                                                             "lvf")
                                                                            (("1"
                                                                              (case
                                                                               "col(qq, x!1)=0")
                                                                              (("1"
                                                                                (assert)
                                                                                nil
                                                                                nil)
                                                                               ("2"
                                                                                (hide
                                                                                 2)
                                                                                (("2"
                                                                                  (expand
                                                                                   "col")
                                                                                  (("2"
                                                                                    (case
                                                                                     "iq0(qq, x!1) AND iq4(qq, x!1)")
                                                                                    (("1"
                                                                                      (flatten)
                                                                                      (("1"
                                                                                        (expand
                                                                                         "iq0")
                                                                                        (("1"
                                                                                          (expand
                                                                                           "iq4")
                                                                                          (("1"
                                                                                            (flatten)
                                                                                            (("1"
                                                                                              (assert)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil)
                                                                                     ("2"
                                                                                      (expand
                                                                                       "globinv")
                                                                                      (("2"
                                                                                        (expand
                                                                                         "kqall")
                                                                                        (("2"
                                                                                          (flatten)
                                                                                          (("2"
                                                                                            (inst?)
                                                                                            (("2"
                                                                                              (flatten)
                                                                                              (("2"
                                                                                                (assert)
                                                                                                (("2"
                                                                                                  (expand
                                                                                                   "iqall")
                                                                                                  (("2"
                                                                                                    (flatten)
                                                                                                    (("2"
                                                                                                      (inst?)
                                                                                                      (("2"
                                                                                                        (assert)
                                                                                                        nil
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (expand
                                                                 "globinv")
                                                                (("2"
                                                                  (expand
                                                                   "kqall")
                                                                  (("2"
                                                                    (flatten)
                                                                    (("2"
                                                                      (inst?)
                                                                      (("2"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide 2)
                      (("2" (expand "hh")
                        (("2" (hide -1)
                          (("2" (use sum_homomorphic)
                            (("2" (replaceh -1)
                              (("2"
                                (use sum_distributive)
                                (("2"
                                  (replaceh -1)
                                  (("2"
                                    (assert)
                                    (("2"
                                      (use sum_distributive)
                                      (("2"
                                        (replaceh -1)
                                        (("2"
                                          (use sum_char)
                                          (("2"
                                            (use sum_char)
                                            (("2"
                                              (replaceh -1)
                                              (("2"
                                                (case
                                                 "(AA - 1) * card(trunc(N, ecomp)) <= AA * kk!1 - kk!1")
                                                (("1" (assert) nil nil)
                                                 ("2"
                                                  (hide 2)
                                                  (("2"
                                                    (lemma
                                                     both_sides_times_pos_le2)
                                                    (("2"
                                                      (inst
                                                       -
                                                       "AA-1"
                                                       "card(trunc(N, ecomp))"
                                                       kk!1)
                                                      (("1"
                                                        (assert)
                                                        (("1"
                                                          (hide 2)
                                                          (("1"
                                                            (hide
                                                             -1
                                                             -2)
                                                            (("1"
                                                              (name
                                                               NC
                                                               "card(x!1`competing)")
                                                              (("1"
                                                                (lemma
                                                                 inj_Card[Thread])
                                                                (("1"
                                                                  (inst?)
                                                                  (("1"
                                                                    (inst
                                                                     -
                                                                     NC)
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (split)
                                                                        (("1"
                                                                          (skolem!)
                                                                          (("1"
                                                                            (lemma
                                                                             Card_injection[nat])
                                                                            (("1"
                                                                              (inst
                                                                               -
                                                                               _
                                                                               NC)
                                                                              (("1"
                                                                                (inst
                                                                                 -
                                                                                 "trunc(N, ecomp)")
                                                                                (("1"
                                                                                  (assert)
                                                                                  (("1"
                                                                                    (hide
                                                                                     2)
                                                                                    (("1"
                                                                                      (inst
                                                                                       +
                                                                                       "lambda (i: (trunc(N, ecomp))): f!1(enum_thread(i))")
                                                                                      (("1"
                                                                                        (expand
                                                                                         "injective?")
                                                                                        (("1"
                                                                                          (skosimp)
                                                                                          (("1"
                                                                                            (inst?)
                                                                                            (("1"
                                                                                              (assert)
                                                                                              (("1"
                                                                                                (typepred
                                                                                                 enum_thread)
                                                                                                (("1"
                                                                                                  (expand
                                                                                                   "bijective?")
                                                                                                  (("1"
                                                                                                    (flatten)
                                                                                                    (("1"
                                                                                                      (expand
                                                                                                       "injective?")
                                                                                                      (("1"
                                                                                                        (hide
                                                                                                         -2
                                                                                                         -3)
                                                                                                        (("1"
                                                                                                          (inst?)
                                                                                                          (("1"
                                                                                                            (assert)
                                                                                                            nil
                                                                                                            nil))
                                                                                                          nil))
                                                                                                        nil))
                                                                                                      nil))
                                                                                                    nil))
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (skosimp)
                                                                                        (("2"
                                                                                          (typepred
                                                                                           i!1)
                                                                                          (("2"
                                                                                            (expand
                                                                                             "trunc")
                                                                                            (("2"
                                                                                              (expand
                                                                                               "ecomp")
                                                                                              (("2"
                                                                                                (assert)
                                                                                                nil
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil)
                                                                                       ("3"
                                                                                        (skosimp)
                                                                                        (("3"
                                                                                          (typepred
                                                                                           i!1)
                                                                                          (("3"
                                                                                            (expand
                                                                                             "trunc")
                                                                                            (("3"
                                                                                              (assert)
                                                                                              nil
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (use
                                                                           card_def[Thread])
                                                                          (("2"
                                                                            (assert)
                                                                            (("2"
                                                                              (postpone)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (postpone)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil)
                                                       ("2"
                                                        (postpone)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   nil nil)
  (savf_UPB-2 nil 3670768648
   ("" (skosimp)
    (("" (expand "savf")
      (("" (expand "competing_leq")
        (("" (expand "sinc")
          ((""
            (name-replace ff
             "LAMBDA n: IF n < N THEN avf(enum_thread(n), x!1) ELSE 0 ENDIF")
            ((""
              (name-replace gg
               "LAMBDA n: IF n < N THEN x!1`cnt(enum_thread(n)) ELSE 0 ENDIF")
              ((""
                (name ecomp
                      "{k | k < N AND x!1`competing(enum_thread(k)) }")
                (("" (name hh "AA * gg + (AA-1) * char(ecomp)")
                  ((""
                    (case "AA * sum(N, gg) + AA * kk!1 - kk!1 = sum(N, hh) ")
                    (("1" (replaceh -1)
                      (("1" (use sum_monotonic)
                        (("1" (assert)
                          (("1" (hide -1 2)
                            (("1" (skosimp)
                              (("1"
                                (expand "ff")
                                (("1"
                                  (expand "hh")
                                  (("1"
                                    (expand "gg")
                                    (("1"
                                      (expand "+")
                                      (("1"
                                        (expand "*")
                                        (("1"
                                          (assert)
                                          (("1"
                                            (expand "char")
                                            (("1"
                                              (lift-if)
                                              (("1"
                                                (split)
                                                (("1"
                                                  (flatten)
                                                  (("1"
                                                    (use avf_bounded)
                                                    (("1"
                                                      (assert)
                                                      nil
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (flatten)
                                                  (("2"
                                                    (expand "ecomp")
                                                    (("2"
                                                      (assert)
                                                      (("2"
                                                        (name-replace
                                                         qq
                                                         "enum_thread(i!1)")
                                                        (("2"
                                                          (case
                                                           "kq5(qq, x!1)")
                                                          (("1"
                                                            (expand
                                                             "kq5")
                                                            (("1"
                                                              (replaceh
                                                               -1)
                                                              (("1"
                                                                (flatten)
                                                                (("1"
                                                                  (expand
                                                                   "avf")
                                                                  (("1"
                                                                    (expand
                                                                     "lvf")
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (case
                                                                         "col(qq, x!1)=0")
                                                                        (("1"
                                                                          (assert)
                                                                          nil
                                                                          nil)
                                                                         ("2"
                                                                          (hide
                                                                           2)
                                                                          (("2"
                                                                            (expand
                                                                             "col")
                                                                            (("2"
                                                                              (case
                                                                               "iq0(qq, x!1) AND iq4(qq, x!1)")
                                                                              (("1"
                                                                                (flatten)
                                                                                (("1"
                                                                                  (expand
                                                                                   "iq0")
                                                                                  (("1"
                                                                                    (expand
                                                                                     "iq4")
                                                                                    (("1"
                                                                                      (flatten)
                                                                                      (("1"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (expand
                                                                                 "globinv")
                                                                                (("2"
                                                                                  (expand
                                                                                   "iqall")
                                                                                  (("2"
                                                                                    (flatten)
                                                                                    (("2"
                                                                                      (inst?)
                                                                                      (("2"
                                                                                        (flatten)
                                                                                        (("2"
                                                                                          (assert)
                                                                                          (("2"
                                                                                            (expand
                                                                                             "kqall")
                                                                                            (("2"
                                                                                              (flatten)
                                                                                              (("2"
                                                                                                (inst?
                                                                                                 -8)
                                                                                                (("2"
                                                                                                  (assert)
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (expand
                                                             "globinv")
                                                            (("2"
                                                              (expand
                                                               "kqall")
                                                              (("2"
                                                                (flatten)
                                                                (("2"
                                                                  (inst?)
                                                                  (("2"
                                                                    (assert)
                                                                    nil
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide 2)
                      (("2" (expand "hh")
                        (("2" (hide -1)
                          (("2" (use sum_homomorphic)
                            (("2" (replaceh -1)
                              (("2"
                                (use sum_distributive)
                                (("2"
                                  (replaceh -1)
                                  (("2"
                                    (assert)
                                    (("2"
                                      (use sum_distributive)
                                      (("2"
                                        (replaceh -1)
                                        (("2"
                                          (use sum_char)
                                          (("2" (postpone) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   nil nil)
  (savf_UPB-1 nil 3670767758
   ("" (skosimp)
    (("" (expand "savf")
      (("" (expand "competing_leq")
        (("" (expand "sinc")
          ((""
            (name-replace ff
             "LAMBDA n: IF n < N THEN avf(enum_thread(n), x!1) ELSE 0 ENDIF")
            ((""
              (name-replace gg
               "LAMBDA n: IF n < N THEN x!1`cnt(enum_thread(n)) ELSE 0 ENDIF")
              ((""
                (name ecomp
                      "{k | k < N AND x!1`competing(enum_thread(k)) }")
                (("" (name hh "gg + (AA-1) * char(ecomp)")
                  ((""
                    (case "AA * sum(N, gg) + AA * kk!1 - kk!1 = sum(N, hh) ")
                    (("1" (replaceh -1)
                      (("1" (use sum_monotonic)
                        (("1" (assert)
                          (("1" (hide -1 2)
                            (("1" (skosimp)
                              (("1"
                                (expand "ff")
                                (("1"
                                  (expand "hh")
                                  (("1"
                                    (expand "gg")
                                    (("1"
                                      (expand
                                       "+
")
                                      (("1"
                                        (expand "*")
                                        (("1"
                                          (assert)
                                          (("1"
                                            (expand "char")
                                            (("1"
                                              (lift-if)
                                              (("1"
                                                (split)
                                                (("1"
                                                  (flatten)
                                                  (("1"
                                                    (use avf_bounded)
                                                    (("1"
                                                      (assert)
                                                      (("1"
                                                        (flatten)
                                                        (("1"
                                                          (assert)
                                                          (("1"
                                                            (postpone)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (postpone)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (postpone) nil nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   nil shostak))
 (savf_ascends 0
  (savf_ascends-1 nil 3670852742
   ("" (skosimp)
    (("" (expand "savf")
      ((""
        (name-replace ff
         "LAMBDA n: IF n < N THEN avf(enum_thread(n), x!1) ELSE 0 ENDIF")
        ((""
          (name-replace gg
           "LAMBDA n: IF n < N THEN avf(enum_thread(n), y!1) ELSE 0 ENDIF")
          (("" (use sum_monotonic)
            (("" (assert)
              (("" (hide 2)
                (("" (skosimp)
                  (("" (expand "ff")
                    (("" (expand "gg")
                      (("" (assert)
                        (("" (lemma avf_ascends)
                          (("" (inst - p!1 _ x!1 y!1)
                            (("" (inst?) (("" (assert) nil nil)) nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((savf const-decl "int" tournamentUnity1 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (gg skolem-const-decl "[nat -> int]" tournamentUnity1 nil)
    (avf_ascends formula-decl nil tournamentUnity1 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (ff skolem-const-decl "[nat -> int]" tournamentUnity1 nil)
    (sum_monotonic formula-decl nil intsum nil)
    (enum_thread const-decl "(bijective?[below[N], (thread)])"
     tournamentSafe0 nil)
    (bijective? const-decl "bool" functions nil)
    (below type-eq-decl nil nat_types nil)
    (avf const-decl "int" tournamentUnity1 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (digit type-eq-decl nil ctrees nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (N const-decl "posnat" tournamentSafe0 nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (savf_increases_fwd 0
  (savf_increases_fwd-1 nil 3670832587
   ("" (skosimp)
    (("" (expand "savf")
      ((""
        (name-replace ff
         "LAMBDA n: IF n < N THEN avf(enum_thread(n), x!1) ELSE 0 ENDIF")
        ((""
          (name-replace gg
           "LAMBDA n: IF n < N THEN avf(enum_thread(n), y!1) ELSE 0 ENDIF")
          (("" (use sum_strict_monotonic)
            (("" (assert)
              (("" (split)
                (("1" (skosimp)
                  (("1" (hide 2)
                    (("1" (expand "ff")
                      (("1" (expand "gg")
                        (("1" (assert)
                          (("1" (lemma avf_ascends)
                            (("1" (inst - p!1 _ x!1 y!1)
                              (("1"
                                (inst?)
                                (("1"
                                  (assert)
                                  (("1"
                                    (expand "step")
                                    (("1"
                                      (flatten)
                                      (("1"
                                        (expand "forward1")
                                        (("1" (assert) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (typepred enum_thread)
                  (("2" (expand "bijective?")
                    (("2" (flatten)
                      (("2" (hide -1)
                        (("2" (expand "surjective?")
                          (("2" (inst - p!1)
                            (("2" (skolem!)
                              (("2"
                                (inst + x!2)
                                (("2"
                                  (assert)
                                  (("2"
                                    (hide 2)
                                    (("2"
                                      (expand "ff")
                                      (("2"
                                        (expand "gg")
                                        (("2"
                                          (use avf_increases_fwd)
                                          (("2" (assert) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((savf const-decl "int" tournamentUnity1 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (surjective? const-decl "bool" functions nil)
    (avf_increases_fwd formula-decl nil tournamentUnity1 nil)
    (ff skolem-const-decl "[nat -> int]" tournamentUnity1 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (forward1 const-decl "bool" tournamentUnity0 nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (avf_ascends formula-decl nil tournamentUnity1 nil)
    (gg skolem-const-decl "[nat -> int]" tournamentUnity1 nil)
    (sum_strict_monotonic formula-decl nil intsum nil)
    (enum_thread const-decl "(bijective?[below[N], (thread)])"
     tournamentSafe0 nil)
    (bijective? const-decl "bool" functions nil)
    (below type-eq-decl nil nat_types nil)
    (avf const-decl "int" tournamentUnity1 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (digit type-eq-decl nil ctrees nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (N const-decl "posnat" tournamentSafe0 nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (savf_at_14 0
  (savf_at_14-1 nil 3670853537
   ("" (skosimp)
    (("" (expand "savf")
      ((""
        (name-replace gg
         "LAMBDA n: IF n < N THEN avf(enum_thread(n), y!1) ELSE 0 ENDIF")
        ((""
          (name-replace ff
           "LAMBDA n: IF n < N THEN avf(enum_thread(n), x!1) ELSE 0 ENDIF")
          (("" (typepred enum_thread)
            (("" (expand "bijective?")
              (("" (flatten)
                (("" (hide -1)
                  (("" (expand "surjective?")
                    (("" (inst?)
                      (("" (skolem!)
                        (("" (case "gg = ff + delta(x!2, D)")
                          (("1" (replaceh -1)
                            (("1" (use sum_homomorphic)
                              (("1"
                                (use sum_delta)
                                (("1" (assert) nil nil))
                                nil))
                              nil))
                            nil)
                           ("2" (hide 2)
                            (("2" (apply-extensionality :hide? t)
                              (("2"
                                (expand "gg")
                                (("2"
                                  (expand "+ ")
                                  (("2"
                                    (expand "delta")
                                    (("2"
                                      (expand "ff")
                                      (("2"
                                        (lift-if)
                                        (("2"
                                          (lift-if)
                                          (("2"
                                            (lift-if)
                                            (("2"
                                              (assert)
                                              (("2"
                                                (split)
                                                (("1"
                                                  (flatten)
                                                  (("1"
                                                    (split)
                                                    (("1"
                                                      (flatten)
                                                      (("1"
                                                        (replaceh -1)
                                                        (("1"
                                                          (replaceh -2)
                                                          (("1"
                                                            (use
                                                             avf_at_14)
                                                            (("1"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (flatten)
                                                      (("2"
                                                        (typepred
                                                         enum_thread)
                                                        (("2"
                                                          (expand
                                                           "bijective?")
                                                          (("2"
                                                            (flatten)
                                                            (("2"
                                                              (expand
                                                               "injective?")
                                                              (("2"
                                                                (inst?)
                                                                (("2"
                                                                  (assert)
                                                                  (("2"
                                                                    (replaceh
                                                                     -3)
                                                                    (("2"
                                                                      (name-replace
                                                                       qq
                                                                       "enum_thread(x!3)")
                                                                      (("2"
                                                                        (use
                                                                         avf_constant_dif
                                                                         (p
                                                                          p!1
                                                                          y
                                                                          y!1))
                                                                        (("2"
                                                                          (assert)
                                                                          (("2"
                                                                            (expand
                                                                             "step")
                                                                            (("2"
                                                                              (propax)
                                                                              nil
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (propax)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((savf const-decl "int" tournamentUnity1 nil)
    (+ const-decl "[nat -> int]" intsum nil)
    (delta const-decl "int" intsum nil)
    (D const-decl "posnat" tournamentUnity0 nil)
    (sum_homomorphic formula-decl nil intsum nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (sum_delta formula-decl nil intsum nil)
    (ff skolem-const-decl "[nat -> int]" tournamentUnity1 nil)
    (injective? const-decl "bool" functions nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (avf_constant_dif formula-decl nil tournamentUnity1 nil)
    (avf_at_14 formula-decl nil tournamentUnity1 nil)
    (gg skolem-const-decl "[nat -> int]" tournamentUnity1 nil)
    (surjective? const-decl "bool" functions nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (enum_thread const-decl "(bijective?[below[N], (thread)])"
     tournamentSafe0 nil)
    (bijective? const-decl "bool" functions nil)
    (below type-eq-decl nil nat_types nil)
    (avf const-decl "int" tournamentUnity1 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (digit type-eq-decl nil ctrees nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (N const-decl "posnat" tournamentSafe0 nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (savf_at_15 0
  (savf_at_15-1 nil 3670854302
   ("" (skosimp)
    (("" (expand "savf")
      ((""
        (name-replace gg
         "LAMBDA n: IF n < N THEN avf(enum_thread(n), y!1) ELSE 0 ENDIF")
        ((""
          (name-replace ff
           "LAMBDA n: IF n < N THEN avf(enum_thread(n), x!1) ELSE 0 ENDIF")
          (("" (typepred enum_thread)
            (("" (expand "bijective?")
              (("" (flatten)
                (("" (expand "surjective?")
                  (("" (inst?)
                    (("" (skolem!)
                      (("" (case "gg = ff + delta(x!2, W)")
                        (("1" (replaceh -1)
                          (("1" (use sum_homomorphic)
                            (("1" (use sum_delta)
                              (("1" (assert) nil nil)) nil))
                            nil))
                          nil)
                         ("2" (hide 2)
                          (("2" (apply-extensionality :hide? t)
                            (("2" (expand "gg")
                              (("2"
                                (expand "+ ")
                                (("2"
                                  (expand "ff")
                                  (("2"
                                    (expand "delta")
                                    (("2"
                                      (assert)
                                      (("2"
                                        (lift-if)
                                        (("2"
                                          (lift-if)
                                          (("2"
                                            (lift-if)
                                            (("2"
                                              (assert)
                                              (("2"
                                                (split)
                                                (("1"
                                                  (flatten)
                                                  (("1"
                                                    (split)
                                                    (("1"
                                                      (flatten)
                                                      (("1"
                                                        (replaceh -1)
                                                        (("1"
                                                          (replaceh -3)
                                                          (("1"
                                                            (use
                                                             avf_at_15)
                                                            (("1"
                                                              (assert)
                                                              nil
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil)
                                                     ("2"
                                                      (flatten)
                                                      (("2"
                                                        (expand
                                                         "injective?")
                                                        (("2"
                                                          (inst?)
                                                          (("2"
                                                            (assert)
                                                            (("2"
                                                              (replaceh
                                                               -2)
                                                              (("2"
                                                                (name-replace
                                                                 qq
                                                                 "enum_thread(x!3)")
                                                                (("2"
                                                                  (case
                                                                   "step(p!1, x!1, y!1)")
                                                                  (("1"
                                                                    (use
                                                                     avf_constant_dif)
                                                                    (("1"
                                                                      (assert)
                                                                      nil
                                                                      nil))
                                                                    nil)
                                                                   ("2"
                                                                    (expand
                                                                     "step")
                                                                    (("2"
                                                                      (flatten)
                                                                      (("2"
                                                                        (assert)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (propax)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((savf const-decl "int" tournamentUnity1 nil)
    (surjective? const-decl "bool" functions nil)
    (gg skolem-const-decl "[nat -> int]" tournamentUnity1 nil)
    (ff skolem-const-decl "[nat -> int]" tournamentUnity1 nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (avf_constant_dif formula-decl nil tournamentUnity1 nil)
    (injective? const-decl "bool" functions nil)
    (avf_at_15 formula-decl nil tournamentUnity1 nil)
    (sum_delta formula-decl nil intsum nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (sum_homomorphic formula-decl nil intsum nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (delta const-decl "int" intsum nil)
    (+ const-decl "[nat -> int]" intsum nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (enum_thread const-decl "(bijective?[below[N], (thread)])"
     tournamentSafe0 nil)
    (bijective? const-decl "bool" functions nil)
    (below type-eq-decl nil nat_types nil)
    (avf const-decl "int" tournamentUnity1 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (digit type-eq-decl nil ctrees nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (N const-decl "posnat" tournamentSafe0 nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (savf_at_16 0
  (savf_at_16-1 nil 3671701073
   ("" (skosimp)
    (("" (expand "savf")
      ((""
        (name-replace ff
         "LAMBDA n: IF n < N THEN avf(enum_thread(n), y!1) ELSE 0 ENDIF")
        ((""
          (name-replace gg
           "LAMBDA n: IF n < N THEN avf(enum_thread(n), x!1) ELSE 0 ENDIF")
          (("" (typepred enum_thread)
            (("" (expand "bijective?")
              (("" (flatten)
                (("" (expand "surjective?")
                  (("" (inst?)
                    (("" (skolem!)
                      (("" (case "ff = gg + delta(x!2, cs)")
                        (("1" (replaceh -1)
                          (("1" (use sum_homomorphic)
                            (("1" (replaceh -1)
                              (("1"
                                (use sum_delta)
                                (("1" (assert) nil nil))
                                nil))
                              nil))
                            nil))
                          nil)
                         ("2" (hide 2)
                          (("2" (apply-extensionality :hide? t)
                            (("2" (expand "ff")
                              (("2"
                                (expand "+ ")
                                (("2"
                                  (expand "gg")
                                  (("2"
                                    (expand "delta")
                                    (("2"
                                      (assert)
                                      (("2"
                                        (lift-if)
                                        (("2"
                                          (lift-if)
                                          (("2"
                                            (assert)
                                            (("2"
                                              (split)
                                              (("1"
                                                (flatten)
                                                (("1"
                                                  (split)
                                                  (("1"
                                                    (flatten)
                                                    (("1"
                                                      (replaceh -1)
                                                      (("1"
                                                        (replaceh -3)
                                                        (("1"
                                                          (use
                                                           avf_at_16)
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil)
                                                   ("2"
                                                    (flatten)
                                                    (("2"
                                                      (expand
                                                       "injective?")
                                                      (("2"
                                                        (inst?)
                                                        (("2"
                                                          (assert)
                                                          (("2"
                                                            (replaceh
                                                             -2)
                                                            (("2"
                                                              (lemma
                                                               avf_constant_dif)
                                                              (("2"
                                                                (inst?)
                                                                (("2"
                                                                  (inst
                                                                   -
                                                                   p!1)
                                                                  (("2"
                                                                    (assert)
                                                                    (("2"
                                                                      (expand
                                                                       "step")
                                                                      (("2"
                                                                        (propax)
                                                                        nil
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2" (propax) nil nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((savf const-decl "int" tournamentUnity1 nil)
    (surjective? const-decl "bool" functions nil)
    (ff skolem-const-decl "[nat -> int]" tournamentUnity1 nil)
    (gg skolem-const-decl "[nat -> int]" tournamentUnity1 nil)
    (avf_at_16 formula-decl nil tournamentUnity1 nil)
    (injective? const-decl "bool" functions nil)
    (avf_constant_dif formula-decl nil tournamentUnity1 nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (sum_delta formula-decl nil intsum nil)
    (sum_homomorphic formula-decl nil intsum nil)
    (cs const-decl "posnat" tournamentUnity0 nil)
    (delta const-decl "int" intsum nil)
    (+ const-decl "[nat -> int]" intsum nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (enum_thread const-decl "(bijective?[below[N], (thread)])"
     tournamentSafe0 nil)
    (bijective? const-decl "bool" functions nil)
    (below type-eq-decl nil nat_types nil)
    (avf const-decl "int" tournamentUnity1 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (digit type-eq-decl nil ctrees nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (N const-decl "posnat" tournamentSafe0 nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (savf_at_18 0
  (savf_at_18-1 nil 3670854796
   ("" (skosimp)
    (("" (expand "savf")
      ((""
        (name-replace ff
         "LAMBDA n: IF n < N THEN avf(enum_thread(n), x!1) ELSE 0 ENDIF")
        ((""
          (name-replace gg
           "LAMBDA n: IF n < N THEN avf(enum_thread(n), y!1) ELSE 0 ENDIF")
          (("" (typepred enum_thread)
            (("" (expand "bijective?")
              (("" (flatten)
                (("" (expand "surjective?")
                  (("" (inst?)
                    (("" (skolem!)
                      (("" (case "gg = ff + delta(x!2, exi)")
                        (("1" (replaceh -1)
                          (("1" (use sum_homomorphic)
                            (("1" (use sum_delta)
                              (("1" (assert) nil nil)) nil))
                            nil))
                          nil)
                         ("2" (apply-extensionality :hide? t)
                          (("2" (hide 2)
                            (("2" (expand "gg")
                              (("2"
                                (expand "ff")
                                (("2"
                                  (expand
                                   "+
")
                                  (("2"
                                    (expand "delta")
                                    (("2"
                                      (lift-if)
                                      (("2"
                                        (lift-if)
                                        (("2"
                                          (assert)
                                          (("2"
                                            (split)
                                            (("1"
                                              (flatten)
                                              (("1"
                                                (split)
                                                (("1"
                                                  (flatten)
                                                  (("1"
                                                    (replaceh -1)
                                                    (("1"
                                                      (replaceh -3)
                                                      (("1"
                                                        (use avf_at_18)
                                                        (("1"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (flatten)
                                                  (("2"
                                                    (expand
                                                     "injective?")
                                                    (("2"
                                                      (inst?)
                                                      (("2"
                                                        (assert)
                                                        (("2"
                                                          (replaceh -2)
                                                          (("2"
                                                            (name-replace
                                                             qq
                                                             "enum_thread(x!3)")
                                                            (("2"
                                                              (case
                                                               "step(p!1, x!1, y!1)")
                                                              (("1"
                                                                (use
                                                                 avf_constant_dif)
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil)
                                                               ("2"
                                                                (expand
                                                                 "step")
                                                                (("2"
                                                                  (propax)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil)
                                             ("2" (propax) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((savf const-decl "int" tournamentUnity1 nil)
    (surjective? const-decl "bool" functions nil)
    (gg skolem-const-decl "[nat -> int]" tournamentUnity1 nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (avf_constant_dif formula-decl nil tournamentUnity1 nil)
    (injective? const-decl "bool" functions nil)
    (avf_at_18 formula-decl nil tournamentUnity1 nil)
    (ff skolem-const-decl "[nat -> int]" tournamentUnity1 nil)
    (sum_delta formula-decl nil intsum nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (sum_homomorphic formula-decl nil intsum nil)
    (exi const-decl "posnat" tournamentUnity0 nil)
    (delta const-decl "int" intsum nil)
    (+ const-decl "[nat -> int]" intsum nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (enum_thread const-decl "(bijective?[below[N], (thread)])"
     tournamentSafe0 nil)
    (bijective? const-decl "bool" functions nil)
    (below type-eq-decl nil nat_types nil)
    (avf const-decl "int" tournamentUnity1 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (digit type-eq-decl nil ctrees nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (N const-decl "posnat" tournamentSafe0 nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil)
    (IF const-decl "[boolean, T, T -> T]" if_def nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil))
   shostak))
 (at_fwd_ensures 0
  (at_fwd_ensures-1 nil 3670910792
   ("" (s-ensures)
    (("" (split)
      (("1" (skosimp*)
        (("1" (expand "E1")
          (("1" (expand "step")
            (("1" (split -)
              (("1" (assert) nil nil)
               ("2" (skolem!)
                (("2" (expand "leq")
                  (("2" (use savf_ascends)
                    (("2" (assert)
                      (("2" (hide -1 1)
                        (("2" (case "q!1=p!1")
                          (("1" (replaceh -1)
                            (("1" (case "forward1(p!1)(s!1, y!1)")
                              (("1"
                                (use savf_increases_fwd)
                                (("1" (assert) nil nil))
                                nil)
                               ("2"
                                (expand "forward1")
                                (("2"
                                  (flatten)
                                  (("2"
                                    (expand "step")
                                    (("2"
                                      (assert)
                                      (("2"
                                        (hide-all-but (-1 -3))
                                        (("2"
                                          (expand "at_fwd")
                                          (("2"
                                            (expand "step11")
                                            (("2"
                                              (expand "step13")
                                              (("2"
                                                (expand "step14")
                                                (("2"
                                                  (expand "step15F")
                                                  (("2"
                                                    (expand "step15G")
                                                    (("2"
                                                      (expand "step18")
                                                      (("2"
                                                        (expand
                                                         "step16")
                                                        (("2"
                                                          (ground)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (hide -2 -4 3)
                            (("2" (expand "at_fwd")
                              (("2"
                                (case "y!1`pc(q!1)=s!1`pc(q!1)")
                                (("1" (replaceh -1) nil nil)
                                 ("2"
                                  (hide -2 3)
                                  (("2" (grind) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (typepred enum_thread)
        (("2" (expand "bijective?")
          (("2" (flatten)
            (("2" (expand "surjective?")
              (("2" (inst?)
                (("2" (skolem!)
                  (("2" (inst + x!1)
                    (("2" (split)
                      (("1" (skosimp)
                        (("1" (use enabled_E1)
                          (("1" (assert)
                            (("1" (hide 3)
                              (("1"
                                (replaceh -5)
                                (("1"
                                  (expand "enabled1")
                                  (("1"
                                    (expand "at_fwd")
                                    (("1" (propax) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil)
                       ("2" (skosimp)
                        (("2" (expand "E1")
                          (("2" (replaceh -6)
                            (("2" (expand "leq")
                              (("2"
                                (use savf_increases_fwd)
                                (("2" (assert) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (forward1 const-decl "bool" tournamentUnity0 nil)
    (savf_increases_fwd formula-decl nil tournamentUnity1 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (empty? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (savf_ascends formula-decl nil tournamentUnity1 nil)
    (step const-decl "bool" tournamentUnity0 nil)
    (surjective? const-decl "bool" functions nil)
    (enabled_E1 formula-decl nil tournamentUnity0 nil)
    (enabled1 const-decl "bool" tournamentUnity0 nil)
    (enum_thread const-decl "(bijective?[below[N], (thread)])"
     tournamentSafe0 nil)
    (bijective? const-decl "bool" functions nil)
    (below type-eq-decl nil nat_types nil)
    (N const-decl "posnat" tournamentSafe0 nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (neg const-decl "bool" ownpred nil)
    (cup const-decl "bool" ownpred nil)
    (wp const-decl "bool" ownpred nil)
    (<= const-decl "bool" mucalculus nil)
    (transient const-decl "bool" bdUnity nil)
    (co const-decl "bool" bdUnity nil)
    (ensures const-decl "bool" bdUnity nil)
    (ensures_leto formula-decl nil bdUnity nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (digit type-eq-decl nil ctrees nil) (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (at_fwd const-decl "bool" tournamentUnity1 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (savf const-decl "int" tournamentUnity1 nil)
    (leq const-decl "bool" bdUnity nil)
    (cap const-decl "bool" ownpred nil)
    (pred type-eq-decl nil defined_types nil)
    (int_plus_int_is_int application-judgement "int" integers nil))
   shostak))
 (some_fwd_progress 0
  (some_fwd_progress-1 nil 3670911539
   ("" (skolem!)
    (("" (lemma leto_union)
      (("" (inst?)
        (("" (inst?)
          (("" (inst - _ "leq(z!1 + 1, savf)")
            ((""
              (name ppset
                    "{pp: pred[state] | EXISTS q: pp = cap(leq(z!1, savf), at_fwd(q))}")
              (("" (inst - ppset)
                (("" (hide -1)
                  ((""
                    (case "Union(ppset) = cap(leq(z!1, savf), some_at_fwd)")
                    (("1" (assert)
                      (("1" (hide - 2)
                        (("1" (skosimp)
                          (("1" (expand "ppset")
                            (("1" (skolem!)
                              (("1"
                                (replaceh -1)
                                (("1"
                                  (use at_fwd_ensures)
                                  (("1" (assert) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide - 2)
                      (("2" (apply-extensionality :hide? t)
                        (("2" (iff)
                          (("2" (prop)
                            (("1" (expand "Union")
                              (("1"
                                (skolem!)
                                (("1"
                                  (typepred a!1)
                                  (("1"
                                    (expand "ppset")
                                    (("1"
                                      (skolem!)
                                      (("1"
                                        (replaceh -1)
                                        (("1"
                                          (expand "cap")
                                          (("1"
                                            (flatten)
                                            (("1"
                                              (assert)
                                              (("1"
                                                (expand "some_at_fwd")
                                                (("1" (inst?) nil nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil)
                             ("2" (expand "Union")
                              (("2"
                                (expand "cap")
                                (("2"
                                  (flatten)
                                  (("2"
                                    (expand "some_at_fwd")
                                    (("2"
                                      (skolem!)
                                      (("2"
                                        (inst
                                         +
                                         "cap(leq(z!1, savf), at_fwd(q!1))")
                                        (("1"
                                          (expand "cap")
                                          (("1" (assert) nil nil))
                                          nil)
                                         ("2"
                                          (expand "ppset")
                                          (("2" (inst?) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (digit type-eq-decl nil ctrees nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (leto_union formula-decl nil bdUnity nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (cap const-decl "bool" ownpred nil)
    (at_fwd const-decl "bool" tournamentUnity1 nil)
    (q!1 skolem-const-decl "Thread[degree, node]" tournamentUnity1 nil)
    (z!1 skolem-const-decl "int" tournamentUnity1 nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (Union_surjective name-judgement
     "(surjective?[setofsets[T], set[T]])" sets_lemmas nil)
    (at_fwd_ensures formula-decl nil tournamentUnity1 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (ppset skolem-const-decl "[pred[state] -> boolean]"
     tournamentUnity1 nil)
    (some_at_fwd const-decl "bool" tournamentUnity1 nil)
    (Union const-decl "set" sets nil)
    (setofsets type-eq-decl nil sets nil)
    (setof type-eq-decl nil defined_types nil)
    (savf const-decl "int" tournamentUnity1 nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (leq const-decl "bool" bdUnity nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil))
   shostak))
 (savf_13_14_unless 0
  (savf_13_14_unless-1 nil 3670852538
   ("" (expand "unless")
    (("" (expand "<=")
      (("" (expand "wp")
        (("" (expand "cap")
          (("" (expand "cup")
            (("" (expand "neg")
              (("" (expand "between")
                (("" (skosimp*)
                  (("" (expand "E1")
                    (("" (expand "step")
                      (("" (split -)
                        (("1" (assert) nil nil)
                         ("2" (skolem!)
                          (("2" (expand "leq")
                            (("2" (use savf_ascends)
                              (("2"
                                (assert)
                                (("2"
                                  (case "q!1=p!1")
                                  (("1"
                                    (replaceh -1)
                                    (("1"
                                      (expand "step")
                                      (("1"
                                        (expand "step11")
                                        (("1"
                                          (assert)
                                          (("1"
                                            (expand "step12")
                                            (("1"
                                              (expand "step15F")
                                              (("1"
                                                (expand "step19")
                                                (("1"
                                                  (expand "step17")
                                                  (("1"
                                                    (expand "step18")
                                                    (("1"
                                                      (expand
                                                       "step15G")
                                                      (("1"
                                                        (expand
                                                         "step16")
                                                        (("1"
                                                          (split)
                                                          (("1"
                                                            (expand
                                                             "step13")
                                                            (("1"
                                                              (flatten)
                                                              (("1"
                                                                (hide
                                                                 3)
                                                                (("1"
                                                                  (replaceh
                                                                   -1)
                                                                  (("1"
                                                                    (expand
                                                                     "next13")
                                                                    (("1"
                                                                      (propax)
                                                                      nil
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (hide
                                                             1
                                                             2
                                                             -4
                                                             -5
                                                             -2)
                                                            (("2"
                                                              (use
                                                               savf_at_14)
                                                              (("2"
                                                                (assert)
                                                                nil
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (hide-all-but (-2 -4 -5 1 3))
                                    (("2"
                                      (case
                                       "y!1`pc(q!1) = s!1`pc(q!1)")
                                      (("1" (assert) nil nil)
                                       ("2"
                                        (hide -2 -3 3)
                                        (("2" (grind) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((<= const-decl "bool" mucalculus nil)
    (cap const-decl "bool" ownpred nil)
    (neg const-decl "bool" ownpred nil)
    (step const-decl "bool" tournamentUnity0 nil)
    (savf_ascends formula-decl nil tournamentUnity1 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (digit type-eq-decl nil ctrees nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (savf_at_14 formula-decl nil tournamentUnity1 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (leq const-decl "bool" bdUnity nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (between const-decl "bool" tournamentUnity0 nil)
    (cup const-decl "bool" ownpred nil)
    (wp const-decl "bool" ownpred nil)
    (unless const-decl "bool" bdUnity nil))
   shostak))
 (doorway_progress 0
  (doorway_progress-1 nil 3670852890
   ("" (skosimp)
    (("" (expand "ass_doorway")
      (("" (inst?)
        (("" (lemma PSP0_leto)
          ((""
            (inst - D "cap(leq(z!1, savf), between(q!1, 13, 14))"
             "between(q!1, 13, 14)" "leq(z!1 + D, savf)" E1)
            (("" (assert)
              (("" (hide - 2)
                (("" (split)
                  (("1" (use savf_13_14_unless)
                    (("1" (assert) nil nil)) nil)
                   ("2" (expand "<=")
                    (("2" (expand "cap") (("2" (skosimp) nil nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((ass_doorway const-decl "bool" tournamentUnity0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (digit type-eq-decl nil ctrees nil)
    (PSP0_leto formula-decl nil bdUnity nil)
    (savf_13_14_unless formula-decl nil tournamentUnity1 nil)
    (<= const-decl "bool" mucalculus nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (between const-decl "bool" tournamentUnity0 nil)
    (savf const-decl "int" tournamentUnity1 nil)
    (leq const-decl "bool" bdUnity nil)
    (cap const-decl "bool" ownpred nil)
    (pred type-eq-decl nil defined_types nil)
    (D const-decl "posnat" tournamentUnity0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil))
   shostak))
 (doorway_progress_1 0
  (doorway_progress_1-1 nil 3670903537
   ("" (skosimp)
    (("" (lemma leto_union)
      (("" (inst - D _ "leq(z!1 + D, savf)" E1)
        ((""
          (name ppset
                "{pp: pred[state] | EXISTS q: pp = cap(leq(z!1, savf), 
between(q, 13, 14)) }")
          (("" (inst - ppset)
            (("" (split)
              (("1" (hide -2)
                (("1"
                  (case "Union(ppset) = cap(leq(z!1, savf), some_doorway)")
                  (("1" (assert) nil nil)
                   ("2" (hide - 2)
                    (("2" (apply-extensionality :hide? t)
                      (("2" (iff)
                        (("2" (prop)
                          (("1" (expand "Union")
                            (("1" (skolem!)
                              (("1"
                                (typepred a!1)
                                (("1"
                                  (expand "ppset")
                                  (("1"
                                    (skolem!)
                                    (("1"
                                      (replaceh -1)
                                      (("1"
                                        (expand "cap")
                                        (("1"
                                          (flatten)
                                          (("1"
                                            (assert)
                                            (("1"
                                              (expand "some_doorway")
                                              (("1"
                                                (inst?)
                                                (("1"
                                                  (expand "between")
                                                  (("1"
                                                    (propax)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (expand "cap")
                            (("2" (flatten)
                              (("2"
                                (expand "some_doorway")
                                (("2"
                                  (skosimp)
                                  (("2"
                                    (expand "Union")
                                    (("2"
                                      (inst
                                       +
                                       "cap(leq(z!1, savf), between(q!1, 13, 14))")
                                      (("1"
                                        (expand "cap")
                                        (("1"
                                          (expand "between")
                                          (("1" (assert) nil nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (expand "ppset")
                                        (("2" (inst?) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (hide 2)
                (("2" (skosimp)
                  (("2" (hide -2)
                    (("2" (expand "ppset")
                      (("2" (skolem!)
                        (("2" (replaceh -1)
                          (("2" (use doorway_progress)
                            (("2" (assert) nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (digit type-eq-decl nil ctrees nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (leto_union formula-decl nil bdUnity nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (cap const-decl "bool" ownpred nil)
    (between const-decl "bool" tournamentUnity0 nil)
    (setof type-eq-decl nil defined_types nil)
    (setofsets type-eq-decl nil sets nil)
    (Union const-decl "set" sets nil)
    (some_doorway const-decl "bool" tournamentUnity1 nil)
    (Union_surjective name-judgement
     "(surjective?[setofsets[T], set[T]])" sets_lemmas nil)
    (ppset skolem-const-decl "[pred[state] -> boolean]"
     tournamentUnity1 nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (z!1 skolem-const-decl "int" tournamentUnity1 nil)
    (q!1 skolem-const-decl "Thread[degree, node]" tournamentUnity1 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (doorway_progress formula-decl nil tournamentUnity1 nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (savf const-decl "int" tournamentUnity1 nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (leq const-decl "bool" bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (D const-decl "posnat" tournamentUnity0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil))
   shostak))
 (cs_unless 0
  (cs_unless-1 nil 3671701894
   ("" (expand "unless")
    (("" (expand "<=")
      (("" (expand "wp")
        (("" (expand "cap")
          (("" (expand "cup")
            (("" (expand "neg")
              (("" (skosimp*)
                (("" (expand "E1")
                  (("" (expand "step")
                    (("" (split -)
                      (("1" (assert) nil nil)
                       ("2" (skolem!)
                        (("2" (expand "at")
                          (("2" (expand "leq")
                            (("2" (case "q!1=p!1")
                              (("1"
                                (replaceh -1)
                                (("1"
                                  (expand "step")
                                  (("1"
                                    (expand "step11")
                                    (("1"
                                      (assert)
                                      (("1"
                                        (expand "step12")
                                        (("1"
                                          (expand "step13")
                                          (("1"
                                            (expand "step14")
                                            (("1"
                                              (expand "step15F")
                                              (("1"
                                                (expand "step15G")
                                                (("1"
                                                  (expand "step17")
                                                  (("1"
                                                    (expand "step18")
                                                    (("1"
                                                      (expand "step19")
                                                      (("1"
                                                        (use
                                                         savf_at_16)
                                                        (("1"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (use savf_ascends)
                                (("2"
                                  (assert)
                                  (("2"
                                    (hide-all-but (-2 -4 1 3))
                                    (("2" (grind) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((<= const-decl "bool" mucalculus nil)
    (cap const-decl "bool" ownpred nil)
    (neg const-decl "bool" ownpred nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (at const-decl "bool" tournamentUnity0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (digit type-eq-decl nil ctrees nil)
    (savf_at_16 formula-decl nil tournamentUnity1 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (savf_ascends formula-decl nil tournamentUnity1 nil)
    (leq const-decl "bool" bdUnity nil)
    (step const-decl "bool" tournamentUnity0 nil)
    (cup const-decl "bool" ownpred nil)
    (wp const-decl "bool" ownpred nil)
    (unless const-decl "bool" bdUnity nil))
   shostak))
 (cs_progress 0
  (cs_progress-1 nil 3671702202
   ("" (skosimp)
    (("" (use cs_unless)
      (("" (lemma PSP0_leto)
        (("" (inst?)
          (("" (assert)
            (("" (expand "ass_cs")
              (("" (inst? -3)
                (("" (inst?)
                  (("" (assert)
                    (("" (hide - 2)
                      (("" (expand "<=")
                        (("" (expand "cap") (("" (skosimp) nil nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((cs_unless formula-decl nil tournamentUnity1 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (cs const-decl "posnat" tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil)
    (cap const-decl "bool" ownpred nil)
    (leq const-decl "bool" bdUnity nil)
    (savf const-decl "int" tournamentUnity1 nil)
    (at const-decl "bool" tournamentUnity0 nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (specification type-eq-decl nil bdUnity nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (ass_cs const-decl "bool" tournamentUnity0 nil)
    (<= const-decl "bool" mucalculus nil)
    (PSP0_leto formula-decl nil bdUnity nil)
    (digit type-eq-decl nil ctrees nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil))
   shostak))
 (cs_progress_1 0
  (cs_progress_1-1 nil 3671702359
   ("" (skosimp)
    (("" (lemma leto_union)
      (("" (inst?)
        (("" (inst?)
          (("" (inst - _ "leq(z!1 + cs, savf)")
            ((""
              (name ppset "{pp : pred [state] | EXISTS q : pp = 
cap(leq(z!1, savf), at(q, 16)) }")
              (("" (inst - ppset)
                (("" (hide -1)
                  (("" (split)
                    (("1"
                      (case "Union(ppset) = cap(leq(z!1, savf), some_cs)")
                      (("1" (assert) nil nil)
                       ("2" (hide - 2)
                        (("2" (apply-extensionality :hide? t)
                          (("2" (iff)
                            (("2" (prop)
                              (("1"
                                (expand "Union")
                                (("1"
                                  (skolem!)
                                  (("1"
                                    (typepred a!1)
                                    (("1"
                                      (expand "ppset")
                                      (("1"
                                        (skolem!)
                                        (("1"
                                          (replaceh -1)
                                          (("1"
                                            (expand "cap")
                                            (("1"
                                              (flatten)
                                              (("1"
                                                (assert)
                                                (("1"
                                                  (expand "some_cs")
                                                  (("1"
                                                    (inst?)
                                                    (("1"
                                                      (expand "at")
                                                      (("1"
                                                        (propax)
                                                        nil
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil)
                               ("2"
                                (expand "cap")
                                (("2"
                                  (flatten)
                                  (("2"
                                    (expand "some_cs")
                                    (("2"
                                      (skolem!)
                                      (("2"
                                        (expand "Union")
                                        (("2"
                                          (inst
                                           +
                                           "cap(leq(z!1, savf), at(q!1, 16))")
                                          (("1"
                                            (expand "cap")
                                            (("1"
                                              (expand "at")
                                              (("1" (assert) nil nil))
                                              nil))
                                            nil)
                                           ("2"
                                            (expand "ppset")
                                            (("2" (inst?) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (hide 2)
                      (("2" (skosimp)
                        (("2" (expand "ppset")
                          (("2" (skolem!)
                            (("2" (replaceh -1)
                              (("2"
                                (use cs_progress)
                                (("2" (assert) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (digit type-eq-decl nil ctrees nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (leto_union formula-decl nil bdUnity nil)
    (cs const-decl "posnat" tournamentUnity0 nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (cap const-decl "bool" ownpred nil)
    (at const-decl "bool" tournamentUnity0 nil)
    (cs_progress formula-decl nil tournamentUnity1 nil)
    (setof type-eq-decl nil defined_types nil)
    (setofsets type-eq-decl nil sets nil)
    (Union const-decl "set" sets nil)
    (some_cs const-decl "bool" tournamentUnity1 nil)
    (Union_surjective name-judgement
     "(surjective?[setofsets[T], set[T]])" sets_lemmas nil)
    (ppset skolem-const-decl "[pred[state] -> boolean]"
     tournamentUnity1 nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (z!1 skolem-const-decl "int" tournamentUnity1 nil)
    (q!1 skolem-const-decl "Thread[degree, node]" tournamentUnity1 nil)
    (savf const-decl "int" tournamentUnity1 nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (leq const-decl "bool" bdUnity nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (pred type-eq-decl nil defined_types nil))
   shostak))
 (exi_unless 0
  (exi_unless-1 nil 3670857284
   ("" (expand "unless")
    (("" (expand "<=")
      (("" (expand "wp")
        (("" (expand "cap")
          (("" (expand "cup")
            (("" (skosimp*)
              (("" (expand "E1")
                (("" (expand "step")
                  (("" (split -)
                    (("1" (assert) nil nil)
                     ("2" (skolem!)
                      (("2" (expand "neg")
                        (("2" (expand "at")
                          (("2" (expand "leq")
                            (("2" (use savf_ascends)
                              (("2"
                                (assert)
                                (("2"
                                  (hide 1)
                                  (("2"
                                    (case "q!1=p!1")
                                    (("1"
                                      (replaceh -1)
                                      (("1"
                                        (expand "step")
                                        (("1"
                                          (hide -1)
                                          (("1"
                                            (expand "step11")
                                            (("1"
                                              (assert)
                                              (("1"
                                                (expand "step12")
                                                (("1"
                                                  (expand "step13")
                                                  (("1"
                                                    (expand "step14")
                                                    (("1"
                                                      (expand
                                                       "step15F")
                                                      (("1"
                                                        (expand
                                                         "step15G")
                                                        (("1"
                                                          (expand
                                                           "step17")
                                                          (("1"
                                                            (expand
                                                             "step16")
                                                            (("1"
                                                              (expand
                                                               "step19")
                                                              (("1"
                                                                (use
                                                                 savf_at_18)
                                                                (("1"
                                                                  (assert)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (hide-all-but (-2 -4 1 2))
                                      (("2" (grind) nil nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((<= const-decl "bool" mucalculus nil)
    (cap const-decl "bool" ownpred nil)
    (step const-decl "bool" tournamentUnity0 nil)
    (at const-decl "bool" tournamentUnity0 nil)
    (savf_ascends formula-decl nil tournamentUnity1 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (digit type-eq-decl nil ctrees nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (empty? const-decl "bool" sets nil)
    (member const-decl "bool" sets nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (savf_at_18 formula-decl nil tournamentUnity1 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (leq const-decl "bool" bdUnity nil)
    (neg const-decl "bool" ownpred nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (cup const-decl "bool" ownpred nil)
    (wp const-decl "bool" ownpred nil)
    (unless const-decl "bool" bdUnity nil))
   shostak))
 (exi_progress 0
  (exi_progress-1 nil 3670857520
   ("" (skosimp)
    (("" (expand "ass_exit")
      (("" (inst?)
        (("" (use exi_unless)
          (("" (lemma PSP0_leto)
            (("" (name-replace pp0 "cap(leq(z!1, savf), at(q!1, 18))")
              (("" (name-replace pp1 "leq(z!1 + exi, savf)")
                (("" (name-replace pp2 "at(q!1, 18)")
                  (("" (inst - exi pp0 pp2 pp1 E1)
                    (("" (assert)
                      (("" (hide - 2)
                        (("" (expand "<=")
                          (("" (expand "pp0")
                            (("" (expand "pp2")
                              ((""
                                (expand "cap")
                                (("" (skosimp) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((ass_exit const-decl "bool" tournamentUnity0 nil)
    (exi_unless formula-decl nil tournamentUnity1 nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (pred type-eq-decl nil defined_types nil)
    (cap const-decl "bool" ownpred nil)
    (leq const-decl "bool" bdUnity nil)
    (savf const-decl "int" tournamentUnity1 nil)
    (at const-decl "bool" tournamentUnity0 nil)
    (<= const-decl "bool" mucalculus nil)
    (pp2 skolem-const-decl "[state[degree, node] -> bool]"
     tournamentUnity1 nil)
    (pp0 skolem-const-decl "[state[degree, node] -> bool]"
     tournamentUnity1 nil)
    (specification type-eq-decl nil bdUnity nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (exi const-decl "posnat" tournamentUnity0 nil)
    (PSP0_leto formula-decl nil bdUnity nil)
    (digit type-eq-decl nil ctrees nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil))
   shostak))
 (exi_progress_1 0
  (exi_progress_1-1 nil 3670904019
   ("" (skosimp)
    (("" (lemma leto_union)
      (("" (inst - exi _ "leq(z!1 + exi, savf)" E1)
        ((""
          (name ppset
                "{pp: pred[state] | EXISTS q: pp = cap(leq(z!1, savf), at(q, 18))}")
          (("" (inst - ppset)
            (("" (hide -1)
              (("" (split)
                (("1"
                  (case "Union(ppset) = cap(leq(z!1, savf), some_exit)")
                  (("1" (assert) nil nil)
                   ("2" (hide - 2)
                    (("2" (apply-extensionality :hide? t)
                      (("2" (iff)
                        (("2" (prop)
                          (("1" (expand "Union")
                            (("1" (skolem!)
                              (("1"
                                (typepred a!1)
                                (("1"
                                  (expand "ppset")
                                  (("1"
                                    (skolem!)
                                    (("1"
                                      (replaceh -1)
                                      (("1"
                                        (expand "cap")
                                        (("1"
                                          (flatten)
                                          (("1"
                                            (assert)
                                            (("1"
                                              (expand "some_exit")
                                              (("1"
                                                (inst?)
                                                (("1"
                                                  (expand "at")
                                                  (("1"
                                                    (propax)
                                                    nil
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (expand "Union")
                            (("2" (expand "cap")
                              (("2"
                                (flatten)
                                (("2"
                                  (expand "some_exit")
                                  (("2"
                                    (skolem!)
                                    (("2"
                                      (inst
                                       +
                                       "cap(leq(z!1, savf), at(q!1, 18))")
                                      (("1"
                                        (expand "cap")
                                        (("1"
                                          (expand "at")
                                          (("1" (assert) nil nil))
                                          nil))
                                        nil)
                                       ("2"
                                        (expand "ppset")
                                        (("2" (inst?) nil nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil)
                 ("2" (hide 2)
                  (("2" (skosimp)
                    (("2" (expand "ppset")
                      (("2" (skolem!)
                        (("2" (replaceh -1)
                          (("2" (use exi_progress)
                            (("2" (assert) nil nil)) nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (digit type-eq-decl nil ctrees nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (leto_union formula-decl nil bdUnity nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (cap const-decl "bool" ownpred nil)
    (at const-decl "bool" tournamentUnity0 nil)
    (exi_progress formula-decl nil tournamentUnity1 nil)
    (setof type-eq-decl nil defined_types nil)
    (setofsets type-eq-decl nil sets nil)
    (Union const-decl "set" sets nil)
    (some_exit const-decl "bool" tournamentUnity1 nil)
    (Union_surjective name-judgement
     "(surjective?[setofsets[T], set[T]])" sets_lemmas nil)
    (ppset skolem-const-decl "[pred[state] -> boolean]"
     tournamentUnity1 nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (z!1 skolem-const-decl "int" tournamentUnity1 nil)
    (q!1 skolem-const-decl "Thread[degree, node]" tournamentUnity1 nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (savf const-decl "int" tournamentUnity1 nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (leq const-decl "bool" bdUnity nil)
    (pred type-eq-decl nil defined_types nil)
    (exi const-decl "posnat" tournamentUnity0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil))
   shostak))
 (waiting_unless 0
  (waiting_unless-1 nil 3670859026
   ("" (expand "unless")
    (("" (expand "<=")
      (("" (expand "wp")
        (("" (expand "cup")
          (("" (expand "cap")
            (("" (expand "neg")
              (("" (skosimp*)
                (("" (expand "E1")
                  (("" (expand "step")
                    (("" (split -)
                      (("1" (assert) nil nil)
                       ("2" (skolem!)
                        (("2" (expand "leq")
                          (("2" (use savf_ascends)
                            (("2" (assert)
                              (("2"
                                (hide -1 1)
                                (("2"
                                  (case "s!1`pc(p!1) = 15")
                                  (("1"
                                    (expand "step")
                                    (("1"
                                      (expand "step11")
                                      (("1"
                                        (assert)
                                        (("1"
                                          (expand "step12")
                                          (("1"
                                            (expand "step13")
                                            (("1"
                                              (expand "step14")
                                              (("1"
                                                (expand "step16")
                                                (("1"
                                                  (expand "step17")
                                                  (("1"
                                                    (expand "step18")
                                                    (("1"
                                                      (expand "step19")
                                                      (("1"
                                                        (use
                                                         savf_at_15)
                                                        (("1"
                                                          (split -3)
                                                          (("1"
                                                            (assert)
                                                            nil
                                                            nil)
                                                           ("2"
                                                            (assert)
                                                            nil
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil)
                                   ("2"
                                    (hide -2 -5 3)
                                    (("2"
                                      (expand "atlev")
                                      (("2"
                                        (flatten)
                                        (("2"
                                          (expand "mubot")
                                          (("2"
                                            (split)
                                            (("1" (grind) nil nil)
                                             ("2" (grind) nil nil)
                                             ("3" (grind) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((<= const-decl "bool" mucalculus nil)
    (cup const-decl "bool" ownpred nil)
    (neg const-decl "bool" ownpred nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (leq const-decl "bool" bdUnity nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (savf_at_15 formula-decl nil tournamentUnity1 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (mubot const-decl "bool" tournamentUnity0 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (finite_remove application-judgement "finite_set" finite_sets nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (nonempty_add_finite application-judgement "non_empty_finite_set"
     finite_sets nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (boolean nonempty-type-decl nil booleans nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (number nonempty-type-decl nil numbers nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (digit type-eq-decl nil ctrees nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (< const-decl "bool" reals nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (savf_ascends formula-decl nil tournamentUnity1 nil)
    (step const-decl "bool" tournamentUnity0 nil)
    (cap const-decl "bool" ownpred nil)
    (wp const-decl "bool" ownpred nil)
    (unless const-decl "bool" bdUnity nil))
   shostak))
 (waiting_progress_lev_mu 0
  (waiting_progress_lev_mu-2 nil 3678791244
   ("" (skosimp)
    (("" (expand "ass_waiting")
      (("" (inst?)
        (("" (lemma PSP_leto)
          (("" (inst?)
            (("" (assert)
              (("" (hide -2)
                (("" (use waiting_unless)
                  (("" (inst?)
                    (("" (assert)
                      (("" (hide -1)
                        ((""
                          (case "cap(atlev(q!1, 15, k!1),
               cap(leq(z!1, savf),
                   cap(atlev(q!1, 15, k!1), mubot(path(q!1, k!1))))) =
cap(leq(z!1, savf),
               cap(atlev(q!1, 15, k!1), mubot(path(q!1, k!1))))")
                          (("1" (replaceh -1)
                            (("1"
                              (case "cup(cap(neg(mubot(path(q!1, k!1))),
                   cap(leq(z!1, savf),
                       cap(atlev(q!1, 15, k!1), mubot(path(q!1, k!1))))),
               leq(W + z!1, savf)) =
leq(W + z!1, savf)")
                              (("1" (assert) nil nil)
                               ("2"
                                (hide - 2)
                                (("2"
                                  (apply-extensionality :hide? t)
                                  (("2"
                                    (iff)
                                    (("2"
                                      (expand "cup")
                                      (("2"
                                        (prop)
                                        (("2"
                                          (expand "cap")
                                          (("2"
                                            (expand "neg")
                                            (("2" (prop) nil nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (hide - 2)
                            (("2" (apply-extensionality :hide? t)
                              (("2"
                                (iff)
                                (("2"
                                  (expand "cap")
                                  (("2" (prop) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((ass_waiting const-decl "bool" tournamentUnity0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil) (digit type-eq-decl nil ctrees nil)
    (PSP_leto formula-decl nil bdUnity nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (waiting_unless formula-decl nil tournamentUnity1 nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (cup const-decl "bool" ownpred nil)
    (cap const-decl "bool" ownpred nil)
    (leq const-decl "bool" bdUnity nil)
    (savf const-decl "int" tournamentUnity1 nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (path const-decl "node" ctrees nil)
    (mubot const-decl "bool" tournamentUnity0 nil)
    (neg const-decl "bool" ownpred nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil))
   nil)
  (waiting_progress_lev_mu-1 nil 3670858868
   ("" (skosimp)
    (("" (expand "ass_waiting")
      (("" (inst?)
        (("" (lemma PSP_leto)
          (("" (inst?)
            (("" (assert)
              (("" (hide -2)
                (("" (use waiting_unless)
                  (("" (inst?)
                    (("" (assert)
                      (("" (hide -1)
                        ((""
                          (case "cap(cap(atlev(q!1, 15, k!1), mubot(take(k!1, q!1))),
               cap(leq(z!1, savf),
                   cap(atlev(q!1, 15, k!1), mubot(take(k!1, q!1))))) =
cap(leq(z!1, savf),
               cap(atlev(q!1, 15, k!1), mubot(take(k!1, q!1))))")
                          (("1" (replaceh -1)
                            (("1"
                              (case "cup(cap(neg(mubot(take(k!1, q!1))),
                   cap(leq(z!1, savf),
                       cap(atlev(q!1, 15, k!1), mubot(take(k!1, q!1))))),
               leq(W + z!1, savf)) =
leq(W + z!1, savf)")
                              (("1" (assert) nil nil)
                               ("2"
                                (hide - 2)
                                (("2"
                                  (apply-extensionality :hide? t)
                                  (("2"
                                    (iff)
                                    (("2"
                                      (expand "cap")
                                      (("2"
                                        (expand "cup")
                                        (("2"
                                          (expand "neg")
                                          (("2" (prop) nil nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil)
                           ("2" (hide -1 2)
                            (("2" (apply-extensionality :hide? t)
                              (("2"
                                (iff)
                                (("2"
                                  (expand "cap")
                                  (("2" (prop) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((ass_waiting const-decl "bool" tournamentUnity0 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (PSP_leto formula-decl nil bdUnity nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (waiting_unless formula-decl nil tournamentUnity1 nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (cup const-decl "bool" ownpred nil)
    (leq const-decl "bool" bdUnity nil)
    (savf const-decl "int" tournamentUnity1 nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (neg const-decl "bool" ownpred nil)
    (mubot const-decl "bool" tournamentUnity0 nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (cap const-decl "bool" ownpred nil)
    (pred type-eq-decl nil defined_types nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (< const-decl "bool" reals nil) (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (below type-eq-decl nil nat_types nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil))
   shostak))
 (waiting_progress 0
  (waiting_progress-2 nil 3678791392
   ("" (skosimp)
    (("" (lemma sub_leto)
      ((""
        (inst - W "cap(leq(z!1, savf), only_some_waiting)" _
         "leq(z!1 + W, savf)" E1)
        (("" (assert)
          (("" (hide 1)
            ((""
              (name ppset "{pp: pred[state] | EXISTS q, k: pp =
        cap(leq(z!1, savf), cap(atlev(q, 15, k), mubot(path(q, k)))) }")
              (("" (inst - "Union(ppset)")
                (("" (hide -1)
                  (("" (split)
                    (("1" (expand "<=")
                      (("1" (expand "Union")
                        (("1" (expand "cap")
                          (("1" (expand "only_some_waiting")
                            (("1" (skosimp*)
                              (("1"
                                (expand "E1")
                                (("1"
                                  (hide -5)
                                  (("1"
                                    (name
                                     km
                                     "min({k | EXISTS q: s!1`pc(q) = 15 AND k = s!1`level(q) })")
                                    (("1"
                                      (typepred km)
                                      (("1"
                                        (hide -3)
                                        (("1"
                                          (skosimp)
                                          (("1"
                                            (hide -6)
                                            (("1"
                                              (inst
                                               +
                                               "cap(leq(z!1, savf), cap(atlev(q!2, 15, km), mubot(path(q!2, km))))")
                                              (("1"
                                                (expand "cap")
                                                (("1"
                                                  (expand "atlev")
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (expand "mubot")
                                                      (("1"
                                                        (name-replace
                                                         nn1
                                                         "path(q!2, km)"
                                                         nil)
                                                        (("1"
                                                          (case
                                                           "kq1(nn1, s!1)")
                                                          (("1"
                                                            (expand
                                                             "kq1")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (flatten)
                                                                (("1"
                                                                  (name-replace
                                                                   rr
                                                                   "s!1`occ(nn1)")
                                                                  (("1"
                                                                    (assert)
                                                                    (("1"
                                                                      (inst
                                                                       -9
                                                                       rr)
                                                                      (("1"
                                                                        (split)
                                                                        (("1"
                                                                          (case
                                                                           "iq4(rr, s!1)")
                                                                          (("1"
                                                                            (expand
                                                                             "iq4")
                                                                            (("1"
                                                                              (assert)
                                                                              nil
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (hide-all-but
                                                                             (-10
                                                                              1))
                                                                            (("2"
                                                                              (expand
                                                                               "globinv")
                                                                              (("2"
                                                                                (expand
                                                                                 "iqall")
                                                                                (("2"
                                                                                  (flatten)
                                                                                  (("2"
                                                                                    (inst?)
                                                                                    (("2"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (inst
                                                                           -
                                                                           "s!1`level(rr)")
                                                                          (("1"
                                                                            (split)
                                                                            (("1"
                                                                              (lemma
                                                                               depth_path)
                                                                              (("1"
                                                                                (inst
                                                                                 -
                                                                                 km
                                                                                 q!2)
                                                                                (("1"
                                                                                  (lift-if)
                                                                                  (("1"
                                                                                    (assert)
                                                                                    nil
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (inst
                                                                               +
                                                                               rr)
                                                                              nil
                                                                              nil))
                                                                            nil)
                                                                           ("2"
                                                                            (case
                                                                             "iq1(rr, s!1)")
                                                                            (("1"
                                                                              (expand
                                                                               "iq1")
                                                                              (("1"
                                                                                (assert)
                                                                                nil
                                                                                nil))
                                                                              nil)
                                                                             ("2"
                                                                              (expand
                                                                               "globinv")
                                                                              (("2"
                                                                                (expand
                                                                                 "iqall")
                                                                                (("2"
                                                                                  (flatten)
                                                                                  (("2"
                                                                                    (inst?)
                                                                                    (("2"
                                                                                      (assert)
                                                                                      nil
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (expand
                                                             "globinv")
                                                            (("2"
                                                              (expand
                                                               "kqall")
                                                              (("2"
                                                                (flatten)
                                                                (("2"
                                                                  (inst?
                                                                   -9)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (expand "ppset")
                                                (("2"
                                                  (inst? +)
                                                  nil
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (hide 2)
                                      (("2"
                                        (expand "nonempty?")
                                        (("2"
                                          (expand "empty?")
                                          (("2"
                                            (expand "member")
                                            (("2"
                                              (inst - "s!1`level(q!1)")
                                              (("1"
                                                (inst + q!1)
                                                nil
                                                nil)
                                               ("2"
                                                (case "iq1(q!1, s!1)")
                                                (("1"
                                                  (expand "iq1")
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (expand "globinv")
                                                  (("2"
                                                    (expand "iqall")
                                                    (("2"
                                                      (flatten)
                                                      (("2"
                                                        (inst? -4)
                                                        (("2"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (use leto_union)
                      (("2" (assert)
                        (("2" (hide 2)
                          (("2" (skosimp)
                            (("2" (expand "ppset")
                              (("2"
                                (skolem!)
                                (("2"
                                  (replaceh -1)
                                  (("2"
                                    (use waiting_progress_lev_mu)
                                    (("2" (assert) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (digit type-eq-decl nil ctrees nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (sub_leto formula-decl nil bdUnity nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (mubot const-decl "bool" tournamentUnity0 nil)
    (path const-decl "node" ctrees nil)
    (leto_union formula-decl nil bdUnity nil)
    (waiting_progress_lev_mu formula-decl nil tournamentUnity1 nil)
    (Union_surjective name-judgement
     "(surjective?[setofsets[T], set[T]])" sets_lemmas nil)
    (<= const-decl "bool" mucalculus nil)
    (empty? const-decl "bool" sets nil)
    (q!1 skolem-const-decl "Thread[degree, node]" tournamentUnity1 nil)
    (member const-decl "bool" sets nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (ppset skolem-const-decl "[pred[state] -> boolean]"
     tournamentUnity1 nil)
    (z!1 skolem-const-decl "int" tournamentUnity1 nil)
    (q!2 skolem-const-decl "Thread[degree, node]" tournamentUnity1 nil)
    (s!1 skolem-const-decl "state[degree, node]" tournamentUnity1 nil)
    (km skolem-const-decl "{a |
         (EXISTS q: s!1`pc(q) = 15 AND a = s!1`level(q)) AND
          (FORALL (x: nat):
             (EXISTS q: s!1`pc(q) = 15 AND x = s!1`level(q)) IMPLIES
              a <= x)}" tournamentUnity1 nil)
    (kq1 const-decl "bool" tournamentSafe0 nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (rr skolem-const-decl "(thread[degree, node])" tournamentUnity1
     nil)
    (depth_path formula-decl nil ctrees nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (iq1 const-decl "bool" tournamentSafe0 nil)
    (iq4 const-decl "bool" tournamentSafe0 nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (kqall const-decl "bool" tournamentSafe0 nil)
    (min const-decl "{a | S(a) AND (FORALL x: S(x) IMPLIES a <= x)}"
         min_nat nil)
    (<= const-decl "bool" reals nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (nonempty? const-decl "bool" sets nil)
    (setof type-eq-decl nil defined_types nil)
    (setofsets type-eq-decl nil sets nil)
    (Union const-decl "set" sets nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (only_some_waiting const-decl "bool" tournamentUnity1 nil)
    (savf const-decl "int" tournamentUnity1 nil)
    (leq const-decl "bool" bdUnity nil)
    (cap const-decl "bool" ownpred nil)
    (pred type-eq-decl nil defined_types nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (int_plus_int_is_int application-judgement "int" integers nil))
   nil)
  (waiting_progress-1 nil 3670857837
   ("" (skosimp)
    (("" (lemma sub_leto)
      ((""
        (inst - W "cap(leq(z!1, savf), only_some_waiting)" _
         "leq(z!1 + W, savf)" E1)
        (("" (assert)
          (("" (hide 1)
            ((""
              (name ppset "{pp: pred[state] | EXISTS q, k: pp = 
cap(leq(z!1, savf), cap(atlev(q, 15, k), mubot(take(k, q)))) }")
              (("1" (inst - "Union(ppset)")
                (("1" (hide -1)
                  (("1" (split)
                    (("1" (expand "<=")
                      (("1" (expand "Union")
                        (("1" (expand "cap")
                          (("1" (expand "only_some_waiting")
                            (("1" (skosimp*)
                              (("1"
                                (expand "E1")
                                (("1"
                                  (hide -5)
                                  (("1"
                                    (name
                                     km
                                     "min({k | EXISTS q: s!1`pc(q) = 15 AND k = s!1`level(q) })")
                                    (("1"
                                      (typepred km)
                                      (("1"
                                        (hide -3)
                                        (("1"
                                          (skosimp)
                                          (("1"
                                            (hide -6)
                                            (("1"
                                              (inst
                                               +
                                               "cap(leq(z!1, savf), cap(atlev(q!2, 15, km), mubot(take(km, q!2))))")
                                              (("1"
                                                (expand "cap")
                                                (("1"
                                                  (expand "atlev")
                                                  (("1"
                                                    (assert)
                                                    (("1"
                                                      (expand "mubot")
                                                      (("1"
                                                        (name-replace
                                                         nn1
                                                         "take(km, q!2)"
                                                         nil)
                                                        (("1"
                                                          (case
                                                           "kq1(nn1, s!1)")
                                                          (("1"
                                                            (expand
                                                             "kq1")
                                                            (("1"
                                                              (assert)
                                                              (("1"
                                                                (flatten)
                                                                (("1"
                                                                  (name-replace
                                                                   rr
                                                                   "s!1`occ(nn1)")
                                                                  (("1"
                                                                    (use
                                                                     level_at14_15
                                                                     (q
                                                                      q!2))
                                                                    (("1"
                                                                      (assert)
                                                                      (("1"
                                                                        (split)
                                                                        (("1"
                                                                          (expand
                                                                           "curnode")
                                                                          (("1"
                                                                            (inst
                                                                             -10
                                                                             rr)
                                                                            (("1"
                                                                              (case
                                                                               "iq4(rr, s!1)")
                                                                              (("1"
                                                                                (expand
                                                                                 "iq4")
                                                                                (("1"
                                                                                  (flatten)
                                                                                  (("1"
                                                                                    (assert)
                                                                                    (("1"
                                                                                      (inst
                                                                                       -
                                                                                       "s!1`level(rr)")
                                                                                      (("1"
                                                                                        (assert)
                                                                                        (("1"
                                                                                          (inst
                                                                                           +
                                                                                           rr)
                                                                                          nil
                                                                                          nil))
                                                                                        nil)
                                                                                       ("2"
                                                                                        (case
                                                                                         "iq1(rr, s!1)")
                                                                                        (("1"
                                                                                          (expand
                                                                                           "iq1")
                                                                                          (("1"
                                                                                            (assert)
                                                                                            nil
                                                                                            nil))
                                                                                          nil)
                                                                                         ("2"
                                                                                          (expand
                                                                                           "globinv")
                                                                                          (("2"
                                                                                            (expand
                                                                                             "iqall")
                                                                                            (("2"
                                                                                              (flatten)
                                                                                              (("2"
                                                                                                (inst?)
                                                                                                (("2"
                                                                                                  (assert)
                                                                                                  nil
                                                                                                  nil))
                                                                                                nil))
                                                                                              nil))
                                                                                            nil))
                                                                                          nil))
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil)
                                                                               ("2"
                                                                                (expand
                                                                                 "globinv")
                                                                                (("2"
                                                                                  (expand
                                                                                   "iqall")
                                                                                  (("2"
                                                                                    (flatten)
                                                                                    (("2"
                                                                                      (inst?
                                                                                       -11)
                                                                                      (("2"
                                                                                        (assert)
                                                                                        nil
                                                                                        nil))
                                                                                      nil))
                                                                                    nil))
                                                                                  nil))
                                                                                nil))
                                                                              nil))
                                                                            nil))
                                                                          nil)
                                                                         ("2"
                                                                          (expand
                                                                           "globinv")
                                                                          (("2"
                                                                            (assert)
                                                                            nil
                                                                            nil))
                                                                          nil))
                                                                        nil))
                                                                      nil))
                                                                    nil))
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil)
                                                           ("2"
                                                            (expand
                                                             "globinv")
                                                            (("2"
                                                              (expand
                                                               "kqall")
                                                              (("2"
                                                                (flatten)
                                                                (("2"
                                                                  (inst?
                                                                   -9)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil)
                                               ("2"
                                                (expand "ppset")
                                                (("2"
                                                  (inst? +)
                                                  nil
                                                  nil))
                                                nil)
                                               ("3"
                                                (hide -)
                                                (("3"
                                                  (typepred pp)
                                                  (("3"
                                                    (expand "tree?")
                                                    (("3"
                                                      (flatten)
                                                      (("3"
                                                        (inst?)
                                                        (("3"
                                                          (assert)
                                                          (("3"
                                                            (typepred
                                                             q!2)
                                                            (("3"
                                                              (expand
                                                               "thread")
                                                              (("3"
                                                                (expand
                                                                 "leaves")
                                                                (("3"
                                                                  (propax)
                                                                  nil
                                                                  nil))
                                                                nil))
                                                              nil))
                                                            nil))
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil)
                                     ("2"
                                      (hide 2)
                                      (("2"
                                        (expand "nonempty?")
                                        (("2"
                                          (expand "empty?")
                                          (("2"
                                            (expand "member")
                                            (("2"
                                              (inst - "s!1`level(q!1)")
                                              (("1"
                                                (inst + q!1)
                                                nil
                                                nil)
                                               ("2"
                                                (case "iq1(q!1, s!1)")
                                                (("1"
                                                  (expand "iq1")
                                                  (("1"
                                                    (assert)
                                                    nil
                                                    nil))
                                                  nil)
                                                 ("2"
                                                  (expand "globinv")
                                                  (("2"
                                                    (expand "iqall")
                                                    (("2"
                                                      (flatten)
                                                      (("2"
                                                        (inst? -4)
                                                        (("2"
                                                          (assert)
                                                          nil
                                                          nil))
                                                        nil))
                                                      nil))
                                                    nil))
                                                  nil))
                                                nil))
                                              nil))
                                            nil))
                                          nil))
                                        nil))
                                      nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil)
                     ("2" (use leto_union)
                      (("2" (assert)
                        (("2" (hide 2)
                          (("2" (skosimp)
                            (("2" (expand "ppset")
                              (("2"
                                (skolem!)
                                (("2"
                                  (replaceh -1)
                                  (("2"
                                    (use waiting_progress_lev_mu)
                                    (("2" (assert) nil nil))
                                    nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (hide -)
                (("2" (skolem!)
                  (("2" (typepred pp)
                    (("2" (expand "tree?")
                      (("2" (flatten)
                        (("2" (inst?)
                          (("2" (assert)
                            (("2" (typepred q!1)
                              (("2"
                                (expand "thread")
                                (("2"
                                  (expand "leaves")
                                  (("2" (propax) nil nil))
                                  nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((int_plus_int_is_int application-judgement "int" integers nil)
    (W const-decl "posnat" tournamentUnity0 nil)
    (pred type-eq-decl nil defined_types nil)
    (cap const-decl "bool" ownpred nil)
    (leq const-decl "bool" bdUnity nil)
    (savf const-decl "int" tournamentUnity1 nil)
    (only_some_waiting const-decl "bool" tournamentUnity1 nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (+ const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (specification type-eq-decl nil bdUnity nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (Union const-decl "set" sets nil)
    (setofsets type-eq-decl nil sets nil)
    (setof type-eq-decl nil defined_types nil)
    (nonempty? const-decl "bool" sets nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (IMPLIES const-decl "[bool, bool -> bool]" booleans nil)
    (<= const-decl "bool" reals nil)
    (min const-decl "{a | S(a) AND (FORALL x: S(x) IMPLIES a <= x)}"
         min_nat nil)
    (kqall const-decl "bool" tournamentSafe0 nil)
    (iq1 const-decl "bool" tournamentSafe0 nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (iq4 const-decl "bool" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (kq1 const-decl "bool" tournamentSafe0 nil)
    (NOT const-decl "[bool -> bool]" booleans nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil)
    (<= const-decl "bool" mucalculus nil)
    (Union_surjective name-judgement
     "(surjective?[setofsets[T], set[T]])" sets_lemmas nil)
    (waiting_progress_lev_mu formula-decl nil tournamentUnity1 nil)
    (leto_union formula-decl nil bdUnity nil)
    (mubot const-decl "bool" tournamentUnity0 nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (sub_leto formula-decl nil bdUnity nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (below type-eq-decl nil nat_types nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil) (< const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (set type-eq-decl nil sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (state type-eq-decl nil tournamentSafe0 nil))
   shostak))
 (covering 0
  (covering-1 nil 3670945449
   ("" (skosimp)
    (("" (case "FORALL q: 11 <= x!1`pc(q) AND x!1`pc(q) <= 19")
      (("1" (case "FORALL q: x!1`pc(q) = 11 OR x!1`pc(q) = 15")
        (("1" (hide -2)
          (("1" (inst-cp + 0)
            (("1" (expand cover 2)
              (("1" (expand "allidle")
                (("1" (skolem!)
                  (("1" (inst-cp - q!1)
                    (("1" (assert)
                      (("1" (inst + 2)
                        (("1" (expand "cover")
                          (("1" (expand "only_some_waiting")
                            (("1" (split)
                              (("1" (propax) nil nil)
                               ("2" (inst? +) nil nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (skosimp)
          (("2" (case "x!1`pc(q!1) = 18")
            (("1" (inst + 3)
              (("1" (expand "cover")
                (("1" (expand "some_exit") (("1" (inst? +) nil nil))
                  nil))
                nil))
              nil)
             ("2" (case "x!1`pc(q!1) = 13 OR x!1`pc(q!1) = 14")
              (("1" (inst + 1)
                (("1" (expand "cover")
                  (("1" (expand "some_doorway")
                    (("1" (inst + q!1) (("1" (ground) nil nil)) nil))
                    nil))
                  nil))
                nil)
               ("2" (flatten)
                (("2" (case "x!1`pc(q!1) = 16")
                  (("1" (inst + 4)
                    (("1" (expand "cover")
                      (("1" (expand "some_cs")
                        (("1" (inst? +) nil nil)) nil))
                      nil))
                    nil)
                   ("2" (inst + 5)
                    (("2" (expand "cover")
                      (("2" (expand "some_at_fwd")
                        (("2" (inst?)
                          (("2" (inst?)
                            (("2" (expand "at_fwd")
                              (("2"
                                (flatten)
                                (("2" (assert) nil nil))
                                nil))
                              nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil)
       ("2" (skosimp)
        (("2" (case "kq0(q!1, x!1)")
          (("1" (expand "kq0") (("1" (propax) nil nil)) nil)
           ("2" (expand "globinv")
            (("2" (expand "kqall")
              (("2" (flatten)
                (("2" (inst?) (("2" (assert) nil nil)) nil)) nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (digit type-eq-decl nil ctrees nil)
    (<= const-decl "bool" reals nil)
    (AND const-decl "[bool, bool -> bool]" booleans nil)
    (Thread type-eq-decl nil tournamentUnity0 nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number nonempty-type-decl nil numbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (boolean nonempty-type-decl nil booleans nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (some_doorway const-decl "bool" tournamentUnity1 nil)
    (some_cs const-decl "bool" tournamentUnity1 nil)
    (at_fwd const-decl "bool" tournamentUnity1 nil)
    (some_at_fwd const-decl "bool" tournamentUnity1 nil)
    (some_exit const-decl "bool" tournamentUnity1 nil)
    (cover const-decl "set[state]" tournamentUnity1 nil)
    (only_some_waiting const-decl "bool" tournamentUnity1 nil)
    (allidle const-decl "bool" tournamentUnity1 nil)
    (OR const-decl "[bool, bool -> bool]" booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (kq0 const-decl "bool" tournamentSafe0 nil)
    (kqall const-decl "bool" tournamentSafe0 nil)
    (globinv const-decl "bool" tournamentSafe1 nil))
   shostak))
 (disgrowth_cover 0
  (disgrowth_cover-1 nil 3670995054
   ("" (expand "disgrowth")
    (("" (skosimp*)
      (("" (case "r!1=1")
        (("1" (expand "cover")
          (("1" (expand "weight")
            (("1" (assert)
              (("1" (use doorway_progress_1) (("1" (assert) nil nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (case "r!1=2")
          (("1" (expand "cover")
            (("1" (expand "weight")
              (("1" (assert)
                (("1" (use waiting_progress) (("1" (assert) nil nil))
                  nil))
                nil))
              nil))
            nil)
           ("2" (case "r!1=3")
            (("1" (expand "weight")
              (("1" (expand "cover")
                (("1" (assert)
                  (("1" (use exi_progress_1) (("1" (assert) nil nil))
                    nil))
                  nil))
                nil))
              nil)
             ("2" (case "r!1 = 4")
              (("1" (expand "weight")
                (("1" (assert)
                  (("1" (expand "cover")
                    (("1" (use cs_progress_1) (("1" (assert) nil nil))
                      nil))
                    nil))
                  nil))
                nil)
               ("2" (expand "weight")
                (("2" (assert)
                  (("2" (expand "cover")
                    (("2" (use some_fwd_progress)
                      (("2" (assert) nil nil)) nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((waiting_progress formula-decl nil tournamentUnity1 nil)
    (cs_progress_1 formula-decl nil tournamentUnity1 nil)
    (some_fwd_progress formula-decl nil tournamentUnity1 nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (even_minus_odd_is_odd application-judgement "odd_int" integers
     nil)
    (odd_minus_odd_is_even application-judgement "even_int" integers
     nil)
    (exi_progress_1 formula-decl nil tournamentUnity1 nil)
    (cover const-decl "set[state]" tournamentUnity1 nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (doorway_progress_1 formula-decl nil tournamentUnity1 nil)
    (weight const-decl "posnat" tournamentUnity1 nil)
    (number nonempty-type-decl nil numbers nil)
    (boolean nonempty-type-decl nil booleans nil)
    (= const-decl "[T, T -> boolean]" equalities nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (real nonempty-type-from-decl nil reals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (int nonempty-type-eq-decl nil integers nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (>= const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (disgrowth const-decl "bool" bdUnity nil))
   shostak))
 (eventual_growth_savf_TCC1 0
  (eventual_growth_savf_TCC1-1 nil 3670997005
   ("" (subtype-tcc) nil nil)
   ((NOT const-decl "[bool -> bool]" booleans nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (N const-decl "posnat" tournamentSafe0 nil)
    (enum_thread const-decl "(bijective?[below[N], (thread)])"
     tournamentSafe0 nil)
    (inverse const-decl "D" function_inverse nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (step const-decl "bool" tournamentUnity0 nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (iq1 const-decl "bool" tournamentSafe0 nil)
    (iq2 const-decl "bool" tournamentSafe0 nil)
    (iq3 const-decl "bool" tournamentSafe0 nil)
    (iq4 const-decl "bool" tournamentSafe0 nil)
    (iq5 const-decl "bool" tournamentSafe0 nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (kq0 const-decl "bool" tournamentSafe0 nil)
    (kq5 const-decl "bool" tournamentSafe0 nil)
    (kq1 const-decl "bool" tournamentSafe0 nil)
    (kq4 const-decl "bool" tournamentSafe0 nil)
    (kqall const-decl "bool" tournamentSafe0 nil)
    (lq2 const-decl "bool" tournamentSafe1 nil)
    (lq1 const-decl "bool" tournamentSafe1 nil)
    (lq0 const-decl "bool" tournamentSafe1 nil)
    (lqall const-decl "bool" tournamentSafe1 nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (digit type-eq-decl nil ctrees nil)
    (exec const-decl "bool" bdUnity nil)
    (fullset const-decl "set" sets nil)
    (at const-decl "bool" tournamentUnity0 nil)
    (neg const-decl "bool" ownpred nil)
    (leto const-decl "bool" bdUnity nil)
    (ass_exit const-decl "bool" tournamentUnity0 nil)
    (ass_cs const-decl "bool" tournamentUnity0 nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (mubot const-decl "bool" tournamentUnity0 nil)
    (ass_waiting const-decl "bool" tournamentUnity0 nil)
    (between const-decl "bool" tournamentUnity0 nil)
    (ass_doorway const-decl "bool" tournamentUnity0 nil)
    (maxDWE const-decl "posnat" tournamentUnity1 nil)
    (posint_max application-judgement "{k: posint | i <= k AND j <= k}"
     real_defs nil)
    (posrat_max application-judgement "{s: posrat | s >= q AND s >= r}"
     real_defs nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil))
   nil))
 (eventual_growth_savf 0
  (eventual_growth_savf-1 nil 3670997073
   ("" (skosimp)
    (("" (use disgrowth_cover)
      (("" (assert)
        (("" (lemma distributed_progress)
          (("" (inst?)
            (("" (inst - "maxDWE" n!1 z!1)
              (("" (assert)
                (("" (split)
                  (("1" (hide -2)
                    (("1" (expand "cover") (("1" (propax) nil nil))
                      nil))
                    nil)
                   ("2" (hide 2 -)
                    (("2" (skolem!)
                      (("2" (expand "weight")
                        (("2" (expand "maxDWE")
                          (("2" (expand "max") (("2" (smash) nil nil))
                            nil))
                          nil))
                        nil))
                      nil))
                    nil)
                   ("3" (hide - 2)
                    (("3" (skosimp)
                      (("3" (expand "E1")
                        (("3" (use covering) (("3" (assert) nil nil))
                          nil))
                        nil))
                      nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil))
        nil))
      nil))
    nil)
   ((disgrowth_cover formula-decl nil tournamentUnity1 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (digit type-eq-decl nil ctrees nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (distributed_progress formula-decl nil bdUnity nil)
    (maxDWE const-decl "posnat" tournamentUnity1 nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (max const-decl "{p: real | p >= m AND p >= n}" real_defs nil)
    (covering formula-decl nil tournamentUnity1 nil)
    (weight const-decl "posnat" tournamentUnity1 nil)
    (savf const-decl "int" tournamentUnity1 nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (cover const-decl "set[state]" tournamentUnity1 nil)
    (pred type-eq-decl nil defined_types nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil))
   shostak))
 (eventual_growth_sinc_TCC1 0
  (eventual_growth_sinc_TCC1-1 nil 3671006711
   ("" (subtype-tcc) nil nil)
   ((NOT const-decl "[bool -> bool]" booleans nil)
    (real_lt_is_strict_total_order name-judgement
     "(strict_total_order?[real])" real_props nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (N const-decl "posnat" tournamentSafe0 nil)
    (enum_thread const-decl "(bijective?[below[N], (thread)])"
     tournamentSafe0 nil)
    (inverse const-decl "D" function_inverse nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (next11 const-decl "state" tournamentSafe0 nil)
    (/= const-decl "boolean" notequal nil)
    (step11 const-decl "bool" tournamentSafe0 nil)
    (goto const-decl "state" tournamentSafe0 nil)
    (step12 const-decl "bool" tournamentSafe0 nil)
    (curnode const-decl "node" tournamentSafe0 nil)
    (curbranch const-decl "digit" tournamentSafe0 nil)
    (next13 const-decl "state" tournamentSafe0 nil)
    (step13 const-decl "bool" tournamentSafe0 nil)
    (next14 const-decl "state" tournamentSafe0 nil)
    (step14 const-decl "bool" tournamentSafe0 nil)
    (next15 const-decl "state" tournamentSafe0 nil)
    (member const-decl "bool" sets nil)
    (empty? const-decl "bool" sets nil)
    (step15F const-decl "bool" tournamentSafe0 nil)
    (step15G const-decl "bool" tournamentSafe0 nil)
    (step16 const-decl "bool" tournamentSafe0 nil)
    (step17 const-decl "bool" tournamentSafe0 nil)
    (next18 const-decl "state" tournamentSafe0 nil)
    (step18 const-decl "bool" tournamentSafe0 nil)
    (next19 const-decl "state" tournamentSafe0 nil)
    (step19 const-decl "bool" tournamentSafe0 nil)
    (step const-decl "bool" tournamentSafe0 nil)
    (step const-decl "bool" tournamentUnity0 nil)
    (iq0 const-decl "bool" tournamentSafe0 nil)
    (iq1 const-decl "bool" tournamentSafe0 nil)
    (iq2 const-decl "bool" tournamentSafe0 nil)
    (iq3 const-decl "bool" tournamentSafe0 nil)
    (iq4 const-decl "bool" tournamentSafe0 nil)
    (iq5 const-decl "bool" tournamentSafe0 nil)
    (iqall const-decl "bool" tournamentSafe0 nil)
    (kq0 const-decl "bool" tournamentSafe0 nil)
    (kq5 const-decl "bool" tournamentSafe0 nil)
    (kq1 const-decl "bool" tournamentSafe0 nil)
    (kq4 const-decl "bool" tournamentSafe0 nil)
    (kqall const-decl "bool" tournamentSafe0 nil)
    (lq2 const-decl "bool" tournamentSafe1 nil)
    (lq1 const-decl "bool" tournamentSafe1 nil)
    (lq0 const-decl "bool" tournamentSafe1 nil)
    (lqall const-decl "bool" tournamentSafe1 nil)
    (globinv const-decl "bool" tournamentSafe1 nil)
    (state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (digit type-eq-decl nil ctrees nil)
    (exec const-decl "bool" bdUnity nil)
    (fullset const-decl "set" sets nil)
    (at const-decl "bool" tournamentUnity0 nil)
    (neg const-decl "bool" ownpred nil)
    (leto const-decl "bool" bdUnity nil)
    (ass_exit const-decl "bool" tournamentUnity0 nil)
    (ass_cs const-decl "bool" tournamentUnity0 nil)
    (atlev const-decl "bool" tournamentUnity0 nil)
    (mubot const-decl "bool" tournamentUnity0 nil)
    (ass_waiting const-decl "bool" tournamentUnity0 nil)
    (between const-decl "bool" tournamentUnity0 nil)
    (ass_doorway const-decl "bool" tournamentUnity0 nil)
    (depthnode const-decl "nat" ctrees nil)
    (DW1 const-decl "posnat" tournamentUnity1 nil)
    (exi1 const-decl "posnat" tournamentUnity0 nil)
    (AA const-decl "posnat" tournamentUnity1 nil)
    (maxDWE const-decl "posnat" tournamentUnity1 nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (even_times_int_is_even application-judgement "even_int" integers
     nil)
    (nnint_plus_nnint_is_nnint application-judgement "nonneg_int"
     integers nil)
    (posint_max application-judgement "{k: posint | i <= k AND j <= k}"
     real_defs nil)
    (posrat_max application-judgement "{s: posrat | s >= q AND s >= r}"
     real_defs nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (int_plus_int_is_int application-judgement "int" integers nil))
   nil))
 (eventual_growth_sinc 0
  (eventual_growth_sinc-1 nil 3671006732
   ("" (skosimp)
    (("" (lemma proportional_progress)
      ((""
        (inst - allidle "kk!1 * (AA - 1)" "neg(competing_leq(kk!1))" AA
         i!1 "maxDWE - 1" E1 sinc savf z!1)
        (("1" (assert)
          (("1" (hide 2)
            (("1" (split)
              (("1" (skosimp)
                (("1" (use eventual_growth_savf (n k!1))
                  (("1" (assert) nil nil)) nil))
                nil)
               ("2" (skosimp)
                (("2" (expand "E1")
                  (("2" (use savf_LWB) (("2" (assert) nil nil)) nil))
                  nil))
                nil)
               ("3" (skosimp)
                (("3" (expand "E1")
                  (("3" (expand "neg")
                    (("3" (use savf_UPB) (("3" (assert) nil nil)) nil))
                    nil))
                  nil))
                nil))
              nil))
            nil))
          nil)
         ("2" (assert) nil nil)
         ("3" (lemma pos_times_le)
          (("3" (inst - "AA-1" kk!1) (("3" (assert) nil nil)) nil))
          nil))
        nil))
      nil))
    nil)
   ((state type-eq-decl nil tournamentSafe0 nil)
    (edigit type-eq-decl nil tournamentSafe0 nil)
    (< const-decl "bool" reals nil)
    (nat nonempty-type-eq-decl nil naturalnumbers nil)
    (thread const-decl "finite_set[node]" tournamentSafe0 nil)
    (finite_set type-eq-decl nil finite_sets nil)
    (is_finite const-decl "bool" finite_sets nil)
    (set type-eq-decl nil sets nil) (digit type-eq-decl nil ctrees nil)
    (degree formal-const-decl "posnat" tournamentUnity1 nil)
    (posnat nonempty-type-eq-decl nil integers nil)
    (> const-decl "bool" reals nil)
    (nonneg_int nonempty-type-eq-decl nil integers nil)
    (>= const-decl "bool" reals nil)
    (bool nonempty-type-eq-decl nil booleans nil)
    (int nonempty-type-eq-decl nil integers nil)
    (integer_pred const-decl "[rational -> boolean]" integers nil)
    (rational nonempty-type-from-decl nil rationals nil)
    (rational_pred const-decl "[real -> boolean]" rationals nil)
    (real nonempty-type-from-decl nil reals nil)
    (real_pred const-decl "[number_field -> boolean]" reals nil)
    (number_field nonempty-type-from-decl nil number_fields nil)
    (number_field_pred const-decl "[number -> boolean]" number_fields
     nil)
    (boolean nonempty-type-decl nil booleans nil)
    (number nonempty-type-decl nil numbers nil)
    (node formal-nonempty-type-decl nil tournamentUnity1 nil)
    (proportional_progress formula-decl nil bdUnity nil)
    (pos_times_le formula-decl nil real_props nil)
    (int_plus_int_is_int application-judgement "int" integers nil)
    (eventual_growth_savf formula-decl nil tournamentUnity1 nil)
    (nnint_plus_posint_is_posint application-judgement "posint"
     integers nil)
    (real_le_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (savf_LWB formula-decl nil tournamentUnity1 nil)
    (savf_UPB formula-decl nil tournamentUnity1 nil)
    (savf const-decl "int" tournamentUnity1 nil)
    (sinc const-decl "int" tournamentUnity0 nil)
    (E1 const-decl "specification[state]" tournamentUnity0 nil)
    (specification type-eq-decl nil bdUnity nil)
    (competing_leq const-decl "bool" tournamentUnity0 nil)
    (neg const-decl "bool" ownpred nil)
    (allidle const-decl "bool" tournamentUnity1 nil)
    (pred type-eq-decl nil defined_types nil)
    (maxDWE const-decl "posnat" tournamentUnity1 nil)
    (kk!1 skolem-const-decl "nat" tournamentUnity1 nil)
    (AA const-decl "posnat" tournamentUnity1 nil)
    (* const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (- const-decl "[numfield, numfield -> numfield]" number_fields nil)
    (numfield nonempty-type-eq-decl nil number_fields nil)
    (mult_divides1 application-judgement "(divides(n))" divides nil)
    (mult_divides2 application-judgement "(divides(m))" divides nil)
    (int_minus_int_is_int application-judgement "int" integers nil)
    (real_ge_is_total_order name-judgement "(total_order?[real])"
     real_props nil)
    (minus_odd_is_odd application-judgement "odd_int" integers nil)
    (nnint_times_nnint_is_nnint application-judgement "nonneg_int"
     integers nil))
   shostak)))

