%% PVS Version 3.1
%% 6.2 [Linux (x86)] (Feb 14, 2003 18:46)
$$$pvs-strategies
; ***                         Section 0                            ***
;
; *** Definitions of access and analysis functions for strategies. ***

;; The global variable *timed-auto-simp-strat* is set to |<timed-auto>_simp|
;; once the name <timed-auto> is determined in either auto_induct or
;; direct_proof.

(setq *timed-auto-simp-strat* 'skip)
(setq *timed-auto-forward-strat* 'skip)
(setq *timed-auto-verbose-proofs* t)
(setq *branch-counter* 0)
(setq *timed-auto-unique-aux* nil)
(setq *timed-auto-rewrite-thy-1* nil)
(setq *timed-auto-rewrite-thy-2* nil)

(defun has_quant (form)
   (let ((has-quant nil))
   (mapobject #'(lambda (x) (if has-quant t
                                (when (or (typep x 'forall-expr)
                                          (typep x 'exists-expr))
                                      (setq has-quant t) t)))
              form)
   has-quant))

(defun has_specific_precond_form (form)
   (let ((has-specific nil))
   (mapobject #'(lambda (x)
                (if has-specific t
                    (when (and (application? x)
                               (name? (operator x))
                               (tc-eq (id (operator x))
                                      '|enabled_specific|))
                    (setq has-specific t) t)))
              form)
   has-specific))

(defun has_specific_precond(forms)
  (eval (cons 'or
              (loop for x in forms collect (has_specific_precond_form x)))))

(defun is_state_var (x)
  (cond (x (string-equal (princ-to-string
                           (setq *type-comment* (type (typecheck
                            (setq *pc-parse-comment* (pc-parse x 'expr))))))
                         "states[actions, MMTstates, time, fintime?]"))))

(defun gather_labels (lis pred)
   (loop for x in lis when (apply pred (list x)) collect (label x)))

(defun gather_negsforms (sforms)
   (loop for x in sforms
         when (if (and (application? (formula x))
                       (name? (operator (formula x))))
                  (tc-eq (id (operator (formula x))) 'NOT)
                  nil)
         collect x))

(defun gather_possforms (sforms)
   (loop for x in sforms
         when (not (if (and (application? (formula x))
                            (name? (operator (formula x))))
                       (tc-eq (id (operator (formula x))) 'NOT)
                       nil))
         collect x))

(defun gather_fnums_label (sforms lab)
   (let ((negsforms (setq *negsforms-comment* (gather_negsforms sforms)))
         (possforms (setq *possforms-comment* (gather_possforms sforms))))
   (let ((negfnums (setq *negfnums-comment*
           (let ((fnum 0))
           (loop for x in negsforms do (setq fnum (- fnum 1))
                 when (member lab (label x)) collect fnum))))
         (posfnums (setq *posfnums-comment*
           (let ((fnum 0))
           (loop for x in possforms do (setq fnum (+ fnum 1))
                 when (member lab (label x)) collect fnum)))))
    (append negfnums posfnums))))

;The following function gathers the formula numbers that will correspond
;to the label once a new, single "negative" formula has been revealed.

(defun gather_fnums_label_adjusted (sforms lab)
   (let ((negsforms (setq *negsforms-comment* (gather_negsforms sforms)))
         (possforms (setq *possforms-comment* (gather_possforms sforms))))
   (let ((negfnums (setq *negfnums-comment*
           (let ((fnum 0))
           (loop for x in negsforms do (setq fnum (- fnum 1))
                 when (member lab (label x)) collect (- fnum 1)))))
         (posfnums (setq *posfnums-comment*
           (let ((fnum 0))
           (loop for x in possforms do (setq fnum (+ fnum 1))
                 when (member lab (label x)) collect fnum)))))
    (append negfnums posfnums))))

(defun gather_forms_label (sforms lab)
    (loop for x in sforms when (member lab (label x)) collect x))

; The function get_sform gets the sform in the list sforms whose formula number
; is fnum.

(defun get_sform (fnum sforms)
   (let ((possforms (gather_possforms sforms))
         (negsforms (gather_negsforms sforms)))
   (cond ((< fnum 0) (nth (- (- fnum) 1) negsforms))
         ((> fnum 0) (nth (- fnum 1) possforms)))))

; The function flatten_length computes the number of new formulae that will
; appear in the sequent if "flatten" is applied to formula whose formula number
; in sforms is fnum.

(defun flatten_length (fnum sforms)
   (let ((sform (setq *form-fl-len-comment* (get_sform fnum sforms))))
   (cond ((< fnum 0)
          (flatten_length_form fnum (argument (formula sform))))
         (t (flatten_length_form fnum (formula sform))))))

; The function flatten_length_form computes the number of new formulae that
; will appear in the sequent if "flatten" is applied to the "apparent" formula
; form whose formula number is fnum.  Only the sign of fnum matters.

(defun flatten_length_form (fnum form)
   (cond ((< fnum 0)
          (cond ((conjunction? form)
                 (+ (flatten_length_form -1 (args1 form))
                    (flatten_length_form -1 (args2 form))))
                ((iff? form) 2)
                (t 1)))
         (t
          (cond ((disjunction? form)
                 (+ (flatten_length_form +1 (args1 form))
                    (flatten_length_form +1 (args2 form))))
                ((implication? form)
                 (+ (flatten_length_form -1 (args1 form))
                    (flatten_length_form +1 (args2 form))))
                (t 1)))))

; The function get_form_label gets the first sform whose label is lab.

(defun get_form_label (sforms lab)
   (let ((fnums-label (gather_fnums_label sforms lab)))
   (cond (fnums-label (get_sform (car fnums-label) sforms))
         (t nil))))

(defun grab_trans (sform)
  (let ((trans_expr nil)
        (expr (formula sform)))
  (mapobject #'(lambda (x) (if trans_expr t
                               (when (and (typep x 'application)
                                          (tc-eq (id (operator x)) '|trans|))
                                     (setq trans_expr x)
                                     t)))
             expr)
   trans_expr))

(defun grab_reachable_expr (sform)
  (let ((reach_expr nil)
        (expr (formula sform)))
  (mapobject #'(lambda (x) (if reach_expr t
                               (when (and (typep x 'application)
                                         (tc-eq (id (operator x)) '|reachable|))
                                     (setq reach_expr x)
                                     t)))
             expr)
   reach_expr))

(defun grab_actions_ref (sforms)
   (cadr (actuals (module-instance
        (car (resolutions (operator (grab_reachable_expr (car sforms)))))))))

(defun grab_adt_constructors (sforms)
   (constructors (adt (type (car (resolutions (type-value
        (grab_actions_ref sforms))))))))

(defun grab_thy_name_base (sforms)
   (id (module-instance (car (resolutions (type-value
        (grab_actions_ref sforms)))))))

(defun grab_inv (sforms)
   (operator (cadr (exprs (argument (expression (formula (car sforms))))))))

(defun grab_inv_def (sforms)
   (definition (declaration (car (resolutions (grab_inv sforms))))))

(defun insert_in_list (val lis) (if (member val lis) lis (cons val lis)))

(defun grab_list_types (sforms)
  (let ((list_types nil))
  (mapobject
   #'(lambda (x)
     (when (and (or (typep x 'type-name) (typep x 'adt-type-name))
                (eq (id x) '|list|))
           (setq list_types
                 (insert_in_list (print-string (car (actuals x))) list_types))
           t))
   sforms)
  list_types))

(defun get_ta_name (thyname)
   (let* ((extnchar (coerce '_ 'character))
          (endpt (position extnchar thyname :from-end t)))
   (subseq thyname 0 endpt)))

(defun simp_strat_name (ta_name)
   (intern (concatenate 'string ta_name "_simp")))

(defun forward_strat_name (ta_name)
   (intern (concatenate 'string ta_name "_forward")))

(defun unique_aux_name (ta_name)
   (concatenate 'string ta_name "_unique_aux"))

(defun rewrite_thy_1_name (ta_name)
   (concatenate 'string ta_name "_rewrite_aux_1"))

(defun rewrite_thy_2_name (ta_name)
   (concatenate 'string ta_name "_rewrite_aux_2"))

(defun action_skolem_name (argname)
   (concatenate 'string (string argname) "_action"))

(defun simple_induct_strat_step (inv invform opterm simp_strat)
   (let* ((opname (id opterm))
          (argnames (mapcar #'id (arguments opterm)))
          (arg_skolem_names (mapcar #'action_skolem_name argnames))
          (argsrest
            (let ((comma-list ""))
                 (loop for argname in (cdr arg_skolem_names) do
                       (setq comma-list
                         (concatenate 'string comma-list
                                       (format nil "~a~a" ", " argname))))
                 comma-list)))
   `(then ,(cons 'reduce_case (cons inv arg_skolem_names))
          (|match_univ_and_simp_probe| ,invform ,simp_strat)
          (set_up_poststate)
          (comment
           ,(if (not (string-equal argsrest ""))
                (format nil "~a~a~a~a~a~a" "Case " opname "("
                        (car arg_skolem_names) argsrest ")" )
                (if argnames (format nil "~a~a~a~a~a" "Case " opname "("
                              (car arg_skolem_names) ")" )
                             (format nil "~a~a" "Case " opname))))
          (postpone))))

(defun simple_induct_strat_step_poststate (inv invform opterm simp_strat)
   (let* ((opname (id opterm))
          (argnames (mapcar #'id (arguments opterm)))
          (arg_skolem_names (mapcar #'action_skolem_name argnames))
          (argsrest
            (let ((comma-list ""))
                 (loop for argname in (cdr arg_skolem_names) do
                       (setq comma-list
                         (concatenate 'string comma-list
                                       (format nil "~a~a" ", " argname))))
                 comma-list)))
   `(then ,(cons 'reduce_case_poststate (cons inv arg_skolem_names))
          (|match_univ_and_simp_probe| ,invform ,simp_strat)
          (set_up_poststate_and_action)
          (reveal "poststate-definition")
          (replace "poststate-definition")
          (hide "poststate-definition")
          (comment
           ,(if (not (string-equal argsrest ""))
                (format nil "~a~a~a~a~a~a" "Case " opname "("
                        (car arg_skolem_names) argsrest ")" )
                (if argnames (format nil "~a~a~a~a~a" "Case " opname "("
                              (car arg_skolem_names) ")" )
                             (format nil "~a~a" "Case " opname))))
          (postpone))))

(defun mk_induction_strategy (sforms inv)
   (let ((thy_name (grab_thy_name_base sforms))
         (opterms (setq *opterms-comment* (grab_adt_constructors sforms)))
         (invform (setq *invform-comment* (grab_inv_def sforms))))
   (let ((list_types (setq *list-types-comment* (grab_list_types sforms))))
   (let ((list_rewrites_cmd (setq *list-rewrites-comment*
           (cons 'then
                 (mapcar
                   #'(lambda (x)
                   (list 'auto-rewrite-theory
                         (format nil "~a~a~a" "list_rewrites[" x "]")))
              (grab_list_types sforms))))))
   (let ((ta_name (get_ta_name (string thy_name))))
   (let ((simp_strat (setq *timed-auto-simp-strat* 
          (simp_strat_name ta_name)))
         (forward_strat (setq *timed-auto-forward-strat* 
          (forward_strat_name ta_name)))
         (unique_aux (setq *timed-auto-unique-aux*
          (unique_aux_name ta_name)))
         (rewrite_thy_1 (setq *timed-auto-rewrite-thy-1*
          (rewrite_thy_1_name ta_name)))
         (rewrite_thy_2 (setq *timed-auto-rewrite-thy-2*
          (rewrite_thy_2_name ta_name))))
   (let ((induction_branches (setq *ind-branch-comment*
           (loop for opterm in opterms collect
            (simple_induct_strat_step inv invform opterm simp_strat)))))
   `(then (auto-rewrite "fintime_unique" "fintime_elim_1" "fintime_elim_2"
                        "fintime_dur")
          (auto-rewrite-theory "bool_rewrites")
          ,list_rewrites_cmd
          (auto-rewrite-theory ,rewrite_thy_1)
          (branch (auto_cases ,inv)
                  ((then (base_case ,inv)
                         (replace "start-state")
                         (simplify)
                         (,simp_strat) (prop_probe)
                         (comment "Base case") (postpone))
                   (branch (induct_cases ,inv) ,induction_branches)))))))))))

(defun mk_induction_strategy_poststate (sforms inv)
   (let ((thy_name (grab_thy_name_base sforms))
         (opterms (setq *opterms-comment* (grab_adt_constructors sforms)))
         (invform (setq *invform-comment* (grab_inv_def sforms))))
   (let ((list_types (setq *list-types-comment* (grab_list_types sforms))))
   (let ((list_rewrites_cmd (setq *list-rewrites-comment*
           (cons 'then
                 (mapcar
                   #'(lambda (x)
                   (list 'auto-rewrite-theory
                         (format nil "~a~a~a" "list_rewrites[" x "]")))
              (grab_list_types sforms))))))
   (let ((ta_name (get_ta_name (string thy_name))))
   (let ((simp_strat (setq *timed-auto-simp-strat* 
          (simp_strat_name ta_name)))
         (forward_strat (setq *timed-auto-forward-strat* 
          (forward_strat_name ta_name)))
         (unique_aux (setq *timed-auto-unique-aux*
          (unique_aux_name ta_name)))
         (rewrite_thy_1 (setq *timed-auto-rewrite-thy-1*
          (rewrite_thy_1_name ta_name)))
         (rewrite_thy_2 (setq *timed-auto-rewrite-thy-2*
          (rewrite_thy_2_name ta_name))))
   (let ((induction_branches (setq *ind-branch-comment*
           (loop for opterm in opterms collect
            (simple_induct_strat_step_poststate
                 inv invform opterm simp_strat)))))
   `(then (auto-rewrite "fintime_unique" "fintime_elim_1" "fintime_elim_2"
                        "fintime_dur")
          (auto-rewrite-theory "bool_rewrites")
          ,list_rewrites_cmd
          (auto-rewrite-theory ,rewrite_thy_1)
          (branch (auto_cases ,inv)
                  ((then (base_case ,inv)
                         (replace "start-state")
                         (simplify)
                         (,simp_strat) (prop_probe)
                         (comment "Base case") (postpone))
                   (branch (induct_cases,inv)
                            ,induction_branches)))))))))))


; ***                         Section 1                                 ***
;
; *** Strategies that support induction and direct proof of invariants. ***

(defstep auto_cases (inv)
  (let ((dummy (setq *capture-context-name* *current-context*)))
  (then (lemma "reachable_trans")
        (expand "reachable_trans_fact")
        (lemma "machine_induct")
        (expand "inductthm")
        (inst -1 inv)
        (split)))
  ""
  "Splitting into machine base and induction cases")

(defstep base_case (inv)
  (let ((sforms (setq *sforms-comment* (s-forms (current-goal *ps*))))
        (transexpr (setq *trans-comment* (grab_trans (cadr sforms))))
        (constrs (setq *constrs-comment*
         (constructors (adt (type (car (exprs (argument transexpr)))))))))
  (then (delete 2)
        (delete -1)
        (expand "base")
        (skolem 1 "prestate")
        (with-labels (flatten-disjunct :depth 1)
                     (("start-state" "conclusion")))
        (flatten_labelled_formula "conclusion")
        (expand "start")
        (expand inv)))
  ""
  "Simplifying the machine base case")

(defstep induct_cases (inv)
  (let ((x (format nil "~a~a~a~a~a"
           "(LAMBDA (a: actions): (FORALL (s: states): reachable(s) & "
           inv
           "(s) & enabled(a,s) & reachable(trans(a,s)) => "
           inv
           "(trans(a,s))))")) )
  (then* (delete 2)
         (expand "inductstep")
         (lemma "actions_induction")
         (inst -1 x)
         (beta)
         (branch (split)
                 ((then (skolem 1 ("s_1" "a_1"))(inst -1 "a_1")(inst -1 "s_1")
                        (inst -2 "s_1" "a_1") (prop))
                  (skip)))))
  ""
  "Splitting the induction case on action class")

(defstep reduce_case (inv &rest vars)
  (let ((dummy1 (setq *varname-comment* (pc-parse "a_1" 'name)))
        (dummy2 (setq *varfind-comment*
                      (find *varname-comment* (collect-skolem-constants))))
        (sforms (setq *sforms-comment-red* (s-forms (current-goal *ps*))))
        (dummy3 (setq *trans-comment* (grab_trans (car sforms))))
        (cmd1 (cond (vars `(then (skolem 1 ,vars) (skolem 1 ("prestate"))))
                   (t '(skolem 1 "prestate")))))
  (let ((cmd `(then ,cmd1
                    (with-labels (flatten)
                        (("pre-state-reachable" "inductive-hypothesis"
                          "full-precondition" "post-state-reachable"
                          "inductive-conclusion")))
                    ,(cons 'reduce_case_2 (cons inv vars)))))
  (then (delete -1 2)
        cmd)))
  ""
  "Applying the standard simplification")

(defstep reduce_case_poststate (inv &rest vars)
  (let ((dummy1 (setq *varname-comment* (pc-parse "a_1" 'name)))
        (dummy2 (setq *varfind-comment*
                      (find *varname-comment* (collect-skolem-constants))))
        (sforms (setq *sforms-comment-red* (s-forms (current-goal *ps*))))
        (dummy3 (setq *trans-comment* (grab_trans (car sforms))))
        (cmd1 (cond (vars `(then (skolem 1 ,vars) (skolem 1 ("prestate"))))
                   (t '(skolem 1 "prestate")))))
  (let ((cmd `(then ,cmd1
                    (with-labels (flatten)
                        (("pre-state-reachable" "inductive-hypothesis"
                          "full-precondition" "post-state-reachable"
                          "inductive-conclusion")))
                    ,(cons 'reduce_case_2_poststate (cons inv vars)))))
  (then (delete -1 2)
        cmd)))
  ""
  "Applying the standard simplification")

(defstep reduce_case_2 (inv &rest vars)
  (let ((dummy1 (setq *reduce2-sforms-comment* (s-forms (current-goal *ps*)))))
   (then
    (with-labels (then (expand "enabled") (flatten "full-precondition"))
                 (("general-precondition" "specific-precondition"
                   "OKstate?-precondition")))
    (expand "trans" "inductive-conclusion" :assert? NONE)
    (expand inv :assert? NONE)
    (simplify)))
  "" "")

(defstep reduce_case_2_poststate (inv &rest vars)
  (let ((dummy1 (setq *reduce2-sforms-comment* (s-forms (current-goal *ps*)))))
   (then
    (with-labels (then (expand "enabled") (flatten "full-precondition"))
                 (("general-precondition" "specific-precondition"
                   "OKstate?-precondition")))
    (replace "poststate-definition" "inductive-conclusion")
    (expand inv :assert? NONE)
    (simplify)))
  "" "")

(defstep auto_induct ()
  (let ((sforms (setq *sforms-comment* (s-forms (current-goal *ps*))))
        (inv (setq *inv-comment* (string (id (grab_inv sforms)))))
        (cmd (setq *cmd-comment* (mk_induction_strategy sforms inv))))
  cmd)
  ""
  "Taking care of the standard steps in the induction proof")

(defstep auto_induct_poststate ()
  (let ((sforms (setq *sforms-comment* (s-forms (current-goal *ps*))))
        (inv (setq *inv-comment* (string (id (grab_inv sforms)))))
        (cmd (setq *cmd-comment* (mk_induction_strategy_poststate sforms inv))))
  cmd)
  ""
  "Taking care of the standard steps in the induction proof")

; The strategy set_up_poststate replaces each "trans" form of the post-state
; by the variable "poststate", which is defined via "name" to equal the "trans"
; form.  The definition of "poststate" is then hidden under the label
; "poststate-definition", to be retrieved as needed.

(defstep set_up_poststate ()
  (let ((sforms (setq *sforms-comment-2* (s-forms (current-goal *ps*))))
        (dummy (setq *poststate-comments-list* nil))
        (post (setq *post-comment*
          (gather_forms_label sforms '|post-state-reachable|)))
        (post-form-nums (setq *post-form-num-comment*
          (gather_fnums_label sforms '|post-state-reachable|))))
  (let ((poststate
         (cond
          (post
           (setq *poststate-comments-list*
             (cons (print-string (argument (argument (formula (car post)))))
                   *poststate-comments-list*))
           (setq *poststate-comment*
                 (print-string (argument (argument (formula (car post)))))))
          (t nil)))
; Note that post-form-num is computed because "replace" refuses to replace to
; a label.  Hopefully that will change, since this computation depends on
; the "name" command adding a new formula at position -1.
        (new-post-form-num (setq *new-post-form-num-comment*
         (cond (post-form-nums (- (car post-form-nums) 1)) (t nil)))))
  (let ((dummy (setq *hereiam* t))
        (cmd (setq *auto-induct-2-cmd-comment*
          (cond
           (poststate `(then (with-labels (name "poststate" ,poststate)
                                          (("poststate-definition")))
                            (replace "poststate-definition" ,new-post-form-num)
                            (hide "poststate-definition")))
           (t '(skip))))))
  cmd)))
  ""
  "Simplifying notation for the poststate on an action branch of induction proof")

(defstep set_up_poststate_and_action ()
  (let ((sforms (setq *sforms-comment-2* (s-forms (current-goal *ps*))))
        (dummy (setq *poststate-comments-list* nil))
        (post (setq *post-comment*
          (gather_forms_label sforms '|post-state-reachable|)))
        (post-form-nums (setq *post-form-num-comment*
          (gather_fnums_label sforms '|post-state-reachable|))))
  (let ((poststate
         (cond
          (post
           (setq *poststate-comments-list*
             (cons (print-string (argument (argument (formula (car post)))))
                   *poststate-comments-list*))
           (setq *poststate-comment*
                 (print-string (argument (argument (formula (car post)))))))
          (t nil)))
        (action
         (cond
          (post
           (setq *action-comment*
                 (print-string (car (exprs (argument
                               (argument (argument (formula (car post))))))))))
          (t nil)))
; Note that post-form-num is computed because "replace" refuses to replace to
; a label.  Hopefully that will change, since this computation depends on
; the "name" command adding a new formula at position -1.
        (new-post-form-num (setq *new-post-form-num-comment*
         (cond (post-form-nums (- (car post-form-nums) 1)) (t nil)))))
  (let ((dummy (setq *hereiam* t))
        (cmd (setq *auto-induct-2-cmd-comment*
          (cond
           (poststate `(then (with-labels (name "action" ,action)
                                          (("action-definition")))
                             (with-labels (name "poststate" ,poststate)
                                          (("poststate-definition")))
                             (replace "poststate-definition" ,new-post-form-num)
                             (hide "poststate-definition")))
           (t '(skip))))))
  cmd)))
  ""
  "Simplifying notation for the poststate on an action branch of induction proof")

;; The strategy prop_probe is used to test whether the remainder of a proof
;; is "trivial".  It is part of several other "_probe" strategies.

(defstep prop_probe ()
  (then* (lift-if)
         (prop)
         (assert)
         (fail))
  "" "")

(defstep |match_univ_and_simp_probe| (invform simp_strat)
  (let ((dummy (setq *branch-counter* (+ 1 *branch-counter*)))
        (quantvars (setq *quantvars-comment*
         (if (forall-expr? invform) (bindings invform) nil))))
  (let ((skolemvars (setq *skolemvars-comment*
         (mapcar #'(lambda (x) (format nil "~a~a" x "_theorem"))
          (mapcar #'id quantvars)))))
  (let ((skolemcmd (setq *skolemcmd-comment*
         (if skolemvars `(skolem "inductive-conclusion" ,skolemvars) '(skip))))
        (instcmd (setq *instcmd-comment*
         (if skolemvars
             (cons 'inst (cons "inductive-hypothesis" skolemvars))
             '(skip))))
        (simp_stratcmd `(,simp_strat)))
  (then skolemcmd instcmd
        (flatten_labelled_formula '|inductive-hypothesis|)
        (flatten_labelled_formula '|inductive-conclusion|)
        simp_stratcmd (prop_probe)))))
  "" "")

(defstep direct_proof ()
  (let ((sforms (setq *sforms-comment* (s-forms (current-goal *ps*))))
        (inv-name (setq *inv-comment* (string (id (grab_inv sforms)))))
        (thy_name (grab_thy_name_base sforms)))
  (let ((ta_name (get_ta_name (string thy_name))))
  (let ((simp_strat (setq *timed-auto-simp-strat*
         (simp_strat_name ta_name)))
        (forward_strat (setq *timed-auto-forward-strat*
          (forward_strat_name ta_name)))
        (unique_aux (setq *timed-auto-unique-aux*
         (unique_aux_name ta_name)))
        (rewrite_thy_1 (setq *timed-auto-rewrite-thy-1*
         (rewrite_thy_1_name ta_name)))
        (rewrite_thy_2 (setq *timed-auto-rewrite-thy-2*
         (rewrite_thy_2_name ta_name))))
  (then (skolem 1 "prestate")
        (expand inv-name)
        (with-labels (flatten-disjunct :depth 1)
                     (("prestate-reachable" "conclusion")))
        (flatten_labelled_formula "conclusion")
        (direct_proof_2)))))
  ""
  "Doing the standard steps of a non-induction proof")

(defstep direct_proof_2 ()
  (let ((sforms (s-forms (current-goal *ps*)))
        (inv (setq *direct-inv-commnet*
         (formula (car (select-seq sforms 1)))))
        (simpcmd `(,*timed-auto-simp-strat*))
        (skolemcmd
         (if (forall-expr? inv)
             (let ((quantvars (setq *quantvars-comment* (bindings inv))))
             (let ((skolemvars (setq *skolemvars-comment*
                    (mapcar #'(lambda (x) (format nil "~a~a" x "_theorem"))
                     (mapcar #'id quantvars)))))
             `(skolem 1 ,skolemvars)))
             '(skip))))
  (then skolemcmd (flatten_labelled_formula '|conclusion|) simpcmd))
  ""
  "Doing the standard steps of a non-induction proof")

(defstep direct_induction ()
  (let ((sforms (setq *sforms-comment* (s-forms (current-goal *ps*))))
        (inv-name (setq *inv-comment* (string (id (grab_inv sforms)))))
        (thy_name (grab_thy_name_base sforms)))
  (let ((ta_name (get_ta_name (string thy_name))))
  (let ((simp_strat (setq *timed-auto-simp-strat*
         (simp_strat_name ta_name)))
        (forward_strat (setq *timed-auto-forward-strat*
         (forward_strat_name ta_name)))
        (unique_aux (setq *timed-auto-unique-aux*
         (unique_aux_name ta_name)))
        (rewrite_thy_1 (setq *timed-auto-rewrite-thy-1*
         (rewrite_thy_1_name ta_name)))
        (rewrite_thy_2 (setq *timed-auto-rewrite-thy-2*
         (rewrite_thy_2_name ta_name))))
  (then (skolem 1 "prestate")
        (expand inv-name)
        (with-labels (flatten-disjunct :depth 1)
                     (("prestate-reachable" "conclusion")))
        (flatten_labelled_formula "conclusion")
        (direct_induction_2)
        ))))
  ""
  "Doing the standard steps of a direct-induction proof")

(defstep direct_induction_2 ()
  (let ((sforms (s-forms (current-goal *ps*)))
        (inv (setq *direct-inv-comment*
          (formula (car (select-seq sforms 1)))))
        (ind-var-name (setq *direct-inductvar-comment*
          (id (car (bindings inv)))))
        (ind-skolem-var-name (format nil "~a~a" ind-var-name "_induct"))
        (ind-type-name (setq *direct-inducttype-comment*
          (let ((induct-type (type (car (bindings inv)))))
          (cond ((subtype? induct-type) (id (print-type induct-type)))
                ((adt-type-name? induct-type)
                 (id (type (car (resolutions induct-type)))))))))
        (ind-lemma-name (format nil "~a~a" ind-type-name "_induction"))
        (ind-inst-cmd (setq *direct-instcmd-comment*
          ;June 8, 2001
          ;Note one really wants to replace (bindings inv) by
          ;(bindings inv) with commas between items.
          (format nil "~a~a~a~a~a" "(LAMBDA " (bindings inv) ": "
                  (expression inv) ")")))
        (simpcmd `(,*timed-auto-simp-strat*))
        (quantvars (setq *quantvars-comment0* (bindings (expression inv))))
        (skolemvars (setq *skolemvars-comment0*
          (mapcar #'(lambda (x) (format nil "~a~a" x "_theorem"))
                  (mapcar #'id quantvars))))
        (specializecmd
          (setq *direct-specialize-comment*
           (if (forall-expr? (expression inv))
               `,(cons 'specialize_induction_to skolemvars)
               '(skip))))
        (skolemcmd
          (if (forall-expr? (expression inv))
              `(skolem 1 ,skolemvars)
              '(skip)))
        (inductcmd
          (if (forall-expr? inv)
              (let ((inductvars (setq *inductvars-comment* (bindings inv))))
              (let ((inductname (setq *inductname-comment*
                    (id (car inductvars)))))
              `(then (apply_lemma_no_comment ,ind-lemma-name)
                     (inst -1 ,ind-inst-cmd)
                     (beta)
                     (branch
                      (split)
                      (,simpcmd
                       (then (hide "conclusion")
                             (label "induction-base-case"
                                    ,(format nil "~a" ind-lemma-name))
                             ,skolemcmd
                             (flatten_labelled_formula "induction-base-case")
                             ,simpcmd)
                       (then (hide "conclusion")
                             (label "induction-step-case"
                                    ,(format nil "~a" ind-lemma-name))
                             (skolem "induction-step-case"
                                     ,ind-skolem-var-name)
                             (with-labels
                              (flatten-disjunct "induction-step-case" :depth 1)
                              (("inductive-hypothesis" "inductive-conclusion")))
                             ,specializecmd
                             (flatten_labelled_formula "inductive-conclusion")
                             (flatten_labelled_formula "inductive-hypothesis")
                             ,simpcmd))))))
              '(skip))))
  inductcmd)
  ""
  "Doing the standard steps of a direct-induction proof")

; ***                         Section 2                            ***
;
; ***   Specialized simplification strategies for timed automata.  ***

; Simplification strategies that handle time definitions and other simple
; types of reasoning needed for timed automata.

(defstep time_etc_simp ()
  (then  (lift-if)
         (assert)
         (prop)
         (assert)
         (expand "time_thy.zero" :assert? NONE)
         (expand "time_thy.<=" :assert? NONE)
         (lift-if)
         (expand "time_thy.>=" :assert? NONE)
         (lift-if)
         (expand "<" :assert? NONE)
         (lift-if)
         (expand ">" :assert? NONE)
         (lift-if)
         (expand "+" :assert? NONE)
         (lift-if)
         (expand "-" :assert? NONE)
         (lift-if)
         (repeat* (then* (assert) (split) (lift-if) (flatten)))
 ;       (repeat* (forward-chain "fintime_elim_1"))
 ; Experimental change 2-15-01
         (forward-chain "fintime_elim_1")
         (forward-chain "fintime_elim_1")
         (forward-chain "fintime_elim_1")
 ;       (repeat* (forward-chain "fintime_elim_2"))
 ; Experimental change 2-15-01
         (forward-chain "fintime_elim_2")
         (forward-chain "fintime_elim_2")
         (forward-chain "fintime_elim_2")
         (list_forward_chain)
         )
  ""
  "Doing time-arithmetic")

(defstep list_forward_chain ()
  (then (then (forward-chain "listforward_6") (simplify))
        (then (forward-chain "listforward_5") (simplify))
        (forward-chain "listforward_7")
        (then (forward-chain "listforward_4") (simplify))
        (forward-chain "listforward_8")
        (forward-chain "listforward_1a")
        (forward-chain "listforward_1")
        (forward-chain "listforward_2")
        (forward-chain "listforward_3")
        (forward-chain "listforward_9"))
  "" "")

(defstep time_vals_simp ()
  (then* (expand "time_thy.zero")
         (expand "time_thy.<=")
         (expand "time_thy.>=")
         (expand "<")
         (expand ">")
         (expand "+")
         (expand "-")
         (lift-if)
         )
  ""
  "Doing time-arithmetic")

(defstep try_simp ()
   (let ((sforms (setq *sforms-trysimp-comment* (s-forms (current-goal *ps*))))
         (neg_quantform_list (setq *neg-quantform-comment*
          (gather-fnums (s-forms (current-goal *ps*)) '- nil
                        #'(lambda (sform)
                            (let ((expr (formula sform)))
                                 (has_quant expr))))))
         (pos_quantform_list (setq *pos-quantform-comment*
          (gather-fnums (s-forms (current-goal *ps*)) '+ nil
                        #'(lambda (sform)
                            (let ((expr (formula sform)))
                                 (has_quant expr)))))))
   (let ((label-hide-cmd
          `(then (label_formula_list
                   "quantified-formula"
                   ,(append neg_quantform_list pos_quantform_list))
                 (hide "quantified-formula")))
          (rewrite-init-cmd
           `(auto-rewrite-theory ,*timed-auto-rewrite-thy-1*))
          (rewrite-unique-cmd
           `(then (auto-rewrite-theory ,*timed-auto-unique-aux*)
                  (assert)
                  (stop-rewrite-theory ,*timed-auto-unique-aux*)))
          (rewrite-change-cmd-1
           `(then (stop-rewrite-theory ,*timed-auto-rewrite-thy-1*)
                  (auto-rewrite-theory ,*timed-auto-rewrite-thy-2*)))
          (rewrite-change-cmd-2
           `(then (stop-rewrite-theory ,*timed-auto-rewrite-thy-2*)
                  (auto-rewrite-theory ,*timed-auto-unique-aux*)
                  (assert)
                  (stop-rewrite-theory ,*timed-auto-unique-aux*))))
   (then label-hide-cmd
         rewrite-init-cmd
         (time_etc_simp)
         (reveal "quantified-formula")
; NOTE: the following LIFT-IF is included simply so that the base case
; in lemma_3_3_3 in fischer can be handled.  If it is omitted, and
; time_vals_simp is done first, then lift-if fails to turn the CASE
; expression into an if-then-else expression.  Perhaps this is a result
; of some unexpected property of using EXPAND with :assert? NONE  ???
         (lift-if)
         (time_vals_simp)
         (repeat* (then* (lift-if) (split) (flatten) (assert)))
; NOTE: the following takes care of several cases where apply-extensionality
; was previously needed.
         rewrite-change-cmd-1
         (assert)
; NOTE: the following takes care of the cases where one previously had to
; apply a "unique_aux" lemma to the effect that if two actions of the same
; kind are equal, then their parameters are equal.
         rewrite-change-cmd-2
; NOTE: it is unclear why apply-extensionality seems to be needed in some
; cases; the rewrites should handle what it does !!!!  See, in particular,
; the proof of lemma_5_2 in fischer.
         (apply-extensionality)
         )))
   ""
   "Applying simple reasoning")

(defstep try_simp_again2 ()
   (let ((sforms (setq *sforms-trysimp-comment* (s-forms (current-goal *ps*))))
         (neg_quantform_list (setq *neg-quantform-comment*
          (gather-fnums (s-forms (current-goal *ps*)) '- nil
                        #'(lambda (sform)
                            (let ((expr (formula sform)))
                                 (has_quant expr))))))
         (pos_quantform_list (setq *pos-quantform-comment*
          (gather-fnums (s-forms (current-goal *ps*)) '+ nil
                        #'(lambda (sform)
                            (let ((expr (formula sform)))
                                 (has_quant expr)))))))
   (let ((label-hide-cmd
          `(then (label_formula_list
                   "quantified-formula"
                   ,(append neg_quantform_list pos_quantform_list))
                 (hide "quantified-formula")))
          (forward-cmd `(,*timed-auto-forward-strat*)))
          (rewrite-init-cmd
           `(auto-rewrite-theory ,*timed-auto-rewrite-thy-1*))
          (rewrite-stop-cmd
           `(stop-rewrite-theory ,*timed-auto-rewrite-thy-1*))
          (rewrite-unique-cmd
           `(then (auto-rewrite-theory ,*timed-auto-unique-aux*)
                  (assert)
                  (stop-rewrite-theory ,*timed-auto-unique-aux*)))
          (rewrite-change-cmd-1
           `(then (stop-rewrite-theory ,*timed-auto-rewrite-thy-1*)
                  (auto-rewrite-theory ,*timed-auto-rewrite-thy-2*)))
          (rewrite-change-cmd-2
           `(then (stop-rewrite-theory ,*timed-auto-rewrite-thy-2*)
                  (auto-rewrite-theory ,*timed-auto-unique-aux*)
                  (assert)
                  (stop-rewrite-theory ,*timed-auto-unique-aux*))))
   (then label-hide-cmd
         rewrite-stop-cmd
         forward-cmd
         (try (then (repeat* (replace*)) (assert)) (skip) (skip))
         rewrite-init-cmd
         (time_etc_simp)
         (reveal "quantified-formula")
; NOTE: the following LIFT-IF is included simply so that the base case
; in lemma_3_3_3 in fischer can be handled.  If it is omitted, and
; time_vals_simp is done first, then lift-if fails to turn the CASE
; expression into an if-then-else expression.  Perhaps this is a result
; of some unexpected property of using EXPAND with :assert? NONE  ???
         (lift-if)
; NOTE: iff solves a problem in one application (rpc_memoryimpl) where
; a = b and c = d are insufficient for ASSERT to conclude that a AND c
; = b AND d (all values being boolean).  Thus, it really is mostly a band-aid.
         (iff)
         (time_vals_simp)
         (repeat* (then (lift-if) (split) (flatten) (assert)))
         rewrite-stop-cmd
         forward-cmd
         (try (then (repeat* (replace*)) (assert)) (skip) (skip))
; NOTE: the following takes care of several cases where apply-extensionality
; was previously needed.
         rewrite-change-cmd-1
         (assert)
; NOTE: the following takes care of the cases where one previously had to
; apply a "unique_aux" lemma to the effect that if two actions of the same
; kind are equal, then their parameters are equal.
         rewrite-change-cmd-2
; NOTE: it is unclear why apply-extensionality seems to be needed in some
; cases; the rewrites should handle what it does !!!!  See, in particular,
; the proof of lemma_5_2 in fischer.
         (apply-extensionality)
         ))
   ""
   "Applying simple reasoning")


; ***                         Section 3                            ***
;
; ***        Apply-lemma strategies for timed automata.            ***

; Some of the apply-lemma strategies are specialized for application of
; state invariant lemmas.

(defstep apply_lemma (lem &rest args)
  (let ((instcmd (cons 'inst (cons -1 args)))
        (cmd (setq *cmd-comment2*
                   `(then (with-labels (lemma ,lem) ((,lem)))
                          (apply_lemma_2 ,instcmd ,lem)))))
  cmd)
  ""
  "Applying a lemma to some arguments")

(defstep apply_lemma_2 (instcmd lemma_name)
   (let ((sforms (setq *applylem2-sforms-comment*
           (s-forms (current-goal *ps*))))
         (lemma_formula_list (setq *lemma-lab-comment*
           (loop for sform in sforms
            when (string-equal (princ-to-string (car (label sform)))
                               (princ-to-string lemma_name))
            collect sform)))
         (lemma_body (setq *body-comment*
           (cond (lemma_formula_list (formula (car lemma_formula_list)))
                 (t nil))))
         (lemma_comment (setq *comment-comment*
           (cond
            ((and lemma_body *timed-auto-verbose-proofs*)
             (format nil "~a~a~a~a" "Applying the lemma
" (princ-to-string (argument lemma_body)) "
to the arguments
" (cddr instcmd)))
            (t "")))) 
         (cmd (setq *apply2-cmd-comment*
           (cond (lemma_body
                   `(then (comment ,lemma_comment)
                          ,instcmd (,*timed-auto-simp-strat*)))
                 (t '(skip))))))
   cmd)
   "" "")
         
(defstep apply_lemma_no_comment (lem &rest args)
  (let ((instcmd (cons 'inst (cons -1 args)))
        (cmd (setq *cmd-comment2*
                   `(then (with-labels (lemma ,lem) ((,lem)))
                          ,instcmd (,*timed-auto-simp-strat*)))))
  cmd)
  ""
  "Applying a lemma to some arguments")

; poststate_strategy is used in supporting application of invariant lemmas
; to the poststate in an induction proof -- it is called indirectly by
; apply_inv_lemma

(defstep poststate_strategy (lemma_name)
  (let ((sforms (setq *sforms-comment* (s-forms (current-goal *ps*))))
        (poststate-fnums (setq *poststate-strategy-fnums-comment*
          (gather_fnums_label sforms (intern lemma_name))))
        (cmd (setq *poststate-strategy-command-comment*
             `(then (replace "poststate-definition" ,poststate-fnums rl)
                    (do_trans ,lemma_name)
                    (hide "poststate-definition")))))
  cmd)
  "" "")

(defstep apply_inv_lemma (invno &rest state+quantvars)
  (let ((cmd (setq *apply-inv-lemma-cmd-comment*
        (let ((state-arg-present (is_state_var (car state+quantvars))))
        (cond (state-arg-present
               (let ((state (setq *state-comment* (car state+quantvars)))
                     (quantvars (setq *quantvars-comment*
                                      (cdr state+quantvars))))
               (setq *state-cmd-comment*
               (cond (quantvars
                      `(apply_univ_inv_lemma ,invno ,quantvars ,state))
                     (t `(apply_simple_inv_lemma ,invno ,state))))))
              (t (setq *no-state-cmd-comment*
                 (cond (state+quantvars `(apply_univ_inv_lemma ,invno
                                            ,state+quantvars))
                       (t `(apply_simple_inv_lemma ,invno))))))))))
  cmd)
  ""
  "Applying a state invariant")
                                    
(defstep apply_simple_inv_lemma (invno &optional statevar)
  (let ((lemma_name (setq *simple-lemmaname-comment*
         (format nil "~a~a" "lemma_" invno)))
        (theorem_name (setq *simple-theoremname-comment*
         (format nil "~a~a" "theorem_" invno)))
        (inv_name (format nil "~a~a" "Inv_" invno))
        (state (cond (statevar) (t "prestate"))))
  (let ((poststate-cmd
        (setq *simple-poststate-cmd-comment*
        (cond ((string-equal state "poststate")
                `(then (reveal "poststate-definition")
                       (poststate_strategy ,lemma_name)))
              (t '(skip))))))
  (then (try (apply_lemma_no_comment lemma_name state)
             (skip)
             (apply_lemma_no_comment theorem_name state))
        (apply (then (split -1 :depth 1) (assert)))
        (expand inv_name)
        (apply_simple_inv_lemma_2 lemma_name)
        poststate-cmd)))
  ""
  "Applying the appropriate invariant lemma")

(defstep apply_simple_inv_lemma_2 (lemma_name)
  (let ((sforms (setq *simple-sforms-comment* (s-forms (current-goal *ps*))))
        (lemma_body (setq *simple-body-comment*
         (formula (car (loop for sform in sforms
                    when (string-equal (princ-to-string (car (label sform)))
                                       (princ-to-string lemma_name))
                    collect sform)))))
         (lemma_comment (setq *simple-comment-comment*
          (cond
           (*timed-auto-verbose-proofs*
            (format nil "~a~a" "Applying the lemma
" (princ-to-string (argument lemma_body))))
           (t "")))) 
        (simp_cmd (list *timed-auto-simp-strat*))
        (cmd (setq *apply2-cmd-comment* `(then (comment ,lemma_comment)
                    (,*timed-auto-simp-strat*)))))
        cmd)
  "" "")

(defstep apply_univ_inv_lemma (invno quantvars &optional statevar)
  (let ((lemma_name (setq *univ-lemmaname-comment*
         (format nil "~a~a" "lemma_" invno)))
        (theorem_name (setq *univ-theoremname-comment*
         (format nil "~a~a" "lemma_" invno)))
        (inv_name (format nil "~a~a" "Inv_" invno))
        (state (setq *univ-state-comment* (cond (statevar) (t "prestate"))))
        (inst_cmd (cons 'inst (cons '-1 quantvars)))
        (dummy (setq *inst-comment* (princ-to-string inst_cmd))))
  (let ((poststate-cmd
         (setq *univ-poststate-cmd-comment*
               (cond ((string-equal state "poststate")
                       `(then (reveal "poststate-definition")
                              (poststate_strategy ,lemma_name)))
                     (t '(skip))))))
  (then (try (apply_lemma_no_comment lemma_name state)
             (skip)
             (apply_lemma_no_comment theorem_name state))
        (apply (then (split -1 :depth 1)(assert)))
        (expand inv_name)
        (apply_univ_inv_lemma_2 lemma_name inst_cmd)
        poststate-cmd)))
  ""
  "Applying and instantiating the appropriate invariant lemma")

(defstep apply_univ_inv_lemma_2 (lemma_name inst_cmd)
  (let ((sforms (setq *univ-sforms-comment* (s-forms (current-goal *ps*))))
        (lemma_body (setq *univ-body-comment*
         (formula (car (loop for sform in sforms
                    when (string-equal (princ-to-string (car (label sform)))
                                       (princ-to-string lemma_name))
                    collect sform)))))
        (lemma_comment (setq *univ-comment-comment*
         (cond
          (*timed-auto-verbose-proofs*
           (format nil "~a~a" "Applying the lemma
" (princ-to-string (argument lemma_body))))
          (t "")))) 
        (simp_cmd (list *timed-auto-simp-strat*))
        (cmd (setq *apply2-cmd-comment* `(then (comment ,lemma_comment)
                    ,inst_cmd
                    (,*timed-auto-simp-strat*)))))
        cmd)
  "" "")

; ***                         Section 4                             ***
;
; ***                  Other standard TAME steps.                   ***

(defstep apply_ind_hyp (&rest var)
   (let ((simplification_strat *timed-auto-simp-strat*)
         (instcmd (setq *apply-ind-hyp-inst-comment*
            (cons 'inst (cons "inductive-hypothesis" var))))
         (cmd `(,simplification_strat)))
   (then (reveal "inductive-hypothesis")
         instcmd
         cmd))
   "" "")

; The strategy apply_specific_precond is broken into two parts in order
; to permit the specific precondition to be expanded and the resulting
; formula to be printed as a comment.

(defstep apply_specific_precond ()
   (let ((sforms
          (setq *sforms-precond-comment* (s-forms (current-goal *ps*)))))
   (let ((simp-flag (setq *simp-flag-comment* (has_specific_precond sforms))))
   (then (with-labels (try (expand "enabled") (flatten) (skip))
                      (("general-precondition" "specific-precondition"
                        "OKstate?-precondition")) :push? T)
         (expand "enabled_specific")
         (apply_specific_precond_2 simp-flag))))
  "" "")

(defstep apply_specific_precond_2 (simp-flag)
   (let ((sforms
          (setq *sforms-precond-comment2* (s-forms (current-goal *ps*))))
         (simplification_strat *timed-auto-simp-strat*))
   (let ((precond_sform (get_form_label sforms '|specific-precondition|)))
   (let ((precond_form (setq *precond-form-comment*
          (cond (precond_sform (argument (formula precond_sform)))
                (t nil)))))
   (let ((cmd (setq *precond-cmd-comment*
          (cond (precond_form `(then
                 (comment
                   ,(cond (*timed-auto-verbose-proofs*
                           (format nil "~a~a" "Applying the precondition
" (princ-to-string precond_form)))
                          (t "")))
                 (flatten_labelled_formula '|specific-precondition|)
                 (,simplification_strat)))
                (simp-flag `(,simplification_strat))
                (t '(skip))))))
    cmd))))
  "" "")

(defstep apply_general_precond () (expand "enabled_general") "" "")

(defstep use_OKstate ()
   (let ((simp_cmd (list *timed-auto-simp-strat*)))
   (then (expand "OKstate?")
         simp_cmd
         (do_trans "OKstate?-precondition")))
  ""
  "using the OKstate? precondition")

(defstep suppose (x)
   (let ((simp_cmd (list *timed-auto-simp-strat*))
         (suppstring (setq *supp-comment*
          (format nil "~a~a" "Suppose " x)))
         (nsuppstring (setq *supp-not-comment*
          (format nil "~a~a~a" "Suppose not [" x "]"))))
   (branch (with-labels (case x) (("Suppose") ("Suppose not")))
           ((then simp_cmd (comment suppstring))
            (then simp_cmd (comment nsuppstring)))))
   "" "")

;; The strategy const_facts introduces the facts about the constants from
;; the axiom "const_facts" in the template.  It has two segments, to allow
;  the body of the axiom "const_facts" to be expanded and printed as a comment.

(defstep const_facts ()
  (then (with-labels (lemma "const_facts") (("const_facts")))
        (const_facts_2))
  ""
  "Adducing facts about the constants")

(defstep const_facts_2 ()
   (let ((sforms
          (setq *sforms-const-comment* (s-forms (current-goal *ps*))))
         (simplification_strat *timed-auto-simp-strat*)
         (const_form (setq *const-form-comment*
          (argument (formula
           (get_form_label sforms '|const_facts|)))))
         (cmd (setq *const-cmd-comment* `(then
                (comment ,(format nil "~a~a" "Applying the facts about the constants:
" (princ-to-string const_form)))
                (flatten_labelled_formula '|const_facts|)
                (,simplification_strat)))))
    cmd)
  "" "")

(defstep do_trans (&optional formnum)
   (let ((cmd (cond (formnum
                    `(then (expand "trans" ,formnum)
                          ;(,*timed-auto-simp-strat*)
                          ;experiment 6-11-01
                           (,(cond (*timed-auto-simp-strat*) (t '(skip))))
                           (lift-if ,formnum)(assert)(assert)))
                    (t `(then (expand "trans")
                             ;(,*timed-auto-simp-strat*)
                             ;experiment 6-11-01
                              (,(cond (*timed-auto-simp-strat*) (t '(skip))))
                              (lift-if)(assert)(assert))))))
    cmd)
   ""
   "Computing the transition")

(defstep compute_poststate (&optional lab)
   (let ((sforms (setq *sforms-comment* (s-forms (current-goal *ps*))))
         (formnums (setq *compute-post-formnums-comment*
        ;   (gather_fnums_label sforms (intern lab))))
            (gather_fnums_label_adjusted sforms (intern lab))))
        ; above is repair created 6-1-01
         (cmd (cond (formnums
                    `(then (reveal "poststate-definition")
                           (replace "poststate-definition" ,formnums rl)
                           (hide "poststate-definition")
                           (do_trans ,lab)))
                    (t '(then (reveal "poststate-definition")
                              (replace "poststate-definition" * rl)
                              (hide "poststate-definition")
                              (do_trans))))))
    cmd)
   ""
   "Computing the poststate")

; The strategy focus_on differs from the "scr" version in that the value
; of the poststate is not repeatedly substituted.  Note that focus_on does
; not work well unless a label is passed as argument.

(defstep focus_on (lab)
   (let ((cmd `(apply (repeat*
                     (then (split ,lab) (lift-if ,lab)
                           (flatten_labelled_formula ,lab) (assert))))))
   cmd)
   "" "")

(defstep inst_in (lab &rest args)
   (let ((cmd (setq *inst_in-cmd-comment* `(then (focus_on ,lab)
                     ,(cons 'inst (cons lab args))
                     (,*timed-auto-simp-strat*)
                     ))))
   cmd)
   "" "")

(defstep skolem_in (lab &rest args)
   (let ((cmd (setq *skolem_in-cmd-comment* `(then (focus_on ,lab)
                     (skolem ,lab ,args)
                     (,*timed-auto-simp-strat*)
                     ))))
   cmd)
   "" "")

(defstep verbose ()
   (let ((dummy (setq *timed-auto-verbose-proofs* t)))
   (skip))
   "" "")

(defstep nonverbose ()
   (let ((dummy (setq *timed-auto-verbose-proofs* nil)))
   (skip))
   "" "")

; ***                         Section 5                             ***
;
; *** Definitions and strategies to support reasoning about epsilon ***

(defun attach_arg (x y)
   (if (null y)
       (format nil "~a~a" x ")")
       (if (null (cdr y))
           (format nil "~a~a~a~a" x ", " (car y) ")")
           (format nil "~a~a~a" x ", " (attach_arg (car y) (cdr y))))))

(defun make_pref_expr (eps_pred_name &rest eps_pred_args)
   (if (null eps_pred_args)
       eps_pred_name
       (format nil "~a~a~a" eps_pred_name "("
                   (attach_arg (car eps_pred_args) (cdr eps_pred_args)))))

(defun grab_epsilon_expr (sforms predname)
  (cond (sforms (cond ((grab_epsilon_expr_2 (car sforms) predname))
                      (t (grab_epsilon_expr (cdr sforms) predname))))
        (t nil)))

(defun grab_epsilon_expr_2 (sform predname)
  (let ((epsilon_expr nil)
        (expr (formula sform)))
  (mapobject #'(lambda (x) (if epsilon_expr t
                               (when (and (typep x 'application)
                                         (tc-eq (id (operator x)) '|epsilon|)
                                         (tc-eq
                                           (cond ((application? (argument x))
                                                  (id (operator (argument x))))
                                                 ((name-expr? (argument x))
                                                  (id (argument x))))
                                           (intern predname)))
                                     (setq epsilon_expr x)
                                     t)))
             expr)
   epsilon_expr))

(defstep use_epsilon (eps_pred_name &rest eps_pred_args)
   (let ((sforms (setq *sforms-comment* (s-forms (current-goal *ps*))))
         (eps_expr (setq *epsilon-comment*
           (grab_epsilon_expr sforms eps_pred_name)))
         (inst_pred (setq *pred-comment*
           (cond ((setq *args-comment* eps_pred_args)
                  (setq *args-comment2*
                  (eval (cons 'make_pref_expr
                              (cons eps_pred_name eps_pred_args)))))
                 (t (princ-to-string (argument eps_expr))))))
         (eps_constraints_comment
           (format nil "~a~a~a" "Introducing the constraints on
epsilon(" inst_pred ")"))
         (eps_obligation_comment
           (format nil "~a~a" "Proof that there is a value satisfying
" inst_pred))
         (eps_type (setq *type-comment* (type eps_expr)))
         (eps_lemma (setq *epslemma-comment*
          (format nil "~a~a~a" "epsilon_ax[" (princ-to-string eps_type) "]")))
         (eps_lemma_cmd (setq *epslemma-comment2* `(lemma ,eps_lemma)))
         (expand_cmd (setq *expand-comment* `(expand ,eps_pred_name 1))))
   (then eps_lemma_cmd
         (inst -1 inst_pred)
         (branch (with-labels
                  (split -1)
                  (("epsilon axiom")
                   ("epsilon axiom existence proof obligation")))
                 ((then (expand eps_pred_name -1 1) (flatten)
                        (comment eps_constraints_comment))
                  (then expand_cmd
                        (comment eps_obligation_comment))))))
  ""
  "Adducing facts about an epsilon expression")

(defstep epsilon_witness (witness)
   (let ((simplification_strat *timed-auto-simp-strat*)
        (simp-cmd `(,simplification_strat)))
   (then (inst "epsilon axiom existence proof obligation" witness)
         simp-cmd))
   "" "")
   
; ***                         Section 7                             ***
;
; ***             Miscellaneous auxiliary strategies.               ***

(defstep specialize_induction_to (&rest vars)
   (let ((cmd `(then (skolem "inductive-conclusion" ,vars)
                     ,(cons 'inst (cons "inductive-hypothesis" vars)))))
        cmd)
   "" "")

; flatten_labelled_formula completely flattens the formula with label lab,
; labelling the resulting parts in the order they appear in the original
; formula.  All parts also retain their original label.

; A peculiarity of this strategy is that it uses a longer label list than
; should be necessary.  For some reason, the :push? T does not work on the
; last label in the list.  Therefore, a new label |dummy| is appended to the
; list of labels.

(defstep flatten_labelled_formula (lab)
   (let ((sforms
          (setq *sforms-flatten-comment* (s-forms (current-goal *ps*)))))
   (let ((labval (intern (eval lab))))
   (let ((fnums
          (setq *fnums-flatten-comment*
                (gather_fnums_label sforms labval))))
   (let ((cmd (setq *flatten-cmd-comment*
          (cons 'then
           (let ((labcount 0) (lablist nil))
           (loop for x in fnums do
                ;(setq labcount (+ labcount 1))
                 (setq lablist (setq *fl-lablist-comment*
                   (loop for y from 1 to
                      (setq *fl-len-comment* (flatten_length x sforms)) collect
                         (format nil "~a~a~a"
                                 labval "_part_"
                                 (setq labcount (+ labcount 1))))))
                 collect `(with-labels (flatten ,x)
                           (,(append lablist '(|dummy|)))
                           :push? T)))))))
   cmd))))
   "" "")

; label_formula_list expects a list fnums of formula numbers, and a label
; lab.  It pushes lab as an extra label on each indicated formula in the
; sequent.

(defstep label_formula_list (lab fnums)
   (let ((labval (eval lab)))
   (let ((cmd (setq *label-list-comment*
          (cons 'then
           (loop for x in fnums
                 collect `(label ,labval ,x :push? T))))))
   cmd))
   "" "")

; The strategy modus_ponens is used to avoid splitting an assertion having
; a complex hypothesis identical to another assertion present.

(defstep modus_ponens (fnum)
  (branch (split fnum) ((skip) (assert))) 
  ""
  "Attempting to eliminate an hypothesis")


; ***                         Section 10                           ***
;
; ***   Special strategies for proving auxliary theory lemmas.     ***

(defstep rewrite_aux_1_strat ()
   (then (skolem!) (flatten) (replace -1 * rl) (assert))
   "" "")

(defstep rewrite_aux_2_strat ()
   (then (skolem!) (flatten) (apply-extensionality))
   "" "")

(defstep action_unique_strat_1 (constructor destructor)
   (let ((cmd
         `(then
           (skolem 1 ("x_1" "x_2"))
           (flatten)
           (branch (case ,(format nil "~a~a~a~a~a"
                          "x_1 = " destructor "(" constructor "(x_1))"))
                   ((branch (case ,(format nil "~a~a~a~a~a"
                                   "x_2 = " destructor "("
                                   constructor "(x_2))"))
                            ((then (replace -1 +) (replace -2 +) (hide -1 -2)
                                  (replace -1))
                             (assert)))
                    (assert))))))
   cmd)
   "" "")

; ***                         Section 12                           ***
;
; ***        Grabbing the application-specific  strategies.        ***

(load "local-strategies")


$$$ttmbisimul.pvs

sebisimul: THEORY

BEGIN

	IMPORTING ttm1_invariants
	IMPORTING ttm2_invariants

% Beginning of definition of intermediate states and actions etc.
	
	action: DATATYPE
	BEGIN
	 tick: tick?
	  tau: tau?
	END action

	s1,s10: VAR S_state;
	s2,s20: VAR I_state;
	a1,a11: VAR S_action;
	a2,a22: VAR I_action;

	state: TYPE = s_internal_state

	ps1(s1): state = s1`basic

	ps2(s2): state = (# Relay:=s2`basic`Relay,
			    Power:=s2`basic`Power, 
			    Pressure:=s2`basic`Pressure #)

	pa1(a1): action = 
		CASES a1 OF
			tick: tick,
	  		mu: tau,
          		omega29: tau,	  
	  		alpha: tau,
	  		omega19: tau,
			rho1: tau,
	  		rho2: tau,
			gamma: tau,
			wr: tau,
	  		ws: tau,
	  		pr: tau,
	  		ps: tau	 	
		ENDCASES

	pa2(a2): action =
		CASES a2 OF
			tick: tick,
	  		mu1: tau,  
	  		alpha: tau,
	  		mu2: tau,
			rho1: tau,
	  		rho2: tau,
			gamma: tau,
			wr: tau,
	  		ws: tau,
	  		pr: tau,
	  		ps: tau	 
		ENDCASES

	Is_tau?(a:action): bool = (a=tau) 

	dd1(s1,a1,s10): bool =
		enabled(a1,s1)&(s10 = trans(a1,s1))

	dd2(s2,a2,s20): bool =
		enabled(a2,s2)&(s20 = trans(a2,s2))

	IMPORTING ttm_lib@sebisim[state,S_state,I_state,action,S_action,I_action,ps1,ps2,pa1,pa2,dd1,dd2,Is_tau?]

		sim12_2: LEMMA    (s1`activity = b
  			&  s2`basic`c1 >= 1
			&  s2`basic`c1 <= 29
			&  ((s1`action_time(omega29) = fintime(s2`basic`c1) AND
         			s2`action_time(mu1) = one)
        			OR
        			(s1`action_time(omega29) + one = fintime(s2`basic`c1) AND
          			s2`action_time(mu1) = zero))
			&  enabled(a1, s1)
			&  Inv_11(s1)
			&  Inv_21(s2)
			&  Inv_1(s1)
			&  Inv_2(s2)
			&  s1`action_time(alpha) = s2`action_time(alpha)
 			&  s1`action_time(rho1) = s2`action_time(rho1)
 			&  s1`action_time(rho2) = s2`action_time(rho2)
 			&  s1`action_time(gamma) = s2`action_time(gamma)
			&  s1`action_time(wr) = s2`action_time(wr)
			&  s1`action_time(ws) = s2`action_time(ws)
			&  s1`action_time(pr) = s2`action_time(pr)
			&  s1`action_time(ps) = s2`action_time(ps)
			&  ps1(s1) = ps2(s2))
		=>
			   (EXISTS (s2a: I_state),
             			(a22: I_action), (s2b: I_state), (s2c: I_state):
        			(   sitc(r2, ps2)(s2, s2a) & dd2(s2a, a22, s2b)
          			& sitc(r2, ps2)(s2b, s2c) & ps1(trans(a1, s1)) = ps2(s2c)
          			& pa1(a1) = pa2(a22) & Inv_11(trans(a1, s1)) & Inv_21(s2c)
          			& Inv_1(trans(a1, s1)) & Inv_2(s2c)
          			& trans(a1, s1)`action_time(alpha) = s2c`action_time(alpha)
          			& trans(a1, s1)`action_time(rho1) = s2c`action_time(rho1)
          			& trans(a1, s1)`action_time(rho2) = s2c`action_time(rho2)
          			& trans(a1, s1)`action_time(gamma) = s2c`action_time(gamma)
          			& trans(a1, s1)`action_time(wr) = s2c`action_time(wr)
          			& trans(a1, s1)`action_time(ws) = s2c`action_time(ws)
          			& trans(a1, s1)`action_time(pr) = s2c`action_time(pr)
          			& trans(a1, s1)`action_time(ps) = s2c`action_time(ps)
          			& ps1(trans(a1, s1)) = ps2(s2c)
          			& (    (trans(a1, s1)`activity = a AND
                   			(s2c`basic`c1 = 0 & s2c`basic`c2 = 0) AND
                    			(trans(a1, s1)`action_time(mu) =
                      			s2c`action_time(mu1)))
              			OR (trans(a1, s1)`activity = b AND
                   			s2c`basic`c1 >= 1 AND
                    			s2c`basic`c1 <= 29 AND
                     			((trans(a1, s1)`action_time(omega29) =
                        			fintime(s2c`basic`c1)
                        			AND s2c`action_time(mu1) = one)
                       		OR
                       			(trans(a1, s1)`action_time(omega29) + one =
                         			fintime(s2c`basic`c1)
                         			AND s2c`action_time(mu1) = zero)))
              			OR (trans(a1, s1)`activity = c AND s2c`basic`c1 = 30)
              			OR (trans(a1, s1)`activity = d AND
                   			s2c`basic`c2 >= 1 AND
                    			s2c`basic`c2 <= 19 AND
                     			((trans(a1, s1)`action_time(omega19) =
                        			fintime(s2c`basic`c2)
                        			AND s2c`action_time(mu2) = one)
                       			OR
                       			(trans(a1, s1)`action_time(omega19) + one =
                         			fintime(s2c`basic`c2)
                         			AND s2c`action_time(mu2) = zero)))
              			OR (trans(a1, s1)`activity = e AND s2c`basic`c2 = 20))))
		or  	(EXISTS (s2d: I_state):
             			ps1(trans(a1, s1)) = ps2(s2d) AND Is_tau?(pa1(a1))
         			AND sitc(r2, ps2)(s2, s2d) AND Inv_11(trans(a1, s1))
         			AND Inv_21(s2d) AND Inv_1(trans(a1, s1)) AND Inv_2(s2d)
         			AND trans(a1, s1)`action_time(alpha) = s2d`action_time(alpha)
         			AND trans(a1, s1)`action_time(rho1) = s2d`action_time(rho1)
         			AND trans(a1, s1)`action_time(rho2) = s2d`action_time(rho2)
         			AND trans(a1, s1)`action_time(gamma) = s2d`action_time(gamma)
         			AND trans(a1, s1)`action_time(wr) = s2d`action_time(wr)
         			AND trans(a1, s1)`action_time(ws) = s2d`action_time(ws)
         			AND trans(a1, s1)`action_time(pr) = s2d`action_time(pr)
         			AND trans(a1, s1)`action_time(ps) = s2d`action_time(ps)
         			AND ps1(trans(a1, s1)) = ps2(s2d)
         			AND (    (trans(a1, s1)`activity = a AND
                    			(s2d`basic`c1 = 0 & s2d`basic`c2 = 0) AND
                     			(trans(a1, s1)`action_time(mu) =
                       			s2d`action_time(mu1)))
               				OR (trans(a1, s1)`activity = b AND
                    			s2d`basic`c1 >= 1 AND
                     			s2d`basic`c1 <= 29 AND
                      			((trans(a1, s1)`action_time(omega29) =
                         			fintime(s2d`basic`c1)
                         			AND s2d`action_time(mu1) = one)
                        			OR
                        			(trans(a1, s1)`action_time(omega29) + one =
                          			fintime(s2d`basic`c1)
                          			AND s2d`action_time(mu1) = zero)))
               				OR (trans(a1, s1)`activity = c AND s2d`basic`c1 = 30)
               				OR (trans(a1, s1)`activity = d AND
                    				s2d`basic`c2 >= 1 AND
                     				s2d`basic`c2 <= 19 AND
                      				((trans(a1, s1)`action_time(omega19) =
                         				fintime(s2d`basic`c2)
                         				AND s2d`action_time(mu2) = one)
                        			OR
                        				(trans(a1, s1)`action_time(omega19) + one =
                          				fintime(s2d`basic`c2)
                          				AND s2d`action_time(mu2) = zero)))
               				OR (trans(a1, s1)`activity = e AND s2d`basic`c2 = 20)))



	sim12_4: LEMMA 		((s1`activity = d AND
        			s2`basic`c2 >= 1 AND
         			s2`basic`c2 <= 19 AND
          			((s1`action_time(omega19) = fintime(s2`basic`c2) AND
             			s2`action_time(mu2) = one)
            			OR
            			(s1`action_time(omega19) + one = fintime(s2`basic`c2) AND
              			s2`action_time(mu2) = zero)))
				&  enabled(a1, s1)
				&  Inv_11(s1)
				&  Inv_21(s2)
				&  Inv_1(s1)
				&  Inv_2(s2)
				&  s1`action_time(alpha) = s2`action_time(alpha)
				&  s1`action_time(rho1) = s2`action_time(rho1)
				&  s1`action_time(rho2) = s2`action_time(rho2)
				&  s1`action_time(gamma) = s2`action_time(gamma)
				&  s1`action_time(wr) = s2`action_time(wr)
				&  s1`action_time(ws) = s2`action_time(ws)
				&  s1`action_time(pr) = s2`action_time(pr)
				&  s1`action_time(ps) = s2`action_time(ps)
				&  ps1(s1) = ps2(s2))
  			=>
   			(EXISTS (s2a: I_state),
             				(a22: I_action), (s2b: I_state), (s2c: I_state):
        				(   sitc(r2, ps2)(s2, s2a) & dd2(s2a, a22, s2b)
          				& sitc(r2, ps2)(s2b, s2c) & ps1(trans(a1, s1)) = ps2(s2c)
          				& pa1(a1) = pa2(a22) & Inv_11(trans(a1, s1)) & Inv_21(s2c)
          				& Inv_1(trans(a1, s1)) & Inv_2(s2c)
          				& trans(a1, s1)`action_time(alpha) = s2c`action_time(alpha)
          				& trans(a1, s1)`action_time(rho1) = s2c`action_time(rho1)
          				& trans(a1, s1)`action_time(rho2) = s2c`action_time(rho2)
          				& trans(a1, s1)`action_time(gamma) = s2c`action_time(gamma)
          				& trans(a1, s1)`action_time(wr) = s2c`action_time(wr)
          				& trans(a1, s1)`action_time(ws) = s2c`action_time(ws)
          				& trans(a1, s1)`action_time(pr) = s2c`action_time(pr)
          				& trans(a1, s1)`action_time(ps) = s2c`action_time(ps)
          				& ps1(trans(a1, s1)) = ps2(s2c)
          				& (    (trans(a1, s1)`activity = a AND
                   				(s2c`basic`c1 = 0 & s2c`basic`c2 = 0) AND
                    				(trans(a1, s1)`action_time(mu) =
                      				s2c`action_time(mu1)))
              				OR (trans(a1, s1)`activity = b AND
                   				s2c`basic`c1 >= 1 AND
                    				s2c`basic`c1 <= 29 AND
                     				((trans(a1, s1)`action_time(omega29) =
                        				fintime(s2c`basic`c1)
                        				AND s2c`action_time(mu1) = one)
                       				OR
                       				(trans(a1, s1)`action_time(omega29) + one =
                         				fintime(s2c`basic`c1)
                         				AND s2c`action_time(mu1) = zero)))
              				OR (trans(a1, s1)`activity = c AND s2c`basic`c1 = 30)
              				OR (trans(a1, s1)`activity = d AND
                   				s2c`basic`c2 >= 1 AND
                    				s2c`basic`c2 <= 19 AND
                     				((trans(a1, s1)`action_time(omega19) =
                        				fintime(s2c`basic`c2)
                        				AND s2c`action_time(mu2) = one)
                       				OR
                       				(trans(a1, s1)`action_time(omega19) + one =
                         				fintime(s2c`basic`c2)
                         				AND s2c`action_time(mu2) = zero)))
              				OR (trans(a1, s1)`activity = e AND s2c`basic`c2 = 20))))
			or   (EXISTS (s2d: I_state):
             				ps1(trans(a1, s1)) = ps2(s2d) AND Is_tau?(pa1(a1))
         				AND sitc(r2, ps2)(s2, s2d) AND Inv_11(trans(a1, s1))
         				AND Inv_21(s2d) AND Inv_1(trans(a1, s1)) AND Inv_2(s2d)
         				AND trans(a1, s1)`action_time(alpha) = s2d`action_time(alpha)
         				AND trans(a1, s1)`action_time(rho1) = s2d`action_time(rho1)
         				AND trans(a1, s1)`action_time(rho2) = s2d`action_time(rho2)
         				AND trans(a1, s1)`action_time(gamma) = s2d`action_time(gamma)
         				AND trans(a1, s1)`action_time(wr) = s2d`action_time(wr)
         				AND trans(a1, s1)`action_time(ws) = s2d`action_time(ws)
        				AND trans(a1, s1)`action_time(pr) = s2d`action_time(pr)
         				AND trans(a1, s1)`action_time(ps) = s2d`action_time(ps)
         				AND ps1(trans(a1, s1)) = ps2(s2d)
         				AND (    (trans(a1, s1)`activity = a AND
                    				(s2d`basic`c1 = 0 & s2d`basic`c2 = 0) AND
                     				(trans(a1, s1)`action_time(mu) =
                       					s2d`action_time(mu1)))
               					OR (trans(a1, s1)`activity = b AND
                    				s2d`basic`c1 >= 1 AND
                     				s2d`basic`c1 <= 29 AND
                      				((trans(a1, s1)`action_time(omega29) =
                         				fintime(s2d`basic`c1)
                         				AND s2d`action_time(mu1) = one)
                        				OR
                        				(trans(a1, s1)`action_time(omega29) + one =
                          				fintime(s2d`basic`c1)
                          				AND s2d`action_time(mu1) = zero)))
               					OR (trans(a1, s1)`activity = c AND s2d`basic`c1 = 30)
               					OR (trans(a1, s1)`activity = d AND
                    					s2d`basic`c2 >= 1 AND
                     					s2d`basic`c2 <= 19 AND
                      				((trans(a1, s1)`action_time(omega19) =
                         				fintime(s2d`basic`c2)
                         				AND s2d`action_time(mu2) = one)
                        				OR
                        				(trans(a1, s1)`action_time(omega19) + one =
                          				fintime(s2d`basic`c2)
                          				AND s2d`action_time(mu2) = zero)))
               					OR (trans(a1, s1)`activity = e AND s2d`basic`c2 = 20)))


	sim21_2121: LEMMA 
			  ((a22 = mu1)
				&  enabled_general(a22, s2)
				&  enabled_time(a22, s2)
				&  s1`activity = b
				&  s2`basic`c1 >= 1
				&  s2`basic`c1 <= 29
				&  ((s1`action_time(omega29) = fintime(s2`basic`c1) AND
         				s2`action_time(mu1) = one)
        				OR
        			 	(s1`action_time(omega29) + one = fintime(s2`basic`c1) AND
          				s2`action_time(mu1) = zero))
				&  Inv_11(s1)
				&  Inv_21(s2)
				&  Inv_1(s1)
				&  Inv_2(s2)
				&  s1`action_time(alpha) = s2`action_time(alpha)
				&  s1`action_time(rho1) = s2`action_time(rho1)
				&  s1`action_time(rho2) = s2`action_time(rho2)	
				&  s1`action_time(gamma) = s2`action_time(gamma)
				&  s1`action_time(wr) = s2`action_time(wr)
				&  s1`action_time(ws) = s2`action_time(ws)
				&  s1`action_time(pr) = s2`action_time(pr)
				&  s1`action_time(ps) = s2`action_time(ps)
				&  ps1(s1) = ps2(s2))
				=>  	
			   ((tick?(a22))
      		OR	(EXISTS (s2a: S_state),
             			(a2: S_action), (s2b: S_state), (s2c: S_state):
       			 (   sitc(r2, ps1)(s1, s2a) & dd1(s2a, a2, s2b)
          			& sitc(r2, ps1)(s2b, s2c) & ps2(trans(a22, s2)) = ps1(s2c)
         			& pa2(a22) = pa1(a2) & Inv_11(s2c) & Inv_21(trans(a22,s2)) & Inv_1(s2c) & Inv_2(trans(a22, s2))
          			& s2c`action_time(alpha) = trans(a22, s2)`action_time(alpha)
          			& s2c`action_time(rho1) = trans(a22, s2)`action_time(rho1)
          			& s2c`action_time(rho2) = trans(a22, s2)`action_time(rho2)
          			& s2c`action_time(gamma) = trans(a22, s2)`action_time(gamma)
          			& s2c`action_time(wr) = trans(a22, s2)`action_time(wr)
          			& s2c`action_time(ws) = trans(a22, s2)`action_time(ws)
          			& s2c`action_time(pr) = trans(a22, s2)`action_time(pr)
          			& s2c`action_time(ps) = trans(a22, s2)`action_time(ps)
          			& ps1(s2c) = ps2(trans(a22, s2))
          			& (    (s2c`activity = a AND
                   			(trans(a22, s2)`basic`c1 = 0 &
                     			trans(a22, s2)`basic`c2 = 0)
                    			AND
                    			(s2c`action_time(mu) =
                      			trans(a22, s2)`action_time(mu1)))	
              			OR (s2c`activity = b AND
                   			trans(a22, s2)`basic`c1 >= 1 AND
                    			trans(a22, s2)`basic`c1 <= 29 AND
                     			((s2c`action_time(omega29) =
                        			fintime(trans(a22, s2)`basic`c1)
                        			AND trans(a22, s2)`action_time(mu1) = one)
                       			OR
                       			(s2c`action_time(omega29) + one =
                         			fintime(trans(a22, s2)`basic`c1)
                         			AND trans(a22, s2)`action_time(mu1) = zero)))
              			OR (s2c`activity = c AND trans(a22, s2)`basic`c1 = 30)
              			OR (s2c`activity = d AND
                   			trans(a22, s2)`basic`c2 >= 1 AND
                    			trans(a22, s2)`basic`c2 <= 19 AND
                     			((s2c`action_time(omega19) =
                        			fintime(trans(a22, s2)`basic`c2)
                        			AND trans(a22, s2)`action_time(mu2) = one)
                       			OR
                       			(s2c`action_time(omega19) + one =
                         			fintime(trans(a22, s2)`basic`c2)
                         			AND trans(a22, s2)`action_time(mu2) = zero)))
              			OR (s2c`activity = e AND trans(a22, s2)`basic`c2 = 20))))
			OR   (EXISTS (s2d: S_state):
             			ps2(trans(a22, s2)) = ps1(s2d) AND Is_tau?(pa2(a22))
         			AND sitc(r2, ps1)(s1, s2d) AND Inv_11(s2d) AND Inv_21(trans(a22,s2)) AND Inv_1(s2d)
         			AND Inv_2(trans(a22, s2))
         			AND s2d`action_time(alpha) = trans(a22, s2)`action_time(alpha)
         			AND s2d`action_time(rho1) = trans(a22, s2)`action_time(rho1)
         			AND s2d`action_time(rho2) = trans(a22, s2)`action_time(rho2)
         			AND s2d`action_time(gamma) = trans(a22, s2)`action_time(gamma)
         			AND s2d`action_time(wr) = trans(a22, s2)`action_time(wr)
        			AND s2d`action_time(ws) = trans(a22, s2)`action_time(ws)
         			AND s2d`action_time(pr) = trans(a22, s2)`action_time(pr)
         			AND s2d`action_time(ps) = trans(a22, s2)`action_time(ps)
         			AND ps1(s2d) = ps2(trans(a22, s2))
         			AND (    (s2d`activity = a AND
                    			(trans(a22, s2)`basic`c1 = 0 &
                      			trans(a22, s2)`basic`c2 = 0)
                    	 		AND
                     			(s2d`action_time(mu) =
                       			trans(a22, s2)`action_time(mu1)))
               			OR (s2d`activity = b AND
                    			trans(a22, s2)`basic`c1 >= 1 AND
                     			trans(a22, s2)`basic`c1 <= 29 AND
                      			((s2d`action_time(omega29) =
                         			fintime(trans(a22, s2)`basic`c1)
                         			AND trans(a22, s2)`action_time(mu1) = one)
                        			OR
                        			(s2d`action_time(omega29) + one =
                          			fintime(trans(a22, s2)`basic`c1)
                          			AND trans(a22, s2)`action_time(mu1) = zero)))
               			OR (s2d`activity = c AND trans(a22, s2)`basic`c1 = 30)
               			OR (s2d`activity = d AND
                    			trans(a22, s2)`basic`c2 >= 1 AND
                     			trans(a22, s2)`basic`c2 <= 19 AND
                      			((s2d`action_time(omega19) =
                         			fintime(trans(a22, s2)`basic`c2)
                         			AND trans(a22, s2)`action_time(mu2) = one)
                        			OR
                        			(s2d`action_time(omega19) + one =
                          			fintime(trans(a22, s2)`basic`c2)
                          			AND trans(a22, s2)`action_time(mu2) = zero)))
               			OR (s2d`activity = e AND trans(a22, s2)`basic`c2 = 20))))

	
	sim21_221: LEMMA    (a22 = tick
			% 	&  (tick?(tick))
				&  enabled_tick(s2)
				&  s1`activity = b
				&  s2`basic`c1 >= 1
				&  s2`basic`c1 <= 29
				&  ((s1`action_time(omega29) = fintime(s2`basic`c1) AND
         				s2`action_time(mu1) = one)
        				OR
        				(s1`action_time(omega29) + one = fintime(s2`basic`c1) AND
          				s2`action_time(mu1) = zero))
				&  Inv_11(s1)
				&  Inv_21(s2)
				&  Inv_1(s1)
				&  Inv_2(s2)
				&  s1`action_time(alpha) = s2`action_time(alpha)
				&  s1`action_time(rho1) = s2`action_time(rho1)
				&  s1`action_time(rho2) = s2`action_time(rho2)
				&  s1`action_time(gamma) = s2`action_time(gamma)
				&  s1`action_time(wr) = s2`action_time(wr)
				&  s1`action_time(ws) = s2`action_time(ws)
				&  s1`action_time(pr) = s2`action_time(pr)
				&  s1`action_time(ps) = s2`action_time(ps)
				&  ps1(s1) = ps2(s2))
			=>	  
   				EXISTS (s2a: S_state),
             				(a2: S_action), (s2b: S_state), (s2c: S_state):
        				(   sitc(r2, ps1)(s1, s2a) & dd1(s2a, a2, s2b)
          				& sitc(r2, ps1)(s2b, s2c) & ps2(trans(tick, s2)) = ps1(s2c)
          				& pa2(tick) = pa1(a2) & Inv_11(s2c) & Inv_21(trans(tick,s2)) & Inv_1(s2c) & Inv_2(trans(tick, s2))
          				& s2c`action_time(alpha) = trans(tick, s2)`action_time(alpha)
          				& s2c`action_time(rho1) = trans(tick, s2)`action_time(rho1)
          				& s2c`action_time(rho2) = trans(tick, s2)`action_time(rho2)
          				& s2c`action_time(gamma) = trans(tick, s2)`action_time(gamma)
          				& s2c`action_time(wr) = trans(tick, s2)`action_time(wr)
          				& s2c`action_time(ws) = trans(tick, s2)`action_time(ws)
          				& s2c`action_time(pr) = trans(tick, s2)`action_time(pr)
          				& s2c`action_time(ps) = trans(tick, s2)`action_time(ps)
          				& ps1(s2c) = ps2(trans(tick, s2))
          				& (    (s2c`activity = a AND
                   				(trans(tick, s2)`basic`c1 = 0 &
                     				trans(tick, s2)`basic`c2 = 0)
                    				AND
                    				(s2c`action_time(mu) =
                      				trans(tick, s2)`action_time(mu1)))
              				OR (s2c`activity = b AND
                   				trans(tick, s2)`basic`c1 >= 1 AND
                    				trans(tick, s2)`basic`c1 <= 29 AND
                     				((s2c`action_time(omega29) =
                        				fintime(trans(tick, s2)`basic`c1)
                        				AND trans(tick, s2)`action_time(mu1) = one)
                       				OR
                       				(s2c`action_time(omega29) + one =
                         				fintime(trans(tick, s2)`basic`c1)
                         				AND trans(tick, s2)`action_time(mu1) = zero)))
              				OR (s2c`activity = c AND trans(tick, s2)`basic`c1 = 30)
              				OR (s2c`activity = d AND
                   				trans(tick, s2)`basic`c2 >= 1 AND
                    				trans(tick, s2)`basic`c2 <= 19 AND
                     				((s2c`action_time(omega19) =
                        				fintime(trans(tick, s2)`basic`c2)
                        				AND trans(tick, s2)`action_time(mu2) = one)
                       				OR
                       				(s2c`action_time(omega19) + one =
                         				fintime(trans(tick, s2)`basic`c2)
                         				AND trans(tick, s2)`action_time(mu2) = zero)))
              				OR (s2c`activity = e AND trans(tick, s2)`basic`c2 = 20)))



	sim21_4121: LEMMA   (a22 = mu2
				&  enabled_general(mu2, s2)
				&  enabled_time(mu2, s2)
				&  s1`activity = d
				&  s2`basic`c2 >= 1
				&  s2`basic`c2 <= 19
				&  ((s1`action_time(omega19) = fintime(s2`basic`c2) AND
         				s2`action_time(mu2) = one)
        				OR
        				(s1`action_time(omega19) + one = fintime(s2`basic`c2) AND
          				s2`action_time(mu2) = zero))
				&  Inv_11(s1)
				&  Inv_21(s2)
				&  Inv_1(s1)
				&  Inv_2(s2)
				&  s1`action_time(alpha) = s2`action_time(alpha)
				&  s1`action_time(rho1) = s2`action_time(rho1)
				&  s1`action_time(rho2) = s2`action_time(rho2)
				&  s1`action_time(gamma) = s2`action_time(gamma)
				&  s1`action_time(wr) = s2`action_time(wr)
				&  s1`action_time(ws) = s2`action_time(ws)
				&  s1`action_time(pr) = s2`action_time(pr)
				&  s1`action_time(ps) = s2`action_time(ps)
				&  ps1(s1) = ps2(s2))
                       =>
   				((EXISTS (s2a: S_state),
             				(a2: S_action), (s2b: S_state), (s2c: S_state):
        				(   sitc(r2, ps1)(s1, s2a) & dd1(s2a, a2, s2b)
          				& sitc(r2, ps1)(s2b, s2c) & ps2(trans(mu2, s2)) = ps1(s2c)
          				& pa2(mu2) = pa1(a2) & Inv_11(s2c) & Inv_21(trans(mu2,s2)) & Inv_1(s2c) & Inv_2(trans(mu2, s2))
          				& s2c`action_time(alpha) = trans(mu2, s2)`action_time(alpha)
          				& s2c`action_time(rho1) = trans(mu2, s2)`action_time(rho1)
          				& s2c`action_time(rho2) = trans(mu2, s2)`action_time(rho2)
          				& s2c`action_time(gamma) = trans(mu2, s2)`action_time(gamma)
         	 			& s2c`action_time(wr) = trans(mu2, s2)`action_time(wr)
          				& s2c`action_time(ws) = trans(mu2, s2)`action_time(ws)
          				& s2c`action_time(pr) = trans(mu2, s2)`action_time(pr)
          				& s2c`action_time(ps) = trans(mu2, s2)`action_time(ps)
          				& ps1(s2c) = ps2(trans(mu2, s2))
          				& (    (s2c`activity = a AND
                   				(trans(mu2, s2)`basic`c1 = 0 &
                     				trans(mu2, s2)`basic`c2 = 0)
                    				AND
                    				(s2c`action_time(mu) =
                      				trans(mu2, s2)`action_time(mu1)))
              				OR (s2c`activity = b AND
                   				trans(mu2, s2)`basic`c1 >= 1 AND
                    				trans(mu2, s2)`basic`c1 <= 29 AND
                     				((s2c`action_time(omega29) =
                        				fintime(trans(mu2, s2)`basic`c1)
                        				AND trans(mu2, s2)`action_time(mu1) = one)
                       				OR
                       				(s2c`action_time(omega29) + one =
                         				fintime(trans(mu2, s2)`basic`c1)
                         				AND trans(mu2, s2)`action_time(mu1) = zero)))
              				OR (s2c`activity = c AND trans(mu2, s2)`basic`c1 = 30)
              				OR (s2c`activity = d AND
                   				trans(mu2, s2)`basic`c2 >= 1 AND
                    				trans(mu2, s2)`basic`c2 <= 19 AND
                     				((s2c`action_time(omega19) =
                        				fintime(trans(mu2, s2)`basic`c2)
                        				AND trans(mu2, s2)`action_time(mu2) = one)
                       					OR
                       				(s2c`action_time(omega19) + one =
                         				fintime(trans(mu2, s2)`basic`c2)
                         				AND trans(mu2, s2)`action_time(mu2) = zero)))
              				OR (s2c`activity = e AND trans(mu2, s2)`basic`c2 = 20))))
			or   (tick?(mu2))
				or   (EXISTS (s2d: S_state):
             				ps2(trans(mu2, s2)) = ps1(s2d) AND Is_tau?(pa2(mu2))
         				AND sitc(r2, ps1)(s1, s2d) AND Inv_11(s2d) AND Inv_21(trans(mu2,s2)) AND Inv_1(s2d)
         				AND Inv_2(trans(mu2, s2))
         				AND s2d`action_time(alpha) = trans(mu2, s2)`action_time(alpha)
         				AND s2d`action_time(rho1) = trans(mu2, s2)`action_time(rho1)
         				AND s2d`action_time(rho2) = trans(mu2, s2)`action_time(rho2)
        	 			AND s2d`action_time(gamma) = trans(mu2, s2)`action_time(gamma)
         				AND s2d`action_time(wr) = trans(mu2, s2)`action_time(wr)
         				AND s2d`action_time(ws) = trans(mu2, s2)`action_time(ws)
         				AND s2d`action_time(pr) = trans(mu2, s2)`action_time(pr)
         				AND s2d`action_time(ps) = trans(mu2, s2)`action_time(ps)
         				AND ps1(s2d) = ps2(trans(mu2, s2))
         				AND (    (s2d`activity = a AND
                    				(trans(mu2, s2)`basic`c1 = 0 &
                      				trans(mu2, s2)`basic`c2 = 0)
                     				AND
                     				(s2d`action_time(mu) =
                       				trans(mu2, s2)`action_time(mu1)))
               				OR (s2d`activity = b AND
                    				trans(mu2, s2)`basic`c1 >= 1 AND
                     				trans(mu2, s2)`basic`c1 <= 29 AND
                      				((s2d`action_time(omega29) =
                         				fintime(trans(mu2, s2)`basic`c1)
                         				AND trans(mu2, s2)`action_time(mu1) = one)
                        				OR
                        				(s2d`action_time(omega29) + one =
                          				fintime(trans(mu2, s2)`basic`c1)
                          				AND trans(mu2, s2)`action_time(mu1) = zero)))
               				OR (s2d`activity = c AND trans(mu2, s2)`basic`c1 = 30)
               				OR (s2d`activity = d AND
                    				trans(mu2, s2)`basic`c2 >= 1 AND
                     				trans(mu2, s2)`basic`c2 <= 19 AND
                      				((s2d`action_time(omega19) =
                         				fintime(trans(mu2, s2)`basic`c2)
                         				AND trans(mu2, s2)`action_time(mu2) = one)
                        				OR
                        				(s2d`action_time(omega19) + one =
                          				fintime(trans(mu2, s2)`basic`c2)
                          				AND trans(mu2, s2)`action_time(mu2) = zero)))
               				OR (s2d`activity = e AND trans(mu2, s2)`basic`c2 = 20))))


	sim21_42: LEMMA    (NOT (NOT (tick?(a22))) AND enabled_tick(s2)
				&  (s1`activity = d AND
        				s2`basic`c2 >= 1 AND
         				s2`basic`c2 <= 19 AND
          				((s1`action_time(omega19) = fintime(s2`basic`c2) AND
             				s2`action_time(mu2) = one)
            				OR
            				(s1`action_time(omega19) + one = fintime(s2`basic`c2) AND
              				s2`action_time(mu2) = zero)))
				&  Inv_11(s1)
				&  Inv_21(s2)
				&  Inv_1(s1)
				&  Inv_2(s2)
				&  s1`action_time(alpha) = s2`action_time(alpha)
				&  s1`action_time(rho1) = s2`action_time(rho1)
				&  s1`action_time(rho2) = s2`action_time(rho2)
				&  s1`action_time(gamma) = s2`action_time(gamma)	
				&  s1`action_time(wr) = s2`action_time(wr)
				&  s1`action_time(ws) = s2`action_time(ws)
				&  s1`action_time(pr) = s2`action_time(pr)
				&  s1`action_time(ps) = s2`action_time(ps)
				&  ps1(s1) = ps2(s2))
 			=>
   				(EXISTS (s2a: S_state),
             				(a2: S_action), (s2b: S_state), (s2c: S_state):
        				(   sitc(r2, ps1)(s1, s2a) & dd1(s2a, a2, s2b)
          				& sitc(r2, ps1)(s2b, s2c) & ps2(trans(a22, s2)) = ps1(s2c)
          				& pa2(a22) = pa1(a2) & Inv_11(s2c) & Inv_21(trans(a22,s2)) & Inv_1(s2c) & Inv_2(trans(a22, s2))
          				& s2c`action_time(alpha) = trans(a22, s2)`action_time(alpha)
          				& s2c`action_time(rho1) = trans(a22, s2)`action_time(rho1)
          				& s2c`action_time(rho2) = trans(a22, s2)`action_time(rho2)
          				& s2c`action_time(gamma) = trans(a22, s2)`action_time(gamma)
          				& s2c`action_time(wr) = trans(a22, s2)`action_time(wr)
          				& s2c`action_time(ws) = trans(a22, s2)`action_time(ws)
          				& s2c`action_time(pr) = trans(a22, s2)`action_time(pr)
          				& s2c`action_time(ps) = trans(a22, s2)`action_time(ps)
          				& ps1(s2c) = ps2(trans(a22, s2))
          				& (    (s2c`activity = a AND
                   				(trans(a22, s2)`basic`c1 = 0 &
                     					trans(a22, s2)`basic`c2 = 0)
                    				AND
                    				(s2c`action_time(mu) =
                      				trans(a22, s2)`action_time(mu1)))
              				OR (s2c`activity = b AND
                   				trans(a22, s2)`basic`c1 >= 1 AND
                    				trans(a22, s2)`basic`c1 <= 29 AND
                     				((s2c`action_time(omega29) =
                        				fintime(trans(a22, s2)`basic`c1)
                        				AND trans(a22, s2)`action_time(mu1) = one)
                       				OR
                       				(s2c`action_time(omega29) + one =
                         				fintime(trans(a22, s2)`basic`c1)
                         				AND trans(a22, s2)`action_time(mu1) = zero)))
              					OR (s2c`activity = c AND trans(a22, s2)`basic`c1 = 30)
              				OR (s2c`activity = d AND
                   				trans(a22, s2)`basic`c2 >= 1 AND
                    				trans(a22, s2)`basic`c2 <= 19 AND
                     				((s2c`action_time(omega19) =
                        				fintime(trans(a22, s2)`basic`c2)
                        				AND trans(a22, s2)`action_time(mu2) = one)
                       				OR
                       				(s2c`action_time(omega19) + one =
                         				fintime(trans(a22, s2)`basic`c2)
                         				AND trans(a22, s2)`action_time(mu2) = zero)))
              				OR (s2c`activity = e AND trans(a22, s2)`basic`c2 = 20))))




	
	Sim1_2: LEMMA  wsesim?(LAMBDA (s1: S_state, s2: I_state):
                   Inv_11(s1) & Inv_21(s2) & Inv_1(s1) & Inv_2(s2)
                 & s1`action_time(alpha) = s2`action_time(alpha)
                 & s1`action_time(rho1) = s2`action_time(rho1)
                 & s1`action_time(rho2) = s2`action_time(rho2)
                 & s1`action_time(gamma) = s2`action_time(gamma)
                 & s1`action_time(wr) = s2`action_time(wr)
                 & s1`action_time(ws) = s2`action_time(ws)
                 & s1`action_time(pr) = s2`action_time(pr)
                 & s1`action_time(ps) = s2`action_time(ps)
                 & ps1(s1) = ps2(s2)
                 & (    (s1`activity = a AND
                          (s2`basic`c1 = 0 & s2`basic`c2 = 0) AND
                           (s1`action_time(mu) = s2`action_time(mu1)))
                     OR (s1`activity = b AND
                          s2`basic`c1 >= 1 AND
                           s2`basic`c1 <= 29 AND
                            ((s1`action_time(omega29) =
                               fintime(s2`basic`c1)
                               AND s2`action_time(mu1) = one)
                              OR
                              (s1`action_time(omega29) + one =
                                fintime(s2`basic`c1)
                                AND s2`action_time(mu1) = zero)))
                     OR (s1`activity = c AND s2`basic`c1 = 30)
                     OR (s1`activity = d AND
                          s2`basic`c2 >= 1 AND
                           s2`basic`c2 <= 19 AND
                            ((s1`action_time(omega19) =
                               fintime(s2`basic`c2)
                               AND s2`action_time(mu2) = one)
                              OR
                              (s1`action_time(omega19) + one =
                                fintime(s2`basic`c2)
                                AND s2`action_time(mu2) = zero)))
                     OR (s1`activity = e AND s2`basic`c2 = 20)))

	Sim2_1: LEMMA  wsesim?(converse(LAMBDA (s1: S_state, s2: I_state):
                            Inv_11(s1) & Inv_21(s2) & Inv_1(s1) & Inv_2(s2)
                          & s1`action_time(alpha) = s2`action_time(alpha)
                          & s1`action_time(rho1) = s2`action_time(rho1)
                          & s1`action_time(rho2) = s2`action_time(rho2)
                          & s1`action_time(gamma) = s2`action_time(gamma)
                          & s1`action_time(wr) = s2`action_time(wr)
                          & s1`action_time(ws) = s2`action_time(ws)
                          & s1`action_time(pr) = s2`action_time(pr)
                          & s1`action_time(ps) = s2`action_time(ps)
                          & ps1(s1) = ps2(s2)
                          & (    (s1`activity = a AND
                                   (s2`basic`c1 = 0 & s2`basic`c2 = 0) AND
                                    (s1`action_time(mu)
                                     =
                                     s2`action_time(mu1)))
                              OR (s1`activity = b AND
                                   s2`basic`c1 >= 1 AND
                                    s2`basic`c1 <= 29
                                    AND
                                    ((s1`action_time(omega29)
                                      =
                                      fintime(s2`basic`c1)
                                      AND
                                      s2`action_time(mu1) = one)
                                     OR
                                     (s1`action_time(omega29) + one
                                      =
                                      fintime(s2`basic`c1)
                                      AND
                                      s2`action_time(mu1) = zero)))
                              OR (s1`activity = c AND s2`basic`c1 = 30)
                              OR (s1`activity = d AND
                                   s2`basic`c2 >= 1 AND
                                    s2`basic`c2 <= 19
                                    AND
                                    ((s1`action_time(omega19)
                                      =
                                      fintime(s2`basic`c2)
                                      AND
                                      s2`action_time(mu2) = one)
                                     OR
                                     (s1`action_time(omega19) + one
                                      =
                                      fintime(s2`basic`c2)
                                      AND
                                      s2`action_time(mu2) = zero)))
                              OR (s1`activity = e AND s2`basic`c2 = 20))))


	RR:Wsebisim = LAMBDA(s1,s2): 
					  
		 ((Inv_11(s1) & Inv_21(s2) & Inv_1(s1) & Inv_2(s2))
		& s1`action_time(alpha)=s2`action_time(alpha)
		& s1`action_time(rho1)=s2`action_time(rho1)
		& s1`action_time(rho2)=s2`action_time(rho2)
		& s1`action_time(gamma)=s2`action_time(gamma)
		& s1`action_time(wr)=s2`action_time(wr)
		& s1`action_time(ws)=s2`action_time(ws)
		& s1`action_time(pr)=s2`action_time(pr)
		& s1`action_time(ps)=s2`action_time(ps)
		& ps1(s1) = ps2(s2))
		& 
		((s1`activity=a and (s2`basic`c1=0 &s2`basic`c2=0) and (s1`action_time(mu)=s2`action_time(mu1))) or
		(s1`activity=b and s2`basic`c1>=1 and s2`basic`c1<=29 and 
		   ((s1`action_time(omega29)=fintime(s2`basic`c1) and s2`action_time(mu1)=one) or
		   (s1`action_time(omega29)+ one =fintime(s2`basic`c1) and s2`action_time(mu1)=zero))) or
		(s1`activity=c and s2`basic`c1=30 )  or
		(s1`activity=d and s2`basic`c2>=1 and s2`basic`c2<=19 and 
		   ((s1`action_time(omega19)=fintime(s2`basic`c2) and s2`action_time(mu2)=one) or
		   (s1`action_time(omega19)+one=fintime(s2`basic`c2) and s2`action_time(mu2)=zero))) or
		(s1`activity=e and s2`basic`c2=20)) 


	weakequi: LEMMA weakequivalence(RR)(start,start)(s1,s2);

END sebisimul

$$$ttmbisimul.prf
(|sebisimul| (|sim12_2_TCC1| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC2| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC3| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC4| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC5| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC6| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC7| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC8| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC9| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC10| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC11| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC12| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC13| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC14| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC15| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC16| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC17| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC18| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC19| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC20| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC21| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC22| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC23| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC24| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC25| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC26| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC27| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC28| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC29| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC30| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC31| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC32| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2_TCC33| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_2| "" (SKOLEM-TYPEPRED)
  (("" (FLATTEN)
    (("" (SPLIT)
      (("1" (FLATTEN)
        (("1" (EXPAND "enabled")
          (("1" (SPLIT)
            (("1" (FLATTEN)
              (("1"
                (CASE "NOT (a1!1=omega29 or a1!1=pr or a1!1=ps or a1!1=wr or a1!1=ws)")
                (("1" (HIDE 3 4)
                  (("1" (FLATTEN)
                    (("1" (HIDE -2 -8 -9 -10 -11 -20) (("1" (GRIND) NIL NIL))
                      NIL))
                    NIL))
                  NIL)
                 ("2" (SPLIT)
                  (("1" (HIDE 3)
                    (("1"
                      (INST + "s2!1" "mu1" "trans(mu1,s2!1)"
                       "trans(mu1,s2!1)")
                      (("1" (BDDSIMP)
                        (("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" (HIDE -9 -10)
                          (("10" (HIDE -9)
                            (("10" (GRIND)
                              (("10" (TIME_ETC_SIMP) (("10" (ASSERT) NIL NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL)
                         ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                         ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                         ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                         ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                         ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                         ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                         ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                         ("25" (GRIND) NIL NIL)
                         ("26" (HIDE -2 -3 -9 -10 -11)
                          (("26" (GRIND) NIL NIL)) NIL)
                         ("27" (HIDE -2 -3 -9 -10 -12)
                          (("27" (GRIND) NIL NIL)) NIL)
                         ("28" (HIDE -2 -3 -9 -11 -12)
                          (("28" (GRIND) NIL NIL)) NIL)
                         ("29" (HIDE -2 -3 -10 -11 -12)
                          (("29" (GRIND) NIL NIL)) NIL)
                         ("30" (GRIND) NIL NIL) ("31" (GRIND) NIL NIL)
                         ("32" (EXPAND "sitc")
                          (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL)) NIL))
                          NIL)
                         ("33" (GRIND) NIL NIL)
                         ("34" (EXPAND "sitc")
                          (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL)) NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL)
                   ("2" (REPLACE -1 *)
                    (("2" (HIDE 3)
                      (("2"
                        (INST + "s2!1" "pr" "trans(pr,s2!1)" "trans(pr,s2!1)")
                        (("2" (BDDSIMP)
                          (("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)
                           ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                           ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                           ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                           ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                           ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                           ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                           ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                           ("25" (GRIND) NIL NIL)
                           ("26" (HIDE -2 -3 -9 -10 -11)
                            (("26" (GRIND) NIL NIL)) NIL)
                           ("27" (HIDE -2 -3 -9 -10 -12)
                            (("27" (GRIND) NIL NIL)) NIL)
                           ("28" (HIDE -2 -3 -9 -11 -12)
                            (("28" (GRIND) NIL NIL)) NIL)
                           ("29" (HIDE -2 -3 -10 -11 -12)
                            (("29" (GRIND) NIL NIL)) NIL)
                           ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                           ("31" (GRIND) NIL NIL)
                           ("32" (EXPAND "sitc")
                            (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL))
                              NIL))
                            NIL)
                           ("33" (GRIND) NIL NIL)
                           ("34" (EXPAND "sitc")
                            (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL)
                   ("3" (REPLACE -1 *)
                    (("3" (HIDE 3)
                      (("3"
                        (INST + "s2!1" "ps" "trans(ps,s2!1)" "trans(ps,s2!1)")
                        (("3" (BDDSIMP)
                          (("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)
                           ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                           ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                           ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                           ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                           ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                           ("21" (GRIND) NIL NIL)
                           ("22" (HIDE -2 -3 -9 -10 -11 -12)
                            (("22" (GRIND) NIL NIL)) NIL)
                           ("23" (HIDE -2 -3 -9 -10 -11 -12)
                            (("23" (GRIND) NIL NIL)) NIL)
                           ("24" (HIDE -2 -3 -9 -10 -11 -12)
                            (("24" (GRIND) NIL NIL)) NIL)
                           ("25" (HIDE -2 -3 -9 -10 -11 -12)
                            (("25" (GRIND) NIL NIL)) NIL)
                           ("26" (HIDE -2 -3 -9 -10 -11)
                            (("26" (GRIND) NIL NIL)) NIL)
                           ("27" (HIDE -2 -3 -9 -10 -12)
                            (("27" (GRIND) NIL NIL)) NIL)
                           ("28" (HIDE -2 -3 -9 -11 -12)
                            (("28" (GRIND) NIL NIL)) NIL)
                           ("29" (HIDE -2 -3 -10 -11 -12)
                            (("29" (GRIND) NIL NIL)) NIL)
                           ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                           ("31" (GRIND) NIL NIL)
                           ("32" (EXPAND "sitc")
                            (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL))
                              NIL))
                            NIL)
                           ("33" (GRIND) NIL NIL)
                           ("34" (EXPAND "sitc")
                            (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL)
                   ("4" (REPLACE -1 *)
                    (("4" (HIDE 3)
                      (("4"
                        (INST + "s2!1" "wr" "trans(wr,s2!1)" "trans(wr,s2!1)")
                        (("4" (BDDSIMP)
                          (("1" (HIDE -2 -3 -9 -10 -11 -12)
                            (("1" (GRIND) NIL NIL)) NIL)
                           ("2" (HIDE -2 -3 -9 -10 -11 -12)
                            (("2" (GRIND) NIL NIL)) NIL)
                           ("3" (HIDE -2 -3 -9 -10 -11 -12)
                            (("3" (GRIND) NIL NIL)) NIL)
                           ("4" (HIDE -2 -3 -9 -10 -11 -12)
                            (("4" (GRIND) NIL NIL)) NIL)
                           ("5" (HIDE -2 -3 -9 -10 -11 -12)
                            (("5" (GRIND) NIL NIL)) NIL)
                           ("6" (HIDE -2 -3 -9 -10 -11 -12)
                            (("6" (GRIND) NIL NIL)) NIL)
                           ("7" (HIDE -2 -3 -9 -10 -11 -12)
                            (("7" (GRIND) NIL NIL)) NIL)
                           ("8" (HIDE -2 -3 -9 -10 -11 -12)
                            (("8" (GRIND) NIL NIL)) NIL)
                           ("9" (HIDE -2 -3 -9 -10 -11 -12)
                            (("9" (GRIND) NIL NIL)) NIL)
                           ("10" (HIDE -2 -3 -9 -10 -11 -12)
                            (("10" (GRIND) NIL NIL)) NIL)
                           ("11" (HIDE -2 -3 -9 -10 -11 -12)
                            (("11" (GRIND) NIL NIL)) NIL)
                           ("12" (HIDE -2 -3 -9 -10 -11 -12)
                            (("12" (GRIND) NIL NIL)) NIL)
                           ("13" (HIDE -2 -3 -9 -10 -11 -12)
                            (("13" (GRIND) NIL NIL)) NIL)
                           ("14" (HIDE -2 -3 -9 -10 -11 -12)
                            (("14" (GRIND) NIL NIL)) NIL)
                           ("15" (HIDE -2 -3 -9 -10 -11 -12)
                            (("15" (GRIND) NIL NIL)) NIL)
                           ("16" (HIDE -2 -3 -9 -10 -11 -12)
                            (("16" (GRIND) NIL NIL)) NIL)
                           ("17" (HIDE -2 -3 -9 -10 -11 -12)
                            (("17" (GRIND) NIL NIL)) NIL)
                           ("18" (HIDE -2 -3 -9 -10 -11 -12)
                            (("18" (GRIND) NIL NIL)) NIL)
                           ("19" (HIDE -2 -3 -9 -10 -11 -12)
                            (("19" (GRIND) NIL NIL)) NIL)
                           ("20" (HIDE -2 -3 -9 -10 -11 -12)
                            (("20" (GRIND) NIL NIL)) NIL)
                           ("21" (HIDE -2 -3 -9 -10 -11 -12)
                            (("21" (GRIND) NIL NIL)) NIL)
                           ("22" (HIDE -2 -3 -9 -10 -11 -12)
                            (("22" (GRIND) NIL NIL)) NIL)
                           ("23" (HIDE -2 -3 -9 -10 -11 -12)
                            (("23" (GRIND) NIL NIL)) NIL)
                           ("24" (HIDE -2 -3 -9 -10 -11 -12)
                            (("24" (GRIND) NIL NIL)) NIL)
                           ("25" (HIDE -2 -3 -9 -10 -11 -12)
                            (("25" (GRIND) NIL NIL)) NIL)
                           ("26" (GRIND) NIL NIL)
                           ("27" (HIDE -2 -3 -9 -10 -12)
                            (("27" (GRIND) NIL NIL)) NIL)
                           ("28" (HIDE -2 -3 -9 -11 -12)
                            (("28" (GRIND) NIL NIL)) NIL)
                           ("29" (HIDE -2 -3 -10 -11 -12)
                            (("29" (GRIND) NIL NIL)) NIL)
                           ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                           ("31" (HIDE -2 -3 -10 -11 -12)
                            (("31" (GRIND) NIL NIL)) NIL)
                           ("32" (EXPAND "sitc")
                            (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL))
                              NIL))
                            NIL)
                           ("33" (GRIND) NIL NIL)
                           ("34" (EXPAND "sitc")
                            (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL)
                   ("5" (REPLACE -1 *)
                    (("5" (HIDE 3)
                      (("5"
                        (INST + "s2!1" "ws" "trans(ws,s2!1)" "trans(ws,s2!1)")
                        (("5" (BDDSIMP)
                          (("1" (HIDE -2 -3 -9 -10 -11 -12)
                            (("1" (GRIND) NIL NIL)) NIL)
                           ("2" (HIDE -2 -3 -9 -10 -11 -12)
                            (("2" (GRIND) NIL NIL)) NIL)
                           ("3" (HIDE -2 -3 -9 -10 -11 -12)
                            (("3" (GRIND) NIL NIL)) NIL)
                           ("4" (HIDE -2 -3 -9 -10 -11 -12)
                            (("4" (GRIND) NIL NIL)) NIL)
                           ("5" (HIDE -2 -3 -9 -10 -11 -12)
                            (("5" (GRIND) NIL NIL)) NIL)
                           ("6" (HIDE -2 -3 -9 -10 -11 -12)
                            (("6" (GRIND) NIL NIL)) NIL)
                           ("7" (HIDE -2 -3 -9 -10 -11 -12)
                            (("7" (GRIND) NIL NIL)) NIL)
                           ("8" (HIDE -2 -3 -9 -10 -11 -12)
                            (("8" (GRIND) NIL NIL)) NIL)
                           ("9" (HIDE -2 -3 -9 -10 -11 -12)
                            (("9" (GRIND) NIL NIL)) NIL)
                           ("10" (HIDE -2 -3 -9 -10 -11 -12)
                            (("10" (GRIND) NIL NIL)) NIL)
                           ("11" (HIDE -2 -3 -9 -10 -11 -12)
                            (("11" (GRIND) NIL NIL)) NIL)
                           ("12" (HIDE -2 -3 -9 -10 -11 -12)
                            (("12" (GRIND) NIL NIL)) NIL)
                           ("13" (HIDE -2 -3 -9 -10 -11 -12)
                            (("13" (GRIND) NIL NIL)) NIL)
                           ("14" (HIDE -2 -3 -9 -10 -11 -12)
                            (("14" (GRIND) NIL NIL)) NIL)
                           ("15" (HIDE -2 -3 -9 -10 -11 -12)
                            (("15" (GRIND) NIL NIL)) NIL)
                           ("16" (HIDE -2 -3 -9 -10 -11 -12)
                            (("16" (GRIND) NIL NIL)) NIL)
                           ("17" (HIDE -2 -3 -9 -10 -11 -12)
                            (("17" (GRIND) NIL NIL)) NIL)
                           ("18" (HIDE -2 -3 -9 -10 -11 -12)
                            (("18" (GRIND) NIL NIL)) NIL)
                           ("19" (HIDE -2 -3 -9 -10 -11 -12)
                            (("19" (GRIND) NIL NIL)) NIL)
                           ("20" (HIDE -2 -3 -9 -10 -11 -12)
                            (("20" (GRIND) NIL NIL)) NIL)
                           ("21" (HIDE -2 -3 -9 -10 -11 -12)
                            (("21" (GRIND) NIL NIL)) NIL)
                           ("22" (HIDE -2 -3 -9 -10 -11 -12)
                            (("22" (GRIND) NIL NIL)) NIL)
                           ("23" (HIDE -2 -3 -9 -10 -11 -12)
                            (("23" (GRIND) NIL NIL)) NIL)
                           ("24" (HIDE -2 -3 -9 -10 -11 -12)
                            (("24" (GRIND) NIL NIL)) NIL)
                           ("25" (HIDE -2 -3 -9 -10 -11 -12)
                            (("25" (GRIND) NIL NIL)) NIL)
                           ("26" (HIDE -2 -3 -9 -10 -11)
                            (("26" (GRIND) NIL NIL)) NIL)
                           ("27" (HIDE -2 -3 -9 -10 -12)
                            (("27" (GRIND) NIL NIL)) NIL)
                           ("28" (HIDE -2 -3 -9 -11 -12)
                            (("28" (GRIND) NIL NIL)) NIL)
                           ("29" (HIDE -2 -3 -10 -11 -12)
                            (("29" (GRIND) NIL NIL)) NIL)
                           ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                           ("31" (GRIND) NIL NIL)
                           ("32" (EXPAND "sitc")
                            (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL))
                              NIL))
                            NIL)
                           ("33" (GRIND) NIL NIL)
                           ("34" (EXPAND "sitc")
                            (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL))
                  NIL))
                NIL))
              NIL)
             ("2" (FLATTEN)
              (("2" (HIDE 2)
                (("2" (CASE "a1!1=tick")
                  (("1" (REPLACE -1 *)
                    (("1"
                      (INST + "trans(mu1,s2!1)" "tick"
                       "trans(tick,trans(mu1,s2!1))"
                       "trans(tick,trans(mu1,s2!1))")
                      (("1" (BDDSIMP)
                        (("1" (HIDE -9 -10) (("1" (GRIND) NIL NIL)) NIL)
                         ("2" (GRIND) NIL NIL)
                         ("3" (HIDE -3 -9 -10 -11 -12) (("3" (GRIND) NIL NIL))
                          NIL)
                         ("4" (HIDE -3 -9 -10 -11 -12) (("4" (GRIND) NIL NIL))
                          NIL)
                         ("5" (HIDE -9 -10) (("5" (GRIND) NIL NIL)) NIL)
                         ("6" (HIDE -3 -9 -10 -11 -12) (("6" (GRIND) NIL NIL))
                          NIL)
                         ("7" (HIDE -3 -9 -10 -11 -12) (("7" (GRIND) NIL NIL))
                          NIL)
                         ("8" (HIDE -9 -10 -11 -21) (("8" (GRIND) NIL NIL))
                          NIL)
                         ("9" (HIDE -9 -10 -11 -12 -21)
                          (("9" (GRIND) NIL NIL)) NIL)
                         ("10" (HIDE -9 -10 -11 -12 -21)
                          (("10" (GRIND) NIL NIL)) NIL)
                         ("11" (HIDE -9 -10 -11 -12 -21)
                          (("11" (GRIND) NIL NIL)) NIL)
                         ("12" (HIDE -9 -10 -11 -12 -21)
                          (("12" (GRIND) NIL NIL)) NIL)
                         ("13" (HIDE -9 -10 -11 -12 -21)
                          (("13" (GRIND) NIL NIL)) NIL)
                         ("14" (HIDE -9 -10 -11 -12 -21)
                          (("14" (GRIND) NIL NIL)) NIL)
                         ("15" (HIDE -9 -10 -11 -12 -21)
                          (("15" (GRIND) NIL NIL)) NIL)
                         ("16" (HIDE -9 -10 -11 -12 -21)
                          (("16" (GRIND) NIL NIL)) NIL)
                         ("17" (HIDE -9 -10 -11 -12 -21)
                          (("17" (GRIND) NIL NIL)) NIL)
                         ("18" (HIDE -9 -10) (("18" (GRIND) NIL NIL)) NIL)
                         ("19" (HIDE -9 -10) (("19" (GRIND) NIL NIL)) NIL)
                         ("20" (HIDE -9 -10) (("20" (GRIND) NIL NIL)) NIL)
                         ("21" (HIDE -9 -10) (("21" (GRIND) NIL NIL)) NIL)
                         ("22" (HIDE -9 -10) (("22" (GRIND) NIL NIL)) NIL)
                         ("23" (HIDE -9 -10) (("23" (GRIND) NIL NIL)) NIL)
                         ("24" (HIDE -9 -10) (("24" (GRIND) NIL NIL)) NIL)
                         ("25" (HIDE -9 -10) (("25" (GRIND) NIL NIL)) NIL)
                         ("26" (HIDE -9 -10 -11) (("26" (GRIND) NIL NIL)) NIL)
                         ("27" (HIDE -9 -10 -12 -21) (("27" (GRIND) NIL NIL))
                          NIL)
                         ("28" (HIDE -9 -11 -12) (("28" (GRIND) NIL NIL)) NIL)
                         ("29" (HIDE -10 -11 -12) (("29" (GRIND) NIL NIL))
                          NIL)
                         ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                         ("31" (GRIND) NIL NIL)
                         ("32" (EXPAND "sitc")
                          (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL)) NIL))
                          NIL)
                         ("33" (EXPAND "dd2")
                          (("33" (EXPAND "enabled")
                            (("33" (EXPAND "enabled_tick")
                              (("33" (SKOLEM-TYPEPRED)
                                (("33" (FLATTEN)
                                  (("33" (CASE "q!1=alpha")
                                    (("1" (REPLACE -1 *)
                                      (("1"
                                        (INST - "alpha")
                                        (("1" (GRIND) NIL NIL))
                                        NIL))
                                      NIL)
                                     ("2" (CASE "q!1=rho1")
                                      (("1"
                                        (REPLACE -1 *)
                                        (("1"
                                          (INST - "rho1")
                                          (("1"
                                            (HIDE -10 -11)
                                            (("1" (GRIND) NIL NIL))
                                            NIL))
                                          NIL))
                                        NIL)
                                       ("2"
                                        (CASE "q!1=gamma")
                                        (("1"
                                          (REPLACE -1 *)
                                          (("1"
                                            (INST - "gamma")
                                            (("1" (GRIND) NIL NIL))
                                            NIL))
                                          NIL)
                                         ("2"
                                          (CASE "q!1=rho2")
                                          (("1"
                                            (REPLACE -1 *)
                                            (("1"
                                              (INST - "rho2")
                                              (("1" (GRIND) NIL NIL))
                                              NIL))
                                            NIL)
                                           ("2"
                                            (CASE "q!1=pr")
                                            (("1"
                                              (REPLACE -1 *)
                                              (("1"
                                                (INST - "pr")
                                                (("1" (GRIND) NIL NIL))
                                                NIL))
                                              NIL)
                                             ("2"
                                              (CASE "q!1=ps")
                                              (("1"
                                                (REPLACE -1 *)
                                                (("1"
                                                  (INST - "ps")
                                                  (("1" (GRIND) NIL NIL))
                                                  NIL))
                                                NIL)
                                               ("2"
                                                (CASE "q!1=wr")
                                                (("1"
                                                  (REPLACE -1 *)
                                                  (("1"
                                                    (INST - "wr")
                                                    (("1" (GRIND) NIL NIL))
                                                    NIL))
                                                  NIL)
                                                 ("2"
                                                  (CASE "q!1=ws")
                                                  (("1"
                                                    (REPLACE -1 *)
                                                    (("1"
                                                      (INST - "ws")
                                                      (("1" (GRIND) NIL NIL))
                                                      NIL))
                                                    NIL)
                                                   ("2"
                                                    (CASE "q!1=mu1")
                                                    (("1"
                                                      (REPLACE -1 *)
                                                      (("1"
                                                        (INST - "mu")
                                                        (("1"
                                                          (GRIND)
                                                          NIL
                                                          NIL))
                                                        NIL))
                                                      NIL)
                                                     ("2"
                                                      (CASE "q!1=mu2")
                                                      (("1"
                                                        (REPLACE -1 *)
                                                        (("1"
                                                          (INST - "omega19")
                                                          (("1"
                                                            (GRIND)
                                                            NIL
                                                            NIL))
                                                          NIL))
                                                        NIL)
                                                       ("2" (GRIND) NIL NIL))
                                                      NIL))
                                                    NIL))
                                                  NIL))
                                                NIL))
                                              NIL))
                                            NIL))
                                          NIL))
                                        NIL))
                                      NIL))
                                    NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL)
                         ("34" (EXPAND "sitc")
                          (("34" (EXPAND "tc")
                            (("34" (FLATTEN)
                              (("34" (HIDE 1 3)
                                (("34" (EXPAND "r2")
                                  (("34" (SPLIT 1)
                                    (("1" (INST + "mu1")
                                      (("1" (GRIND) NIL NIL)) NIL)
                                     ("2" (GRIND) NIL NIL))
                                    NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL)
                   ("2" (ASSERT) NIL NIL))
                  NIL))
                NIL))
              NIL))
            NIL))
          NIL))
        NIL)
       ("2" (EXPAND "enabled")
        (("2" (FLATTEN)
          (("2" (SPLIT)
            (("1" (FLATTEN)
              (("1"
                (CASE "NOT (a1!1=omega29 or a1!1=pr or a1!1=ps or a1!1=wr or a1!1=ws)")
                (("1" (HIDE 3 4)
                  (("1" (FLATTEN)
                    (("1" (HIDE -2 -8 -9 -10 -11 -20) (("1" (GRIND) NIL NIL))
                      NIL))
                    NIL))
                  NIL)
                 ("2" (SPLIT -)
                  (("1" (HIDE 3)
                    (("1" (REPLACE -1 *)
                      (("1"
                        (INST + "s2!1" "mu2" "trans(mu2,s2!1)"
                         "trans(mu2,s2!1)")
                        (("1" (BDDSIMP)
                          (("1" (HIDE -9 -10 -11 -12) (("1" (GRIND) NIL NIL))
                            NIL)
                           ("2" (HIDE -9 -10 -11 -12) (("2" (GRIND) NIL NIL))
                            NIL)
                           ("3" (HIDE -9 -10 -11 -12) (("3" (GRIND) NIL NIL))
                            NIL)
                           ("4" (HIDE -9 -10 -11 -12) (("4" (GRIND) NIL NIL))
                            NIL)
                           ("5" (HIDE -9 -10 -11 -12) (("5" (GRIND) NIL NIL))
                            NIL)
                           ("6" (HIDE -9 -10 -11 -12) (("6" (GRIND) NIL NIL))
                            NIL)
                           ("7" (HIDE -9 -10 -11 -12) (("7" (GRIND) NIL NIL))
                            NIL)
                           ("8" (HIDE -9 -10 -11 -12) (("8" (GRIND) NIL NIL))
                            NIL)
                           ("9" (HIDE -9 -10 -11 -12) (("9" (GRIND) NIL NIL))
                            NIL)
                           ("10" (HIDE -9 -10)
                            (("10" (GRIND)
                              (("10" (TIME_ETC_SIMP)
                                (("1" (ASSERT) NIL NIL)
                                 ("2" (TIME_ETC_SIMP) NIL NIL))
                                NIL))
                              NIL))
                            NIL)
                           ("11" (HIDE -9 -10 -11 -12)
                            (("11" (GRIND) NIL NIL)) NIL)
                           ("12" (HIDE -9 -10 -11 -12)
                            (("12" (GRIND) NIL NIL)) NIL)
                           ("13" (HIDE -9 -10 -11 -12)
                            (("13" (GRIND) NIL NIL)) NIL)
                           ("14" (HIDE -9 -10 -11 -12)
                            (("14" (GRIND) NIL NIL)) NIL)
                           ("15" (HIDE -9 -10 -11 -12)
                            (("15" (GRIND) NIL NIL)) NIL)
                           ("16" (HIDE -9 -10 -11 -12)
                            (("16" (GRIND) NIL NIL)) NIL)
                           ("17" (HIDE -9 -10 -11 -12)
                            (("17" (GRIND) NIL NIL)) NIL)
                           ("18" (HIDE -9 -10 -11 -12)
                            (("18" (GRIND) NIL NIL)) NIL)
                           ("19" (HIDE -9 -10 -11 -12)
                            (("19" (GRIND) NIL NIL)) NIL)
                           ("20" (HIDE -9 -10 -11 -12)
                            (("20" (GRIND) NIL NIL)) NIL)
                           ("21" (HIDE -9 -10 -11 -12)
                            (("21" (GRIND) NIL NIL)) NIL)
                           ("22" (HIDE -9 -10 -11 -12)
                            (("22" (GRIND) NIL NIL)) NIL)
                           ("23" (HIDE -9 -10 -11 -12)
                            (("23" (GRIND) NIL NIL)) NIL)
                           ("24" (HIDE -9 -10) (("24" (GRIND) NIL NIL)) NIL)
                           ("25" (GRIND) NIL NIL)
                           ("26" (HIDE -9 -10 -11 -21)
                            (("26" (GRIND)
                              (("26" (TIME_ETC_SIMP)
                                (("1" (ASSERT) NIL NIL)
                                 ("2" (TIME_ETC_SIMP) NIL NIL))
                                NIL))
                              NIL))
                            NIL)
                           ("27" (HIDE -9 -10 -12 -21)
                            (("27" (GRIND) NIL NIL)) NIL)
                           ("28" (HIDE -2 -3 -11 -12) (("28" (GRIND) NIL NIL))
                            NIL)
                           ("29" (HIDE -2 -3 -10 -11 -12 -21)
                            (("29" (GRIND) NIL NIL)) NIL)
                           ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                           ("31" (HIDE -9 -10)
                            (("31" (GRIND)
                              (("31" (TIME_ETC_SIMP)
                                (("1" (ASSERT) NIL NIL)
                                 ("2" (TIME_ETC_SIMP) NIL NIL))
                                NIL))
                              NIL))
                            NIL)
                           ("32" (EXPAND "sitc")
                            (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL))
                              NIL))
                            NIL)
                           ("33" (HIDE -9 -10 -11)
                            (("33" (GRIND)
                              (("33" (TIME_ETC_SIMP)
                                (("1" (ASSERT) NIL NIL)
                                 ("2" (TIME_ETC_SIMP) NIL NIL))
                                NIL))
                              NIL))
                            NIL)
                           ("34" (EXPAND "sitc")
                            (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL)
                   ("2" (HIDE 3)
                    (("2" (REPLACE -1 *)
                      (("2"
                        (INST + "s2!1" "pr" "trans(pr,s2!1)" "trans(pr,s2!1)")
                        (("2" (BDDSIMP)
                          (("1" (HIDE -2 -3 -9 -10 -11 -12)
                            (("1" (GRIND) NIL NIL)) NIL)
                           ("2" (HIDE -2 -3 -9 -10 -11 -12)
                            (("2" (GRIND) NIL NIL)) NIL)
                           ("3" (HIDE -2 -3 -9 -10 -11 -12)
                            (("3" (GRIND) NIL NIL)) NIL)
                           ("4" (HIDE -2 -3 -9 -10 -11 -12)
                            (("4" (GRIND) NIL NIL)) NIL)
                           ("5" (HIDE -2 -3 -9 -10 -11 -12)
                            (("5" (GRIND) NIL NIL)) NIL)
                           ("6" (HIDE -2 -3 -9 -10 -11 -12)
                            (("6" (GRIND) NIL NIL)) NIL)
                           ("7" (HIDE -2 -3 -9 -10 -11 -12)
                            (("7" (GRIND) NIL NIL)) NIL)
                           ("8" (HIDE -2 -3 -9 -10 -11 -12)
                            (("8" (GRIND) NIL NIL)) NIL)
                           ("9" (HIDE -2 -3 -9 -10 -11 -12)
                            (("9" (GRIND) NIL NIL)) NIL)
                           ("10" (HIDE -2 -3 -9 -10 -11 -12)
                            (("10" (GRIND) NIL NIL)) NIL)
                           ("11" (HIDE -2 -3 -9 -10 -11 -12)
                            (("11" (GRIND) NIL NIL)) NIL)
                           ("12" (HIDE -2 -3 -9 -10 -11 -12)
                            (("12" (GRIND) NIL NIL)) NIL)
                           ("13" (HIDE -2 -3 -9 -10 -11 -12)
                            (("13" (GRIND) NIL NIL)) NIL)
                           ("14" (HIDE -2 -3 -9 -10 -11 -12)
                            (("14" (GRIND) NIL NIL)) NIL)
                           ("15" (HIDE -2 -3 -9 -10 -11 -12)
                            (("15" (GRIND) NIL NIL)) NIL)
                           ("16" (HIDE -2 -3 -9 -10 -11 -12)
                            (("16" (GRIND) NIL NIL)) NIL)
                           ("17" (HIDE -2 -3 -9 -10 -11 -12)
                            (("17" (GRIND) NIL NIL)) NIL)
                           ("18" (HIDE -2 -3 -9 -10 -11 -12)
                            (("18" (GRIND) NIL NIL)) NIL)
                           ("19" (HIDE -2 -3 -9 -10 -11 -12)
                            (("19" (GRIND) NIL NIL)) NIL)
                           ("20" (HIDE -2 -3 -9 -10 -11 -12)
                            (("20" (GRIND) NIL NIL)) NIL)
                           ("21" (HIDE -2 -3 -9 -10 -11 -12)
                            (("21" (GRIND) NIL NIL)) NIL)
                           ("22" (HIDE -2 -3 -9 -10 -11 -12)
                            (("22" (GRIND) NIL NIL)) NIL)
                           ("23" (HIDE -2 -3 -9 -10 -11 -12)
                            (("23" (GRIND) NIL NIL)) NIL)
                           ("24" (HIDE -2 -3 -9 -10 -11 -12)
                            (("24" (GRIND) NIL NIL)) NIL)
                           ("25" (HIDE -2 -3 -9 -10 -11 -12)
                            (("25" (GRIND) NIL NIL)) NIL)
                           ("26" (HIDE -2 -3 -9 -10 -11)
                            (("26" (GRIND) NIL NIL)) NIL)
                           ("27" (HIDE -2 -3 -9 -10 -12)
                            (("27" (GRIND) NIL NIL)) NIL)
                           ("28" (HIDE -2 -3 -9 -11 -12)
                            (("28" (GRIND) NIL NIL)) NIL)
                           ("29" (HIDE -2 -3 -10 -11 -12 -21)
                            (("29" (GRIND) NIL NIL)) NIL)
                           ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                           ("31" (GRIND) NIL NIL)
                           ("32" (EXPAND "sitc")
                            (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL))
                              NIL))
                            NIL)
                           ("33" (GRIND) NIL NIL)
                           ("34" (EXPAND "sitc")
                            (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL)
                   ("3" (REPLACE -1 *)
                    (("3" (HIDE 3)
                      (("3"
                        (INST + "s2!1" "ps" "trans(ps,s2!1)" "trans(ps,s2!1)")
                        (("3" (BDDSIMP)
                          (("1" (HIDE -2 -3 -9 -10 -11 -12)
                            (("1" (GRIND) NIL NIL)) NIL)
                           ("2" (HIDE -2 -3 -9 -10 -11 -12)
                            (("2" (GRIND) NIL NIL)) NIL)
                           ("3" (HIDE -2 -3 -9 -10 -11 -12)
                            (("3" (GRIND) NIL NIL)) NIL)
                           ("4" (HIDE -2 -3 -9 -10 -11 -12)
                            (("4" (GRIND) NIL NIL)) NIL)
                           ("5" (HIDE -2 -3 -9 -10 -11 -12)
                            (("5" (GRIND) NIL NIL)) NIL)
                           ("6" (HIDE -2 -3 -9 -10 -11 -12)
                            (("6" (GRIND) NIL NIL)) NIL)
                           ("7" (HIDE -2 -3 -9 -10 -11 -12)
                            (("7" (GRIND) NIL NIL)) NIL)
                           ("8" (HIDE -2 -3 -9 -10 -11 -12)
                            (("8" (GRIND) NIL NIL)) NIL)
                           ("9" (HIDE -2 -3 -9 -10 -11 -12)
                            (("9" (GRIND) NIL NIL)) NIL)
                           ("10" (HIDE -2 -3 -9 -10 -11 -12)
                            (("10" (GRIND) NIL NIL)) NIL)
                           ("11" (HIDE -2 -3 -9 -10 -11 -12)
                            (("11" (GRIND) NIL NIL)) NIL)
                           ("12" (HIDE -2 -3 -9 -10 -11 -12)
                            (("12" (GRIND) NIL NIL)) NIL)
                           ("13" (HIDE -2 -3 -9 -10 -11 -12)
                            (("13" (GRIND) NIL NIL)) NIL)
                           ("14" (HIDE -2 -3 -9 -10 -11 -12)
                            (("14" (GRIND) NIL NIL)) NIL)
                           ("15" (HIDE -2 -3 -9 -10 -11 -12)
                            (("15" (GRIND) NIL NIL)) NIL)
                           ("16" (HIDE -2 -3 -9 -10 -11 -12)
                            (("16" (GRIND) NIL NIL)) NIL)
                           ("17" (HIDE -2 -3 -9 -10 -11 -12)
                            (("17" (GRIND) NIL NIL)) NIL)
                           ("18" (HIDE -2 -3 -9 -10 -11 -12)
                            (("18" (GRIND) NIL NIL)) NIL)
                           ("19" (HIDE -2 -3 -9 -10 -11 -12)
                            (("19" (GRIND) NIL NIL)) NIL)
                           ("20" (HIDE -2 -3 -9 -10 -11 -12)
                            (("20" (GRIND) NIL NIL)) NIL)
                           ("21" (HIDE -2 -3 -9 -10 -11 -12)
                            (("21" (GRIND) NIL NIL)) NIL)
                           ("22" (HIDE -2 -3 -9 -10 -11 -12)
                            (("22" (GRIND) NIL NIL)) NIL)
                           ("23" (HIDE -2 -3 -9 -10 -11 -12)
                            (("23" (GRIND) NIL NIL)) NIL)
                           ("24" (HIDE -2 -3 -9 -10 -11 -12)
                            (("24" (GRIND) NIL NIL)) NIL)
                           ("25" (HIDE -2 -3 -9 -10 -11 -12)
                            (("25" (GRIND) NIL NIL)) NIL)
                           ("26" (HIDE -2 -3 -9 -10 -11)
                            (("26" (GRIND) NIL NIL)) NIL)
                           ("27" (HIDE -2 -3 -9 -10 -12)
                            (("27" (GRIND) NIL NIL)) NIL)
                           ("28" (HIDE -2 -3 -9 -11 -12)
                            (("28" (GRIND) NIL NIL)) NIL)
                           ("29" (HIDE -2 -3 -10 -11 -12)
                            (("29" (GRIND) NIL NIL)) NIL)
                           ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                           ("31" (HIDE -2 -3 -10 -11 -12)
                            (("31" (GRIND) NIL NIL)) NIL)
                           ("32" (EXPAND "sitc")
                            (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL))
                              NIL))
                            NIL)
                           ("33" (GRIND) NIL NIL)
                           ("34" (EXPAND "sitc")
                            (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL)
                   ("4" (REPLACE -1 *)
                    (("4" (HIDE 3)
                      (("4"
                        (INST + "s2!1" "wr" "trans(wr,s2!1)" "trans(wr,s2!1)")
                        (("4" (BDDSIMP)
                          (("1" (HIDE -2 -3 -9 -10 -11 -12)
                            (("1" (GRIND) NIL NIL)) NIL)
                           ("2" (HIDE -2 -3 -9 -10 -11 -12)
                            (("2" (GRIND) NIL NIL)) NIL)
                           ("3" (HIDE -2 -3 -9 -10 -11 -12)
                            (("3" (GRIND) NIL NIL)) NIL)
                           ("4" (HIDE -2 -3 -9 -10 -11 -12)
                            (("4" (GRIND) NIL NIL)) NIL)
                           ("5" (HIDE -2 -3 -9 -10 -11 -12)
                            (("5" (GRIND) NIL NIL)) NIL)
                           ("6" (HIDE -2 -3 -9 -10 -11 -12)
                            (("6" (GRIND) NIL NIL)) NIL)
                           ("7" (HIDE -2 -3 -9 -10 -11 -12)
                            (("7" (GRIND) NIL NIL)) NIL)
                           ("8" (HIDE -2 -3 -9 -10 -11 -12)
                            (("8" (GRIND) NIL NIL)) NIL)
                           ("9" (HIDE -2 -3 -9 -10 -11 -12)
                            (("9" (GRIND) NIL NIL)) NIL)
                           ("10" (HIDE -2 -3 -9 -10 -11 -12)
                            (("10" (GRIND) NIL NIL)) NIL)
                           ("11" (HIDE -2 -3 -9 -10 -11 -12)
                            (("11" (GRIND) NIL NIL)) NIL)
                           ("12" (HIDE -2 -3 -9 -10 -11 -12)
                            (("12" (GRIND) NIL NIL)) NIL)
                           ("13" (HIDE -2 -3 -9 -10 -11 -12)
                            (("13" (GRIND) NIL NIL)) NIL)
                           ("14" (HIDE -2 -3 -9 -10 -11 -12)
                            (("14" (GRIND) NIL NIL)) NIL)
                           ("15" (HIDE -2 -3 -9 -10 -11 -12)
                            (("15" (GRIND) NIL NIL)) NIL)
                           ("16" (HIDE -2 -3 -9 -10 -11 -12)
                            (("16" (GRIND) NIL NIL)) NIL)
                           ("17" (HIDE -2 -3 -9 -10 -11 -12)
                            (("17" (GRIND) NIL NIL)) NIL)
                           ("18" (HIDE -2 -3 -9 -10 -11 -12)
                            (("18" (GRIND) NIL NIL)) NIL)
                           ("19" (HIDE -2 -3 -9 -10 -11 -12)
                            (("19" (GRIND) NIL NIL)) NIL)
                           ("20" (HIDE -2 -3 -9 -10 -11 -12)
                            (("20" (GRIND) NIL NIL)) NIL)
                           ("21" (HIDE -2 -3 -9 -10 -11 -12)
                            (("21" (GRIND) NIL NIL)) NIL)
                           ("22" (HIDE -2 -3 -9 -10 -11 -12)
                            (("22" (GRIND) NIL NIL)) NIL)
                           ("23" (HIDE -2 -3 -9 -10 -11 -12)
                            (("23" (GRIND) NIL NIL)) NIL)
                           ("24" (HIDE -2 -3 -9 -10 -11 -12)
                            (("24" (GRIND) NIL NIL)) NIL)
                           ("25" (HIDE -2 -3 -9 -10 -11 -12)
                            (("25" (GRIND) NIL NIL)) NIL)
                           ("26" (HIDE -2 -3 -9 -10 -11)
                            (("26" (GRIND) NIL NIL)) NIL)
                           ("27" (HIDE -2 -3 -9 -10 -12)
                            (("27" (GRIND) NIL NIL)) NIL)
                           ("28" (HIDE -2 -3 -9 -11 -12)
                            (("28" (GRIND) NIL NIL)) NIL)
                           ("29" (HIDE -2 -3 -10 -11 -12)
                            (("29" (GRIND) NIL NIL)) NIL)
                           ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                           ("31" (HIDE -2 -3 -9 -10 -11 -12)
                            (("31" (GRIND) NIL NIL)) NIL)
                           ("32" (EXPAND "sitc")
                            (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL))
                              NIL))
                            NIL)
                           ("33" (GRIND) NIL NIL)
                           ("34" (EXPAND "sitc")
                            (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL)
                   ("5" (REPLACE -1 *)
                    (("5" (HIDE 3)
                      (("5"
                        (INST + "s2!1" "ws" "trans(ws,s2!1)" "trans(ws,s2!1)")
                        (("5" (BDDSIMP)
                          (("1" (HIDE -2 -3 -9 -10 -11 -12)
                            (("1" (GRIND) NIL NIL)) NIL)
                           ("2" (HIDE -2 -3 -9 -10 -11 -12)
                            (("2" (GRIND) NIL NIL)) NIL)
                           ("3" (HIDE -2 -3 -9 -10 -11 -12)
                            (("3" (GRIND) NIL NIL)) NIL)
                           ("4" (HIDE -2 -3 -9 -10 -11 -12)
                            (("4" (GRIND) NIL NIL)) NIL)
                           ("5" (HIDE -2 -3 -9 -10 -11 -12)
                            (("5" (GRIND) NIL NIL)) NIL)
                           ("6" (HIDE -2 -3 -9 -10 -11 -12)
                            (("6" (GRIND) NIL NIL)) NIL)
                           ("7" (HIDE -2 -3 -9 -10 -11 -12)
                            (("7" (GRIND) NIL NIL)) NIL)
                           ("8" (HIDE -2 -3 -9 -10 -11 -12)
                            (("8" (GRIND) NIL NIL)) NIL)
                           ("9" (HIDE -2 -3 -9 -10 -11 -12)
                            (("9" (GRIND) NIL NIL)) NIL)
                           ("10" (HIDE -2 -3 -9 -10 -11 -12)
                            (("10" (GRIND) NIL NIL)) NIL)
                           ("11" (HIDE -2 -3 -9 -10 -11 -12)
                            (("11" (GRIND) NIL NIL)) NIL)
                           ("12" (HIDE -2 -3 -9 -10 -11 -12)
                            (("12" (GRIND) NIL NIL)) NIL)
                           ("13" (HIDE -2 -3 -9 -10 -11 -12)
                            (("13" (GRIND) NIL NIL)) NIL)
                           ("14" (HIDE -2 -3 -9 -10 -11 -12)
                            (("14" (GRIND) NIL NIL)) NIL)
                           ("15" (HIDE -2 -3 -9 -10 -11 -12)
                            (("15" (GRIND) NIL NIL)) NIL)
                           ("16" (HIDE -2 -3 -9 -10 -11 -12)
                            (("16" (GRIND) NIL NIL)) NIL)
                           ("17" (HIDE -2 -3 -9 -10 -11 -12)
                            (("17" (GRIND) NIL NIL)) NIL)
                           ("18" (HIDE -2 -3 -9 -10 -11 -12)
                            (("18" (GRIND) NIL NIL)) NIL)
                           ("19" (HIDE -2 -3 -9 -10 -11 -12)
                            (("19" (GRIND) NIL NIL)) NIL)
                           ("20" (HIDE -2 -3 -9 -10 -11 -12)
                            (("20" (GRIND) NIL NIL)) NIL)
                           ("21" (HIDE -2 -3 -9 -10 -11 -12)
                            (("21" (GRIND) NIL NIL)) NIL)
                           ("22" (HIDE -2 -3 -9 -10 -11 -12)
                            (("22" (GRIND) NIL NIL)) NIL)
                           ("23" (HIDE -2 -3 -9 -10 -11 -12)
                            (("23" (GRIND) NIL NIL)) NIL)
                           ("24" (HIDE -2 -3 -9 -10 -11 -12)
                            (("24" (GRIND) NIL NIL)) NIL)
                           ("25" (HIDE -2 -3 -9 -10 -11 -12)
                            (("25" (GRIND) NIL NIL)) NIL)
                           ("26" (HIDE -2 -3 -9 -10 -11)
                            (("26" (GRIND) NIL NIL)) NIL)
                           ("27" (HIDE -2 -3 -9 -10 -12)
                            (("27" (GRIND) NIL NIL)) NIL)
                           ("28" (HIDE -2 -3 -9 -11 -12)
                            (("28" (GRIND) NIL NIL)) NIL)
                           ("29" (HIDE -2 -3 -10 -11 -12)
                            (("29" (GRIND) NIL NIL)) NIL)
                           ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                           ("31" (GRIND) NIL NIL)
                           ("32" (EXPAND "sitc")
                            (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL))
                              NIL))
                            NIL)
                           ("33" (GRIND) NIL NIL)
                           ("34" (EXPAND "sitc")
                            (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL))
                  NIL))
                NIL))
              NIL)
             ("2" (FLATTEN)
              (("2" (HIDE 2)
                (("2" (CASE "a1!1=tick")
                  (("1" (REPLACE -1 *)
                    (("1"
                      (INST + "s2!1 WITH [(action_time)(mu1) :=zero]" "tick"
                       "trans(tick,s2!1 WITH [(action_time)(mu1) :=zero])"
                       "trans(tick,s2!1 WITH [(action_time)(mu1) :=zero])")
                      (("1" (BDDSIMP)
                        (("1" (HIDE -9 -10 -11 -12) (("1" (GRIND) NIL NIL))
                          NIL)
                         ("2" (HIDE -9 -10 -11 -12) (("2" (GRIND) NIL NIL))
                          NIL)
                         ("3" (HIDE -9 -10 -11 -12) (("3" (GRIND) NIL NIL))
                          NIL)
                         ("4" (HIDE -9 -10 -11 -12) (("4" (GRIND) NIL NIL))
                          NIL)
                         ("5" (HIDE -9 -10 -11 -12) (("5" (GRIND) NIL NIL))
                          NIL)
                         ("6" (HIDE -9 -10 -11 -12) (("6" (GRIND) NIL NIL))
                          NIL)
                         ("7" (HIDE -9 -10 -11 -12) (("7" (GRIND) NIL NIL))
                          NIL)
                         ("8" (HIDE -9 -10 -11 -12) (("8" (GRIND) NIL NIL))
                          NIL)
                         ("9" (HIDE -9 -10 -11 -12) (("9" (GRIND) NIL NIL))
                          NIL)
                         ("10" (HIDE -9 -10 -11 -12) (("10" (GRIND) NIL NIL))
                          NIL)
                         ("11" (HIDE -9 -10 -11 -12) (("11" (GRIND) NIL NIL))
                          NIL)
                         ("12" (HIDE -9 -10 -11 -12) (("12" (GRIND) NIL NIL))
                          NIL)
                         ("13" (HIDE -9 -10 -11 -12) (("13" (GRIND) NIL NIL))
                          NIL)
                         ("14" (HIDE -9 -10 -11 -12) (("14" (GRIND) NIL NIL))
                          NIL)
                         ("15" (HIDE -9 -10 -11 -12) (("15" (GRIND) NIL NIL))
                          NIL)
                         ("16" (HIDE -9 -10 -11 -12) (("16" (GRIND) NIL NIL))
                          NIL)
                         ("17" (HIDE -9 -10 -11 -12) (("17" (GRIND) NIL NIL))
                          NIL)
                         ("18" (HIDE -9 -10 -11 -12) (("18" (GRIND) NIL NIL))
                          NIL)
                         ("19" (HIDE -9 -10 -11 -12) (("19" (GRIND) NIL NIL))
                          NIL)
                         ("20" (HIDE -9 -10 -11 -12) (("20" (GRIND) NIL NIL))
                          NIL)
                         ("21" (HIDE -9 -10 -11 -12) (("21" (GRIND) NIL NIL))
                          NIL)
                         ("22" (HIDE -9 -10 -11 -12) (("22" (GRIND) NIL NIL))
                          NIL)
                         ("23" (HIDE -9 -10 -11 -12) (("23" (GRIND) NIL NIL))
                          NIL)
                         ("24" (HIDE -9 -10 -11 -12) (("24" (GRIND) NIL NIL))
                          NIL)
                         ("25" (HIDE -9 -10 -11 -12) (("25" (GRIND) NIL NIL))
                          NIL)
                         ("26" (HIDE -9 -10 -11) (("26" (GRIND) NIL NIL)) NIL)
                         ("27" (HIDE -9 -10 -12) (("27" (GRIND) NIL NIL)) NIL)
                         ("28" (HIDE -9 -11 -12) (("28" (GRIND) NIL NIL)) NIL)
                         ("29" (HIDE -10 -11 -12) (("29" (GRIND) NIL NIL))
                          NIL)
                         ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                         ("31" (GRIND) NIL NIL)
                         ("32" (EXPAND "sitc")
                          (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL)) NIL))
                          NIL)
                         ("33" (EXPAND "dd2")
                          (("33" (EXPAND "enabled")
                            (("33" (EXPAND "enabled_tick")
                              (("33" (SKOLEM-TYPEPRED)
                                (("33" (FLATTEN)
                                  (("33" (CASE "q!1=alpha")
                                    (("1" (INST - "alpha")
                                      (("1" (GRIND) NIL NIL)) NIL)
                                     ("2" (CASE "q!1=rho1")
                                      (("1"
                                        (REPLACE -1 *)
                                        (("1"
                                          (INST - "rho1")
                                          (("1" (GRIND) NIL NIL))
                                          NIL))
                                        NIL)
                                       ("2"
                                        (CASE "q!1=gamma")
                                        (("1"
                                          (REPLACE -1 *)
                                          (("1"
                                            (INST - "gamma")
                                            (("1" (GRIND) NIL NIL))
                                            NIL))
                                          NIL)
                                         ("2"
                                          (CASE "q!1=rho2")
                                          (("1"
                                            (REPLACE -1 *)
                                            (("1"
                                              (INST - "rho2")
                                              (("1" (GRIND) NIL NIL))
                                              NIL))
                                            NIL)
                                           ("2"
                                            (CASE "q!1=pr")
                                            (("1"
                                              (REPLACE -1 *)
                                              (("1"
                                                (INST - "pr")
                                                (("1" (GRIND) NIL NIL))
                                                NIL))
                                              NIL)
                                             ("2"
                                              (CASE "q!1=ps")
                                              (("1"
                                                (REPLACE -1 *)
                                                (("1"
                                                  (INST - "ps")
                                                  (("1" (GRIND) NIL NIL))
                                                  NIL))
                                                NIL)
                                               ("2"
                                                (CASE "q!1=wr")
                                                (("1"
                                                  (REPLACE -1 *)
                                                  (("1"
                                                    (INST - "wr")
                                                    (("1" (GRIND) NIL NIL))
                                                    NIL))
                                                  NIL)
                                                 ("2"
                                                  (CASE "q!1=ws")
                                                  (("1"
                                                    (REPLACE -1 *)
                                                    (("1"
                                                      (INST - "ws")
                                                      (("1" (GRIND) NIL NIL))
                                                      NIL))
                                                    NIL)
                                                   ("2"
                                                    (CASE "q!1=mu1")
                                                    (("1"
                                                      (REPLACE -1 *)
                                                      (("1"
                                                        (INST - "mu")
                                                        (("1"
                                                          (GRIND)
                                                          NIL
                                                          NIL))
                                                        NIL))
                                                      NIL)
                                                     ("2"
                                                      (CASE "q!1=mu2")
                                                      (("1"
                                                        (REPLACE -1 *)
                                                        (("1"
                                                          (INST - "omega19")
                                                          (("1"
                                                            (GRIND)
                                                            NIL
                                                            NIL))
                                                          NIL))
                                                        NIL)
                                                       ("2" (GRIND) NIL NIL))
                                                      NIL))
                                                    NIL))
                                                  NIL))
                                                NIL))
                                              NIL))
                                            NIL))
                                          NIL))
                                        NIL))
                                      NIL))
                                    NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL)
                         ("34" (EXPAND "sitc")
                          (("34" (EXPAND "tc")
                            (("34" (FLATTEN)
                              (("34" (HIDE 3)
                                (("34" (EXPAND "r2")
                                  (("34" (SPLIT)
                                    (("1" (APPLY-EXTENSIONALITY)
                                      (("1"
                                        (APPLY-EXTENSIONALITY)
                                        (("1"
                                          (HIDE 3)
                                          (("1"
                                            (HIDE 2 3)
                                            (("1"
                                              (CASE "x!1=alpha")
                                              (("1"
                                                (REPLACE -1 *)
                                                (("1" (ASSERT) NIL NIL))
                                                NIL)
                                               ("2"
                                                (CASE "x!1=rho1")
                                                (("1"
                                                  (REPLACE -1 *)
                                                  (("1" (ASSERT) NIL NIL))
                                                  NIL)
                                                 ("2"
                                                  (CASE "x!1=gamma")
                                                  (("1"
                                                    (REPLACE -1 *)
                                                    (("1" (ASSERT) NIL NIL))
                                                    NIL)
                                                   ("2"
                                                    (CASE "x!1=rho2")
                                                    (("1"
                                                      (REPLACE -1 *)
                                                      (("1" (ASSERT) NIL NIL))
                                                      NIL)
                                                     ("2"
                                                      (CASE "x!1=pr")
                                                      (("1"
                                                        (REPLACE -1 *)
                                                        (("1"
                                                          (ASSERT)
                                                          NIL
                                                          NIL))
                                                        NIL)
                                                       ("2"
                                                        (CASE "x!1=ps")
                                                        (("1"
                                                          (REPLACE -1 *)
                                                          (("1"
                                                            (ASSERT)
                                                            NIL
                                                            NIL))
                                                          NIL)
                                                         ("2"
                                                          (CASE "x!1=wr")
                                                          (("1"
                                                            (REPLACE -1 *)
                                                            (("1"
                                                              (ASSERT)
                                                              NIL
                                                              NIL))
                                                            NIL)
                                                           ("2"
                                                            (CASE "x!1=ws")
                                                            (("1"
                                                              (REPLACE -1 *)
                                                              (("1"
                                                                (ASSERT)
                                                                NIL
                                                                NIL))
                                                              NIL)
                                                             ("2"
                                                              (CASE "x!1=mu1")
                                                              (("1"
                                                                (REPLACE -1 *)
                                                                (("1"
                                                                  (ASSERT)
                                                                  NIL
                                                                  NIL))
                                                                NIL)
                                                               ("2"
                                                                (CASE
                                                                 "x!1=mu2")
                                                                (("1"
                                                                  (REPLACE

                                                                   -1
                                                                   *)
                                                                  (("1"
                                                                    (ASSERT)
                                                                    NIL
                                                                    NIL))
                                                                  NIL)
                                                                 ("2"
                                                                  (ASSERT)
                                                                  NIL
                                                                  NIL))
                                                                NIL))
                                                              NIL))
                                                            NIL))
                                                          NIL))
                                                        NIL))
                                                      NIL))
                                                    NIL))
                                                  NIL))
                                                NIL))
                                              NIL))
                                            NIL))
                                          NIL))
                                        NIL))
                                      NIL)
                                     ("2" (GRIND) NIL NIL))
                                    NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL)
                   ("2" (ASSERT) NIL NIL))
                  NIL))
                NIL))
              NIL))
            NIL))
          NIL))
        NIL))
      NIL))
    NIL))
  NIL)
 (|sim12_4_TCC1| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC2| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC3| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC4| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC5| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC6| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC7| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC8| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC9| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC10| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC11| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC12| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC13| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC14| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC15| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC16| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC17| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC18| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC19| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC20| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC21| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC22| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC23| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC24| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC25| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC26| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC27| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC28| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC29| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC30| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC31| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC32| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4_TCC33| "" (SUBTYPE-TCC) NIL NIL)
 (|sim12_4| "" (SKOLEM-TYPEPRED)
  (("" (FLATTEN)
    (("" (EXPAND "enabled")
      (("" (SPLIT -5)
        (("1" (FLATTEN)
          (("1"
            (CASE "NOT (a1!1=omega19 or a1!1=pr or a1!1=ps or a1!1=wr or a1!1=ws)")
            (("1" (HIDE 3 4)
              (("1" (FLATTEN)
                (("1" (HIDE -2 -7 -8 -9 -10 -19) (("1" (GRIND) NIL NIL)) NIL))
                NIL))
              NIL)
             ("2" (SPLIT -1)
              (("1" (HIDE 3)
                (("1" (SPLIT)
                  (("1"
                    (INST + "s2!1" "mu2" "trans(mu2,s2!1)" "trans(mu2,s2!1)")
                    (("1" (REPLACE -2 *)
                      (("1" (BDDSIMP)
                        (("1" (HIDE -4 -5 -9 -10 -11 -12)
                          (("1" (GRIND) NIL NIL)) NIL)
                         ("2" (HIDE -4 -5 -9 -10 -11 -12)
                          (("2" (GRIND) NIL NIL)) NIL)
                         ("3" (HIDE -4 -5 -9 -10 -11 -12)
                          (("3" (GRIND) NIL NIL)) NIL)
                         ("4" (HIDE -4 -5 -9 -10 -11 -12)
                          (("4" (GRIND) NIL NIL)) NIL)
                         ("5" (HIDE -4 -5 -9 -10 -11 -12)
                          (("5" (GRIND) NIL NIL)) NIL)
                         ("6" (HIDE -4 -5 -9 -10 -11 -12)
                          (("6" (GRIND) NIL NIL)) NIL)
                         ("7" (HIDE -4 -5 -9 -10 -11 -12)
                          (("7" (GRIND) NIL NIL)) NIL)
                         ("8" (HIDE -4 -5 -9 -10 -11 -12)
                          (("8" (GRIND) NIL NIL)) NIL)
                         ("9" (HIDE -4 -5 -9 -10 -11 -12)
                          (("9" (GRIND) NIL NIL)) NIL)
                         ("10" (HIDE -4 -5 -9 -10 -11 -12)
                          (("10" (GRIND) NIL NIL)) NIL)
                         ("11" (HIDE -4 -5 -9 -10 -11 -12)
                          (("11" (GRIND) NIL NIL)) NIL)
                         ("12" (HIDE -4 -5 -9 -10 -11 -12)
                          (("12" (GRIND) NIL NIL)) NIL)
                         ("13" (HIDE -4 -5 -9 -10 -11 -12)
                          (("13" (GRIND) NIL NIL)) NIL)
                         ("14" (HIDE -4 -5 -9 -10 -11 -12)
                          (("14" (GRIND) NIL NIL)) NIL)
                         ("15" (HIDE -4 -5 -9 -10 -11 -12)
                          (("15" (GRIND) NIL NIL)) NIL)
                         ("16" (HIDE -4 -5 -9 -10 -11 -12)
                          (("16" (GRIND) NIL NIL)) NIL)
                         ("17" (GRIND) NIL NIL)
                         ("18" (HIDE -4 -5 -9 -10 -11 -12)
                          (("18" (GRIND) NIL NIL)) NIL)
                         ("19" (HIDE -4 -5 -9 -10 -11 -12)
                          (("19" (GRIND) NIL NIL)) NIL)
                         ("20" (HIDE -4 -5 -9 -10 -11 -12)
                          (("20" (GRIND) NIL NIL)) NIL)
                         ("21" (HIDE -4 -5 -9 -10 -11 -12)
                          (("21" (GRIND) NIL NIL)) NIL)
                         ("22" (GRIND) NIL NIL)
                         ("23" (HIDE -9 -10) (("23" (GRIND) NIL NIL)) NIL)
                         ("24" (HIDE -9 -10) (("24" (GRIND) NIL NIL)) NIL)
                         ("25" (HIDE -9 -10) (("25" (GRIND) NIL NIL)) NIL)
                         ("26" (HIDE -9 -10 -11) (("26" (GRIND) NIL NIL)) NIL)
                         ("27" (HIDE -4 -5 -9 -10 -12)
                          (("27" (GRIND) NIL NIL)) NIL)
                         ("28" (HIDE -4 -5 -9 -11 -12)
                          (("28" (GRIND) NIL NIL)) NIL)
                         ("29" (HIDE -4 -5 -10 -11 -12)
                          (("29" (GRIND) NIL NIL)) NIL)
                         ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                         ("31" (GRIND) NIL NIL)
                         ("32" (EXPAND "sitc")
                          (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL)) NIL))
                          NIL)
                         ("33" (GRIND) NIL NIL)
                         ("34" (EXPAND "sitc")
                          (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL)) NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL)
                   ("2" (REPLACE -2 *)
                    (("2"
                      (INST + "s2!1" "mu2" "trans(mu2,s2!1)"
                       "trans(mu2,s2!1)")
                      (("2" (BDDSIMP)
                        (("1" (HIDE -4 -5 -9 -10 -11 -12)
                          (("1" (GRIND) NIL NIL)) NIL)
                         ("2" (HIDE -4 -5 -9 -10 -11 -12)
                          (("2" (GRIND) NIL NIL)) NIL)
                         ("3" (HIDE -4 -5 -9 -10 -11 -12)
                          (("3" (GRIND) NIL NIL)) NIL)
                         ("4" (HIDE -4 -5 -9 -10 -11 -12)
                          (("4" (GRIND) NIL NIL)) NIL)
                         ("5" (HIDE -4 -5 -9 -10 -11 -12)
                          (("5" (GRIND) NIL NIL)) NIL)
                         ("6" (HIDE -4 -5 -9 -10 -11 -12)
                          (("6" (GRIND) NIL NIL)) NIL)
                         ("7" (HIDE -4 -5 -9 -10 -11 -12)
                          (("7" (GRIND) NIL NIL)) NIL)
                         ("8" (HIDE -4 -5 -9 -10 -11 -12)
                          (("8" (GRIND) NIL NIL)) NIL)
                         ("9" (HIDE -4 -5 -9 -10 -11 -12)
                          (("9" (GRIND) NIL NIL)) NIL)
                         ("10" (HIDE -4 -5 -9 -10 -11 -12)
                          (("10" (GRIND) NIL NIL)) NIL)
                         ("11" (HIDE -4 -5 -9 -10 -11 -12)
                          (("11" (GRIND) NIL NIL)) NIL)
                         ("12" (HIDE -4 -5 -9 -10 -11 -12)
                          (("12" (GRIND) NIL NIL)) NIL)
                         ("13" (HIDE -4 -5 -9 -10 -11 -12)
                          (("13" (GRIND) NIL NIL)) NIL)
                         ("14" (HIDE -4 -5 -9 -10 -11 -12)
                          (("14" (GRIND) NIL NIL)) NIL)
                         ("15" (HIDE -4 -5 -9 -10 -11 -12)
                          (("15" (GRIND) NIL NIL)) NIL)
                         ("16" (HIDE -4 -5 -9 -10 -11 -12)
                          (("16" (GRIND) NIL NIL)) NIL)
                         ("17" (HIDE -9 -10)
                          (("17" (HIDE -9)
                            (("17" (GRIND)
                              (("17" (TIME_ETC_SIMP) (("17" (ASSERT) NIL NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL)
                         ("18" (HIDE -4 -5 -9 -10 -11 -12)
                          (("18" (GRIND) NIL NIL)) NIL)
                         ("19" (HIDE -4 -5 -9 -10 -11 -12)
                          (("19" (GRIND) NIL NIL)) NIL)
                         ("20" (HIDE -4 -5 -9 -10 -11 -12)
                          (("20" (GRIND) NIL NIL)) NIL)
                         ("21" (HIDE -4 -5 -9 -10 -11 -12)
                          (("21" (GRIND) NIL NIL)) NIL)
                         ("22" (HIDE -9 -10) (("22" (GRIND) NIL NIL)) NIL)
                         ("23" (HIDE -9 -10) (("23" (GRIND) NIL NIL)) NIL)
                         ("24" (HIDE -9 -10) (("24" (GRIND) NIL NIL)) NIL)
                         ("25" (HIDE -9 -10) (("25" (GRIND) NIL NIL)) NIL)
                         ("26" (HIDE -4 -5 -9 -10 -11)
                          (("26" (GRIND) NIL NIL)) NIL)
                         ("27" (HIDE -4 -5 -9 -10 -12)
                          (("27" (GRIND) NIL NIL)) NIL)
                         ("28" (HIDE -4 -5 -9 -11 -12)
                          (("28" (GRIND) NIL NIL)) NIL)
                         ("29" (HIDE -4 -5 -10 -11 -12)
                          (("29" (GRIND) NIL NIL)) NIL)
                         ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                         ("31" (GRIND) NIL NIL)
                         ("32" (EXPAND "sitc")
                          (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL)) NIL))
                          NIL)
                         ("33" (HIDE -9 -10)
                          (("33" (HIDE -9)
                            (("33" (GRIND)
                              (("33" (TIME_ETC_SIMP)
                                (("1" (ASSERT) NIL NIL)
                                 ("2" (TIME_ETC_SIMP) NIL NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL)
                         ("34" (EXPAND "sitc")
                          (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL)) NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL))
                  NIL))
                NIL)
               ("2" (HIDE 3)
                (("2" (REPLACE -1 *)
                  (("2" (INST + "s2!1" "pr" "trans(pr,s2!1)" "trans(pr,s2!1)")
                    (("2" (BDDSIMP)
                      (("1" (HIDE -2 -3 -9 -10 -11 -12)
                        (("1" (GRIND) NIL NIL)) NIL)
                       ("2" (HIDE -2 -3 -9 -10 -11 -12)
                        (("2" (GRIND) NIL NIL)) NIL)
                       ("3" (HIDE -2 -3 -9 -10 -11 -12)
                        (("3" (GRIND) NIL NIL)) NIL)
                       ("4" (HIDE -2 -3 -9 -10 -11 -12)
                        (("4" (GRIND) NIL NIL)) NIL)
                       ("5" (HIDE -2 -3 -9 -10 -11 -12)
                        (("5" (GRIND) NIL NIL)) NIL)
                       ("6" (HIDE -2 -3 -9 -10 -11 -12)
                        (("6" (GRIND) NIL NIL)) NIL)
                       ("7" (HIDE -2 -3 -9 -10 -11 -12)
                        (("7" (GRIND) NIL NIL)) NIL)
                       ("8" (HIDE -2 -3 -9 -10 -11 -12)
                        (("8" (GRIND) NIL NIL)) NIL)
                       ("9" (HIDE -2 -3 -9 -10 -11 -12)
                        (("9" (GRIND) NIL NIL)) NIL)
                       ("10" (HIDE -2 -3 -9 -10 -11 -12)
                        (("10" (GRIND) NIL NIL)) NIL)
                       ("11" (HIDE -2 -3 -9 -10 -11 -12)
                        (("11" (GRIND) NIL NIL)) NIL)
                       ("12" (HIDE -9 -10) (("12" (GRIND) NIL NIL)) NIL)
                       ("13" (HIDE -2 -3 -9 -10 -11 -12)
                        (("13" (GRIND) NIL NIL)) NIL)
                       ("14" (HIDE -2 -3 -9 -10 -11 -12)
                        (("14" (GRIND) NIL NIL)) NIL)
                       ("15" (HIDE -2 -3 -9 -10 -11 -12)
                        (("15" (GRIND) NIL NIL)) NIL)
                       ("16" (HIDE -2 -3 -9 -10 -11 -12)
                        (("16" (GRIND) NIL NIL)) NIL)
                       ("17" (HIDE -2 -3 -9 -10 -11 -12)
                        (("17" (GRIND) NIL NIL)) NIL)
                       ("18" (HIDE -2 -3 -9 -10 -11 -12)
                        (("18" (GRIND) NIL NIL)) NIL)
                       ("19" (HIDE -2 -3 -9 -10 -11 -12)
                        (("19" (GRIND) NIL NIL)) NIL)
                       ("20" (HIDE -2 -3 -9 -10 -11 -12)
                        (("20" (GRIND) NIL NIL)) NIL)
                       ("21" (HIDE -2 -3 -9 -10 -11 -12)
                        (("21" (GRIND) NIL NIL)) NIL)
                       ("22" (HIDE -2 -3 -9 -10 -11 -12)
                        (("22" (GRIND) NIL NIL)) NIL)
                       ("23" (HIDE -2 -3 -9 -10 -11 -12)
                        (("23" (GRIND) NIL NIL)) NIL)
                       ("24" (HIDE -9 -10) (("24" (GRIND) NIL NIL)) NIL)
                       ("25" (HIDE -9 -10) (("25" (GRIND) NIL NIL)) NIL)
                       ("26" (HIDE -2 -3 -9 -10 -11) (("26" (GRIND) NIL NIL))
                        NIL)
                       ("27" (HIDE -2 -3 -9 -10 -12) (("27" (GRIND) NIL NIL))
                        NIL)
                       ("28" (HIDE -2 -3 -9 -11 -12) (("28" (GRIND) NIL NIL))
                        NIL)
                       ("29" (HIDE -2 -3 -10 -11 -12) (("29" (GRIND) NIL NIL))
                        NIL)
                       ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                       ("31" (GRIND) NIL NIL)
                       ("32" (EXPAND "sitc")
                        (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL)) NIL))
                        NIL)
                       ("33" (GRIND) NIL NIL)
                       ("34" (EXPAND "sitc")
                        (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL)) NIL))
                        NIL)
                       ("35" (HIDE -2 -3 -9 -10 -11 -12)
                        (("35" (GRIND) NIL NIL)) NIL)
                       ("36" (HIDE -2 -3 -9 -10 -11 -12)
                        (("36" (GRIND) NIL NIL)) NIL)
                       ("37" (HIDE -2 -3 -9 -10 -11 -12)
                        (("37" (GRIND) NIL NIL)) NIL)
                       ("38" (HIDE -2 -3 -9 -10 -11 -12)
                        (("38" (GRIND) NIL NIL)) NIL)
                       ("39" (HIDE -2 -3 -9 -10 -11 -12)
                        (("39" (GRIND) NIL NIL)) NIL)
                       ("40" (HIDE -2 -3 -9 -10 -11 -12)
                        (("40" (GRIND) NIL NIL)) NIL)
                       ("41" (HIDE -2 -3 -9 -10 -11 -12)
                        (("41" (GRIND) NIL NIL)) NIL)
                       ("42" (HIDE -2 -3 -9 -10 -11 -12)
                        (("42" (GRIND) NIL NIL)) NIL)
                       ("43" (HIDE -2 -3 -9 -10 -11 -12)
                        (("43" (GRIND) NIL NIL)) NIL)
                       ("44" (HIDE -2 -3 -9 -10 -11 -12)
                        (("44" (GRIND) NIL NIL)) NIL)
                       ("45" (HIDE -2 -3 -9 -10 -11 -12)
                        (("45" (GRIND) NIL NIL)) NIL)
                       ("46" (HIDE -2 -3 -9 -10 -11 -12)
                        (("46" (GRIND) NIL NIL)) NIL)
                       ("47" (HIDE -2 -3 -9 -10 -11 -12)
                        (("47" (GRIND) NIL NIL)) NIL)
                       ("48" (HIDE -2 -3 -9 -10 -11 -12)
                        (("48" (GRIND) NIL NIL)) NIL)
                       ("49" (HIDE -2 -3 -9 -10 -11 -12)
                        (("49" (GRIND) NIL NIL)) NIL)
                       ("50" (HIDE -2 -3 -9 -10 -11 -12)
                        (("50" (GRIND) NIL NIL)) NIL)
                       ("51" (HIDE -2 -3 -9 -10 -11 -12)
                        (("51" (GRIND) NIL NIL)) NIL)
                       ("52" (HIDE -2 -3 -9 -10 -11 -12)
                        (("52" (GRIND) NIL NIL)) NIL)
                       ("53" (HIDE -2 -3 -9 -10 -11 -12)
                        (("53" (GRIND) NIL NIL)) NIL)
                       ("54" (HIDE -2 -3 -9 -10 -11 -12)
                        (("54" (GRIND) NIL NIL)) NIL)
                       ("55" (HIDE -2 -3 -9 -10 -11 -12)
                        (("55" (GRIND) NIL NIL)) NIL)
                       ("56" (HIDE -2 -3 -9 -10 -11 -12)
                        (("56" (GRIND) NIL NIL)) NIL)
                       ("57" (HIDE -2 -3 -9 -10 -11 -12)
                        (("57" (GRIND) NIL NIL)) NIL)
                       ("58" (HIDE -9 -10) (("58" (GRIND) NIL NIL)) NIL)
                       ("59" (HIDE -9 -10) (("59" (GRIND) NIL NIL)) NIL)
                       ("60" (HIDE -2 -3 -9 -10 -11) (("60" (GRIND) NIL NIL))
                        NIL)
                       ("61" (HIDE -2 -3 -9 -10 -12) (("61" (GRIND) NIL NIL))
                        NIL)
                       ("62" (HIDE -2 -3 -9 -11 -12) (("62" (GRIND) NIL NIL))
                        NIL)
                       ("63" (HIDE -2 -3 -10 -11 -12) (("63" (GRIND) NIL NIL))
                        NIL)
                       ("64" (HIDE -) (("64" (GRIND) NIL NIL)) NIL)
                       ("65" (GRIND) NIL NIL)
                       ("66" (EXPAND "sitc")
                        (("66" (EXPAND "tc") (("66" (PROPAX) NIL NIL)) NIL))
                        NIL)
                       ("67" (GRIND) NIL NIL)
                       ("68" (EXPAND "sitc")
                        (("68" (EXPAND "tc") (("68" (PROPAX) NIL NIL)) NIL))
                        NIL))
                      NIL))
                    NIL))
                  NIL))
                NIL)
               ("3" (HIDE 3)
                (("3" (REPLACE -1 *)
                  (("3" (INST + "s2!1" "ps" "trans(ps,s2!1)" "trans(ps,s2!1)")
                    (("3" (BDDSIMP)
                      (("1" (HIDE -2 -3 -9 -10 -11 -12)
                        (("1" (GRIND) NIL NIL)) NIL)
                       ("2" (HIDE -2 -3 -9 -10 -11 -12)
                        (("2" (GRIND) NIL NIL)) NIL)
                       ("3" (HIDE -2 -3 -9 -10 -11 -12)
                        (("3" (GRIND) NIL NIL)) NIL)
                       ("4" (HIDE -2 -3 -9 -10 -11 -12)
                        (("4" (GRIND) NIL NIL)) NIL)
                       ("5" (HIDE -2 -3 -9 -10 -11 -12)
                        (("5" (GRIND) NIL NIL)) NIL)
                       ("6" (HIDE -2 -3 -9 -10 -11 -12)
                        (("6" (GRIND) NIL NIL)) NIL)
                       ("7" (HIDE -2 -3 -9 -10 -11 -12)
                        (("7" (GRIND) NIL NIL)) NIL)
                       ("8" (HIDE -2 -3 -9 -10 -11 -12)
                        (("8" (GRIND) NIL NIL)) NIL)
                       ("9" (HIDE -2 -3 -9 -10 -11 -12)
                        (("9" (GRIND) NIL NIL)) NIL)
                       ("10" (HIDE -2 -3 -9 -10 -11 -12)
                        (("10" (GRIND) NIL NIL)) NIL)
                       ("11" (HIDE -2 -3 -9 -10 -11 -12)
                        (("11" (GRIND) NIL NIL)) NIL)
                       ("12" (HIDE -9 -10) (("12" (GRIND) NIL NIL)) NIL)
                       ("13" (HIDE -2 -3 -9 -10 -11 -12)
                        (("13" (GRIND) NIL NIL)) NIL)
                       ("14" (HIDE -2 -3 -9 -10 -11 -12)
                        (("14" (GRIND) NIL NIL)) NIL)
                       ("15" (HIDE -2 -3 -9 -10 -11 -12)
                        (("15" (GRIND) NIL NIL)) NIL)
                       ("16" (HIDE -2 -3 -9 -10 -11 -12)
                        (("16" (GRIND) NIL NIL)) NIL)
                       ("17" (HIDE -9 -10 -11) (("17" (GRIND) NIL NIL)) NIL)
                       ("18" (HIDE -2 -3 -9 -10 -11 -12)
                        (("18" (GRIND) NIL NIL)) NIL)
                       ("19" (HIDE -2 -3 -9 -10 -11 -12)
                        (("19" (GRIND) NIL NIL)) NIL)
                       ("20" (HIDE -2 -3 -9 -10 -11 -12)
                        (("20" (GRIND) NIL NIL)) NIL)
                       ("21" (HIDE -2 -3 -9 -10 -11 -12)
                        (("21" (GRIND) NIL NIL)) NIL)
                       ("22" (HIDE -2 -3 -9 -10 -11 -12)
                        (("22" (GRIND) NIL NIL)) NIL)
                       ("23" (HIDE -2 -3 -9 -10 -11 -12)
                        (("23" (GRIND) NIL NIL)) NIL)
                       ("24" (HIDE -9 -10) (("24" (GRIND) NIL NIL)) NIL)
                       ("25" (HIDE -9 -10) (("25" (GRIND) NIL NIL)) NIL)
                       ("26" (HIDE -2 -3 -9 -10 -11) (("26" (GRIND) NIL NIL))
                        NIL)
                       ("27" (HIDE -2 -3 -9 -10 -12) (("27" (GRIND) NIL NIL))
                        NIL)
                       ("28" (HIDE -2 -3 -9 -11 -12) (("28" (GRIND) NIL NIL))
                        NIL)
                       ("29" (HIDE -2 -3 -10 -11 -12) (("29" (GRIND) NIL NIL))
                        NIL)
                       ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                       ("31" (GRIND) NIL NIL)
                       ("32" (EXPAND "sitc")
                        (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL)) NIL))
                        NIL)
                       ("33" (GRIND) NIL NIL)
                       ("34" (EXPAND "sitc")
                        (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL)) NIL))
                        NIL)
                       ("35" (HIDE -2 -3 -9 -10 -11 -12)
                        (("35" (GRIND) NIL NIL)) NIL)
                       ("36" (HIDE -2 -3 -9 -10 -11 -12)
                        (("36" (GRIND) NIL NIL)) NIL)
                       ("37" (HIDE -2 -3 -9 -10 -11 -12)
                        (("37" (GRIND) NIL NIL)) NIL)
                       ("38" (HIDE -2 -3 -9 -10 -11 -12)
                        (("38" (GRIND) NIL NIL)) NIL)
                       ("39" (HIDE -2 -3 -9 -10 -11 -12)
                        (("39" (GRIND) NIL NIL)) NIL)
                       ("40" (HIDE -2 -3 -9 -10 -11 -12)
                        (("40" (GRIND) NIL NIL)) NIL)
                       ("41" (HIDE -2 -3 -9 -10 -11 -12)
                        (("41" (GRIND) NIL NIL)) NIL)
                       ("42" (HIDE -2 -3 -9 -10 -11 -12)
                        (("42" (GRIND) NIL NIL)) NIL)
                       ("43" (HIDE -2 -3 -9 -10 -11 -12)
                        (("43" (GRIND) NIL NIL)) NIL)
                       ("44" (HIDE -2 -3 -9 -10 -11 -12)
                        (("44" (GRIND) NIL NIL)) NIL)
                       ("45" (HIDE -2 -3 -9 -10 -11 -12)
                        (("45" (GRIND) NIL NIL)) NIL)
                       ("46" (HIDE -2 -3 -9 -10 -11 -12)
                        (("46" (GRIND) NIL NIL)) NIL)
                       ("47" (HIDE -2 -3 -9 -10 -11 -12)
                        (("47" (GRIND) NIL NIL)) NIL)
                       ("48" (HIDE -2 -3 -9 -10 -11 -12)
                        (("48" (GRIND) NIL NIL)) NIL)
                       ("49" (HIDE -2 -3 -9 -10 -11 -12)
                        (("49" (GRIND) NIL NIL)) NIL)
                       ("50" (HIDE -2 -3 -9 -10 -11 -12)
                        (("50" (GRIND) NIL NIL)) NIL)
                       ("51" (HIDE -2 -3 -9 -10 -11 -12)
                        (("51" (GRIND) NIL NIL)) NIL)
                       ("52" (HIDE -2 -3 -9 -10 -11 -12)
                        (("52" (GRIND) NIL NIL)) NIL)
                       ("53" (HIDE -2 -3 -9 -10 -11 -12)
                        (("53" (GRIND) NIL NIL)) NIL)
                       ("54" (HIDE -2 -3 -9 -10 -11 -12)
                        (("54" (GRIND) NIL NIL)) NIL)
                       ("55" (HIDE -2 -3 -9 -10 -11 -12)
                        (("55" (GRIND) NIL NIL)) NIL)
                       ("56" (HIDE -2 -3 -9 -10 -11 -12)
                        (("56" (GRIND) NIL NIL)) NIL)
                       ("57" (HIDE -2 -3 -9 -10 -11 -12)
                        (("57" (GRIND) NIL NIL)) NIL)
                       ("58" (HIDE -9 -10) (("58" (GRIND) NIL NIL)) NIL)
                       ("59" (HIDE -9 -10) (("59" (GRIND) NIL NIL)) NIL)
                       ("60" (HIDE -2 -3 -9 -10 -11) (("60" (GRIND) NIL NIL))
                        NIL)
                       ("61" (HIDE -2 -3 -9 -10 -12) (("61" (GRIND) NIL NIL))
                        NIL)
                       ("62" (HIDE -2 -3 -9 -11 -12) (("62" (GRIND) NIL NIL))
                        NIL)
                       ("63" (HIDE -2 -3 -10 -11 -12) (("63" (GRIND) NIL NIL))
                        NIL)
                       ("64" (HIDE -) (("64" (GRIND) NIL NIL)) NIL)
                       ("65" (GRIND) NIL NIL)
                       ("66" (EXPAND "sitc")
                        (("66" (EXPAND "tc") (("66" (PROPAX) NIL NIL)) NIL))
                        NIL)
                       ("67" (GRIND) NIL NIL)
                       ("68" (EXPAND "sitc")
                        (("68" (EXPAND "tc") (("68" (PROPAX) NIL NIL)) NIL))
                        NIL))
                      NIL))
                    NIL))
                  NIL))
                NIL)
               ("4" (REPLACE -1 *)
                (("4" (HIDE 3)
                  (("4" (INST + "s2!1" "wr" "trans(wr,s2!1)" "trans(wr,s2!1)")
                    (("4" (BDDSIMP)
                      (("1" (HIDE -2 -3 -9 -10 -11 -12)
                        (("1" (GRIND) NIL NIL)) NIL)
                       ("2" (HIDE -2 -3 -9 -10 -11 -12)
                        (("2" (GRIND) NIL NIL)) NIL)
                       ("3" (HIDE -2 -3 -9 -10 -11 -12)
                        (("3" (GRIND) NIL NIL)) NIL)
                       ("4" (HIDE -2 -3 -9 -10 -11 -12)
                        (("4" (GRIND) NIL NIL)) NIL)
                       ("5" (HIDE -2 -3 -9 -10 -11 -12)
                        (("5" (GRIND) NIL NIL)) NIL)
                       ("6" (HIDE -2 -3 -9 -10 -11 -12)
                        (("6" (GRIND) NIL NIL)) NIL)
                       ("7" (HIDE -2 -3 -9 -10 -11 -12)
                        (("7" (GRIND) NIL NIL)) NIL)
                       ("8" (HIDE -2 -3 -9 -10 -11 -12)
                        (("8" (GRIND) NIL NIL)) NIL)
                       ("9" (HIDE -2 -3 -9 -10 -11 -12)
                        (("9" (GRIND) NIL NIL)) NIL)
                       ("10" (HIDE -2 -3 -9 -10 -11 -12)
                        (("10" (GRIND) NIL NIL)) NIL)
                       ("11" (HIDE -2 -3 -9 -10 -11 -12)
                        (("11" (GRIND) NIL NIL)) NIL)
                       ("12" (HIDE -9 -10) (("12" (GRIND) NIL NIL)) NIL)
                       ("13" (HIDE -2 -3 -9 -10 -11 -12)
                        (("13" (GRIND) NIL NIL)) NIL)
                       ("14" (HIDE -2 -3 -9 -10 -11 -12)
                        (("14" (GRIND) NIL NIL)) NIL)
                       ("15" (HIDE -2 -3 -9 -10 -11 -12)
                        (("15" (GRIND) NIL NIL)) NIL)
                       ("16" (HIDE -2 -3 -9 -10 -11 -12)
                        (("16" (GRIND) NIL NIL)) NIL)
                       ("17" (HIDE -2 -3 -9 -10 -11 -12)
                        (("17" (GRIND) NIL NIL)) NIL)
                       ("18" (HIDE -2 -3 -9 -10 -11 -12)
                        (("18" (GRIND) NIL NIL)) NIL)
                       ("19" (HIDE -2 -3 -9 -10 -11 -12)
                        (("19" (GRIND) NIL NIL)) NIL)
                       ("20" (HIDE -2 -3 -9 -10 -11 -12)
                        (("20" (GRIND) NIL NIL)) NIL)
                       ("21" (HIDE -2 -3 -9 -10 -11 -12)
                        (("21" (GRIND) NIL NIL)) NIL)
                       ("22" (HIDE -2 -3 -9 -10 -11 -12)
                        (("22" (GRIND) NIL NIL)) NIL)
                       ("23" (HIDE -2 -3 -9 -10 -11 -12)
                        (("23" (GRIND) NIL NIL)) NIL)
                       ("24" (HIDE -9 -10) (("24" (GRIND) NIL NIL)) NIL)
                       ("25" (HIDE -9 -10) (("25" (GRIND) NIL NIL)) NIL)
                       ("26" (HIDE -2 -3 -9 -10 -11) (("26" (GRIND) NIL NIL))
                        NIL)
                       ("27" (HIDE -2 -3 -9 -10 -12) (("27" (GRIND) NIL NIL))
                        NIL)
                       ("28" (HIDE -2 -3 -9 -11 -12) (("28" (GRIND) NIL NIL))
                        NIL)
                       ("29" (HIDE -2 -3 -10 -11 -12) (("29" (GRIND) NIL NIL))
                        NIL)
                       ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                       ("31" (GRIND) NIL NIL)
                       ("32" (EXPAND "sitc")
                        (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL)) NIL))
                        NIL)
                       ("33" (GRIND) NIL NIL)
                       ("34" (EXPAND "sitc")
                        (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL)) NIL))
                        NIL)
                       ("35" (HIDE -2 -3 -9 -10 -11 -12)
                        (("35" (GRIND) NIL NIL)) NIL)
                       ("36" (HIDE -2 -3 -9 -10 -11 -12)
                        (("36" (GRIND) NIL NIL)) NIL)
                       ("37" (HIDE -2 -3 -9 -10 -11 -12)
                        (("37" (GRIND) NIL NIL)) NIL)
                       ("38" (HIDE -2 -3 -9 -10 -11 -12)
                        (("38" (GRIND) NIL NIL)) NIL)
                       ("39" (HIDE -2 -3 -9 -10 -11 -12)
                        (("39" (GRIND) NIL NIL)) NIL)
                       ("40" (HIDE -2 -3 -9 -10 -11 -12)
                        (("40" (GRIND) NIL NIL)) NIL)
                       ("41" (HIDE -2 -3 -9 -10 -11 -12)
                        (("41" (GRIND) NIL NIL)) NIL)
                       ("42" (HIDE -2 -3 -9 -10 -11 -12)
                        (("42" (GRIND) NIL NIL)) NIL)
                       ("43" (HIDE -2 -3 -9 -10 -11 -12)
                        (("43" (GRIND) NIL NIL)) NIL)
                       ("44" (HIDE -2 -3 -9 -10 -11 -12)
                        (("44" (GRIND) NIL NIL)) NIL)
                       ("45" (HIDE -2 -3 -9 -10 -11 -12)
                        (("45" (GRIND) NIL NIL)) NIL)
                       ("46" (HIDE -2 -3 -9 -10 -11 -12)
                        (("46" (GRIND) NIL NIL)) NIL)
                       ("47" (HIDE -2 -3 -9 -10 -11 -12)
                        (("47" (GRIND) NIL NIL)) NIL)
                       ("48" (HIDE -2 -3 -9 -10 -11 -12)
                        (("48" (GRIND) NIL NIL)) NIL)
                       ("49" (HIDE -2 -3 -9 -10 -11 -12)
                        (("49" (GRIND) NIL NIL)) NIL)
                       ("50" (HIDE -2 -3 -9 -10 -11 -12)
                        (("50" (GRIND) NIL NIL)) NIL)
                       ("51" (HIDE -2 -3 -9 -10 -11 -12)
                        (("51" (GRIND) NIL NIL)) NIL)
                       ("52" (HIDE -2 -3 -9 -10 -11 -12)
                        (("52" (GRIND) NIL NIL)) NIL)
                       ("53" (HIDE -2 -3 -9 -10 -11 -12)
                        (("53" (GRIND) NIL NIL)) NIL)
                       ("54" (HIDE -2 -3 -9 -10 -11 -12)
                        (("54" (GRIND) NIL NIL)) NIL)
                       ("55" (HIDE -2 -3 -9 -10 -11 -12)
                        (("55" (GRIND) NIL NIL)) NIL)
                       ("56" (HIDE -2 -3 -9 -10 -11 -12)
                        (("56" (GRIND) NIL NIL)) NIL)
                       ("57" (HIDE -2 -3 -9 -10 -11 -12)
                        (("57" (GRIND) NIL NIL)) NIL)
                       ("58" (HIDE -9 -10) (("58" (GRIND) NIL NIL)) NIL)
                       ("59" (HIDE -9 -10) (("59" (GRIND) NIL NIL)) NIL)
                       ("60" (HIDE -2 -3 -9 -10 -11) (("60" (GRIND) NIL NIL))
                        NIL)
                       ("61" (HIDE -2 -3 -9 -10 -12) (("61" (GRIND) NIL NIL))
                        NIL)
                       ("62" (HIDE -2 -3 -9 -11 -12) (("62" (GRIND) NIL NIL))
                        NIL)
                       ("63" (HIDE -2 -3 -10 -11 -12) (("63" (GRIND) NIL NIL))
                        NIL)
                       ("64" (HIDE -) (("64" (GRIND) NIL NIL)) NIL)
                       ("65" (GRIND) NIL NIL)
                       ("66" (EXPAND "sitc")
                        (("66" (EXPAND "tc") (("66" (PROPAX) NIL NIL)) NIL))
                        NIL)
                       ("67" (GRIND) NIL NIL)
                       ("68" (EXPAND "sitc")
                        (("68" (EXPAND "tc") (("68" (PROPAX) NIL NIL)) NIL))
                        NIL))
                      NIL))
                    NIL))
                  NIL))
                NIL)
               ("5" (REPLACE -1 *)
                (("5" (HIDE 3)
                  (("5" (INST + "s2!1" "ws" "trans(ws,s2!1)" "trans(ws,s2!1)")
                    (("5" (BDDSIMP)
                      (("1" (HIDE -2 -3 -9 -10 -11 -12)
                        (("1" (GRIND) NIL NIL)) NIL)
                       ("2" (HIDE -2 -3 -9 -10 -11 -12)
                        (("2" (GRIND) NIL NIL)) NIL)
                       ("3" (HIDE -2 -3 -9 -10 -11 -12)
                        (("3" (GRIND) NIL NIL)) NIL)
                       ("4" (HIDE -2 -3 -9 -10 -11 -12)
                        (("4" (GRIND) NIL NIL)) NIL)
                       ("5" (HIDE -2 -3 -9 -10 -11 -12)
                        (("5" (GRIND) NIL NIL)) NIL)
                       ("6" (HIDE -2 -3 -9 -10 -11 -12)
                        (("6" (GRIND) NIL NIL)) NIL)
                       ("7" (HIDE -2 -3 -9 -10 -11 -12)
                        (("7" (GRIND) NIL NIL)) NIL)
                       ("8" (HIDE -2 -3 -9 -10 -11 -12)
                        (("8" (GRIND) NIL NIL)) NIL)
                       ("9" (HIDE -2 -3 -9 -10 -11 -12)
                        (("9" (GRIND) NIL NIL)) NIL)
                       ("10" (HIDE -2 -3 -9 -10 -11 -12)
                        (("10" (GRIND) NIL NIL)) NIL)
                       ("11" (HIDE -2 -3 -9 -10 -11 -12)
                        (("11" (GRIND) NIL NIL)) NIL)
                       ("12" (HIDE -9 -10) (("12" (GRIND) NIL NIL)) NIL)
                       ("13" (HIDE -2 -3 -9 -10 -11 -12)
                        (("13" (GRIND) NIL NIL)) NIL)
                       ("14" (HIDE -2 -3 -9 -10 -11 -12)
                        (("14" (GRIND) NIL NIL)) NIL)
                       ("15" (HIDE -2 -3 -9 -10 -11 -12)
                        (("15" (GRIND) NIL NIL)) NIL)
                       ("16" (HIDE -2 -3 -9 -10 -11 -12)
                        (("16" (GRIND) NIL NIL)) NIL)
                       ("17" (HIDE -2 -3 -9 -10 -11 -12)
                        (("17" (GRIND) NIL NIL)) NIL)
                       ("18" (HIDE -2 -3 -9 -10 -11 -12)
                        (("18" (GRIND) NIL NIL)) NIL)
                       ("19" (HIDE -2 -3 -9 -10 -11 -12)
                        (("19" (GRIND) NIL NIL)) NIL)
                       ("20" (HIDE -2 -3 -9 -10 -11 -12)
                        (("20" (GRIND) NIL NIL)) NIL)
                       ("21" (HIDE -2 -3 -9 -10 -11 -12)
                        (("21" (GRIND) NIL NIL)) NIL)
                       ("22" (HIDE -2 -3 -9 -10 -11 -12)
                        (("22" (GRIND) NIL NIL)) NIL)
                       ("23" (HIDE -2 -3 -9 -10 -11 -12)
                        (("23" (GRIND) NIL NIL)) NIL)
                       ("24" (HIDE -2 -3 -9 -10 -11 -12)
                        (("24" (GRIND) NIL NIL)) NIL)
                       ("25" (HIDE -9 -10) (("25" (GRIND) NIL NIL)) NIL)
                       ("26" (HIDE -2 -3 -9 -10 -11) (("26" (GRIND) NIL NIL))
                        NIL)
                       ("27" (HIDE -2 -3 -9 -10 -12) (("27" (GRIND) NIL NIL))
                        NIL)
                       ("28" (HIDE -2 -3 -9 -11 -12) (("28" (GRIND) NIL NIL))
                        NIL)
                       ("29" (HIDE -2 -3 -10 -11 -12) (("29" (GRIND) NIL NIL))
                        NIL)
                       ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                       ("31" (GRIND) NIL NIL)
                       ("32" (EXPAND "sitc")
                        (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL)) NIL))
                        NIL)
                       ("33" (GRIND) NIL NIL)
                       ("34" (EXPAND "sitc")
                        (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL)) NIL))
                        NIL)
                       ("35" (HIDE -2 -3 -9 -10 -11 -12)
                        (("35" (GRIND) NIL NIL)) NIL)
                       ("36" (HIDE -2 -3 -9 -10 -11 -12)
                        (("36" (GRIND) NIL NIL)) NIL)
                       ("37" (HIDE -2 -3 -9 -10 -11 -12)
                        (("37" (GRIND) NIL NIL)) NIL)
                       ("38" (HIDE -2 -3 -9 -10 -11 -12)
                        (("38" (GRIND) NIL NIL)) NIL)
                       ("39" (HIDE -2 -3 -9 -10 -11 -12)
                        (("39" (GRIND) NIL NIL)) NIL)
                       ("40" (HIDE -2 -3 -9 -10 -11 -12)
                        (("40" (GRIND) NIL NIL)) NIL)
                       ("41" (HIDE -2 -3 -9 -10 -11 -12)
                        (("41" (GRIND) NIL NIL)) NIL)
                       ("42" (HIDE -2 -3 -9 -10 -11 -12)
                        (("42" (GRIND) NIL NIL)) NIL)
                       ("43" (HIDE -2 -3 -9 -10 -11 -12)
                        (("43" (GRIND) NIL NIL)) NIL)
                       ("44" (HIDE -2 -3 -9 -10 -11 -12)
                        (("44" (GRIND) NIL NIL)) NIL)
                       ("45" (HIDE -2 -3 -9 -10 -11 -12)
                        (("45" (GRIND) NIL NIL)) NIL)
                       ("46" (HIDE -2 -3 -9 -10 -11 -12)
                        (("46" (GRIND) NIL NIL)) NIL)
                       ("47" (HIDE -2 -3 -9 -10 -11 -12)
                        (("47" (GRIND) NIL NIL)) NIL)
                       ("48" (HIDE -2 -3 -9 -10 -11 -12)
                        (("48" (GRIND) NIL NIL)) NIL)
                       ("49" (HIDE -2 -3 -9 -10 -11 -12)
                        (("49" (GRIND) NIL NIL)) NIL)
                       ("50" (HIDE -2 -3 -9 -10 -11 -12)
                        (("50" (GRIND) NIL NIL)) NIL)
                       ("51" (HIDE -2 -3 -9 -10 -11 -12)
                        (("51" (GRIND) NIL NIL)) NIL)
                       ("52" (HIDE -2 -3 -9 -10 -11 -12)
                        (("52" (GRIND) NIL NIL)) NIL)
                       ("53" (HIDE -2 -3 -9 -10 -11 -12)
                        (("53" (GRIND) NIL NIL)) NIL)
                       ("54" (HIDE -2 -3 -9 -10 -11 -12)
                        (("54" (GRIND) NIL NIL)) NIL)
                       ("55" (HIDE -2 -3 -9 -10 -11 -12)
                        (("55" (GRIND) NIL NIL)) NIL)
                       ("56" (HIDE -2 -3 -9 -10 -11 -12)
                        (("56" (GRIND) NIL NIL)) NIL)
                       ("57" (HIDE -2 -3 -9 -10 -11 -12)
                        (("57" (GRIND) NIL NIL)) NIL)
                       ("58" (HIDE -2 -3 -9 -10 -11 -12)
                        (("58" (GRIND) NIL NIL)) NIL)
                       ("59" (HIDE -9 -10) (("59" (GRIND) NIL NIL)) NIL)
                       ("60" (HIDE -2 -3 -9 -10 -11) (("60" (GRIND) NIL NIL))
                        NIL)
                       ("61" (HIDE -2 -3 -9 -10 -12) (("61" (GRIND) NIL NIL))
                        NIL)
                       ("62" (HIDE -2 -3 -9 -11 -12) (("62" (GRIND) NIL NIL))
                        NIL)
                       ("63" (HIDE -2 -3 -10 -11 -12) (("63" (GRIND) NIL NIL))
                        NIL)
                       ("64" (HIDE -) (("64" (GRIND) NIL NIL)) NIL)
                       ("65" (GRIND) NIL NIL)
                       ("66" (EXPAND "sitc")
                        (("66" (EXPAND "tc") (("66" (PROPAX) NIL NIL)) NIL))
                        NIL)
                       ("67" (GRIND) NIL NIL)
                       ("68" (EXPAND "sitc")
                        (("68" (EXPAND "tc") (("68" (PROPAX) NIL NIL)) NIL))
                        NIL))
                      NIL))
                    NIL))
                  NIL))
                NIL))
              NIL))
            NIL))
          NIL)
         ("2" (HIDE 2)
          (("2" (FLATTEN)
            (("2" (CASE "a1!1=tick")
              (("1" (REPLACE -1 *)
                (("1" (SPLIT)
                  (("1"
                    (INST + "trans(mu2,s2!1)" "tick"
                     "trans(tick,trans(mu2,s2!1))"
                     "trans(tick,trans(mu2,s2!1))")
                    (("1" (BDDSIMP)
                      (("1" (HIDE -9 -10 -11 -12) (("1" (GRIND) NIL NIL)) NIL)
                       ("2" (HIDE -9 -10 -11 -12) (("2" (GRIND) NIL NIL)) NIL)
                       ("3" (HIDE -9 -10 -11 -12) (("3" (GRIND) NIL NIL)) NIL)
                       ("4" (HIDE -9 -10 -11 -12) (("4" (GRIND) NIL NIL)) NIL)
                       ("5" (HIDE -9 -10 -11 -12) (("5" (GRIND) NIL NIL)) NIL)
                       ("6" (HIDE -9 -10 -11 -12) (("6" (GRIND) NIL NIL)) NIL)
                       ("7" (HIDE -9 -10 -11 -12) (("7" (GRIND) NIL NIL)) NIL)
                       ("8" (HIDE -9 -10 -11 -12) (("8" (GRIND) NIL NIL)) NIL)
                       ("9" (HIDE -9 -10 -11 -12) (("9" (GRIND) NIL NIL)) NIL)
                       ("10" (HIDE -9 -10 -11 -12) (("10" (GRIND) NIL NIL))
                        NIL)
                       ("11" (HIDE -9 -10 -11 -12) (("11" (GRIND) NIL NIL))
                        NIL)
                       ("12" (HIDE -9 -10) (("12" (GRIND) NIL NIL)) NIL)
                       ("13" (HIDE -9 -10 -11 -12) (("13" (GRIND) NIL NIL))
                        NIL)
                       ("14" (HIDE -9 -10 -11 -12) (("14" (GRIND) NIL NIL))
                        NIL)
                       ("15" (HIDE -9 -10 -11 -12) (("15" (GRIND) NIL NIL))
                        NIL)
                       ("16" (HIDE -9 -10 -11 -12) (("16" (GRIND) NIL NIL))
                        NIL)
                       ("17" (HIDE -9 -10 -11 -12) (("17" (GRIND) NIL NIL))
                        NIL)
                       ("18" (HIDE -9 -10 -11 -12) (("18" (GRIND) NIL NIL))
                        NIL)
                       ("19" (HIDE -9 -10 -11 -12) (("19" (GRIND) NIL NIL))
                        NIL)
                       ("20" (HIDE -9 -10 -11 -12) (("20" (GRIND) NIL NIL))
                        NIL)
                       ("21" (HIDE -9 -10 -11 -12) (("21" (GRIND) NIL NIL))
                        NIL)
                       ("22" (HIDE -9 -10 -11 -12) (("22" (GRIND) NIL NIL))
                        NIL)
                       ("23" (HIDE -9 -10 -11 -12) (("23" (GRIND) NIL NIL))
                        NIL)
                       ("24" (HIDE -9 -10) (("24" (GRIND) NIL NIL)) NIL)
                       ("25" (HIDE -9 -10) (("25" (GRIND) NIL NIL)) NIL)
                       ("26" (HIDE -9 -10 -11) (("26" (GRIND) NIL NIL)) NIL)
                       ("27" (HIDE -9 -10) (("27" (GRIND) NIL NIL)) NIL)
                       ("28" (HIDE -5 -9 -11 -12) (("28" (GRIND) NIL NIL))
                        NIL)
                       ("29" (HIDE -5 -10 -11 -12) (("29" (GRIND) NIL NIL))
                        NIL)
                       ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                       ("31" (GRIND) NIL NIL)
                       ("32" (EXPAND "sitc")
                        (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL)) NIL))
                        NIL)
                       ("33" (EXPAND "dd2")
                        (("33" (EXPAND "enabled")
                          (("33" (EXPAND "enabled_tick")
                            (("33" (SKOLEM-TYPEPRED)
                              (("33" (FLATTEN)
                                (("33" (CASE "q!1=alpha")
                                  (("1" (REPLACE -1 *)
                                    (("1" (INST - "alpha")
                                      (("1" (GRIND) NIL NIL)) NIL))
                                    NIL)
                                   ("2" (CASE "q!1=rho1")
                                    (("1" (REPLACE -1 *)
                                      (("1"
                                        (INST - "rho1")
                                        (("1" (GRIND) NIL NIL))
                                        NIL))
                                      NIL)
                                     ("2" (CASE "q!1=gamma")
                                      (("1"
                                        (REPLACE -1 *)
                                        (("1"
                                          (INST - "gamma")
                                          (("1" (GRIND) NIL NIL))
                                          NIL))
                                        NIL)
                                       ("2"
                                        (CASE "q!1=rho2")
                                        (("1"
                                          (REPLACE -1 *)
                                          (("1"
                                            (INST - "rho2")
                                            (("1" (GRIND) NIL NIL))
                                            NIL))
                                          NIL)
                                         ("2"
                                          (CASE "q!1=pr")
                                          (("1"
                                            (REPLACE -1 *)
                                            (("1"
                                              (INST - "pr")
                                              (("1" (GRIND) NIL NIL))
                                              NIL))
                                            NIL)
                                           ("2"
                                            (CASE "q!1=ps")
                                            (("1"
                                              (REPLACE -1 *)
                                              (("1"
                                                (INST - "ps")
                                                (("1" (GRIND) NIL NIL))
                                                NIL))
                                              NIL)
                                             ("2"
                                              (CASE "q!1=wr")
                                              (("1"
                                                (REPLACE -1 *)
                                                (("1"
                                                  (INST - "wr")
                                                  (("1" (GRIND) NIL NIL))
                                                  NIL))
                                                NIL)
                                               ("2"
                                                (CASE "q!1=ws")
                                                (("1"
                                                  (INST - "ws")
                                                  (("1" (GRIND) NIL NIL))
                                                  NIL)
                                                 ("2"
                                                  (CASE "q!1=mu1")
                                                  (("1"
                                                    (REPLACE -1 *)
                                                    (("1"
                                                      (INST - "mu")
                                                      (("1" (GRIND) NIL NIL))
                                                      NIL))
                                                    NIL)
                                                   ("2"
                                                    (CASE "q!1=mu2")
                                                    (("1"
                                                      (REPLACE -1 *)
                                                      (("1"
                                                        (INST - "omega19")
                                                        (("1"
                                                          (GRIND)
                                                          NIL
                                                          NIL))
                                                        NIL))
                                                      NIL)
                                                     ("2" (GRIND) NIL NIL))
                                                    NIL))
                                                  NIL))
                                                NIL))
                                              NIL))
                                            NIL))
                                          NIL))
                                        NIL))
                                      NIL))
                                    NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("34" (EXPAND "sitc")
                        (("34" (EXPAND "tc")
                          (("34" (FLATTEN)
                            (("34" (HIDE 1)
                              (("34" (EXPAND "r2")
                                (("34" (HIDE 2)
                                  (("34" (SPLIT)
                                    (("1" (INST + "mu2")
                                      (("1" (GRIND) NIL NIL)) NIL)
                                     ("2" (GRIND) NIL NIL))
                                    NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL)
                   ("2" (FLATTEN)
                    (("2"
                      (INST + "s2!1 WITH [(action_time)(mu2) := zero]" "tick"
                       "trans(tick,s2!1 WITH [(action_time)(mu2) := zero])"
                       "trans(tick,s2!1 WITH [(action_time)(mu2) := zero])")
                      (("2" (BDDSIMP)
                        (("1" (HIDE -5 -9 -10 -11 -12) (("1" (GRIND) NIL NIL))
                          NIL)
                         ("2" (HIDE -5 -9 -10 -11 -12) (("2" (GRIND) NIL NIL))
                          NIL)
                         ("3" (HIDE -5 -9 -10 -11 -12) (("3" (GRIND) NIL NIL))
                          NIL)
                         ("4" (HIDE -5 -9 -10 -11 -12) (("4" (GRIND) NIL NIL))
                          NIL)
                         ("5" (HIDE -5 -9 -10 -11 -12) (("5" (GRIND) NIL NIL))
                          NIL)
                         ("6" (HIDE -5 -9 -10 -11 -12) (("6" (GRIND) NIL NIL))
                          NIL)
                         ("7" (HIDE -5 -9 -10 -11 -12) (("7" (GRIND) NIL NIL))
                          NIL)
                         ("8" (HIDE -5 -9 -10 -11 -12) (("8" (GRIND) NIL NIL))
                          NIL)
                         ("9" (HIDE -5 -9 -10 -11 -12) (("9" (GRIND) NIL NIL))
                          NIL)
                         ("10" (HIDE -5 -9 -10 -11 -12)
                          (("10" (GRIND) NIL NIL)) NIL)
                         ("11" (HIDE -5 -9 -10 -11 -12)
                          (("11" (GRIND) NIL NIL)) NIL)
                         ("12" (HIDE -9 -10) (("12" (GRIND) NIL NIL)) NIL)
                         ("13" (HIDE -5 -9 -10 -11 -12)
                          (("13" (GRIND) NIL NIL)) NIL)
                         ("14" (HIDE -5 -9 -10 -11 -12)
                          (("14" (GRIND) NIL NIL)) NIL)
                         ("15" (HIDE -5 -9 -10 -11 -12)
                          (("15" (GRIND) NIL NIL)) NIL)
                         ("16" (HIDE -5 -9 -10 -11 -12)
                          (("16" (GRIND) NIL NIL)) NIL)
                         ("17" (HIDE -5 -9 -10 -11 -12)
                          (("17" (GRIND) NIL NIL)) NIL)
                         ("18" (HIDE -5 -9 -10 -11 -12)
                          (("18" (GRIND) NIL NIL)) NIL)
                         ("19" (HIDE -5 -9 -10 -11 -12)
                          (("19" (GRIND) NIL NIL)) NIL)
                         ("20" (HIDE -5 -9 -10 -11 -12)
                          (("20" (GRIND) NIL NIL)) NIL)
                         ("21" (HIDE -5 -9 -10 -11 -12)
                          (("21" (GRIND) NIL NIL)) NIL)
                         ("22" (HIDE -5 -9 -10 -11 -12)
                          (("22" (GRIND) NIL NIL)) NIL)
                         ("23" (HIDE -5 -9 -10 -11 -12)
                          (("23" (GRIND) NIL NIL)) NIL)
                         ("24" (HIDE -9 -10) (("24" (GRIND) NIL NIL)) NIL)
                         ("25" (HIDE -9 -10) (("25" (GRIND) NIL NIL)) NIL)
                         ("26" (HIDE -9 -10 -11) (("26" (GRIND) NIL NIL)) NIL)
                         ("27" (HIDE -9 -10 -12) (("27" (GRIND) NIL NIL)) NIL)
                         ("28" (HIDE -9 -11 -12) (("28" (GRIND) NIL NIL)) NIL)
                         ("29" (HIDE -10 -11 -12) (("29" (GRIND) NIL NIL))
                          NIL)
                         ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                         ("31" (GRIND) NIL NIL)
                         ("32" (EXPAND "sitc")
                          (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL)) NIL))
                          NIL)
                         ("33" (EXPAND "dd2")
                          (("33" (EXPAND "enabled")
                            (("33" (EXPAND "enabled_tick")
                              (("33" (SKOLEM-TYPEPRED)
                                (("33" (FLATTEN)
                                  (("33" (CASE "q!1=alpha")
                                    (("1" (REPLACE -1 *)
                                      (("1"
                                        (INST - "alpha")
                                        (("1" (GRIND) NIL NIL))
                                        NIL))
                                      NIL)
                                     ("2" (CASE "q!1=rho1")
                                      (("1"
                                        (REPLACE -1 *)
                                        (("1"
                                          (INST - "rho1")
                                          (("1" (GRIND) NIL NIL))
                                          NIL))
                                        NIL)
                                       ("2"
                                        (CASE "q!1=gamma")
                                        (("1"
                                          (REPLACE -1 *)
                                          (("1"
                                            (INST - "gamma")
                                            (("1" (GRIND) NIL NIL))
                                            NIL))
                                          NIL)
                                         ("2"
                                          (CASE "q!1=rho2")
                                          (("1"
                                            (REPLACE -1 *)
                                            (("1"
                                              (INST - "rho2")
                                              (("1" (GRIND) NIL NIL))
                                              NIL))
                                            NIL)
                                           ("2"
                                            (CASE "q!1=pr")
                                            (("1"
                                              (REPLACE -1 *)
                                              (("1"
                                                (INST - "pr")
                                                (("1" (GRIND) NIL NIL))
                                                NIL))
                                              NIL)
                                             ("2"
                                              (CASE "q!1=ps")
                                              (("1"
                                                (REPLACE -1 *)
                                                (("1"
                                                  (INST - "ps")
                                                  (("1" (GRIND) NIL NIL))
                                                  NIL))
                                                NIL)
                                               ("2"
                                                (CASE "q!1=wr")
                                                (("1"
                                                  (REPLACE -1 *)
                                                  (("1"
                                                    (INST - "wr")
                                                    (("1" (GRIND) NIL NIL))
                                                    NIL))
                                                  NIL)
                                                 ("2"
                                                  (CASE "q!1=ws")
                                                  (("1"
                                                    (REPLACE -1 *)
                                                    (("1"
                                                      (INST - "ws")
                                                      (("1" (GRIND) NIL NIL))
                                                      NIL))
                                                    NIL)
                                                   ("2"
                                                    (CASE "q!1=mu1")
                                                    (("1"
                                                      (REPLACE -1 *)
                                                      (("1"
                                                        (INST - "mu")
                                                        (("1"
                                                          (GRIND)
                                                          NIL
                                                          NIL))
                                                        NIL))
                                                      NIL)
                                                     ("2"
                                                      (CASE "q!1=mu2")
                                                      (("1"
                                                        (REPLACE -1 *)
                                                        (("1"
                                                          (INST - "omega19")
                                                          (("1"
                                                            (GRIND)
                                                            NIL
                                                            NIL))
                                                          NIL))
                                                        NIL)
                                                       ("2" (GRIND) NIL NIL))
                                                      NIL))
                                                    NIL))
                                                  NIL))
                                                NIL))
                                              NIL))
                                            NIL))
                                          NIL))
                                        NIL))
                                      NIL))
                                    NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL)
                         ("34" (EXPAND "sitc")
                          (("34" (EXPAND "tc")
                            (("34" (FLATTEN)
                              (("34" (HIDE 3)
                                (("34" (APPLY-EXTENSIONALITY)
                                  (("34" (APPLY-EXTENSIONALITY)
                                    (("34" (HIDE 2 3 4)
                                      (("34"
                                        (CASE "x!1=alpha")
                                        (("1"
                                          (REPLACE -1 *)
                                          (("1" (ASSERT) NIL NIL))
                                          NIL)
                                         ("2"
                                          (CASE "x!1=rho1")
                                          (("1"
                                            (REPLACE -1 *)
                                            (("1" (ASSERT) NIL NIL))
                                            NIL)
                                           ("2"
                                            (CASE "x!1=gamma")
                                            (("1"
                                              (REPLACE -1 *)
                                              (("1" (ASSERT) NIL NIL))
                                              NIL)
                                             ("2"
                                              (CASE "x!1=rho2")
                                              (("1"
                                                (REPLACE -1 *)
                                                (("1" (ASSERT) NIL NIL))
                                                NIL)
                                               ("2"
                                                (CASE "x!1=pr")
                                                (("1"
                                                  (REPLACE -1 *)
                                                  (("1" (ASSERT) NIL NIL))
                                                  NIL)
                                                 ("2"
                                                  (CASE "x!1=ps")
                                                  (("1"
                                                    (REPLACE -1 *)
                                                    (("1" (ASSERT) NIL NIL))
                                                    NIL)
                                                   ("2"
                                                    (CASE "x!1=pr")
                                                    (("1" (PROPAX) NIL NIL)
                                                     ("2"
                                                      (CASE "x!1=wr")
                                                      (("1"
                                                        (REPLACE -1 *)
                                                        (("1"
                                                          (ASSERT)
                                                          NIL
                                                          NIL))
                                                        NIL)
                                                       ("2"
                                                        (CASE "x!1=ws")
                                                        (("1"
                                                          (REPLACE -1 *)
                                                          (("1"
                                                            (ASSERT)
                                                            NIL
                                                            NIL))
                                                          NIL)
                                                         ("2"
                                                          (CASE "x!1=mu1")
                                                          (("1"
                                                            (REPLACE -1 *)
                                                            (("1"
                                                              (ASSERT)
                                                              NIL
                                                              NIL))
                                                            NIL)
                                                           ("2"
                                                            (CASE "x!1=mu2")
                                                            (("1"
                                                              (REPLACE -1 *)
                                                              (("1"
                                                                (ASSERT)
                                                                NIL
                                                                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)
               ("2" (ASSERT) NIL NIL))
              NIL))
            NIL))
          NIL))
        NIL))
      NIL))
    NIL))
  NIL)
 (|sim21_2121_TCC1| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC2| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC3| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC4| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC5| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC6| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC7| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC8| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC9| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC10| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC11| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC12| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC13| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC14| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC15| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC16| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC17| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC18| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC19| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC20| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC21| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC22| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC23| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC24| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC25| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC26| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC27| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC28| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC29| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC30| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121_TCC31| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_2121| "" (SKOLEM-TYPEPRED)
  (("" (FLATTEN)
    (("" (HIDE 3)
      (("" (REPLACE -1 *)
        (("" (CASE "s2!1`basic`c1=29 and s2!1`action_time(mu1)=one")
          (("1" (FLATTEN)
            (("1"
              (INST + "s1!1" "omega29" "trans(omega29,s1!1)"
               "trans(omega29,s1!1)")
              (("1" (BDDSIMP)
                (("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)
                 ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                 ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                 ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                 ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                 ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                 ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                 ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                 ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                 ("27" (GRIND) NIL NIL) ("28" (GRIND) NIL NIL)
                 ("29" (GRIND) NIL NIL) ("30" (GRIND) NIL NIL)
                 ("31" (GRIND) NIL NIL) ("32" (GRIND) NIL NIL)
                 ("33" (GRIND)
                  (("1" (EXPAND "tc") (("1" (PROPAX) NIL NIL)) NIL)
                   ("2" (EXPAND "tc") (("2" (PROPAX) NIL NIL)) NIL)
                   ("3" (EXPAND "tc") (("3" (PROPAX) NIL NIL)) NIL)
                   ("4" (EXPAND "tc") (("4" (PROPAX) NIL NIL)) NIL)
                   ("5" (EXPAND "tc") (("5" (PROPAX) NIL NIL)) NIL)
                   ("6" (EXPAND "tc") (("6" (PROPAX) NIL NIL)) NIL)
                   ("7" (EXPAND "tc") (("7" (PROPAX) NIL NIL)) NIL)
                   ("8" (EXPAND "tc") (("8" (PROPAX) NIL NIL)) NIL))
                  NIL)
                 ("34" (GRIND) NIL NIL)
                 ("35" (GRIND)
                  (("1" (EXPAND "tc") (("1" (PROPAX) NIL NIL)) NIL)
                   ("2" (EXPAND "tc") (("2" (PROPAX) NIL NIL)) NIL)
                   ("3" (EXPAND "tc") (("3" (PROPAX) NIL NIL)) NIL)
                   ("4" (EXPAND "tc") (("4" (PROPAX) NIL NIL)) NIL)
                   ("5" (EXPAND "tc") (("5" (PROPAX) NIL NIL)) NIL)
                   ("6" (EXPAND "tc") (("6" (PROPAX) NIL NIL)) NIL)
                   ("7" (EXPAND "tc") (("7" (PROPAX) NIL NIL)) NIL)
                   ("8" (EXPAND "tc") (("8" (PROPAX) NIL NIL)) NIL))
                  NIL)
                 ("36" (GRIND) NIL NIL) ("37" (GRIND) NIL NIL)
                 ("38" (GRIND) NIL NIL) ("39" (GRIND) NIL NIL)
                 ("40" (GRIND) NIL NIL) ("41" (GRIND) NIL NIL)
                 ("42" (GRIND) NIL NIL) ("43" (GRIND) NIL NIL)
                 ("44" (GRIND) NIL NIL) ("45" (GRIND) NIL NIL)
                 ("46" (GRIND) NIL NIL) ("47" (GRIND) NIL NIL)
                 ("48" (GRIND) NIL NIL) ("49" (GRIND) NIL NIL)
                 ("50" (GRIND) NIL NIL) ("51" (GRIND) NIL NIL)
                 ("52" (GRIND) NIL NIL) ("53" (GRIND) NIL NIL)
                 ("54" (GRIND) NIL NIL) ("55" (GRIND) NIL NIL)
                 ("56" (GRIND) NIL NIL) ("57" (GRIND) NIL NIL)
                 ("58" (GRIND) NIL NIL) ("59" (GRIND) NIL NIL)
                 ("60" (GRIND) NIL NIL) ("61" (GRIND) NIL NIL)
                 ("62" (GRIND) NIL NIL) ("63" (GRIND) NIL NIL)
                 ("64" (GRIND) NIL NIL) ("65" (GRIND) NIL NIL)
                 ("66" (GRIND) NIL NIL) ("67" (GRIND) NIL NIL)
                 ("68" (EXPAND "sitc")
                  (("68" (EXPAND "tc") (("68" (PROPAX) NIL NIL)) NIL)) NIL)
                 ("69" (GRIND) NIL NIL)
                 ("70" (EXPAND "sitc")
                  (("70" (EXPAND "tc") (("70" (PROPAX) NIL NIL)) NIL)) NIL))
                NIL))
              NIL))
            NIL)
           ("2" (SPLIT -7)
            (("1" (FLATTEN)
              (("1" (HIDE 3)
                (("1" (REVEAL 2)
                  (("1" (INST + "s1!1")
                    (("1" (REPLACE -3 *)
                      (("1" (BDDSIMP)
                        (("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" (EXPAND "ps2")
                          (("9" (EXPAND "ps1") (("9" (GRIND) NIL NIL)) NIL))
                          NIL)
                         ("10" (GRIND) NIL NIL) ("11" (GRIND) NIL NIL)
                         ("12" (GRIND) NIL NIL) ("13" (GRIND) NIL NIL)
                         ("14" (GRIND) NIL NIL) ("15" (GRIND) NIL NIL)
                         ("16" (GRIND) NIL NIL) ("17" (GRIND) NIL NIL)
                         ("18" (EXPAND "sitc")
                          (("18" (EXPAND "tc") (("18" (PROPAX) NIL NIL)) NIL))
                          NIL)
                         ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL))
                        NIL))
                      NIL))
                    NIL))
                  NIL))
                NIL))
              NIL)
             ("2" (FLATTEN)
              (("2" (HIDE 3)
                (("2" (REVEAL 2)
                  (("2" (INST + "s1!1")
                    (("2" (BDDSIMP)
                      (("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)
                       ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                       ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                       ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                       ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                       ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                       ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                       ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                       ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                       ("27" (GRIND) NIL NIL) ("28" (GRIND) NIL NIL)
                       ("29" (GRIND) NIL NIL) ("30" (GRIND) NIL NIL)
                       ("31" (GRIND) NIL NIL) ("32" (GRIND) NIL NIL)
                       ("33" (GRIND) NIL NIL) ("34" (GRIND) NIL NIL)
                       ("35" (EXPAND "sitc")
                        (("35" (EXPAND "tc") (("35" (PROPAX) NIL NIL)) NIL))
                        NIL)
                       ("36" (EXPAND "sitc")
                        (("36" (EXPAND "tc") (("36" (PROPAX) NIL NIL)) NIL))
                        NIL)
                       ("37" (GRIND) NIL NIL)
                       ("38" (EXPAND "pa2") (("38" (GRIND) NIL NIL)) NIL)
                       ("39" (GRIND) NIL NIL) ("40" (GRIND) NIL NIL))
                      NIL))
                    NIL))
                  NIL))
                NIL))
              NIL))
            NIL))
          NIL))
        NIL))
      NIL))
    NIL))
  NIL)
 (|sim21_221_TCC1| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_221_TCC2| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_221_TCC3| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_221_TCC4| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_221_TCC5| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_221_TCC6| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_221_TCC7| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_221_TCC8| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_221_TCC9| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_221_TCC10| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_221_TCC11| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_221_TCC12| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_221_TCC13| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_221_TCC14| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_221_TCC15| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_221_TCC16| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_221_TCC17| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_221_TCC18| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_221_TCC19| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_221_TCC20| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_221_TCC21| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_221_TCC22| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_221_TCC23| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_221| "" (SKOLEM-TYPEPRED)
  (("" (FLATTEN)
    (("" (SPLIT)
      (("1" (FLATTEN)
        (("1" (INST + "s1!1" "tick" "trans(tick,s1!1)" "trans(tick,s1!1)")
          (("1" (BDDSIMP)
            (("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) ("11" (GRIND) NIL NIL)
             ("12" (GRIND) NIL NIL) ("13" (GRIND) NIL NIL)
             ("14" (GRIND) NIL NIL) ("15" (GRIND) NIL NIL)
             ("16" (GRIND) NIL NIL) ("17" (GRIND) NIL NIL)
             ("18" (GRIND) NIL NIL) ("19" (GRIND) NIL NIL)
             ("20" (GRIND) NIL NIL) ("21" (GRIND) NIL NIL)
             ("22" (GRIND) NIL NIL) ("23" (GRIND) NIL NIL)
             ("24" (GRIND) NIL NIL) ("25" (GRIND) NIL NIL)
             ("26" (GRIND) NIL NIL) ("27" (GRIND) NIL NIL)
             ("28" (GRIND) NIL NIL) ("29" (GRIND) NIL NIL)
             ("30" (GRIND) NIL NIL) ("31" (GRIND) NIL NIL)
             ("32" (EXPAND "enabled_tick") (("32" (GRIND) NIL NIL)) NIL)
             ("33" (EXPAND "sitc")
              (("33" (EXPAND "tc") (("33" (PROPAX) NIL NIL)) NIL)) NIL)
             ("34" (EXPAND "dd1")
              (("34" (EXPAND "enabled")
                (("34" (EXPAND "enabled_tick")
                  (("34" (SKOLEM-TYPEPRED)
                    (("34" (FLATTEN)
                      (("34" (CASE "q!1=alpha")
                        (("1" (REPLACE -1 *)
                          (("1" (INST - "alpha") (("1" (GRIND) NIL NIL)) NIL))
                          NIL)
                         ("2" (CASE "q!1=rho1")
                          (("1" (REPLACE -1 *)
                            (("1" (INST - "rho1") (("1" (GRIND) NIL NIL))
                              NIL))
                            NIL)
                           ("2" (CASE "q!1=gamma")
                            (("1" (REPLACE -1 *)
                              (("1" (INST - "gamma") (("1" (GRIND) NIL NIL))
                                NIL))
                              NIL)
                             ("2" (CASE "q!1=rho2")
                              (("1" (REPLACE -1 *)
                                (("1" (INST - "rho2") (("1" (GRIND) NIL NIL))
                                  NIL))
                                NIL)
                               ("2" (CASE "q!1=pr")
                                (("1" (REPLACE -1 *)
                                  (("1" (INST - "pr") (("1" (GRIND) NIL NIL))
                                    NIL))
                                  NIL)
                                 ("2" (CASE "q!1=ps")
                                  (("1" (REPLACE -1 *)
                                    (("1" (INST - "ps")
                                      (("1" (GRIND) NIL NIL)) NIL))
                                    NIL)
                                   ("2" (CASE "q!1=wr")
                                    (("1" (REPLACE -1 *)
                                      (("1"
                                        (INST - "wr")
                                        (("1" (GRIND) NIL NIL))
                                        NIL))
                                      NIL)
                                     ("2" (CASE "q!1=ws")
                                      (("1"
                                        (REPLACE -1 *)
                                        (("1"
                                          (INST - "ws")
                                          (("1" (GRIND) NIL NIL))
                                          NIL))
                                        NIL)
                                       ("2"
                                        (CASE "q!1=mu")
                                        (("1"
                                          (REPLACE -1 *)
                                          (("1"
                                            (INST - "mu1")
                                            (("1" (GRIND) NIL NIL))
                                            NIL))
                                          NIL)
                                         ("2"
                                          (CASE "q!1=omega29")
                                          (("1"
                                            (REPLACE -1 *)
                                            (("1"
                                              (INST - "mu1")
                                              (("1" (GRIND) NIL NIL))
                                              NIL))
                                            NIL)
                                           ("2"
                                            (CASE "q!1=omega19")
                                            (("1"
                                              (REPLACE -1 *)
                                              (("1"
                                                (INST - "mu2")
                                                (("1" (GRIND) NIL NIL))
                                                NIL))
                                              NIL)
                                             ("2" (GRIND) NIL NIL))
                                            NIL))
                                          NIL))
                                        NIL))
                                      NIL))
                                    NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL))
                  NIL))
                NIL))
              NIL)
             ("35" (EXPAND "sitc")
              (("35" (EXPAND "tc") (("35" (PROPAX) NIL NIL)) NIL)) NIL))
            NIL))
          NIL))
        NIL)
       ("2" (FLATTEN)
        (("2" (INST + "s1!1" "tick" "trans(tick,s1!1)" "trans(tick,s1!1)")
          (("2" (BDDSIMP)
            (("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) ("11" (GRIND) NIL NIL)
             ("12" (GRIND) NIL NIL) ("13" (GRIND) NIL NIL)
             ("14" (GRIND) NIL NIL) ("15" (GRIND) NIL NIL)
             ("16" (GRIND) NIL NIL) ("17" (GRIND) NIL NIL)
             ("18" (GRIND) NIL NIL) ("19" (GRIND) NIL NIL)
             ("20" (GRIND) NIL NIL) ("21" (GRIND) NIL NIL)
             ("22" (GRIND) NIL NIL) ("23" (GRIND) NIL NIL)
             ("24" (GRIND) NIL NIL) ("25" (GRIND) NIL NIL)
             ("26" (GRIND) NIL NIL) ("27" (GRIND) NIL NIL)
             ("28" (GRIND)
              (("1" (TIME_ETC_SIMP)
                (("1" (ASSERT) NIL NIL) ("2" (ASSERT) NIL NIL)) NIL)
               ("2" (TIME_ETC_SIMP)
                (("1" (ASSERT) NIL NIL) ("2" (ASSERT) NIL NIL)) NIL)
               ("3" (TIME_ETC_SIMP)
                (("1" (ASSERT) NIL NIL) ("2" (ASSERT) NIL NIL)) NIL)
               ("4" (TIME_ETC_SIMP)
                (("1" (ASSERT) NIL NIL) ("2" (ASSERT) NIL NIL)) NIL)
               ("5" (TIME_ETC_SIMP)
                (("1" (ASSERT) NIL NIL) ("2" (ASSERT) NIL NIL)) NIL)
               ("6" (TIME_ETC_SIMP)
                (("1" (ASSERT) NIL NIL) ("2" (ASSERT) NIL NIL)) NIL)
               ("7" (TIME_ETC_SIMP)
                (("1" (ASSERT) NIL NIL) ("2" (ASSERT) NIL NIL)) NIL)
               ("8" (TIME_ETC_SIMP)
                (("1" (ASSERT) NIL NIL) ("2" (ASSERT) NIL NIL)) NIL))
              NIL)
             ("29" (GRIND) NIL NIL) ("30" (GRIND) NIL NIL)
             ("31" (GRIND) NIL NIL)
             ("32" (EXPAND "enabled_tick") (("32" (GRIND) NIL NIL)) NIL)
             ("33" (EXPAND "sitc")
              (("33" (EXPAND "tc") (("33" (PROPAX) NIL NIL)) NIL)) NIL)
             ("34" (EXPAND "dd1")
              (("34" (EXPAND "enabled")
                (("34" (EXPAND "enabled_tick")
                  (("34" (SKOLEM-TYPEPRED)
                    (("34" (FLATTEN)
                      (("34" (CASE "q!1=alpha")
                        (("1" (REPLACE -1 *)
                          (("1" (INST - "alpha") (("1" (GRIND) NIL NIL)) NIL))
                          NIL)
                         ("2" (CASE "q!1=rho1")
                          (("1" (REPLACE -1 *)
                            (("1" (INST - "rho1") (("1" (GRIND) NIL NIL))
                              NIL))
                            NIL)
                           ("2" (CASE "q!1=gamma")
                            (("1" (REPLACE -1 *)
                              (("1" (INST - "gamma") (("1" (GRIND) NIL NIL))
                                NIL))
                              NIL)
                             ("2" (CASE "q!1=rho2")
                              (("1" (REPLACE -1 *)
                                (("1" (INST - "rho2") (("1" (GRIND) NIL NIL))
                                  NIL))
                                NIL)
                               ("2" (CASE "q!1=pr")
                                (("1" (REPLACE -1 *)
                                  (("1" (INST - "pr") (("1" (GRIND) NIL NIL))
                                    NIL))
                                  NIL)
                                 ("2" (CASE "q!1=ps")
                                  (("1" (REPLACE -1 *)
                                    (("1" (INST - "ps")
                                      (("1" (GRIND) NIL NIL)) NIL))
                                    NIL)
                                   ("2" (CASE "q!1=wr")
                                    (("1" (REPLACE -1 *)
                                      (("1"
                                        (INST - "wr")
                                        (("1" (GRIND) NIL NIL))
                                        NIL))
                                      NIL)
                                     ("2" (CASE "q!1=ws")
                                      (("1"
                                        (REPLACE -1 *)
                                        (("1"
                                          (INST - "ws")
                                          (("1" (GRIND) NIL NIL))
                                          NIL))
                                        NIL)
                                       ("2"
                                        (CASE "q!1=mu")
                                        (("1"
                                          (REPLACE -1 *)
                                          (("1"
                                            (INST - "mu1")
                                            (("1" (GRIND) NIL NIL))
                                            NIL))
                                          NIL)
                                         ("2"
                                          (CASE "q!1=omega29")
                                          (("1"
                                            (REPLACE -1 *)
                                            (("1"
                                              (INST - "mu1")
                                              (("1"
                                                (GRIND)
                                                (("1"
                                                  (TIME_ETC_SIMP)
                                                  (("1" (ASSERT) NIL NIL)
                                                   ("2"
                                                    (TIME_ETC_SIMP)
                                                    NIL
                                                    NIL))
                                                  NIL)
                                                 ("2"
                                                  (TIME_ETC_SIMP)
                                                  (("1" (ASSERT) NIL NIL)
                                                   ("2" (ASSERT) NIL NIL))
                                                  NIL)
                                                 ("3"
                                                  (TIME_ETC_SIMP)
                                                  (("1" (ASSERT) NIL NIL)
                                                   ("2"
                                                    (TIME_ETC_SIMP)
                                                    NIL
                                                    NIL))
                                                  NIL)
                                                 ("4"
                                                  (TIME_ETC_SIMP)
                                                  (("1" (ASSERT) NIL NIL)
                                                   ("2" (ASSERT) NIL NIL))
                                                  NIL)
                                                 ("5"
                                                  (TIME_ETC_SIMP)
                                                  (("1" (ASSERT) NIL NIL)
                                                   ("2"
                                                    (TIME_ETC_SIMP)
                                                    NIL
                                                    NIL))
                                                  NIL)
                                                 ("6"
                                                  (TIME_ETC_SIMP)
                                                  (("1" (ASSERT) NIL NIL)
                                                   ("2" (ASSERT) NIL NIL))
                                                  NIL)
                                                 ("7"
                                                  (TIME_ETC_SIMP)
                                                  (("1" (ASSERT) NIL NIL)
                                                   ("2"
                                                    (TIME_ETC_SIMP)
                                                    NIL
                                                    NIL))
                                                  NIL)
                                                 ("8"
                                                  (TIME_ETC_SIMP)
                                                  (("1" (ASSERT) NIL NIL)
                                                   ("2" (ASSERT) NIL NIL))
                                                  NIL))
                                                NIL))
                                              NIL))
                                            NIL)
                                           ("2"
                                            (CASE "q!1=omega19")
                                            (("1"
                                              (REPLACE -1 *)
                                              (("1"
                                                (INST - "mu2")
                                                (("1" (GRIND) NIL NIL))
                                                NIL))
                                              NIL)
                                             ("2" (GRIND) NIL NIL))
                                            NIL))
                                          NIL))
                                        NIL))
                                      NIL))
                                    NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL))
                  NIL))
                NIL))
              NIL)
             ("35" (EXPAND "sitc")
              (("35" (EXPAND "tc") (("35" (PROPAX) NIL NIL)) NIL)) NIL))
            NIL))
          NIL))
        NIL))
      NIL))
    NIL))
  NIL)
 (|sim21_4121_TCC1| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_4121_TCC2| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_4121_TCC3| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_4121_TCC4| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_4121_TCC5| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_4121_TCC6| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_4121_TCC7| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_4121_TCC8| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_4121_TCC9| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_4121_TCC10| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_4121_TCC11| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_4121_TCC12| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_4121_TCC13| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_4121_TCC14| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_4121_TCC15| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_4121_TCC16| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_4121_TCC17| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_4121_TCC18| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_4121_TCC19| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_4121_TCC20| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_4121_TCC21| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_4121_TCC22| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_4121_TCC23| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_4121_TCC24| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_4121_TCC25| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_4121_TCC26| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_4121_TCC27| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_4121| "" (SKOLEM-TYPEPRED)
  (("" (FLATTEN)
    (("" (CASE "s2!1`basic`c2=19 and s2!1`action_time(mu2)=one")
      (("1" (FLATTEN)
        (("1" (HIDE 2 3)
          (("1"
            (INST + "s1!1" "omega19" "trans(omega19,s1!1)"
             "trans(omega19,s1!1)")
            (("1" (BDDSIMP)
              (("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)
               ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
               ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
               ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
               ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
               ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
               ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
               ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
               ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
               ("27" (GRIND) NIL NIL) ("28" (GRIND) NIL NIL)
               ("29" (GRIND) NIL NIL) ("30" (GRIND) NIL NIL)
               ("31" (GRIND) NIL NIL) ("32" (GRIND) NIL NIL)
               ("33" (EXPAND "sitc")
                (("33" (EXPAND "tc") (("33" (PROPAX) NIL NIL)) NIL)) NIL)
               ("34" (GRIND) NIL NIL)
               ("35" (GRIND)
                (("1" (EXPAND "tc") (("1" (PROPAX) NIL NIL)) NIL)
                 ("2" (EXPAND "tc") (("2" (PROPAX) NIL NIL)) NIL)
                 ("3" (EXPAND "tc") (("3" (PROPAX) NIL NIL)) NIL)
                 ("4" (EXPAND "tc") (("4" (PROPAX) NIL NIL)) NIL))
                NIL)
               ("36" (GRIND) NIL NIL) ("37" (GRIND) NIL NIL)
               ("38" (GRIND) NIL NIL) ("39" (GRIND) NIL NIL)
               ("40" (GRIND) NIL NIL) ("41" (GRIND) NIL NIL)
               ("42" (GRIND) NIL NIL) ("43" (GRIND) NIL NIL)
               ("44" (GRIND) NIL NIL) ("45" (GRIND) NIL NIL)
               ("46" (GRIND) NIL NIL) ("47" (GRIND) NIL NIL)
               ("48" (GRIND) NIL NIL) ("49" (GRIND) NIL NIL)
               ("50" (GRIND) NIL NIL) ("51" (GRIND) NIL NIL)
               ("52" (GRIND) NIL NIL) ("53" (GRIND) NIL NIL)
               ("54" (GRIND) NIL NIL) ("55" (GRIND) NIL NIL)
               ("56" (GRIND) NIL NIL) ("57" (GRIND) NIL NIL)
               ("58" (GRIND) NIL NIL) ("59" (GRIND) NIL NIL)
               ("60" (GRIND) NIL NIL) ("61" (GRIND) NIL NIL)
               ("62" (GRIND) NIL NIL) ("63" (GRIND) NIL NIL)
               ("64" (GRIND) NIL NIL) ("65" (GRIND) NIL NIL)
               ("66" (GRIND) NIL NIL) ("67" (GRIND) NIL NIL)
               ("68" (EXPAND "sitc")
                (("68" (EXPAND "tc") (("68" (PROPAX) NIL NIL)) NIL)) NIL)
               ("69" (GRIND) NIL NIL)
               ("70" (EXPAND "sitc")
                (("70" (EXPAND "tc") (("70" (PROPAX) NIL NIL)) NIL)) NIL))
              NIL))
            NIL))
          NIL))
        NIL)
       ("2" (SPLIT -)
        (("1" (HIDE 2)
          (("1" (HIDE 2)
            (("1" (FLATTEN)
              (("1" (INST + "s1!1")
                (("1" (BDDSIMP)
                  (("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)
                   ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                   ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                   ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                   ("17" (GRIND) NIL NIL)
                   ("18" (EXPAND "sitc")
                    (("18" (EXPAND "tc") (("18" (PROPAX) NIL NIL)) NIL)) NIL)
                   ("19" (HIDE -4 -5 -10 -11 -12 -9) (("19" (GRIND) NIL NIL))
                    NIL)
                   ("20" (GRIND) NIL NIL))
                  NIL))
                NIL))
              NIL))
            NIL))
          NIL)
         ("2" (HIDE 2 3)
          (("2" (INST + "s1!1")
            (("2" (BDDSIMP)
              (("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)
               ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
               ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
               ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
               ("17" (GRIND) NIL NIL)
               ("18" (EXPAND "sitc")
                (("18" (EXPAND "tc") (("18" (PROPAX) NIL NIL)) NIL)) NIL)
               ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
               ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
               ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
               ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
               ("27" (GRIND) NIL NIL) ("28" (GRIND) NIL NIL)
               ("29" (GRIND) NIL NIL) ("30" (GRIND) NIL NIL)
               ("31" (GRIND) NIL NIL) ("32" (GRIND) NIL NIL)
               ("33" (GRIND) NIL NIL) ("34" (GRIND) NIL NIL)
               ("35" (GRIND) NIL NIL) ("36" (GRIND) NIL NIL)
               ("37" (GRIND) NIL NIL)
               ("38" (EXPAND "sitc")
                (("38" (EXPAND "tc") (("38" (PROPAX) NIL NIL)) NIL)) NIL)
               ("39" (GRIND) NIL NIL) ("40" (GRIND) NIL NIL))
              NIL))
            NIL))
          NIL))
        NIL))
      NIL))
    NIL))
  NIL)
 (|sim21_42_TCC1| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_42_TCC2| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_42_TCC3| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_42_TCC4| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_42_TCC5| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_42_TCC6| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_42_TCC7| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_42_TCC8| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_42_TCC9| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_42_TCC10| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_42_TCC11| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_42_TCC12| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_42_TCC13| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_42_TCC14| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_42_TCC15| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_42_TCC16| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_42_TCC17| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_42_TCC18| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_42_TCC19| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_42_TCC20| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_42_TCC21| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_42_TCC22| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_42_TCC23| "" (SUBTYPE-TCC) NIL NIL)
 (|sim21_42| "" (SKOLEM-TYPEPRED)
  (("" (FLATTEN)
    (("" (SPLIT)
      (("1" (FLATTEN)
        (("1" (INST + "s1!1" "tick" "trans(tick,s1!1)" "trans(tick,s1!1)")
          (("1" (BDDSIMP)
            (("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) ("11" (GRIND) NIL NIL)
             ("12" (GRIND) NIL NIL) ("13" (GRIND) NIL NIL)
             ("14" (GRIND) NIL NIL) ("15" (GRIND) NIL NIL)
             ("16" (GRIND) NIL NIL) ("17" (GRIND) NIL NIL)
             ("18" (GRIND) NIL NIL) ("19" (GRIND) NIL NIL)
             ("20" (GRIND) NIL NIL) ("21" (GRIND) NIL NIL)
             ("22" (GRIND) NIL NIL) ("23" (GRIND) NIL NIL)
             ("24" (GRIND) NIL NIL) ("25" (GRIND) NIL NIL)
             ("26" (GRIND) NIL NIL) ("27" (GRIND) NIL NIL)
             ("28" (GRIND) NIL NIL) ("29" (GRIND) NIL NIL)
             ("30" (GRIND) NIL NIL) ("31" (GRIND) NIL NIL)
             ("32" (EXPAND "enabled_tick") (("32" (GRIND) NIL NIL)) NIL)
             ("33" (EXPAND "sitc")
              (("33" (EXPAND "tc") (("33" (PROPAX) NIL NIL)) NIL)) NIL)
             ("34" (EXPAND "dd1")
              (("34" (EXPAND "enabled")
                (("34" (EXPAND "enabled_tick")
                  (("34" (SKOLEM-TYPEPRED)
                    (("34" (FLATTEN)
                      (("34" (CASE "q!1=alpha")
                        (("1" (REPLACE -1 *)
                          (("1" (INST - "alpha") (("1" (GRIND) NIL NIL)) NIL))
                          NIL)
                         ("2" (CASE "q!1=rho1")
                          (("1" (REPLACE -1 *)
                            (("1" (INST - "rho1") (("1" (GRIND) NIL NIL))
                              NIL))
                            NIL)
                           ("2" (CASE "q!1=gamma")
                            (("1" (REPLACE -1 *)
                              (("1" (INST - "gamma") (("1" (GRIND) NIL NIL))
                                NIL))
                              NIL)
                             ("2" (CASE "q!1=rho2")
                              (("1" (REPLACE -1 *)
                                (("1" (INST - "rho2") (("1" (GRIND) NIL NIL))
                                  NIL))
                                NIL)
                               ("2" (CASE "q!1=pr")
                                (("1" (REPLACE -1 *)
                                  (("1" (INST - "pr") (("1" (GRIND) NIL NIL))
                                    NIL))
                                  NIL)
                                 ("2" (CASE "q!1=ps")
                                  (("1" (REPLACE -1 *)
                                    (("1" (INST - "ps")
                                      (("1" (GRIND) NIL NIL)) NIL))
                                    NIL)
                                   ("2" (CASE "q!1=wr")
                                    (("1" (REPLACE -1 *)
                                      (("1"
                                        (INST - "wr")
                                        (("1" (GRIND) NIL NIL))
                                        NIL))
                                      NIL)
                                     ("2" (CASE "q!1=ws")
                                      (("1"
                                        (REPLACE -1 *)
                                        (("1"
                                          (INST - "ws")
                                          (("1" (GRIND) NIL NIL))
                                          NIL))
                                        NIL)
                                       ("2"
                                        (CASE "q!1=omega29")
                                        (("1"
                                          (REPLACE -1 *)
                                          (("1"
                                            (INST - "mu1")
                                            (("1" (GRIND) NIL NIL))
                                            NIL))
                                          NIL)
                                         ("2"
                                          (CASE "q!1=omega19")
                                          (("1"
                                            (REPLACE -1 *)
                                            (("1"
                                              (INST - "mu2")
                                              (("1" (GRIND) NIL NIL))
                                              NIL))
                                            NIL)
                                           ("2" (GRIND) NIL NIL))
                                          NIL))
                                        NIL))
                                      NIL))
                                    NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL))
                  NIL))
                NIL))
              NIL)
             ("35" (EXPAND "sitc")
              (("35" (EXPAND "tc") (("35" (PROPAX) NIL NIL)) NIL)) NIL))
            NIL))
          NIL))
        NIL)
       ("2" (FLATTEN)
        (("2" (INST + "s1!1" "tick" "trans(tick,s1!1)" "trans(tick,s1!1)")
          (("2" (CASE "a22!1=tick")
            (("1" (REPLACE -1 *)
              (("1" (BDDSIMP)
                (("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)
                 ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                 ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                 ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                 ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                 ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                 ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                 ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                 ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                 ("27" (GRIND) NIL NIL)
                 ("28" (GRIND)
                  (("1" (TIME_ETC_SIMP)
                    (("1" (ASSERT) NIL NIL) ("2" (ASSERT) NIL NIL)) NIL)
                   ("2" (TIME_ETC_SIMP)
                    (("1" (ASSERT) NIL NIL) ("2" (ASSERT) NIL NIL)) NIL)
                   ("3" (TIME_ETC_SIMP)
                    (("1" (ASSERT) NIL NIL) ("2" (ASSERT) NIL NIL)) NIL)
                   ("4" (TIME_ETC_SIMP)
                    (("1" (ASSERT) NIL NIL) ("2" (ASSERT) NIL NIL)) NIL))
                  NIL)
                 ("29" (GRIND) NIL NIL) ("30" (GRIND) NIL NIL)
                 ("31" (GRIND) NIL NIL)
                 ("32" (EXPAND "enabled_tick") (("32" (GRIND) NIL NIL)) NIL)
                 ("33" (EXPAND "sitc")
                  (("33" (EXPAND "tc") (("33" (PROPAX) NIL NIL)) NIL)) NIL)
                 ("34" (EXPAND "dd1")
                  (("34" (EXPAND "enabled")
                    (("34" (EXPAND "enabled_tick")
                      (("34" (SKOLEM-TYPEPRED)
                        (("34" (FLATTEN)
                          (("34" (CASE "q!1=alpha")
                            (("1" (REPLACE -1 *)
                              (("1" (INST - "alpha") (("1" (GRIND) NIL NIL))
                                NIL))
                              NIL)
                             ("2" (CASE "q!1=rho1")
                              (("1" (REPLACE -1 *)
                                (("1" (INST - "rho1") (("1" (GRIND) NIL NIL))
                                  NIL))
                                NIL)
                               ("2" (CASE "q!1=gamma")
                                (("1" (REPLACE -1 *)
                                  (("1" (INST - "gamma")
                                    (("1" (GRIND) NIL NIL)) NIL))
                                  NIL)
                                 ("2" (CASE "q!1=rho2")
                                  (("1" (REPLACE -1 *)
                                    (("1" (INST - "rho2")
                                      (("1" (GRIND) NIL NIL)) NIL))
                                    NIL)
                                   ("2" (CASE "q!1=pr")
                                    (("1" (REPLACE -1 *)
                                      (("1"
                                        (INST - "pr")
                                        (("1" (GRIND) NIL NIL))
                                        NIL))
                                      NIL)
                                     ("2" (CASE "q!1=ps")
                                      (("1"
                                        (REPLACE -1 *)
                                        (("1"
                                          (INST - "ps")
                                          (("1" (GRIND) NIL NIL))
                                          NIL))
                                        NIL)
                                       ("2"
                                        (CASE "q!1=wr")
                                        (("1"
                                          (REPLACE -1 *)
                                          (("1"
                                            (INST - "wr")
                                            (("1" (GRIND) NIL NIL))
                                            NIL))
                                          NIL)
                                         ("2"
                                          (CASE "q!1=ws")
                                          (("1"
                                            (REPLACE -1 *)
                                            (("1"
                                              (INST - "ws")
                                              (("1" (GRIND) NIL NIL))
                                              NIL))
                                            NIL)
                                           ("2"
                                            (CASE "q!1=omega29")
                                            (("1"
                                              (REPLACE -1 *)
                                              (("1"
                                                (INST - "mu1")
                                                (("1" (GRIND) NIL NIL))
                                                NIL))
                                              NIL)
                                             ("2"
                                              (CASE "q!1=omega19")
                                              (("1"
                                                (REPLACE -1 *)
                                                (("1"
                                                  (INST - "mu2")
                                                  (("1"
                                                    (GRIND)
                                                    (("1"
                                                      (TIME_ETC_SIMP)
                                                      (("1" (ASSERT) NIL NIL)
                                                       ("2"
                                                        (TIME_ETC_SIMP)
                                                        NIL
                                                        NIL))
                                                      NIL)
                                                     ("2"
                                                      (TIME_ETC_SIMP)
                                                      (("1" (ASSERT) NIL NIL)
                                                       ("2" (ASSERT) NIL NIL))
                                                      NIL)
                                                     ("3"
                                                      (TIME_ETC_SIMP)
                                                      (("1" (ASSERT) NIL NIL)
                                                       ("2" (ASSERT) NIL NIL))
                                                      NIL)
                                                     ("4"
                                                      (TIME_ETC_SIMP)
                                                      (("1" (ASSERT) NIL NIL)
                                                       ("2"
                                                        (TIME_ETC_SIMP)
                                                        NIL
                                                        NIL))
                                                      NIL))
                                                    NIL))
                                                  NIL))
                                                NIL)
                                               ("2" (GRIND) NIL NIL))
                                              NIL))
                                            NIL))
                                          NIL))
                                        NIL))
                                      NIL))
                                    NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL))
                  NIL)
                 ("35" (EXPAND "sitc")
                  (("35" (EXPAND "tc") (("35" (PROPAX) NIL NIL)) NIL)) NIL))
                NIL))
              NIL)
             ("2" (ASSERT) NIL NIL))
            NIL))
          NIL))
        NIL))
      NIL))
    NIL))
  NIL)
 (|Sim1_2_TCC1| "" (SUBTYPE-TCC) NIL NIL)
 (|Sim1_2_TCC2| "" (SUBTYPE-TCC) NIL NIL)
 (|Sim1_2_TCC3| "" (SUBTYPE-TCC) NIL NIL)
 (|Sim1_2_TCC4| "" (SUBTYPE-TCC) NIL NIL)
 (|Sim1_2_TCC5| "" (SUBTYPE-TCC) NIL NIL)
 (|Sim1_2_TCC6| "" (SUBTYPE-TCC) NIL NIL)
 (|Sim1_2_TCC7| "" (SUBTYPE-TCC) NIL NIL)
 (|Sim1_2_TCC8| "" (SUBTYPE-TCC) NIL NIL)
 (|Sim1_2_TCC9| "" (SUBTYPE-TCC) NIL NIL)
 (|Sim1_2_TCC10| "" (SUBTYPE-TCC) NIL NIL)
 (|Sim1_2_TCC11| "" (SUBTYPE-TCC) NIL NIL)
 (|Sim1_2_TCC12| "" (SUBTYPE-TCC) NIL NIL)
 (|Sim1_2_TCC13| "" (SUBTYPE-TCC) NIL NIL)
 (|Sim1_2_TCC14| "" (SUBTYPE-TCC) NIL NIL)
 (|Sim1_2_TCC15| "" (SUBTYPE-TCC) NIL NIL)
 (|Sim1_2_TCC16| "" (SUBTYPE-TCC) NIL NIL)
 (|Sim1_2_TCC17| "" (SUBTYPE-TCC) NIL NIL)
 (|Sim1_2_TCC18| "" (SUBTYPE-TCC) NIL NIL)
 (|Sim1_2| "" (EXPAND "wsesim?")
  (("" (SKOLEM-TYPEPRED)
    (("" (EXPAND "dd1")
      (("" (FLATTEN)
        (("" (SPLIT -)
          (("1" (EXPAND "enabled")
            (("1" (SPLIT)
              (("1" (FLATTEN)
                (("1"
                  (CASE "NOT (a1!1=mu or a1!1=ps or a1!1=pr or a1!1=wr or a1!1=ws)")
                  (("1" (HIDE 3 4) (("1" (GRIND) NIL NIL)) NIL)
                   ("2" (BDDSIMP)
                    (("1" (HIDE 2)
                      (("1"
                        (INST + "s2!1" "mu1" "trans(mu1,s2!1)"
                         "trans(mu1,s2!1)")
                        (("1" (CASE "a1!1=mu")
                          (("1" (REPLACE -1 *)
                            (("1" (BDDSIMP)
                              (("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)
                               ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                               ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                               ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                               ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                               ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                               ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                               ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                               ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                               ("27" (GRIND) NIL NIL) ("28" (GRIND) NIL NIL)
                               ("29" (GRIND) NIL NIL)
                               ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                               ("31" (GRIND) NIL NIL)
                               ("32" (EXPAND "sitc")
                                (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("33" (GRIND) NIL NIL)
                               ("34" (EXPAND "sitc")
                                (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL)
                           ("2" (HIDE 2) (("2" (GRIND) NIL NIL)) NIL))
                          NIL))
                        NIL))
                      NIL)
                     ("2" (CASE "a1!1=ps")
                      (("1" (REPLACE -1 *)
                        (("1"
                          (INST + "s2!1" "ps" "trans(ps,s2!1)"
                           "trans(ps,s2!1)")
                          (("1" (HIDE 2)
                            (("1" (BDDSIMP)
                              (("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)
                               ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                               ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                               ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                               ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                               ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                               ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                               ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                               ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                               ("27" (GRIND) NIL NIL) ("28" (GRIND) NIL NIL)
                               ("29" (GRIND) NIL NIL)
                               ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                               ("31" (GRIND) NIL NIL)
                               ("32" (EXPAND "sitc")
                                (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("33" (GRIND) NIL NIL)
                               ("34" (EXPAND "sitc")
                                (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("2" (HIDE 2 3) (("2" (GRIND) NIL NIL)) NIL))
                      NIL)
                     ("3" (HIDE 2)
                      (("3"
                        (INST + "s2!1" "pr" "trans(pr,s2!1)" "trans(pr,s2!1)")
                        (("3" (CASE "a1!1=pr")
                          (("1" (REPLACE -1 *)
                            (("1" (BDDSIMP)
                              (("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)
                               ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                               ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                               ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                               ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                               ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                               ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                               ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                               ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                               ("27" (GRIND) NIL NIL) ("28" (GRIND) NIL NIL)
                               ("29" (GRIND) NIL NIL)
                               ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                               ("31" (GRIND) NIL NIL)
                               ("32" (EXPAND "sitc")
                                (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("33" (GRIND) NIL NIL)
                               ("34" (EXPAND "sitc")
                                (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL)
                           ("2" (HIDE 2) (("2" (GRIND) NIL NIL)) NIL))
                          NIL))
                        NIL))
                      NIL)
                     ("4" (HIDE 2)
                      (("4"
                        (INST + "s2!1" "wr" "trans(wr,s2!1)" "trans(wr,s2!1)")
                        (("4" (BDDSIMP)
                          (("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)
                           ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                           ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                           ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                           ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                           ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                           ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                           ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                           ("25" (GRIND) NIL NIL)
                           ("26" (HIDE -2 -3 -8 -9 -10)
                            (("26" (GRIND) NIL NIL)) NIL)
                           ("27" (HIDE -2 -3 -8 -9 -11)
                            (("27" (GRIND) NIL NIL)) NIL)
                           ("28" (HIDE -2 -3 -8 -10 -11)
                            (("28" (GRIND) NIL NIL)) NIL)
                           ("29" (HIDE -2 -3 -9 -10 -11)
                            (("29" (GRIND) NIL NIL)) NIL)
                           ("30" (GRIND) NIL NIL) ("31" (GRIND) NIL NIL)
                           ("32" (EXPAND "sitc")
                            (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL))
                              NIL))
                            NIL)
                           ("33" (GRIND) NIL NIL)
                           ("34" (EXPAND "sitc")
                            (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL)
                     ("5" (HIDE 2)
                      (("5"
                        (INST + "s2!1" "ws" "trans(ws,s2!1)" "trans(ws,s2!1)")
                        (("5" (CASE "a1!1=ws")
                          (("1" (REPLACE -1 *)
                            (("1" (BDDSIMP)
                              (("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)
                               ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                               ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                               ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                               ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                               ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                               ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                               ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                               ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                               ("27" (GRIND) NIL NIL) ("28" (GRIND) NIL NIL)
                               ("29" (GRIND) NIL NIL)
                               ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                               ("31" (GRIND) NIL NIL)
                               ("32" (EXPAND "sitc")
                                (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("33" (GRIND) NIL NIL)
                               ("34" (EXPAND "sitc")
                                (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL)
                           ("2" (HIDE 2) (("2" (GRIND) NIL NIL)) NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL))
                  NIL))
                NIL)
               ("2" (HIDE 2)
                (("2" (FLATTEN)
                  (("2"
                    (INST + "s2!1" "tick" "trans(tick,s2!1)"
                     "trans(tick,s2!1)")
                    (("2" (BDDSIMP)
                      (("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)
                       ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                       ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                       ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                       ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                       ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                       ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                       ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                       ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                       ("27" (EXPAND "enabled_tick") (("27" (GRIND) NIL NIL))
                        NIL)
                       ("28" (GRIND) NIL NIL) ("29" (GRIND) NIL NIL)
                       ("30" (GRIND) NIL NIL)
                       ("31" (EXPAND "enabled_tick") (("31" (GRIND) NIL NIL))
                        NIL)
                       ("32" (EXPAND "sitc")
                        (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL)) NIL))
                        NIL)
                       ("33" (EXPAND "dd2")
                        (("33" (EXPAND "enabled")
                          (("33" (EXPAND "enabled_tick")
                            (("33" (SKOLEM-TYPEPRED)
                              (("33" (FLATTEN)
                                (("33" (CASE "q!1=alpha")
                                  (("1" (REPLACE -1 *)
                                    (("1" (INST - "alpha")
                                      (("1" (GRIND) NIL NIL)) NIL))
                                    NIL)
                                   ("2" (CASE "q!1=rho1")
                                    (("1" (REPLACE -1 *)
                                      (("1"
                                        (INST - "rho1")
                                        (("1" (GRIND) NIL NIL))
                                        NIL))
                                      NIL)
                                     ("2" (CASE "q!1=gamma")
                                      (("1"
                                        (REPLACE -1 *)
                                        (("1"
                                          (INST - "gamma")
                                          (("1" (GRIND) NIL NIL))
                                          NIL))
                                        NIL)
                                       ("2"
                                        (CASE "q!1=pr")
                                        (("1"
                                          (REPLACE -1 *)
                                          (("1"
                                            (INST - "pr")
                                            (("1" (GRIND) NIL NIL))
                                            NIL))
                                          NIL)
                                         ("2"
                                          (CASE "q!1=ps")
                                          (("1"
                                            (REPLACE -1 *)
                                            (("1"
                                              (INST - "ps")
                                              (("1" (GRIND) NIL NIL))
                                              NIL))
                                            NIL)
                                           ("2"
                                            (CASE "q!1=wr")
                                            (("1"
                                              (REPLACE -1 *)
                                              (("1"
                                                (INST - "wr")
                                                (("1" (GRIND) NIL NIL))
                                                NIL))
                                              NIL)
                                             ("2"
                                              (CASE "q!1=ws")
                                              (("1"
                                                (REPLACE -1 *)
                                                (("1"
                                                  (INST - "ws")
                                                  (("1" (GRIND) NIL NIL))
                                                  NIL))
                                                NIL)
                                               ("2"
                                                (CASE "q!1=mu1")
                                                (("1"
                                                  (REPLACE -1 *)
                                                  (("1"
                                                    (INST - "mu")
                                                    (("1" (GRIND) NIL NIL))
                                                    NIL))
                                                  NIL)
                                                 ("2"
                                                  (CASE "q!1=mu2")
                                                  (("1"
                                                    (REPLACE -1 *)
                                                    (("1"
                                                      (INST - "omega19")
                                                      (("1" (GRIND) NIL NIL))
                                                      NIL))
                                                    NIL)
                                                   ("2" (GRIND) NIL NIL))
                                                  NIL))
                                                NIL))
                                              NIL))
                                            NIL))
                                          NIL))
                                        NIL))
                                      NIL))
                                    NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("34" (EXPAND "sitc")
                        (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL)) NIL))
                        NIL))
                      NIL))
                    NIL))
                  NIL))
                NIL))
              NIL))
            NIL)
           ("2" (FLATTEN)
            (("2" (LEMMA "sim12_2")
              (("2" (INST - "a1!1" "s1!1" "s2!1") (("2" (GRIND) NIL NIL))
                NIL))
              NIL))
            NIL)
           ("3" (FLATTEN)
            (("3" (EXPAND "enabled")
              (("3" (SPLIT -)
                (("1" (FLATTEN)
                  (("1"
                    (CASE "not (a1!1=alpha or a1!1=rho1 or a1!1=pr or a1!1=ps or a1!1=wr or a1!1=ws)")
                    (("1" (HIDE 3 4)
                      (("1" (FLATTEN)
                        (("1" (HIDE -5 -6 -8 -17) (("1" (GRIND) NIL NIL))
                          NIL))
                        NIL))
                      NIL)
                     ("2" (SPLIT)
                      (("1" (REPLACE -1 *)
                        (("1" (HIDE 3)
                          (("1"
                            (INST + "s2!1" "alpha" "trans(alpha,s2!1)"
                             "trans(alpha,s2!1)")
                            (("1" (BDDSIMP)
                              (("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)
                               ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                               ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                               ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                               ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                               ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                               ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                               ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                               ("25" (GRIND) NIL NIL)
                               ("26" (HIDE -2 -3 -6 -7 -8 -18)
                                (("26" (GRIND) NIL NIL)) NIL)
                               ("27" (HIDE -2 -3 -6 -7 -9)
                                (("27" (GRIND) NIL NIL)) NIL)
                               ("28" (HIDE -2 -3 -6 -8 -9)
                                (("28" (GRIND) NIL NIL)) NIL)
                               ("29" (HIDE -2 -3 -7 -8 -9)
                                (("29" (GRIND) NIL NIL)) NIL)
                               ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                               ("31" (GRIND) NIL NIL)
                               ("32" (EXPAND "sitc")
                                (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("33" (GRIND) NIL NIL)
                               ("34" (EXPAND "sitc")
                                (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("2" (REPLACE -1 *)
                        (("2" (HIDE 3)
                          (("2"
                            (INST + "s2!1" "rho1" "trans(rho1,s2!1)"
                             "trans(rho1,s2!1)")
                            (("2" (BDDSIMP)
                              (("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)
                               ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                               ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                               ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                               ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                               ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                               ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                               ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                               ("25" (GRIND) NIL NIL)
                               ("26" (HIDE -2 -3 -6 -7 -8)
                                (("26" (GRIND) NIL NIL)) NIL)
                               ("27" (HIDE -2 -3 -6 -7 -9)
                                (("27" (GRIND) NIL NIL)) NIL)
                               ("28" (HIDE -2 -3 -6 -8 -9)
                                (("28" (GRIND) NIL NIL)) NIL)
                               ("29" (HIDE -2 -3 -7 -8 -9)
                                (("29" (GRIND) NIL NIL)) NIL)
                               ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                               ("31" (GRIND) NIL NIL)
                               ("32" (EXPAND "sitc")
                                (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("33" (GRIND) NIL NIL)
                               ("34" (EXPAND "sitc")
                                (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("3" (REPLACE -1 *)
                        (("3" (HIDE 3)
                          (("3"
                            (INST + "s2!1" "pr" "trans(pr,s2!1)"
                             "trans(pr,s2!1)")
                            (("3" (BDDSIMP)
                              (("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)
                               ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                               ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                               ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                               ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                               ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                               ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                               ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                               ("25" (GRIND) NIL NIL)
                               ("26" (HIDE -2 -3 -6 -7 -8)
                                (("26" (GRIND) NIL NIL)) NIL)
                               ("27" (HIDE -2 -3 -6 -7 -9)
                                (("27" (GRIND) NIL NIL)) NIL)
                               ("28" (HIDE -2 -3 -6 -8 -9)
                                (("28" (GRIND) NIL NIL)) NIL)
                               ("29" (HIDE -2 -3 -7 -8 -9)
                                (("29" (GRIND) NIL NIL)) NIL)
                               ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                               ("31" (GRIND) NIL NIL)
                               ("32" (EXPAND "sitc")
                                (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("33" (GRIND) NIL NIL)
                               ("34" (EXPAND "sitc")
                                (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("4" (REPLACE -1 *)
                        (("4" (HIDE 3)
                          (("4"
                            (INST + "s2!1" "ps" "trans(ps,s2!1)"
                             "trans(ps,s2!1)")
                            (("4" (BDDSIMP)
                              (("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)
                               ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                               ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                               ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                               ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                               ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                               ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                               ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                               ("25" (GRIND) NIL NIL)
                               ("26" (HIDE -2 -3 -6 -7 -8)
                                (("26" (GRIND) NIL NIL)) NIL)
                               ("27" (HIDE -2 -3 -6 -7 -9)
                                (("27" (GRIND) NIL NIL)) NIL)
                               ("28" (HIDE -2 -3 -6 -8 -9)
                                (("28" (GRIND) NIL NIL)) NIL)
                               ("29" (HIDE -2 -3 -7 -8 -9)
                                (("29" (GRIND) NIL NIL)) NIL)
                               ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                               ("31" (GRIND) NIL NIL)
                               ("32" (EXPAND "sitc")
                                (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("33" (GRIND) NIL NIL)
                               ("34" (EXPAND "sitc")
                                (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("5" (REPLACE -1 *)
                        (("5" (HIDE 3)
                          (("5"
                            (INST + "s2!1" "wr" "trans(wr,s2!1)"
                             "trans(wr,s2!1)")
                            (("5" (BDDSIMP)
                              (("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)
                               ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                               ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                               ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                               ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                               ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                               ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                               ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                               ("25" (GRIND) NIL NIL)
                               ("26" (HIDE -2 -3 -6 -7 -8)
                                (("26" (GRIND) NIL NIL)) NIL)
                               ("27" (HIDE -2 -3 -6 -7 -9)
                                (("27" (GRIND) NIL NIL)) NIL)
                               ("28" (HIDE -2 -3 -6 -8 -9)
                                (("28" (GRIND) NIL NIL)) NIL)
                               ("29" (HIDE -2 -3 -7 -8 -9)
                                (("29" (GRIND) NIL NIL)) NIL)
                               ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                               ("31" (GRIND) NIL NIL)
                               ("32" (EXPAND "sitc")
                                (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("33" (GRIND) NIL NIL)
                               ("34" (EXPAND "sitc")
                                (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("6" (REPLACE -1 *)
                        (("6" (HIDE 3)
                          (("6"
                            (INST + "s2!1" "ws" "trans(ws,s2!1)"
                             "trans(ws,s2!1)")
                            (("6" (BDDSIMP)
                              (("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)
                               ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                               ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                               ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                               ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                               ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                               ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                               ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                               ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                               ("27" (HIDE -2 -3 -6 -7 -9)
                                (("27" (GRIND) NIL NIL)) NIL)
                               ("28" (HIDE -2 -3 -6 -8 -9)
                                (("28" (GRIND) NIL NIL)) NIL)
                               ("29" (HIDE -2 -3 -7 -8 -9)
                                (("29" (GRIND) NIL NIL)) NIL)
                               ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                               ("31" (GRIND) NIL NIL)
                               ("32" (EXPAND "sitc")
                                (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("33" (GRIND) NIL NIL)
                               ("34" (EXPAND "sitc")
                                (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL))
                  NIL)
                 ("2" (FLATTEN)
                  (("2" (HIDE 2)
                    (("2" (CASE "a1!1=tick")
                      (("1" (REPLACE -1 *)
                        (("1"
                          (INST + "s2!1" "tick" "trans(tick,s2!1)"
                           "trans(tick,s2!1)")
                          (("1" (BDDSIMP)
                            (("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)
                             ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                             ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                             ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                             ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                             ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                             ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                             ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                             ("25" (GRIND) NIL NIL)
                             ("26" (HIDE -6 -7)
                              (("26" (GRIND)
                                (("1" (REVEAL -1)
                                  (("1" (INST - "rho1")
                                    (("1" (GRIND) NIL NIL)) NIL))
                                  NIL)
                                 ("2" (REVEAL -1)
                                  (("2" (INST - "rho1")
                                    (("2" (GRIND) NIL NIL)) NIL))
                                  NIL)
                                 ("3" (REVEAL -1)
                                  (("3" (INST - "rho1")
                                    (("3" (GRIND) NIL NIL)) NIL))
                                  NIL)
                                 ("4" (REVEAL -1)
                                  (("4" (INST - "rho1")
                                    (("4" (GRIND) NIL NIL)) NIL))
                                  NIL)
                                 ("5" (REVEAL -1)
                                  (("5" (INST - "alpha")
                                    (("5" (GRIND) NIL NIL)) NIL))
                                  NIL)
                                 ("6" (REVEAL -1)
                                  (("6" (INST - "alpha")
                                    (("6" (GRIND) NIL NIL)) NIL))
                                  NIL)
                                 ("7" (REVEAL -1)
                                  (("7" (INST - "alpha")
                                    (("7" (GRIND) NIL NIL)) NIL))
                                  NIL)
                                 ("8" (REVEAL -1)
                                  (("8" (INST - "alpha")
                                    (("8" (GRIND) NIL NIL)) NIL))
                                  NIL))
                                NIL))
                              NIL)
                             ("27" (HIDE -6 -7)
                              (("27" (GRIND)
                                (("1" (REVEAL -1)
                                  (("1" (INST - "rho1")
                                    (("1" (GRIND) NIL NIL)) NIL))
                                  NIL)
                                 ("2" (REVEAL -1)
                                  (("2" (INST - "rho1")
                                    (("2" (GRIND) NIL NIL)) NIL))
                                  NIL)
                                 ("3" (REVEAL -1)
                                  (("3" (INST - "rho1")
                                    (("3" (GRIND) NIL NIL)) NIL))
                                  NIL)
                                 ("4" (REVEAL -1)
                                  (("4" (INST - "rho1")
                                    (("4" (GRIND) NIL NIL)) NIL))
                                  NIL)
                                 ("5" (REVEAL -1)
                                  (("5" (INST - "alpha")
                                    (("5" (GRIND) NIL NIL)) NIL))
                                  NIL)
                                 ("6" (REVEAL -1)
                                  (("6" (INST - "alpha")
                                    (("6" (GRIND) NIL NIL)) NIL))
                                  NIL)
                                 ("7" (REVEAL -1)
                                  (("7" (INST - "alpha")
                                    (("7" (GRIND) NIL NIL)) NIL))
                                  NIL)
                                 ("8" (REVEAL -1)
                                  (("8" (INST - "alpha")
                                    (("8" (GRIND) NIL NIL)) NIL))
                                  NIL))
                                NIL))
                              NIL)
                             ("28" (HIDE -3 -6 -8 -9) (("28" (GRIND) NIL NIL))
                              NIL)
                             ("29" (HIDE -3 -7 -8 -9) (("29" (GRIND) NIL NIL))
                              NIL)
                             ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                             ("31" (GRIND) NIL NIL)
                             ("32" (EXPAND "sitc")
                              (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL))
                                NIL))
                              NIL)
                             ("33" (EXPAND "dd2")
                              (("33" (EXPAND "enabled")
                                (("33" (EXPAND "enabled_tick")
                                  (("33" (SKOLEM-TYPEPRED)
                                    (("33" (FLATTEN)
                                      (("33"
                                        (CASE "q!1=alpha")
                                        (("1"
                                          (INST - "alpha")
                                          (("1"
                                            (REPLACE -1 *)
                                            (("1" (GRIND) NIL NIL))
                                            NIL))
                                          NIL)
                                         ("2"
                                          (CASE "q!1=rho1")
                                          (("1"
                                            (REPLACE -1 *)
                                            (("1"
                                              (INST - "rho1")
                                              (("1" (GRIND) NIL NIL))
                                              NIL))
                                            NIL)
                                           ("2"
                                            (CASE "q!1=gamma")
                                            (("1"
                                              (REPLACE -1 *)
                                              (("1"
                                                (INST - "gamma")
                                                (("1" (GRIND) NIL NIL))
                                                NIL))
                                              NIL)
                                             ("2"
                                              (CASE "q!1=rho2")
                                              (("1"
                                                (REPLACE -1 *)
                                                (("1"
                                                  (INST - "rho2")
                                                  (("1" (GRIND) NIL NIL))
                                                  NIL))
                                                NIL)
                                               ("2"
                                                (CASE "q!1=pr")
                                                (("1"
                                                  (REPLACE -1 *)
                                                  (("1"
                                                    (INST - "pr")
                                                    (("1" (GRIND) NIL NIL))
                                                    NIL))
                                                  NIL)
                                                 ("2"
                                                  (CASE "q!1=ps")
                                                  (("1"
                                                    (REPLACE -1 *)
                                                    (("1"
                                                      (INST - "ps")
                                                      (("1" (GRIND) NIL NIL))
                                                      NIL))
                                                    NIL)
                                                   ("2"
                                                    (CASE "q!1=wr")
                                                    (("1"
                                                      (REPLACE -1 *)
                                                      (("1"
                                                        (INST - "wr")
                                                        (("1"
                                                          (GRIND)
                                                          NIL
                                                          NIL))
                                                        NIL))
                                                      NIL)
                                                     ("2"
                                                      (CASE "q!1=ws")
                                                      (("1"
                                                        (REPLACE -1 *)
                                                        (("1"
                                                          (INST - "ws")
                                                          (("1"
                                                            (GRIND)
                                                            NIL
                                                            NIL))
                                                          NIL))
                                                        NIL)
                                                       ("2"
                                                        (CASE "q!1=mu1")
                                                        (("1"
                                                          (REPLACE -1 *)
                                                          (("1"
                                                            (INST - "mu")
                                                            (("1"
                                                              (GRIND)
                                                              NIL
                                                              NIL))
                                                            NIL))
                                                          NIL)
                                                         ("2"
                                                          (CASE "q!1=mu2")
                                                          (("1"
                                                            (REPLACE -1 *)
                                                            (("1"
                                                              (INST
                                                               -
                                                               "omega19")
                                                              (("1"
                                                                (GRIND)
                                                                NIL
                                                                NIL))
                                                              NIL))
                                                            NIL)
                                                           ("2"
                                                            (GRIND)
                                                            NIL
                                                            NIL))
                                                          NIL))
                                                        NIL))
                                                      NIL))
                                                    NIL))
                                                  NIL))
                                                NIL))
                                              NIL))
                                            NIL))
                                          NIL))
                                        NIL))
                                      NIL))
                                    NIL))
                                  NIL))
                                NIL))
                              NIL)
                             ("34" (EXPAND "sitc")
                              (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("2" (ASSERT) NIL NIL))
                      NIL))
                    NIL))
                  NIL))
                NIL))
              NIL))
            NIL)
           ("4" (LEMMA "sim12_4")
            (("4" (INST - "a1!1" "s1!1" "s2!1") (("4" (GRIND) NIL NIL)) NIL))
            NIL)
           ("5" (EXPAND "enabled")
            (("5" (SPLIT)
              (("1" (FLATTEN)
                (("1"
                  (CASE "NOT (a1!1=rho2 or a1!1=gamma or a1!1=pr or a1!1=ps or a1!1=wr or a1!1=ws)")
                  (("1" (HIDE 3 4)
                    (("1" (FLATTEN)
                      (("1" (HIDE -5 -6 -7 -8 -17)
                        (("1" (HIDE -2) (("1" (GRIND) NIL NIL)) NIL)) NIL))
                      NIL))
                    NIL)
                   ("2" (SPLIT -)
                    (("1" (HIDE 3)
                      (("1" (REPLACE -1 *)
                        (("1"
                          (INST + "s2!1" "rho2" "trans(rho2,s2!1)"
                           "trans(rho2,s2!1)")
                          (("1" (BDDSIMP)
                            (("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)
                             ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                             ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                             ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                             ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                             ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                             ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                             ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                             ("25" (GRIND) NIL NIL)
                             ("26" (HIDE -2 -3 -6 -7 -8)
                              (("26" (GRIND) NIL NIL)) NIL)
                             ("27" (HIDE -2 -3 -6 -7 -9)
                              (("27" (GRIND) NIL NIL)) NIL)
                             ("28" (HIDE -2 -3 -6 -8 -9)
                              (("28" (GRIND) NIL NIL)) NIL)
                             ("29" (HIDE -2 -3 -7 -8 -9)
                              (("29" (GRIND) NIL NIL)) NIL)
                             ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                             ("31" (GRIND) NIL NIL)
                             ("32" (EXPAND "sitc")
                              (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL))
                                NIL))
                              NIL)
                             ("33" (GRIND) NIL NIL)
                             ("34" (EXPAND "sitc")
                              (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL)
                     ("2" (REPLACE -1 *)
                      (("2" (HIDE 3)
                        (("2"
                          (INST + "s2!1" "gamma" "trans(gamma,s2!1)"
                           "trans(gamma,s2!1)")
                          (("2" (BDDSIMP)
                            (("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)
                             ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                             ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                             ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                             ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                             ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                             ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                             ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                             ("25" (GRIND) NIL NIL)
                             ("26" (HIDE -2 -3 -6 -7 -8)
                              (("26" (GRIND) NIL NIL)) NIL)
                             ("27" (HIDE -2 -3 -6 -7 -9)
                              (("27" (GRIND) NIL NIL)) NIL)
                             ("28" (HIDE -2 -3 -6 -8 -9)
                              (("28" (GRIND) NIL NIL)) NIL)
                             ("29" (HIDE -2 -3 -7 -8 -9)
                              (("29" (GRIND) NIL NIL)) NIL)
                             ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                             ("31" (GRIND) NIL NIL)
                             ("32" (EXPAND "sitc")
                              (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL))
                                NIL))
                              NIL)
                             ("33" (GRIND) NIL NIL)
                             ("34" (EXPAND "sitc")
                              (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL)
                     ("3" (REPLACE -1 *)
                      (("3" (HIDE 3)
                        (("3"
                          (INST + "s2!1" "pr" "trans(pr,s2!1)"
                           "trans(pr,s2!1)")
                          (("3" (BDDSIMP)
                            (("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)
                             ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                             ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                             ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                             ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                             ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                             ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                             ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                             ("25" (GRIND) NIL NIL)
                             ("26" (HIDE -2 -3 -6 -7 -8)
                              (("26" (GRIND) NIL NIL)) NIL)
                             ("27" (HIDE -2 -3 -6 -7 -9)
                              (("27" (GRIND) NIL NIL)) NIL)
                             ("28" (HIDE -2 -3 -6 -8 -9)
                              (("28" (GRIND) NIL NIL)) NIL)
                             ("29" (HIDE -2 -3 -7 -8 -9)
                              (("29" (GRIND) NIL NIL)) NIL)
                             ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                             ("31" (GRIND) NIL NIL)
                             ("32" (EXPAND "sitc")
                              (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL))
                                NIL))
                              NIL)
                             ("33" (GRIND) NIL NIL)
                             ("34" (EXPAND "sitc")
                              (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL)
                     ("4" (REPLACE -1 *)
                      (("4" (HIDE 3)
                        (("4"
                          (INST + "s2!1" "ps" "trans(ps,s2!1)"
                           "trans(ps,s2!1)")
                          (("4" (BDDSIMP)
                            (("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)
                             ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                             ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                             ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                             ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                             ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                             ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                             ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                             ("25" (GRIND) NIL NIL)
                             ("26" (HIDE -2 -3 -6 -7 -8)
                              (("26" (GRIND) NIL NIL)) NIL)
                             ("27" (HIDE -2 -3 -6 -7 -9)
                              (("27" (GRIND) NIL NIL)) NIL)
                             ("28" (HIDE -2 -3 -6 -8 -9)
                              (("28" (GRIND) NIL NIL)) NIL)
                             ("29" (HIDE -2 -3 -7 -8 -9)
                              (("29" (GRIND) NIL NIL)) NIL)
                             ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                             ("31" (GRIND) NIL NIL)
                             ("32" (EXPAND "sitc")
                              (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL))
                                NIL))
                              NIL)
                             ("33" (GRIND) NIL NIL)
                             ("34" (EXPAND "sitc")
                              (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL)
                     ("5" (REPLACE -1 *)
                      (("5" (HIDE 3)
                        (("5"
                          (INST + "s2!1" "wr" "trans(wr,s2!1)"
                           "trans(wr,s2!1)")
                          (("5" (BDDSIMP)
                            (("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)
                             ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                             ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                             ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                             ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                             ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                             ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                             ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                             ("25" (GRIND) NIL NIL)
                             ("26" (HIDE -2 -3 -6 -7 -8)
                              (("26" (GRIND) NIL NIL)) NIL)
                             ("27" (HIDE -2 -3 -6 -7 -9)
                              (("27" (GRIND) NIL NIL)) NIL)
                             ("28" (HIDE -2 -3 -6 -8 -9)
                              (("28" (GRIND) NIL NIL)) NIL)
                             ("29" (HIDE -2 -3 -7 -8 -9)
                              (("29" (GRIND) NIL NIL)) NIL)
                             ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                             ("31" (GRIND) NIL NIL)
                             ("32" (EXPAND "sitc")
                              (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL))
                                NIL))
                              NIL)
                             ("33" (GRIND) NIL NIL)
                             ("34" (EXPAND "sitc")
                              (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL)
                     ("6" (REPLACE -1 *)
                      (("6" (HIDE 3)
                        (("6"
                          (INST + "s2!1" "ws" "trans(ws,s2!1)"
                           "trans(ws,s2!1)")
                          (("6" (BDDSIMP)
                            (("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)
                             ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                             ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                             ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                             ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                             ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                             ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                             ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                             ("25" (GRIND) NIL NIL)
                             ("26" (HIDE -2 -3 -6 -7 -8)
                              (("26" (GRIND) NIL NIL)) NIL)
                             ("27" (HIDE -2 -3 -6 -7 -9)
                              (("27" (GRIND) NIL NIL)) NIL)
                             ("28" (HIDE -2 -3 -6 -8 -9)
                              (("28" (GRIND) NIL NIL)) NIL)
                             ("29" (HIDE -2 -3 -7 -8 -9)
                              (("29" (GRIND) NIL NIL)) NIL)
                             ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                             ("31" (GRIND) NIL NIL)
                             ("32" (EXPAND "sitc")
                              (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL))
                                NIL))
                              NIL)
                             ("33" (GRIND) NIL NIL)
                             ("34" (EXPAND "sitc")
                              (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL))
                  NIL))
                NIL)
               ("2" (FLATTEN)
                (("2" (HIDE 2)
                  (("2" (CASE "a1!1=tick")
                    (("1" (REPLACE -1 *)
                      (("1"
                        (INST + "s2!1" "tick" "trans(tick,s2!1)"
                         "trans(tick,s2!1)")
                        (("1" (BDDSIMP)
                          (("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)
                           ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                           ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                           ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                           ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                           ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                           ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                           ("23" (GRIND) NIL NIL)
                           ("24" (HIDE -6 -7) (("24" (GRIND) NIL NIL)) NIL)
                           ("25" (HIDE -6 -7) (("25" (GRIND) NIL NIL)) NIL)
                           ("26" (HIDE -6 -7 -8)
                            (("26" (GRIND)
                              (("1" (REVEAL -1)
                                (("1" (INST - "gamma") (("1" (GRIND) NIL NIL))
                                  NIL))
                                NIL)
                               ("2" (REVEAL -1)
                                (("2" (INST - "gamma") (("2" (GRIND) NIL NIL))
                                  NIL))
                                NIL)
                               ("3" (REVEAL -1)
                                (("3" (INST - "gamma") (("3" (GRIND) NIL NIL))
                                  NIL))
                                NIL)
                               ("4" (REVEAL -1)
                                (("4" (INST - "gamma") (("4" (GRIND) NIL NIL))
                                  NIL))
                                NIL)
                               ("5" (REVEAL -1)
                                (("5" (INST - "rho2") (("5" (GRIND) NIL NIL))
                                  NIL))
                                NIL)
                               ("6" (REVEAL -1)
                                (("6" (INST - "rho2") (("6" (GRIND) NIL NIL))
                                  NIL))
                                NIL)
                               ("7" (REVEAL -1)
                                (("7" (INST - "rho2") (("7" (GRIND) NIL NIL))
                                  NIL))
                                NIL)
                               ("8" (REVEAL -1)
                                (("8" (INST - "rho2") (("8" (GRIND) NIL NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL)
                           ("27" (HIDE -6 -7 -9) (("27" (GRIND) NIL NIL)) NIL)
                           ("28" (HIDE -6 -8 -9) (("28" (GRIND) NIL NIL)) NIL)
                           ("29" (HIDE -7 -8 -9) (("29" (GRIND) NIL NIL)) NIL)
                           ("30" (HIDE -) (("30" (GRIND) NIL NIL)) NIL)
                           ("31" (GRIND) NIL NIL)
                           ("32" (EXPAND "sitc")
                            (("32" (EXPAND "tc") (("32" (PROPAX) NIL NIL))
                              NIL))
                            NIL)
                           ("33" (EXPAND "dd2")
                            (("33" (EXPAND "enabled")
                              (("33" (EXPAND "enabled_tick")
                                (("33" (SKOLEM-TYPEPRED)
                                  (("33" (FLATTEN)
                                    (("33" (CASE "q!1=alpha")
                                      (("1"
                                        (REPLACE -1 *)
                                        (("1"
                                          (INST - "alpha")
                                          (("1" (GRIND) NIL NIL))
                                          NIL))
                                        NIL)
                                       ("2"
                                        (CASE "q!1=rho1")
                                        (("1"
                                          (REPLACE -1 *)
                                          (("1"
                                            (INST - "rho1")
                                            (("1" (GRIND) NIL NIL))
                                            NIL))
                                          NIL)
                                         ("2"
                                          (CASE "q!1=gamma")
                                          (("1"
                                            (REPLACE -1 *)
                                            (("1"
                                              (INST - "gamma")
                                              (("1" (GRIND) NIL NIL))
                                              NIL))
                                            NIL)
                                           ("2"
                                            (CASE "q!1=rho2")
                                            (("1"
                                              (REPLACE -1 *)
                                              (("1"
                                                (INST - "rho2")
                                                (("1" (GRIND) NIL NIL))
                                                NIL))
                                              NIL)
                                             ("2"
                                              (CASE "q!1=pr")
                                              (("1"
                                                (REPLACE -1 *)
                                                (("1"
                                                  (INST - "pr")
                                                  (("1" (GRIND) NIL NIL))
                                                  NIL))
                                                NIL)
                                               ("2"
                                                (CASE "q!1=ps")
                                                (("1"
                                                  (REPLACE -1 *)
                                                  (("1"
                                                    (INST - "ps")
                                                    (("1" (GRIND) NIL NIL))
                                                    NIL))
                                                  NIL)
                                                 ("2"
                                                  (CASE "q!1=wr")
                                                  (("1"
                                                    (REPLACE -1 *)
                                                    (("1"
                                                      (INST - "wr")
                                                      (("1" (GRIND) NIL NIL))
                                                      NIL))
                                                    NIL)
                                                   ("2"
                                                    (CASE "q!1=ws")
                                                    (("1"
                                                      (REPLACE -1 *)
                                                      (("1"
                                                        (INST - "ws")
                                                        (("1"
                                                          (GRIND)
                                                          NIL
                                                          NIL))
                                                        NIL))
                                                      NIL)
                                                     ("2"
                                                      (CASE "q!1=mu1")
                                                      (("1"
                                                        (REPLACE -1 *)
                                                        (("1"
                                                          (INST - "mu")
                                                          (("1"
                                                            (GRIND)
                                                            NIL
                                                            NIL))
                                                          NIL))
                                                        NIL)
                                                       ("2"
                                                        (CASE "q!1=mu2")
                                                        (("1"
                                                          (REPLACE -1 *)
                                                          (("1"
                                                            (INST - "omega19")
                                                            (("1"
                                                              (GRIND)
                                                              NIL
                                                              NIL))
                                                            NIL))
                                                          NIL)
                                                         ("2"
                                                          (GRIND)
                                                          NIL
                                                          NIL))
                                                        NIL))
                                                      NIL))
                                                    NIL))
                                                  NIL))
                                                NIL))
                                              NIL))
                                            NIL))
                                          NIL))
                                        NIL))
                                      NIL))
                                    NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL)
                           ("34" (EXPAND "sitc")
                            (("34" (EXPAND "tc") (("34" (PROPAX) NIL NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL)
                     ("2" (ASSERT) NIL NIL))
                    NIL))
                  NIL))
                NIL))
              NIL))
            NIL))
          NIL))
        NIL))
      NIL))
    NIL))
  NIL)
 (|Sim2_1| "" (EXPAND "converse")
  (("" (EXPAND "wsesim?")
    (("" (SKOLEM-TYPEPRED)
      (("" (EXPAND "dd2")
        (("" (FLATTEN)
          (("" (SPLIT -)
            (("1" (EXPAND "enabled")
              (("1" (SPLIT)
                (("1" (FLATTEN)
                  (("1"
                    (CASE "Not (a1!1=mu1 or a1!1=pr or a1!1=ps or a1!1=wr or a1!1=ws)")
                    (("1" (HIDE 3 4)
                      (("1" (FLATTEN) (("1" (GRIND) NIL NIL)) NIL)) NIL)
                     ("2" (BDDSIMP)
                      (("1" (HIDE 2)
                        (("1"
                          (INST + "s2!1" "mu" "trans(mu,s2!1)"
                           "trans(mu,s2!1)")
                          (("1" (CASE "a1!1=mu1")
                            (("1" (REPLACE -1 *)
                              (("1" (BDDSIMP)
                                (("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)
                                 ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                                 ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                                 ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                                 ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                                 ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                                 ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                                 ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                                 ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                                 ("27" (GRIND) NIL NIL) ("28" (GRIND) NIL NIL)
                                 ("29" (GRIND) NIL NIL) ("30" (GRIND) NIL NIL)
                                 ("31" (HIDE -3 -4) (("31" (GRIND) NIL NIL))
                                  NIL)
                                 ("32" (GRIND) NIL NIL)
                                 ("33" (EXPAND "sitc")
                                  (("33" (EXPAND "tc")
                                    (("33" (PROPAX) NIL NIL)) NIL))
                                  NIL)
                                 ("34" (GRIND) NIL NIL)
                                 ("35" (EXPAND "sitc")
                                  (("35" (EXPAND "tc")
                                    (("35" (PROPAX) NIL NIL)) NIL))
                                  NIL))
                                NIL))
                              NIL)
                             ("2" (HIDE 2) (("2" (GRIND) NIL NIL)) NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("2" (HIDE 2)
                        (("2"
                          (INST + "s2!1" "pr" "trans(pr,s2!1)"
                           "trans(pr,s2!1)")
                          (("2" (CASE "a1!1=pr")
                            (("1" (REPLACE -1 *)
                              (("1" (BDDSIMP)
                                (("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)
                                 ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                                 ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                                 ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                                 ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                                 ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                                 ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                                 ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                                 ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                                 ("27" (GRIND) NIL NIL) ("28" (GRIND) NIL NIL)
                                 ("29" (GRIND) NIL NIL) ("30" (GRIND) NIL NIL)
                                 ("31" (HIDE -3 -4) (("31" (GRIND) NIL NIL))
                                  NIL)
                                 ("32" (GRIND) NIL NIL)
                                 ("33" (EXPAND "sitc")
                                  (("33" (EXPAND "tc")
                                    (("33" (PROPAX) NIL NIL)) NIL))
                                  NIL)
                                 ("34" (GRIND) NIL NIL)
                                 ("35" (EXPAND "sitc")
                                  (("35" (EXPAND "tc")
                                    (("35" (PROPAX) NIL NIL)) NIL))
                                  NIL))
                                NIL))
                              NIL)
                             ("2" (HIDE 2) (("2" (GRIND) NIL NIL)) NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("3" (HIDE 2)
                        (("3"
                          (INST + "s2!1" "ps" "trans(ps,s2!1)"
                           "trans(ps,s2!1)")
                          (("3" (CASE "a1!1=ps")
                            (("1" (REPLACE -1 *)
                              (("1" (BDDSIMP)
                                (("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)
                                 ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                                 ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                                 ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                                 ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                                 ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                                 ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                                 ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                                 ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                                 ("27" (GRIND) NIL NIL) ("28" (GRIND) NIL NIL)
                                 ("29" (GRIND) NIL NIL) ("30" (GRIND) NIL NIL)
                                 ("31" (HIDE -3 -4) (("31" (GRIND) NIL NIL))
                                  NIL)
                                 ("32" (GRIND) NIL NIL)
                                 ("33" (EXPAND "sitc")
                                  (("33" (EXPAND "tc")
                                    (("33" (PROPAX) NIL NIL)) NIL))
                                  NIL)
                                 ("34" (GRIND) NIL NIL)
                                 ("35" (EXPAND "sitc")
                                  (("35" (EXPAND "tc")
                                    (("35" (PROPAX) NIL NIL)) NIL))
                                  NIL))
                                NIL))
                              NIL)
                             ("2" (HIDE 2) (("2" (GRIND) NIL NIL)) NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("4" (HIDE 2)
                        (("4"
                          (INST + "s2!1" "wr" "trans(wr,s2!1)"
                           "trans(wr,s2!1)")
                          (("4" (CASE "a1!1=wr")
                            (("1" (REPLACE -1 *)
                              (("1" (BDDSIMP)
                                (("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)
                                 ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                                 ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                                 ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                                 ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                                 ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                                 ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                                 ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                                 ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                                 ("27" (GRIND) NIL NIL) ("28" (GRIND) NIL NIL)
                                 ("29" (GRIND) NIL NIL) ("30" (GRIND) NIL NIL)
                                 ("31" (HIDE -3 -4) (("31" (GRIND) NIL NIL))
                                  NIL)
                                 ("32" (GRIND) NIL NIL)
                                 ("33" (EXPAND "sitc")
                                  (("33" (EXPAND "tc")
                                    (("33" (PROPAX) NIL NIL)) NIL))
                                  NIL)
                                 ("34" (GRIND) NIL NIL)
                                 ("35" (EXPAND "sitc")
                                  (("35" (EXPAND "tc")
                                    (("35" (PROPAX) NIL NIL)) NIL))
                                  NIL))
                                NIL))
                              NIL)
                             ("2" (HIDE 2) (("2" (ASSERT) NIL NIL)) NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("5" (HIDE 2)
                        (("5"
                          (INST + "s2!1" "ws" "trans(ws,s2!1)"
                           "trans(ws,s2!1)")
                          (("5" (CASE "a1!1=ws")
                            (("1" (REPLACE -1 *)
                              (("1" (BDDSIMP)
                                (("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)
                                 ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                                 ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                                 ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                                 ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                                 ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                                 ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                                 ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                                 ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                                 ("27" (GRIND) NIL NIL) ("28" (GRIND) NIL NIL)
                                 ("29" (GRIND) NIL NIL) ("30" (GRIND) NIL NIL)
                                 ("31" (HIDE -3 -4) (("31" (GRIND) NIL NIL))
                                  NIL)
                                 ("32" (GRIND) NIL NIL)
                                 ("33" (EXPAND "sitc")
                                  (("33" (EXPAND "tc")
                                    (("33" (PROPAX) NIL NIL)) NIL))
                                  NIL)
                                 ("34" (GRIND) NIL NIL)
                                 ("35" (EXPAND "sitc")
                                  (("35" (EXPAND "tc")
                                    (("35" (PROPAX) NIL NIL)) NIL))
                                  NIL))
                                NIL))
                              NIL)
                             ("2" (HIDE 2) (("2" (ASSERT) NIL NIL)) NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL))
                  NIL)
                 ("2" (FLATTEN)
                  (("2" (HIDE 2)
                    (("2"
                      (INST + "s2!1" "tick" "trans(tick,s2!1)"
                       "trans(tick,s2!1)")
                      (("2" (CASE "a1!1=tick")
                        (("1" (REPLACE -1 *)
                          (("1" (BDDSIMP)
                            (("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)
                             ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                             ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                             ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                             ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                             ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                             ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                             ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                             ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                             ("27" (GRIND) NIL NIL)
                             ("28" (EXPAND "enabled_tick")
                              (("28" (GRIND) NIL NIL)) NIL)
                             ("29" (GRIND) NIL NIL) ("30" (GRIND) NIL NIL)
                             ("31" (HIDE -3 -4) (("31" (GRIND) NIL NIL)) NIL)
                             ("32" (EXPAND "enabled_tick")
                              (("32" (GRIND) NIL NIL)) NIL)
                             ("33" (EXPAND "sitc")
                              (("33" (EXPAND "tc") (("33" (PROPAX) NIL NIL))
                                NIL))
                              NIL)
                             ("34" (EXPAND "dd1")
                              (("34" (EXPAND "enabled")
                                (("34" (EXPAND "enabled_tick")
                                  (("34" (SKOLEM-TYPEPRED)
                                    (("34" (FLATTEN)
                                      (("34"
                                        (CASE "q!1=alpha")
                                        (("1"
                                          (REPLACE -1 *)
                                          (("1"
                                            (INST - "alpha")
                                            (("1" (GRIND) NIL NIL))
                                            NIL))
                                          NIL)
                                         ("2"
                                          (CASE "q!1=rho1")
                                          (("1"
                                            (REPLACE -1 *)
                                            (("1"
                                              (INST - "rho1")
                                              (("1" (GRIND) NIL NIL))
                                              NIL))
                                            NIL)
                                           ("2"
                                            (CASE "q!1=gamma")
                                            (("1"
                                              (REPLACE -1 *)
                                              (("1"
                                                (INST - "gamma")
                                                (("1" (GRIND) NIL NIL))
                                                NIL))
                                              NIL)
                                             ("2"
                                              (CASE "q!1=rho2")
                                              (("1"
                                                (REPLACE -1 *)
                                                (("1"
                                                  (INST - "rho2")
                                                  (("1" (GRIND) NIL NIL))
                                                  NIL))
                                                NIL)
                                               ("2"
                                                (CASE "q!1=pr")
                                                (("1"
                                                  (REPLACE -1 *)
                                                  (("1"
                                                    (INST - "pr")
                                                    (("1" (GRIND) NIL NIL))
                                                    NIL))
                                                  NIL)
                                                 ("2"
                                                  (CASE "q!1=ps")
                                                  (("1"
                                                    (REPLACE -1 *)
                                                    (("1"
                                                      (INST - "ps")
                                                      (("1" (GRIND) NIL NIL))
                                                      NIL))
                                                    NIL)
                                                   ("2"
                                                    (CASE "q!1=wr")
                                                    (("1"
                                                      (REPLACE -1 *)
                                                      (("1"
                                                        (INST - "wr")
                                                        (("1"
                                                          (GRIND)
                                                          NIL
                                                          NIL))
                                                        NIL))
                                                      NIL)
                                                     ("2"
                                                      (CASE "q!1=ws")
                                                      (("1"
                                                        (REPLACE -1 *)
                                                        (("1"
                                                          (INST - "ws")
                                                          (("1"
                                                            (GRIND)
                                                            NIL
                                                            NIL))
                                                          NIL))
                                                        NIL)
                                                       ("2"
                                                        (CASE "q!1=omega29")
                                                        (("1"
                                                          (REPLACE -1 *)
                                                          (("1"
                                                            (INST - "mu1")
                                                            (("1"
                                                              (GRIND)
                                                              NIL
                                                              NIL))
                                                            NIL))
                                                          NIL)
                                                         ("2"
                                                          (CASE "q!1=omega19")
                                                          (("1"
                                                            (REPLACE -1 *)
                                                            (("1"
                                                              (INST - "mu2")
                                                              (("1"
                                                                (GRIND)
                                                                NIL
                                                                NIL))
                                                              NIL))
                                                            NIL)
                                                           ("2"
                                                            (CASE "q!1=mu")
                                                            (("1"
                                                              (REPLACE -1 *)
                                                              (("1"
                                                                (INST - "mu1")
                                                                (("1"
                                                                  (GRIND)
                                                                  NIL
                                                                  NIL))
                                                                NIL))
                                                              NIL)
                                                             ("2"
                                                              (GRIND)
                                                              NIL
                                                              NIL))
                                                            NIL))
                                                          NIL))
                                                        NIL))
                                                      NIL))
                                                    NIL))
                                                  NIL))
                                                NIL))
                                              NIL))
                                            NIL))
                                          NIL))
                                        NIL))
                                      NIL))
                                    NIL))
                                  NIL))
                                NIL))
                              NIL)
                             ("35" (EXPAND "sitc")
                              (("35" (EXPAND "tc") (("35" (PROPAX) NIL NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL)
                         ("2" (ASSERT) NIL NIL))
                        NIL))
                      NIL))
                    NIL))
                  NIL))
                NIL))
              NIL)
             ("2" (EXPAND "enabled")
              (("2" (SPLIT -2)
                (("1" (FLATTEN)
                  (("1"
                    (CASE "NOT (a1!1=mu1 or a1!1=pr or a1!1=ps or a1!1=wr or a1!1=ws)")
                    (("1" (HIDE 3 4)
                      (("1" (FLATTEN)
                        (("1" (HIDE -7 -8 -9 -10 -19) (("1" (GRIND) NIL NIL))
                          NIL))
                        NIL))
                      NIL)
                     ("2" (SPLIT -1)
                      (("1" (LEMMA "sim21_2121")
                        (("1" (INST - "a1!1" "s2!1" "s1!1")
                          (("1" (ASSERT) (("1" (GRIND) NIL NIL)) NIL)) NIL))
                        NIL)
                       ("2" (HIDE 3)
                        (("2" (REPLACE -1 *)
                          (("2"
                            (INST + "s2!1" "pr" "trans(pr,s2!1)"
                             "trans(pr,s2!1)")
                            (("2" (BDDSIMP)
                              (("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)
                               ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                               ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                               ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                               ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                               ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                               ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                               ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                               ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                               ("27" (GRIND) NIL NIL) ("28" (GRIND) NIL NIL)
                               ("29" (GRIND) NIL NIL) ("30" (GRIND) NIL NIL)
                               ("31" (HIDE -2 -3) (("31" (GRIND) NIL NIL))
                                NIL)
                               ("32" (GRIND) NIL NIL)
                               ("33" (EXPAND "sitc")
                                (("33" (EXPAND "tc") (("33" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("34" (GRIND) NIL NIL)
                               ("35" (EXPAND "sitc")
                                (("35" (EXPAND "tc") (("35" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("36" (GRIND) NIL NIL) ("37" (GRIND) NIL NIL)
                               ("38" (GRIND) NIL NIL) ("39" (GRIND) NIL NIL)
                               ("40" (GRIND) NIL NIL) ("41" (GRIND) NIL NIL)
                               ("42" (GRIND) NIL NIL)
                               ("43" (EXPAND "ps1")
                                (("43" (EXPAND "ps2")
                                  (("43" (EXPAND "trans")
                                    (("43" (PROPAX) NIL NIL)) NIL))
                                  NIL))
                                NIL)
                               ("44" (EXPAND "trans")
                                (("44" (PROPAX) NIL NIL)) NIL)
                               ("45" (GRIND) NIL NIL) ("46" (GRIND) NIL NIL)
                               ("47" (GRIND) NIL NIL) ("48" (GRIND) NIL NIL)
                               ("49" (GRIND) NIL NIL) ("50" (GRIND) NIL NIL)
                               ("51" (GRIND) NIL NIL) ("52" (GRIND) NIL NIL)
                               ("53" (GRIND) NIL NIL) ("54" (GRIND) NIL NIL)
                               ("55" (GRIND) NIL NIL) ("56" (GRIND) NIL NIL)
                               ("57" (GRIND) NIL NIL) ("58" (GRIND) NIL NIL)
                               ("59" (GRIND) NIL NIL) ("60" (GRIND) NIL NIL)
                               ("61" (GRIND) NIL NIL) ("62" (GRIND) NIL NIL)
                               ("63" (GRIND) NIL NIL) ("64" (GRIND) NIL NIL)
                               ("65" (GRIND) NIL NIL)
                               ("66" (HIDE -2 -3) (("66" (GRIND) NIL NIL))
                                NIL)
                               ("67" (HIDE -2 -3) (("67" (GRIND) NIL NIL))
                                NIL)
                               ("68" (EXPAND "sitc")
                                (("68" (EXPAND "tc") (("68" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("69" (GRIND) NIL NIL)
                               ("70" (EXPAND "sitc")
                                (("70" (EXPAND "tc") (("70" (PROPAX) NIL NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("3" (HIDE 3)
                        (("3" (REPLACE -1 *)
                          (("3"
                            (INST + "s2!1" "ps" "trans(ps,s2!1)"
                             "trans(ps,s2!1)")
                            (("3" (BDDSIMP)
                              (("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)
                               ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                               ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                               ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                               ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                               ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                               ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                               ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                               ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                               ("27" (GRIND) NIL NIL) ("28" (GRIND) NIL NIL)
                               ("29" (GRIND) NIL NIL) ("30" (GRIND) NIL NIL)
                               ("31" (HIDE -2 -3) (("31" (GRIND) NIL NIL))
                                NIL)
                               ("32" (GRIND) NIL NIL)
                               ("33" (EXPAND "sitc")
                                (("33" (EXPAND "tc") (("33" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("34" (GRIND) NIL NIL)
                               ("35" (EXPAND "sitc")
                                (("35" (EXPAND "tc") (("35" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("36" (GRIND) NIL NIL) ("37" (GRIND) NIL NIL)
                               ("38" (GRIND) NIL NIL) ("39" (GRIND) NIL NIL)
                               ("40" (GRIND) NIL NIL) ("41" (GRIND) NIL NIL)
                               ("42" (GRIND) NIL NIL) ("43" (GRIND) NIL NIL)
                               ("44" (GRIND) NIL NIL) ("45" (GRIND) NIL NIL)
                               ("46" (GRIND) NIL NIL) ("47" (GRIND) NIL NIL)
                               ("48" (GRIND) NIL NIL) ("49" (GRIND) NIL NIL)
                               ("50" (GRIND) NIL NIL) ("51" (GRIND) NIL NIL)
                               ("52" (GRIND) NIL NIL) ("53" (GRIND) NIL NIL)
                               ("54" (GRIND) NIL NIL) ("55" (GRIND) NIL NIL)
                               ("56" (GRIND) NIL NIL) ("57" (GRIND) NIL NIL)
                               ("58" (GRIND) NIL NIL) ("59" (GRIND) NIL NIL)
                               ("60" (GRIND) NIL NIL) ("61" (GRIND) NIL NIL)
                               ("62" (GRIND) NIL NIL) ("63" (GRIND) NIL NIL)
                               ("64" (GRIND) NIL NIL) ("65" (GRIND) NIL NIL)
                               ("66" (GRIND) NIL NIL) ("67" (GRIND) NIL NIL)
                               ("68" (EXPAND "sitc")
                                (("68" (EXPAND "tc") (("68" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("69" (GRIND) NIL NIL)
                               ("70" (EXPAND "sitc")
                                (("70" (EXPAND "tc") (("70" (PROPAX) NIL NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("4" (HIDE 3)
                        (("4" (REPLACE -1 *)
                          (("4"
                            (INST + "s2!1" "wr" "trans(wr,s2!1)"
                             "trans(wr,s2!1)")
                            (("4" (BDDSIMP)
                              (("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)
                               ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                               ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                               ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                               ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                               ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                               ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                               ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                               ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                               ("27" (GRIND) NIL NIL) ("28" (GRIND) NIL NIL)
                               ("29" (GRIND) NIL NIL) ("30" (GRIND) NIL NIL)
                               ("31" (GRIND) NIL NIL) ("32" (GRIND) NIL NIL)
                               ("33" (EXPAND "sitc")
                                (("33" (EXPAND "tc") (("33" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("34" (GRIND) NIL NIL)
                               ("35" (EXPAND "sitc")
                                (("35" (EXPAND "tc") (("35" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("36" (GRIND) NIL NIL) ("37" (GRIND) NIL NIL)
                               ("38" (GRIND) NIL NIL) ("39" (GRIND) NIL NIL)
                               ("40" (GRIND) NIL NIL) ("41" (GRIND) NIL NIL)
                               ("42" (GRIND) NIL NIL) ("43" (GRIND) NIL NIL)
                               ("44" (GRIND) NIL NIL) ("45" (GRIND) NIL NIL)
                               ("46" (GRIND) NIL NIL) ("47" (GRIND) NIL NIL)
                               ("48" (GRIND) NIL NIL) ("49" (GRIND) NIL NIL)
                               ("50" (GRIND) NIL NIL) ("51" (GRIND) NIL NIL)
                               ("52" (GRIND) NIL NIL) ("53" (GRIND) NIL NIL)
                               ("54" (GRIND) NIL NIL) ("55" (GRIND) NIL NIL)
                               ("56" (GRIND) NIL NIL) ("57" (GRIND) NIL NIL)
                               ("58" (GRIND) NIL NIL) ("59" (GRIND) NIL NIL)
                               ("60" (GRIND) NIL NIL) ("61" (GRIND) NIL NIL)
                               ("62" (GRIND) NIL NIL) ("63" (GRIND) NIL NIL)
                               ("64" (GRIND) NIL NIL) ("65" (GRIND) NIL NIL)
                               ("66" (GRIND) NIL NIL) ("67" (GRIND) NIL NIL)
                               ("68" (EXPAND "sitc")
                                (("68" (EXPAND "tc") (("68" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("69" (GRIND) NIL NIL)
                               ("70" (EXPAND "sitc")
                                (("70" (EXPAND "tc") (("70" (PROPAX) NIL NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("5" (REPLACE -1 *)
                        (("5" (HIDE 3)
                          (("5"
                            (INST + "s2!1" "ws" "trans(ws,s2!1)"
                             "trans(ws,s2!1)")
                            (("5" (BDDSIMP)
                              (("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)
                               ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                               ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                               ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                               ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                               ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                               ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                               ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                               ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                               ("27" (GRIND) NIL NIL) ("28" (GRIND) NIL NIL)
                               ("29" (GRIND) NIL NIL) ("30" (GRIND) NIL NIL)
                               ("31" (GRIND) NIL NIL) ("32" (GRIND) NIL NIL)
                               ("33" (EXPAND "sitc")
                                (("33" (EXPAND "tc") (("33" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("34" (GRIND) NIL NIL)
                               ("35" (EXPAND "sitc")
                                (("35" (EXPAND "tc") (("35" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("36" (GRIND) NIL NIL) ("37" (GRIND) NIL NIL)
                               ("38" (GRIND) NIL NIL) ("39" (GRIND) NIL NIL)
                               ("40" (GRIND) NIL NIL) ("41" (GRIND) NIL NIL)
                               ("42" (GRIND) NIL NIL) ("43" (GRIND) NIL NIL)
                               ("44" (GRIND) NIL NIL) ("45" (GRIND) NIL NIL)
                               ("46" (GRIND) NIL NIL) ("47" (GRIND) NIL NIL)
                               ("48" (GRIND) NIL NIL) ("49" (GRIND) NIL NIL)
                               ("50" (GRIND) NIL NIL) ("51" (GRIND) NIL NIL)
                               ("52" (GRIND) NIL NIL) ("53" (GRIND) NIL NIL)
                               ("54" (GRIND) NIL NIL) ("55" (GRIND) NIL NIL)
                               ("56" (GRIND) NIL NIL) ("57" (GRIND) NIL NIL)
                               ("58" (GRIND) NIL NIL) ("59" (GRIND) NIL NIL)
                               ("60" (GRIND) NIL NIL) ("61" (GRIND) NIL NIL)
                               ("62" (GRIND) NIL NIL) ("63" (GRIND) NIL NIL)
                               ("64" (GRIND) NIL NIL) ("65" (GRIND) NIL NIL)
                               ("66" (GRIND) NIL NIL) ("67" (GRIND) NIL NIL)
                               ("68" (EXPAND "sitc")
                                (("68" (EXPAND "tc") (("68" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("69" (GRIND) NIL NIL)
                               ("70" (EXPAND "sitc")
                                (("70" (EXPAND "tc") (("70" (PROPAX) NIL NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL))
                  NIL)
                 ("2" (FLATTEN)
                  (("2" (HIDE 2)
                    (("2" (CASE "a1!1=tick")
                      (("1" (REPLACE -1 *)
                        (("1" (LEMMA "sim21_221")
                          (("1" (INST - "a1!1" "s2!1" "s1!1")
                            (("1" (GRIND) NIL NIL)) NIL))
                          NIL))
                        NIL)
                       ("2" (ASSERT) NIL NIL))
                      NIL))
                    NIL))
                  NIL))
                NIL))
              NIL)
             ("3" (EXPAND "enabled")
              (("3" (SPLIT)
                (("1" (FLATTEN)
                  (("1"
                    (CASE "NOT (a1!1=alpha or a1!1=rho1 or a1!1=ps or a1!1=pr or a1!1=wr or a1!1=ws)")
                    (("1" (HIDE 3 4) (("1" (GRIND) NIL NIL)) NIL)
                     ("2" (BDDSIMP)
                      (("1" (HIDE 2)
                        (("1"
                          (INST + "s2!1" "alpha" "trans(alpha,s2!1)"
                           "trans(alpha,s2!1)")
                          (("1" (CASE "a1!1=alpha")
                            (("1" (REPLACE -1 *)
                              (("1" (BDDSIMP)
                                (("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)
                                 ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                                 ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                                 ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                                 ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                                 ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                                 ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                                 ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                                 ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                                 ("27" (GRIND) NIL NIL) ("28" (GRIND) NIL NIL)
                                 ("29" (GRIND) NIL NIL) ("30" (GRIND) NIL NIL)
                                 ("31" (GRIND) NIL NIL) ("32" (GRIND) NIL NIL)
                                 ("33" (EXPAND "sitc")
                                  (("33" (EXPAND "tc")
                                    (("33" (PROPAX) NIL NIL)) NIL))
                                  NIL)
                                 ("34" (GRIND) NIL NIL)
                                 ("35" (EXPAND "sitc")
                                  (("35" (EXPAND "tc")
                                    (("35" (PROPAX) NIL NIL)) NIL))
                                  NIL))
                                NIL))
                              NIL)
                             ("2" (HIDE 2) (("2" (GRIND) NIL NIL)) NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("2" (HIDE 2)
                        (("2" (CASE "a1!1=rho1")
                          (("1" (REPLACE -1 *)
                            (("1"
                              (INST + "s2!1" "rho1" "trans(rho1,s2!1)"
                               "trans(rho1,s2!1)")
                              (("1" (BDDSIMP)
                                (("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)
                                 ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                                 ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                                 ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                                 ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                                 ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                                 ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                                 ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                                 ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                                 ("27" (GRIND) NIL NIL) ("28" (GRIND) NIL NIL)
                                 ("29" (GRIND) NIL NIL) ("30" (GRIND) NIL NIL)
                                 ("31" (GRIND) NIL NIL) ("32" (GRIND) NIL NIL)
                                 ("33" (EXPAND "sitc")
                                  (("33" (EXPAND "tc")
                                    (("33" (PROPAX) NIL NIL)) NIL))
                                  NIL)
                                 ("34" (GRIND) NIL NIL)
                                 ("35" (EXPAND "sitc")
                                  (("35" (EXPAND "tc")
                                    (("35" (PROPAX) NIL NIL)) NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL)
                           ("2" (HIDE 2) (("2" (GRIND) NIL NIL)) NIL))
                          NIL))
                        NIL)
                       ("3" (HIDE 2)
                        (("3"
                          (INST + "s2!1" "ps" "trans(ps,s2!1)"
                           "trans(ps,s2!1)")
                          (("3" (CASE "a1!1=ps")
                            (("1" (REPLACE -1 *)
                              (("1" (BDDSIMP)
                                (("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)
                                 ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                                 ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                                 ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                                 ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                                 ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                                 ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                                 ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                                 ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                                 ("27" (GRIND) NIL NIL) ("28" (GRIND) NIL NIL)
                                 ("29" (GRIND) NIL NIL) ("30" (GRIND) NIL NIL)
                                 ("31" (GRIND) NIL NIL) ("32" (GRIND) NIL NIL)
                                 ("33" (EXPAND "sitc")
                                  (("33" (EXPAND "tc")
                                    (("33" (PROPAX) NIL NIL)) NIL))
                                  NIL)
                                 ("34" (GRIND) NIL NIL)
                                 ("35" (EXPAND "sitc")
                                  (("35" (EXPAND "tc")
                                    (("35" (PROPAX) NIL NIL)) NIL))
                                  NIL))
                                NIL))
                              NIL)
                             ("2" (HIDE 2) (("2" (GRIND) NIL NIL)) NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("4" (HIDE 2)
                        (("4"
                          (INST + "s2!1" "pr" "trans(pr,s2!1)"
                           "trans(pr,s2!1)")
                          (("4" (CASE "a1!1=pr")
                            (("1" (REPLACE -1 *)
                              (("1" (BDDSIMP)
                                (("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)
                                 ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                                 ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                                 ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                                 ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                                 ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                                 ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                                 ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                                 ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                                 ("27" (GRIND) NIL NIL) ("28" (GRIND) NIL NIL)
                                 ("29" (GRIND) NIL NIL) ("30" (GRIND) NIL NIL)
                                 ("31" (GRIND) NIL NIL) ("32" (GRIND) NIL NIL)
                                 ("33" (EXPAND "sitc")
                                  (("33" (EXPAND "tc")
                                    (("33" (PROPAX) NIL NIL)) NIL))
                                  NIL)
                                 ("34" (GRIND) NIL NIL)
                                 ("35" (EXPAND "sitc")
                                  (("35" (EXPAND "tc")
                                    (("35" (PROPAX) NIL NIL)) NIL))
                                  NIL))
                                NIL))
                              NIL)
                             ("2" (HIDE 2) (("2" (GRIND) NIL NIL)) NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("5" (HIDE 2)
                        (("5"
                          (INST + "s2!1" "wr" "trans(wr,s2!1)"
                           "trans(wr,s2!1)")
                          (("5" (CASE "a1!1=wr")
                            (("1" (REPLACE -1 *)
                              (("1" (BDDSIMP)
                                (("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)
                                 ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                                 ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                                 ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                                 ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                                 ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                                 ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                                 ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                                 ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                                 ("27" (GRIND) NIL NIL) ("28" (GRIND) NIL NIL)
                                 ("29" (GRIND) NIL NIL) ("30" (GRIND) NIL NIL)
                                 ("31" (GRIND) NIL NIL) ("32" (GRIND) NIL NIL)
                                 ("33" (EXPAND "sitc")
                                  (("33" (EXPAND "tc")
                                    (("33" (PROPAX) NIL NIL)) NIL))
                                  NIL)
                                 ("34" (GRIND) NIL NIL)
                                 ("35" (EXPAND "sitc")
                                  (("35" (EXPAND "tc")
                                    (("35" (PROPAX) NIL NIL)) NIL))
                                  NIL))
                                NIL))
                              NIL)
                             ("2" (HIDE 2) (("2" (GRIND) NIL NIL)) NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("6" (HIDE 2)
                        (("6"
                          (INST + "s2!1" "ws" "trans(ws,s2!1)"
                           "trans(ws,s2!1)")
                          (("6" (CASE "a1!1=ws")
                            (("1" (REPLACE -1 *)
                              (("1" (BDDSIMP)
                                (("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)
                                 ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                                 ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                                 ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                                 ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                                 ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                                 ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                                 ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                                 ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                                 ("27" (GRIND) NIL NIL) ("28" (GRIND) NIL NIL)
                                 ("29" (GRIND) NIL NIL) ("30" (GRIND) NIL NIL)
                                 ("31" (GRIND) NIL NIL) ("32" (GRIND) NIL NIL)
                                 ("33" (EXPAND "sitc")
                                  (("33" (EXPAND "tc")
                                    (("33" (PROPAX) NIL NIL)) NIL))
                                  NIL)
                                 ("34" (GRIND) NIL NIL)
                                 ("35" (EXPAND "sitc")
                                  (("35" (EXPAND "tc")
                                    (("35" (PROPAX) NIL NIL)) NIL))
                                  NIL))
                                NIL))
                              NIL)
                             ("2" (HIDE 2) (("2" (GRIND) NIL NIL)) NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL))
                  NIL)
                 ("2" (FLATTEN)
                  (("2" (HIDE 2)
                    (("2"
                      (INST + "s2!1" "tick" "trans(tick,s2!1)"
                       "trans(tick,s2!1)")
                      (("2" (CASE "a1!1=tick")
                        (("1" (REPLACE -1 *)
                          (("1" (BDDSIMP)
                            (("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)
                             ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                             ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                             ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                             ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                             ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                             ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                             ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                             ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                             ("27" (GRIND) NIL NIL)
                             ("28" (EXPAND "enabled_tick")
                              (("28" (GRIND) NIL NIL)) NIL)
                             ("29" (GRIND) NIL NIL) ("30" (GRIND) NIL NIL)
                             ("31" (GRIND) NIL NIL)
                             ("32" (EXPAND "enabled_tick")
                              (("32" (GRIND) NIL NIL)) NIL)
                             ("33" (EXPAND "sitc")
                              (("33" (EXPAND "tc") (("33" (PROPAX) NIL NIL))
                                NIL))
                              NIL)
                             ("34" (EXPAND "dd1")
                              (("34" (EXPAND "enabled")
                                (("34" (EXPAND "enabled_tick")
                                  (("34" (SKOLEM-TYPEPRED)
                                    (("34" (FLATTEN)
                                      (("34"
                                        (CASE "q!1=alpha")
                                        (("1"
                                          (REPLACE -1 *)
                                          (("1"
                                            (INST - "alpha")
                                            (("1" (GRIND) NIL NIL))
                                            NIL))
                                          NIL)
                                         ("2"
                                          (CASE "q!1=rho1")
                                          (("1"
                                            (REPLACE -1 *)
                                            (("1"
                                              (INST - "rho1")
                                              (("1" (GRIND) NIL NIL))
                                              NIL))
                                            NIL)
                                           ("2"
                                            (CASE "q!1=gamma")
                                            (("1"
                                              (REPLACE -1 *)
                                              (("1"
                                                (INST - "gamma")
                                                (("1" (GRIND) NIL NIL))
                                                NIL))
                                              NIL)
                                             ("2"
                                              (CASE "q!1=rho2")
                                              (("1"
                                                (REPLACE -1 *)
                                                (("1"
                                                  (INST - "rho2")
                                                  (("1" (GRIND) NIL NIL))
                                                  NIL))
                                                NIL)
                                               ("2"
                                                (CASE "q!1=pr")
                                                (("1"
                                                  (REPLACE -1 *)
                                                  (("1"
                                                    (INST - "pr")
                                                    (("1" (GRIND) NIL NIL))
                                                    NIL))
                                                  NIL)
                                                 ("2"
                                                  (CASE "q!1=ps")
                                                  (("1"
                                                    (REPLACE -1 *)
                                                    (("1"
                                                      (INST - "ps")
                                                      (("1" (GRIND) NIL NIL))
                                                      NIL))
                                                    NIL)
                                                   ("2"
                                                    (CASE "q!1=wr")
                                                    (("1"
                                                      (REPLACE -1 *)
                                                      (("1"
                                                        (INST - "wr")
                                                        (("1"
                                                          (GRIND)
                                                          NIL
                                                          NIL))
                                                        NIL))
                                                      NIL)
                                                     ("2"
                                                      (CASE "q!1=ws")
                                                      (("1"
                                                        (REPLACE -1 *)
                                                        (("1"
                                                          (INST - "ws")
                                                          (("1"
                                                            (GRIND)
                                                            NIL
                                                            NIL))
                                                          NIL))
                                                        NIL)
                                                       ("2"
                                                        (CASE "q!1=mu")
                                                        (("1"
                                                          (REPLACE -1 *)
                                                          (("1"
                                                            (INST - "mu1")
                                                            (("1"
                                                              (GRIND)
                                                              NIL
                                                              NIL))
                                                            NIL))
                                                          NIL)
                                                         ("2"
                                                          (CASE "q!1=omega29")
                                                          (("1"
                                                            (REPLACE -1 *)
                                                            (("1"
                                                              (INST - "mu1")
                                                              (("1"
                                                                (GRIND)
                                                                NIL
                                                                NIL))
                                                              NIL))
                                                            NIL)
                                                           ("2"
                                                            (CASE
                                                             "q!1=omega19")
                                                            (("1"
                                                              (REPLACE -1 *)
                                                              (("1"
                                                                (INST - "mu2")
                                                                (("1"
                                                                  (GRIND)
                                                                  NIL
                                                                  NIL))
                                                                NIL))
                                                              NIL)
                                                             ("2"
                                                              (GRIND)
                                                              NIL
                                                              NIL))
                                                            NIL))
                                                          NIL))
                                                        NIL))
                                                      NIL))
                                                    NIL))
                                                  NIL))
                                                NIL))
                                              NIL))
                                            NIL))
                                          NIL))
                                        NIL))
                                      NIL))
                                    NIL))
                                  NIL))
                                NIL))
                              NIL)
                             ("35" (EXPAND "sitc")
                              (("35" (EXPAND "tc") (("35" (PROPAX) NIL NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL)
                         ("2" (HIDE 2) (("2" (ASSERT) NIL NIL)) NIL))
                        NIL))
                      NIL))
                    NIL))
                  NIL))
                NIL))
              NIL)
             ("4" (EXPAND "enabled")
              (("4" (SPLIT -2)
                (("1" (FLATTEN)
                  (("1"
                    (CASE "Not (a1!1=mu2 or a1!1=pr or a1!1=ps or a1!1=wr or a1!1=ws)")
                    (("1" (HIDE 3 4)
                      (("1" (FLATTEN)
                        (("1" (HIDE -7 -9) (("1" (GRIND) NIL NIL)) NIL)) NIL))
                      NIL)
                     ("2" (SPLIT -1)
                      (("1" (LEMMA "sim21_4121")
                        (("1" (INST - "a1!1" "s2!1" "s1!1")
                          (("1" (REPLACE -2 *) (("1" (GRIND) NIL NIL)) NIL))
                          NIL))
                        NIL)
                       ("2" (REPLACE -1 *)
                        (("2" (HIDE 3)
                          (("2"
                            (INST + "s2!1" "pr" "trans(pr,s2!1)"
                             "trans(pr,s2!1)")
                            (("2" (BDDSIMP)
                              (("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)
                               ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                               ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                               ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                               ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                               ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                               ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                               ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                               ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                               ("27" (HIDE -9 -10 -11)
                                (("27" (HIDE -2 -3) (("27" (GRIND) NIL NIL))
                                  NIL))
                                NIL)
                               ("28" (HIDE -2 -3 -9 -10 -12)
                                (("28" (GRIND) NIL NIL)) NIL)
                               ("29" (GRIND) NIL NIL) ("30" (GRIND) NIL NIL)
                               ("31" (HIDE -2 -3 -9 -10 -11 -12)
                                (("31" (GRIND) NIL NIL)) NIL)
                               ("32" (HIDE -2 -3 -9 -10 -11 -12)
                                (("32" (GRIND) NIL NIL)) NIL)
                               ("33" (EXPAND "sitc")
                                (("33" (EXPAND "tc") (("33" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("34" (GRIND) NIL NIL)
                               ("35" (EXPAND "sitc")
                                (("35" (EXPAND "tc") (("35" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("36" (GRIND) NIL NIL) ("37" (GRIND) NIL NIL)
                               ("38" (GRIND) NIL NIL) ("39" (GRIND) NIL NIL)
                               ("40" (GRIND) NIL NIL) ("41" (GRIND) NIL NIL)
                               ("42" (GRIND) NIL NIL) ("43" (GRIND) NIL NIL)
                               ("44" (GRIND) NIL NIL) ("45" (GRIND) NIL NIL)
                               ("46" (GRIND) NIL NIL) ("47" (GRIND) NIL NIL)
                               ("48" (GRIND) NIL NIL) ("49" (GRIND) NIL NIL)
                               ("50" (GRIND) NIL NIL) ("51" (GRIND) NIL NIL)
                               ("52" (GRIND) NIL NIL) ("53" (GRIND) NIL NIL)
                               ("54" (GRIND) NIL NIL) ("55" (GRIND) NIL NIL)
                               ("56" (GRIND) NIL NIL) ("57" (GRIND) NIL NIL)
                               ("58" (GRIND) NIL NIL) ("59" (GRIND) NIL NIL)
                               ("60" (GRIND) NIL NIL) ("61" (GRIND) NIL NIL)
                               ("62" (HIDE -2 -3 -9 -10 -11)
                                (("62" (GRIND) NIL NIL)) NIL)
                               ("63" (HIDE -2 -3 -9 -10 -12)
                                (("63" (GRIND) NIL NIL)) NIL)
                               ("64" (HIDE -2 -3 -9 -11 -12)
                                (("64" (GRIND) NIL NIL)) NIL)
                               ("65" (HIDE -2 -3 -10 -11 -12)
                                (("65" (GRIND) NIL NIL)) NIL)
                               ("66" (HIDE -2 -3 -9 -10 -11 -12)
                                (("66" (GRIND) NIL NIL)) NIL)
                               ("67" (HIDE -2 -3 -9 -10 -11 -12)
                                (("67" (GRIND) NIL NIL)) NIL)
                               ("68" (EXPAND "sitc")
                                (("68" (EXPAND "tc") (("68" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("69" (GRIND) NIL NIL)
                               ("70" (EXPAND "sitc")
                                (("70" (EXPAND "tc") (("70" (PROPAX) NIL NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("3" (HIDE 3)
                        (("3" (REPLACE -1 *)
                          (("3"
                            (INST + "s2!1" "ps" "trans(ps,s2!1)"
                             "trans(ps,s2!1)")
                            (("3" (BDDSIMP)
                              (("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)
                               ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                               ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                               ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                               ("17" (GRIND) NIL NIL)
                               ("18" (HIDE -2 -3 -9 -10 -11 -12)
                                (("18" (GRIND) NIL NIL)) NIL)
                               ("19" (HIDE -2 -3 -9 -10 -11 -12)
                                (("19" (GRIND) NIL NIL)) NIL)
                               ("20" (HIDE -2 -3 -9 -10 -11 -12)
                                (("20" (GRIND) NIL NIL)) NIL)
                               ("21" (HIDE -2 -3 -9 -10 -11 -12)
                                (("21" (GRIND) NIL NIL)) NIL)
                               ("22" (HIDE -2 -3 -9 -10 -11 -12)
                                (("22" (GRIND) NIL NIL)) NIL)
                               ("23" (HIDE -2 -3 -9 -10 -11 -12)
                                (("23" (GRIND) NIL NIL)) NIL)
                               ("24" (HIDE -2 -3 -9 -10 -11 -12)
                                (("24" (GRIND) NIL NIL)) NIL)
                               ("25" (GRIND) NIL NIL)
                               ("26" (HIDE -9 -10) (("26" (GRIND) NIL NIL))
                                NIL)
                               ("27" (HIDE -2 -3 -9 -10 -11)
                                (("27" (GRIND) NIL NIL)) NIL)
                               ("28" (HIDE -2 -3 -9 -10 -12)
                                (("28" (GRIND) NIL NIL)) NIL)
                               ("29" (HIDE -2 -3 -9 -11 -12)
                                (("29" (GRIND) NIL NIL)) NIL)
                               ("30" (HIDE -2 -3 -10 -11 -12)
                                (("30" (GRIND) NIL NIL)) NIL)
                               ("31" (HIDE -) (("31" (GRIND) NIL NIL)) NIL)
                               ("32" (GRIND) NIL NIL)
                               ("33" (EXPAND "sitc")
                                (("33" (EXPAND "tc") (("33" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("34" (GRIND) NIL NIL)
                               ("35" (EXPAND "sitc")
                                (("35" (EXPAND "tc") (("35" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("36" (GRIND) NIL NIL) ("37" (GRIND) NIL NIL)
                               ("38" (GRIND) NIL NIL) ("39" (GRIND) NIL NIL)
                               ("40" (GRIND) NIL NIL) ("41" (GRIND) NIL NIL)
                               ("42" (GRIND) NIL NIL) ("43" (GRIND) NIL NIL)
                               ("44" (GRIND) NIL NIL) ("45" (GRIND) NIL NIL)
                               ("46" (GRIND) NIL NIL) ("47" (GRIND) NIL NIL)
                               ("48" (GRIND) NIL NIL) ("49" (GRIND) NIL NIL)
                               ("50" (GRIND) NIL NIL) ("51" (GRIND) NIL NIL)
                               ("52" (GRIND) NIL NIL)
                               ("53" (HIDE -2 -3 -9 -10 -11 -12)
                                (("53" (GRIND) NIL NIL)) NIL)
                               ("54" (HIDE -2 -3 -9 -10 -11 -12)
                                (("54" (GRIND) NIL NIL)) NIL)
                               ("55" (HIDE -2 -3 -9 -10 -11 -12)
                                (("55" (HIDE -2 -3 -9 -10 -11 -12)
                                  (("55" (GRIND) NIL NIL)) NIL))
                                NIL)
                               ("56" (HIDE -2 -3 -9 -10 -11 -12)
                                (("56" (GRIND) NIL NIL)) NIL)
                               ("57" (HIDE -2 -3 -9 -10 -11 -12)
                                (("57" (GRIND) NIL NIL)) NIL)
                               ("58" (HIDE -2 -3 -9 -10 -11 -12)
                                (("58" (GRIND) NIL NIL)) NIL)
                               ("59" (HIDE -2 -3 -9 -10 -11 -12)
                                (("59" (GRIND) NIL NIL)) NIL)
                               ("60" (GRIND) NIL NIL)
                               ("61" (HIDE -9 -10) (("61" (GRIND) NIL NIL))
                                NIL)
                               ("62" (HIDE -2 -3 -9 -10 -11)
                                (("62" (GRIND) NIL NIL)) NIL)
                               ("63" (HIDE -2 -3 -9 -10 -12)
                                (("63" (GRIND) NIL NIL)) NIL)
                               ("64" (HIDE -2 -3 -9 -11 -12)
                                (("64" (GRIND) NIL NIL)) NIL)
                               ("65" (HIDE -2 -3 -10 -11 -12)
                                (("65" (GRIND) NIL NIL)) NIL)
                               ("66" (HIDE -) (("66" (GRIND) NIL NIL)) NIL)
                               ("67" (GRIND) NIL NIL)
                               ("68" (EXPAND "sitc")
                                (("68" (EXPAND "tc") (("68" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("69" (GRIND) NIL NIL)
                               ("70" (EXPAND "sitc")
                                (("70" (EXPAND "tc") (("70" (PROPAX) NIL NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("4" (REPLACE -1 *)
                        (("4" (HIDE 3)
                          (("4"
                            (INST + "s2!1" "wr" "trans(wr,s2!1)"
                             "trans(wr,s2!1)")
                            (("4" (BDDSIMP)
                              (("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)
                               ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                               ("13" (HIDE 2 3 4 6) (("13" (GRIND) NIL NIL))
                                NIL)
                               ("14" (GRIND) NIL NIL) ("15" (GRIND) NIL NIL)
                               ("16" (GRIND) NIL NIL) ("17" (GRIND) NIL NIL)
                               ("18" (HIDE -2 -3 -9 -10 -11 -12)
                                (("18" (GRIND) NIL NIL)) NIL)
                               ("19" (HIDE -2 -3 -9 -10 -11 -12)
                                (("19" (GRIND) NIL NIL)) NIL)
                               ("20" (HIDE -2 -3 -9 -10 -11 -12)
                                (("20" (GRIND) NIL NIL)) NIL)
                               ("21" (HIDE -2 -3 -9 -10 -11 -12)
                                (("21" (GRIND) NIL NIL)) NIL)
                               ("22" (HIDE -2 -3 -9 -10 -11 -12)
                                (("22" (GRIND) NIL NIL)) NIL)
                               ("23" (HIDE -2 -3 -9 -10 -11 -12)
                                (("23" (GRIND) NIL NIL)) NIL)
                               ("24" (HIDE -2 -3 -9 -10 -11 -12)
                                (("24" (GRIND) NIL NIL)) NIL)
                               ("25" (GRIND) NIL NIL)
                               ("26" (HIDE -9 -10) (("26" (GRIND) NIL NIL))
                                NIL)
                               ("27" (HIDE -2 -3 -9 -10 -11)
                                (("27" (GRIND) NIL NIL)) NIL)
                               ("28" (HIDE -2 -3 -9 -10 -12)
                                (("28" (GRIND) NIL NIL)) NIL)
                               ("29" (HIDE -2 -3 -9 -11 -12 -21)
                                (("29" (GRIND) NIL NIL)) NIL)
                               ("30" (HIDE -2 -3 -10 -11 -12 -21)
                                (("30" (GRIND) NIL NIL)) NIL)
                               ("31" (HIDE -) (("31" (GRIND) NIL NIL)) NIL)
                               ("32" (HIDE -2 -3 -9 -10 -11 -12)
                                (("32" (GRIND) NIL NIL)) NIL)
                               ("33" (EXPAND "sitc")
                                (("33" (EXPAND "tc") (("33" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("34" (GRIND) NIL NIL)
                               ("35" (EXPAND "sitc")
                                (("35" (EXPAND "tc") (("35" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("36" (GRIND) NIL NIL) ("37" (GRIND) NIL NIL)
                               ("38" (GRIND) NIL NIL) ("39" (GRIND) NIL NIL)
                               ("40" (GRIND) NIL NIL) ("41" (GRIND) NIL NIL)
                               ("42" (GRIND) NIL NIL) ("43" (GRIND) NIL NIL)
                               ("44" (GRIND) NIL NIL) ("45" (GRIND) NIL NIL)
                               ("46" (GRIND) NIL NIL) ("47" (GRIND) NIL NIL)
                               ("48" (GRIND) NIL NIL) ("49" (GRIND) NIL NIL)
                               ("50" (GRIND) NIL NIL) ("51" (GRIND) NIL NIL)
                               ("52" (GRIND) NIL NIL) ("53" (GRIND) NIL NIL)
                               ("54" (GRIND) NIL NIL) ("55" (GRIND) NIL NIL)
                               ("56" (GRIND) NIL NIL) ("57" (GRIND) NIL NIL)
                               ("58" (GRIND) NIL NIL) ("59" (GRIND) NIL NIL)
                               ("60" (GRIND) NIL NIL)
                               ("61" (HIDE -9 -10) (("61" (GRIND) NIL NIL))
                                NIL)
                               ("62" (HIDE -2 -3 -9 -10 -11)
                                (("62" (GRIND) NIL NIL)) NIL)
                               ("63" (HIDE -2 -3 -9 -10 -12)
                                (("63" (GRIND) NIL NIL)) NIL)
                               ("64" (HIDE -2 -3 -9 -11 -12)
                                (("64" (GRIND) NIL NIL)) NIL)
                               ("65" (HIDE -10 -11 -12 -2 -3)
                                (("65" (GRIND) NIL NIL)) NIL)
                               ("66" (HIDE -) (("66" (GRIND) NIL NIL)) NIL)
                               ("67" (GRIND) NIL NIL)
                               ("68" (EXPAND "sitc")
                                (("68" (EXPAND "tc") (("68" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("69" (GRIND) NIL NIL)
                               ("70" (EXPAND "sitc")
                                (("70" (EXPAND "tc") (("70" (PROPAX) NIL NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("5" (REPLACE -1 *)
                        (("5" (HIDE 3)
                          (("5"
                            (INST + "s2!1" "ws" "trans(ws,s2!1)"
                             "trans(ws,s2!1)")
                            (("5" (BDDSIMP)
                              (("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)
                               ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                               ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                               ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                               ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                               ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                               ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                               ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                               ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                               ("27" (HIDE -2 -3 -9 -10 -11)
                                (("27" (GRIND) NIL NIL)) NIL)
                               ("28" (HIDE -2 -3 -9 -10 -12)
                                (("28" (GRIND) NIL NIL)) NIL)
                               ("29" (HIDE -2 -3 -9 -11 -12)
                                (("29" (GRIND) NIL NIL)) NIL)
                               ("30" (HIDE -2 -3 -10 -11 -12)
                                (("30" (GRIND) NIL NIL)) NIL)
                               ("31" (HIDE -) (("31" (GRIND) NIL NIL)) NIL)
                               ("32" (GRIND) NIL NIL)
                               ("33" (EXPAND "sitc")
                                (("33" (EXPAND "tc") (("33" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("34" (GRIND) NIL NIL)
                               ("35" (EXPAND "sitc")
                                (("35" (EXPAND "tc") (("35" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("36" (GRIND) NIL NIL) ("37" (GRIND) NIL NIL)
                               ("38" (GRIND) NIL NIL) ("39" (GRIND) NIL NIL)
                               ("40" (GRIND) NIL NIL) ("41" (GRIND) NIL NIL)
                               ("42" (GRIND) NIL NIL) ("43" (GRIND) NIL NIL)
                               ("44" (GRIND) NIL NIL) ("45" (GRIND) NIL NIL)
                               ("46" (GRIND) NIL NIL) ("47" (GRIND) NIL NIL)
                               ("48" (GRIND) NIL NIL) ("49" (GRIND) NIL NIL)
                               ("50" (GRIND) NIL NIL) ("51" (GRIND) NIL NIL)
                               ("52" (GRIND) NIL NIL) ("53" (GRIND) NIL NIL)
                               ("54" (GRIND) NIL NIL) ("55" (GRIND) NIL NIL)
                               ("56" (GRIND) NIL NIL) ("57" (GRIND) NIL NIL)
                               ("58" (GRIND) NIL NIL) ("59" (GRIND) NIL NIL)
                               ("60" (GRIND) NIL NIL) ("61" (GRIND) NIL NIL)
                               ("62" (HIDE -2 -3 -9 -10 -11)
                                (("62" (GRIND) NIL NIL)) NIL)
                               ("63" (HIDE -2 -3 -9 -10 -12)
                                (("63" (GRIND) NIL NIL)) NIL)
                               ("64" (HIDE -2 -3 -9 -11 -12)
                                (("64" (GRIND) NIL NIL)) NIL)
                               ("65" (HIDE -2 -3 -10 -11 -12)
                                (("65" (GRIND) NIL NIL)) NIL)
                               ("66" (HIDE -) (("66" (GRIND) NIL NIL)) NIL)
                               ("67" (GRIND) NIL NIL)
                               ("68" (EXPAND "sitc")
                                (("68" (EXPAND "tc") (("68" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("69" (GRIND) NIL NIL)
                               ("70" (EXPAND "sitc")
                                (("70" (EXPAND "tc") (("70" (PROPAX) NIL NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL))
                  NIL)
                 ("2" (LEMMA "sim21_42")
                  (("2" (INST - "a1!1" "s2!1" "s1!1") (("2" (GRIND) NIL NIL))
                    NIL))
                  NIL))
                NIL))
              NIL)
             ("5" (EXPAND "enabled")
              (("5" (SPLIT)
                (("1" (FLATTEN)
                  (("1"
                    (CASE "NOT (a1!1=rho2 or a1!1=gamma or a1!1=pr or a1!1=ps or a1!1=wr or a1!1=ws)")
                    (("1" (HIDE 3 4)
                      (("1" (FLATTEN)
                        (("1" (HIDE -5 -6)
                          (("1" (HIDE -15)
                            (("1" (HIDE -5) (("1" (GRIND) NIL NIL)) NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL)
                     ("2" (SPLIT -1)
                      (("1" (REPLACE -1 *)
                        (("1" (HIDE 3)
                          (("1"
                            (INST + "s2!1" "rho2" "trans(rho2,s2!1)"
                             "trans(rho2,s2!1)")
                            (("1" (BDDSIMP)
                              (("1" (HIDE -6 -7) (("1" (GRIND) NIL 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) ("11" (GRIND) NIL NIL)
                               ("12" (GRIND) NIL NIL) ("13" (GRIND) NIL NIL)
                               ("14" (GRIND) NIL NIL) ("15" (GRIND) NIL NIL)
                               ("16" (GRIND) NIL NIL) ("17" (GRIND) NIL NIL)
                               ("18" (GRIND) NIL NIL) ("19" (GRIND) NIL NIL)
                               ("20" (GRIND) NIL NIL) ("21" (GRIND) NIL NIL)
                               ("22" (GRIND) NIL NIL) ("23" (GRIND) NIL NIL)
                               ("24" (GRIND) NIL NIL) ("25" (GRIND) NIL NIL)
                               ("26" (GRIND) NIL NIL)
                               ("27" (HIDE -2 -3)
                                (("27" (HIDE -4 -5 -6)
                                  (("27" (GRIND) NIL NIL)) NIL))
                                NIL)
                               ("28" (HIDE -2 -3 -6 -7 -9)
                                (("28" (GRIND) NIL NIL)) NIL)
                               ("29" (HIDE -2 -3 -6 -8 -9)
                                (("29" (GRIND) NIL NIL)) NIL)
                               ("30" (HIDE -2 -3 -7 -8 -9)
                                (("30" (GRIND) NIL NIL)) NIL)
                               ("31" (HIDE -2 -3 -6 -7 -8 -9)
                                (("31" (GRIND) NIL NIL)) NIL)
                               ("32" (HIDE -2 -3 -6 -7 -8 -9)
                                (("32" (GRIND) NIL NIL)) NIL)
                               ("33" (EXPAND "sitc")
                                (("33" (EXPAND "tc") (("33" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("34" (GRIND) NIL NIL)
                               ("35" (EXPAND "sitc")
                                (("35" (EXPAND "tc") (("35" (PROPAX) NIL NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("2" (REPLACE -1 *)
                        (("2" (HIDE 3)
                          (("2"
                            (INST + "s2!1" "gamma" "trans(gamma,s2!1)"
                             "trans(gamma,s2!1)")
                            (("2" (BDDSIMP)
                              (("1" (HIDE -6 -7) (("1" (GRIND) NIL 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) ("11" (GRIND) NIL NIL)
                               ("12" (GRIND) NIL NIL) ("13" (GRIND) NIL NIL)
                               ("14" (GRIND) NIL NIL) ("15" (GRIND) NIL NIL)
                               ("16" (GRIND) NIL NIL) ("17" (GRIND) NIL NIL)
                               ("18" (GRIND) NIL NIL) ("19" (GRIND) NIL NIL)
                               ("20" (GRIND) NIL NIL) ("21" (GRIND) NIL NIL)
                               ("22" (GRIND) NIL NIL) ("23" (GRIND) NIL NIL)
                               ("24" (GRIND) NIL NIL) ("25" (GRIND) NIL NIL)
                               ("26" (GRIND) NIL NIL)
                               ("27" (HIDE -2 -3 -6 -7 -8)
                                (("27" (GRIND) NIL NIL)) NIL)
                               ("28" (HIDE -2 -3 -6 -7 -9)
                                (("28" (GRIND) NIL NIL)) NIL)
                               ("29" (HIDE -2 -3 -6 -8 -9)
                                (("29" (GRIND) NIL NIL)) NIL)
                               ("30" (HIDE -2 -3 -7 -8 -9)
                                (("30" (GRIND) NIL NIL)) NIL)
                               ("31" (HIDE -2 -3 -6 -7 -8 -9)
                                (("31" (GRIND) NIL NIL)) NIL)
                               ("32" (GRIND) NIL NIL)
                               ("33" (EXPAND "sitc")
                                (("33" (EXPAND "tc") (("33" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("34" (GRIND) NIL NIL)
                               ("35" (EXPAND "sitc")
                                (("35" (EXPAND "tc") (("35" (PROPAX) NIL NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("3" (REPLACE -1 *)
                        (("3" (HIDE 3)
                          (("3"
                            (INST + "s2!1" "pr" "trans(pr,s2!1)"
                             "trans(pr,s2!1)")
                            (("3" (BDDSIMP)
                              (("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)
                               ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                               ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                               ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                               ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                               ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                               ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                               ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                               ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                               ("27" (HIDE -2 -3 -6 -7 -8)
                                (("27" (GRIND) NIL NIL)) NIL)
                               ("28" (HIDE -2 -3 -6 -7 -9)
                                (("28" (HIDE -13) (("28" (GRIND) NIL NIL))
                                  NIL))
                                NIL)
                               ("29" (HIDE -2 -3 -6 -8 -9 -18)
                                (("29" (GRIND) NIL NIL)) NIL)
                               ("30" (HIDE -2 -3 -7 -8 -9 -18)
                                (("30" (GRIND) NIL NIL)) NIL)
                               ("31" (HIDE -) (("31" (GRIND) NIL NIL)) NIL)
                               ("32" (GRIND) NIL NIL)
                               ("33" (EXPAND "sitc")
                                (("33" (EXPAND "tc") (("33" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("34" (GRIND) NIL NIL)
                               ("35" (EXPAND "sitc")
                                (("35" (EXPAND "tc") (("35" (PROPAX) NIL NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("4" (REPLACE -1 *)
                        (("4" (HIDE 3)
                          (("4"
                            (INST + "s2!1" "ps" "trans(ps,s2!1)"
                             "trans(ps,s2!1)")
                            (("4" (BDDSIMP)
                              (("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)
                               ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                               ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                               ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                               ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                               ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                               ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                               ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                               ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                               ("27" (HIDE -2 -3 -6 -7 -8 -18)
                                (("27" (GRIND) NIL NIL)) NIL)
                               ("28" (HIDE -2 -3 -6 -7 -9 -18)
                                (("28" (GRIND) NIL NIL)) NIL)
                               ("29" (HIDE -2 -3 -6 -8 -9 -18)
                                (("29" (GRIND) NIL NIL)) NIL)
                               ("30" (HIDE -2 -3 -7 -8 -9 -18)
                                (("30" (GRIND) NIL NIL)) NIL)
                               ("31" (HIDE -) (("31" (GRIND) NIL NIL)) NIL)
                               ("32" (HIDE -2 -3 -6 -7 -8 -9)
                                (("32" (GRIND) NIL NIL)) NIL)
                               ("33" (EXPAND "sitc")
                                (("33" (EXPAND "tc") (("33" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("34" (GRIND) NIL NIL)
                               ("35" (EXPAND "sitc")
                                (("35" (EXPAND "tc") (("35" (PROPAX) NIL NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("5" (REPLACE -1 *)
                        (("5" (HIDE 3)
                          (("5"
                            (INST + "s2!1" "wr" "trans(wr,s2!1)"
                             "trans(wr,s2!1)")
                            (("5" (BDDSIMP)
                              (("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)
                               ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                               ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                               ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                               ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                               ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                               ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                               ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                               ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                               ("27" (HIDE -2 -3 -6 -7 -8)
                                (("27" (GRIND) NIL NIL)) NIL)
                               ("28" (HIDE -2 -3 -6 -7 -9)
                                (("28" (GRIND) NIL NIL)) NIL)
                               ("29" (HIDE -2 -3 -6 -8 -9)
                                (("29" (GRIND) NIL NIL)) NIL)
                               ("30" (HIDE -2 -3 -7 -8 -9)
                                (("30" (GRIND) NIL NIL)) NIL)
                               ("31" (HIDE -) (("31" (GRIND) NIL NIL)) NIL)
                               ("32" (GRIND) NIL NIL)
                               ("33" (EXPAND "sitc")
                                (("33" (EXPAND "tc") (("33" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("34" (GRIND) NIL NIL)
                               ("35" (EXPAND "sitc")
                                (("35" (EXPAND "tc") (("35" (PROPAX) NIL NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("6" (REPLACE -1 *)
                        (("6" (HIDE 3)
                          (("6"
                            (INST + "s2!1" "ws" "trans(ws,s2!1)"
                             "trans(ws,s2!1)")
                            (("6" (BDDSIMP)
                              (("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)
                               ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                               ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                               ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                               ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                               ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                               ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                               ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                               ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                               ("27" (HIDE -2 -3 -6 -7 -8)
                                (("27" (GRIND) NIL NIL)) NIL)
                               ("28" (HIDE -2 -3 -6 -7 -9)
                                (("28" (GRIND) NIL NIL)) NIL)
                               ("29" (HIDE -2 -3 -6 -8 -9)
                                (("29" (GRIND) NIL NIL)) NIL)
                               ("30" (HIDE -2 -3 -7 -8 -9)
                                (("30" (GRIND) NIL NIL)) NIL)
                               ("31" (HIDE -) (("31" (GRIND) NIL NIL)) NIL)
                               ("32" (GRIND) NIL NIL)
                               ("33" (EXPAND "sitc")
                                (("33" (EXPAND "tc") (("33" (PROPAX) NIL NIL))
                                  NIL))
                                NIL)
                               ("34" (GRIND) NIL NIL)
                               ("35" (EXPAND "sitc")
                                (("35" (EXPAND "tc") (("35" (PROPAX) NIL NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL))
                  NIL)
                 ("2" (HIDE 2)
                  (("2" (FLATTEN)
                    (("2" (CASE "a1!1=tick")
                      (("1" (REPLACE -1 *)
                        (("1"
                          (INST + "s2!1" "tick" "trans(tick,s2!1)"
                           "trans(tick,s2!1)")
                          (("1" (BDDSIMP)
                            (("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)
                             ("11" (GRIND) NIL NIL) ("12" (GRIND) NIL NIL)
                             ("13" (GRIND) NIL NIL) ("14" (GRIND) NIL NIL)
                             ("15" (GRIND) NIL NIL) ("16" (GRIND) NIL NIL)
                             ("17" (GRIND) NIL NIL) ("18" (GRIND) NIL NIL)
                             ("19" (GRIND) NIL NIL) ("20" (GRIND) NIL NIL)
                             ("21" (GRIND) NIL NIL) ("22" (GRIND) NIL NIL)
                             ("23" (GRIND) NIL NIL) ("24" (GRIND) NIL NIL)
                             ("25" (GRIND) NIL NIL) ("26" (GRIND) NIL NIL)
                             ("27" (GRIND) NIL NIL)
                             ("28" (HIDE -6 -7)
                              (("28" (HIDE -7) (("28" (GRIND) NIL NIL)) NIL))
                              NIL)
                             ("29" (HIDE -3 -6 -8 -9) (("29" (GRIND) NIL NIL))
                              NIL)
                             ("30" (HIDE -3 -7 -8 -9) (("30" (GRIND) NIL NIL))
                              NIL)
                             ("31" (HIDE -) (("31" (GRIND) NIL NIL)) NIL)
                             ("32" (GRIND) NIL NIL)
                             ("33" (EXPAND "sitc")
                              (("33" (EXPAND "tc") (("33" (PROPAX) NIL NIL))
                                NIL))
                              NIL)
                             ("34" (EXPAND "dd1")
                              (("34" (EXPAND "enabled")
                                (("34" (EXPAND "enabled_tick")
                                  (("34" (SKOLEM-TYPEPRED)
                                    (("34" (FLATTEN)
                                      (("34"
                                        (CASE "q!1=alpha")
                                        (("1"
                                          (REPLACE -1 *)
                                          (("1"
                                            (INST - "alpha")
                                            (("1" (GRIND) NIL NIL))
                                            NIL))
                                          NIL)
                                         ("2"
                                          (CASE "q!1=rho1")
                                          (("1"
                                            (REPLACE -1 *)
                                            (("1"
                                              (INST - "rho1")
                                              (("1" (GRIND) NIL NIL))
                                              NIL))
                                            NIL)
                                           ("2"
                                            (CASE "q!1=gamma")
                                            (("1"
                                              (REPLACE -1 *)
                                              (("1"
                                                (INST - "gamma")
                                                (("1" (GRIND) NIL NIL))
                                                NIL))
                                              NIL)
                                             ("2"
                                              (CASE "q!1=rho2")
                                              (("1"
                                                (REPLACE -1 *)
                                                (("1"
                                                  (INST - "rho2")
                                                  (("1" (GRIND) NIL NIL))
                                                  NIL))
                                                NIL)
                                               ("2"
                                                (CASE "q!1=pr")
                                                (("1"
                                                  (REPLACE -1 *)
                                                  (("1"
                                                    (INST - "pr")
                                                    (("1" (GRIND) NIL NIL))
                                                    NIL))
                                                  NIL)
                                                 ("2"
                                                  (CASE "q!1=ps")
                                                  (("1"
                                                    (REPLACE -1 *)
                                                    (("1"
                                                      (INST - "ps")
                                                      (("1" (GRIND) NIL NIL))
                                                      NIL))
                                                    NIL)
                                                   ("2"
                                                    (CASE "q!1=wr")
                                                    (("1"
                                                      (REPLACE -1 *)
                                                      (("1"
                                                        (INST - "wr")
                                                        (("1"
                                                          (GRIND)
                                                          NIL
                                                          NIL))
                                                        NIL))
                                                      NIL)
                                                     ("2"
                                                      (CASE "q!1=ws")
                                                      (("1"
                                                        (REPLACE -1 *)
                                                        (("1"
                                                          (INST - "ws")
                                                          (("1"
                                                            (GRIND)
                                                            NIL
                                                            NIL))
                                                          NIL))
                                                        NIL)
                                                       ("2"
                                                        (CASE "q!1=omega29")
                                                        (("1"
                                                          (REPLACE -1 *)
                                                          (("1"
                                                            (INST - "mu1")
                                                            (("1"
                                                              (GRIND)
                                                              NIL
                                                              NIL))
                                                            NIL))
                                                          NIL)
                                                         ("2"
                                                          (CASE "q!1=omega19")
                                                          (("1"
                                                            (REPLACE -1 *)
                                                            (("1"
                                                              (INST - "mu2")
                                                              (("1"
                                                                (GRIND)
                                                                NIL
                                                                NIL))
                                                              NIL))
                                                            NIL)
                                                           ("2"
                                                            (CASE "q!1=mu")
                                                            (("1"
                                                              (REPLACE -1 *)
                                                              (("1"
                                                                (INST - "mu1")
                                                                (("1"
                                                                  (GRIND)
                                                                  NIL
                                                                  NIL))
                                                                NIL))
                                                              NIL)
                                                             ("2"
                                                              (GRIND)
                                                              NIL
                                                              NIL))
                                                            NIL))
                                                          NIL))
                                                        NIL))
                                                      NIL))
                                                    NIL))
                                                  NIL))
                                                NIL))
                                              NIL))
                                            NIL))
                                          NIL))
                                        NIL))
                                      NIL))
                                    NIL))
                                  NIL))
                                NIL))
                              NIL)
                             ("35" (EXPAND "sitc")
                              (("35" (EXPAND "tc") (("35" (PROPAX) NIL NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL)
                       ("2" (ASSERT) NIL NIL))
                      NIL))
                    NIL))
                  NIL))
                NIL))
              NIL))
            NIL))
          NIL))
        NIL))
      NIL))
    NIL))
  NIL)
 (RR_TCC1 "" (EXPAND "wsebisim?")
  (("" (SPLIT)
    (("1" (LEMMA "Sim1_2") (("1" (PROPAX) NIL NIL)) NIL)
     ("2" (LEMMA "Sim2_1") (("2" (PROPAX) NIL NIL)) NIL))
    NIL))
  NIL)
 (|weakequi| "" (SKOLEM-TYPEPRED)
  (("" (EXPAND "weakequivalence") (("" (FLATTEN) (("" (GRIND) NIL NIL)) NIL))
    NIL))
  NIL))


$$$../ttm_lib/state_trans.pvs
state_trans [ 	OUT:TYPE+,
		S:TYPE+
	    ] 
                : THEORY

BEGIN
   
%  transitive closure
   x,y,z:VAR S
   R:VAR PRED[[S,S]]
   P:VAR [S->OUT]

    tc(R)(x,z): INDUCTIVE bool
      =    x=z OR R(x, z)
        OR (EXISTS (y: S): tc(R)(x, y) AND tc(R)(y, z)) ; 

%  state_invariant_transitive_closure

    sitc(R, P)(x,y): bool = 
	tc(lambda x,y: R(x,y) & P(x)=P(y))(x,y)


END state_trans

$$$../ttm_lib/sesim.pvs
sesim   [ S, S1, S2, A, A1, A2: TYPE+,
	 pS1: [S1 -> S],
  	 pS2: [S2 -> S],	  
         pA1: [A1 -> A],
         pA2: [A2 -> A],
         d1: PRED[[S1,A1,S1]],
         d2: PRED[[S2,A2,S2]],
	 Is_tau?:  PRED[A]	 
	 ]
				: THEORY

  BEGIN

  IMPORTING state_trans

  R:VAR PRED[[S1,S2]];

  s1,s1a: VAR S1;
  s2,s2a,s2b,s2c,s2d:VAR S2;
  a1:VAR A1;
  a2:VAR A2;
  
  r1(s1,s1a):bool = (EXISTS (a1): d1(s1,a1,s1a) & Is_tau?(pA1(a1)));
  r2(s2,s2a):bool = (EXISTS (a2): d2(s2,a2,s2a) & Is_tau?(pA2(a2))); 

  sesim?(R): bool =
      FORALL s1, a1, s2:
        FORALL s1a:
          d1(s1, a1, s1a) & R(s1, s2) =>
           (EXISTS s2a, a2:
              (d2(s2, a2, s2a) &
                pS1(s1a) = pS2(s2a) & pA1(a1) = pA2(a2) & R(s1a, s2a))); 
  
  Sesim:TYPE = (sesim?)

  wsesim?(R): bool =
      FORALL s1, a1, s2:
        (FORALL s1a:
           (d1(s1, a1, s1a) & R(s1, s2)) =>
            (EXISTS s2a, a2, s2b, s2c:
               (sitc(r2, pS2)(s2, s2a) &
                 d2(s2a, a2, s2b) &
                  sitc(r2, pS2)(s2b, s2c) &
                   pS1(s1a) = pS2(s2c) & pA1(a1) = pA2(a2) & R(s1a, s2c)))
             OR
             (EXISTS s2d:
                pS1(s1a) = pS2(s2d) AND
                 Is_tau?(pA1(a1)) AND
                  sitc(r2, pS2)(s2, s2d) AND R(s1a, s2d)));

  Wsesim:TYPE = (wsesim?)

END sesim

$$$../ttm_lib/sebisim.pvs
sebisim     [ S, S1, S2, A, A1, A2: TYPE+,
	 pS1: [S1 -> S],
  	 pS2: [S2 -> S],	  
         pA1: [A1 -> A],
         pA2: [A2 -> A],
         d1: PRED[[S1,A1,S1]],
         d2: PRED[[S2,A2,S2]],
	 Is_tau?:  PRED[A]	 
	 ]
				: THEORY
BEGIN

  R:VAR PRED[[S1,S2]];

  start1: VAR PRED[S1];
  start2: VAR PRED[S2];
  
  IMPORTING sesim[S,S1,S2,A,A1,A2,pS1,pS2,pA1,pA2,d1,d2,Is_tau?]
  IMPORTING sesim[S,S2,S1,A,A2,A1,pS2,pS1,pA2,pA1,d2,d1,Is_tau?]

  sebisim?(R):bool = sesim?(R) & sesim?(converse(R))

  Sebisim:TYPE = (sebisim?)

  s1:VAR S1 
  s2:VAR S2
  Rse: VAR Sebisim

  strongequivalence(Rse)(start1,start2)(s1,s2):bool =
	((start1(s1)&start2(s2))=> Rse(s1,s2))

  wsebisim?(R):bool = wsesim?(R) & wsesim?(converse(R))

  Wsebisim:TYPE = (wsebisim?)

  Rwse:VAR Wsebisim

  weakequivalence(Rwse)(start1,start2)(s1,s2):bool =
	((start1(s1)&start2(s2))=> Rwse(s1,s2))

END sebisim

$$$action2.pvs
action2: THEORY

BEGIN
	I_action: DATATYPE
	BEGIN
	 tick: tick?
	 mu1: mu1?
	 alpha: alpha?
	 mu2:mu2?
	 rho1: rho1?
	 rho2: rho2?
	 gamma: gamma?
	 wr: wr?
	 ws: ws?
	 pr: pr?
	 ps: ps?
	END I_action

	I_nt_action: TYPE = {action: I_action | action/=tick}

END action2

$$$ttm2decls.pvs
ttm2_decls: THEORY
BEGIN

	ttm_lib: LIBRARY = "../ttm_lib"

% type and function declarations:

	IMPORTING time_thy
	IMPORTING ttm_lib@list_rewrites
	IMPORTING ttm_lib@bool_rewrites

	I_activity: TYPE = {a}
	
	IMPORTING action2

% state variables

	internal_state: TYPE = [# Relay: bool, Power:bool, Pressure:bool, c1:nat, c2:nat #]

% Auxiliary functions

	lower_bound (ac:I_nt_action): time =
	 	CASES ac OF
		        mu1: one,
			alpha: one,
			mu2: one,
			rho1: one,
			rho2: one,
			gamma: one,
			wr: one,
			ws: one,
			pr: one,
			ps: one
		ENDCASES
	
	upper_bound (ac:I_nt_action): time =
		CASES ac OF
			mu1: one,
			alpha: one,
			mu2: one,
			rho1: one,
			rho2: one,
			gamma: one,
			wr: infinity,
			ws: infinity,
			pr: infinity,
			ps: infinity			
		ENDCASES

% preconditions

    enabled_state (ac:I_nt_action, si:internal_state): bool =
		CASES ac OF
		 	mu1: (si`Pressure and si`Power and si`c1=0 and si`c2=0) or (si`c1>=1 and si`c1<=29),
			alpha: si`Power and si`c1>=30,
			mu2: (si`c1=0 and si`c2>=1 and si`c2<=19),
			rho1: Not si`Power and si`c1>=30,
			rho2: Not si`Power and si`c1=0 and si`c2>=20,
			gamma: si`Power and si`c1=0 and si`c2>=20,
			wr: si`Power,
			ws: Not si`Power,
			pr: si`Pressure,
			ps: Not si`Pressure
		ENDCASES;

    graph (ac:I_nt_action, sa:I_activity):bool = 
         	CASES ac OF
			mu1: sa=a,
			alpha: sa=a,
			mu2: sa=a,
			rho1: sa=a,
			rho2: sa=a,
			gamma: sa=a,
			wr: True,
			ws: True,
			pr: True,
			ps: True
	 	ENDCASES

IMPORTING ttm[I_activity,internal_state,I_nt_action,
			lower_bound,upper_bound,enabled_state,graph]


IMPORTING states[I_activity, I_nt_action, internal_state,time]

    I_state: TYPE = states[I_activity, I_nt_action, internal_state,time]
  

    enabled(ac:I_action,s:I_state):bool =
		IF(not (tick?(ac))) THEN enabled_general(ac,s) & enabled_time(ac,s)
		ELSE enabled_tick(s)
		ENDIF
	
    trans (ac:I_action, s:I_state):I_state =
         	CASES ac OF
		 	tick: s WITH [ action_time:= update_clocks(s)],
			mu1:   s WITH [ basic:= s`basic WITH [c1:=s`basic`c1+1], 
					action_time:= reset_clocks(mu1, s WITH [basic:=s`basic WITH [c1:=s`basic`c1+1]])],
			alpha: s WITH [ basic:= s`basic WITH [c1:=0,c2:=s`basic`c2+1,Relay:=True], 
					action_time:= reset_clocks(alpha, s WITH [ basic:= s`basic WITH [c1:=0,c2:=s`basic`c2+1,Relay:=True]])],
			mu2: s WITH [ basic:=s`basic WITH [c2:=s`basic`c2+1,Relay:=True], 
					action_time:= reset_clocks(mu2, s WITH [ basic:=s`basic WITH [c2:=s`basic`c2+1,Relay:=True]]) ],
			rho1: s WITH [ basic:=s`basic WITH [ c1:=0 ],
					action_time:= reset_clocks(rho1, s WITH [ basic:= s`basic WITH [c1:=0]]) ],
			rho2: s WITH [ basic:= s`basic WITH[c2:=0, Relay:=False], 
					action_time:= reset_clocks(rho2, s WITH [ basic:= s`basic WITH[c2:=0,Relay:=False]]) ],
			gamma: s WITH [ basic:= s`basic WITH [ c2:=0 ],
					action_time:= reset_clocks(gamma, s WITH [ basic:= s`basic WITH [c2:=0]]) ],
			wr: s WITH [basic:=s`basic WITH [Power:=False], action_time:= reset_clocks(wr,s WITH [basic:=s`basic WITH [Power:=False]])],
			ws: s WITH [basic:=s`basic WITH [Power:=True], action_time:= reset_clocks(ws,s WITH [basic:=s`basic WITH [Power:=True]])],
			pr: s WITH [basic:=s`basic WITH [Pressure:=False], action_time:= reset_clocks(pr,s WITH [basic:=s`basic WITH [Pressure:=False]])],
			ps: s WITH [basic:=s`basic WITH [Pressure:=True], action_time:= reset_clocks(ps,s WITH [basic:=s`basic WITH [Pressure:=True]])]
	 	ENDCASES
 
% define initial state
   	
    start (s:I_state):bool = 
	  ( s = (# activity:=a,
		   basic:= (# Relay:=False,Power:=False,Pressure:=False,c1:=0,c2:=0 #),
		   action_time:=(LAMBDA (a:I_nt_action): zero)
		#)
	  )

IMPORTING ttm_lib@machine[I_state,I_action,enabled,trans,start] 

END ttm2_decls

$$$ttm2decls.prf
(|ttm2_decls| (|lower_bound_TCC1| "" (CASES-TCC) NIL NIL)
 (|enabled_TCC1| "" (SUBTYPE-TCC) NIL NIL)
 (|trans_TCC1| "" (SUBTYPE-TCC) NIL NIL)
 (|trans_TCC2| "" (SUBTYPE-TCC) NIL NIL)
 (|trans_TCC3| "" (SUBTYPE-TCC) NIL NIL)
 (|trans_TCC4| "" (SUBTYPE-TCC) NIL NIL)
 (|trans_TCC5| "" (SUBTYPE-TCC) NIL NIL)
 (|trans_TCC6| "" (SUBTYPE-TCC) NIL NIL)
 (|trans_TCC7| "" (SUBTYPE-TCC) NIL NIL)
 (|trans_TCC8| "" (SUBTYPE-TCC) NIL NIL)
 (|trans_TCC9| "" (SUBTYPE-TCC) NIL NIL)
 (|trans_TCC10| "" (SUBTYPE-TCC) NIL NIL))


$$$ttm2invariant.pvs
ttm2_invariants  	: THEORY

   BEGIN

 	IMPORTING  ttm2_decls

 	Inv_2(s:I_state) : bool = 	
				(s`basic`c1=0 and s`basic`c2=0 
				  and (s`action_time(mu1)= zero or s`action_time(mu1)=one)
				  and s`action_time(mu2)= zero and s`action_time(alpha)=zero 
				  and s`action_time(rho1)=zero and s`action_time(rho2)= zero 
				  and s`action_time(gamma)=zero ) or

				((s`basic`c1>=1 and s`basic`c1<=29) 
				  and s`basic`c2=0 
				  and (s`action_time(mu1)= zero or s`action_time(mu1)= one) 
				  and s`action_time(mu2)= zero and s`action_time(alpha)=zero 
				  and s`action_time(rho1)=zero and s`action_time(rho2)= zero 
				  and s`action_time(gamma)=zero ) or
	
				(s`basic`c1=30 and s`basic`c2=0 and s`action_time(mu1)= zero  
				  and s`action_time(mu2)= zero 
				  and (    (s`action_time(alpha)=zero and s`action_time(rho1)=zero) 
					or (s`action_time(alpha)=zero and s`action_time(rho1)=one) 
					or (s`action_time(alpha)=one  and  s`action_time(rho1)=zero)) 
				  and s`action_time(rho2)= zero and s`action_time(gamma)=zero ) or
		
				(s`basic`c1=0 
				  and (s`basic`c2>=1 and s`basic`c2<=19)  
				  and s`action_time(mu1)= zero  
				  and (s`action_time(mu2)= zero or s`action_time(mu2)= one)
				  and s`action_time(alpha)=zero and s`action_time(rho1)=zero 
				  and s`action_time(rho2)= zero and s`action_time(gamma)=zero ) or		

				(s`basic`c1=0 and s`basic`c2=20 and s`action_time(mu1)= zero  
				  and s`action_time(mu2)= zero  and s`action_time(alpha)=zero 
				  and s`action_time(rho1)=zero 
				  and (	   (s`action_time(rho2)= zero and s`action_time(gamma)=zero)
					or (s`action_time(rho2)= zero and s`action_time(gamma)=one)
					or (s`action_time(rho2)= one and s`action_time(gamma)=zero))) 
	
	Inv_21(s:I_state): bool = (s`basic`c2 >= 1 => s`basic`Relay = True)
		
	LEMMA2_1: LEMMA (FORALL (s:I_state): reachable(s) => Inv_2(s));

	LEMMA2_2: LEMMA (FORALL (s:I_state): reachable(s) => Inv_21(s));

END ttm2_invariants

$$$ttm2invariant.prf
(|ttm2_invariants| (|Inv_2_TCC1| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC2| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC3| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC4| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC5| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC6| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC7| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC8| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC9| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC10| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC11| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC12| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC13| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC14| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC15| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC16| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC17| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC18| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC19| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC20| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC21| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC22| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC23| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC24| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC25| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC26| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC27| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC28| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC29| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC30| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC31| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_2_TCC32| "" (SUBTYPE-TCC) NIL NIL)
 (LEMMA2_1 "" (LEMMA "machine_induct")
  (("" (INST -1 "Inv_2")
    (("" (EXPAND "inductthm")
      (("" (SPLIT)
        (("1" (PROPAX) NIL NIL) ("2" (GRIND) NIL NIL)
         ("3" (HIDE 2)
          (("3" (EXPAND "inductstep")
            (("3" (SKOLEM-TYPEPRED)
              (("3" (FLATTEN)
                (("3" (EXPAND "enabled")
                  (("3" (SPLIT)
                    (("1" (FLATTEN)
                      (("1" (EXPAND "enabled_time")
                        (("1" (FLATTEN)
                          (("1" (EXPAND "enabled_general")
                            (("1" (FLATTEN)
                              (("1" (EXPAND "enabled_state")
                                (("1" (EXPAND "graph")
                                  (("1" (CASE "a!1=tick")
                                    (("1" (GRIND) NIL NIL)
                                     ("2" (CASE "a!1=mu1")
                                      (("1"
                                        (REPLACE -1 *)
                                        (("1" (GRIND) NIL NIL))
                                        NIL)
                                       ("2"
                                        (CASE "a!1=alpha")
                                        (("1"
                                          (REPLACE -1 *)
                                          (("1" (GRIND) NIL NIL))
                                          NIL)
                                         ("2"
                                          (CASE "a!1=mu2")
                                          (("1" (GRIND) NIL NIL)
                                           ("2"
                                            (CASE "a!1=rho1")
                                            (("1"
                                              (REPLACE -1 *)
                                              (("1" (GRIND) NIL NIL))
                                              NIL)
                                             ("2"
                                              (CASE "a!1=rho2")
                                              (("1"
                                                (REPLACE -1 *)
                                                (("1" (GRIND) NIL NIL))
                                                NIL)
                                               ("2"
                                                (CASE "a!1=gamma")
                                                (("1"
                                                  (REPLACE -1 *)
                                                  (("1" (GRIND) NIL NIL))
                                                  NIL)
                                                 ("2"
                                                  (CASE "a!1=wr")
                                                  (("1"
                                                    (REPLACE -1 *)
                                                    (("1" (GRIND) NIL NIL))
                                                    NIL)
                                                   ("2"
                                                    (CASE "a!1=ws")
                                                    (("1"
                                                      (REPLACE -1 *)
                                                      (("1" (GRIND) NIL NIL))
                                                      NIL)
                                                     ("2"
                                                      (CASE "a!1=pr")
                                                      (("1"
                                                        (REPLACE -1 *)
                                                        (("1"
                                                          (GRIND)
                                                          NIL
                                                          NIL))
                                                        NIL)
                                                       ("2"
                                                        (CASE "a!1=ps")
                                                        (("1"
                                                          (REPLACE -1 *)
                                                          (("1"
                                                            (GRIND)
                                                            NIL
                                                            NIL))
                                                          NIL)
                                                         ("2"
                                                          (GRIND)
                                                          NIL
                                                          NIL))
                                                        NIL))
                                                      NIL))
                                                    NIL))
                                                  NIL))
                                                NIL))
                                              NIL))
                                            NIL))
                                          NIL))
                                        NIL))
                                      NIL))
                                    NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL)
                     ("2" (FLATTEN)
                      (("2" (EXPAND "enabled_tick")
                        (("2" (CASE "a!1=tick")
                          (("1" (REPLACE -1 *)
                            (("1" (HIDE -2 -3)
                              (("1" (EXPAND "Inv_2" -3)
                                (("1" (SPLIT)
                                  (("1" (GRIND)
                                    (("1" (REVEAL -2)
                                      (("1"
                                        (INST - "mu1")
                                        (("1" (GRIND) NIL NIL))
                                        NIL))
                                      NIL))
                                    NIL)
                                   ("2" (FLATTEN)
                                    (("2" (SPLIT)
                                      (("1" (GRIND) NIL NIL)
                                       ("2"
                                        (REVEAL -2)
                                        (("2"
                                          (INST - "mu1")
                                          (("2" (GRIND) NIL NIL))
                                          NIL))
                                        NIL))
                                      NIL))
                                    NIL)
                                   ("3" (GRIND)
                                    (("1" (REVEAL -2)
                                      (("1"
                                        (INST - "rho1")
                                        (("1" (GRIND) NIL NIL))
                                        NIL))
                                      NIL)
                                     ("2" (REVEAL -2)
                                      (("2"
                                        (INST - "alpha")
                                        (("2" (GRIND) NIL NIL))
                                        NIL))
                                      NIL))
                                    NIL)
                                   ("4" (GRIND)
                                    (("4" (REVEAL -2)
                                      (("4"
                                        (INST - "mu2")
                                        (("4" (GRIND) NIL NIL))
                                        NIL))
                                      NIL))
                                    NIL)
                                   ("5" (GRIND)
                                    (("1" (REVEAL -2)
                                      (("1"
                                        (INST - "gamma")
                                        (("1" (GRIND) NIL NIL))
                                        NIL))
                                      NIL)
                                     ("2" (REVEAL -2)
                                      (("2"
                                        (INST - "rho2")
                                        (("2" (GRIND) 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)
 (LEMMA2_2 "" (LEMMA "machine_induct")
  (("" (INST -1 "Inv_21")
    (("" (EXPAND "inductthm")
      (("" (SPLIT)
        (("1" (PROPAX) NIL NIL) ("2" (HIDE 2) (("2" (GRIND) NIL NIL)) NIL)
         ("3" (HIDE 2)
          (("3" (EXPAND "inductstep")
            (("3" (SKOLEM-TYPEPRED)
              (("3" (FLATTEN) (("3" (GRIND) NIL NIL)) NIL)) NIL))
            NIL))
          NIL))
        NIL))
      NIL))
    NIL))
  NIL))


$$$../ttm_lib/machine.pvs
machine  [ states, actions: TYPE,
           enabled: [actions,states -> bool],
           trans: [actions,states -> states],
           start: [states -> bool] ] : THEORY
		
  BEGIN
    s,s1: VAR states;
    a: VAR actions;
    n,n1: VAR nat;
    Inv: VAR pred[states];

    reachable_hidden(s,n): RECURSIVE bool =
         IF n = 0 THEN start(s)
         ELSE (EXISTS a, s1 : reachable_hidden(s1,n - 1) &
                                  enabled(a,s1) &
                                  s = trans(a,s1))
         ENDIF
         MEASURE (LAMBDA s,n: n);

    reachable(s): bool = (EXISTS n : reachable_hidden(s,n));

    base(Inv) : bool = (FORALL s: start(s) => Inv(s));

    inductstep(Inv) : bool =
       (FORALL s, a: reachable(s) & Inv(s) & enabled(a,s) => Inv(trans(a,s)));

    inductthm(Inv): bool =
       base(Inv) & inductstep(Inv) => (FORALL s : reachable(s) => Inv(s));

    machine_induct: THEOREM (FORALL Inv: inductthm(Inv));

    reachable_trans_fact(s,a) : bool =
       (reachable(s) & enabled(a,s) => reachable(trans(a,s)));

    reachable_trans: LEMMA (FORALL s,a : reachable_trans_fact(s,a));

  END machine

$$$../ttm_lib/machine.prf
(|machine|
 (|reachable_hidden_TCC1| 0
  (|reachable_hidden_TCC1-1| NIL 3125070202 3125070203
   ("" (ASSERT) (("" (SKOSIMP) (("" (SKOSIMP) (("" (ASSERT) NIL))))))
    NIL)
   PROVED-COMPLETE NIL 1097 190 NIL NIL))
 (|reachable_hidden_TCC2| 0
  (|reachable_hidden_TCC2-1| NIL 3125070202 3125070204
   ("" (SKOLEM 1 ("n_1" "s_1")) (("" (FLATTEN) (("" (ASSERT) NIL))))
    NIL)
   PROVED-COMPLETE NIL 565 40 NIL NIL))
 (|machine_induct| 1
  (|machine_induct-2| "rushby's grind proof" 3175274330 3175274376
   ("" (GRIND :IF-MATCH NIL)
    ((""
      (CASE "(FORALL (n): (FORALL (s): (reachable_hidden(s,n) IMPLIES Inv!1(s))))")
      (("1" (GRIND) NIL NIL)
       ("2" (INDUCT "n")
        (("1" (GRIND) NIL NIL)
         ("2" (GRIND :IF-MATCH NIL)
          (("2" (INST -8 "s1!1" "a!1")
            (("2" (INST -2 "s1!1") (("2" (GRIND) NIL NIL)) NIL)) NIL))
          NIL))
        NIL))
      NIL))
    NIL)
   PROVED
   ((|base| CONST-DECL "bool" |machine| NIL)
    (|reachable| CONST-DECL "bool" |machine| NIL)
    (|inductstep| CONST-DECL "bool" |machine| NIL)
    (|inductthm| CONST-DECL "bool" |machine| NIL)
    (|nat| NONEMPTY-TYPE-EQ-DECL NIL |naturalnumbers| NIL)
    (|int| NONEMPTY-TYPE-EQ-DECL NIL |integers| NIL)
    (|integer_pred| CONST-DECL
     "[{x: {x: number | real_pred(x)} | rational_pred(x)} -> boolean]"
     |integers| NIL)
    (|rational| NONEMPTY-TYPE-FROM-DECL NIL |rationals| NIL)
    (|rational_pred| CONST-DECL
     "[{x: number | real_pred(x)} -> boolean]" |rationals| NIL)
    (>= CONST-DECL "bool" |reals| NIL)
    (|real| NONEMPTY-TYPE-FROM-DECL NIL |reals| NIL)
    (|real_pred| CONST-DECL "[number -> boolean]" |reals| NIL)
    (|number| NONEMPTY-TYPE-DECL NIL |numbers| NIL)
    (NOT CONST-DECL "[bool -> bool]" |booleans| NIL)
    (|bool| NONEMPTY-TYPE-EQ-DECL NIL |booleans| NIL)
    (|boolean| NONEMPTY-TYPE-DECL NIL |booleans| NIL)
    (|nat_induction| FORMULA-DECL NIL |naturalnumbers| NIL)
    (|actions| FORMAL-TYPE-DECL NIL |machine| NIL)
    (|pred| TYPE-EQ-DECL NIL |defined_types| NIL)
    (|reachable_hidden| DEF-DECL "bool" |machine| NIL)
    (IMPLIES CONST-DECL "[bool, bool -> bool]" |booleans| NIL)
    (|states| FORMAL-TYPE-DECL NIL |machine| NIL))
   2061 1760 T NIL)
  (|machine_induct-1| NIL 3125070202 3175274380
   ("" (EXPAND "inductthm")
    (("" (SKOLEM 1 "Inv_1")
      (("" (FLATTEN)
        (("" (SKOLEM 1 "s_1")
          (("" (FLATTEN)
            (("" (EXPAND "reachable")
              ((""
                (CASE "(FORALL (n): (FORALL (s):
                                (reachable_hidden(s,n) IMPLIES Inv_1(s))))")
                (("1" (DELETE -2 -3)
                  (("1" (SKOLEM -2 "n_0")
                    (("1" (INST -1 "n_0")
                      (("1" (INST -1 "s_1") (("1" (GROUND) NIL NIL))
                        NIL))
                      NIL))
                    NIL))
                  NIL)
                 ("2" (INDUCT "n")
                  (("1" (DELETE -2 -3 2)
                    (("1" (EXPAND "reachable_hidden")
                      (("1" (EXPAND "base") (("1" (PROPAX) NIL NIL))
                        NIL))
                      NIL))
                    NIL)
                   ("2" (DELETE -1 -3 2)
                    (("2" (SKOLEM 1 "j_1")
                      (("2" (FLATTEN)
                        (("2" (SKOLEM 1 "s_01")
                          (("2" (FLATTEN)
                            (("2" (EXPAND "reachable_hidden" -2)
                              (("2"
                                (SKOLEM -2 ("a_0" "s_0"))
                                (("2"
                                  (INST -1 "s_0")
                                  (("2"
                                    (GROUND)
                                    (("2"
                                      (EXPAND "inductstep")
                                      (("2"
                                        (INST -5 "s_0" "a_0")
                                        (("2"
                                          (GROUND)
                                          (("2"
                                            (EXPAND "reachable")
                                            (("2"
                                              (INST 1 "j_1")
                                              NIL
                                              NIL))
                                            NIL))
                                          NIL))
                                        NIL))
                                      NIL))
                                    NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL))
                  NIL))
                NIL))
              NIL))
            NIL))
          NIL))
        NIL))
      NIL))
    NIL)
   PROVED
   ((|inductthm| CONST-DECL "bool" |machine| NIL)
    (|pred| TYPE-EQ-DECL NIL |defined_types| NIL)
    (|reachable_hidden| DEF-DECL "bool" |machine| NIL)
    (IMPLIES CONST-DECL "[bool, bool -> bool]" |booleans| NIL)
    (|states| FORMAL-TYPE-DECL NIL |machine| NIL)
    (|nat| NONEMPTY-TYPE-EQ-DECL NIL |naturalnumbers| NIL)
    (>= CONST-DECL "bool" |reals| NIL)
    (|bool| NONEMPTY-TYPE-EQ-DECL NIL |booleans| NIL)
    (|real| NONEMPTY-TYPE-FROM-DECL NIL |reals| NIL)
    (|int| NONEMPTY-TYPE-EQ-DECL NIL |integers| NIL)
    (|integer_pred| CONST-DECL
     "[{x: {x: number | real_pred(x)} | rational_pred(x)} -> boolean]"
     |integers| NIL)
    (|rational| NONEMPTY-TYPE-FROM-DECL NIL |rationals| NIL)
    (|rational_pred| CONST-DECL
     "[{x: number | real_pred(x)} -> boolean]" |rationals| NIL)
    (|real_pred| CONST-DECL "[number -> boolean]" |reals| NIL)
    (|boolean| NONEMPTY-TYPE-DECL NIL |booleans| NIL)
    (|number| NONEMPTY-TYPE-DECL NIL |numbers| NIL)
    (|actions| FORMAL-TYPE-DECL NIL |machine| NIL)
    (|inductstep| CONST-DECL "bool" |machine| NIL)
    (|base| CONST-DECL "bool" |machine| NIL)
    (|nat_induction| FORMULA-DECL NIL |naturalnumbers| NIL)
    (|reachable| CONST-DECL "bool" |machine| NIL))
   772 560 NIL NIL))
 (|reachable_trans| 0
  (|reachable_trans-1| NIL 3125070202 3125070372
   ("" (SKOLEM 1 ("s_1" "a_1"))
    (("" (EXPAND "reachable_trans_fact")
      (("" (FLATTEN)
        (("" (EXPAND "reachable")
          (("" (SKOLEM -1 "n_1")
            (("" (INST 1 "n_1 + 1")
              (("" (EXPAND "reachable_hidden" 1)
                (("" (INST 1 "a_1" "s_1") (("" (ASSERT) NIL NIL)) NIL))
                NIL))
              NIL))
            NIL))
          NIL))
        NIL))
      NIL))
    NIL)
   UNCHECKED
   ((|reachable_trans_fact| CONST-DECL "bool" |machine| NIL)
    (|reachable| CONST-DECL "bool" |machine| NIL)
    (|states| FORMAL-TYPE-DECL NIL |machine| NIL)
    (|actions| FORMAL-TYPE-DECL NIL |machine| NIL)
    (|reachable_hidden| DEF-DECL "bool" |machine| NIL)
    (+ CONST-DECL "[real, real -> real]" |reals| NIL)
    (|nat| NONEMPTY-TYPE-EQ-DECL NIL |naturalnumbers| NIL)
    (>= CONST-DECL "bool" |reals| NIL)
    (|bool| NONEMPTY-TYPE-EQ-DECL NIL |booleans| NIL)
    (|real| NONEMPTY-TYPE-FROM-DECL NIL |reals| NIL)
    (|integer| NONEMPTY-TYPE-FROM-DECL NIL |integers| NIL)
    (|integer_pred| CONST-DECL
     "[{x: {x: number | real_pred(x)} | rational_pred(x)} -> boolean]"
     |integers| NIL)
    (|rational_pred| CONST-DECL
     "[{x: number | real_pred(x)} -> boolean]" |rationals| NIL)
    (|real_pred| CONST-DECL "[number -> boolean]" |reals| NIL)
    (|boolean| NONEMPTY-TYPE-DECL NIL |booleans| NIL)
    (|number| NONEMPTY-TYPE-DECL NIL |numbers| NIL))
   10160 270 NIL NIL)))


$$$states.pvs
states  [ activity, nt_action, internal_state:TYPE,
		time:TYPE ] 
					: THEORY

  BEGIN

    states: TYPE = [# activity: activity, basic:internal_state, 
			action_time: [nt_action -> time] 
			 #]

  END states

$$$ttm.pvs
ttm [ 	activity,internal_state, nt_action: TYPE,
	( IMPORTING time_thy, 
	  states[activity,nt_action,internal_state,time]
	 ) 
 	lower_bound,upper_bound:[nt_action->time],
	enabled_state: [nt_action,internal_state -> bool],
	graph:[nt_action, activity -> bool]
    ]
	 : THEORY

BEGIN

	enabled_general(ac:nt_action,s:states):bool =
		enabled_state(ac,s`basic) & graph(ac,s`activity)

% Only the tick can change the timers associated with the action.
% If enabled_general is not satisfied, It is reset to zero.
    
    	update_clocks(s:states): [nt_action->time] =
		(LAMBDA (q:nt_action):
		IF enabled_general(q,s) THEN
		s`action_time(q) + one
		ELSE zero
		ENDIF
		)

% After the normal action(except for Tick), Set the value of timers 
% according to the new enable conditions

    	reset_clocks(ac:nt_action,s:states): [nt_action->time] =
		(LAMBDA (q:nt_action):
		IF (enabled_general(q,s) & q/=ac) THEN
		s`action_time(q)
		ELSE zero
		ENDIF
		)

    	enabled_time(ac:nt_action, s:states): bool =
		 s`action_time(ac) >= lower_bound(ac) & s`action_time(ac) <= upper_bound(ac)

	enabled_tick(s:states): bool =
		 FORALL (q:nt_action): enabled_general(q,s) =>(s`action_time(q) < upper_bound(q))


END ttm

$$$action1.pvs
action1: THEORY

BEGIN

% S_action is actions with tick.

% S_action

	S_action: DATATYPE
	BEGIN
	 tick: tick?
	 mu: mu?
	 omega29: omega29?
	 alpha: alpha?
	 omega19: omega19?
	 rho1: rho1?
	 rho2: rho2?
	 gamma: gamma?
	 wr: wr?
	 ws: ws?
	 pr: pr?
	 ps: ps?	 	 
	END S_action

% action is actions without Tick, We need this because we do not
% need to associate a timer with tick action.

	S_nt_action: TYPE = { action: S_action | action/=tick}

END action1

$$$../ttm_lib/bool_rewrites.pvs
bool_rewrites: THEORY

  BEGIN

    boolrewrite_1: LEMMA (FORALL (b: boolean): (b AND NOT(b)) = FALSE);

    boolrewrite_2: LEMMA (FORALL (b: boolean): (b & NOT(b)) = FALSE);

    boolrewrite_3: LEMMA (FORALL (b: boolean): (NOT(b) AND b) = FALSE);

    boolrewrite_4: LEMMA (FORALL (b: boolean): (NOT(b) & b) = FALSE);

    boolrewrite_5: LEMMA (FORALL (b: boolean): (FALSE IMPLIES b) = TRUE);

    boolrewrite_6: LEMMA (FORALL (b: boolean): (FALSE => b) = TRUE);

    boolrewrite_7: LEMMA (FALSE AND TRUE) = FALSE;

    boolrewrite_8: LEMMA (FALSE & TRUE) = FALSE;

    boolrewrite_9: LEMMA (TRUE AND FALSE) = FALSE;

    boolrewrite_10: LEMMA (TRUE & FALSE) = FALSE;

    boolrewrite_11: LEMMA (TRUE OR FALSE) = TRUE;

    boolrewrite_12: LEMMA (TRUE OR TRUE) = TRUE;

    boolrewrite_13: LEMMA (FALSE OR TRUE) = TRUE;

    boolrewrite_14: LEMMA (FALSE OR FALSE) = FALSE;

    boolrewrite_15: LEMMA (FORALL (b: boolean): (TRUE IMPLIES b) = b);

    boolrewrite_16: LEMMA (FORALL (b: boolean): (TRUE => b) = b);

    boolrewrite_17: LEMMA (FORALL (b: boolean): (b AND FALSE) = FALSE);

    boolrewrite_18: LEMMA (FORALL (b: boolean): (b & FALSE) = FALSE);

    boolrewrite_19: LEMMA (FORALL (b: boolean): (FALSE AND b) = FALSE);

    boolrewrite_20: LEMMA (FORALL (b: boolean): (FALSE & b) = FALSE);

    boolrewrite_21: LEMMA (FORALL (b: boolean): (TRUE AND b) = b);

    boolrewrite_22: LEMMA (FORALL (b: boolean): (TRUE & b) = b);

    boolrewrite_23: LEMMA (FORALL (b: boolean): (b AND TRUE) = b);

    boolrewrite_24: LEMMA (FORALL (b: boolean): (b & TRUE) = b);

    boolrewrite_25: LEMMA (FORALL (b: boolean): (TRUE OR b) = TRUE);

    boolrewrite_26: LEMMA (FORALL (b: boolean): (b OR TRUE) = TRUE);

    boolrewrite_27: LEMMA (FORALL (b: boolean): (FALSE OR b) = b);

    boolrewrite_28: LEMMA (FORALL (b: boolean): (b OR FALSE) = b);

    boolrewrite_29: LEMMA (FORALL (b: boolean): (NOT(b) IMPLIES b) = b);

    boolrewrite_30: LEMMA (FORALL (b: boolean): (NOT(b) => b) = b);

    boolrewrite_31: LEMMA (FORALL (b: boolean): (b IMPLIES NOT(b)) = NOT(b));

    boolrewrite_32: LEMMA (FORALL (b: boolean): (b => NOT(b)) = NOT(b));

  END bool_rewrites

$$$../ttm_lib/bool_rewrites.prf
(|bool_rewrites|
 (|boolrewrite_1| 0
  (|boolrewrite_1-1| NIL 3098837802 3175379906
   ("" (SKOLEM 1 "b_1") (("" (ASSERT) (("" (FLATTEN) NIL NIL)) NIL))
    NIL)
   UNCHECKED NIL 25 20 NIL NIL))
 (|boolrewrite_2| 0
  (|boolrewrite_2-1| NIL 3098837855 3175379906
   ("" (SKOLEM 1 "b_1")
    (("" (APPLY (THEN (FLATTEN) (ASSERT))) (("" (FLATTEN) NIL NIL))
      NIL))
    NIL)
   UNCHECKED NIL 25 30 NIL NIL))
 (|boolrewrite_3| 0
  (|boolrewrite_3-1| NIL 3098837880 3175379906
   ("" (SKOLEM!) (("" (ASSERT) (("" (FLATTEN) NIL NIL)) NIL)) NIL)
   UNCHECKED NIL 26 20 NIL NIL))
 (|boolrewrite_4| 0
  (|boolrewrite_4-1| NIL 3098837897 3175379906
   ("" (SKOLEM!) (("" (ASSERT) (("" (FLATTEN) NIL NIL)) NIL)) NIL)
   UNCHECKED NIL 79 30 NIL NIL))
 (|boolrewrite_5| 0
  (|boolrewrite_5-1| NIL 3098837915 3175379907
   ("" (SKOLEM!) (("" (ASSERT) NIL NIL)) NIL) UNCHECKED NIL 22 20 NIL
   NIL))
 (|boolrewrite_6| 0
  (|boolrewrite_6-1| NIL 3098837935 3175379907
   ("" (SKOLEM!) (("" (ASSERT) NIL NIL)) NIL) UNCHECKED NIL 21 20 NIL
   NIL))
 (|boolrewrite_7| 0
  (|boolrewrite_7-1| NIL 3098837952 3175379907
   ("" (SKOLEM!) (("" (ASSERT) NIL NIL)) NIL) UNCHECKED NIL 12 10 NIL
   NIL))
 (|boolrewrite_8| 0
  (|boolrewrite_8-1| NIL 3098837973 3175379907
   ("" (SKOLEM!) (("" (ASSERT) NIL NIL)) NIL) UNCHECKED NIL 11 10 NIL
   NIL))
 (|boolrewrite_9| 0
  (|boolrewrite_9-1| NIL 3098837986 3175379907
   ("" (SKOLEM!) (("" (ASSERT) NIL NIL)) NIL) UNCHECKED NIL 12 10 NIL
   NIL))
 (|boolrewrite_10| 0
  (|boolrewrite_10-1| NIL 3098838004 3175379907
   ("" (SKOLEM!) (("" (ASSERT) NIL NIL)) NIL) UNCHECKED NIL 11 20 NIL
   NIL))
 (|boolrewrite_11| 0
  (|boolrewrite_11-1| NIL 3098838025 3175379907
   ("" (SKOLEM!) (("" (ASSERT) NIL NIL)) NIL) UNCHECKED NIL 14 10 NIL
   NIL))
 (|boolrewrite_12| 0
  (|boolrewrite_12-1| NIL 3098838040 3175379907
   ("" (SKOLEM!) (("" (ASSERT) NIL NIL)) NIL) UNCHECKED NIL 12 10 NIL
   NIL))
 (|boolrewrite_13| 0
  (|boolrewrite_13-1| NIL 3098838065 3175379907
   ("" (SKOLEM!) (("" (ASSERT) NIL NIL)) NIL) UNCHECKED NIL 13 10 NIL
   NIL))
 (|boolrewrite_14| 0
  (|boolrewrite_14-1| NIL 3098838088 3175379907
   ("" (SKOLEM!) (("" (ASSERT) NIL NIL)) NIL) UNCHECKED NIL 12 10 NIL
   NIL))
 (|boolrewrite_15| 0
  (|boolrewrite_15-1| NIL 3098838101 3175379907
   ("" (SKOLEM!)
    (("" (APPLY (REPEAT* (THEN (FLATTEN) (ASSERT)))) NIL NIL)) NIL)
   UNCHECKED NIL 67 30 NIL NIL))
 (|boolrewrite_16| 0
  (|boolrewrite_16-1| NIL 3098838120 3175379907
   ("" (SKOLEM!)
    (("" (APPLY (REPEAT* (THEN (FLATTEN) (ASSERT)))) NIL NIL)) NIL)
   UNCHECKED NIL 23 30 NIL NIL))
 (|boolrewrite_17| 0
  (|boolrewrite_17-1| NIL 3175379895 3175379980 ("" (ASSERT) NIL NIL)
   UNCHECKED NIL 3430 10 T NIL))
 (|boolrewrite_18| 0
  (|boolrewrite_18-1| NIL 3175379895 3175379996 ("" (ASSERT) NIL NIL)
   UNCHECKED NIL 10688 10 T NIL))
 (|boolrewrite_19| 0
  (|boolrewrite_19-1| NIL 3175379895 3175379968 ("" (ASSERT) NIL NIL)
   UNCHECKED NIL 2076 20 T NIL))
 (|boolrewrite_20| 0
  (|boolrewrite_20-1| NIL 3175379895 3175380004 ("" (ASSERT) NIL NIL)
   UNCHECKED NIL 3426 20 T NIL))
 (|boolrewrite_21| 0
  (|boolrewrite_21-1| NIL 3175379895 3175380016 ("" (ASSERT) NIL NIL)
   UNCHECKED NIL 1858 20 T NIL))
 (|boolrewrite_22| 0
  (|boolrewrite_22-1| NIL 3175379895 3175380043 ("" (ASSERT) NIL NIL)
   UNCHECKED NIL 2635 20 T NIL))
 (|boolrewrite_23| 0
  (|boolrewrite_23-1| NIL 3175379895 3175380050 ("" (ASSERT) NIL NIL)
   UNCHECKED NIL 3237 20 T NIL))
 (|boolrewrite_24| 0
  (|boolrewrite_24-1| NIL 3175379895 3175380057 ("" (ASSERT) NIL NIL)
   UNCHECKED NIL 2278 20 T NIL))
 (|boolrewrite_25| 0
  (|boolrewrite_25-1| NIL 3175379895 3175380064 ("" (ASSERT) NIL NIL)
   UNCHECKED NIL 2078 30 T NIL))
 (|boolrewrite_26| 0
  (|boolrewrite_26-1| NIL 3175379895 3175380069 ("" (ASSERT) NIL NIL)
   UNCHECKED NIL 2047 20 T NIL))
 (|boolrewrite_27| 0
  (|boolrewrite_27-1| NIL 3175379895 3175380075 ("" (ASSERT) NIL NIL)
   UNCHECKED NIL 2188 20 T NIL))
 (|boolrewrite_28| 0
  (|boolrewrite_28-1| NIL 3175379895 3175380080 ("" (ASSERT) NIL NIL)
   UNCHECKED NIL 2289 20 T NIL))
 (|boolrewrite_29| 0
  (|boolrewrite_29-1| NIL 3179507745 3179507936
   ("" (SKOLEM!) (("" (IFF) (("" (PROP) NIL NIL)) NIL)) NIL) PROVED NIL
   30068 280 T NIL))
 (|boolrewrite_30| 0
  (|boolrewrite_30-1| NIL 3179507745 3179507953
   ("" (SKOLEM!) (("" (IFF) (("" (PROP) NIL NIL)) NIL)) NIL) PROVED NIL
   9594 30 T NIL))
 (|boolrewrite_31| 0
  (|boolrewrite_31-1| NIL 3179507745 3179507966
   ("" (SKOLEM!) (("" (IFF) (("" (PROP) NIL NIL)) NIL)) NIL) PROVED NIL
   10052 40 T NIL))
 (|boolrewrite_32| 0
  (|boolrewrite_32-1| NIL 3179507745 3179507982
   ("" (SKOLEM!) (("" (IFF) (("" (PROP) NIL NIL)) NIL)) NIL) PROVED NIL
   8968 40 T NIL)))


$$$../ttm_lib/list_forward.pvs
list_forward [T: TYPE]: THEORY

  BEGIN

    IMPORTING list[T]

    listforward_1: LEMMA (FORALL (L: list[T]):
       length(L) = 0 => L = (null::list[T]));

    listforward_1a: LEMMA (FORALL (L: list[T]):
       length(L) <= 0 => L = (null::list[T]));

    listforward_2: LEMMA (FORALL (L: list[T]):
       L = (null::list[T]) => length(L) = 0);

    listforward_3: LEMMA (FORALL (L: list[T]):
       not(L = (null::list[T])) => length(cdr(L)) < length(L));

    listforward_4: LEMMA (FORALL (n: nat, e:T, L: list[T]):
       length(cons(e,L)) = n => length(L) = n-1);

    listforward_5: LEMMA (FORALL (n: nat, e:T, L: list[T]):
       length(cons(e,L)) < n => length(L) < n-1);

    listforward_6: LEMMA (FORALL (n: nat, L: list[T]):
       (length(L) <= n) => (not(L = (null::list[T])) => length(cdr(L)) <= n-1));

    listforward_7: LEMMA (FORALL (L: list[T]):
       length(L) < 1 => length(L) = 0);

    listforward_8: LEMMA (FORALL (L: list[T]):
       length(L) = 1 =>  cdr(L) = (null::list[T]));

    listrewrite_9: LEMMA (FORALL (n: nat, e:T, L: list[T]):
       length(L) = n => length(cons(e,L)) = n + 1);

  END list_forward

$$$../ttm_lib/list_forward.prf
(|list_forward|
 (|listforward_1| 0
  (|listforward_1-2| "what's different?" 3117479226 3175379631
   ("" (SKOLEM 1 "l_1")
    (("" (EXPAND "length")
      (("" (APPLY (THEN (LIFT-IF) (ASSERT)))
        (("" (SPLIT)
          (("1" (FLATTEN) NIL NIL)
           ("2" (BDDSIMP)
            (("2" (TYPEPRED "length(cdr(l_1))")
              (("1" (ASSERT) NIL NIL) ("2" (ASSERT) NIL NIL)) NIL))
            NIL))
          NIL))
        NIL))
      NIL))
    NIL)
   PROVED
   ((|length| DEF-DECL "nat" |list_props| NIL)
    (|cdr| ADT-ACCESSOR-DECL "[(cons?) -> list]" |list_adt| NIL)
    (|cons?| ADT-RECOGNIZER-DECL "[list -> boolean]" |list_adt| NIL)
    (|nat| NONEMPTY-TYPE-EQ-DECL NIL |naturalnumbers| NIL)
    (|int| NONEMPTY-TYPE-EQ-DECL NIL |integers| NIL)
    (|integer_pred| CONST-DECL
     "[{x: {x: number | real_pred(x)} | rational_pred(x)} -> boolean]"
     |integers| NIL)
    (|rational| NONEMPTY-TYPE-FROM-DECL NIL |rationals| NIL)
    (|rational_pred| CONST-DECL
     "[{x: number | real_pred(x)} -> boolean]" |rationals| NIL)
    (|list| TYPE-DECL NIL |list_adt| NIL)
    (T FORMAL-TYPE-DECL NIL |list_forward| NIL)
    (>= CONST-DECL "bool" |reals| NIL)
    (|real| NONEMPTY-TYPE-FROM-DECL NIL |reals| NIL)
    (|real_pred| CONST-DECL "[number -> boolean]" |reals| NIL)
    (|number| NONEMPTY-TYPE-DECL NIL |numbers| NIL)
    (NOT CONST-DECL "[bool -> bool]" |booleans| NIL)
    (|bool| NONEMPTY-TYPE-EQ-DECL NIL |booleans| NIL)
    (|boolean| NONEMPTY-TYPE-DECL NIL |booleans| NIL))
   801 500 NIL NIL)
  (|listforward_1-1| NIL 3117400872 3117474681
   ("" (SKOLEM 1 "l_1")
    (("" (EXPAND "length")
      (("" (APPLY (THEN (LIFT-IF) (ASSERT)))
        (("" (SPLIT)
          (("1" (FLATTEN)
            (("1" (BDDSIMP) (("1" (PROPAX) NIL NIL)) NIL)) NIL)
           ("2" (TYPEPRED "length(cdr(l_1))")
            (("1" (ASSERT) NIL NIL) ("2" (ASSERT) NIL NIL)) NIL))
          NIL))
        NIL))
      NIL))
    NIL)
   PROVED
   ((|length| DEF-DECL "nat" |list_props| NIL)
    (|cons?| ADT-RECOGNIZER-DECL "[list -> boolean]" |list_adt| NIL)
    (|boolean| NONEMPTY-TYPE-DECL NIL |booleans| NIL)
    (|list| TYPE-DECL NIL |list_adt| NIL)
    (T FORMAL-TYPE-DECL NIL |list_forward| NIL)
    (|cdr| ADT-ACCESSOR-DECL "[(cons?) -> list]" |list_adt| NIL)
    (|nat| NONEMPTY-TYPE-EQ-DECL NIL |naturalnumbers| NIL)
    (|integer| NONEMPTY-TYPE-FROM-DECL NIL |integers| NIL)
    (|integer_pred| CONST-DECL
     "[{x: {x: number | real_pred(x)} | rational_pred(x)} -> boolean]"
     |integers| NIL)
    (|rational_pred| CONST-DECL
     "[{x: number | real_pred(x)} -> 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 -> boolean]" |reals| NIL)
    (|number| NONEMPTY-TYPE-DECL NIL |numbers| NIL)
    (NOT CONST-DECL "[bool -> bool]" |booleans| NIL))
   1710 350 NIL NIL))
 (|listforward_1a| 0
  (|listforward_1a-1| NIL 3117478926 3175379631
   ("" (SKOLEM 1 "l_1")
    (("" (EXPAND "length")
      (("" (APPLY (THEN (LIFT-IF) (ASSERT)))
        (("" (SPLIT)
          (("1" (FLATTEN) NIL NIL)
           ("2" (BDDSIMP)
            (("2" (TYPEPRED "length(cdr(l_1))")
              (("1" (ASSERT) NIL NIL) ("2" (ASSERT) NIL NIL)) NIL))
            NIL))
          NIL))
        NIL))
      NIL))
    NIL)
   PROVED
   ((|length| DEF-DECL "nat" |list_props| NIL)
    (|cdr| ADT-ACCESSOR-DECL "[(cons?) -> list]" |list_adt| NIL)
    (|cons?| ADT-RECOGNIZER-DECL "[list -> boolean]" |list_adt| NIL)
    (|nat| NONEMPTY-TYPE-EQ-DECL NIL |naturalnumbers| NIL)
    (|int| NONEMPTY-TYPE-EQ-DECL NIL |integers| NIL)
    (|integer_pred| CONST-DECL
     "[{x: {x: number | real_pred(x)} | rational_pred(x)} -> boolean]"
     |integers| NIL)
    (|rational| NONEMPTY-TYPE-FROM-DECL NIL |rationals| NIL)
    (|rational_pred| CONST-DECL
     "[{x: number | real_pred(x)} -> boolean]" |rationals| NIL)
    (|list| TYPE-DECL NIL |list_adt| NIL)
    (T FORMAL-TYPE-DECL NIL |list_forward| NIL)
    (>= CONST-DECL "bool" |reals| NIL)
    (|real| NONEMPTY-TYPE-FROM-DECL NIL |reals| NIL)
    (|real_pred| CONST-DECL "[number -> boolean]" |reals| NIL)
    (|number| NONEMPTY-TYPE-DECL NIL |numbers| NIL)
    (NOT CONST-DECL "[bool -> bool]" |booleans| NIL)
    (|bool| NONEMPTY-TYPE-EQ-DECL NIL |booleans| NIL)
    (|boolean| NONEMPTY-TYPE-DECL NIL |booleans| NIL))
   333 220 NIL NIL))
 (|listforward_2| 0
  (|listforward_2-1| NIL 3117401286 3175379632
   ("" (SKOLEM 1 "l_1")
    (("" (FLATTEN) (("" (EXPAND "length") (("" (ASSERT) NIL NIL)) NIL))
      NIL))
    NIL)
   PROVED ((|length| DEF-DECL "nat" |list_props| NIL)) 62 60 NIL NIL))
 (|listforward_3_TCC1| 0
  (|listforward_3_TCC1-1| NIL 3117400835 3117400837 ("" (SUBTYPE-TCC))
   PROVED-COMPLETE NIL 2793 230 NIL NIL))
 (|listforward_3| 0
  (|listforward_3-1| NIL 3117401324 3175379632
   ("" (SKOLEM 1 "l_1")
    (("" (FLATTEN)
      (("" (EXPAND "length" 2 2) (("" (ASSERT) NIL NIL)) NIL)) NIL))
    NIL)
   PROVED ((|length| DEF-DECL "nat" |list_props| NIL)) 196 80 NIL NIL))
 (|listforward_4| 0
  (|listforward_4-1| NIL 3117401431 3175379632
   ("" (SKOLEM 1 ("n_1" "e_1" "l_1"))
    (("" (FLATTEN)
      (("" (EXPAND "length" -1) (("" (ASSERT) NIL NIL)) NIL)) NIL))
    NIL)
   PROVED ((|length| DEF-DECL "nat" |list_props| NIL)) 334 160 NIL
   NIL))
 (|listforward_5| 0
  (|listforward_5-1| NIL 3117401478 3175379632
   ("" (SKOLEM 1 ("n_1" "e_1" "l_1"))
    (("" (FLATTEN)
      (("" (EXPAND "length" -1) (("" (ASSERT) NIL NIL)) NIL)) NIL))
    NIL)
   PROVED ((|length| DEF-DECL "nat" |list_props| NIL)) 115 120 NIL
   NIL))
 (|listforward_6| 0
  (|listforward_6-1| NIL 3117401511 3175379632
   ("" (SKOLEM 1 ("n_1" "l_1"))
    (("" (FLATTEN)
      (("" (EXPAND "length" -1) (("" (ASSERT) NIL NIL)) NIL)) NIL))
    NIL)
   PROVED ((|length| DEF-DECL "nat" |list_props| NIL)) 163 110 NIL
   NIL))
 (|listforward_7| 0
  (|listforward_7-1| NIL 3117474717 3175379632
   ("" (SKOLEM 1 "l_1") (("" (FLATTEN) (("" (ASSERT) NIL NIL)) NIL))
    NIL)
   PROVED NIL 32 30 NIL NIL))
 (|listforward_8_TCC1| 0
  (|listforward_8_TCC1-1| NIL 3117478201 3117478274
   ("" (SKOLEM 1 "l_1")
    (("" (FLATTEN)
      (("" (EXPAND "length")
        (("" (APPLY (THEN (LIFT-IF) (ASSERT))) NIL NIL)) NIL))
      NIL))
    NIL)
   PROVED-COMPLETE ((|length| DEF-DECL "nat" |list_props| NIL)) 42654
   470 NIL NIL))
 (|listforward_8| 0
  (|listforward_8-1| NIL 3117478296 3175379633
   ("" (SKOLEM 1 "l_1")
    (("" (FLATTEN)
      (("" (EXPAND "length")
        (("" (APPLY (THEN (LIFT-IF) (ASSERT)))
          (("" (BDDSIMP)
            (("" (EXPAND "length") (("" (ASSERT) NIL NIL)) NIL)) NIL))
          NIL))
        NIL))
      NIL))
    NIL)
   PROVED ((|length| DEF-DECL "nat" |list_props| NIL)) 210 170 NIL
   NIL))
 (|listrewrite_9| 0
  (|listrewrite_9-1| NIL 3175379621 3175379735
   ("" (SKOLEM 1 ("n_1" "e_1" "L_1"))
    (("" (FLATTEN)
      (("" (EXPAND "length" 1) (("" (PROPAX) NIL NIL)) NIL)) NIL))
    NIL)
   PROVED ((|length| DEF-DECL "nat" |list_props| NIL)) 69097 100 T
   NIL)))


$$$../ttm_lib/list_rewrites.pvs
list_rewrites [T: TYPE]: THEORY

  BEGIN

    IMPORTING list[T]
    IMPORTING list_forward[T]

    listrewrite_1: LEMMA (length(null::list[T]) = 0);

    listrewrite_2: LEMMA (FORALL (L: list[T]):
       length(L) = 0 => L = (null::list[T]));

    listrewrite_3: LEMMA (FORALL (n: nat, e:T, L: list[T]):
       length(L) = n => length(cons(e,L)) = n + 1);

    listrewrite_4: LEMMA (FORALL (e:T, L: list[T]):
       L = (null::list[T]) => length(cons(e,L)) = 1);

    listrewrite_5: LEMMA (FORALL (n: nat, e:T, L: list[T]):
       (not(L = (null::list[T])) & length(L) = n) => length(cdr(L)) = n-1);

    listrewrite_6: LEMMA (FORALL (n: nat, e:T, L: list[T]):
       (not(L = (null::list[T])) & length(L) <= n) => length(cdr(L)) <= n-1);

    listrewrite_7: LEMMA (FORALL (L: list[T]): length(L) < 0 = FALSE);

  END list_rewrites

$$$../ttm_lib/list_rewrites.prf
(|list_rewrites|
 (|listrewrite_1| 0
  (|listrewrite_1-1| NIL 3117316491 3117471692
   ("" (EXPAND "length") (("" (PROPAX) NIL NIL)) NIL) PROVED
   ((|length| DEF-DECL "nat" |list_props| NIL)) 575 60 NIL))
 (|listrewrite_2| 0
  (|listrewrite_2-1| NIL 3117316501 3117471782
   ("" (SKOLEM 1 "l_1")
    (("" (FLATTEN)
      (("" (EXPAND "length") (("" (APPLY (THEN (LIFT-IF) (ASSERT))) NIL NIL))
        NIL))
      NIL))
    NIL)
   PROVED ((|length| DEF-DECL "nat" |list_props| NIL)) 29865 180 NIL))
 (|listrewrite_3| 0
  (|listrewrite_3-3| "" 3117401788 3117471787
   ("" (SKOLEM 1 ("n_1" "e_1" "l_1"))
    (("" (FLATTEN) (("" (EXPAND "length" 1) (("" (PROPAX) NIL NIL)) NIL))
      NIL))
    NIL)
   PROVED ((|length| DEF-DECL "nat" |list_props| NIL)) 153 120 NIL)
  (|listrewrite_3-2| "" 3117401702 3117401702
   ("" (SKOLEM 1 ("e_1" "l_1"))
    (("" (FLATTEN)
      (("" (EXPAND "length" 1)
        (("" (APPLY (THEN (REPLACE -1) (SIMPLIFY)))
          (("" (EXPAND "length") (("" (PROPAX) NIL NIL)) NIL)) NIL))
        NIL))
      NIL))
    NIL)
   PROVED ((|length| DEF-DECL "nat" |list_props| NIL)) 66356 270 NIL)
  (|listrewrite_3-1| NIL 3117317267 3117317551
   ("" (SKOLEM 1 "l_1")
    (("" (EXPAND "length")
      (("" (APPLY (THEN (LIFT-IF) (ASSERT)))
        (("" (APPLY (THEN (SPLIT) (FLATTEN) (ASSERT)))
          (("" (APPLY (THEN (REPLACE -1) (SIMPLIFY))) NIL NIL)) NIL))
        NIL))
      NIL))
    NIL)
   PROVED ((|length| DEF-DECL "nat" |list_props| NIL)) 75262 290 NIL))
 (|listrewrite_4| 0
  (|listrewrite_4-1| NIL 3117401714 3117471896
   ("" (SKOLEM 1 ("e_1" "l_1"))
    (("" (FLATTEN)
      (("" (EXPAND "length")
        (("" (EXPAND "length")
          (("" (APPLY (THEN (LIFT-IF) (ASSERT))) NIL NIL)) NIL))
        NIL))
      NIL))
    NIL)
   PROVED ((|length| DEF-DECL "nat" |list_props| NIL)) 31763 200 NIL))
 (|listrewrite_5_TCC1| 0
  (|listrewrite_5_TCC1-1| NIL 3117471668 3117471672 ("" (SUBTYPE-TCC)) PROVED
   ((|nat| NONEMPTY-TYPE-EQ-DECL NIL |naturalnumbers| NIL)
    (|integer| NONEMPTY-TYPE-FROM-DECL NIL |integers| NIL)
    (|integer_pred| CONST-DECL
     "[{x: {x: number | real_pred(x)} | rational_pred(x)} -> boolean]"
     |integers| NIL)
    (|rational_pred| CONST-DECL "[{x: number | real_pred(x)} -> 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 -> boolean]" |reals| NIL)
    (|number| NONEMPTY-TYPE-DECL NIL |numbers| NIL)
    (NOT CONST-DECL "[bool -> bool]" |booleans| NIL)
    (|boolean| NONEMPTY-TYPE-DECL NIL |booleans| NIL))
   3798 320 NIL))
 (|listrewrite_5| 0
  (|listrewrite_5-1| NIL 3117471840 3117471849
   ("" (SKOLEM 1 ("n_1" "e_1" "l_1"))
    (("" (FLATTEN)
      (("" (EXPAND "length" -1)
        (("" (APPLY (THEN (LIFT-IF) (ASSERT))) NIL NIL)) NIL))
      NIL))
    NIL)
   PROVED ((|length| DEF-DECL "nat" |list_props| NIL)) 8702 280 NIL))
 (|listrewrite_6_TCC1| 0
  (|listrewrite_6_TCC1-1| NIL 3117471672 3117471673 ("" (SUBTYPE-TCC)) PROVED
   ((|nat| NONEMPTY-TYPE-EQ-DECL NIL |naturalnumbers| NIL)
    (|integer| NONEMPTY-TYPE-FROM-DECL NIL |integers| NIL)
    (|integer_pred| CONST-DECL
     "[{x: {x: number | real_pred(x)} | rational_pred(x)} -> boolean]"
     |integers| NIL)
    (|rational_pred| CONST-DECL "[{x: number | real_pred(x)} -> 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 -> boolean]" |reals| NIL)
    (|number| NONEMPTY-TYPE-DECL NIL |numbers| NIL)
    (NOT CONST-DECL "[bool -> bool]" |booleans| NIL)
    (|boolean| NONEMPTY-TYPE-DECL NIL |booleans| NIL))
   1508 310 NIL))
 (|listrewrite_6| 0
  (|listrewrite_6-1| NIL 3117471819 3117471828
   ("" (SKOLEM 1 ("n_1" "e_1" "l_1"))
    (("" (FLATTEN)
      (("" (EXPAND "length" -1)
        (("" (APPLY (THEN (LIFT-IF) (ASSERT))) NIL NIL)) NIL))
      NIL))
    NIL)
   PROVED ((|length| DEF-DECL "nat" |list_props| NIL)) 8860 260 NIL))
 (|listrewrite_7| 0
  (|listrewrite_7-1| NIL 3117483024 3117483187
   ("" (SKOLEM 1 "l_1")
    (("" (EXPAND "length")
      (("" (LIFT-IF)
        (("" (TYPEPRED "length(cdr(l_1))")
          (("1" (APPLY (THEN (SPLIT) (ASSERT))) NIL NIL)
           ("2" (ASSERT) NIL NIL))
          NIL))
        NIL))
      NIL))
    NIL)
   PROVED
   ((|length| DEF-DECL "nat" |list_props| NIL)
    (|cons?| ADT-RECOGNIZER-DECL "[list -> boolean]" |list_adt| NIL)
    (|boolean| NONEMPTY-TYPE-DECL NIL |booleans| NIL)
    (|list| TYPE-DECL NIL |list_adt| NIL)
    (T FORMAL-TYPE-DECL NIL |list_rewrites| NIL)
    (|cdr| ADT-ACCESSOR-DECL "[(cons?) -> list]" |list_adt| NIL)
    (|nat| NONEMPTY-TYPE-EQ-DECL NIL |naturalnumbers| NIL)
    (|integer| NONEMPTY-TYPE-FROM-DECL NIL |integers| NIL)
    (|integer_pred| CONST-DECL
     "[{x: {x: number | real_pred(x)} | rational_pred(x)} -> boolean]"
     |integers| NIL)
    (|rational_pred| CONST-DECL "[{x: number | real_pred(x)} -> 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 -> boolean]" |reals| NIL)
    (|number| NONEMPTY-TYPE-DECL NIL |numbers| NIL)
    (NOT CONST-DECL "[bool -> bool]" |booleans| NIL))
   65531 360 NIL)))

$$$time_adt.pvs
%%% ADT file generated from time

time_adt: THEORY
 BEGIN

  time: TYPE

  fintime?, inftime?: [time -> boolean]

  fintime: [nat -> (fintime?)]

  dur: [(fintime?) -> nat]

  infinity: (inftime?)

  ord(x: time): upto(1) =
      CASES x OF fintime(fintime1_var): 0, infinity: 1 ENDCASES

  time_fintime_extensionality: AXIOM
    FORALL (fintime?_var: (fintime?), fintime?_var2: (fintime?)):
      dur(fintime?_var) = dur(fintime?_var2) IMPLIES
       fintime?_var = fintime?_var2;

  time_fintime_eta: AXIOM
    FORALL (fintime?_var: (fintime?)):
      fintime(dur(fintime?_var)) = fintime?_var;

  time_infinity_extensionality: AXIOM
    FORALL (inftime?_var: (inftime?), inftime?_var2: (inftime?)):
      inftime?_var = inftime?_var2;

  time_dur_fintime: AXIOM
    FORALL (fintime1_var: nat): dur(fintime(fintime1_var)) = fintime1_var;

  time_inclusive: AXIOM
    FORALL (time_var: time): fintime?(time_var) OR inftime?(time_var);

  time_induction: AXIOM
    FORALL (p: [time -> boolean]):
      (FORALL (fintime1_var: nat): p(fintime(fintime1_var))) AND
       p(infinity)
       IMPLIES (FORALL (time_var: time): p(time_var));

  subterm(x, y: time):  boolean = x = y;

  <<(x, y: time):  boolean = FALSE;

  time_well_founded: AXIOM well_founded?[time](<<);

  reduce_nat(fintime?_fun: [nat -> nat], inftime?_fun: nat):
  [time -> nat] =
      LAMBDA (time_adtvar: time):
        LET red: [time -> nat] = reduce_nat(fintime?_fun, inftime?_fun) IN
          CASES time_adtvar
            OF fintime(fintime1_var): fintime?_fun(fintime1_var),
               infinity: inftime?_fun
            ENDCASES;

  REDUCE_nat(fintime?_fun: [[nat, time] -> nat],
             inftime?_fun: [time -> nat]):
   [time -> nat] =
      LAMBDA (time_adtvar: time):
        LET red: [time -> nat] = REDUCE_nat(fintime?_fun, inftime?_fun) IN
          CASES time_adtvar
            OF fintime(fintime1_var):
                 fintime?_fun(fintime1_var, time_adtvar),
               infinity: inftime?_fun(time_adtvar)
            ENDCASES;

  reduce_ordinal(fintime?_fun: [nat -> ordinal], inftime?_fun: ordinal):
  [time -> ordinal] =
      LAMBDA (time_adtvar: time):
        LET red: [time -> ordinal] =
              reduce_ordinal(fintime?_fun, inftime?_fun)
          IN
          CASES time_adtvar
            OF fintime(fintime1_var): fintime?_fun(fintime1_var),
               infinity: inftime?_fun
            ENDCASES;

  REDUCE_ordinal(fintime?_fun: [[nat, time] -> ordinal],
                 inftime?_fun: [time -> ordinal]):
   [time -> ordinal] =
      LAMBDA (time_adtvar: time):
        LET red: [time -> ordinal] =
              REDUCE_ordinal(fintime?_fun, inftime?_fun)
          IN
          CASES time_adtvar
            OF fintime(fintime1_var):
                 fintime?_fun(fintime1_var, time_adtvar),
               infinity: inftime?_fun(time_adtvar)
            ENDCASES;
 END time_adt

time_adt_reduce[range: TYPE]: THEORY
 BEGIN

  IMPORTING time_adt

  reduce(fintime?_fun: [nat -> range], inftime?_fun: range):
  [time -> range] =
      LAMBDA (time_adtvar: time):
        LET red: [time -> range] = reduce(fintime?_fun, inftime?_fun) IN
          CASES time_adtvar
            OF fintime(fintime1_var): fintime?_fun(fintime1_var),
               infinity: inftime?_fun
            ENDCASES;

  REDUCE(fintime?_fun: [[nat, time] -> range],
         inftime?_fun: [time -> range]):
   [time -> range] =
      LAMBDA (time_adtvar: time):
        LET red: [time -> range] = REDUCE(fintime?_fun, inftime?_fun) IN
          CASES time_adtvar
            OF fintime(fintime1_var):
                 fintime?_fun(fintime1_var, time_adtvar),
               infinity: inftime?_fun(time_adtvar)
            ENDCASES;
 END time_adt_reduce
$$$time.pvs
time: DATATYPE

  BEGIN

    fintime(dur: nat): fintime?
    infinity: inftime?

  END time

$$$time_thy.pvs
time_thy: THEORY

  BEGIN

    IMPORTING time

    zero:time = fintime(0);
    one:time = fintime(1);
    two:time = fintime(2);
    three:time = fintime(3);
    four:time = fintime(4);
    nineteen:time = fintime(19);
    twenty:time = fintime(20);
    twenty_nine:time = fintime(29);
    thirty:time = fintime(30);	

    <= (t1,t2:time):bool =
       IF fintime?(t1) & fintime?(t2) THEN dur(t1) <= dur(t2)
       ELSE inftime?(t2)
       ENDIF;

    >= (t1,t2:time):bool =
       IF fintime?(t1) & fintime?(t2) THEN dur(t1) >= dur(t2)
       ELSE inftime?(t1)
       ENDIF;

    < (t1,t2:time):bool =
       IF fintime?(t1) & fintime?(t2) THEN dur(t1) < dur(t2)
       ELSE NOT(inftime?(t1)) & inftime?(t2)
       ENDIF;

    > (t1,t2:time):bool =
       IF fintime?(t1) & fintime?(t2) THEN dur(t1) > dur(t2)
       ELSE NOT(inftime?(t2)) & inftime?(t1)
       ENDIF;

    + (t1,t2:time):time =
       IF fintime?(t1) & fintime?(t2) THEN fintime(dur(t1) + dur(t2))
       ELSE infinity
       ENDIF;

    - (t1:time, t2:(fintime?)):time =
       IF fintime?(t1) & dur(t1) >= dur(t2) THEN fintime(dur(t1) - dur(t2))
       ELSE infinity
       ENDIF;

    fintime_unique: LEMMA
       (FORALL (z1,z2:nat):(fintime(z1) = fintime(z2)) => (z1 = z2));

    fintime_elim_1: LEMMA
       (FORALL (z:nat, t:(fintime?)):
      %(FORALL (z:nat, t:time):
         (fintime(z) = t) => (z = dur(t)));
        %(fintime(z) = t) = (z = dur(t)));

    fintime_elim_2: LEMMA
       (FORALL (z:nat, t:(fintime?)):
      %(FORALL (z:nat, t:time):
         (t = fintime(z)) => (dur(t) = z));
        %(t = fintime(z)) = (dur(t) = z));

    fintime_dur: LEMMA
       (FORALL (t:(fintime?)): fintime(dur(t)) = t);

    trans_order: LEMMA
       (FORALL (t1,t2,t3:time): t1 <= t2 & t2 <= t3 => t1 <= t3)

  END time_thy

$$$time_thy.prf
(|time_thy| (|difference_TCC1| "" (SKOSIMP) (("" (GRIND) NIL NIL)) NIL)
 (|fintime_unique_TCC1| "" (SUBTYPE-TCC))
 (|fintime_unique_TCC2| "" (SUBTYPE-TCC))
 (|fintime_unique| "" (SKOLEM-TYPEPRED)
  (("" (FLATTEN)
    (("" (CASE "z1!1 = dur(fintime(z1!1))")
      (("1" (CASE "z2!1 = dur(fintime(z2!1))")
        (("1" (REPLACE -1 1)
          (("1" (REPLACE -2 1)
            (("1" (REPLACE -5 1) (("1" (PROPAX) NIL NIL)) NIL)) NIL))
          NIL)
         ("2" (ASSERT) NIL NIL))
        NIL)
       ("2" (ASSERT) NIL NIL))
      NIL))
    NIL))
  NIL)
 (|fintime_elim_1_TCC1| "" (SUBTYPE-TCC))
 (|fintime_elim_1| "" (SKOLEM-TYPEPRED)
  (("" (CASE "z!1 = dur(t!1)")
    (("1" (REPLACE -1 1) (("1" (SIMPLIFY 1) (("1" (PROPAX) NIL NIL)) NIL))
      NIL)
     ("2" (SIMPLIFY)
      (("2" (CASE "(z!1 = dur(t!1)) = FALSE")
        (("1" (REPLACE -1 2)
          (("1" (SIMPLIFY)
            (("1" (REPLACE -3 * RL)
              (("1" (SIMPLIFY) (("1" (PROPAX) NIL NIL)) NIL)) NIL))
            NIL))
          NIL)
         ("2" (SIMPLIFY) (("2" (PROPAX) NIL NIL)) NIL))
        NIL))
      NIL))
    NIL))
  NIL)
 (|fintime_elim_2| "" (SKOLEM-TYPEPRED)
  (("" (CASE "z!1 = dur(t!1)")
    (("1" (REPLACE -1 1) (("1" (SIMPLIFY 1) (("1" (PROPAX) NIL NIL)) NIL))
      NIL)
     ("2" (CASE "(dur(t!1) = z!1) = FALSE")
      (("1" (REPLACE -1 2)
        (("1" (SIMPLIFY)
          (("1" (REPLACE -3) (("1" (SIMPLIFY) (("1" (PROPAX) NIL NIL)) NIL))
            NIL))
          NIL))
        NIL)
       ("2" (ASSERT) NIL NIL))
      NIL))
    NIL))
  NIL)
 (|fintime_dur| "" (SKOLEM-TYPEPRED) (("" (APPLY-EXTENSIONALITY) NIL NIL))
  NIL)
 (|trans_order| "" (SKOLEM-TYPEPRED)
  (("" (FLATTEN) (("" (ASSERT) (("" (GRIND) NIL NIL)) NIL)) NIL)) NIL))


$$$ttm1decls.pvs
ttm1_decls: THEORY

BEGIN

	ttm_lib: LIBRARY = "../ttm_lib"

% ----Beginning of the frist TTM declaration ----------
% We add a prefix S for specification to the variable names to
% distingush from the prefix I for Implementation.
% type and function declarations:

	IMPORTING time_thy
	IMPORTING ttm_lib@list_rewrites
	IMPORTING ttm_lib@bool_rewrites

	activity: TYPE = {a,b,c,d,e}
	
	IMPORTING action1

%% state variables

	s_internal_state: TYPE = [# Relay: bool, Power:bool, Pressure:bool #]

% Auxiliary functions

	lower_bound (ac:S_nt_action): time =
	 	CASES ac OF
		        mu: one,
		        omega29: twenty_nine,
			alpha: one,
			omega19: nineteen,
			rho1: one,
			rho2: one,
			gamma: one,
			wr: one,
			ws: one,
			pr: one,
			ps: one
		ENDCASES
	
	upper_bound (ac:S_nt_action): time =
		CASES ac OF
			mu: one,
		        omega29: twenty_nine,
			alpha: one,
			omega19: nineteen,
			rho1: one,
			rho2: one,
			gamma: one,
			wr: infinity,
			ws: infinity,
			pr: infinity,
			ps: infinity			
		ENDCASES

% preconditions

    enabled_state (ac:S_nt_action, si:s_internal_state): bool =
		CASES ac OF
		 	mu: si`Pressure and si`Power,
		 	omega29: True,
			alpha: si`Power,
			omega19: True,
			rho1: Not si`Power,
			rho2: Not si`Power,
			gamma: si`Power,
			wr: si`Power,
			ws: Not si`Power,
			pr: si`Pressure,
			ps: Not si`Pressure
		ENDCASES;

    graph (ac:S_nt_action, sa:activity):bool = 
         	CASES ac OF
			mu:  sa=a,
		 	omega29: sa=b,
			alpha: sa=c,
			omega19: sa=d,
			rho1: sa=c,
			rho2: sa=e,
			gamma: sa=e,
			wr: True,
			ws: True,
			pr: True,
			ps: True
	 	ENDCASES

IMPORTING ttm[activity,s_internal_state,S_nt_action,
			lower_bound,upper_bound,enabled_state,graph]


IMPORTING states[activity, S_nt_action, s_internal_state,time]

    S_state: TYPE = states[activity, S_nt_action, s_internal_state,time]
  	
    enabled(ac:S_action,s:S_state):bool =
		IF(not (tick?(ac))) THEN enabled_general(ac,s) & enabled_time(ac,s)
		ELSE enabled_tick(s)
		ENDIF

    trans (ac:S_action, s:S_state):S_state =
         	CASES ac OF
		 	tick: s WITH [ action_time:= update_clocks(s)],
			mu:   s WITH [ activity:=b, action_time:= reset_clocks(ac, s WITH [activity:=b]) ],
		 	omega29: s WITH [activity:=c, action_time:= reset_clocks(ac, s WITH [activity:=c]) ],
			alpha: s WITH [activity:=d, basic:= s`basic WITH [Relay:=True ], 
					action_time:= reset_clocks(ac, s WITH [activity:=d, basic:= s`basic WITH [Relay:=True]])],
			omega19: s WITH [activity:=e, action_time:= reset_clocks(ac, s WITH [ activity:=e ]) ],
			rho1: s WITH [activity:=a, action_time:= reset_clocks(ac, s WITH [ activity:=a ]) ],
			rho2: s WITH [activity:=a, basic:= s`basic WITH[Relay:=False], 
					action_time:= reset_clocks(ac, s WITH [activity:=a, basic:= s`basic WITH[Relay:=False]])],
			gamma: s WITH [activity:=a, action_time:= reset_clocks(ac, s WITH [ activity:=a ]) ],
			wr: s WITH [basic:=s`basic WITH [Power:=False], action_time:= reset_clocks(ac,s WITH [basic:=s`basic WITH [Power:=False]])],
			ws: s WITH [basic:=s`basic WITH [Power:=True], action_time:= reset_clocks(ac,s WITH [basic:=s`basic WITH [Power:=True]])],
			pr: s WITH [basic:=s`basic WITH [Pressure:=False], action_time:= reset_clocks(ac,s WITH [basic:=s`basic WITH [Pressure:=False]])],
			ps: s WITH [basic:=s`basic WITH [Pressure:=True], action_time:= reset_clocks(ac,s WITH [basic:=s`basic WITH [Pressure:=True]])]
	 	ENDCASES
 
% define initial state
   	
    start (s:S_state):bool = 
	  ( s = (# activity:=a,
		   basic:= (#  Relay:=False, Power:=False, Pressure:=False #),
		   action_time:=(LAMBDA (a:S_nt_action): zero)
		#)
	  )

IMPORTING ttm_lib@machine[S_state,S_action,enabled,trans,start] 

END ttm1_decls

$$$ttm1decls.prf
(|ttm1_decls| (|lower_bound_TCC1| "" (CASES-TCC) NIL NIL)
 (|enabled_TCC1| "" (SUBTYPE-TCC) NIL NIL)
 (|trans_TCC1| "" (SUBTYPE-TCC) NIL NIL)
 (|trans_TCC2| "" (SUBTYPE-TCC) NIL NIL)
 (|trans_TCC3| "" (SUBTYPE-TCC) NIL NIL)
 (|trans_TCC4| "" (SUBTYPE-TCC) NIL NIL)
 (|trans_TCC5| "" (SUBTYPE-TCC) NIL NIL)
 (|trans_TCC6| "" (SUBTYPE-TCC) NIL NIL)
 (|trans_TCC7| "" (SUBTYPE-TCC) NIL NIL)
 (|trans_TCC8| "" (SUBTYPE-TCC) NIL NIL)
 (|trans_TCC9| "" (SUBTYPE-TCC) NIL NIL)
 (|trans_TCC10| "" (SUBTYPE-TCC) NIL NIL)
 (|trans_TCC11| "" (SUBTYPE-TCC) NIL NIL))


$$$ttm1invariant.pvs
ttm1_invariants  	: THEORY

   BEGIN

	IMPORTING  ttm1_decls

   	Inv_1(s:S_state): bool = 

			(s`activity=a and (s`action_time(mu)= zero or s`action_time(mu)=one)  
			  and s`action_time(omega29)=zero and s`action_time(alpha)=zero 
			  and s`action_time(omega19)=zero and s`action_time(rho1)=zero 
			  and s`action_time(rho2)=zero and s`action_time(gamma)=zero) or

			(s`activity=b and s`action_time(mu)= zero
			  and (s`action_time(omega29)>=zero and s`action_time(omega29)<=twenty_nine)
			  and s`action_time(alpha)=zero and s`action_time(omega19)=zero 
			  and s`action_time(rho1)=zero and s`action_time(rho2)=zero and s`action_time(gamma)=zero) or

			(s`activity=c and s`action_time(mu)= zero and s`action_time(omega29)=zero 
			  and ((s`action_time(alpha)=zero and s`action_time(rho1)=zero) 
				 or (s`action_time(alpha)=one and s`action_time(rho1)=zero) 
				 or (s`action_time(alpha)=zero and s`action_time(rho1)=one))  
			  and s`action_time(omega19)=zero 
			  and s`action_time(rho2)=zero and s`action_time(gamma)=zero) or

			(s`activity=d and s`action_time(mu)= zero and s`action_time(omega29)=zero 
			  and s`action_time(alpha)=zero 
			  and (s`action_time(omega19)>=zero and s`action_time(omega19)<=nineteen) 
			  and s`action_time(rho1)=zero and s`action_time(rho2)=zero and s`action_time(gamma)=zero) or

			(s`activity=e and s`action_time(mu)= zero and s`action_time(omega29)=zero 
			  and s`action_time(alpha)=zero and  s`action_time(omega19)= zero and s`action_time(rho1)=zero 
                          and       ((s`action_time(rho2)=zero or s`action_time(gamma)=zero)
				or  (s`action_time(rho2)=zero or s`action_time(gamma)=one)
				or  (s`action_time(rho2)=one or s`action_time(gamma)=zero)))

	Inv_11(s:S_state): bool = ((NOT s`basic`Power) => s`action_time(wr) = zero) and 
				 (s`basic`Power => s`action_time(ws) = zero) and 
				 ((NOT s`basic`Pressure) => s`action_time(pr) = zero) and
				 ( s`basic`Pressure => s`action_time(ps) = zero)	

  	lemma_1: LEMMA (FORALL (s:S_state): reachable(s) => Inv_1(s));

	lemma1_2: LEMMA (FORALL (s:S_state): reachable(s) => Inv_11(s));

  END ttm1_invariants

$$$ttm1invariant.prf
(|ttm1_invariants| (|Inv_1_TCC1| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC2| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC3| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC4| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC5| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC6| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC7| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC8| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC9| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC10| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC11| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC12| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC13| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC14| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC15| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC16| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC17| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC18| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC19| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC20| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC21| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC22| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC23| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC24| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC25| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC26| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC27| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC28| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC29| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC30| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC31| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC32| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC33| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC34| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC35| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_1_TCC36| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_11_TCC1| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_11_TCC2| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_11_TCC3| "" (SUBTYPE-TCC) NIL NIL)
 (|Inv_11_TCC4| "" (SUBTYPE-TCC) NIL NIL)
 (|lemma_1| "" (LEMMA "machine_induct")
  (("" (INST -1 "Inv_1")
    (("" (EXPAND "inductthm")
      (("" (SPLIT)
        (("1" (PROPAX) NIL NIL) ("2" (HIDE 2) (("2" (GRIND) NIL NIL)) NIL)
         ("3" (HIDE 2)
          (("3" (EXPAND "inductstep")
            (("3" (SKOLEM-TYPEPRED)
              (("3" (FLATTEN)
                (("3" (EXPAND "enabled")
                  (("3" (SPLIT)
                    (("1" (FLATTEN)
                      (("1" (EXPAND "enabled_time")
                        (("1" (FLATTEN)
                          (("1" (EXPAND "enabled_general")
                            (("1" (FLATTEN)
                              (("1" (EXPAND "enabled_state")
                                (("1" (EXPAND "graph")
                                  (("1" (CASE "a!1=tick")
                                    (("1" (GRIND) NIL NIL)
                                     ("2" (CASE "a!1=mu")
                                      (("1"
                                        (REPLACE -1 *)
                                        (("1" (GRIND) NIL NIL))
                                        NIL)
                                       ("2"
                                        (CASE "a!1=omega29")
                                        (("1" (GRIND) NIL NIL)
                                         ("2"
                                          (CASE "a!1=alpha")
                                          (("1" (GRIND) NIL NIL)
                                           ("2"
                                            (CASE "a!1=omega19")
                                            (("1" (GRIND) NIL NIL)
                                             ("2"
                                              (CASE "a!1=rho1")
                                              (("1" (GRIND) NIL NIL)
                                               ("2"
                                                (CASE "a!1=rho2")
                                                (("1" (GRIND) NIL NIL)
                                                 ("2"
                                                  (CASE "a!1=gamma")
                                                  (("1" (GRIND) NIL NIL)
                                                   ("2"
                                                    (CASE "a!1=wr")
                                                    (("1"
                                                      (REPLACE -1 10)
                                                      (("1" (GRIND) NIL NIL))
                                                      NIL)
                                                     ("2"
                                                      (CASE "a!1=ws")
                                                      (("1"
                                                        (REPLACE -1 11)
                                                        (("1"
                                                          (GRIND)
                                                          NIL
                                                          NIL))
                                                        NIL)
                                                       ("2"
                                                        (HIDE -1 -2 -3 -4)
                                                        (("2"
                                                          (CASE "a!1=pr")
                                                          (("1"
                                                            (REPLACE -1 12)
                                                            (("1"
                                                              (GRIND)
                                                              NIL
                                                              NIL))
                                                            NIL)
                                                           ("2"
                                                            (CASE "a!1=ps")
                                                            (("1"
                                                              (REPLACE -1 13)
                                                              (("1"
                                                                (GRIND)
                                                                NIL
                                                                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)
                     ("2" (FLATTEN)
                      (("2" (EXPAND "enabled_tick")
                        (("2" (CASE "a!1=tick")
                          (("1" (REPLACE -1 *)
                            (("1" (HIDE -2)
                              (("1" (HIDE -3)
                                (("1" (EXPAND "Inv_1" -3)
                                  (("1" (SPLIT)
                                    (("1" (GRIND) NIL NIL)
                                     ("2" (FLATTEN) (("2" (GRIND) NIL NIL))
                                      NIL)
                                     ("3" (FLATTEN)
                                      (("3"
                                        (SPLIT)
                                        (("1" (GRIND) NIL NIL)
                                         ("2"
                                          (INST - "alpha")
                                          (("2" (GRIND) NIL NIL))
                                          NIL)
                                         ("3"
                                          (FLATTEN)
                                          (("3"
                                            (INST - "rho1")
                                            (("3" (GRIND) NIL NIL))
                                            NIL))
                                          NIL))
                                        NIL))
                                      NIL)
                                     ("4" (FLATTEN) (("4" (GRIND) NIL NIL))
                                      NIL)
                                     ("5" (FLATTEN)
                                      (("5"
                                        (SPLIT)
                                        (("1" (GRIND) NIL NIL)
                                         ("2" (GRIND) NIL NIL)
                                         ("3" (GRIND) NIL NIL)
                                         ("4"
                                          (INST - "gamma")
                                          (("4" (GRIND) NIL NIL))
                                          NIL)
                                         ("5"
                                          (INST - "rho2")
                                          (("5" (GRIND) NIL NIL))
                                          NIL)
                                         ("6" (GRIND) NIL NIL))
                                        NIL))
                                      NIL))
                                    NIL))
                                  NIL))
                                NIL))
                              NIL))
                            NIL)
                           ("2" (GRIND) NIL NIL))
                          NIL))
                        NIL))
                      NIL))
                    NIL))
                  NIL))
                NIL))
              NIL))
            NIL))
          NIL))
        NIL))
      NIL))
    NIL))
  NIL)
 (|lemma1_2| "" (LEMMA "machine_induct")
  (("" (INST -1 "Inv_11")
    (("" (EXPAND "inductthm")
      (("" (SPLIT)
        (("1" (PROPAX) NIL NIL) ("2" (HIDE 2) (("2" (GRIND) NIL NIL)) NIL)
         ("3" (HIDE 2)
          (("3" (EXPAND "inductstep")
            (("3" (SKOLEM-TYPEPRED)
              (("3" (FLATTEN)
                (("3" (EXPAND "trans") (("3" (GRIND) NIL NIL)) NIL)) NIL))
              NIL))
            NIL))
          NIL))
        NIL))
      NIL))
    NIL))
  NIL))