diff options
Diffstat (limited to 'contrib/ML4PG/coq')
| -rw-r--r-- | contrib/ML4PG/coq/auxiliary_files.el | 23 | ||||
| -rw-r--r-- | contrib/ML4PG/coq/feature_extraction.el | 862 | ||||
| -rw-r--r-- | contrib/ML4PG/coq/lemmas.txt | 44 | ||||
| -rw-r--r-- | contrib/ML4PG/coq/matlab_interaction.el | 627 | ||||
| -rw-r--r-- | contrib/ML4PG/coq/menus.el | 304 | ||||
| -rw-r--r-- | contrib/ML4PG/coq/save_lemmas.el | 117 | ||||
| -rw-r--r-- | contrib/ML4PG/coq/shortcuts.el | 14 | ||||
| -rw-r--r-- | contrib/ML4PG/coq/storage.el | 51 | ||||
| -rw-r--r-- | contrib/ML4PG/coq/views.txt | 1 | ||||
| -rw-r--r-- | contrib/ML4PG/coq/weka.el | 81 |
10 files changed, 0 insertions, 2124 deletions
diff --git a/contrib/ML4PG/coq/auxiliary_files.el b/contrib/ML4PG/coq/auxiliary_files.el deleted file mode 100644 index 95a4ce0a..00000000 --- a/contrib/ML4PG/coq/auxiliary_files.el +++ /dev/null @@ -1,23 +0,0 @@ -(defun ml4pg-quicksort-pair (list) - (if (<= (length list) 1) - list - (let ((pivot (cadar list))) - (append (ml4pg-quicksort-pair (remove-if-not #'(lambda (x) (> (cadr x) pivot)) list)) - (remove-if-not #'(lambda (x) (= (cadr x) pivot)) list) - (ml4pg-quicksort-pair (remove-if-not #'(lambda (x) (< (cadr x) pivot)) list)))))) - - -(defun ml4pg-zip (l1 l2) - (do ((temp1 l1 (cdr temp1)) - (temp2 l2 (cdr temp2)) - (res nil)) - ((endp temp1) res) - (setf res (append res (list (append (list (car temp1)) (list (car temp2)))))))) - -(defun ml4pg-unzip (l) - (do ((temp l (cdr temp)) - (res1 nil) - (res2 nil)) - ((endp temp) (list (reverse res1) (reverse res2))) - (progn (setf res1 (cons (caar temp) res1)) - (setf res2 (cons (cadr (car temp)) res2))))) diff --git a/contrib/ML4PG/coq/feature_extraction.el b/contrib/ML4PG/coq/feature_extraction.el deleted file mode 100644 index 4d934143..00000000 --- a/contrib/ML4PG/coq/feature_extraction.el +++ /dev/null @@ -1,862 +0,0 @@ -;; Variables to store the tree depth levels - -(defvar ml4pg-tdl1 nil) -(defvar ml4pg-tdl2 nil) -(defvar ml4pg-tdl3 nil) -(defvar ml4pg-tdl4 nil) -(defvar ml4pg-tdl5 nil) - -;; Variables to store the information about the tactic level - -(defvar ml4pg-intro nil) -(defvar ml4pg-case nil) -(defvar ml4pg-simpltrivial nil) -(defvar ml4pg-induction nil) -(defvar ml4pg-simpl nil) -(defvar ml4pg-rewrite nil) -(defvar ml4pg-trivial nil) - -(defvar ml4pg-hypothesis nil) - -(defvar ml4pg-init 0) - -(defun ml4pg-export-theorem () - (interactive) - (progn (setf ml4pg-tdl1 nil - ml4pg-tdl2 nil - ml4pg-tdl3 nil - ml4pg-tdl4 nil - ml4pg-tdl5 nil - ml4pg-intro nil - ml4pg-case nil - ml4pg-simpltrivial nil - ml4pg-induction nil - ml4pg-simpl nil - ml4pg-rewrite nil - ml4pg-trivial nil - ml4pg-hypothesis nil - ml4pg-goal-level nil) - (if (equal ml4pg-init 0) - (progn (ml4pg-read-lemmas) - (setq ml4pg-init 1))) - (ml4pg-export-theorem-aux nil nil 1 nil) - (proof-shell-invisible-cmd-get-result (format "Unset Printing All")) - )) - -(defvar ml4pg-saved-theorems nil) -(defvar ml4pg-goal-level-temp nil) -(defvar ml4pg-tactic-level nil) -(defvar ml4pg-proof-tree-level nil) - -;; Variables to store the different values associated with the tactics, the -;; types or the rewrite rules - -(defvar ml4pg-tactic_id '(("intro" . 1) - ("case" . 2) - ("simpl" . 3) - ("trivial" . 4) - ("induction" . 5) - ("rewrite" . 6) - ("simpl; trivial" . 34))) - - -(defvar ml4pg-types_id '(("nat" . -2) - ("Prop" . -4) - ("bool" . -3) - ("A" . -1) - ("list" . -5))) - -(defvar ml4pg-theorems_id nil) - -;; A function to obtain the type associated with an object - -(defun ml4pg-get-type-id (object) - (let* ((a (proof-shell-invisible-cmd-get-result (format (concat "Check " object)))) - (pos_jump (search " -" a :start2 (+ 2 (search " " a)))) - (pos_space (search " " a :start2 (+ 2 (search ": " a)))) - (type (if pos_space - (cdr (assoc (subseq a (+ 2 (search ": " a)) pos_space) ml4pg-types_id)) - (cdr (assoc (subseq a (+ 2 (search ": " a)) pos_jump) ml4pg-types_id))))) - (if type type -4))) - - -;; A function to obtain the value of a top symbol - - -(defun ml4pg-get-top-symbol () - (proof-shell-invisible-cmd-get-result (format "Set Printing All")) - (let* ((res (proof-shell-invisible-cmd-get-result (format "Focus"))) - (res2 (subseq res (+ 32 (search "============================" res)))) - (fst-symbol (subseq res2 0 (search " " res2)))) - (cond ((string= fst-symbol "forall") 5) - ((search "->" res2) 7) - ((string= "@eq" fst-symbol) 6) - ((string= "and" fst-symbol) 4) ; I have included this - ((string= "iff" fst-symbol) 8) ; I have included this - ((string= "or" fst-symbol) 3) ; I have included this - (t 0)))) - -;; In some cases the intro tactic does not have parameters, the following function -;; obtain the type of the object introduced with the intro tactic in those cases - -(defun ml4pg-get-obj-intro () - (let* ((undo (proof-undo-last-successful-command)) - (obj (proof-shell-invisible-cmd-get-result (format "Show Intro"))) - (object (subseq obj 0 (search " -" obj))) - (dod (proof-assert-next-command-interactive)) - (foo (setf ml4pg-hypothesis (append ml4pg-hypothesis (list object))))) - - (ml4pg-get-type-id object) - )) - -(defun ml4pg-extract-params (seq res) - (let ((pos_space (search " " seq)) - (pos_jump (search " -" seq))) - (if pos_space - (ml4pg-extract-params (subseq seq (+ 1 pos_space)) (cons (subseq seq 0 pos_space) res)) - (reverse (cons (subseq seq 0 pos_jump) res))))) - -(defun ml4pg-extract-params2 (seq res) - (let ((pos_space (search " " seq)) - (pos_jump (search "." seq))) - (if pos_space - (ml4pg-extract-params2 (subseq seq (+ 1 pos_space)) (cons (subseq seq 0 pos_space) res)) - (reverse (cons (subseq seq 0 pos_jump) res))))) - -;; Given a list of objects, it obtains the value associated with their types - -(defun ml4pg-get-types-list (list res) - (if (endp list) - (* -1 res) - (ml4pg-get-types-list (cdr list) (+ (* -1 (ml4pg-get-type-id (car list)) (expt 10 (- (length list) 1))) res)))) - -;; To obtain the number of tactics applied - -(defun ml4pg-get-number-list (list) - (if (endp list) - 0 - (+ (expt 10 (- (length list) 1)) (ml4pg-get-number-list (cdr list))))) - -;; To obtain the value associated with top symbol in the case of intros - -(defun ml4pg-get-top-symbols-list (len res) - (if (= len 0) - res - (let ((gs (ml4pg-get-top-symbol)) - (ps (proof-shell-invisible-cmd-get-result (format "intro")))) - (+ (ml4pg-get-top-symbols-list (- len 1) (+ (* gs (expt 10 (- len 1))) res)))))) - -(defun ml4pg-get-top-symbols-seq (seq res) - (if (endp seq) - res - (let ((gs (ml4pg-get-top-symbol)) - (ps (proof-shell-invisible-cmd-get-result (format (concat "intro " (car seq)))))) - (+ (ml4pg-get-top-symbols-seq (cdr seq) (+ (* gs (expt 10 (- (length seq) 1))) res)))))) - -;; To obtain the values associated with intros both for the case when parameters are -;; given and the case intros. - -(defun ml4pg-get-obj-intros () - (let* ((undo (proof-undo-last-successful-command)) - (obj (proof-shell-invisible-cmd-get-result (format "Show Intros"))) - (dod (proof-assert-next-command-interactive)) - (params (ml4pg-extract-params obj nil)) - (foo (setf ml4pg-hypothesis (append ml4pg-hypothesis params))) - (types (ml4pg-get-types-list params 0)) - (num (ml4pg-get-number-list params)) - (undo2 (proof-shell-invisible-cmd-get-result (format "Undo"))) - (gts (ml4pg-get-top-symbols-list (length params) 0))) - (list num types (length params) gts) - )) - -(defun ml4pg-get-obj-intros2 (objects) - (let* ((params (ml4pg-extract-params2 objects nil)) - (foo (setf ml4pg-hypothesis (append ml4pg-hypothesis params))) - (types (ml4pg-get-types-list params 0)) - (num (ml4pg-get-number-list params)) - (undo2 (proof-shell-invisible-cmd-get-result (format "Undo"))) - (gts (ml4pg-get-top-symbols-seq params 0))) - (list num types (length params) gts) - )) - -;; To obtain the value associated with a theorem - -(defun ml4pg-search-in-hyp (obj hyp) - (if (endp hyp) - nil - (if (string= obj (car hyp)) - t - (ml4pg-search-in-hyp obj (cdr hyp))))) - - -(defvar ml4pg-add_to 0.1) -(defvar ml4pg-start 100) - -(defun ml4pg-extract-theorem-id (cmd) - (let ((s<- (search "<-" cmd))) - (if s<- - (if (assoc (subseq cmd (+ 3 s<-) (search "." cmd)) ml4pg-theorems_id) - (cdr (assoc (subseq cmd (+ 3 s<-) (search "." cmd)) ml4pg-theorems_id)) - (if (ml4pg-search-in-hyp (subseq cmd (+ 3 s<-) (search "." cmd)) ml4pg-hypothesis) - 1 - (progn (setf ml4pg-start (+ ml4pg-start ml4pg-add_to)) - (setf ml4pg-theorems_id - (append ml4pg-theorems_id (list (cons (subseq cmd (+ 3 s<-) - (search "." cmd)) - ml4pg-start)))) - (ml4pg-save-lemma (subseq cmd (+ 3 s<-) - (search "." cmd)) ml4pg-start) - (setf ml4pg-add_to (/ ml4pg-add_to 2)) - ml4pg-start - ))) - (if (assoc (subseq cmd (+ 1 (search " " cmd)) (search "." cmd)) ml4pg-theorems_id) - (cdr (assoc (subseq cmd (+ 1 (search " " cmd)) (search "." cmd)) ml4pg-theorems_id)) - (if (ml4pg-search-in-hyp (subseq cmd (+ 1 (search " " cmd)) (search "." cmd)) ml4pg-hypothesis) - 1 - (progn (setf ml4pg-start (+ ml4pg-start ml4pg-add_to)) - (ml4pg-save-lemma (subseq cmd (+ 1 (search " " cmd)) (search "." cmd)) ml4pg-start) - (setf ml4pg-theorems_id - (append ml4pg-theorems_id (list (cons (subseq cmd (+ 1 (search " " cmd)) (search "." cmd)) - ml4pg-start)))) - (setf ml4pg-add_to (/ ml4pg-add_to 2)) - ml4pg-start - )))))) - - -(defun ml4pg-arg-induction (object) - (let* ((ps0 (proof-shell-invisible-cmd-get-result (format "Undo"))) - (res (proof-shell-invisible-cmd-get-result (concat "Check " object))) - (ps3 (proof-shell-invisible-cmd-get-result (concat "induction " object))) - (err (search "Error" res))) - (if err -1 1))) - -(defun ml4pg-get-type-id-induction (object arg-ind) - (if (equal arg-ind 1) - (let ((ps0 (proof-shell-invisible-cmd-get-result (format "Undo"))) - (gt (ml4pg-get-type-id object)) - (ps3 (proof-shell-invisible-cmd-get-result (concat "induction " object)))) - gt) - (let ((ps0 (proof-shell-invisible-cmd-get-result (format "Undo"))) - (ps (proof-shell-invisible-cmd-get-result (concat "intro " object))) - (gt (ml4pg-get-type-id object)) - (ps2 (proof-shell-invisible-cmd-get-result (format "Undo"))) - (ps3 (proof-shell-invisible-cmd-get-result (concat "induction " object)))) - gt))) - -;; Function to add the information to the corresponding tree depth level - -(defun ml4pg-add-info-to-tree (info level) - (cond ((= ml4pg-level 1) (setf ml4pg-tdl1 (append ml4pg-tdl1 (list info)))) - ((= ml4pg-level 2) (setf ml4pg-tdl2 (append ml4pg-tdl2 (list info)))) - ((= ml4pg-level 3) (setf ml4pg-tdl3 (append ml4pg-tdl3 (list info)))) - ((= ml4pg-level 4) (setf ml4pg-tdl4 (append ml4pg-tdl4 (list info)))) - ((= ml4pg-level 5) (setf ml4pg-tdl5 (append ml4pg-tdl5 (list info)))) - (t nil))) - -;; Function to add the information to the corresponding tactic - -(defun ml4pg-add-info-to-tactic (info tactic) - (cond ((string= ml4pg-tactic "intro") (setf ml4pg-intro (append ml4pg-intro (list info)))) - ((string= ml4pg-tactic "case") (setf ml4pg-case (append ml4pg-case (list info)))) - ((string= ml4pg-tactic "simpltrivial") (setf ml4pg-simpltrivial (append ml4pg-simpltrivial (list info)))) - ((string= ml4pg-tactic "induction") (setf ml4pg-induction (append ml4pg-induction (list info)))) - ((string= ml4pg-tactic "simpl") (setf ml4pg-simpl (append ml4pg-simpl (list info)))) - ((string= ml4pg-tactic "rewrite") (setf ml4pg-rewrite (append ml4pg-rewrite (list info)))) - ((string= ml4pg-tactic "trivial") (setf ml4pg-trivial (append ml4pg-trivial (list info)))) - (t nil))) - - - -;The first value is the tactic, the second one is the number of tactics, -;the third one is the argument type, the fourth one is if the -;argument is a hypothesis of a theorem, the fifth one is the top-symbol -;and the last one the number of subgoals - -(defun ml4pg-get-numbers (cmd tactic ngs ts current-level bot) - (cond ((and (string= tactic "intro") (not (string= cmd "intro."))) - (let* ((object (subseq cmd (1+ (search " " cmd)) (search "." cmd))) - (type (ml4pg-get-type-id object)) - - - (foo (setf ml4pg-hypothesis (append ml4pg-hypothesis (list object)))) - (res (list (cdr (assoc "intro" ml4pg-tactic_id)) - 1 - type - -1 - ts ngs)) - (foo2 (setf ml4pg-goal-level-temp (cons res ml4pg-goal-level-temp)))) - res)) - ((string= tactic "intro") - (let* ((type (ml4pg-get-obj-intro)) - - - (res (list (cdr (assoc "intro" ml4pg-tactic_id)) - 1 - (ml4pg-get-obj-intro) - -1 - ts ngs)) - (foo2 (setf ml4pg-goal-level-temp (cons res ml4pg-goal-level-temp)))) - res)) - ((and (string= tactic "intros") (not (string= cmd "intros."))) - (let* ((params (ml4pg-get-obj-intros2 (subseq cmd (1+ (search " " cmd))))) - (nparams (car params)) - (types-params (cadr params)) - (len (caddr params)) - (gts (cadddr params)) - - - (res (list nparams - len - types-params - -1 - gts ngs)) - (foo2 (setf ml4pg-goal-level-temp (cons res ml4pg-goal-level-temp)))) - res)) - ((string= tactic "intros") - (let* ((params (ml4pg-get-obj-intros)) - (nparams (car params)) - (types-params (cadr params)) - (len (caddr params)) - (gts (cadddr params)) - - - (res (list nparams - len - types-params - -1 - gts ngs)) - (foo2 (setf ml4pg-goal-level-temp (cons res ml4pg-goal-level-temp)))) - res)) - ((string= tactic "case") - (let* ((object (subseq cmd (1+ (search " " cmd)) (search "." cmd))) - (type (ml4pg-get-type-id object)) - - - (res (list (cdr (assoc "case" ml4pg-tactic_id)) - 1 - type - 1 ts ngs)) - (foo2 (setf ml4pg-goal-level-temp (cons res ml4pg-goal-level-temp)))) - res)) - ((string= tactic "simpl") - (progn - - (setf ml4pg-goal-level-temp (cons (list (cdr (assoc "simpl" ml4pg-tactic_id)) 1 0 0 ts ngs) ml4pg-goal-level-temp)) - (list (cdr (assoc "simpl" ml4pg-tactic_id)) 1 0 0 ts ngs))) - ((string= tactic "trivial") - (progn - - (setf ml4pg-goal-level-temp (cons (list (cdr (assoc "trivial" ml4pg-tactic_id)) 1 0 0 ts ngs) ml4pg-goal-level-temp)) - (list (cdr (assoc "trivial" ml4pg-tactic_id)) 1 0 0 ts ngs))) - ((string= tactic "induction") - (let* ((object (subseq cmd (1+ (search " " cmd)) (search "." cmd))) - (arg-ind (ml4pg-arg-induction object)) - (type (ml4pg-get-type-id-induction object arg-ind)) - - - (ih (setf ml4pg-theorems_id (append ml4pg-theorems_id (list (cons (concat "IH" object) 10))))) - (res (list (cdr (assoc "induction" ml4pg-tactic_id)) - 1 type arg-ind ts ngs)) - (foo2 (setf ml4pg-goal-level-temp (cons res ml4pg-goal-level-temp)))) - res)) - ((string= tactic "rewrite") - (progn - - (setf ml4pg-goal-level-temp (cons (list (cdr (assoc "rewrite" ml4pg-tactic_id)) 1 -4 - (ml4pg-extract-theorem-id cmd) ts ngs) ml4pg-goal-level-temp)) - (list (cdr (assoc "rewrite" ml4pg-tactic_id)) 1 -4 - (ml4pg-extract-theorem-id cmd) ts ngs)) - ) - ((string= cmd "simpl; trivial.") - (progn - - (setf goal-level-temp (cons (list (cdr (assoc "simpl; trivial" ml4pg-tactic_id)) 2 0 0 ts ngs) ml4pg-goal-level-temp)) - (list (cdr (assoc "simpl; trivial" ml4pg-tactic_id)) 2 0 0 ts ngs)) - ))) - -;; Function to obtain the information just about the goals. - -(defun ml4pg-get-numbers2 (cmd tactic ngs ts current-level bot) - (cond ((and (string= tactic "intro") (not (string= cmd "intro."))) - (let* ((object (subseq cmd (1+ (search " " cmd)) (search "." cmd))) - (type (ml4pg-get-type-id object)) - - - (foo (setf ml4pg-hypothesis (append ml4pg-hypothesis (list object)))) - (res (list (cdr (assoc "intro" ml4pg-tactic_id)) - 1 - type - -1 - ts ngs)) - (foo2 (setf ml4pg-goal-level-temp (cons res ml4pg-goal-level-temp)))) - res)) - ((string= tactic "intro") - (let* ((type (ml4pg-get-obj-intro)) - - - (res (list (cdr (assoc "intro" ml4pg-tactic_id)) - 1 - (get-obj-intro) - -1 - ts ngs)) - (foo2 (setf ml4pg-goal-level-temp (cons res ml4pg-goal-level-temp)))) - res)) - ((and (string= tactic "intros") (not (string= cmd "intros."))) - (let* ((params (ml4pg-get-obj-intros2 (subseq cmd (1+ (search " " cmd))))) - (nparams (car params)) - (types-params (cadr params)) - (len (caddr params)) - (gts (cadddr params)) - - - (res (list nparams - len - types-params - -1 - gts ngs)) - (foo2 (setf ml4pg-goal-level-temp (cons res ml4pg-goal-level-temp)))) - res)) - ((string= tactic "intros") - (let* ((params (ml4pg-get-obj-intros)) - (nparams (car params)) - (types-params (cadr params)) - (len (caddr params)) - (gts (cadddr params)) - - - (res (list nparams - len - types-params - -1 - gts ngs)) - (foo2 (setf ml4pg-goal-level-temp (cons res ml4pg-goal-level-temp)))) - res)) - ((string= tactic "case") - (let* ((object (subseq cmd (1+ (search " " cmd)) (search "." cmd))) - (type (ml4pg-get-type-id object)) - - - (res (list (cdr (assoc "case" ml4pg-tactic_id)) - 1 - type - 1 ts ngs)) - (foo2 (setf ml4pg-goal-level-temp (cons res ml4pg-goal-level-temp)))) - res)) - ((string= tactic "simpl") - (progn - - (list (cdr (assoc "simpl" ml4pg-tactic_id)) 1 0 0 ts ngs))) - ((string= tactic "trivial") - (progn - - (list (cdr (assoc "trivial" ml4pg-tactic_id)) 1 0 0 ts ngs))) - ((string= tactic "induction") - (let* ((object (subseq cmd (1+ (search " " cmd)) (search "." cmd))) - (arg-ind (ml4pg-arg-induction object)) - (type (ml4pg-get-type-id-induction object arg-ind)) - - - (ih (setf ml4pg-theorems_id (append ml4pg-theorems_id (list (cons (concat "IH" object) 10))))) - (res (list (cdr (assoc "induction" ml4pg-tactic_id)) - 1 type arg-ind ts ngs)) - (foo2 (setf goal-level-temp (cons res goal-level-temp)))) - res)) - ((string= tactic "rewrite") - (progn - - (list (cdr (assoc "rewrite" ml4pg-tactic_id)) 1 -4 - (ml4pg-extract-theorem-id cmd) ts ngs)) - ) - ((string= cmd "simpl; trivial.") - (progn - - (list (cdr (assoc "simpl; trivial" ml4pg-tactic_id)) 2 0 0 ts ngs)) - ))) - -(defun ml4pg-count-seq (item seq) - (let ((is? (search item seq))) - (if is? - (+ 1 (ml4pg-count-seq item (subseq seq (+ 1 is?)))) - 0))) - -(defun ml4pg-get-number-of-goals () - (let ((r (proof-shell-invisible-cmd-get-result (format "Show Proof")))) - (ml4pg-count-seq "?" r))) - - -(defun ml4pg-flat (ll) - (if (endp ll) - nil - (append (car ll) (ml4pg-flat (cdr ll))))) - - -;; The following function computes the result of the proof tree level - -(defun ml4pg-remove-zeros (n) - (do ((temp n (/ temp 10))) - ((or (= temp 0) (not (= (mod temp 10) 0))) temp))) - -(defun ml4pg-obtain-level (level n) - (do ((temp (cdr level) (cdr temp)) - (temp2 (if (endp level) (list 0 0 0 0 0 0 0 0 0) - (list (* (nth 0 (car level)) (expt 10 (length (cdr level)))) - (* (nth 1 (car level)) (expt 10 (length (cdr level)))) - (* (nth 2 (car level)) (expt 10 (length (cdr level)))) - (* (nth 3 (car level)) (expt 10 (length (cdr level)))) - (* (nth 4 (car level)) (expt 10 (length (cdr level)))) - (* (nth 5 (car level)) (expt 10 (length (cdr level)))) - (* (nth 6 (car level)) (expt 10 (length (cdr level)))) - (* (nth 7 (car level)) (expt 10 (length (cdr level)))) - (nth 8 (car level)))))) - ((endp temp) (list (ml4pg-remove-zeros (nth 0 temp2)) - (ml4pg-remove-zeros (nth 1 temp2)) - (ml4pg-remove-zeros (nth 2 temp2)) - (ml4pg-remove-zeros (nth 3 temp2)) - (ml4pg-remove-zeros (nth 4 temp2)) - (nth 5 temp2) - (ml4pg-remove-zeros (nth 6 temp2)) - (if (= (nth 7 temp2) 0) (nth 7 temp2) (+ (* n (expt 10 (length level))) (ml4pg-remove-zeros (nth 7 temp2)))) - (nth 8 temp2))) - (setf temp2 (list (+ (nth 0 temp2) (* (expt 10 (length (cdr temp))) (nth 0 (car temp)))) - (+ (nth 1 temp2) (* (expt 10 (length (cdr temp))) (nth 1 (car temp)))) - (+ (nth 2 temp2) (* (expt 10 (length (cdr temp))) (nth 2 (car temp)))) - (+ (nth 3 temp2) (* (expt 10 (length (cdr temp))) (nth 3 (car temp)))) - (+ (nth 4 temp2) (* (expt 10 (length (cdr temp))) (nth 4 (car temp)))) - (+ (nth 5 temp2) (* (expt 10 (length (cdr temp))) (nth 5 (car temp)))) - (+ (nth 6 temp2) (* (expt 10 (length (cdr temp))) (nth 6 (car temp)))) - (+ (nth 7 temp2) (* (expt 10 (length (cdr temp))) (nth 7 (car temp)))) - (+ (nth 8 temp2) (nth 8 (car temp)))) - ) - )) - - -(defun ml4pg-compute-proof-result () - (append (ml4pg-obtain-level ml4pg-tdl1 1) - (ml4pg-obtain-level ml4pg-tdl2 2) - (ml4pg-obtain-level ml4pg-tdl3 3) - (ml4pg-obtain-level ml4pg-tdl4 4) - (ml4pg-obtain-level ml4pg-tdl5 5))) - -;; The following function computes the result of the tactic - - -(defun ml4pg-digits (n) - (if (= (mod n 10) 0) - 0 - (1+ (ml4pg-digits (/ n 10))))) - -(defun ml4pg-first-digit (n digits) - (/ n (expt 10 (1- digits)))) - -(defun ml4pg-rest-of-digits (n digits) - (- n (* (ml4pg-first-digit n digits) (expt 10 (1- digits))))) - -(defun ml4pg-obtain-tactic-result (tactic) - (do ((temp (cdr tactic) (cdr temp)) - (temp2 (if (endp tactic) (list 0 0 0 0 0) - (list (ml4pg-first-digit (nth 0 (car tactic)) (ml4pg-digits (nth 0 (car tactic)))) - (* (ml4pg-rest-of-digits (nth 0 (car tactic)) (ml4pg-digits (nth 0 (car tactic)))) (expt 10 (length (cdr tactic)))) - (* (nth 1 (car tactic)) (expt 10 (length (cdr tactic)))) - (nth 2 (car tactic)) - (nth 3 (car tactic)))))) - ((endp temp) temp2) - (setf temp2 (list (nth 0 temp2) - (+ (nth 1 temp2) (* (expt 10 (length (cdr temp))) (nth 0 (car temp)))) - (+ (nth 2 temp2) (* (expt 10 (length (cdr temp))) (nth 1 (car temp)))) - (concat (format "%s" (nth 3 temp2)) (format "%s" (nth 2 (car temp)))) - (+ (nth 4 temp2) (nth 3 (car temp)))) - ) - )) - - -(defun ml4pg-compute-tactic-result () - (append (ml4pg-obtain-tactic-result ml4pg-intro) - (ml4pg-obtain-tactic-result ml4pg-case) - (ml4pg-obtain-tactic-result ml4pg-simpltrivial) - (ml4pg-obtain-tactic-result ml4pg-induction) - (ml4pg-obtain-tactic-result ml4pg-simpl) - (ml4pg-obtain-tactic-result ml4pg-rewrite) - (ml4pg-obtain-tactic-result ml4pg-trivial))) - - -(defvar ml4pg-useless-terms '("Definition" "Defined" "Fixpoint" "Structure" "Section" "Add Ring" "Hypothesis" "Hypotheses" "Include" "Export" "Parameter" "Axiom" -"End" "Notation" "Hint" "Inductive" "Variable" "Implicit" "Import" "Canonical" "Coercion" -"Module" "Ltac" "Let" "Opaque" "Bind" "Scope" "Require" "Infix" "Record" "Fact")) - -(defun ml4pg-is-in-search (cmd) - (do ((temp ml4pg-useless-terms (cdr temp)) - (is nil)) - ((or (endp temp) is) is) - (if (search (car temp) cmd) (setf is t)))) - -(defun ml4pg-export-theorem-aux (result name current-level dot-level) - (let* ((semis (save-excursion - (skip-chars-backward " \t\n" - (proof-queue-or-locked-end)) - (proof-segment-up-to-using-cache (point)))) - (comment (caar semis)) - (cmd (cadar semis)) - (pos_dot (search "." cmd)) - (pos_space (search " " cmd)) - (ts nil)) - (if semis - (cond ((or (string= comment "comment") - (ml4pg-is-in-search cmd)) - (progn (proof-assert-next-command-interactive) - (ml4pg-export-theorem-aux result name current-level dot-level))) - ((search "Lemma" cmd) - (progn (proof-assert-next-command-interactive) - (ml4pg-export-theorem-aux result - (subseq cmd (1+ (search " " cmd)) - (search " " cmd :start2 (1+ (search " " cmd)))) - current-level dot-level))) - ((search "Proof" cmd) - (progn (proof-assert-next-command-interactive) - (ml4pg-export-theorem-aux result name current-level dot-level))) - ((search "Theorem" cmd) - (progn (proof-assert-next-command-interactive) - (ml4pg-export-theorem-aux result - (subseq cmd (1+ (search " " cmd)) - (search " " cmd :start2 (1+ (search " " cmd)))) - current-level dot-level))) - ((search "Qed." cmd) - (progn (proof-assert-next-command-interactive) - ; (insert (format "\n(* %s *)\n" (reverse result))) - (setf ml4pg-proof-tree-level (append ml4pg-proof-tree-level (list (ml4pg-compute-proof-result)))) - (setf ml4pg-tactic-level (append ml4pg-tactic-level (list (ml4pg-compute-tactic-result)))) - (setf ml4pg-saved-theorems (append ml4pg-saved-theorems - (list (list name (ml4pg-flat (reverse result)))))))) - (pos_space - (progn (setf ts (ml4pg-get-top-symbol)) - (setf ng (ml4pg-get-number-of-goals)) - (proof-assert-next-command-interactive) - (setf ng2 (ml4pg-get-number-of-goals)) - (cond ((< ng ng2) (ml4pg-export-theorem-aux - (cons (ml4pg-get-numbers cmd (subseq cmd 0 pos_space) (ml4pg-get-number-of-goals) ts current-level 1) result) - name - (1+ current-level) - (1+ current-level))) - ((< ng2 ng) (ml4pg-export-theorem-aux - (cons (ml4pg-get-numbers cmd (subseq cmd 0 pos_space) (ml4pg-get-number-of-goals) ts current-level 0) result) - name - dot-level - nil)) - (t (ml4pg-export-theorem-aux - (cons (ml4pg-get-numbers cmd (subseq cmd 0 pos_space) (ml4pg-get-number-of-goals) ts current-level 0) result) - name - (1+ current-level) - dot-level))))) - (t (progn (setf ts (ml4pg-get-top-symbol)) - (setf ng (ml4pg-get-number-of-goals)) - (proof-assert-next-command-interactive) - (setf ng2 (ml4pg-get-number-of-goals)) - (cond ((< ng ng2) (ml4pg-export-theorem-aux - (cons (ml4pg-get-numbers cmd (subseq cmd 0 pos_dot) (ml4pg-get-number-of-goals) ts current-level 1) result) - name - (1+ current-level) - (1+ current-level))) - ((< ng2 ng) (ml4pg-export-theorem-aux - (cons (ml4pg-get-numbers cmd (subseq cmd 0 pos_dot) (ml4pg-get-number-of-goals) ts current-level 0) result) - name - dot-level - nil)) - (t (ml4pg-export-theorem-aux - (cons (ml4pg-get-numbers cmd (subseq cmd 0 pos_dot) (ml4pg-get-number-of-goals) ts current-level 0) result) - name - (1+ current-level) - dot-level)) - ) - )))))) - - - - - -;;; Functions to save the files - -(defun ml4pg-save-file-conventions1 () - (interactive) - (let ((file (read-file-name "Save in file (don't include the extension): "))) - (progn (with-temp-file (concat file "_goals.csv") (insert (ml4pg-extract-features-1))) - (with-temp-file (concat file "_proof_tree.csv") (insert (ml4pg-extract-features-2 proof-tree-level))) - (with-temp-file (concat file "_tactic.csv") (insert (ml4pg-extract-features-2 tactic-level))) - (with-temp-file (concat file (format "_summary.txt")) (insert (ml4pg-extract-names)))))) - - -(defun ml4pg-extract-names () - (do ((temp ml4pg-saved-theorems (cdr temp)) - (temp2 "") - (i 1 (1+ i))) - ((endp temp) temp2) - (setf temp2 (concat temp2 (format "%s . %s\n" i (caar temp))) ))) - - -(defun ml4pg-print-list (list) - (do ((temp list (cdr temp)) - (temp2 "")) - ((endp temp) (subseq temp2 0 (1- (length temp2)))) - (setf temp2 (concat temp2 (format "%s," (car temp))) ))) - - -(defun ml4pg-extract-features-1 () - (let ((fm (ml4pg-find-max-length))) - (do ((temp ml4pg-saved-theorems (cdr temp)) - (temp2 "")) - ((endp temp) temp2) - (if (< (length (cadar temp)) fm) - (setf temp2 (concat temp2 - (format "%s\n" - (ml4pg-print-list (ml4pg-take-30 (append (cadar temp) - (ml4pg-generate-zeros (- fm (length (cadar temp)))))) )))) - (setf temp2 (concat temp2 (format "%s\n" (ml4pg-print-list (ml4pg-take-30 (cadar temp))) ))))) - )) - - - -(defun ml4pg-extract-features-2 (list) - (do ((temp list (cdr temp)) - (temp2 "")) - ((endp temp) temp2) - (setf temp2 (concat temp2 (format "%s\n" (ml4pg-print-list (car temp))))))) - - - -(defun ml4pg-generate-zeros (n) - (do ((i 0 (1+ i)) - (temp nil (cons 0 temp))) - ((= i n) temp))) - -(defun ml4pg-find-max-length () - (do ((temp ml4pg-saved-theorems (cdr temp)) - (i 0)) - ((endp temp) i) - (if (< i (length (cadar temp))) - (setf i (length (cadar temp))) - nil))) - -(defun ml4pg-take-30 (list) - (do ((i 0 (1+ i)) - (temp list (cdr temp)) - (temp2 nil (cons (car temp) temp2))) - ((= i 30) (reverse temp2)))) - - -;; Function which extract the info of a theorem up to a concrete point - -(defun ml4pg-extract-info-up-to-here () - (interactive) - (setf ml4pg-tdl1 nil - ml4pg-tdl2 nil - ml4pg-tdl3 nil - ml4pg-tdl4 nil - ml4pg-tdl5 nil - ml4pg-intro nil - ml4pg-case nil - ml4pg-simpltrivial nil - ml4pg-induction nil - ml4pg-simpl nil - ml4pg-rewrite nil - ml4pg-trivial nil) - (let ((final (point)) - (result nil) - (current-level 1)) - (search-backward "Proof.") - (proof-goto-point) - (while (< (point) final) - (let* ((semis (save-excursion - (skip-chars-backward " \t\n" - (proof-queue-or-locked-end)) - (proof-segment-up-to-using-cache (point)))) - (comment (caar semis)) - (cmd (cadar semis)) - (pos_dot (search "." cmd)) - (pos_space (search " " cmd)) - (ts nil)) - (cond (pos_space - (progn (setf ts (ml4pg-get-top-symbol)) - (setf ng (ml4pg-get-number-of-goals)) - (proof-assert-next-command-interactive) - (setf ng2 (ml4pg-get-number-of-goals)) - (cond ((< ng ng2) (progn (setf result (cons (ml4pg-get-numbers2 cmd (subseq cmd 0 pos_space) (ml4pg-get-number-of-goals) ts current-level 1) result)) - (setf current-level (1+ current-level)))) - ((< ng2 ng) (progn (setf result (cons (ml4pg-get-numbers2 cmd (subseq cmd 0 pos_space) (ml4pg-get-number-of-goals) ts current-level 0) result)) - (setf current-level (1+ current-level)))) - (t (progn (setf result (cons (ml4pg-get-numbers2 cmd (subseq cmd 0 pos_space) (ml4pg-get-number-of-goals) ts current-level 0) result)) - (setf current-level (1+ current-level))))))) - (t (progn (setf ts (ml4pg-get-top-symbol)) - (setf ng (ml4pg-get-number-of-goals)) - (proof-assert-next-command-interactive) - (setf ng2 (ml4pg-get-number-of-goals)) - (cond ((< ng ng2) (progn (setf result (cons (ml4pg-get-numbers2 cmd (subseq cmd 0 pos_dot) (ml4pg-get-number-of-goals) ts current-level 1) result)) - (setf current-level (1+ current-level)))) - ((< ng2 ng) (progn (setf result (cons (ml4pg-get-numbers2 cmd (subseq cmd 0 pos_dot) (ml4pg-get-number-of-goals) ts current-level 0) result)) - (setf current-level (1+ current-level)))) - (t (progn (setf result(cons (ml4pg-get-numbers2 cmd (subseq cmd 0 pos_dot) (ml4pg-get-number-of-goals) ts current-level 0) result) ) - (setf current-level (1+ current-level)))) - ) - )))) - ) - - - (ml4pg-take-30 (append (ml4pg-flat (reverse result)) (ml4pg-generate-zeros 20) )) - )) - - - -(defun ml4pg-extract-features-1-bis (thm) - (let ((fm (ml4pg-find-max-length))) - (do ((temp ml4pg-saved-theorems (cdr temp)) - (temp2 "")) - ((endp temp) (concat temp2 (format "%s\n" (ml4pg-print-list thm)))) - (if (< (length (cadar temp)) fm) - (setf temp2 (concat temp2 - (format "%s\n" - (ml4pg-print-list (ml4pg-take-30 (append (cadar temp) - (ml4pg-generate-zeros (- fm (length (cadar temp)))))) )))) - (setf temp2 (concat temp2 (format "%s\n" (ml4pg-print-list (ml4pg-take-30 (cadar temp))) ))))) - )) - - -;; Function which extract the information from all the theorems up to a point - -(defun ml4pg-extract-feature-theorems () - (interactive) - (let ((final (point)) - (current-level 1) - (last-point -1)) - (ml4pg-export-theorem) - (while (and (< (point) final) (not (= (point) last-point))) - (progn (setq last-point (point)) - (ml4pg-export-theorem)))) - ) - - - - - - -(defun ml4pg-extract-theorems-library () - (interactive) - (search-backward "Qed.") - (forward-char) - (forward-char) - (forward-char) - (forward-char) - (let ((final (point)) - (last-point -1)) - (beginning-of-buffer) - (proof-goto-point) - (ml4pg-export-theorem) - (while (and (< (point) final) (not (= (point) last-point))) - (progn (setq last-point (point)) - (ml4pg-export-theorem))) - ) - - ) - - - -
\ No newline at end of file diff --git a/contrib/ML4PG/coq/lemmas.txt b/contrib/ML4PG/coq/lemmas.txt deleted file mode 100644 index c818e3b0..00000000 --- a/contrib/ML4PG/coq/lemmas.txt +++ /dev/null @@ -1,44 +0,0 @@ -size_ncons&102$addn0&103$IHs&104$cats1&105$size_cat&106$addnC&107$last_cat&108$lastI&109$belast_cat&110$catA&111$|&112$rewrite&113$cat0s&114$cats0&115$cat_rcons&116$last_nth&119$nth_nil&120$eq_s12&122$IHs1&123$=>&124$i&125$addn1&126$maxn0&127$maxnE&128$subn1&129$add1n&130$addn_maxr&131$nth_ncons&132$eqSS&133$subnn&134$nth_default&135$subn_gt0&136$size_set_nth&138$maxnA&139$maxnn&140$nth_set_nth&141$maxnCA&142$eq_sym&143$if_neg&144$ne_n12&145$add0n&147$eqn_leq&148$andbC&149$ltnNge&150$count_size&151$leqnn&154$fun_if&155$filter_cat&159$count_filter&160$orbA&161$has_cat&162$has_seq1&163$orbC&164$andbA&165$all_cat&166$all_seq1&167$Ea&168$eq_filter&169$has_count&170$eq_count&171$all_count&172$has_find&173$s12&177$filter_pred0&179$filter_predT&180$addnCA&181$addnA&182$addn_negb&183$count_pred0&184$count_predT&185$negb_and&187$has_predC&188$has_predU&189$iterSr&191$IHn&192$drop_oversize&194$drop0&195$take_oversize&196$cat_take_drop&198$size_drop&199$size_takel&200$ltnW&201$ltnS&202$subSS&203$take0&204$take_cat&205$ltn_neqAle&206$Hn0&207$take_size&208$nth_cat&209$size_take&210$lt_n0_s&211$addKn&212$leq_addr&213$eqnP&216$lt_i_n0&217$1IHs&218$take_size_cat&220$drop_size_cat&221$size_rot&222$rot_size_cat&223$catrev_catr&225$catrevE&226$rev_cons&227$size_rcons&228$catrev_catl&229$rev_cat&230$rev_rcons&231$subn0&232$ltnn&233$subnK&234$addSnnS&235$eqseq_cons&237$andbF&238$1andbA&239$in_cons&241$inE&242$mem_cat&243$mem_seq1&244$mem_rcons&246$mem_head&247$mem_behead&249$s0x&250$s0'x&251$orbT&252$ay&254$eq_a&258$y&259$s_y&260$eq_a12&261$s'y&262$eq_in_count&263$has_filter&264$Es12&265$in&266$Hx&267$*&268$eqxx&270$all_pred1_nseq&271$def_s&273$has_pred0&274$has_sym&275$negb_or&276$cat_uniq&277$andbCA&278$uniq_catC&279$mem_filter&280$negbTE&281$mem_rev&282$Hy&283$all_pred1P&284$count_uniq_mem&285$s_x&286$mem_undup&287$size_undup&288$find_size&290$has_pred1&291$find_cat&292$lt_i_s&293$mem_nth&294$rcons_uniq&295$index_cat&296$size_belast&297$index_uniq&298$eq_sij&299$cat_cons&302$i.+1&304$nax&305$exists&306$i]&307$eq_all&308$a_s&309$IHv&310$count_cat&312$addn_eq0&313$count_predC&314$filter_predI&315$cnt_a'&316$leq_add2r&318$eq12&319$perm_eq_sym&321$eqn_add2l&322$perm_catC&324$perm_cat2r&326$cat1s&328$perm_catCA&329$perm_cons&330$def_s2&331$mem_rot&332$negPf&333$rot_uniq&334$le_s21&335$leqNgt&337$s3x&338$uniq_leq_size&339$eqs12&340$eqs12,&342$uniq_size_uniq&343$@uniq_leq_size&345$s2x&346$Hs12&347$x&352$\in&353$s1&354$by&355$/(rot i s1)&356$def_s1&357$FcatCA&359$addnK&360$rot1_cons&361$rotK&362$has_rot&363$subKn&364$rot0&365$size_rev&367$size_rotr&370$@size_takel&371$5(catA, =^~ rot_size_cat)&372$leq_addl&373$rot_addn&375$addnBA&376$@rot_oversize&377$1ltnW&378$rot_add_mod&379$1addnC&380$rot_rot&381$has_mask_cons&382$Hsn0:&383$size&384$take&385$=&386$Hs&387$size_mask&388$mask_cat&389$mask_rot&392$size_nseq&393$mask_false&394$sz_m&396$geq_min&397$nth_take&398$negb_add&399$addbF&400$addbT&401$negb_eqb&402$before_find&403$def_m_i&404$lt_i_m&405$subnKC&406$congr1&407$drop_nth&410$nth_index&411$index_mem&412$mask0&413$sz_m1&414$sz_m2&415$cat_subseq&416$sub0seq&417$mask_true&419$all_predC&428$map_cat&429$map_take&430$map_drop&431$map_rot&433$size_map&434$filter_mask&435$a_x&436$size_subseq_leqif&438$subseq_filter&439$introT&440$uniq_perm_eq&441$filter_uniq&442$Ds2&444$perm_rcons&445$eqP&446$x']&447$map_mask&449$inj_in_eq&450$count_map&453$Est&454$eq_sz&457$ltis&458$nth_map&459$Ef&460$eq_f12&461$eqf12&462$eqxx,&463$sy&464$gK&466$fK&467$mem_map&468$pmap_filter&469$size_pmap&471$IHn1&475$addnS&476$iota_add&477$size_iota&478$andbN&479$leq_eqVlt&480$mem_iota&482$nth_iota&484$size_mkseq&486$Hi&487$nth_mkseq&488$mkseq_nth&490$perm_map&491$perm_eq_small&492$s&493$Ds&494$iota_addl&495$map_rotr&496$map_comp&497$@eq_map&498$mulnC&499$sumn_nseq&500$foldr_cat&501$revK&502$Hfg&503$Hgf&504$addn_minr&505$size_zip&506$zip_cat&507$zip_rcons&508$IHss&509$IHsh&510$leq_subLR&511$leq_add2l&513$leq_max&514$def_z&515$def_x'&516$map_f&517$not_fxt_z&518$eq_s&519$eq_t&520$fpz&521$sp2&522$Ut&526$:&527$z.1,&528$x,&529$Dz1&530$s1z&531$s1'x&532$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$andb_false_r&120$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$andb_false_r&120$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$andb_false_r&120$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$andb_false_r&120$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$andb_false_r&120$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$andb_false_r&120$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$andb_false_r&108$addSn&100.1$plus_Sn_m&100.14999999999999$plus_n_Sm&100.175$app_nil_l2&100.1875$mult_n_O&100.19375$O_minus&100.19687499999999$mult_O_n&100.1984375$plus_n_O&100.19921875$aux12&100.199609375$aux7&100.19980468749999$aux10&100.19990234375$mulSn&100.199951171875$addnCA&100.1999755859375$aux11&100.19998779296874$mulnS&100.19999389648437$andb_false_r&100.19999694824219$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$mulnDl&108$mulnC&109$addn2&110$exp0n&111$mulC&102$mulm1&103$iteropS&104$mulmA&105$mulmC&106$mulmCA&107$mulC&102$mulm1&103$iteropS&104$mulmA&105$mulmC&106$mulmCA&107$mulC&102$mulm1&103$iteropS&104$mulmA&105$mulmC&106$mulmCA&107$mem_iota&110$leq_subLR&111$subSn&112$subnDA&113$subnKC&114$enumT&115$mem_enum&116$unlock&117$f_op&122$big_filter&125$filter_predI&126$mkseq_nth&129$big_map&130$eqn0Ngt&131$big_hasC&132$has_pred0&133$foldr_cat&135$big_cat_nested&136$big_seq_cond&138$big_andbC&139$big_seq&140$eq_bigr&141$mem_index_iota&142$big_nat_cond&143$big_nil&146$big_cons&147$iota_addl&149$big_addn&150$big_ltn&151$big_add1&152$val_ord_enum&153$sorted_filter&155$iota_ltn_sorted&156$mem_filter&157$andbCA&158$andb_idr&159$big_mkord&160$len12&161$big_ord_widen_cond&162$inord_val&163$big_pred0&164$]&165$big_ord0&166$big_nth&167$tnth_nth&168$big_ord_widen_leq&169$inordK&172$eqFG&173$i:&174$F&175$=&176$G&177$by&178$big_const_seq&179$cardE&180$size_iota&181$big_const&182$card_ord&183$big1&186$big_mkcond&187$mul1m,&188$filter_index_enum&189$enum1&190$big_seq1&191$big_cat&193$iota_add&194$leq_sub&195$big_geq&196$@big_cat_nat&197$leqnSn&198$big_nat1&199$big_nat_recr&200$leqW&202$val_enum_ord&204$map_cat&205$map_comp&206$eqxx&207$r2i:&208$\in&209$r2&210$has_pred1&211$eq_r12&212$count_cat&214$uniq_perm_eq&217$enum_uniq&218$big_tnth&219$index_uniq&220$valK&221$filter_undup&222$IHr&223$big_rem&224$idM&225$big_undup&226$undup_uniq&227$mem_undup&228$eq_r&229$big_split&230$simpm&231$bigID&232$orbK&233$cardD1&235$Aj&236$Qp&238$Q0&239$cardD1x&240$bigD1&241$Qj,&242$j&243$P0&244$IH&245$h'K&246$reindex_onto&247$hK&248$reindex_inj&251$addSn&252$subnDr&253$addnBA&254$partition_big&255$Pi&256$andbT&257$andb_idl&259$exchange_big_dep&260$Qi&261$2(big_seq_cond _ _ _ xQ)&262$exchange_big_dep_nat&263$big_endo&264$mulm0&266$x&267$y&268$big_distrl&270$big_distrr&271$f&276$ffunE&277$nri&278$eqP&279$big_distr_big_dep&280$mul0m&282$bigA_distr_big&284$big_has_cond&285$big_all_cond&286$allB&287$sum_nat_const&289$muln1&290$Monoid&291$big_const_nat&292$big_andE&293$@leqif_sum&296$muln_gt0&297$leq_maxl&299$geq_max&304$dvdn_lcm&307$in&308$dvFm&309$p_m&310$dvdn_trans&311$dvdn_lcml&312$dvdn_gcd&313$dvmF&314$m_p&315$dvdn_gcdl&316$mul0n&317$muln0&318$mulnDr&319$mulnDl&320$mulnC&321$addn2&322$exp0n&323$mulC&102$mulm1&103$iteropS&104$mulmA&105$mulmC&106$mulmCA&107$mem_iota&110$leq_subLR&111$subSn&112$subnDA&113$subnKC&114$enumT&115$mem_enum&116$unlock&117$f_op&122$big_filter&125$filter_predI&126$mkseq_nth&129$big_map&130$eqn0Ngt&131$big_hasC&132$has_pred0&133$foldr_cat&135$big_cat_nested&136$big_seq_cond&138$big_andbC&139$big_seq&140$eq_bigr&141$mem_index_iota&142$big_nat_cond&143$big_nil&146$big_cons&147$iota_addl&149$big_addn&150$big_ltn&151$big_add1&152$val_ord_enum&153$sorted_filter&155$iota_ltn_sorted&156$mem_filter&157$andbCA&158$andb_idr&159$big_mkord&160$len12&161$big_ord_widen_cond&162$inord_val&163$big_pred0&164$]&165$big_ord0&166$big_nth&167$tnth_nth&168$big_ord_widen_leq&169$inordK&172$eqFG&173$i:&174$F&175$=&176$G&177$by&178$big_const_seq&179$cardE&180$size_iota&181$big_const&182$card_ord&183$big1&186$big_mkcond&187$mul1m,&188$filter_index_enum&189$enum1&190$big_seq1&191$big_cat&193$iota_add&194$leq_sub&195$big_geq&196$@big_cat_nat&197$leqnSn&198$big_nat1&199$big_nat_recr&200$leqW&202$val_enum_ord&204$map_cat&205$map_comp&206$eqxx&207$r2i:&208$\in&209$r2&210$has_pred1&211$eq_r12&212$count_cat&214$uniq_perm_eq&217$enum_uniq&218$big_tnth&219$index_uniq&220$valK&221$filter_undup&222$IHr&223$big_rem&224$idM&225$big_undup&226$undup_uniq&227$mem_undup&228$eq_r&229$big_split&230$simpm&231$bigID&232$orbK&233$cardD1&235$Aj&236$Qp&238$Q0&239$cardD1x&240$bigD1&241$Qj,&242$j&243$P0&244$IH&245$h'K&246$reindex_onto&247$hK&248$reindex_inj&251$addSn&252$subnDr&253$addnBA&254$partition_big&255$Pi&256$andbT&257$andb_idl&259$exchange_big_dep&260$Qi&261$2(big_seq_cond _ _ _ xQ)&262$exchange_big_dep_nat&263$big_endo&264$mulm0&266$x&267$y&268$big_distrl&270$big_distrr&271$f&276$ffunE&277$nri&278$eqP&279$big_distr_big_dep&280$mul0m&282$bigA_distr_big&284$big_has_cond&285$big_all_cond&286$allB&287$sum_nat_const&289$muln1&290$Monoid&291$big_const_nat&292$big_andE&293$@leqif_sum&296$muln_gt0&297$leq_maxl&299$geq_max&304$dvdn_lcm&307$in&308$dvFm&309$p_m&310$dvdn_trans&311$dvdn_lcml&312$dvdn_gcd&313$dvmF&314$m_p&315$dvdn_gcdl&316$mul0n&317$muln0&318$mulnDr&319$mulnDl&320$mulnC&321$addn2&322$exp0n&323$s0'x&128$orbT&129$ay&131$eq_a&135$y&136$s_y&137$eq_a12&138$s'y&139$eq_in_count&140$has_filter&141$Es12&142$in&143$Hx&144$*&145$eqxx&147$all_pred1_nseq&148$def_s&150$has_pred0&151$has_sym&152$negb_or&153$cat_uniq&154$andbCA&155$uniq_catC&156$mem_filter&157$negbTE&158$mem_rev&159$Hy&160$all_pred1P&161$count_uniq_mem&162$s_x&163$mem_undup&164$size_undup&165$find_size&167$has_pred1&168$find_cat&169$lt_i_s&170$mem_nth&171$rcons_uniq&172$index_cat&173$size_belast&174$index_uniq&175$eq_sij&176$cat_cons&179$i.+1&181$nax&182$exists&183$i]&184$eq_all&185$a_s&186$IHv&187$count_cat&189$addn_eq0&190$count_predC&191$filter_predI&192$cnt_a'&193$leq_add2r&195$eq12&196$perm_eq_sym&198$eqn_add2l&199$perm_catC&201$perm_cat2r&203$cat1s&205$perm_catCA&206$perm_cons&207$def_s2&208$mem_rot&209$negPf&210$rot_uniq&211$le_s21&212$leqNgt&214$s3x&215$uniq_leq_size&216$eqs12&217$eqs12,&219$uniq_size_uniq&220$@uniq_leq_size&222$s2x&223$Hs12&224$x&229$\in&230$s1&231$by&232$/(rot i s1)&233$def_s1&234$FcatCA&236$addnK&237$rot1_cons&238$rotK&239$has_rot&240$subKn&241$rot0&242$size_rev&244$size_rotr&247$@size_takel&248$5(catA, =^~ rot_size_cat)&249$leq_addl&250$rot_addn&252$addnBA&253$@rot_oversize&254$1ltnW&255$rot_add_mod&256$1addnC&257$rot_rot&258$has_mask_cons&259$Hsn0:&260$size&261$take&262$=&263$Hs&264$size_mask&265$mask_cat&266$mask_rot&269$size_nseq&270$mask_false&271$sz_m&273$geq_min&274$nth_take&275$negb_add&276$addbF&277$addbT&278$negb_eqb&279$before_find&280$def_m_i&281$lt_i_m&282$subnKC&283$congr1&284$drop_nth&287$nth_index&288$index_mem&289$mask0&290$sz_m1&291$sz_m2&292$cat_subseq&293$sub0seq&294$mask_true&296$all_predC&305$map_cat&306$map_take&307$map_drop&308$map_rot&310$size_map&311$filter_mask&312$a_x&313$size_subseq_leqif&315$subseq_filter&316$introT&317$uniq_perm_eq&318$filter_uniq&319$Ds2&321$perm_rcons&322$eqP&323$x']&324$map_mask&326$inj_in_eq&327$count_map&330$Est&331$eq_sz&334$ltis&335$nth_map&336$Ef&337$eq_f12&338$eqf12&339$eqxx,&340$sy&341$gK&343$fK&344$mem_map&345$pmap_filter&346$size_pmap&348$IHn1&352$addnS&353$iota_add&354$size_iota&355$andbN&356$leq_eqVlt&357$mem_iota&359$nth_iota&361$size_mkseq&363$Hi&364$nth_mkseq&365$mkseq_nth&367$perm_map&368$perm_eq_small&369$s&370$Ds&371$iota_addl&372$map_rotr&373$map_comp&374$@eq_map&375$mulnC&376$sumn_nseq&377$foldr_cat&378$revK&379$Hfg&380$Hgf&381$addn_minr&382$size_zip&383$zip_cat&384$zip_rcons&385$IHss&386$IHsh&387$leq_subLR&388$leq_add2l&390$leq_max&391$def_z&392$def_x'&393$map_f&394$not_fxt_z&395$eq_s&396$eq_t&397$fpz&398$sp2&399$Ut&403$:&404$z.1,&405$x,&406$Dz1&407$s1z&408$s1'x&409$addSn&100.1$plus_Sn_m&100.14999999999999$plus_n_Sm&100.175$app_nil_l2&100.1875$mult_n_O&100.19375$O_minus&100.19687499999999$mult_O_n&100.1984375$plus_n_O&100.19921875$aux12&100.199609375$aux7&100.19980468749999$aux10&100.19990234375$mulSn&100.199951171875$addnCA&100.1999755859375$aux11&100.19998779296874$mulnS&100.19999389648437$s0'x&128$orbT&129$ay&131$eq_a&135$y&136$s_y&137$eq_a12&138$s'y&139$eq_in_count&140$has_filter&141$Es12&142$in&143$Hx&144$*&145$eqxx&147$all_pred1_nseq&148$def_s&150$has_pred0&151$has_sym&152$negb_or&153$cat_uniq&154$andbCA&155$uniq_catC&156$mem_filter&157$negbTE&158$mem_rev&159$Hy&160$all_pred1P&161$count_uniq_mem&162$s_x&163$mem_undup&164$size_undup&165$find_size&167$has_pred1&168$find_cat&169$lt_i_s&170$mem_nth&171$rcons_uniq&172$index_cat&173$size_belast&174$index_uniq&175$eq_sij&176$cat_cons&179$i.+1&181$nax&182$exists&183$i]&184$eq_all&185$a_s&186$IHv&187$count_cat&189$addn_eq0&190$count_predC&191$filter_predI&192$cnt_a'&193$leq_add2r&195$eq12&196$perm_eq_sym&198$eqn_add2l&199$perm_catC&201$perm_cat2r&203$cat1s&205$perm_catCA&206$perm_cons&207$def_s2&208$mem_rot&209$negPf&210$rot_uniq&211$le_s21&212$leqNgt&214$s3x&215$uniq_leq_size&216$eqs12&217$eqs12,&219$uniq_size_uniq&220$@uniq_leq_size&222$s2x&223$Hs12&224$x&229$\in&230$s1&231$by&232$/(rot i s1)&233$def_s1&234$FcatCA&236$addnK&237$rot1_cons&238$rotK&239$has_rot&240$subKn&241$rot0&242$size_rev&244$size_rotr&247$@size_takel&248$5(catA, =^~ rot_size_cat)&249$leq_addl&250$rot_addn&252$addnBA&253$@rot_oversize&254$1ltnW&255$rot_add_mod&256$1addnC&257$rot_rot&258$has_mask_cons&259$Hsn0:&260$size&261$take&262$=&263$Hs&264$size_mask&265$mask_cat&266$mask_rot&269$size_nseq&270$mask_false&271$sz_m&273$geq_min&274$nth_take&275$negb_add&276$addbF&277$addbT&278$negb_eqb&279$before_find&280$def_m_i&281$lt_i_m&282$subnKC&283$congr1&284$drop_nth&287$nth_index&288$index_mem&289$mask0&290$sz_m1&291$sz_m2&292$cat_subseq&293$sub0seq&294$mask_true&296$all_predC&305$map_cat&306$map_take&307$map_drop&308$map_rot&310$size_map&311$filter_mask&312$a_x&313$size_subseq_leqif&315$subseq_filter&316$introT&317$uniq_perm_eq&318$filter_uniq&319$Ds2&321$perm_rcons&322$eqP&323$x']&324$map_mask&326$inj_in_eq&327$count_map&330$Est&331$eq_sz&334$ltis&335$nth_map&336$Ef&337$eq_f12&338$eqf12&339$eqxx,&340$sy&341$gK&343$fK&344$mem_map&345$pmap_filter&346$size_pmap&348$IHn1&352$addnS&353$iota_add&354$size_iota&355$andbN&356$leq_eqVlt&357$mem_iota&359$nth_iota&361$size_mkseq&363$Hi&364$nth_mkseq&365$mkseq_nth&367$perm_map&368$perm_eq_small&369$s&370$Ds&371$iota_addl&372$map_rotr&373$map_comp&374$@eq_map&375$mulnC&376$sumn_nseq&377$foldr_cat&378$revK&379$Hfg&380$Hgf&381$addn_minr&382$size_zip&383$zip_cat&384$zip_rcons&385$IHss&386$IHsh&387$leq_subLR&388$leq_add2l&390$leq_max&391$def_z&392$def_x'&393$map_f&394$not_fxt_z&395$eq_s&396$eq_t&397$fpz&398$sp2&399$Ut&403$:&404$z.1,&405$x,&406$Dz1&407$s1z&408$s1'x&409$s0'x&128$orbT&129$ay&131$eq_a&135$y&136$s_y&137$eq_a12&138$s'y&139$eq_in_count&140$has_filter&141$Es12&142$in&143$Hx&144$*&145$eqxx&147$all_pred1_nseq&148$def_s&150$has_pred0&151$has_sym&152$negb_or&153$cat_uniq&154$andbCA&155$uniq_catC&156$mem_filter&157$negbTE&158$mem_rev&159$Hy&160$all_pred1P&161$count_uniq_mem&162$s_x&163$mem_undup&164$size_undup&165$find_size&167$has_pred1&168$find_cat&169$lt_i_s&170$mem_nth&171$rcons_uniq&172$index_cat&173$size_belast&174$index_uniq&175$eq_sij&176$cat_cons&179$i.+1&181$nax&182$exists&183$i]&184$eq_all&185$a_s&186$IHv&187$count_cat&189$addn_eq0&190$count_predC&191$filter_predI&192$cnt_a'&193$leq_add2r&195$eq12&196$perm_eq_sym&198$eqn_add2l&199$perm_catC&201$perm_cat2r&203$cat1s&205$perm_catCA&206$perm_cons&207$def_s2&208$mem_rot&209$negPf&210$rot_uniq&211$le_s21&212$leqNgt&214$s3x&215$uniq_leq_size&216$eqs12&217$eqs12,&219$uniq_size_uniq&220$@uniq_leq_size&222$s2x&223$Hs12&224$x&229$\in&230$s1&231$by&232$/(rot i s1)&233$def_s1&234$FcatCA&236$addnK&237$rot1_cons&238$rotK&239$has_rot&240$subKn&241$rot0&242$size_rev&244$size_rotr&247$@size_takel&248$5(catA, =^~ rot_size_cat)&249$leq_addl&250$rot_addn&252$addnBA&253$@rot_oversize&254$1ltnW&255$rot_add_mod&256$1addnC&257$rot_rot&258$has_mask_cons&259$Hsn0:&260$size&261$take&262$=&263$Hs&264$size_mask&265$mask_cat&266$mask_rot&269$size_nseq&270$mask_false&271$sz_m&273$geq_min&274$nth_take&275$negb_add&276$addbF&277$addbT&278$negb_eqb&279$before_find&280$def_m_i&281$lt_i_m&282$subnKC&283$congr1&284$drop_nth&287$nth_index&288$index_mem&289$mask0&290$sz_m1&291$sz_m2&292$cat_subseq&293$sub0seq&294$mask_true&296$all_predC&305$map_cat&306$map_take&307$map_drop&308$map_rot&310$size_map&311$filter_mask&312$a_x&313$size_subseq_leqif&315$subseq_filter&316$introT&317$uniq_perm_eq&318$filter_uniq&319$Ds2&321$perm_rcons&322$eqP&323$x']&324$map_mask&326$inj_in_eq&327$count_map&330$Est&331$eq_sz&334$ltis&335$nth_map&336$Ef&337$eq_f12&338$eqf12&339$eqxx,&340$sy&341$gK&343$fK&344$mem_map&345$pmap_filter&346$size_pmap&348$IHn1&352$addnS&353$iota_add&354$size_iota&355$andbN&356$leq_eqVlt&357$mem_iota&359$nth_iota&361$size_mkseq&363$Hi&364$nth_mkseq&365$mkseq_nth&367$perm_map&368$perm_eq_small&369$s&370$Ds&371$iota_addl&372$map_rotr&373$map_comp&374$@eq_map&375$mulnC&376$sumn_nseq&377$foldr_cat&378$revK&379$Hfg&380$Hgf&381$addn_minr&382$size_zip&383$zip_cat&384$zip_rcons&385$IHss&386$IHsh&387$leq_subLR&388$leq_add2l&390$leq_max&391$def_z&392$def_x'&393$map_f&394$not_fxt_z&395$eq_s&396$eq_t&397$fpz&398$sp2&399$Ut&403$:&404$z.1,&405$x,&406$Dz1&407$s1z&408$s1'x&409$s0'x&128$orbT&129$ay&131$eq_a&135$y&136$s_y&137$eq_a12&138$s'y&139$eq_in_count&140$has_filter&141$Es12&142$in&143$Hx&144$*&145$eqxx&147$all_pred1_nseq&148$def_s&150$has_pred0&151$has_sym&152$negb_or&153$cat_uniq&154$andbCA&155$uniq_catC&156$mem_filter&157$negbTE&158$mem_rev&159$Hy&160$all_pred1P&161$count_uniq_mem&162$s_x&163$mem_undup&164$size_undup&165$find_size&167$has_pred1&168$find_cat&169$lt_i_s&170$mem_nth&171$rcons_uniq&172$index_cat&173$size_belast&174$index_uniq&175$eq_sij&176$cat_cons&179$i.+1&181$nax&182$exists&183$i]&184$eq_all&185$a_s&186$IHv&187$count_cat&189$addn_eq0&190$count_predC&191$filter_predI&192$cnt_a'&193$leq_add2r&195$eq12&196$perm_eq_sym&198$eqn_add2l&199$perm_catC&201$perm_cat2r&203$cat1s&205$perm_catCA&206$perm_cons&207$def_s2&208$mem_rot&209$negPf&210$rot_uniq&211$le_s21&212$leqNgt&214$s3x&215$uniq_leq_size&216$eqs12&217$eqs12,&219$uniq_size_uniq&220$@uniq_leq_size&222$s2x&223$Hs12&224$x&229$\in&230$s1&231$by&232$/(rot i s1)&233$def_s1&234$FcatCA&236$addnK&237$rot1_cons&238$rotK&239$has_rot&240$subKn&241$rot0&242$size_rev&244$size_rotr&247$@size_takel&248$5(catA, =^~ rot_size_cat)&249$leq_addl&250$rot_addn&252$addnBA&253$@rot_oversize&254$1ltnW&255$rot_add_mod&256$1addnC&257$rot_rot&258$has_mask_cons&259$Hsn0:&260$size&261$take&262$=&263$Hs&264$size_mask&265$mask_cat&266$mask_rot&269$size_nseq&270$mask_false&271$sz_m&273$geq_min&274$nth_take&275$negb_add&276$addbF&277$addbT&278$negb_eqb&279$before_find&280$def_m_i&281$lt_i_m&282$subnKC&283$congr1&284$drop_nth&287$nth_index&288$index_mem&289$mask0&290$sz_m1&291$sz_m2&292$cat_subseq&293$sub0seq&294$mask_true&296$all_predC&305$map_cat&306$map_take&307$map_drop&308$map_rot&310$size_map&311$filter_mask&312$a_x&313$size_subseq_leqif&315$subseq_filter&316$introT&317$uniq_perm_eq&318$filter_uniq&319$Ds2&321$perm_rcons&322$eqP&323$x']&324$map_mask&326$inj_in_eq&327$count_map&330$Est&331$eq_sz&334$ltis&335$nth_map&336$Ef&337$eq_f12&338$eqf12&339$eqxx,&340$sy&341$gK&343$fK&344$mem_map&345$pmap_filter&346$size_pmap&348$IHn1&352$addnS&353$iota_add&354$size_iota&355$andbN&356$leq_eqVlt&357$mem_iota&359$nth_iota&361$size_mkseq&363$Hi&364$nth_mkseq&365$mkseq_nth&367$perm_map&368$perm_eq_small&369$s&370$Ds&371$iota_addl&372$map_rotr&373$map_comp&374$@eq_map&375$mulnC&376$sumn_nseq&377$foldr_cat&378$revK&379$Hfg&380$Hgf&381$addn_minr&382$size_zip&383$zip_cat&384$zip_rcons&385$IHss&386$IHsh&387$leq_subLR&388$leq_add2l&390$leq_max&391$def_z&392$def_x'&393$map_f&394$not_fxt_z&395$eq_s&396$eq_t&397$fpz&398$sp2&399$Ut&403$:&404$z.1,&405$x,&406$Dz1&407$s1z&408$s1'x&409$s0'x&128$orbT&129$ay&131$eq_a&135$y&136$s_y&137$eq_a12&138$s'y&139$eq_in_count&140$has_filter&141$Es12&142$in&143$Hx&144$*&145$eqxx&147$all_pred1_nseq&148$def_s&150$has_pred0&151$has_sym&152$negb_or&153$cat_uniq&154$andbCA&155$uniq_catC&156$mem_filter&157$negbTE&158$mem_rev&159$Hy&160$all_pred1P&161$count_uniq_mem&162$s_x&163$mem_undup&164$size_undup&165$find_size&167$has_pred1&168$find_cat&169$lt_i_s&170$mem_nth&171$rcons_uniq&172$index_cat&173$size_belast&174$index_uniq&175$eq_sij&176$cat_cons&179$i.+1&181$nax&182$exists&183$i]&184$eq_all&185$a_s&186$IHv&187$count_cat&189$addn_eq0&190$count_predC&191$filter_predI&192$cnt_a'&193$leq_add2r&195$eq12&196$perm_eq_sym&198$eqn_add2l&199$perm_catC&201$perm_cat2r&203$cat1s&205$perm_catCA&206$perm_cons&207$def_s2&208$mem_rot&209$negPf&210$rot_uniq&211$le_s21&212$leqNgt&214$s3x&215$uniq_leq_size&216$eqs12&217$eqs12,&219$uniq_size_uniq&220$@uniq_leq_size&222$s2x&223$Hs12&224$x&229$\in&230$s1&231$by&232$/(rot i s1)&233$def_s1&234$FcatCA&236$addnK&237$rot1_cons&238$rotK&239$has_rot&240$subKn&241$rot0&242$size_rev&244$size_rotr&247$@size_takel&248$5(catA, =^~ rot_size_cat)&249$leq_addl&250$rot_addn&252$addnBA&253$@rot_oversize&254$1ltnW&255$rot_add_mod&256$1addnC&257$rot_rot&258$has_mask_cons&259$Hsn0:&260$size&261$take&262$=&263$Hs&264$size_mask&265$mask_cat&266$mask_rot&269$size_nseq&270$mask_false&271$sz_m&273$geq_min&274$nth_take&275$negb_add&276$addbF&277$addbT&278$negb_eqb&279$before_find&280$def_m_i&281$lt_i_m&282$subnKC&283$congr1&284$drop_nth&287$nth_index&288$index_mem&289$mask0&290$sz_m1&291$sz_m2&292$cat_subseq&293$sub0seq&294$mask_true&296$all_predC&305$map_cat&306$map_take&307$map_drop&308$map_rot&310$size_map&311$filter_mask&312$a_x&313$size_subseq_leqif&315$subseq_filter&316$introT&317$uniq_perm_eq&318$filter_uniq&319$Ds2&321$perm_rcons&322$eqP&323$x']&324$map_mask&326$inj_in_eq&327$count_map&330$Est&331$eq_sz&334$ltis&335$nth_map&336$Ef&337$eq_f12&338$eqf12&339$eqxx,&340$sy&341$gK&343$fK&344$mem_map&345$pmap_filter&346$size_pmap&348$IHn1&352$addnS&353$iota_add&354$size_iota&355$andbN&356$leq_eqVlt&357$mem_iota&359$nth_iota&361$size_mkseq&363$Hi&364$nth_mkseq&365$mkseq_nth&367$perm_map&368$perm_eq_small&369$s&370$Ds&371$iota_addl&372$map_rotr&373$map_comp&374$@eq_map&375$mulnC&376$sumn_nseq&377$foldr_cat&378$revK&379$Hfg&380$Hgf&381$addn_minr&382$size_zip&383$zip_cat&384$zip_rcons&385$IHss&386$IHsh&387$leq_subLR&388$leq_add2l&390$leq_max&391$def_z&392$def_x'&393$map_f&394$not_fxt_z&395$eq_s&396$eq_t&397$fpz&398$sp2&399$Ut&403$:&404$z.1,&405$x,&406$Dz1&407$s1z&408$s1'x&409$s0'x&128$orbT&129$ay&131$eq_a&135$y&136$s_y&137$eq_a12&138$s'y&139$eq_in_count&140$has_filter&141$Es12&142$in&143$Hx&144$*&145$eqxx&147$all_pred1_nseq&148$def_s&150$has_pred0&151$has_sym&152$negb_or&153$cat_uniq&154$andbCA&155$uniq_catC&156$mem_filter&157$negbTE&158$mem_rev&159$Hy&160$all_pred1P&161$count_uniq_mem&162$s_x&163$mem_undup&164$size_undup&165$find_size&167$has_pred1&168$find_cat&169$lt_i_s&170$mem_nth&171$rcons_uniq&172$index_cat&173$size_belast&174$index_uniq&175$eq_sij&176$cat_cons&179$i.+1&181$nax&182$exists&183$i]&184$eq_all&185$a_s&186$IHv&187$count_cat&189$addn_eq0&190$count_predC&191$filter_predI&192$cnt_a'&193$leq_add2r&195$eq12&196$perm_eq_sym&198$eqn_add2l&199$perm_catC&201$perm_cat2r&203$cat1s&205$perm_catCA&206$perm_cons&207$def_s2&208$mem_rot&209$negPf&210$rot_uniq&211$le_s21&212$leqNgt&214$s3x&215$uniq_leq_size&216$eqs12&217$eqs12,&219$uniq_size_uniq&220$@uniq_leq_size&222$s2x&223$Hs12&224$x&229$\in&230$s1&231$by&232$/(rot i s1)&233$def_s1&234$FcatCA&236$addnK&237$rot1_cons&238$rotK&239$has_rot&240$subKn&241$rot0&242$size_rev&244$size_rotr&247$@size_takel&248$5(catA, =^~ rot_size_cat)&249$leq_addl&250$rot_addn&252$addnBA&253$@rot_oversize&254$1ltnW&255$rot_add_mod&256$1addnC&257$rot_rot&258$has_mask_cons&259$Hsn0:&260$size&261$take&262$=&263$Hs&264$size_mask&265$mask_cat&266$mask_rot&269$size_nseq&270$mask_false&271$sz_m&273$geq_min&274$nth_take&275$negb_add&276$addbF&277$addbT&278$negb_eqb&279$before_find&280$def_m_i&281$lt_i_m&282$subnKC&283$congr1&284$drop_nth&287$nth_index&288$index_mem&289$mask0&290$sz_m1&291$sz_m2&292$cat_subseq&293$sub0seq&294$mask_true&296$all_predC&305$map_cat&306$map_take&307$map_drop&308$map_rot&310$size_map&311$filter_mask&312$a_x&313$size_subseq_leqif&315$subseq_filter&316$introT&317$uniq_perm_eq&318$filter_uniq&319$Ds2&321$perm_rcons&322$eqP&323$x']&324$map_mask&326$inj_in_eq&327$count_map&330$Est&331$eq_sz&334$ltis&335$nth_map&336$Ef&337$eq_f12&338$eqf12&339$eqxx,&340$sy&341$gK&343$fK&344$mem_map&345$pmap_filter&346$size_pmap&348$IHn1&352$addnS&353$iota_add&354$size_iota&355$andbN&356$leq_eqVlt&357$mem_iota&359$nth_iota&361$size_mkseq&363$Hi&364$nth_mkseq&365$mkseq_nth&367$perm_map&368$perm_eq_small&369$s&370$Ds&371$iota_addl&372$map_rotr&373$map_comp&374$@eq_map&375$mulnC&376$sumn_nseq&377$foldr_cat&378$revK&379$Hfg&380$Hgf&381$addn_minr&382$size_zip&383$zip_cat&384$zip_rcons&385$IHss&386$IHsh&387$leq_subLR&388$leq_add2l&390$leq_max&391$def_z&392$def_x'&393$map_f&394$not_fxt_z&395$eq_s&396$eq_t&397$fpz&398$sp2&399$Ut&403$:&404$z.1,&405$x,&406$Dz1&407$s1z&408$s1'x&409$s0'x&128$orbT&129$ay&131$eq_a&135$y&136$s_y&137$eq_a12&138$s'y&139$eq_in_count&140$has_filter&141$Es12&142$in&143$Hx&144$*&145$eqxx&147$all_pred1_nseq&148$def_s&150$has_pred0&151$has_sym&152$negb_or&153$cat_uniq&154$andbCA&155$uniq_catC&156$mem_filter&157$negbTE&158$mem_rev&159$Hy&160$all_pred1P&161$count_uniq_mem&162$s_x&163$mem_undup&164$size_undup&165$find_size&167$has_pred1&168$find_cat&169$lt_i_s&170$mem_nth&171$rcons_uniq&172$index_cat&173$size_belast&174$index_uniq&175$eq_sij&176$cat_cons&179$i.+1&181$nax&182$exists&183$i]&184$eq_all&185$a_s&186$IHv&187$count_cat&189$addn_eq0&190$count_predC&191$filter_predI&192$cnt_a'&193$leq_add2r&195$eq12&196$perm_eq_sym&198$eqn_add2l&199$perm_catC&201$perm_cat2r&203$cat1s&205$perm_catCA&206$perm_cons&207$def_s2&208$mem_rot&209$negPf&210$rot_uniq&211$le_s21&212$leqNgt&214$s3x&215$uniq_leq_size&216$eqs12&217$eqs12,&219$uniq_size_uniq&220$@uniq_leq_size&222$s2x&223$Hs12&224$x&229$\in&230$s1&231$by&232$/(rot i s1)&233$def_s1&234$FcatCA&236$addnK&237$rot1_cons&238$rotK&239$has_rot&240$subKn&241$rot0&242$size_rev&244$size_rotr&247$@size_takel&248$5(catA, =^~ rot_size_cat)&249$leq_addl&250$rot_addn&252$addnBA&253$@rot_oversize&254$1ltnW&255$rot_add_mod&256$1addnC&257$rot_rot&258$has_mask_cons&259$Hsn0:&260$size&261$take&262$=&263$Hs&264$size_mask&265$mask_cat&266$mask_rot&269$size_nseq&270$mask_false&271$sz_m&273$geq_min&274$nth_take&275$negb_add&276$addbF&277$addbT&278$negb_eqb&279$before_find&280$def_m_i&281$lt_i_m&282$subnKC&283$congr1&284$drop_nth&287$nth_index&288$index_mem&289$mask0&290$sz_m1&291$sz_m2&292$cat_subseq&293$sub0seq&294$mask_true&296$all_predC&305$map_cat&306$map_take&307$map_drop&308$map_rot&310$size_map&311$filter_mask&312$a_x&313$size_subseq_leqif&315$subseq_filter&316$introT&317$uniq_perm_eq&318$filter_uniq&319$Ds2&321$perm_rcons&322$eqP&323$x']&324$map_mask&326$inj_in_eq&327$count_map&330$Est&331$eq_sz&334$ltis&335$nth_map&336$Ef&337$eq_f12&338$eqf12&339$eqxx,&340$sy&341$gK&343$fK&344$mem_map&345$pmap_filter&346$size_pmap&348$IHn1&352$addnS&353$iota_add&354$size_iota&355$andbN&356$leq_eqVlt&357$mem_iota&359$nth_iota&361$size_mkseq&363$Hi&364$nth_mkseq&365$mkseq_nth&367$perm_map&368$perm_eq_small&369$s&370$Ds&371$iota_addl&372$map_rotr&373$map_comp&374$@eq_map&375$mulnC&376$sumn_nseq&377$foldr_cat&378$revK&379$Hfg&380$Hgf&381$addn_minr&382$size_zip&383$zip_cat&384$zip_rcons&385$IHss&386$IHsh&387$leq_subLR&388$leq_add2l&390$leq_max&391$def_z&392$def_x'&393$map_f&394$not_fxt_z&395$eq_s&396$eq_t&397$fpz&398$sp2&399$Ut&403$:&404$z.1,&405$x,&406$Dz1&407$s1z&408$s1'x&409$s0'x&128$orbT&129$ay&131$eq_a&135$y&136$s_y&137$eq_a12&138$s'y&139$eq_in_count&140$has_filter&141$Es12&142$in&143$Hx&144$*&145$eqxx&147$all_pred1_nseq&148$def_s&150$has_pred0&151$has_sym&152$negb_or&153$cat_uniq&154$andbCA&155$uniq_catC&156$mem_filter&157$negbTE&158$mem_rev&159$Hy&160$all_pred1P&161$count_uniq_mem&162$s_x&163$mem_undup&164$size_undup&165$find_size&167$has_pred1&168$find_cat&169$lt_i_s&170$mem_nth&171$rcons_uniq&172$index_cat&173$size_belast&174$index_uniq&175$eq_sij&176$cat_cons&179$i.+1&181$nax&182$exists&183$i]&184$eq_all&185$a_s&186$IHv&187$count_cat&189$addn_eq0&190$count_predC&191$filter_predI&192$cnt_a'&193$leq_add2r&195$eq12&196$perm_eq_sym&198$eqn_add2l&199$perm_catC&201$perm_cat2r&203$cat1s&205$perm_catCA&206$perm_cons&207$def_s2&208$mem_rot&209$negPf&210$rot_uniq&211$le_s21&212$leqNgt&214$s3x&215$uniq_leq_size&216$eqs12&217$eqs12,&219$uniq_size_uniq&220$@uniq_leq_size&222$s2x&223$Hs12&224$x&229$\in&230$s1&231$by&232$/(rot i s1)&233$def_s1&234$FcatCA&236$addnK&237$rot1_cons&238$rotK&239$has_rot&240$subKn&241$rot0&242$size_rev&244$size_rotr&247$@size_takel&248$5(catA, =^~ rot_size_cat)&249$leq_addl&250$rot_addn&252$addnBA&253$@rot_oversize&254$1ltnW&255$rot_add_mod&256$1addnC&257$rot_rot&258$has_mask_cons&259$Hsn0:&260$size&261$take&262$=&263$Hs&264$size_mask&265$mask_cat&266$mask_rot&269$size_nseq&270$mask_false&271$sz_m&273$geq_min&274$nth_take&275$negb_add&276$addbF&277$addbT&278$negb_eqb&279$before_find&280$def_m_i&281$lt_i_m&282$subnKC&283$congr1&284$drop_nth&287$nth_index&288$index_mem&289$mask0&290$sz_m1&291$sz_m2&292$cat_subseq&293$sub0seq&294$mask_true&296$all_predC&305$map_cat&306$map_take&307$map_drop&308$map_rot&310$size_map&311$filter_mask&312$a_x&313$size_subseq_leqif&315$subseq_filter&316$introT&317$uniq_perm_eq&318$filter_uniq&319$Ds2&321$perm_rcons&322$eqP&323$x']&324$map_mask&326$inj_in_eq&327$count_map&330$Est&331$eq_sz&334$ltis&335$nth_map&336$Ef&337$eq_f12&338$eqf12&339$eqxx,&340$sy&341$gK&343$fK&344$mem_map&345$pmap_filter&346$size_pmap&348$IHn1&352$addnS&353$iota_add&354$size_iota&355$andbN&356$leq_eqVlt&357$mem_iota&359$nth_iota&361$size_mkseq&363$Hi&364$nth_mkseq&365$mkseq_nth&367$perm_map&368$perm_eq_small&369$s&370$Ds&371$iota_addl&372$map_rotr&373$map_comp&374$@eq_map&375$mulnC&376$sumn_nseq&377$foldr_cat&378$revK&379$Hfg&380$Hgf&381$addn_minr&382$size_zip&383$zip_cat&384$zip_rcons&385$IHss&386$IHsh&387$leq_subLR&388$leq_add2l&390$leq_max&391$def_z&392$def_x'&393$map_f&394$not_fxt_z&395$eq_s&396$eq_t&397$fpz&398$sp2&399$Ut&403$:&404$z.1,&405$x,&406$Dz1&407$s1z&408$s1'x&409$mxE&102$ord1&105$perm1&106$permM&107$eq_axiomK&108$cast_ord_id&109$castmx_id&110$mxE,&113$unsplitK&116$row_mxEl&117$row_mxEr&118$col_mxEu&120$col_mxEd&121$row_mxKl,&122$col_mxKu,&123$tr_col_mx&125$trmx_usub&126$trmx_dsub&127$hsubmxK&128$castmxE&130$j&131$&&&132$by&133$def_j&134$lshift_subproof&135$mxE]&136$~~&137$j2&138$leqNgt&139$j1&140$<&141$n2&142$ltn_add2l&143$leq_add2l&144$trmx_cast&145$row_mxA&146$tr_col,&147$tr_col',&148$row_mxEl,&149$row_mxEr,&150$col_mxEu,&151$col_mxEd,&152$2mxE&153$def_j'&155$addSn&156$ltn_addr&157$@tr_row'&158$@tr_col_mx&159$col'Kl&160$addnS&161$tr_row',&162$col'Kr&163$vsubmxK&164$col_mxKu&165$row_mxKl&166$row_mxKr&167$col_mxKd&168$submxK&169$trmx_ulsub&170$trmx_ursub&171$trmx_dlsub&172$trmx_drsub&173$block_mxKul&174$block_mxKur&175$block_mxKdl&176$block_mxKdr&177$tr_block_mx&178$tr_row_mx&179$2tr_col_mx&180$block_mxEh&181$col_mxA&182$cast_row_mx&183$block_mxEv&184$cast_col_mx&185$castmx_comp&186$etrans_id&187$card_prod&188$card_ord&189$cast_ordK&190$enum_valK&191$enum_rankK&192$mxvecE&193$castmxE,&194$conform_mx_id&195$neq_mn&196$B&197$nonconform_mx&198$addrA&199$addrC&200$add0r&201$addNr&202$mulrS&203$IHd&204$can2_eq&208$raddf0&209$opp_col_mx&213$opp_row_mx&214$add_col_mx&215$add_row_mx&216$negbTE&217$row0&220$eqxx&221$map_const_mx&222$raddfN&223$raddfD&224$map_mxD&225$map_mxN&226$mul1r&227$mulrDl&228$mulrDr&229$mulrA&230$summxE&231$bigD1&232$mulr1&233$big1&234$addr0&235$diff&236$j'&237$mulr0&238$matrix_sum_delta&239$big_ord1&240$can_eq&241$inj_eq&242$vec_mx_delta&243$vec_mxK&244$scale_col_mx&245$scale_row_mx&246$mulrnAr&247$mulrnDl&248$mulr_natr&249$i'&250$ne_i'i&251$diag_const_mx&253$raddfB&254$scale_scalar_mx&255$diag_mx_sum_delta&256$scalar_mx_sum_delta&258$scaler_sumr&259$scale1r&260$A&262$eqxx]&263$eqn0Ngt&264$n0&265$in&266$*&267$flatmx0&268$val_eqE&269$eqn_add2l&270$big_distrr&271$exchange_big&272$big_distrl&273$mul0r&274$sumrN&275$mulrN&276$mulNr&277$big_split&278$mulmxDl&279$mulNmx&280$mulmxDr&281$mulmxN&282$mul0mx&284$mulmx0&286$rowE&287$mulmxA&288$mulmxnE&289$andbT&290$natrM&291$mulrnA&292$mulnb&293$andbAC&294$mul_delta_mx_cond&295$mulrnAl&296$mul_diag_mx&297$mul_scalar_mx&298$mul_mx_diag&299$reindex_inj&300$permKV&301$mul_col_perm&302$invgK&303$tpermV&304$mul_row_perm&305$mulmx1&306$mul1mx&307$col_permE&308$trmx1&310$tr_perm_mx&311$row_permM&313$perm_mx1&315$perm_mx_is_perm&316$s0'x&128$orbT&129$ay&131$eq_a&135$y&136$s_y&137$eq_a12&138$s'y&139$eq_in_count&140$has_filter&141$Es12&142$in&143$Hx&144$*&145$eqxx&147$all_pred1_nseq&148$def_s&150$has_pred0&151$has_sym&152$negb_or&153$cat_uniq&154$andbCA&155$uniq_catC&156$mem_filter&157$negbTE&158$mem_rev&159$Hy&160$all_pred1P&161$count_uniq_mem&162$s_x&163$mem_undup&164$size_undup&165$find_size&167$has_pred1&168$find_cat&169$lt_i_s&170$mem_nth&171$rcons_uniq&172$index_cat&173$size_belast&174$index_uniq&175$eq_sij&176$cat_cons&179$i.+1&181$nax&182$exists&183$i]&184$eq_all&185$a_s&186$IHv&187$count_cat&189$addn_eq0&190$count_predC&191$filter_predI&192$cnt_a'&193$leq_add2r&195$eq12&196$perm_eq_sym&198$eqn_add2l&199$perm_catC&201$perm_cat2r&203$cat1s&205$perm_catCA&206$perm_cons&207$def_s2&208$mem_rot&209$negPf&210$rot_uniq&211$le_s21&212$leqNgt&214$s3x&215$uniq_leq_size&216$eqs12&217$eqs12,&219$uniq_size_uniq&220$@uniq_leq_size&222$s2x&223$Hs12&224$x&229$\in&230$s1&231$by&232$/(rot i s1)&233$def_s1&234$FcatCA&236$addnK&237$rot1_cons&238$rotK&239$has_rot&240$subKn&241$rot0&242$size_rev&244$size_rotr&247$@size_takel&248$5(catA, =^~ rot_size_cat)&249$leq_addl&250$rot_addn&252$addnBA&253$@rot_oversize&254$1ltnW&255$rot_add_mod&256$1addnC&257$rot_rot&258$has_mask_cons&259$Hsn0:&260$size&261$take&262$=&263$Hs&264$size_mask&265$mask_cat&266$mask_rot&269$size_nseq&270$mask_false&271$sz_m&273$geq_min&274$nth_take&275$negb_add&276$addbF&277$addbT&278$negb_eqb&279$before_find&280$def_m_i&281$lt_i_m&282$subnKC&283$congr1&284$drop_nth&287$nth_index&288$index_mem&289$mask0&290$sz_m1&291$sz_m2&292$cat_subseq&293$sub0seq&294$mask_true&296$all_predC&305$map_cat&306$map_take&307$map_drop&308$map_rot&310$size_map&311$filter_mask&312$a_x&313$size_subseq_leqif&315$subseq_filter&316$introT&317$uniq_perm_eq&318$filter_uniq&319$Ds2&321$perm_rcons&322$eqP&323$x']&324$map_mask&326$inj_in_eq&327$count_map&330$Est&331$eq_sz&334$ltis&335$nth_map&336$Ef&337$eq_f12&338$eqf12&339$eqxx,&340$sy&341$gK&343$fK&344$mem_map&345$pmap_filter&346$size_pmap&348$IHn1&352$addnS&353$iota_add&354$size_iota&355$andbN&356$leq_eqVlt&357$mem_iota&359$nth_iota&361$size_mkseq&363$Hi&364$nth_mkseq&365$mkseq_nth&367$perm_map&368$perm_eq_small&369$s&370$Ds&371$iota_addl&372$map_rotr&373$map_comp&374$@eq_map&375$mulnC&376$sumn_nseq&377$foldr_cat&378$revK&379$Hfg&380$Hgf&381$addn_minr&382$size_zip&383$zip_cat&384$zip_rcons&385$IHss&386$IHsh&387$leq_subLR&388$leq_add2l&390$leq_max&391$def_z&392$def_x'&393$map_f&394$not_fxt_z&395$eq_s&396$eq_t&397$fpz&398$sp2&399$Ut&403$:&404$z.1,&405$x,&406$Dz1&407$s1z&408$s1'x&409$s0'x&128$orbT&129$ay&131$eq_a&135$y&136$s_y&137$eq_a12&138$s'y&139$eq_in_count&140$has_filter&141$Es12&142$in&143$Hx&144$*&145$eqxx&147$all_pred1_nseq&148$def_s&150$has_pred0&151$has_sym&152$negb_or&153$cat_uniq&154$andbCA&155$uniq_catC&156$mem_filter&157$negbTE&158$mem_rev&159$Hy&160$all_pred1P&161$count_uniq_mem&162$s_x&163$mem_undup&164$size_undup&165$find_size&167$has_pred1&168$find_cat&169$lt_i_s&170$mem_nth&171$rcons_uniq&172$index_cat&173$size_belast&174$index_uniq&175$eq_sij&176$cat_cons&179$i.+1&181$nax&182$exists&183$i]&184$eq_all&185$a_s&186$IHv&187$count_cat&189$addn_eq0&190$count_predC&191$filter_predI&192$cnt_a'&193$leq_add2r&195$eq12&196$perm_eq_sym&198$eqn_add2l&199$perm_catC&201$perm_cat2r&203$cat1s&205$perm_catCA&206$perm_cons&207$def_s2&208$mem_rot&209$negPf&210$rot_uniq&211$le_s21&212$leqNgt&214$s3x&215$uniq_leq_size&216$eqs12&217$eqs12,&219$uniq_size_uniq&220$@uniq_leq_size&222$s2x&223$Hs12&224$x&229$\in&230$s1&231$by&232$/(rot i s1)&233$def_s1&234$FcatCA&236$addnK&237$rot1_cons&238$rotK&239$has_rot&240$subKn&241$rot0&242$size_rev&244$size_rotr&247$@size_takel&248$5(catA, =^~ rot_size_cat)&249$leq_addl&250$rot_addn&252$addnBA&253$@rot_oversize&254$1ltnW&255$rot_add_mod&256$1addnC&257$rot_rot&258$has_mask_cons&259$Hsn0:&260$size&261$take&262$=&263$Hs&264$size_mask&265$mask_cat&266$mask_rot&269$size_nseq&270$mask_false&271$sz_m&273$geq_min&274$nth_take&275$negb_add&276$addbF&277$addbT&278$negb_eqb&279$before_find&280$def_m_i&281$lt_i_m&282$subnKC&283$congr1&284$drop_nth&287$nth_index&288$index_mem&289$mask0&290$sz_m1&291$sz_m2&292$cat_subseq&293$sub0seq&294$mask_true&296$all_predC&305$map_cat&306$map_take&307$map_drop&308$map_rot&310$size_map&311$filter_mask&312$a_x&313$size_subseq_leqif&315$subseq_filter&316$introT&317$uniq_perm_eq&318$filter_uniq&319$Ds2&321$perm_rcons&322$eqP&323$x']&324$map_mask&326$inj_in_eq&327$count_map&330$Est&331$eq_sz&334$ltis&335$nth_map&336$Ef&337$eq_f12&338$eqf12&339$eqxx,&340$sy&341$gK&343$fK&344$mem_map&345$pmap_filter&346$size_pmap&348$IHn1&352$addnS&353$iota_add&354$size_iota&355$andbN&356$leq_eqVlt&357$mem_iota&359$nth_iota&361$size_mkseq&363$Hi&364$nth_mkseq&365$mkseq_nth&367$perm_map&368$perm_eq_small&369$s&370$Ds&371$iota_addl&372$map_rotr&373$map_comp&374$@eq_map&375$mulnC&376$sumn_nseq&377$foldr_cat&378$revK&379$Hfg&380$Hgf&381$addn_minr&382$size_zip&383$zip_cat&384$zip_rcons&385$IHss&386$IHsh&387$leq_subLR&388$leq_add2l&390$leq_max&391$def_z&392$def_x'&393$map_f&394$not_fxt_z&395$eq_s&396$eq_t&397$fpz&398$sp2&399$Ut&403$:&404$z.1,&405$x,&406$Dz1&407$s1z&408$s1'x&409$s0'x&128$orbT&129$ay&131$eq_a&135$y&136$s_y&137$eq_a12&138$s'y&139$eq_in_count&140$has_filter&141$Es12&142$in&143$Hx&144$*&145$eqxx&147$all_pred1_nseq&148$def_s&150$has_pred0&151$has_sym&152$negb_or&153$cat_uniq&154$andbCA&155$uniq_catC&156$mem_filter&157$negbTE&158$mem_rev&159$Hy&160$all_pred1P&161$count_uniq_mem&162$s_x&163$mem_undup&164$size_undup&165$find_size&167$has_pred1&168$find_cat&169$lt_i_s&170$mem_nth&171$rcons_uniq&172$index_cat&173$size_belast&174$index_uniq&175$eq_sij&176$cat_cons&179$i.+1&181$nax&182$exists&183$i]&184$eq_all&185$a_s&186$IHv&187$count_cat&189$addn_eq0&190$count_predC&191$filter_predI&192$cnt_a'&193$leq_add2r&195$eq12&196$perm_eq_sym&198$eqn_add2l&199$perm_catC&201$perm_cat2r&203$cat1s&205$perm_catCA&206$perm_cons&207$def_s2&208$mem_rot&209$negPf&210$rot_uniq&211$le_s21&212$leqNgt&214$s3x&215$uniq_leq_size&216$eqs12&217$eqs12,&219$uniq_size_uniq&220$@uniq_leq_size&222$s2x&223$Hs12&224$x&229$\in&230$s1&231$by&232$/(rot i s1)&233$def_s1&234$FcatCA&236$addnK&237$rot1_cons&238$rotK&239$has_rot&240$subKn&241$rot0&242$size_rev&244$size_rotr&247$@size_takel&248$5(catA, =^~ rot_size_cat)&249$leq_addl&250$rot_addn&252$addnBA&253$@rot_oversize&254$1ltnW&255$rot_add_mod&256$1addnC&257$rot_rot&258$has_mask_cons&259$Hsn0:&260$size&261$take&262$=&263$Hs&264$size_mask&265$mask_cat&266$mask_rot&269$size_nseq&270$mask_false&271$sz_m&273$geq_min&274$nth_take&275$negb_add&276$addbF&277$addbT&278$negb_eqb&279$before_find&280$def_m_i&281$lt_i_m&282$subnKC&283$congr1&284$drop_nth&287$nth_index&288$index_mem&289$mask0&290$sz_m1&291$sz_m2&292$cat_subseq&293$sub0seq&294$mask_true&296$all_predC&305$map_cat&306$map_take&307$map_drop&308$map_rot&310$size_map&311$filter_mask&312$a_x&313$size_subseq_leqif&315$subseq_filter&316$introT&317$uniq_perm_eq&318$filter_uniq&319$Ds2&321$perm_rcons&322$eqP&323$x']&324$map_mask&326$inj_in_eq&327$count_map&330$Est&331$eq_sz&334$ltis&335$nth_map&336$Ef&337$eq_f12&338$eqf12&339$eqxx,&340$sy&341$gK&343$fK&344$mem_map&345$pmap_filter&346$size_pmap&348$IHn1&352$addnS&353$iota_add&354$size_iota&355$andbN&356$leq_eqVlt&357$mem_iota&359$nth_iota&361$size_mkseq&363$Hi&364$nth_mkseq&365$mkseq_nth&367$perm_map&368$perm_eq_small&369$s&370$Ds&371$iota_addl&372$map_rotr&373$map_comp&374$@eq_map&375$mulnC&376$sumn_nseq&377$foldr_cat&378$revK&379$Hfg&380$Hgf&381$addn_minr&382$size_zip&383$zip_cat&384$zip_rcons&385$IHss&386$IHsh&387$leq_subLR&388$leq_add2l&390$leq_max&391$def_z&392$def_x'&393$map_f&394$not_fxt_z&395$eq_s&396$eq_t&397$fpz&398$sp2&399$Ut&403$:&404$z.1,&405$x,&406$Dz1&407$s1z&408$s1'x&409$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$addSn&100.1$plus_Sn_m&100.14999999999999$plus_n_Sm&100.175$app_nil_l2&100.1875$mult_n_O&100.19375$O_minus&100.19687499999999$mult_O_n&100.1984375$plus_n_O&100.19921875$aux12&100.199609375$aux7&100.19980468749999$aux10&100.19990234375$mulSn&100.199951171875$addnCA&100.1999755859375$aux11&100.19998779296874$mulnS&100.19999389648437$s0'x&128$orbT&129$ay&131$eq_a&135$y&136$s_y&137$eq_a12&138$s'y&139$eq_in_count&140$has_filter&141$Es12&142$in&143$Hx&144$*&145$eqxx&147$all_pred1_nseq&148$def_s&150$has_pred0&151$has_sym&152$negb_or&153$cat_uniq&154$andbCA&155$uniq_catC&156$mem_filter&157$negbTE&158$mem_rev&159$Hy&160$all_pred1P&161$count_uniq_mem&162$s_x&163$mem_undup&164$size_undup&165$find_size&167$has_pred1&168$find_cat&169$lt_i_s&170$mem_nth&171$rcons_uniq&172$index_cat&173$size_belast&174$index_uniq&175$eq_sij&176$cat_cons&179$i.+1&181$nax&182$exists&183$i]&184$eq_all&185$a_s&186$IHv&187$count_cat&189$addn_eq0&190$count_predC&191$filter_predI&192$cnt_a'&193$leq_add2r&195$eq12&196$perm_eq_sym&198$eqn_add2l&199$perm_catC&201$perm_cat2r&203$cat1s&205$perm_catCA&206$perm_cons&207$def_s2&208$mem_rot&209$negPf&210$rot_uniq&211$le_s21&212$leqNgt&214$s3x&215$uniq_leq_size&216$eqs12&217$eqs12,&219$uniq_size_uniq&220$@uniq_leq_size&222$s2x&223$Hs12&224$x&229$\in&230$s1&231$by&232$/(rot i s1)&233$def_s1&234$FcatCA&236$addnK&237$rot1_cons&238$rotK&239$has_rot&240$subKn&241$rot0&242$size_rev&244$size_rotr&247$@size_takel&248$5(catA, =^~ rot_size_cat)&249$leq_addl&250$rot_addn&252$addnBA&253$@rot_oversize&254$1ltnW&255$rot_add_mod&256$1addnC&257$rot_rot&258$has_mask_cons&259$Hsn0:&260$size&261$take&262$=&263$Hs&264$size_mask&265$mask_cat&266$mask_rot&269$size_nseq&270$mask_false&271$sz_m&273$geq_min&274$nth_take&275$negb_add&276$addbF&277$addbT&278$negb_eqb&279$before_find&280$def_m_i&281$lt_i_m&282$subnKC&283$congr1&284$drop_nth&287$nth_index&288$index_mem&289$mask0&290$sz_m1&291$sz_m2&292$cat_subseq&293$sub0seq&294$mask_true&296$all_predC&305$map_cat&306$map_take&307$map_drop&308$map_rot&310$size_map&311$filter_mask&312$a_x&313$size_subseq_leqif&315$subseq_filter&316$introT&317$uniq_perm_eq&318$filter_uniq&319$Ds2&321$perm_rcons&322$eqP&323$x']&324$map_mask&326$inj_in_eq&327$count_map&330$Est&331$eq_sz&334$ltis&335$nth_map&336$Ef&337$eq_f12&338$eqf12&339$eqxx,&340$sy&341$gK&343$fK&344$mem_map&345$pmap_filter&346$size_pmap&348$IHn1&352$addnS&353$iota_add&354$size_iota&355$andbN&356$leq_eqVlt&357$mem_iota&359$nth_iota&361$size_mkseq&363$Hi&364$nth_mkseq&365$mkseq_nth&367$perm_map&368$perm_eq_small&369$s&370$Ds&371$iota_addl&372$map_rotr&373$map_comp&374$@eq_map&375$mulnC&376$sumn_nseq&377$foldr_cat&378$revK&379$Hfg&380$Hgf&381$addn_minr&382$size_zip&383$zip_cat&384$zip_rcons&385$IHss&386$IHsh&387$leq_subLR&388$leq_add2l&390$leq_max&391$def_z&392$def_x'&393$map_f&394$not_fxt_z&395$eq_s&396$eq_t&397$fpz&398$sp2&399$Ut&403$:&404$z.1,&405$x,&406$Dz1&407$s1z&408$s1'x&409$addnS&104$eqn_add2l&105$Heq&107$eqxx&108$subnDl&110$subnDA&114$subnS&115$leqNgt&119$leq_eqVlt&120$negb_or&121$implyNb&125$eq_axiomK&126$def_n2&127$le_mn&129$@leq_trans&133$lt0n&135$addn_eq0&136$subn_eq0&137$leq_subLR&138$addnK&140$subnDr&141$addSn&143$maxnC&144$maxnAC&145$orb_idr&147$leq_max&148$leq_maxl&149$gtn_max&150$addnAC&151$addn_maxl&152$addn_min_max&153$minnC&154$minnE&155$subnAC&156$minnAC&157$minnA&158$minnCA&159$sameP&160$eqn_add2r&161$le_n21&163$leq_min&164$gtn_min&165$geq_min&166$geq_minl&167$addnBA&168$leq_subr&169$addn_minr&170$minn_idPr&171$geq_max&172$leq_maxr&173$le_m21&174$maxn_minl&175$maxn_minr&176$maxnK&177$minn_maxl&178$Pm&180$m_lb&181$subKn&182$ubP&183$le_i_mj:&184$<=&185$m1_lb&186$m2_lb,&187$eqPQ&188$max_i&189$max_j&190$eq_f&191$mulSn&193$mulnS&194$mulnSr&195$muln0&196$muln0,&197$mulnC&198$mulnDl&199$mulnBl&200$mulnA&201$mulnCA&202$mulnBr&203$muln_eq0&204$leq_mul2l&205$le_mn2&207$orbT&208$leq_mul2r&209$le_mn1&210$orb_andr&211$eqn_mul2l&212$eqn_mul2r&213$ltn_mul2l&214$ltn_mul2r&215$mul1n&216$ltn_pmul2r&217$ltn_Pmull&218$maxn_mulr&220$minn_mulr&221$muln1&222$expnS&223$mul1n,&224$exp1n&225$expnD&226$expnMn&227$expnM&228$addn_gt0&229$eqn0Ngt&230$expn_gt0&231$leq_pmul2l&232$leq_pmulr&233$leq_exp2l&234$eqn_exp2l&235$leq_exp2l]&236$ltn_exp2l]&237$leq_mul&239$expn1&240$ltn_mul&241$IHe&242$ltn_exp2r&243$leq_exp2r&244$eqn_exp2r&245$muln_gt0&246$addTb&247$addbA&248$odd_add&251$odd_sub&252$andb_addl&253$odd_mul&254$addnn&255$mul2n&256$doubleB&257$2ltnNge&258$leq_double&259$doubleS&260$ltn_Sdouble&261$addbb&262$muln2&263$uphalf_half&264$doubleD&265$half_double,&266$odd_double_half&267$half_double&268$uphalf_double&269$halfD&270$mulnn&271$mulnDr&272$def_m&273$sqrnD&274$2addnA&275$/(2 * 2)&276$sqrn_sub&277$lte&280$ltm12&281$ltm23&282$andbT&283$eqm12&284$f_mono&285$in&286$hyp&287$*&288$lemn&289$le_ab&290$geq_leqif&291$n12_0&294$le2&295$m2_0&296$n1_gt0&297$n2_gt0&298$sqrn_gt0&299$ne_mn&300$ltn_add2r&301$nat_Cauchy&302$addE&303$add_mulE&304$mulE&305$mul_expE&306$sub2nn&307$:&308$n.*2&309$def_b&106$mem_topred&130$symR&132$Rxy&133$eqiR&134$fK&135$hf&140$fgK&141$mf&143$fgK_on&144$addnS&104$eqn_add2l&105$Heq&107$eqxx&108$subnDl&110$subnDA&114$subnS&115$leqNgt&119$leq_eqVlt&120$negb_or&121$implyNb&125$eq_axiomK&126$def_n2&127$le_mn&129$@leq_trans&133$lt0n&135$addn_eq0&136$subn_eq0&137$leq_subLR&138$addnK&140$subnDr&141$addSn&143$maxnC&144$maxnAC&145$orb_idr&147$leq_max&148$leq_maxl&149$gtn_max&150$addnAC&151$addn_maxl&152$addn_min_max&153$minnC&154$minnE&155$subnAC&156$minnAC&157$minnA&158$minnCA&159$sameP&160$eqn_add2r&161$le_n21&163$leq_min&164$gtn_min&165$geq_min&166$geq_minl&167$addnBA&168$leq_subr&169$addn_minr&170$minn_idPr&171$geq_max&172$leq_maxr&173$le_m21&174$maxn_minl&175$maxn_minr&176$maxnK&177$minn_maxl&178$Pm&180$m_lb&181$subKn&182$ubP&183$le_i_mj:&184$<=&185$le_i_mj&186$:&187$subnBA&188$addnS&104$eqn_add2l&105$Heq&107$eqxx&108$subnDl&110$subnDA&114$subnS&115$leqNgt&119$leq_eqVlt&120$negb_or&121$implyNb&125$eq_axiomK&126$def_n2&127$addnS&104$eqn_add2l&105$Heq&107$eqxx&108$subnDl&110$subnDA&114$subnS&115$leqNgt&119$leq_eqVlt&120$negb_or&121$implyNb&125$eq_axiomK&126$def_n2&127$le_mn&129$@leq_trans&133$lt0n&135$addn_eq0&136$subn_eq0&137$leq_subLR&138$addnK&140$subnDr&141$addSn&143$maxnC&144$maxnAC&145$orb_idr&147$leq_max&148$leq_maxl&149$gtn_max&150$addnAC&151$addn_maxl&152$addn_min_max&153$minnC&154$minnE&155$subnAC&156$minnAC&157$minnA&158$minnCA&159$sameP&160$eqn_add2r&161$le_n21&163$leq_min&164$gtn_min&165$geq_min&166$geq_minl&167$addnBA&168$leq_subr&169$addn_minr&170$minn_idPr&171$geq_max&172$leq_maxr&173$le_m21&174$maxn_minl&175$maxn_minr&176$maxnK&177$minn_maxl&178$Pm&180$m_lb&181$subKn&182$ubP&183$le_i_mj:&184$<=&185$subnBA&186$:&187$addnS&104$eqn_add2l&105$Heq&107$eqxx&108$subnDl&110$subnDA&114$subnS&115$leqNgt&119$leq_eqVlt&120$negb_or&121$implyNb&125$eq_axiomK&126$def_n2&127$le_mn&129$@leq_trans&133$lt0n&135$addn_eq0&136$subn_eq0&137$leq_subLR&138$addnK&140$subnDr&141$addSn&143$maxnC&144$maxnAC&145$orb_idr&147$leq_max&148$leq_maxl&149$gtn_max&150$addnAC&151$addn_maxl&152$addn_min_max&153$minnC&154$minnE&155$subnAC&156$minnAC&157$minnA&158$minnCA&159$sameP&160$eqn_add2r&161$le_n21&163$leq_min&164$gtn_min&165$geq_min&166$geq_minl&167$addnBA&168$leq_subr&169$addn_minr&170$minn_idPr&171$geq_max&172$leq_maxr&173$le_m21&174$maxn_minl&175$maxn_minr&176$maxnK&177$minn_maxl&178$Pm&180$m_lb&181$subKn&182$ubP&183$subnBA&184$m1_lb&185$m2_lb,&186$eqPQ&187$max_i&188$max_j&189$eq_f&190$mulSn&192$mulnS&193$mulnSr&194$muln0&195$muln0,&196$mulnC&197$mulnDl&198$mulnBl&199$mulnA&200$mulnCA&201$mulnBr&202$muln_eq0&203$leq_mul2l&204$le_mn2&206$orbT&207$leq_mul2r&208$le_mn1&209$orb_andr&210$eqn_mul2l&211$eqn_mul2r&212$ltn_mul2l&213$ltn_mul2r&214$mul1n&215$ltn_pmul2r&216$ltn_Pmull&217$maxn_mulr&219$minn_mulr&220$muln1&221$expnS&222$mul1n,&223$exp1n&224$expnD&225$expnMn&226$expnM&227$addn_gt0&228$eqn0Ngt&229$expn_gt0&230$leq_pmul2l&231$leq_pmulr&232$leq_exp2l&233$eqn_exp2l&234$leq_exp2l]&235$ltn_exp2l]&236$leq_mul&238$expn1&239$ltn_mul&240$IHe&241$ltn_exp2r&242$leq_exp2r&243$eqn_exp2r&244$muln_gt0&245$addTb&246$addbA&247$odd_add&250$odd_sub&251$andb_addl&252$odd_mul&253$addnn&254$mul2n&255$doubleB&256$2ltnNge&257$leq_double&258$doubleS&259$ltn_Sdouble&260$addbb&261$muln2&262$uphalf_half&263$doubleD&264$half_double,&265$odd_double_half&266$half_double&267$uphalf_double&268$halfD&269$mulnn&270$mulnDr&271$def_m&272$sqrnD&273$2addnA&274$/(2 * 2)&275$sqrn_sub&276$lte&279$ltm12&280$ltm23&281$andbT&282$eqm12&283$f_mono&284$in&285$hyp&286$*&287$lemn&288$le_ab&289$geq_leqif&290$n12_0&293$le2&294$m2_0&295$n1_gt0&296$n2_gt0&297$sqrn_gt0&298$ne_mn&299$ltn_add2r&300$nat_Cauchy&301$addE&302$add_mulE&303$mulE&304$mul_expE&305$sub2nn&306$natTrecE&307$by&310$IHp&311$nat_of_succ_gt0&312$doubleS,&313$doubleMl&315$mulC&102$mulm1&103$iteropS&104$mulmA&105$mulmC&106$mulmCA&107$mem_iota&110$leq_subLR&111$subSn&112$subnDA&113$subnKC&114$enumT&115$mem_enum&116$unlock&117$f_op&122$big_filter&125$filter_predI&126$mkseq_nth&129$big_map&130$eqn0Ngt&131$big_hasC&132$has_pred0&133$foldr_cat&135$big_cat_nested&136$big_seq_cond&138$big_andbC&139$big_seq&140$eq_bigr&141$mem_index_iota&142$big_nat_cond&143$big_nil&146$big_cons&147$iota_addl&149$big_addn&150$big_ltn&151$big_add1&152$val_ord_enum&153$sorted_filter&155$iota_ltn_sorted&156$mem_filter&157$andbCA&158$andb_idr&159$big_mkord&160$len12&161$big_ord_widen_cond&162$inord_val&163$big_pred0&164$]&165$big_ord0&166$big_nth&167$tnth_nth&168$big_ord_widen_leq&169$inordK&172$eqFG&173$big_const_seq&174$cardE&175$size_iota&176$big_const&177$card_ord&178$big1&181$big_mkcond&182$mul1m,&183$filter_index_enum&184$enum1&185$big_seq1&186$big_cat&188$iota_add&189$leq_sub&190$big_geq&191$@big_cat_nat&192$leqnSn&193$big_nat1&194$big_nat_recr&195$leqW&197$val_enum_ord&199$map_cat&200$map_comp&201$eqxx&202$count_cat&204$uniq_perm_eq&207$enum_uniq&208$big_tnth&209$index_uniq&210$valK&211$filter_undup&212$IHr&213$big_rem&214$idM&215$big_undup&216$undup_uniq&217$mem_undup&218$eq_r&219$big_split&220$simpm&221$bigID&222$orbK&223$cardD1&225$Aj&226$Qp&228$Q0&229$cardD1x&230$bigD1&231$Qj,&232$j&233$P0&234$IH&235$h'K&236$reindex_onto&237$hK&238$reindex_inj&241$addSn&242$subnDr&243$addnBA&244$partition_big&245$Pi&246$andbT&247$andb_idl&249$exchange_big_dep&250$Qi&251$2(big_seq_cond _ _ _ xQ)&252$exchange_big_dep_nat&253$big_endo&254$mulm0&256$x&257$y&258$big_distrl&260$big_distrr&261$f&263$ffunE&264$nri&265$eqP&266$big_distr_big_dep&267$mul0m&269$bigA_distr_big&271$big_has_cond&272$big_all_cond&273$allB&274$sum_nat_const&276$muln1&277$Monoid&278$big_const_nat&279$big_andE&280$@leqif_sum&283$muln_gt0&284$leq_maxl&286$geq_max&291$dvdn_lcm&294$in&295$dvFm&296$p_m&297$dvdn_trans&298$dvdn_lcml&299$dvdn_gcd&300$dvmF&301$m_p&302$dvdn_gcdl&303$mul0n&304$muln0&305$mulnDr&306$mulnDl&307$mulnC&308$addn2&309$exp0n&310$big1_seq&311$in_nil&312$big_cat_nested,&313$op_idx'&314$mulC&102$mulm1&103$iteropS&104$mulmA&105$mulmC&106$mulmCA&107$mem_iota&110$leq_subLR&111$subSn&112$subnDA&113$subnKC&114$enumT&115$mem_enum&116$unlock&117$f_op&122$big_filter&125$filter_predI&126$mkseq_nth&129$big_map&130$eqn0Ngt&131$big_hasC&132$has_pred0&133$foldr_cat&135$big_cat_nested&136$big_seq_cond&138$big_andbC&139$big_seq&140$eq_bigr&141$mem_index_iota&142$big_nat_cond&143$big_nil&146$big_cons&147$iota_addl&149$big_addn&150$big_ltn&151$big_add1&152$val_ord_enum&153$sorted_filter&155$iota_ltn_sorted&156$mem_filter&157$andbCA&158$andb_idr&159$big_mkord&160$len12&161$big_ord_widen_cond&162$inord_val&163$big_pred0&164$]&165$big_ord0&166$big_nth&167$tnth_nth&168$big_ord_widen_leq&169$inordK&172$eqFG&173$big_const_seq&174$cardE&175$size_iota&176$big_const&177$card_ord&178$big_cat_nested,&179$op_idx'&180$big1&183$big_mkcond&184$mul1m,&185$filter_index_enum&186$enum1&187$big_seq1&188$big_cat&190$iota_add&191$leq_sub&192$big_geq&193$@big_cat_nat&194$leqnSn&195$big_nat1&196$big_nat_recr&197$leqW&199$val_enum_ord&201$map_cat&202$map_comp&203$eqxx&204$count_cat&206$uniq_perm_eq&209$enum_uniq&210$big_tnth&211$index_uniq&212$valK&213$filter_undup&214$IHr&215$big_rem&216$idM&217$big_undup&218$undup_uniq&219$mem_undup&220$eq_r&221$big_split&222$simpm&223$bigID&224$orbK&225$cardD1&227$Aj&228$Qp&230$Q0&231$cardD1x&232$bigD1&233$Qj,&234$j&235$P0&236$IH&237$h'K&238$reindex_onto&239$hK&240$reindex_inj&243$addSn&244$subnDr&245$addnBA&246$partition_big&247$Pi&248$andbT&249$andb_idl&251$exchange_big_dep&252$Qi&253$2(big_seq_cond _ _ _ xQ)&254$exchange_big_dep_nat&255$big_endo&256$mulm0&258$x&259$y&260$big_distrl&262$big_distrr&263$f&265$ffunE&266$nri&267$eqP&268$big_distr_big_dep&269$mul0m&271$bigA_distr_big&273$big_has_cond&274$big_all_cond&275$allB&276$sum_nat_const&278$muln1&279$Monoid&280$big_const_nat&281$big_andE&282$@leqif_sum&285$muln_gt0&286$leq_maxl&288$geq_max&293$dvdn_lcm&296$in&297$dvFm&298$p_m&299$dvdn_trans&300$dvdn_lcml&301$dvdn_gcd&302$dvmF&303$m_p&304$dvdn_gcdl&305$mul0n&306$muln0&307$mulnDr&308$mulnDl&309$mulnC&310$addn2&311$exp0n&312$big1_seq&313$in_nil&314$ffunE&102$card_sub&104$card_ffun&105$card_prod&106$card_ord&107$mxE&108$ord1&111$perm1&112$permM&113$eq_axiomK&114$cast_ord_id&115$castmx_id&116$mxE,&119$unsplitK&122$row_mxEl&123$row_mxEr&124$col_mxEu&126$col_mxEd&127$row_mxKl,&128$col_mxKu,&129$tr_col_mx&131$trmx_usub&132$trmx_dsub&133$hsubmxK&134$castmxE&136$mxE]&137$trmx_cast&138$row_mxA&139$tr_col,&140$tr_col',&141$row_mxEl,&142$row_mxEr,&143$col_mxEu,&144$col_mxEd,&145$2mxE&146$def_j'&148$addSn&149$ltn_addr&150$@tr_row'&151$@tr_col_mx&152$col'Kl&153$addnS&154$def_j&155$leqNgt&156$leq_add2l&157$tr_row',&158$col'Kr&159$vsubmxK&160$col_mxKu&161$row_mxKl&162$row_mxKr&163$col_mxKd&164$submxK&165$trmx_ulsub&166$trmx_ursub&167$trmx_dlsub&168$trmx_drsub&169$block_mxKul&170$block_mxKur&171$block_mxKdl&172$block_mxKdr&173$tr_block_mx&174$tr_row_mx&175$2tr_col_mx&176$block_mxEh&177$col_mxA&178$cast_row_mx&179$block_mxEv&180$cast_col_mx&181$castmx_comp&182$etrans_id&183$cast_ordK&184$enum_valK&185$enum_rankK&186$mxvecE&187$castmxE,&188$conform_mx_id&189$neq_mn&190$B&191$nonconform_mx&192$addrA&193$addrC&194$add0r&195$addNr&196$mulrS&197$IHd&198$can2_eq&202$raddf0&203$opp_col_mx&207$opp_row_mx&208$add_col_mx&209$add_row_mx&210$negbTE&211$row0&214$eqxx&215$map_const_mx&216$raddfN&217$raddfD&218$map_mxD&219$map_mxN&220$mul1r&221$mulrDl&222$mulrDr&223$mulrA&224$summxE&225$bigD1&226$mulr1&227$big1&228$addr0&229$diff&230$j'&231$mulr0&232$matrix_sum_delta&233$big_ord1&234$can_eq&235$inj_eq&236$vec_mx_delta&237$vec_mxK&238$scale_col_mx&239$scale_row_mx&240$mulrnAr&241$mulrnDl&242$mulr_natr&243$i'&244$ne_i'i&245$diag_const_mx&247$raddfB&248$scale_scalar_mx&249$diag_mx_sum_delta&250$scalar_mx_sum_delta&252$scaler_sumr&253$scale1r&254$A&256$eqxx]&257$eqn0Ngt&258$n0&259$in&260$*&261$flatmx0&262$val_eqE&263$eqn_add2l&264$big_distrr&265$exchange_big&266$big_distrl&267$j&268$mul0r&269$sumrN&270$mulrN&271$mulNr&272$big_split&273$mulmxDl&274$mulNmx&275$mulmxDr&276$mulmxN&277$mul0mx&279$mulmx0&281$rowE&282$mulmxA&283$mulmxnE&284$andbT&285$natrM&286$mulrnA&287$mulnb&288$andbAC&289$mul_delta_mx_cond&290$mulrnAl&291$mul_diag_mx&292$mul_scalar_mx&293$mul_mx_diag&294$reindex_inj&295$permKV&296$mul_col_perm&297$invgK&298$tpermV&299$mul_row_perm&300$mulmx1&301$mul1mx&302$col_permE&303$trmx1&305$tr_perm_mx&306$row_permM&308$perm_mx1&310$perm_mx_is_perm&311$is_perm_mx_tr&312$is_perm_mxMl&313$perm_mx_is_perm,&314$ltn_ord&315$lshift_subproof&316$row_mx0&317$leq_min&318$tr_pid_mx&319$pid_mx_minv&320$pid_mx_minh&321$le_n_i&322$andbCA&323$mul_pid_mx&324$minnn&325$minn_idPr&326$mulmxBl&327$pid_mx_id&328$subrr&329$mulmxBr&330$mul_pid_mx_copid&331$oppr0&332$defk&333$defi&334$big_split_ord&335$mul_col_mx&336$mul_mx_row&337$mul_row_col&338$mul_row_block&339$linear_sum&340$linearZ&341$mul_rV_lin&343$mxvecK&344$scalemxAl&345$linearP&346$row_mul&347$raddf0]&348$mulr_sumr&349$mxtrace_diag&351$mx11_scalar&353$block_mxEul,&354$oner_eq0&355$lift_permV&359$permK&360$canF_eq&361$split1&362$lift0_perm_lift&363$lift0_perm0&364$lift0_mx_perm&365$rmorphM&366$rmorph_sum&367$rmorph_nat&368$rmorphMn&369$map_scalar_mx&370$rmorph1&371$rmorph_sign&373$rmorph_prod&374$det_map_mx&375$map_row'&376$map_col'&377$cofactor_map_mx&378$map_mx_sub&379$map_mx1&380$map_pid_mx&381$map_delta_mx&385$def_gf&386$map_mxvec&388$map_vec_mx&389$trmx_mul_rev&390$mulrC&391$trmx_mul&392$scalemxAr&393$reindex&394$pair_bigA&395$mulrAC&396$mulmx_sum_row&397$scaler_suml&398$mulmx_diag&399$row_id&402$mulrCA&403$BA&404$CA&405$bigID&406$oddMt&410$mulN1r&411$tpermK&412$eqA12&413$odd_permV&414$t&415$Dst&416$det_perm&417$odd_perm1&418$det1&419$prodr_const&420$scale0r&421$detZ&422$exprS&423$bigA_distr_bigA&425$valP&427$signr_addb&428$odd_permM&429$pvalE&430$determinant_alternate&431$simp&432$Ef12&433$p_i&437$ulsfK&439$liftK&440$permE&441$si0&442$signr_odd&443$odd_add&444$odd_lift_perm&445$_]&446$neq_lift&447$partition_big&448$expand_cofactor&449$tr_row'&451$tr_col'&452$det_tr&453$expand_det_row&454$cofactor_tr&455$cofactorZ&456$eqP&457$Di&458$eq_refl&459$trmx_adj&460$mul_mx_adj&461$mul_adj_mx&462$kA:&463$A'&464$*m&465$=&466$1%:M&467$by&468$kA&469$AB1&470$def_m&471$mul_col_row&472$scalar_mx_block&473$BlAu1&474$AuBr0&475$oner_neq0&476$expand_det_col&477$1simp&478$block_mxEdl&479$block_mxEul&480$col'_col_mx&481$row'Ku&482$row'_row_mx&483$IHn1&484$trmx0&485$det_ublock&486$unitmxE&487$unitr1&488$unitrX&489$unitrN&490$unitrM&491$invr1&492$adj1&493$if_same&494$Ua&495$U_A&496$adjZ&497$scalerA&498$invrM&499$unitrX_pos&500$mulrK&501$exprSr&502$prednK&503$divrK&504$scalemx1&505$invmxZ&506$invmx1&507$invr_out&508$nsA&509$mulVr&510$mulVmx&511$mulmxV&512$uA&513$negbT&514$divrr&516$det_inv&517$unitrV&518$unitmx_tr&519$unitmx_inv&521$unitmx_mul&522$unitmx1&523$perm_mxM&526$mulVg&527$unitr0&531$mulf_eq0&533$nz_a&534$subr_eq0&536$orbF&537$scalemx_eq0&538$linearB&539$eq_aAB&540$mul_mx_scalar&542$vA0&543$detA0&544$thinmx0&545$signr_eq0&546$unlift_none&547$wjA'0&548$reindex_onto&551$defA&552$@mul_mx_row&553$/aj&554$aj0&555$wjA'&556$wj0_0&558$subr0&559$negPf&560$w0A'&561$linear0&562$fmorph_unit&565$unitfE&566$map_mxZ&568$map_mx_adj&569$fmorphV&570$is_perm_mxMr&573$mulmxE&575$xrowE&576$/A1&577$/(1 + n.+1)%N&578$mulmx_block&579$subrK&580$lshift0&581$tpermL&582$mulVf&583$_&584$elimNf&585$@det_lblock&586$def_t&589$trmxK&590$ffunE&102$card_sub&104$card_ffun&105$card_prod&106$card_ord&107$mxE&108$ord1&111$perm1&112$permM&113$eq_axiomK&114$cast_ord_id&115$castmx_id&116$mxE,&119$unsplitK&122$row_mxEl&123$row_mxEr&124$col_mxEu&126$col_mxEd&127$row_mxKl,&128$col_mxKu,&129$tr_col_mx&131$trmx_usub&132$trmx_dsub&133$hsubmxK&134$castmxE&136$mxE]&137$trmx_cast&138$row_mxA&139$tr_col,&140$tr_col',&141$row_mxEl,&142$row_mxEr,&143$col_mxEu,&144$col_mxEd,&145$2mxE&146$def_j'&148$addSn&149$ltn_addr&150$@tr_row'&151$@tr_col_mx&152$col'Kl&153$addnS&154$def_j&155$leqNgt&156$leq_add2l&157$tr_row',&158$col'Kr&159$vsubmxK&160$col_mxKu&161$row_mxKl&162$row_mxKr&163$col_mxKd&164$submxK&165$trmx_ulsub&166$trmx_ursub&167$trmx_dlsub&168$trmx_drsub&169$block_mxKul&170$block_mxKur&171$block_mxKdl&172$block_mxKdr&173$tr_block_mx&174$tr_row_mx&175$2tr_col_mx&176$block_mxEh&177$col_mxA&178$cast_row_mx&179$block_mxEv&180$cast_col_mx&181$castmx_comp&182$etrans_id&183$cast_ordK&184$enum_valK&185$enum_rankK&186$mxvecE&187$castmxE,&188$conform_mx_id&189$neq_mn&190$B&191$nonconform_mx&192$addrA&193$addrC&194$add0r&195$addNr&196$mulrS&197$IHd&198$can2_eq&202$raddf0&203$opp_col_mx&207$opp_row_mx&208$add_col_mx&209$add_row_mx&210$negbTE&211$row0&214$eqxx&215$map_const_mx&216$raddfN&217$raddfD&218$map_mxD&219$map_mxN&220$mul1r&221$mulrDl&222$mulrDr&223$mulrA&224$summxE&225$bigD1&226$mulr1&227$big1&228$addr0&229$diff&230$j'&231$mulr0&232$matrix_sum_delta&233$big_ord1&234$can_eq&235$inj_eq&236$vec_mx_delta&237$vec_mxK&238$scale_col_mx&239$scale_row_mx&240$mulrnAr&241$mulrnDl&242$mulr_natr&243$i'&244$ne_i'i&245$diag_const_mx&247$raddfB&248$scale_scalar_mx&249$diag_mx_sum_delta&250$scalar_mx_sum_delta&252$scaler_sumr&253$scale1r&254$A&256$eqxx]&257$eqn0Ngt&258$n0&259$in&260$*&261$flatmx0&262$val_eqE&263$eqn_add2l&264$big_distrr&265$exchange_big&266$big_distrl&267$j&268$mul0r&269$sumrN&270$mulrN&271$mulNr&272$big_split&273$mulmxDl&274$mulNmx&275$mulmxDr&276$mulmxN&277$mul0mx&279$mulmx0&281$rowE&282$mulmxA&283$mulmxnE&284$andbT&285$natrM&286$mulrnA&287$mulnb&288$andbAC&289$mul_delta_mx_cond&290$mulrnAl&291$mul_diag_mx&292$mul_scalar_mx&293$mul_mx_diag&294$reindex_inj&295$permKV&296$mul_col_perm&297$invgK&298$tpermV&299$mul_row_perm&300$mulmx1&301$mul1mx&302$col_permE&303$trmx1&305$tr_perm_mx&306$row_permM&308$perm_mx1&310$perm_mx_is_perm&311$perm_mxM&312$def_t&313$mulVg&314$trmxK&315$is_perm_mx_tr&316$is_perm_mxMl&317$perm_mx_is_perm,&318$ltn_ord&319$lshift_subproof&320$row_mx0&321$leq_min&322$tr_pid_mx&323$pid_mx_minv&324$pid_mx_minh&325$le_n_i&326$andbCA&327$mul_pid_mx&328$minnn&329$minn_idPr&330$mulmxBl&331$pid_mx_id&332$subrr&333$mulmxBr&334$mul_pid_mx_copid&335$oppr0&336$defk&337$defi&338$big_split_ord&339$mul_col_mx&340$mul_mx_row&341$mul_row_col&342$mul_row_block&343$linear_sum&344$linearZ&345$mul_rV_lin&347$mxvecK&348$scalemxAl&349$linearP&350$row_mul&351$raddf0]&352$mulr_sumr&353$mxtrace_diag&355$mx11_scalar&357$block_mxEul,&358$oner_eq0&359$lift_permV&363$permK&364$canF_eq&365$split1&366$lift0_perm_lift&367$lift0_perm0&368$lift0_mx_perm&369$rmorphM&370$rmorph_sum&371$rmorph_nat&372$rmorphMn&373$map_scalar_mx&374$rmorph1&375$rmorph_sign&377$rmorph_prod&378$det_map_mx&379$map_row'&380$map_col'&381$cofactor_map_mx&382$map_mx_sub&383$map_mx1&384$map_pid_mx&385$map_delta_mx&389$def_gf&390$map_mxvec&392$map_vec_mx&393$trmx_mul_rev&394$mulrC&395$trmx_mul&396$scalemxAr&397$reindex&398$pair_bigA&399$mulrAC&400$mulmx_sum_row&401$scaler_suml&402$mulmx_diag&403$row_id&406$mulrCA&407$BA&408$CA&409$bigID&410$oddMt&414$mulN1r&415$tpermK&416$eqA12&417$odd_permV&418$t&419$Dst&420$det_perm&421$odd_perm1&422$det1&423$prodr_const&424$scale0r&425$detZ&426$exprS&427$bigA_distr_bigA&429$valP&431$signr_addb&432$odd_permM&433$pvalE&434$determinant_alternate&435$simp&436$Ef12&437$p_i&441$ulsfK&443$liftK&444$permE&445$si0&446$signr_odd&447$odd_add&448$odd_lift_perm&449$_]&450$neq_lift&451$partition_big&452$expand_cofactor&453$tr_row'&455$tr_col'&456$det_tr&457$expand_det_row&458$cofactor_tr&459$cofactorZ&460$eqP&461$Di&462$eq_refl&463$trmx_adj&464$mul_mx_adj&465$mul_adj_mx&466$kA:&467$A'&468$*m&469$=&470$1%:M&471$by&472$kA&473$AB1&474$def_m&475$mul_col_row&476$scalar_mx_block&477$BlAu1&478$AuBr0&479$oner_neq0&480$expand_det_col&481$1simp&482$block_mxEdl&483$block_mxEul&484$col'_col_mx&485$row'Ku&486$row'_row_mx&487$IHn1&488$trmx0&489$det_ublock&490$unitmxE&491$unitr1&492$unitrX&493$unitrN&494$unitrM&495$invr1&496$adj1&497$if_same&498$Ua&499$U_A&500$adjZ&501$scalerA&502$invrM&503$unitrX_pos&504$mulrK&505$exprSr&506$prednK&507$divrK&508$scalemx1&509$invmxZ&510$invmx1&511$invr_out&512$nsA&513$mulVr&514$mulVmx&515$mulmxV&516$uA&517$negbT&518$divrr&520$det_inv&521$unitrV&522$unitmx_tr&523$unitmx_inv&525$unitmx_mul&526$unitmx1&527$invrK&530$defA&531$perm_mxV&532$unitr0&536$mulf_eq0&538$nz_a&539$subr_eq0&541$orbF&542$scalemx_eq0&543$linearB&544$eq_aAB&545$mul_mx_scalar&547$vA0&548$detA0&549$thinmx0&550$signr_eq0&551$unlift_none&552$wjA'0&553$reindex_onto&556$@mul_mx_row&557$/aj&558$aj0&559$wjA'&560$wj0_0&562$subr0&563$negPf&564$w0A'&565$linear0&566$fmorph_unit&569$unitfE&570$map_mxZ&572$map_mx_adj&573$fmorphV&574$is_perm_mxMr&577$mulmxE&579$xrowE&580$/A1&581$/(1 + n.+1)%N&582$mulmx_block&583$subrK&584$lshift0&585$tpermL&586$mulVf&587$_&588$elimNf&589$@det_lblock&590$ffunE&102$card_sub&104$card_ffun&105$card_prod&106$card_ord&107$mxE&108$ord1&111$perm1&112$permM&113$eq_axiomK&114$cast_ord_id&115$castmx_id&116$mxE,&119$unsplitK&122$row_mxEl&123$row_mxEr&124$col_mxEu&126$col_mxEd&127$row_mxKl,&128$col_mxKu,&129$tr_col_mx&131$trmx_usub&132$trmx_dsub&133$hsubmxK&134$castmxE&136$mxE]&137$trmx_cast&138$row_mxA&139$tr_col,&140$tr_col',&141$row_mxEl,&142$row_mxEr,&143$col_mxEu,&144$col_mxEd,&145$2mxE&146$def_j'&148$addSn&149$ltn_addr&150$@tr_row'&151$@tr_col_mx&152$col'Kl&153$addnS&154$def_j&155$leqNgt&156$leq_add2l&157$tr_row',&158$col'Kr&159$vsubmxK&160$col_mxKu&161$row_mxKl&162$row_mxKr&163$col_mxKd&164$submxK&165$trmx_ulsub&166$trmx_ursub&167$trmx_dlsub&168$trmx_drsub&169$block_mxKul&170$block_mxKur&171$block_mxKdl&172$block_mxKdr&173$tr_block_mx&174$tr_row_mx&175$2tr_col_mx&176$block_mxEh&177$col_mxA&178$cast_row_mx&179$block_mxEv&180$cast_col_mx&181$castmx_comp&182$etrans_id&183$cast_ordK&184$enum_valK&185$enum_rankK&186$mxvecE&187$castmxE,&188$conform_mx_id&189$neq_mn&190$B&191$nonconform_mx&192$addrA&193$addrC&194$add0r&195$addNr&196$mulrS&197$IHd&198$can2_eq&202$raddf0&203$opp_col_mx&207$opp_row_mx&208$add_col_mx&209$add_row_mx&210$negbTE&211$row0&214$eqxx&215$map_const_mx&216$raddfN&217$raddfD&218$map_mxD&219$map_mxN&220$mul1r&221$mulrDl&222$mulrDr&223$mulrA&224$summxE&225$bigD1&226$mulr1&227$big1&228$addr0&229$diff&230$j'&231$mulr0&232$matrix_sum_delta&233$big_ord1&234$can_eq&235$inj_eq&236$vec_mx_delta&237$vec_mxK&238$scale_col_mx&239$scale_row_mx&240$mulrnAr&241$mulrnDl&242$mulr_natr&243$i'&244$ne_i'i&245$diag_const_mx&247$raddfB&248$scale_scalar_mx&249$diag_mx_sum_delta&250$scalar_mx_sum_delta&252$scaler_sumr&253$scale1r&254$A&256$eqxx]&257$eqn0Ngt&258$n0&259$in&260$*&261$flatmx0&262$val_eqE&263$eqn_add2l&264$big_distrr&265$exchange_big&266$big_distrl&267$j&268$mul0r&269$sumrN&270$mulrN&271$mulNr&272$big_split&273$mulmxDl&274$mulNmx&275$mulmxDr&276$mulmxN&277$mul0mx&279$mulmx0&281$rowE&282$mulmxA&283$mulmxnE&284$andbT&285$natrM&286$mulrnA&287$mulnb&288$andbAC&289$mul_delta_mx_cond&290$mulrnAl&291$mul_diag_mx&292$mul_scalar_mx&293$mul_mx_diag&294$reindex_inj&295$permKV&296$mul_col_perm&297$invgK&298$tpermV&299$mul_row_perm&300$mulmx1&301$mul1mx&302$col_permE&303$trmx1&305$tr_perm_mx&306$row_permM&308$perm_mx1&310$perm_mx_is_perm&311$perm_mxM&312$def_t&313$mulVg&314$trmxK&315$is_perm_mx_tr&316$is_perm_mxMl&317$perm_mx_is_perm,&318$ltn_ord&319$lshift_subproof&320$row_mx0&321$leq_min&322$tr_pid_mx&323$pid_mx_minv&324$pid_mx_minh&325$le_n_i&326$andbCA&327$mul_pid_mx&328$minnn&329$minn_idPr&330$mulmxBl&331$pid_mx_id&332$subrr&333$mulmxBr&334$mul_pid_mx_copid&335$oppr0&336$defk&337$defi&338$big_split_ord&339$mul_col_mx&340$mul_mx_row&341$mul_row_col&342$mul_row_block&343$linear_sum&344$linearZ&345$mul_rV_lin&347$mxvecK&348$scalemxAl&349$linearP&350$row_mul&351$raddf0]&352$mulr_sumr&353$mxtrace_diag&355$mx11_scalar&357$block_mxEul,&358$oner_eq0&359$lift_permV&363$permK&364$canF_eq&365$split1&366$lift0_perm_lift&367$lift0_perm0&368$lift0_mx_perm&369$rmorphM&370$rmorph_sum&371$rmorph_nat&372$rmorphMn&373$map_scalar_mx&374$rmorph1&375$rmorph_sign&377$rmorph_prod&378$det_map_mx&379$map_row'&380$map_col'&381$cofactor_map_mx&382$map_mx_sub&383$map_mx1&384$map_pid_mx&385$map_delta_mx&389$def_gf&390$map_mxvec&392$map_vec_mx&393$trmx_mul_rev&394$mulrC&395$trmx_mul&396$scalemxAr&397$reindex&398$pair_bigA&399$mulrAC&400$mulmx_sum_row&401$scaler_suml&402$mulmx_diag&403$row_id&406$mulrCA&407$BA&408$CA&409$bigID&410$oddMt&414$mulN1r&415$tpermK&416$eqA12&417$odd_permV&418$t&419$Dst&420$det_perm&421$odd_perm1&422$det1&423$prodr_const&424$scale0r&425$detZ&426$exprS&427$bigA_distr_bigA&429$valP&431$signr_addb&432$odd_permM&433$pvalE&434$determinant_alternate&435$simp&436$Ef12&437$p_i&441$ulsfK&443$liftK&444$permE&445$si0&446$signr_odd&447$odd_add&448$odd_lift_perm&449$_]&450$neq_lift&451$partition_big&452$expand_cofactor&453$tr_row'&455$tr_col'&456$det_tr&457$expand_det_row&458$cofactor_tr&459$cofactorZ&460$eqP&461$Di&462$eq_refl&463$trmx_adj&464$mul_mx_adj&465$mul_adj_mx&466$kA:&467$A'&468$*m&469$=&470$1%:M&471$by&472$kA&473$AB1&474$def_m&475$mul_col_row&476$scalar_mx_block&477$BlAu1&478$AuBr0&479$oner_neq0&480$expand_det_col&481$1simp&482$block_mxEdl&483$block_mxEul&484$col'_col_mx&485$row'Ku&486$row'_row_mx&487$IHn1&488$trmx0&489$det_ublock&490$unitmxE&491$unitr1&492$unitrX&493$unitrN&494$unitrM&495$invr1&496$adj1&497$if_same&498$Ua&499$U_A&500$adjZ&501$scalerA&502$invrM&503$unitrX_pos&504$mulrK&505$exprSr&506$prednK&507$divrK&508$scalemx1&509$invmxZ&510$invmx1&511$invr_out&512$nsA&513$mulVr&514$mulVmx&515$mulmxV&516$uA&517$negbT&518$divrr&520$det_inv&521$unitrV&522$unitmx_tr&523$unitmx_inv&525$unitmx_mul&526$unitmx1&527$invrK&530$defA&531$perm_mxV&532$unitr0&536$mulf_eq0&538$nz_a&539$subr_eq0&541$orbF&542$scalemx_eq0&543$linearB&544$eq_aAB&545$mul_mx_scalar&547$vA0&548$detA0&549$thinmx0&550$signr_eq0&551$unlift_none&552$wjA'0&553$reindex_onto&556$@mul_mx_row&557$/aj&558$aj0&559$wjA'&560$wj0_0&562$subr0&563$negPf&564$w0A'&565$linear0&566$fmorph_unit&569$unitfE&570$map_mxZ&572$map_mx_adj&573$fmorphV&574$is_perm_mxMr&577$mulmxE&579$xrowE&580$/A1&581$/(1 + n.+1)%N&582$mulmx_block&583$subrK&584$lshift0&585$tpermL&586$mulVf&587$_&588$elimNf&589$@det_lblock&590$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$andb_false_r&120$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$andb_false_r&120$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$mulnDl&108$mulnC&109$addn2&110$exp0n&111$big1_seq&112$in_nil&113$big_mkcond&114$muln1&115$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$mulnDl&108$mulnC&109$addn2&110$exp0n&111$big1_seq&112$in_nil&113$big_mkcond&114$muln1&115$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$mulnDl&108$mulnC&109$addn2&110$exp0n&111$big1_seq&112$in_nil&113$big_mkcond&114$muln1&115$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$mulnDl&108$mulnC&109$addn2&110$exp0n&111$big1_seq&112$in_nil&113$big_mkcond&114$muln1&115$mulC&116$mulm1&117$iteropS&118$mulmA&119$mulmC&120$mulmCA&121$mem_iota&124$leq_subLR&125$subSn&126$subnDA&127$subnKC&128$enumT&129$mem_enum&130$unlock&131$f_op&136$big_filter&139$filter_predI&140$mkseq_nth&143$big_map&144$eqn0Ngt&145$big_hasC&146$has_pred0&147$foldr_cat&149$big_cat_nested&150$big_seq_cond&152$big_andbC&153$big_seq&154$eq_bigr&155$mem_index_iota&156$big_nat_cond&157$big_nil&160$big_cons&161$iota_addl&163$big_addn&164$big_ltn&165$big_add1&166$val_ord_enum&167$sorted_filter&169$iota_ltn_sorted&170$mem_filter&171$andbCA&172$andb_idr&173$big_mkord&174$len12&175$big_ord_widen_cond&176$inord_val&177$big_pred0&178$]&179$big_ord0&180$big_nth&181$tnth_nth&182$big_ord_widen_leq&183$inordK&186$eqFG&187$big_const_seq&188$cardE&189$size_iota&190$big_const&191$card_ord&192$big_cat_nested,&193$op_idx'&194$big1&197$mul1m,&198$filter_index_enum&199$enum1&200$big_seq1&201$big_cat&203$iota_add&204$leq_sub&205$big_geq&206$@big_cat_nat&207$leqnSn&208$leqW&210$val_enum_ord&212$map_cat&213$map_comp&214$eqxx&215$count_cat&217$uniq_perm_eq&220$enum_uniq&221$big_tnth&222$index_uniq&223$valK&224$filter_undup&225$IHr&226$big_rem&227$idM&228$big_undup&229$undup_uniq&230$mem_undup&231$eq_r&232$big_split&233$simpm&234$bigID&235$orbK&236$cardD1&238$Aj&239$Qp&241$Q0&242$cardD1x&243$bigD1&244$Qj,&245$j&246$P0&247$h'K&248$reindex_onto&249$hK&250$reindex_inj&253$addSn&254$subnDr&255$addnBA&256$partition_big&257$Pi&258$andbT&259$andb_idl&261$exchange_big_dep&262$Qi&263$2(big_seq_cond _ _ _ xQ)&264$exchange_big_dep_nat&265$big_endo&266$mulm0&268$x&269$y&270$big_distrl&272$big_distrr&273$f&275$ffunE&276$nri&277$eqP&278$big_distr_big_dep&279$mul0m&281$bigA_distr_big&283$big_has_cond&284$big_all_cond&285$allB&286$sum_nat_const&288$Monoid&289$big_const_nat&290$big_andE&291$@leqif_sum&294$muln_gt0&295$leq_maxl&297$geq_max&302$dvdn_lcm&305$in&306$dvFm&307$p_m&308$dvdn_trans&309$dvdn_lcml&310$dvdn_gcd&311$dvmF&312$m_p&313$dvdn_gcdl&314$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$mulnDl&108$mulnC&109$addn2&110$exp0n&111$big1_seq&112$in_nil&113$big_mkcond&114$muln1&115$enumT&102$unlock&103$nth_mkseq&107$size_map&108$size_enum_ord&109$nth_map&110$ltn_ord&111$nth_ord_enum&112$map_comp&113$size0nil&114$seqmxE&116$H&117$ltn0&118$size_mkseq&119$size_seqmx&121$Hm&122$in&123$Hi&124$Hn&126$size_row_seqmx&127$fun_of_seqmxE&128$HMN&129$ord_enum_eqE&130$mxE&131$Hf&132$size_zipwith&133$minnn&134$nth_zipwith&135$M&136$N&137$zipwithseqmxE&138$map_seqmxE&139$size_nseq&140$size_seqmx=>&141$leq_min&142$by&143$nth_nseq&144$enumT&102$unlock&103$nth_mkseq&107$size_map&108$size_enum_ord&109$nth_map&110$ltn_ord&111$nth_ord_enum&112$map_comp&113$size0nil&114$seqmxE&116$H&117$ltn0&118$size_mkseq&119$size_seqmx&121$Hm&122$in&123$Hi&124$Hn&126$size_row_seqmx&127$fun_of_seqmxE&128$HMN&129$ord_enum_eqE&130$mxE&131$Hf&132$size_zipwith&133$minnn&134$nth_zipwith&135$M&136$N&137$zipwithseqmxE&138$map_seqmxE&139$size_nseq&140$size_seqmx=>&141$leq_min&142$nth_nseq&143$size_trseqmx&144$size_row_trseqmx&145$Hk&146$const_seqmxE&147$zeroE&148$hn0&149$flatmx0&150$thinmx0&151$mul0mx&152$seqmx0E&153$trseqmxE&154$min0n&155$big_mkord&156$big_ord0&157$GRing&158$minn0&159$mulE&160$addE&161$minSS&162$big_nat_recl&163$GRing.addrC&164$GRing.add0r&165$addnS&167$nth_take&168$nth_drop&170$ltn_add2l&171$lsubseqmxE&172$usubseqmxE&173$rsubseqmxE&174$dsubseqmxE&175$size_row_row_seqmx&176$ltn_add2r&177$leqNgt&178$size_row_col_seqmx&179$ord1&180$row_seqmxE&181$col_seqmxE&182$H2&183$H1&184$H2=>&185$H3&186$H4&187$castmx_id&188$size_iota&189$mkseqmxE&191$oneE&192$scalar_seqmxE&193$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$mulnDl&108$mulnC&109$addn2&110$exp0n&111$big1_seq&112$in_nil&113$big_mkcond&114$muln1&115$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$mulnDl&108$mulnC&109$addn2&110$exp0n&111$big1_seq&112$in_nil&113$big_mkcond&114$muln1&115$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$mulnDl&108$mulnC&109$addn2&110$exp0n&111$big1_seq&112$in_nil&113$big_mkcond&114$muln1&115$mul1n&116$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.Theory.sumrB&115$big_ltn&116$@big_add1&117$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$enumT&102$unlock&103$nth_mkseq&107$size_map&108$size_enum_ord&109$nth_map&110$ltn_ord&111$nth_ord_enum&112$map_comp&113$size0nil&114$seqmxE&116$H&117$ltn0&118$size_mkseq&119$size_seqmx&121$Hm&122$in&123$Hi&124$Hn&126$size_row_seqmx&127$fun_of_seqmxE&128$HMN&129$ord_enum_eqE&130$mxE&131$Hf&132$size_zipwith&133$minnn&134$nth_zipwith&135$M&136$N&137$zipwithseqmxE&138$map_seqmxE&139$size_nseq&140$size_seqmx=>&141$leq_min&142$nth_nseq&143$size_trseqmx&144$size_row_trseqmx&145$Hk&146$const_seqmxE&147$zeroE&148$hn0&149$flatmx0&150$thinmx0&151$mul0mx&152$seqmx0E&153$trseqmxE&154$min0n&155$big_mkord&156$big_ord0&157$GRing&158$minn0&159$mulE&160$addE&161$minSS&162$big_nat_recl&163$GRing.addrC&164$GRing.add0r&165$addnS&167$nth_take&168$nth_drop&170$ltn_add2l&171$lsubseqmxE&172$usubseqmxE&173$rsubseqmxE&174$dsubseqmxE&175$size_row_row_seqmx&176$ltn_add2r&177$leqNgt&178$size_row_col_seqmx&179$ord1&180$row_seqmxE&181$col_seqmxE&182$H2&183$H1&184$H2=>&185$H3&186$H4&187$castmx_id&188$size_iota&189$mkseqmxE&191$oneE&192$scalar_seqmxE&193$h'&102$mulVmx&103$mulmx1&104$mulmxV&105$mulmxA&106$invmx_left&107$mul1mx&108$mxE&109$rshift1&110$H&111$lshift0&112$ord1&113$thinmx0&114$M&115$hM&116$h'&102$mulVmx&103$mulmx1&104$mulmxV&105$mulmxA&106$invmx_left&107$mul1mx&108$mxE&109$rshift1&110$H&111$lshift0&112$ord1&113$thinmx0&114$M&115$hM&116$submxK&117$@mulmx_block&118$mulmx0&119$add0r&120$ih&121$urlower1&122$mul0mx&123$addr0&124$mulmxN&125$mulNmx&126$subrr&127$ullower1&128$scalar_mx_block&129$fast_invmxE&130$seqmx1E&131$h'&102$mulVmx&103$mulmx1&104$mulmxV&105$mulmxA&106$invmx_left&107$mul1mx&108$mxE&109$rshift1&110$H&111$lshift0&112$ord1&113$thinmx0&114$M&115$hM&116$submxK&117$@mulmx_block&118$mulmx0&119$add0r&120$ih&121$urlower1&122$mul0mx&123$addr0&124$mulmxN&125$mulNmx&126$subrr&127$ullower1&128$scalar_mx_block&129$fast_invmxE&130$seqmx1E&131$h'&102$mulVmx&103$mulmx1&104$mulmxV&105$mulmxA&106$invmx_left&107$mul1mx&108$mxE&109$rshift1&110$H&111$lshift0&112$ord1&113$thinmx0&114$M&115$hM&116$submxK&117$@mulmx_block&118$mulmx0&119$add0r&120$ih&121$urlower1&122$mul0mx&123$addr0&124$mulmxN&125$mulNmx&126$subrr&127$ullower1&128$scalar_mx_block&129$fast_invmxE&130$seqmx1E&131$mxE&102$ord1&103$hjj&104$tpermR&105$hxx&106$hjjj&107$tpermL&108$tpermD&109$hx&110$leq0n&111$hy&112$xcolE&113$xcol_tool&114$vsubmxK&115$lshift0&116$eqP&117$hM00&118$unitmx1&119$mulmx1&120$block_mxEv&121$rshift1&122$unitmxE&123$det_ublock&124$det1&125$mul1r&126$unitr1&127$submxK&128$mulmx_block&129$mulmx0&130$addr0&131$mul_scalar_mx&132$scalerA&133$mulrN&134$mulfV&135$scaleN1r&136$addrC&137$subrr&138$scalemxAr&139$scaleNr&140$unitmx_mul&141$unitmx_perm&142$mul1r -&143$h1&144$hsubmxK&145$mulmxA&146$@mul_row_block&147$mulmx0 -&148$add0r&149$h3&150$block_mxEh&151$tperm01_tool&152$_(1 + n)]row_mx0&153$dl&154$h&155$row_mx0&156$addsmxC&158$trmx0&160$trmxK&161$trmx_eq0&162$tr_block_mx&163$tr_col_mx&164$mulr1n&167$mxrank_tr&168$mxrank_disjoint_sum&169$rank_rV&170$rank0M&171$trmx_neq0&172$hC&173$tr_scalar_mx&174$sub_capmx&175$hB&176$big1&177$mulr0&178$hb&179$@mul0r&180$scale0r&181$rankaMc&182$M&183$mxrankMfree&184$subnDr&185$subSn&186$rank_leq_row&187$mulmxV&188$mul0mx&189$by&190$hY&191$mul_mx_scalar&192$@mul_row_col&193$@mul_col_mx&194$col_mx0&195$mul1mx&196$@mulmx_block&197$scalar_mx_block&198$m&199$n&200$castmx_mul&201$castmxE&202$thinmx0&203$X&204$hX&205$@mul_mx_row&206$mulmxN&207$addr_eq0&208$scalerN&209$opprK&210$mulVf&211$scale1r&212$hM&213$hR&214$hZ&215$ker0MS&217$dsubseqmxE&218$seqmx0E&219$@seqmxE&220$rsubseqmxE&221$dlsubseqmxE&222$row_seqmxE&223$ursubseqmxE&224$mulseqmxE&225$drsubseqmxE&226$cinvE&227$scaleseqmxE&228$subseqmxE&229$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$HH1&163$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$fact0&102$muln1&103$factS&104$fact0&102$muln1&103$factS&104$IH&105$fact_auxP&106$mul1n&107$expn0&108$expnS&109$fact0&102$muln1&103$factS&104$IH&105$fact_auxP&106$mul1n&107$expn0&108$expnS&109$exponential_auxP&110$fact0&102$muln1&103$factS&104$IH&105$fact_auxP&106$mul1n&107$expn0&108$expnS&109$exponential_auxP&110$expn0&102$expnS&103$H&104$fact0&102$muln1&103$factS&104$IH&105$fact_auxP&106$mul1n&107$expn0&108$expnS&109$exponential_auxP&110$muln0&111$mulnS&112$multiplication_auxP&113$fact0&102$muln1&103$factS&104$IH&105$fact_auxP&106$mul1n&107$expn0&108$expnS&109$exponential_auxP&110$muln0&111$mulnS&112$multiplication_auxP&113$H&114$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$fact0&102$muln1&103$factS&104$IH&105$fact_auxP&106$mul1n&107$expn0&108$expnS&109$exponential_auxP&110$muln0&111$mulnS&112$multiplication_auxP&113$H&114$fact0&102$muln1&103$factS&104$IH&105$fact_auxP&106$mul1n&107$expn0&108$expnS&109$exponential_auxP&110$muln0&111$mulnS&112$multiplication_auxP&113$H&114$fact0&102$muln1&103$factS&104$IH&105$fact_auxP&106$mul1n&107$expn0&108$expnS&109$exponential_auxP&110$muln0&111$mulnS&112$multiplication_auxP&113$prednK&114$addnS&115$pred_Sn&116$fact0&102$muln1&103$factS&104$IH&105$fact_auxP&106$mul1n&107$expn0&108$expnS&109$exponential_auxP&110$muln0&111$mulnS&112$multiplication_auxP&113$prednK&114$addnS&115$pred_Sn&116$H&117$addnsubn1&118$addSn&119$mulnDr&120$addn2&121$IH0&122$H1&123$expn_gt0&124$fact0&102$muln1&103$factS&104$IH&105$fact_auxP&106$mul1n&107$expn0&108$expnS&109$exponential_auxP&110$muln0&111$mulnS&112$multiplication_auxP&113$prednK&114$addnS&115$pred_Sn&116$H&117$addnsubn1&118$addSn&119$mulnDr&120$addn2&121$IH0&122$H1&123$expn_gt0&124$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$addSn&100.1$plus_Sn_m&100.14999999999999$plus_n_Sm&100.175$app_nil_l2&100.1875$mult_n_O&100.19375$O_minus&100.19687499999999$mult_O_n&100.1984375$plus_n_O&100.19921875$aux12&100.199609375$aux7&100.19980468749999$aux10&100.19990234375$mulSn&100.199951171875$addnCA&100.1999755859375$aux11&100.19998779296874$mulnS&100.19999389648437$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$IHl&102$H&103$addSn&104$IHm&105$plus_Sn_m&106$plus_n_Sm&107$app_nil_l2&108$mult_n_O&109$O_minus&110$mult_O_n&111$IHa&112$plus_n_O&113$aux12&114$aux7&115$aux10&116$mulSn&117$aux11&118$mulnS&119$IHl&102$H&103$addSn&104$IHm&105$plus_Sn_m&106$plus_n_Sm&107$app_nil_l2&108$mult_n_O&109$O_minus&110$mult_O_n&111$IHa&112$plus_n_O&113$aux12&114$aux7&115$aux10&116$mulSn&117$aux11&118$mulnS&119$andb_false_r&120$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$fact0&102$muln1&103$factS&104$IH&105$fact_auxP&106$mul1n&107$expn0&108$expnS&109$exponential_auxP&110$muln0&111$mulnS&112$multiplication_auxP&113$prednK&114$addnS&115$pred_Sn&116$fact0&102$muln1&103$factS&104$IH&105$fact_auxP&106$mul1n&107$expn0&108$expnS&109$exponential_auxP&110$muln0&111$mulnS&112$multiplication_auxP&113$prednK&114$addnS&115$pred_Sn&116$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$IHl&102$muln1&103$plus_Sn_m&104$plus_n_Sm&105$app_nil_l2&106$mult_n_O&107$O_minus&108$mult_O_n&109$mul1n&110$aux12&111$aux7&112$aux10&113$plus_n_O&114$mulSn&115$addSn&116$IHm&117$aux11&118$mulnS&119$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$fact0&102$muln1&103$factS&104$IH&105$fact_auxP&106$mul1n&107$expn0&108$expnS&109$exponential_auxP&110$muln0&111$mulnS&112$multiplication_auxP&113$prednK&114$addnS&115$pred_Sn&116$expn0&102$muln1&103$expnS&104$IH&105$exponential_auxP&106$mul1n&107$muln0&108$mulnS&109$multiplication_auxP&110$fact0&111$factS&112$fact_auxP&113$prednK&114$addnS&115$pred_Sn&116$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$IH&102$mulSn&103$helper_mul_is_theta&104$IH&102$mulSn&103$helper_mul_is_theta&104$IH&102$IH&102$IH&102$pred_Sn&103$IH&102$mulSn&103$helper_mul_is_theta&104$pred_Sn&105$run_app&106$loop_is_helper_mul&107$program_is_fn_mul&108$fn_mul_is_theta&109$H&110$program_correct_mul&111$IH&102$mulSn&103$helper_mul_is_theta&104$pred_Sn&105$run_app&106$loop_is_helper_mul&107$program_is_fn_mul&108$fn_mul_is_theta&109$H&110$program_correct_mul&111$expn0&102$muln1&103$IH&104$expnS&105$mulnA&106$mulnC&107$helper_expt_is_theta&108$mul1n&109$pred_Sn&110$run_app&111$loop_is_helper_expt&112$program_is_fn_expt&113$fn_expt_is_theta&114$H&115$program_correct_expt&116$fact0&102$muln1&103$IH&104$factS&105$mulnA&106$mulnC&107$helper_fact_is_theta&108$mul1n&109$pred_Sn&110$run_app&111$loop_is_helper_fact&112$program_is_fn_fact&113$fn_fact_is_theta&114$H&115$program_correct_fact&116$helper_less_is_theta&102$IH&103$pred_Sn&104$loop_is_helper_less&105$program_is_fn_less&106$fn_less_is_theta&107$H&108$program_correct_less&109$expn0&102$muln1&103$IH&104$expnS&105$mulnA&106$mulnC&107$mulnS&108$helper_power_is_theta&109$mul1n&110$pred_Sn&111$run_app&112$loop_is_helper_power&113$program_is_fn_power&114$fn_power_is_theta&115$H&116$program_correct_power&117$expn0&102$muln1&103$expnS&104$IH&105$exponential_auxP&106$mul1n&107$muln0&108$mulnS&109$multiplication_auxP&110$fact0&111$factS&112$expn0&102$muln1&103$expnS&104$IH&105$exponential_auxP&106$mul1n&107$muln0&108$mulnS&109$multiplication_auxP&110$fact0&111$expn0&102$muln1&103$expnS&104$IH&105$mulnA&106$mulnC&107$exponential_auxP&108$mul1n&109$muln0&110$mulnS&111$multiplication_auxP&112$fact0&113$expn0&102$muln1&103$expnS&104$IH&105$mulnA&106$mulnC&107$exponential_auxP&108$mul1n&109$muln0&110$mulnS&111$multiplication_auxP&112$fact0&113$expn0&102$muln1&103$expnS&104$IH&105$mulnA&106$mulnC&107$exponential_auxP&108$mul1n&109$muln0&110$mulnS&111$multiplication_auxP&112$fact0&113$expn0&102$muln1&103$expnS&104$IH&105$mulnA&106$mulnC&107$exponential_auxP&108$mul1n&109$muln0&110$mulnS&111$multiplication_auxP&112$factS&113$fact0&114$mul0n&102$mul1n&103$IH&104$pred_Sn&105$mulnDr&106$mulnDl&107$ -&108$helper_fib_is_theta&109$muln0&110$muln1&111$H&112$in&113$/fib_locals&114$/helper_fib&115$prednK&116$H1&117$run_app&118$loop_is_helper_fib&119$program_is_fn_fib&120$fn_fib_is_theta&121$program_correct_fib&122$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$addnS&104$eqn_add2l&105$Heq&107$eqxx&108$subnDl&110$subnDA&114$subnS&115$leqNgt&119$leq_eqVlt&120$negb_or&121$implyNb&125$eq_axiomK&126$def_n2&127$le_mn&129$@leq_trans&133$lt0n&135$addn_eq0&136$subn_eq0&137$leq_subLR&138$addnK&140$subnDr&141$addSn&143$maxnC&144$maxnAC&145$orb_idr&147$leq_max&148$leq_maxl&149$gtn_max&150$addnAC&151$addn_maxl&152$addn_min_max&153$minnC&154$minnE&155$subnAC&156$minnAC&157$minnA&158$minnCA&159$sameP&160$eqn_add2r&161$le_n21&163$leq_min&164$gtn_min&165$geq_min&166$geq_minl&167$addnBA&168$leq_subr&169$addn_minr&170$minn_idPr&171$geq_max&172$leq_maxr&173$le_m21&174$maxn_minl&175$maxn_minr&176$maxnK&177$minn_maxl&178$Pm&180$m_lb&181$subKn&182$ubP&183$subnBA&184$m1_lb&185$m2_lb,&186$eqPQ&187$max_i&188$max_j&189$eq_f&190$mulSn&192$mulnS&193$mulnSr&194$muln0&195$muln0,&196$mulnC&197$mulnDl&198$mulnBl&199$mulnA&200$mulnCA&201$mulnBr&202$muln_eq0&203$leq_mul2l&204$le_mn2&206$orbT&207$leq_mul2r&208$le_mn1&209$orb_andr&210$eqn_mul2l&211$eqn_mul2r&212$ltn_mul2l&213$ltn_mul2r&214$mul1n&215$ltn_pmul2r&216$ltn_Pmull&217$maxn_mulr&219$minn_mulr&220$muln1&221$expnS&222$mul1n,&223$exp1n&224$expnD&225$expnMn&226$expnM&227$addn_gt0&228$eqn0Ngt&229$expn_gt0&230$leq_pmul2l&231$leq_pmulr&232$leq_exp2l&233$eqn_exp2l&234$leq_exp2l]&235$ltn_exp2l]&236$leq_mul&238$expn1&239$ltn_mul&240$IHe&241$ltn_exp2r&242$leq_exp2r&243$eqn_exp2r&244$muln_gt0&245$addTb&246$addbA&247$odd_add&250$odd_sub&251$andb_addl&252$odd_mul&253$addnn&254$mul2n&255$doubleB&256$2ltnNge&257$leq_double&258$doubleS&259$ltn_Sdouble&260$addbb&261$muln2&262$uphalf_half&263$doubleD&264$half_double,&265$odd_double_half&266$half_double&267$uphalf_double&268$halfD&269$mulnn&270$mulnDr&271$def_m&272$sqrnD&273$2addnA&274$/(2 * 2)&275$sqrn_sub&276$lte&279$ltm12&280$ltm23&281$andbT&282$eqm12&283$f_mono&284$in&285$hyp&286$*&287$lemn&288$le_ab&289$geq_leqif&290$n12_0&291$le2&292$m2_0&293$n1_gt0&294$n2_gt0&295$sqrn_gt0&297$ne_mn&298$ltn_add2r&299$nat_Cauchy&300$addE&301$add_mulE&302$mulE&303$mul_expE&304$sub2nn&305$natTrecE&306$addnS&104$eqn_add2l&105$Heq&107$eqxx&108$subnDl&110$subnDA&114$subnS&115$leqNgt&119$leq_eqVlt&120$negb_or&121$implyNb&125$eq_axiomK&126$def_n2&127$le_mn&129$@leq_trans&133$lt0n&135$addn_eq0&136$subn_eq0&137$leq_subLR&138$addnK&140$subnDr&141$addSn&143$maxnC&144$maxnAC&145$orb_idr&147$leq_max&148$leq_maxl&149$gtn_max&150$addnAC&151$addn_maxl&152$addn_min_max&153$minnC&154$minnE&155$subnAC&156$minnAC&157$minnA&158$minnCA&159$sameP&160$eqn_add2r&161$le_n21&163$leq_min&164$gtn_min&165$geq_min&166$geq_minl&167$addnBA&168$leq_subr&169$addn_minr&170$minn_idPr&171$geq_max&172$leq_maxr&173$le_m21&174$maxn_minl&175$maxn_minr&176$maxnK&177$minn_maxl&178$Pm&180$m_lb&181$subKn&182$ubP&183$subnBA&184$m1_lb&185$m2_lb,&186$eqPQ&187$max_i&188$max_j&189$eq_f&190$mulSn&192$mulnS&193$mulnSr&194$muln0&195$muln0,&196$mulnC&197$mulnDl&198$mulnBl&199$mulnA&200$mulnCA&201$mulnBr&202$muln_eq0&203$leq_mul2l&204$le_mn2&206$orbT&207$leq_mul2r&208$le_mn1&209$orb_andr&210$eqn_mul2l&211$eqn_mul2r&212$ltn_mul2l&213$ltn_mul2r&214$mul1n&215$ltn_pmul2r&216$ltn_Pmull&217$maxn_mulr&219$minn_mulr&220$muln1&221$expnS&222$mul1n,&223$exp1n&224$expnD&225$expnMn&226$expnM&227$addn_gt0&228$eqn0Ngt&229$expn_gt0&230$leq_pmul2l&231$leq_pmulr&232$leq_exp2l&233$eqn_exp2l&234$leq_exp2l]&235$ltn_exp2l]&236$leq_mul&238$expn1&239$ltn_mul&240$IHe&241$ltn_exp2r&242$leq_exp2r&243$eqn_exp2r&244$muln_gt0&245$addTb&246$addbA&247$odd_add&250$odd_sub&251$andb_addl&252$odd_mul&253$addnn&254$mul2n&255$doubleB&256$2ltnNge&257$leq_double&258$doubleS&259$ltn_Sdouble&260$addbb&261$muln2&262$uphalf_half&263$doubleD&264$half_double,&265$odd_double_half&266$half_double&267$uphalf_double&268$halfD&269$mulnn&270$mulnDr&271$def_m&272$sqrnD&273$2addnA&274$/(2 * 2)&275$sqrn_sub&276$lte&279$ltm12&280$ltm23&281$andbT&282$eqm12&283$f_mono&284$in&285$hyp&286$*&287$lemn&288$le_ab&289$geq_leqif&290$addnS&104$eqn_add2l&105$Heq&107$eqxx&108$subnDl&110$subnDA&114$subnS&115$leqNgt&119$leq_eqVlt&120$negb_or&121$implyNb&125$eq_axiomK&126$def_n2&127$le_mn&129$@leq_trans&133$lt0n&135$addn_eq0&136$subn_eq0&137$leq_subLR&138$addnK&140$subnDr&141$addSn&143$maxnC&144$maxnAC&145$orb_idr&147$leq_max&148$leq_maxl&149$gtn_max&150$addnAC&151$addn_maxl&152$addn_min_max&153$minnC&154$minnE&155$subnAC&156$minnAC&157$minnA&158$minnCA&159$sameP&160$eqn_add2r&161$le_n21&163$leq_min&164$gtn_min&165$geq_min&166$geq_minl&167$addnBA&168$leq_subr&169$addn_minr&170$minn_idPr&171$geq_max&172$leq_maxr&173$le_m21&174$maxn_minl&175$maxn_minr&176$maxnK&177$minn_maxl&178$Pm&180$m_lb&181$subKn&182$ubP&183$subnBA&184$m1_lb&185$m2_lb,&186$eqPQ&187$max_i&188$max_j&189$eq_f&190$mulSn&192$mulnS&193$mulnSr&194$muln0&195$muln0,&196$mulnC&197$mulnDl&198$mulnBl&199$mulnA&200$mulnCA&201$mulnBr&202$muln_eq0&203$leq_mul2l&204$le_mn2&206$orbT&207$leq_mul2r&208$le_mn1&209$orb_andr&210$eqn_mul2l&211$eqn_mul2r&212$ltn_mul2l&213$ltn_mul2r&214$mul1n&215$ltn_pmul2r&216$ltn_Pmull&217$maxn_mulr&219$minn_mulr&220$muln1&221$expnS&222$mul1n,&223$exp1n&224$expnD&225$expnMn&226$expnM&227$addn_gt0&228$eqn0Ngt&229$expn_gt0&230$leq_pmul2l&231$leq_pmulr&232$leq_exp2l&233$eqn_exp2l&234$leq_exp2l]&235$ltn_exp2l]&236$leq_mul&238$expn1&239$ltn_mul&240$IHe&241$ltn_exp2r&242$leq_exp2r&243$eqn_exp2r&244$muln_gt0&245$addTb&246$addbA&247$odd_add&250$odd_sub&251$andb_addl&252$odd_mul&253$addnn&254$mul2n&255$doubleB&256$2ltnNge&257$leq_double&258$doubleS&259$ltn_Sdouble&260$addbb&261$muln2&262$uphalf_half&263$doubleD&264$half_double,&265$odd_double_half&266$half_double&267$uphalf_double&268$halfD&269$mulnn&270$mulnDr&271$def_m&272$sqrnD&273$2addnA&274$/(2 * 2)&275$sqrn_sub&276$lte&279$ltm12&280$ltm23&281$andbT&282$eqm12&283$f_mono&284$in&285$hyp&286$*&287$lemn&288$le_ab&289$geq_leqif&290$n12_0&293$le2&294$m2_0&295$n1_gt0&296$n2_gt0&297$sqrn_gt0&298$ne_mn&299$ltn_add2r&300$nat_Cauchy&301$addE&302$add_mulE&303$mulE&304$mul_expE&305$sub2nn&306$natTrecE&307$by&310$IHp&311$nat_of_succ_gt0&312$doubleS,&313$doubleMl&315$addnS&104$eqn_add2l&105$Heq&107$eqxx&108$subnDl&110$subnDA&114$subnS&115$leqNgt&119$leq_eqVlt&120$negb_or&121$implyNb&125$eq_axiomK&126$def_n2&127$le_mn&129$@leq_trans&133$lt0n&135$addn_eq0&136$subn_eq0&137$leq_subLR&138$addnK&140$subnDr&141$addSn&143$maxnC&144$maxnAC&145$orb_idr&147$leq_max&148$leq_maxl&149$gtn_max&150$addnAC&151$addn_maxl&152$addn_min_max&153$minnC&154$minnE&155$subnAC&156$minnAC&157$minnA&158$minnCA&159$sameP&160$eqn_add2r&161$le_n21&163$leq_min&164$gtn_min&165$geq_min&166$geq_minl&167$addnBA&168$leq_subr&169$addn_minr&170$minn_idPr&171$geq_max&172$leq_maxr&173$le_m21&174$maxn_minl&175$maxn_minr&176$maxnK&177$minn_maxl&178$Pm&180$m_lb&181$subKn&182$ubP&183$subnBA&184$m1_lb&185$m2_lb,&186$eqPQ&187$max_i&188$max_j&189$eq_f&190$mulSn&192$mulnS&193$mulnSr&194$muln0&195$muln0,&196$mulnC&197$mulnDl&198$mulnBl&199$mulnA&200$mulnCA&201$mulnBr&202$muln_eq0&203$leq_mul2l&204$le_mn2&206$orbT&207$leq_mul2r&208$le_mn1&209$orb_andr&210$eqn_mul2l&211$eqn_mul2r&212$ltn_mul2l&213$ltn_mul2r&214$mul1n&215$ltn_pmul2r&216$ltn_Pmull&217$maxn_mulr&219$minn_mulr&220$muln1&221$expnS&222$mul1n,&223$exp1n&224$expnD&225$expnMn&226$expnM&227$addn_gt0&228$eqn0Ngt&229$expn_gt0&230$leq_pmul2l&231$leq_pmulr&232$leq_exp2l&233$eqn_exp2l&234$leq_exp2l]&235$ltn_exp2l]&236$leq_mul&238$expn1&239$ltn_mul&240$IHe&241$ltn_exp2r&242$leq_exp2r&243$eqn_exp2r&244$muln_gt0&245$addTb&246$addbA&247$odd_add&250$odd_sub&251$andb_addl&252$odd_mul&253$addnn&254$mul2n&255$doubleB&256$2ltnNge&257$leq_double&258$doubleS&259$ltn_Sdouble&260$addbb&261$muln2&262$uphalf_half&263$doubleD&264$half_double,&265$odd_double_half&266$half_double&267$uphalf_double&268$halfD&269$mulnn&270$mulnDr&271$def_m&272$sqrnD&273$2addnA&274$/(2 * 2)&275$sqrn_sub&276$lte&279$ltm12&280$ltm23&281$andbT&282$eqm12&283$f_mono&284$in&285$hyp&286$*&287$lemn&288$le_ab&289$geq_leqif&290$n12_0&293$le2&294$m2_0&295$n1_gt0&296$n2_gt0&297$sqrn_gt0&298$ne_mn&299$ltn_add2r&300$nat_Cauchy&301$addE&302$add_mulE&303$mulE&304$mul_expE&305$sub2nn&306$natTrecE&307$by&310$IHp&311$nat_of_succ_gt0&312$doubleS,&313$doubleMl&315$s0'x&128$orbT&129$ay&131$eq_a&135$y&136$s_y&137$eq_a12&138$s'y&139$eq_in_count&140$has_filter&141$Es12&142$in&143$Hx&144$*&145$eqxx&147$all_pred1_nseq&148$def_s&150$has_pred0&151$has_sym&152$negb_or&153$cat_uniq&154$andbCA&155$uniq_catC&156$mem_filter&157$negbTE&158$mem_rev&159$Hy&160$all_pred1P&161$count_uniq_mem&162$s_x&163$mem_undup&164$size_undup&165$find_size&167$has_pred1&168$find_cat&169$lt_i_s&170$mem_nth&171$rcons_uniq&172$index_cat&173$size_belast&174$index_uniq&175$eq_sij&176$cat_cons&179$i.+1&181$nax&182$exists&183$i]&184$eq_all&185$a_s&186$IHv&187$count_cat&189$addn_eq0&190$count_predC&191$filter_predI&192$cnt_a'&193$leq_add2r&195$eq12&196$perm_eq_sym&198$eqn_add2l&199$perm_catC&201$perm_cat2r&203$cat1s&205$perm_catCA&206$perm_cons&207$def_s2&208$mem_rot&209$negPf&210$rot_uniq&211$le_s21&212$leqNgt&214$s3x&215$uniq_leq_size&216$eqs12&217$eqs12,&219$uniq_size_uniq&220$@uniq_leq_size&222$s2x&223$Hs12&224$/(rot i s1)&229$def_s1&230$FcatCA&232$addnK&233$rot1_cons&234$rotK&235$has_rot&236$subKn&237$rot0&238$size_rev&240$size_rotr&243$@size_takel&244$5(catA, =^~ rot_size_cat)&245$leq_addl&246$rot_addn&248$addnBA&249$@rot_oversize&250$1ltnW&251$rot_add_mod&252$1addnC&253$rot_rot&254$has_mask_cons&255$size_mask&256$mask_cat&257$Hs&258$mask_rot&261$size_nseq&262$mask_false&263$sz_m&265$geq_min&266$nth_take&267$negb_add&268$addbF&269$addbT&270$negb_eqb&271$before_find&272$def_m_i&273$lt_i_m&274$subnKC&275$congr1&276$drop_nth&277$nth_index&278$index_mem&279$mask0&280$sz_m1&281$sz_m2&282$cat_subseq&283$sub0seq&284$mask_true&286$all_predC&295$map_cat&296$map_take&297$map_drop&298$map_rot&300$size_map&301$filter_mask&302$a_x&303$size_subseq_leqif&305$subseq_filter&306$introT&307$uniq_perm_eq&308$filter_uniq&309$x&310$Ds2&312$perm_rcons&313$eqP&315$x']&316$map_mask&318$inj_in_eq&319$count_map&322$Est&323$eq_sz&326$ltis&327$nth_map&328$Ef&329$eq_f12&330$eqf12&331$eqxx,&332$sy&333$gK&335$fK&336$mem_map&337$pmap_filter&338$size_pmap&340$IHn1&344$addnS&345$iota_add&346$size_iota&347$andbN&348$leq_eqVlt&349$mem_iota&351$nth_iota&353$size_mkseq&355$Hi&356$nth_mkseq&357$mkseq_nth&359$perm_map&360$perm_eq_small&361$Ds&362$iota_addl&363$map_rotr&364$map_comp&365$@eq_map&366$mulnC&367$sumn_nseq&368$foldr_cat&369$revK&370$Hfg&371$Hgf&372$addn_minr&373$size_zip&374$zip_cat&375$zip_rcons&376$IHss&377$IHsh&378$leq_subLR&379$leq_add2l&381$leq_max&382$def_z&383$def_x'&384$map_f&385$not_fxt_z&386$eq_s&387$eq_t&388$fpz&389$sp2&390$Ut&391$:&392$z.1,&393$=&394$x,&395$by&396$Dz1&397$s1z&398$s1'x&399$def_b&106$mem_topred&129$symR&131$Rxy&132$eqiR&133$fK&134$hf&139$fgK&140$mf&142$fgK_on&143$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$thinmx0&102$=>&103$H&104$det1&105$det0&106$H1&107$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$mulC&102$mulm1&103$iteropS&104$mulmA&105$mulmC&106$mulmCA&107$mem_iota&110$leq_subLR&111$subSn&112$subnDA&113$subnKC&114$enumT&115$mem_enum&116$unlock&117$f_op&122$big_filter&125$filter_predI&126$mkseq_nth&129$big_map&130$eqn0Ngt&131$big_hasC&132$has_pred0&133$foldr_cat&135$big_cat_nested&136$big_seq_cond&138$big_andbC&139$big_seq&140$eq_bigr&141$mem_index_iota&142$big_nat_cond&143$big_nil&146$big_cons&147$iota_addl&149$big_addn&150$big_ltn&151$big_add1&152$val_ord_enum&153$sorted_filter&155$iota_ltn_sorted&156$mem_filter&157$andbCA&158$andb_idr&159$big_mkord&160$len12&161$big_ord_widen_cond&162$inord_val&163$big_pred0&164$]&165$big_ord0&166$big_nth&167$tnth_nth&168$big_ord_widen_leq&169$inordK&172$eqFG&173$big_const_seq&174$cardE&175$size_iota&176$big_const&177$card_ord&178$big_cat_nested,&179$op_idx'&180$big1&183$big_mkcond&184$mul1m,&185$filter_index_enum&186$enum1&187$big_seq1&188$big_cat&190$iota_add&191$leq_sub&192$big_geq&193$@big_cat_nat&194$leqnSn&195$big_nat1&196$big_nat_recr&197$leqW&199$val_enum_ord&201$map_cat&202$map_comp&203$eqxx&204$count_cat&206$uniq_perm_eq&209$enum_uniq&210$big_tnth&211$index_uniq&212$valK&213$filter_undup&214$IHr&215$big_rem&216$idM&217$big_undup&218$undup_uniq&219$mem_undup&220$eq_r&221$big_split&222$simpm&223$bigID&224$orbK&225$cardD1&227$Aj&228$Qp&230$Q0&231$cardD1x&232$bigD1&233$Qj,&234$j&235$P0&236$IH&237$h'K&238$reindex_onto&239$hK&240$reindex_inj&243$addSn&244$subnDr&245$addnBA&246$partition_big&247$Pi&248$andbT&249$andb_idl&251$exchange_big_dep&252$Qi&253$ffunE&102$2(big_seq_cond _ _ _ xQ)&254$exchange_big_dep_nat&255$card_sub&104$card_ffun&105$card_prod&106$card_ord&107$big_endo&256$mxE&108$mulm0&258$x&259$y&260$big_distrl&262$big_distrr&263$f&265$ffunE&266$nri&267$eqP&268$big_distr_big_dep&269$mul0m&271$bigA_distr_big&273$big_has_cond&274$big_all_cond&275$allB&276$sum_nat_const&278$muln1&279$Monoid&280$big_const_nat&281$big_andE&282$@leqif_sum&285$muln_gt0&286$leq_maxl&288$geq_max&293$dvdn_lcm&296$in&297$dvFm&298$p_m&299$dvdn_trans&300$dvdn_lcml&301$dvdn_gcd&302$dvmF&303$m_p&304$dvdn_gcdl&305$ffunE&102$card_sub&104$card_ffun&105$card_prod&106$card_ord&107$mxE&108$ord1&111$perm1&112$permM&113$eq_axiomK&114$cast_ord_id&115$castmx_id&116$mxE,&119$unsplitK&122$row_mxEl&123$row_mxEr&124$col_mxEu&126$col_mxEd&127$row_mxKl,&128$col_mxKu,&129$tr_col_mx&131$trmx_usub&132$trmx_dsub&133$hsubmxK&134$castmxE&136$mxE]&137$trmx_cast&138$row_mxA&139$tr_col,&140$tr_col',&141$row_mxEl,&142$row_mxEr,&143$col_mxEu,&144$col_mxEd,&145$2mxE&146$def_j'&148$addSn&149$ltn_addr&150$@tr_row'&151$@tr_col_mx&152$col'Kl&153$addnS&154$def_j&155$leqNgt&156$leq_add2l&157$tr_row',&158$col'Kr&159$vsubmxK&160$col_mxKu&161$row_mxKl&162$row_mxKr&163$col_mxKd&164$submxK&165$trmx_ulsub&166$trmx_ursub&167$trmx_dlsub&168$trmx_drsub&169$block_mxKul&170$block_mxKur&171$block_mxKdl&172$block_mxKdr&173$tr_block_mx&174$tr_row_mx&175$2tr_col_mx&176$block_mxEh&177$col_mxA&178$cast_row_mx&179$block_mxEv&180$cast_col_mx&181$castmx_comp&182$etrans_id&183$cast_ordK&184$enum_valK&185$enum_rankK&186$mxvecE&187$castmxE,&188$conform_mx_id&189$neq_mn&190$B&191$nonconform_mx&192$addrA&193$addrC&194$add0r&195$addNr&196$mulrS&197$IHd&198$can2_eq&202$raddf0&203$opp_col_mx&207$opp_row_mx&208$add_col_mx&209$add_row_mx&210$negbTE&211$row0&214$eqxx&215$map_const_mx&216$raddfN&217$raddfD&218$map_mxD&219$map_mxN&220$mul1r&221$mulrDl&222$mulrDr&223$mulrA&224$summxE&225$bigD1&226$mulr1&227$big1&228$addr0&229$diff&230$j'&231$mulr0&232$matrix_sum_delta&233$big_ord1&234$can_eq&235$inj_eq&236$vec_mx_delta&237$vec_mxK&238$scale_col_mx&239$scale_row_mx&240$mulrnAr&241$mulrnDl&242$mulr_natr&243$i'&244$ne_i'i&245$diag_const_mx&247$raddfB&248$scale_scalar_mx&249$diag_mx_sum_delta&250$scalar_mx_sum_delta&252$scaler_sumr&253$scale1r&254$A&256$eqxx]&257$eqn0Ngt&258$n0&259$in&260$*&261$flatmx0&262$val_eqE&263$eqn_add2l&264$big_distrr&265$exchange_big&266$big_distrl&267$j&268$mul0r&269$sumrN&270$mulrN&271$mulNr&272$big_split&273$mulmxDl&274$mulNmx&275$mulmxDr&276$mulmxN&277$mul0mx&279$mulmx0&281$rowE&282$mulmxA&283$mulmxnE&284$andbT&285$natrM&286$mulrnA&287$mulnb&288$andbAC&289$mul_delta_mx_cond&290$mulrnAl&291$mul_diag_mx&292$mul_scalar_mx&293$mul_mx_diag&294$reindex_inj&295$permKV&296$mul_col_perm&297$invgK&298$tpermV&299$mul_row_perm&300$mulmx1&301$mul1mx&302$col_permE&303$trmx1&305$tr_perm_mx&306$row_permM&308$perm_mx1&310$perm_mx_is_perm&311$perm_mxM&312$def_t&313$mulVg&314$trmxK&315$is_perm_mx_tr&316$is_perm_mxMl&317$perm_mx_is_perm,&318$ltn_ord&319$lshift_subproof&320$row_mx0&321$leq_min&322$tr_pid_mx&323$pid_mx_minv&324$pid_mx_minh&325$le_n_i&326$andbCA&327$mul_pid_mx&328$minnn&329$minn_idPr&330$mulmxBl&331$pid_mx_id&332$subrr&333$mulmxBr&334$mul_pid_mx_copid&335$oppr0&336$defk&337$defi&338$big_split_ord&339$mul_col_mx&340$mul_mx_row&341$mul_row_col&342$mul_row_block&343$linear_sum&344$linearZ&345$mul_rV_lin&347$mxvecK&348$scalemxAl&349$linearP&350$row_mul&351$raddf0]&352$mulr_sumr&353$mxtrace_diag&355$mx11_scalar&357$block_mxEul,&358$oner_eq0&359$lift_permV&363$permK&364$canF_eq&365$split1&366$lift0_perm_lift&367$lift0_perm0&368$lift0_mx_perm&369$rmorphM&370$rmorph_sum&371$rmorph_nat&372$rmorphMn&373$map_scalar_mx&374$rmorph1&375$rmorph_sign&377$rmorph_prod&378$det_map_mx&379$map_row'&380$map_col'&381$cofactor_map_mx&382$map_mx_sub&383$map_mx1&384$map_pid_mx&385$map_delta_mx&389$def_gf&390$map_mxvec&392$map_vec_mx&393$trmx_mul_rev&394$mulrC&395$trmx_mul&396$scalemxAr&397$reindex&398$pair_bigA&399$mulrAC&400$mulmx_sum_row&401$scaler_suml&402$mulmx_diag&403$row_id&406$mulrCA&407$BA&408$CA&409$bigID&410$oddMt&414$mulN1r&415$tpermK&416$eqA12&417$odd_permV&418$t&419$Dst&420$det_perm&421$odd_perm1&422$det1&423$prodr_const&424$scale0r&425$detZ&426$exprS&427$bigA_distr_bigA&429$valP&431$signr_addb&432$odd_permM&433$pvalE&434$determinant_alternate&435$simp&436$Ef12&437$p_i&441$ulsfK&443$liftK&444$permE&445$si0&446$signr_odd&447$odd_add&448$odd_lift_perm&449$_]&450$neq_lift&451$partition_big&452$expand_cofactor&453$tr_row'&455$tr_col'&456$det_tr&457$expand_det_row&458$cofactor_tr&459$cofactorZ&460$eqP&461$Di&462$eq_refl&463$trmx_adj&464$mul_mx_adj&465$mul_adj_mx&466$kA:&467$A'&468$*m&469$=&470$1%:M&471$by&472$kA&473$AB1&474$def_m&475$mul_col_row&476$scalar_mx_block&477$BlAu1&478$AuBr0&479$oner_neq0&480$expand_det_col&481$1simp&482$block_mxEdl&483$block_mxEul&484$col'_col_mx&485$row'Ku&486$row'_row_mx&487$IHn1&488$trmx0&489$det_ublock&490$unitmxE&491$unitr1&492$unitrX&493$unitrN&494$unitrM&495$invr1&496$adj1&497$if_same&498$Ua&499$U_A&500$adjZ&501$scalerA&502$invrM&503$unitrX_pos&504$mulrK&505$exprSr&506$prednK&507$divrK&508$scalemx1&509$invmxZ&510$invmx1&511$invr_out&512$nsA&513$mulVr&514$mulVmx&515$mulmxV&516$uA&517$negbT&518$divrr&520$det_inv&521$unitrV&522$unitmx_tr&523$unitmx_inv&525$unitmx_mul&526$unitmx1&527$invrK&530$defA&531$perm_mxV&532$unitr0&536$mulf_eq0&538$nz_a&539$subr_eq0&541$orbF&542$scalemx_eq0&543$linearB&544$eq_aAB&545$mul_mx_scalar&547$vA0&548$detA0&549$thinmx0&550$signr_eq0&551$unlift_none&552$wjA'0&553$reindex_onto&556$@mul_mx_row&557$/aj&558$aj0&559$wjA'&560$wj0_0&562$subr0&563$negPf&564$w0A'&565$linear0&566$fmorph_unit&569$unitfE&570$map_mxZ&572$map_mx_adj&573$fmorphV&574$is_perm_mxMr&577$mulmxE&579$xrowE&580$/A1&581$/(1 + n.+1)%N&582$mulmx_block&583$subrK&584$lshift0&585$tpermL&586$mulVf&587$_&588$elimNf&589$@det_lblock&590$enumT&102$unlock&103$nth_mkseq&107$size_map&108$size_enum_ord&109$nth_map&110$ltn_ord&111$nth_ord_enum&112$map_comp&113$size0nil&114$seqmxE&116$H&117$ltn0&118$size_mkseq&119$size_seqmx&121$Hm&122$in&123$Hi&124$Hn&126$size_row_seqmx&127$fun_of_seqmxE&128$HMN&129$ord_enum_eqE&130$mxE&131$Hf&132$size_zipwith&133$minnn&134$nth_zipwith&135$M&136$N&137$zipwithseqmxE&138$map_seqmxE&139$size_nseq&140$size_seqmx=>&141$leq_min&142$nth_nseq&143$size_trseqmx&144$size_row_trseqmx&145$Hk&146$const_seqmxE&147$zeroE&148$hn0&149$flatmx0&150$thinmx0&151$mul0mx&152$seqmx0E&153$trseqmxE&154$addnS&155$nth_take&156$nth_drop&158$ltn_add2l&159$lsubseqmxE&160$usubseqmxE&161$rsubseqmxE&162$dsubseqmxE&163$size_row_row_seqmx&164$ltn_add2r&165$leqNgt&166$size_row_col_seqmx&167$ord1&168$row_seqmxE&169$col_seqmxE&170$H2&171$H1&172$H2=>&173$H3&174$H4&175$castmx_id&176$size_iota&177$mkseqmxE&179$oneE&180$scalar_seqmxE&181$expn0&102$muln1&103$IH&104$expnS&105$mulnA&106$mulnC&107$helper_expt_is_theta&108$mul1n&109$pred_Sn&110$run_app&111$loop_is_helper_expt&112$program_is_fn_expt&113$fn_expt_is_theta&114$H&115$program_correct_expt&116$fact0&102$muln1&103$IH&104$factS&105$mulnA&106$mulnC&107$helper_fact_is_theta&108$mul1n&109$pred_Sn&110$run_app&111$loop_is_helper_fact&112$program_is_fn_fact&113$fn_fact_is_theta&114$H&115$program_correct_fact&116$mul0n&102$mul1n&103$IH&104$pred_Sn&105$mulnDr&106$mulnDl&107$ -&108$helper_fib_is_theta&109$muln0&110$muln1&111$H&112$in&113$/fib_locals&114$/helper_fib&115$prednK&116$H1&117$run_app&118$loop_is_helper_fib&119$program_is_fn_fib&120$fn_fib_is_theta&121$program_correct_fib&122$helper_less_is_theta&102$IH&103$pred_Sn&104$loop_is_helper_less&105$program_is_fn_less&106$fn_less_is_theta&107$H&108$program_correct_less&109$IH&102$IH&102$mulSn&103$helper_mul_is_theta&104$pred_Sn&105$run_app&106$loop_is_helper_mul&107$program_is_fn_mul&108$fn_mul_is_theta&109$H&110$program_correct_mul&111$expn0&102$muln1&103$IH&104$expnS&105$mulnA&106$mulnC&107$mulnS&108$helper_power_is_theta&109$mul1n&110$pred_Sn&111$run_app&112$loop_is_helper_power&113$program_is_fn_power&114$fn_power_is_theta&115$H&116$program_correct_power&117$addn0&102$addn0&102$addn0&102$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$addn0&102$IH&103$addn0&102$IH&103$expn0&102$muln1&103$expnS&104$IH&105$mulnA&106$mulnC&107$exponential_auxP&108$mul1n&109$muln0&110$mulnS&111$multiplication_auxP&112$fact0&113$factS&114$expn0&102$muln1&103$expnS&104$IH&105$mulnA&106$mulnC&107$exponential_auxP&108$mul1n&109$muln0&110$mulnS&111$multiplication_auxP&112$fact0&113$factS&114$fact0&102$muln1&103$fact0&102$muln1&103$res&104$expn0&102$muln1&103$expnS&104$IH&105$mulnA&106$mulnC&107$exponential_auxP&108$mul1n&109$muln0&110$mulnS&111$multiplication_auxP&112$fact0&113$addn0&102$IH&103$addnS&104$eqn_add2l&105$Heq&107$eqxx&108$subnDl&110$subnDA&114$subnS&115$addnS&104$eqn_add2l&105$Heq&107$eqxx&108$subnDl&110$subnDA&114$subnS&115$leqNgt&119$leq_eqVlt&120$negb_or&121$implyNb&125$eq_axiomK&126$def_n2&127$le_mn&129$@leq_trans&133$lt0n&135$addn_eq0&136$subn_eq0&137$leq_subLR&138$addnK&140$subnDr&141$addSn&143$maxnC&144$maxnAC&145$orb_idr&147$leq_max&148$leq_maxl&149$gtn_max&150$addnAC&151$addn_maxl&152$addn_min_max&153$minnC&154$minnE&155$subnAC&156$minnAC&157$minnA&158$minnCA&159$sameP&160$eqn_add2r&161$le_n21&163$leq_min&164$gtn_min&165$geq_min&166$geq_minl&167$addnBA&168$leq_subr&169$addn_minr&170$minn_idPr&171$geq_max&172$leq_maxr&173$le_m21&174$maxn_minl&175$maxn_minr&176$maxnK&177$minn_maxl&178$Pm&180$m_lb&181$subKn&182$ubP&183$subnBA&184$m1_lb&185$m2_lb,&186$eqPQ&187$max_i&188$max_j&189$eq_f&190$mulSn&192$mulnS&193$mulnSr&194$muln0&195$muln0,&196$mulnC&197$mulnDl&198$mulnBl&199$mulnA&200$mulnCA&201$mulnBr&202$muln_eq0&203$leq_mul2l&204$le_mn2&206$orbT&207$leq_mul2r&208$le_mn1&209$orb_andr&210$eqn_mul2l&211$eqn_mul2r&212$ltn_mul2l&213$ltn_mul2r&214$mul1n&215$ltn_pmul2r&216$ltn_Pmull&217$maxn_mulr&219$minn_mulr&220$muln1&221$expnS&222$mul1n,&223$exp1n&224$expnD&225$expnMn&226$expnM&227$addn_gt0&228$eqn0Ngt&229$expn_gt0&230$leq_pmul2l&231$leq_pmulr&232$leq_exp2l&233$eqn_exp2l&234$leq_exp2l]&235$ltn_exp2l]&236$leq_mul&238$expn1&239$ltn_mul&240$IHe&241$ltn_exp2r&242$leq_exp2r&243$eqn_exp2r&244$muln_gt0&245$addTb&246$addbA&247$odd_add&250$odd_sub&251$andb_addl&252$odd_mul&253$addnn&254$mul2n&255$doubleB&256$2ltnNge&257$leq_double&258$doubleS&259$ltn_Sdouble&260$addbb&261$muln2&262$uphalf_half&263$doubleD&264$half_double,&265$odd_double_half&266$half_double&267$uphalf_double&268$halfD&269$mulnn&270$mulnDr&271$def_m&272$sqrnD&273$2addnA&274$/(2 * 2)&275$sqrn_sub&276$lte&279$ltm12&280$ltm23&281$andbT&282$eqm12&283$f_mono&284$in&285$hyp&286$*&287$lemn&288$le_ab&289$geq_leqif&290$n12_0&293$le2&294$m2_0&295$n1_gt0&296$n2_gt0&297$sqrn_gt0&298$ne_mn&299$ltn_add2r&300$nat_Cauchy&301$addE&302$add_mulE&303$mulE&304$mul_expE&305$sub2nn&306$natTrecE&307$by&310$IHp&311$nat_of_succ_gt0&312$doubleS,&313$doubleMl&315$def_b&106$mem_topred&129$symR&131$Rxy&132$eqiR&133$fK&134$hf&139$fgK&140$mf&142$fgK_on&143$s0'x&128$orbT&129$ay&131$eq_a&135$y&136$s_y&137$eq_a12&138$s'y&139$eq_in_count&140$has_filter&141$Es12&142$in&143$Hx&144$*&145$eqxx&147$all_pred1_nseq&148$def_s&150$has_pred0&151$has_sym&152$negb_or&153$cat_uniq&154$andbCA&155$uniq_catC&156$mem_filter&157$negbTE&158$mem_rev&159$Hy&160$all_pred1P&161$count_uniq_mem&162$s_x&163$mem_undup&164$size_undup&165$find_size&167$has_pred1&168$find_cat&169$lt_i_s&170$mem_nth&171$rcons_uniq&172$index_cat&173$size_belast&174$index_uniq&175$eq_sij&176$cat_cons&179$i.+1&181$nax&182$exists&183$i]&184$eq_all&185$a_s&186$IHv&187$count_cat&189$addn_eq0&190$count_predC&191$filter_predI&192$cnt_a'&193$leq_add2r&195$eq12&196$perm_eq_sym&198$eqn_add2l&199$perm_catC&201$perm_cat2r&203$cat1s&205$perm_catCA&206$perm_cons&207$def_s2&208$mem_rot&209$negPf&210$rot_uniq&211$le_s21&212$leqNgt&214$s3x&215$uniq_leq_size&216$eqs12&217$eqs12,&219$uniq_size_uniq&220$@uniq_leq_size&222$s2x&223$Hs12&224$/(rot i s1)&229$def_s1&230$FcatCA&232$addnK&233$rot1_cons&234$rotK&235$has_rot&236$subKn&237$rot0&238$size_rev&240$size_rotr&243$@size_takel&244$5(catA, =^~ rot_size_cat)&245$leq_addl&246$rot_addn&248$addnBA&249$@rot_oversize&250$1ltnW&251$rot_add_mod&252$1addnC&253$rot_rot&254$has_mask_cons&255$size_mask&256$mask_cat&257$Hs&258$mask_rot&261$size_nseq&262$mask_false&263$sz_m&265$geq_min&266$nth_take&267$negb_add&268$addbF&269$addbT&270$negb_eqb&271$before_find&272$def_m_i&273$lt_i_m&274$subnKC&275$congr1&276$drop_nth&277$nth_index&278$index_mem&279$mask0&280$sz_m1&281$sz_m2&282$cat_subseq&283$sub0seq&284$mask_true&286$all_predC&295$map_cat&296$map_take&297$map_drop&298$map_rot&300$size_map&301$filter_mask&302$a_x&303$size_subseq_leqif&305$subseq_filter&306$introT&307$uniq_perm_eq&308$filter_uniq&309$x&310$Ds2&312$perm_rcons&313$eqP&315$x']&316$map_mask&318$inj_in_eq&319$count_map&322$Est&323$eq_sz&326$ltis&327$nth_map&328$Ef&329$eq_f12&330$eqf12&331$eqxx,&332$sy&333$gK&335$fK&336$mem_map&337$pmap_filter&338$size_pmap&340$IHn1&344$addnS&345$iota_add&346$size_iota&347$andbN&348$leq_eqVlt&349$mem_iota&351$nth_iota&353$size_mkseq&355$Hi&356$nth_mkseq&357$mkseq_nth&359$perm_map&360$perm_eq_small&361$Ds&362$iota_addl&363$map_rotr&364$map_comp&365$@eq_map&366$mulnC&367$sumn_nseq&368$foldr_cat&369$revK&370$Hfg&371$Hgf&372$addn_minr&373$size_zip&374$zip_cat&375$zip_rcons&376$IHss&377$IHsh&378$leq_subLR&379$leq_add2l&381$leq_max&382$def_z&383$def_x'&384$map_f&385$not_fxt_z&386$eq_s&387$eq_t&388$fpz&389$sp2&390$Ut&391$:&392$z.1,&393$=&394$x,&395$by&396$Dz1&397$s1z&398$s1'x&399$muln1&102$leq_mul&103$fact_gt0&104$ltn_mul&105$big_nil&106$factS&108$big_add1&109$big_nat_recr&110$mulnC&111$logn1&112$big_geq&113$lognM&114$logn_count_dvd&116$big_mkcond&117$big_nat_widen&118$1ltnW&119$exchange_big_nat&122$divn_count_dvd&124$big_filter&125$fact_prod&126$prednK&128$all_predC&129$has_pred1&130$mem_iota&131$leq_eqVlt&132$bigD1&133$lt0n&134$dvdn_gt0&135$dvdn_addr&136$dvdn_mulr&137$dvdn1&138$1((1 =P p.-1)&139$modnMml&141$modnMmr&142$mulnA&143$mul1n&144$val_eqE&145$i_gt0&146$modnMDl&147$modn_small&148$coprime_sym&149$prime_coprime&150$leqNgt&151$ltn_ord&152$vFp0&153$mod0n&154$mFp1r&155$vFpV&156$mFpA&157$vFp0,&158$eqn_mod_dvd&162$modnDl,&163$subnKC&164$2eqFp&165$Euclid_dvdM&166$addnS&167$addnBA&168$mulnDl&169$subn_sqr&170$leq_sqr&171$mulnS&172$mulnn&173$/(Fp1 : nat)&174$dvdn_addl&175$eqFp&176$Fp_mod&177$eqn0Ngt&178$lt0i&179$modnDl&180$eqxx&181$modnDml&182$mod_fact&183$modnn&184$modnMm&185$big_mkord&186$bigID&187$/mFpM&188$mFpC&189$vFpId&190$mFp1&191$lt1p&192$orbT&193$eqF1n1&194$reindex_onto&195$2negb_or&196$E&197$vFpK&198$big_split&199$big1&200$ffactn1&201$ffactSS&202$muln_gt0&203$ffact_gt0&204$ffactnS&205$mulnK&206$binS&207$bin0&208$addn_gt0&209$IHm&210$andKb&211$leq_add&212$bin_gt0&213$bin_small&214$bin1&215$mulSn&216$mulnDr&217$mulnCA&218$mul_Sm_binm&219$divnMA&220$divn_small&221$fact_smonotone&222$ffact_small&223$eqn_pmul2r&224$bin_ffact&225$subKn&226$bin_fact&227$mulnAC&228$bin_sub&229$leqnSn&230$subSnn&231$mul2n&232$half_double&233$bin2&234$divn2&235$muln_divA&236$dvdn2&237$def_p&238$gtnNdvd&239$bin1]&240$addnn&242$big_nat_rev&243$sum_nat_const&244$card_ord&245$big_ord_recl&246$big_ord0&247$expnS&248$big_distrr&249$big_ord_recr&250$binn&251$subnSK&252$2mulnA&253$expnSr&254$/(f _ _)&255$fxx&256$IHk&257$big1_eq&258$mulnBl&259$subnDA&260$addnK&261$exp1n&262$subn_exp&263$reindex_inj&264$@eq_card1&265$t&266$tuple0&267$sum1dep_card&268$partition_big&269$cardD1&270$Ax&271$reindex&272$tuple_eta&273$theadE&274$andbT&275$all_predI&276$card_uniq_tuples&277$on_card_preimset&278$codom_ffun&280$has_map&282$enumT&283$has_filter&284$size_eq0&285$cardE&286$card_inj_ffuns_on&287$2inE&288$eq_card0&289$A&290$leq_ltn_trans&291$sum_nat_dep_const&292$card_inj_ffuns&293$card_imset&294$cardAk&295$enum_rankK_in&298$ffunE&299$inj_eq&300$im_f0&301$ffactnn&302$eq_pij&303$eqEcard&304$mem_imset&305$card_draws&307$mkseq_nth&308$Am&309$sorted_filter&310$unlock&311$val_ord_enum&312$iota_ltn_sorted&313$mem_enum&314$val_fA&315$cardsE&316$card_uniqP&317$size_tuple&318$map_inj_uniq&319$ft_m&321$in&323$t_x&324$*&325$addSn&326$tnth_nth&327$card_ltn_sorted_tuples&328$map_comp&329$eq_map&330$m0&331$def_m&332$drop_nth&333$leq_addl&334$drop_size&335$leq_add2l&336$tnth_ord_tuple,&338$inord_val&339$inc_t&340$tnth_map&341$tnth_ord_tuple&342$inordK&343$leq_subLR&344$nth_map&345$def_e&346$size_map&347$IHj&349$card_sorted_tuples&351$/(val x0)&352$big_cons&353$IHt&354$val_insubd&355$leq_add2r&356$add_mn&357$s&358$sub_mn&359$=&360$x&361$by&362$card_partial_ord_partitions&363$sameP&364$def_n&365$rowK&107$tnth_nth&108$genmx_id&109$gen_vs2mx&111$sameP&113$memvK&115$linear0&116$genmx0&117$genmx_adds&118$genmx_cap&119$genmx1&120$tvalK&121$mulmx_sum_row&122$linear_sum&123$row_b2mx&125$linearZ&126$mul_b2mx&127$mxE&128$span_b2mx&129$size_tuple&130$scalemx_sub&132$sub0mx&133$Uu&134$Uv&135$linearP&136$addmx_sub&137$scale1r&144$memvE&146$subv_refl&147$eqUV&148$row_sub&150$eqEsubv&152$sub0v&153$andbT&154$scaler0,&155$vs2mxF&156$submx1&157$mem_r2v&159$nz_row_sub&160$memv0&161$subv0&162$vs2mx0&163$submx0&164$nz_row_eq0&165$vs2mxD&166$addsmx_sub&167$addsmxSl&169$addsmxSr&170$addsmxC&171$submx_refl&172$addsmxA&173$addvC&175$linearD&177$submxMl&180$bigD1&181$addvSl&182$subv_add&187$vs2mx_sum&189$vs2mxI&190$sub_capmx&191$capmxSl&193$capmxSr&194$capmxC&195$capmxA&196$capvC&197$subv_cap&199$memv_cap&200$vs2mxD,&202$capvSl&204$bigcapv_inf&205$sub1mx&206$capmx_compl&208$diffmxSl&209$capmx_diff&210$addv_diff_cap&211$addvA&212$addv_idPr&213$mxrank0&214$mxrank_eq0&215$mxrank1&216$mxrank_gen&217$rank_rV&218$can2_eq&219$dimvf&223$mxrank_compl&224$mxrank_cap_compl&225$mxrank_sum_cap&226$dimv_sum_cap&227$dxUV&228$dimv0&229$dimv_eq0&231$eqn_add2l&232$dimv_leqif_eq&233$dim_vline&234$eqxx&235$leq_add2l&237$directvE&239$leq_eqVlt&242$dimv_sum_leqif&243$orbF&244$mxdirectE&245$mxdirect_addsE&246$directv_addE&247$directv_trivial&248$subr_eq0&250$opprD&251$addrACA&252$addr_eq0&253$xpair_eqE&254$eq_uv&255$oppr_eq0&256$andbb&257$memvN&258$memvB&259$addrC&260$vs2mx0]&262$2vs2mx_sum&263$dxU&266$sub0r&267$u_0&268$addKr&269$j&270$Dv&271$sumrB&272$big1&273$negPf&274$subrr&275$Pj&276$big1_eq&278$eq_row_sub&279$memv_span&280$rank_leq_row&281$sXU&283$mem_tnth&284$sub_span&286$u&287$eqXY&288$big_rem&289$big_tnth&290$span_def&291$big_nil&292$big_seq1&293$big_cons&294$big_cat&295$mulmxDl&296$scalemxAl&297$Xv&298$mulmxKpV&299$span_nil&300$span_seq1&301$perm_eq_size&302$eq_span&303$seq1_free&304$sum1_card&305$card_ord&306$has_pred1&307$all_predC&308$big_all&309$big_andE&310$free_directv&311$free_b2mx&312$\row_i&313$k&314$=&315$0&316$by&317$mul0mx&318$lin_b2mx&319$kt0&320$kermx_eq0&321$t_free&322$row_mul&323$mulmx1&324$CtK&325$2mulmxA&326$coord_free&327$mulr1&328$addr0&329$j'i&330$mulr0&331$negb_or&332$cat_free&333$perm_free&334$directvEgeq&336$geq_leqif&337$nil_free&338$big_ord0&339$free_cons&340$IH_X&341$big_ord_recl&342$freeE&343$negb_exists&344$negbK&345$in_tupleE&346$freeX&347$def_v&348$big_nth&349$big_mkord&350$index_uniq&351$free_uniq&352$valK&353$insubT&354$coord_sum_free&355$scaler_sumr&356$big_split&357$scalerA&358$scalerDl&359$size_map&360$eq_szX&361$ltiX&362$nth_map&363$neqji&364$scale0r&365$span_cat&367$defU&368$defV&369$freeY&370$eqEdim&371$sUX&372$dimvS&373$tnth_mktuple&375$row_base_free&376$eq_row_base&377$big_morph&381$span_bigcat&382$freeXs&383$bigcat_free&384$directvP&385$mul_rV_lin1&386$rowE&387$fun_of_lfunK&388$eq_fg&389$lfunE&390$addrA&391$add0r&392$addNr&393$scalerDr&394$/(f2mx (Vector.Hom _))&395$mulmxDr&396$scalemxAr&397$mxvecK&401$linearN&402$eqmxMr&404$limg_line&405$limgS&406$mulmxA&408$Drw&409$capvSr&411$big_map&412$limg_sum&413$opp_lfunE&416$add_lfunE&417$fg0&418$memvf&419$comp_lfunE&420$inv_lfun_def&421$lkerE&422$mxrank_mul_ker&423$limg_ker_dim&424$limg_span&425$limg_dim_eq&426$injf&428$memv_ker&429$linearB&430$eq_fuv&431$inj_eq&432$limg_ker0&433$limg_lfunVK&434$fK&435$capv0&436$lker0_limgf&437$lker0_lfunVK&438$comp_lfunA&439$lker0_compfV&440$comp_lfun1l&441$lker0_compVf&442$comp_lfun1r&443$map_id_in&444$map_comp&445$capvA&446$capvv&447$cap0v&448$limg0&449$add0v&450$addvS&451$capvS&452$limg_add&453$limg_comp&454$addv0&455$defW&456$x&457$Xx&458$lpreim_cap_limg&460$lpreimK&461$addNKr&462$Wfu&463$oner_eq0&464$proj_mx_sub&465$subvP&467$proj_mx_id&468$add_proj_mx&469$daddv_pi_add&473$projv_id&475$dimv_compl&476$limg_proj&477$addnK&478$capfv&479$subr0&480$capv_diff&482$addv_pi2_id&483$memv_pi2&484$addv_diff&485$memv_pi1&486$big_filter&487$IHr&488$coord_vbasis&494$vsprojK&495$basis_free&496$vbasis_mem&497$memt_nth&498$rmorphD&501$scale_scalar_mx&502$mx11_scalar&503$hsubmxK&504$row_mxKl&505$row_mxKr&506$ffunE&508$enum_rankK&509$enum_valK&510$sol_u&512$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$addSn&100.1$plus_Sn_m&100.14999999999999$plus_n_Sm&100.175$app_nil_l2&100.1875$mult_n_O&100.19375$O_minus&100.19687499999999$mult_O_n&100.1984375$plus_n_O&100.19921875$aux12&100.199609375$aux7&100.19980468749999$aux10&100.19990234375$mulSn&100.199951171875$addnCA&100.1999755859375$aux11&100.19998779296874$mulnS&100.19999389648437$addSn&100.1$plus_Sn_m&100.14999999999999$plus_n_Sm&100.175$app_nil_l2&100.1875$mult_n_O&100.19375$O_minus&100.19687499999999$mult_O_n&100.1984375$plus_n_O&100.19921875$aux12&100.199609375$aux7&100.19980468749999$aux10&100.19990234375$mulSn&100.199951171875$addnCA&100.1999755859375$aux11&100.19998779296874$mulnS&100.19999389648437$andb_false_r&100.19999694824219$addSn&100.1$plus_Sn_m&100.14999999999999$plus_n_Sm&100.175$app_nil_l2&100.1875$mult_n_O&100.19375$O_minus&100.19687499999999$mult_O_n&100.1984375$plus_n_O&100.19921875$aux12&100.199609375$aux7&100.19980468749999$aux10&100.19990234375$mulSn&100.199951171875$addnCA&100.1999755859375$aux11&100.19998779296874$mulnS&100.19999389648437$andb_false_r&100.19999694824219$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$h'&102$mulVmx&103$mulmx1&104$mulmxV&105$mulmxA&106$invmx_left&107$mul1mx&108$mxE&109$rshift1&110$H&111$lshift0&112$ord1&113$thinmx0&114$M&115$hM&116$submxK&117$@mulmx_block&118$mulmx0&119$add0r&120$ih&121$urlower1&122$mul0mx&123$addr0&124$mulmxN&125$mulNmx&126$subrr&127$ullower1&128$scalar_mx_block&129$fast_invmxE&130$seqmx1E&131$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$expn0&102$muln1&103$expnS&104$IH&105$mulnA&106$mulnC&107$exponential_auxP&108$mul1n&109$muln0&110$mulnS&111$multiplication_auxP&112$fact0&113$factS&114$expn0&102$muln1&103$expnS&104$IH&105$mulnA&106$mulnC&107$exponential_auxP&108$mul1n&109$muln0&110$mulnS&111$multiplication_auxP&112$fact0&113$expn0&102$muln1&103$expnS&104$IH&105$mulnA&106$mulnC&107$exponential_auxP&108$mul1n&109$muln0&110$mulnS&111$multiplication_auxP&112$fact0&113$expn0&102$muln1&103$expnS&104$IH&105$mulnA&106$mulnC&107$exponential_auxP&108$mul1n&109$muln0&110$mulnS&111$multiplication_auxP&112$fact0&113$expn0&102$muln1&103$expnS&104$IH&105$mulnA&106$mulnC&107$exponential_auxP&108$mul1n&109$muln0&110$mulnS&111$multiplication_auxP&112$fact0&113$factS&114$expn0&102$muln1&103$expnS&104$IH&105$mulnA&106$mulnC&107$exponential_auxP&108$mul1n&109$muln0&110$mulnS&111$multiplication_auxP&112$fact0&113$expn0&102$muln1&103$expnS&104$IH&105$mulnA&106$mulnC&107$exponential_auxP&108$mul1n&109$muln0&110$mulnS&111$multiplication_auxP&112$fact0&113$factS&114$expn0&102$muln1&103$expnS&104$IH&105$mulnA&106$mulnC&107$exponential_auxP&108$mul1n&109$muln0&110$mulnS&111$multiplication_auxP&112$fact0&113$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$exp0n&102$subn0&103$big1_seq&104$muln0&105$in_nil&106$exp0n&102$subn0&103$big1_seq&104$muln0&105$in_nil&106$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul1n&114$GRing.subr_eq&115$GRing.addrA&116$GRing.addrC&117$GRing&118$GRing.Theory.sumrB&119$big_nat_recl&120$subr_sub&121$@eq_bigr&122$@big1&123$GRing.subr_eq0&124$in&125$H1&126$eqP&127$big_ltn&128$@big_add1&129$big_addn&130$H&131$ltn_predK&132$pred_Sn&133$subnDA&134$subnS&135$H4&136$addnBA&137$subnDl&138$lemma2_aux&139$subn_eq0&140$big_nil&141$leq_eqVlt&142$lemma1&143$lemma2'&144$lemma2&145$h'&146$mulVmx&147$mulmx1&148$mulmxV&149$mulmxA&150$invmx_left&151$mul1mx&152$/pot_matrix&153$thinmx0&154$det1&155$det0&156$mulmxBr&157$pot_1&158$big_nat_recr -&159$submx_sub&160$GRing.sub0r&161$p&162$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$exp0n&108$big1_seq&109$in_nil&110$big_mkcond&111$muln1&112$addn2&113$mul0n&102$big_nat1&103$muln0&104$big_nat_recr&105$mulnDr&106$IH&107$addSn&100.1$plus_Sn_m&100.14999999999999$plus_n_Sm&100.175$app_nil_l2&100.1875$mult_n_O&100.19375$O_minus&100.19687499999999$mult_O_n&100.1984375$plus_n_O&100.19921875$aux12&100.199609375$aux7&100.19980468749999$aux10&100.19990234375$mulSn&100.199951171875$addnCA&100.1999755859375$aux11&100.19998779296874$mulnS&100.19999389648437$
\ No newline at end of file diff --git a/contrib/ML4PG/coq/matlab_interaction.el b/contrib/ML4PG/coq/matlab_interaction.el deleted file mode 100644 index bab2a30f..00000000 --- a/contrib/ML4PG/coq/matlab_interaction.el +++ /dev/null @@ -1,627 +0,0 @@ -;; This function starts Matlab - -(defun ml4pg-init-clusters () - (interactive) - (ml4pg-my-config-display) - (require 'comint) - (apply 'make-comint "matlab" *matlab-program* nil - (list "-nodesktop -r 0"))) - ;(apply 'make-comint "matlab" *matlab-program* nil (list "-nodesktop -r"))) - ; (shell-command "/home/jonathan/Matlab/bin/matlab -nodesktop -r - ; \"load /home/jonathan/Desktop/Research/Matlab/expt1_complete_goals.csv; kmeans_clusters_and_frequencies(expt1_complete_goals,3,1000)\"") - -(defvar ml4pg-my-buffer "") - -(defun ml4pg-my-config-display () - (delete-other-windows) - (switch-to-buffer-other-window "*display*") - (erase-buffer) - (other-window -1)) - -;; This function is in charge of processing the output produced by Matlab -;; The variable signal is used to indicate the function which has called to matlab and to process the result - -(defvar ml4pg-signal 0) - -(defun ml4pg-my-output-filter (output) - (setq ml4pg-my-buffer (concat ml4pg-my-buffer output)) - (when (and output (get-buffer "*display*")) - (with-current-buffer "*display*" - (progn (erase-buffer) - (cond ((equal ml4pg-signal 0) nil) - ;((equal signal 1) (print-similarities (search-cluster (split-clusters-aux (remove-jumps my-buffer) nil) (1+(length saved-theorems))))) - ;((equal signal 2) (print-clusters (split-clusters-aux (remove-jumps my-buffer) nil) (split-frequencies my-buffer nil))) - ((equal ml4pg-signal 1) (ml4pg-print-similarities (ml4pg-split-clusters-aux2 ml4pg-my-buffer nil))) - ;((equal signal 2) (print-clusters (split-clusters-aux my-buffer nil) (split-frequencies my-buffer nil))) - ((equal ml4pg-signal 4) (ml4pg-print-clusters-bis (ml4pg-split-clusters-aux ml4pg-my-buffer nil) (ml4pg-split-frequencies ml4pg-my-buffer nil))) - ((equal ml4pg-signal 3) (ml4pg-compute-clusters-and-values (ml4pg-split-clusters-aux (ml4pg-remove-jumps (subseq ml4pg-my-buffer (search "load" ml4pg-my-buffer :from-end t))) nil) - (ml4pg-split-frequencies (ml4pg-remove-jumps (subseq ml4pg-my-buffer (search "load" ml4pg-my-buffer :from-end t))) nil))) - (t nil))))) - output) - -(add-hook 'comint-preoutput-filter-functions 'ml4pg-my-output-filter) - -;(defun ml4pg-split-clusters-aux (str res) - ;(let ((init (search "'" str))) - ;(if init -; (let ((end (search "'" str :start2 (1+ init)))) -; (split-clusters-aux (subseq str (1+ end)) -; (cons (cluster-string-to-list (subseq str (1+ init) end)) res))) - ; res))) - -;(defun ml4pg-split-frequencies (str res) - ;(let ((init (search "[" str))) - ;(if init -; (let ((end (search "]" str :start2 (1+ init)))) -; (if (not (search "char" (subseq str init end))) -; (split-frequencies (subseq str (1+ end)) -; (cons (string-to-number (subseq str (1+ init) end)) res)) -; (split-frequencies (subseq str (1+ (search "[" str :start2 (1+ end)))) res) -; )) - ; res))) - - -(defun ml4pg-split-clusters-aux2 (str res) - (let ((init (search "ans =" str))) - (if init - (list (ml4pg-cluster-string-to-list (ml4pg-remove-jumps (subseq str (+ 5 init) (search ">>" str :from-end t))))) - nil))) - -(defun ml4pg-split-clusters-aux (str res) - (let ((init (search "ans =" str))) - (if init - (let ((end (search "[" str :start2 (1+ init)))) - (ml4pg-split-clusters-aux (subseq str (1+ end)) - (cons (ml4pg-cluster-string-to-list (ml4pg-remove-jumps (subseq str (+ 5 init) end))) res))) - res))) - - -(defun ml4pg-split-frequencies (str res) -(let ((init (search "[" str))) - (if init - (let ((end (search "]" str :start2 (1+ init)))) - (if (not (search "char" (subseq str init end))) - (ml4pg-split-frequencies (subseq str (1+ end)) - (cons (string-to-number (ml4pg-remove-jumps (subseq str (1+ init) end))) res)) - (ml4pg-split-frequencies (subseq str (1+ (search "[" str :start2 (1+ end)))) res) - )) - res))) - - - - -(defun ml4pg-search-cluster (res n) - (do ((temp res (cdr temp)) - (temp2 nil)) - ((endp temp) temp2) - (if (member (format "%s" n) (car temp)) - (append temp2 (list (car temp)))))) - - - -(defun ml4pg-cluster-string-to-list (cluster) - (do ((temp cluster) - (temp2 nil)) - ((not (search "," temp)) (append temp2 (list temp))) - (progn (setf temp2 (append temp2 (list (subseq temp 0 (search "," temp))))) - (setf temp (subseq temp (1+ (search "," temp))))))) - - - - - -(defun ml4pg-remove-occurrence (list n) - (do ((temp list (cdr temp)) - (temp2 nil)) - ((endp temp) temp2) - (if (not (equal (format "%s" n) (car temp))) - (setf temp2 (append temp2 (list (car temp))))))) - - -(defvar ml4pg-granularity-level-temp 1) - -(defun ml4pg-print-similarities (res) - (interactive) - (cond ((not (caar res)) (insert (format "Searching similarities...\n"))) - ((search "None" (caar res)) - (if (not ml4pg-iterative) - (insert (format "Sorry, but we have not found any similarity using granularity %s\n" ml4pg-granularity-level)) - (if (eq ml4pg-granularity-level-temp 5) - (format "Sorry, but we have not found any similarity at any ganularity level\n") - (progn (setf ml4pg-granularity-level-temp (1+ ml4pg-granularity-level-temp)) - (ml4pg-show-clusters-of-theorem-iterative))))) - (t (progn (insert (format "Similarities:\n")) - (insert (format "------------------------------------------------------------------------------------------------------------\n")) - (insert (format "This lemma is similar to the lemmas:\n")) - (do ((temp2 (ml4pg-remove-occurrence (car res) (1+ (length ml4pg-saved-theorems))) (cdr temp2))) - ((endp temp2) ) - (if (<= (string-to-number (car temp2)) (length ml4pg-saved-theorems)) - (progn (insert (format "- ")) - (ml4pg-insert-button-lemma (ml4pg-remove_last_colon(car (nth (- (string-to-number (car temp2)) 1) ml4pg-saved-theorems))))) - (progn (shell-command (concat "cat "(expand-file-name "names_temp.txt") " | sed -n '" - (format "%s" (- (string-to-number (car temp2)) (length ml4pg-saved-theorems))) - "p'")) - (with-current-buffer "*Shell Command Output*" - (beginning-of-buffer) - (read (current-buffer)) - (setf temp-res (ml4pg-remove_last_colon (format "%s" (read (current-buffer)))))) - (insert (format "- ")) - (ml4pg-insert-button-lemma temp-res))))) - (insert (format "------------------------------------------------------------------------------------------------------------\n")) - (if ml4pg-iterative (insert (format "Similarities found using granularity level %s\n" ml4pg-granularity-level-temp))) - ))) - - - - -(defun ml4pg-print-similarities-matlab () - (with-current-buffer "*display*" - (while (string= "0" (car (read-lines (expand-file-name "available.txt")))) - - (progn (erase-buffer) - (insert (format "Searching clusters...\n")) - (sleep-for 1)) - ) - (erase-buffer) - (let* ((clu (car (ml4pg-read-lines (expand-file-name "matlab_res.txt"))))) - (cond - ((search "None" clu) - (if (not ml4pg-iterative) - (insert (format "Sorry, but we have not found any similarity using granularity %s\n" ml4pg-granularity-level)) - (if (eq ml4pg-granularity-level-temp 5) - (format "Sorry, but we have not found any similarity at any ganularity level\n") - (progn (setf ml4pg-granularity-level-temp (1+ ml4pg-granularity-level-temp)) - (ml4pg-show-clusters-of-theorem-iterative))))) - (t (progn (insert (format "Similarities:\n")) - (insert (format "------------------------------------------------------------------------------------------------------------\n")) - (insert (format "This lemma is similar to the lemmas:\n ")) - (do ((temp2 (ml4pg-remove-occurrence (ml4pg-cluster-string-to-list clu) (1+ (length ml4pg-saved-theorems))) (cdr temp2))) - ((endp temp2) ) - (if (<= (string-to-number (car temp2)) (length ml4pg-saved-theorems)) - (progn (insert (format "- ")) - (ml4pg-insert-button-lemma (ml4pg-remove_last_colon(car (nth (- (string-to-number (car temp2)) 1) ml4pg-saved-theorems))))) - (progn (shell-command (concat "cat "(expand-file-name "names_temp.txt") " | sed -n '" - (format "%s" (- (string-to-number (car temp2)) (length ml4pg-saved-theorems))) - "p'")) - (with-current-buffer "*Shell Command Output*" - (beginning-of-buffer) - (read (current-buffer)) - (setf temp-res (ml4pg-remove_last_colon (format "%s" (read (current-buffer)))))) - (insert (format "- ")) - (ml4pg-insert-button-lemma temp-res))))) - (insert (format "------------------------------------------------------------------------------------------------------------\n")) - (if ml4pg-iterative (insert (format "Similarities found using granularity level %s\n" ml4pg-granularity-level-temp))) - )) -))) - - - - - -(defun ml4pg-print-similarities-weka (n) - (let ((clusters (ml4pg-extract-clusters-from-file n))) - (with-current-buffer "*display*" - (erase-buffer) - (insert (format "Similarities:\n")) - (insert (format "------------------------------------------------------------------------------------------------------------\n")) - (insert (format "This lemma is similar to the lemmas:\n ")) - (do ((temp2 (ml4pg-remove-occurrence (ml4pg-clusters-of-n clusters (nth (1- (length ml4pg-saved-theorems)) clusters)) (1+ (length ml4pg-saved-theorems))) (cdr temp2))) - ((endp temp2) ) - (if (<= (car temp2) (length ml4pg-saved-theorems)) - (progn (insert (format "- ")) - (ml4pg-insert-button-lemma (ml4pg-remove_last_colon(car (nth (- (car temp2) 1) ml4pg-saved-theorems))))) - (progn (shell-command (concat "cat "(expand-file-name "names_temp.txt") " | sed -n '" - (format "%s" (- (car temp2) (length ml4pg-saved-theorems))) - "p'")) - (with-current-buffer "*Shell Command Output*" - (beginning-of-buffer) - (read (current-buffer)) - (setf temp-res (ml4pg-remove_last_colon (format "%s" (read (current-buffer)))))) - (insert (format "- ")) - (ml4pg-insert-button-lemma temp-res)))) - (insert (format "------------------------------------------------------------------------------------------------------------\n")) - ) - )) - - - -(defun ml4pg-insert-button-lemma (lemma) - (progn (insert-button lemma 'action (ml4pg-insert-button-lemma-macro lemma) - 'face (list 'link) - 'follow-link t) - (insert (format "\n")))) - - - -(defun ml4pg-insert-button-lemma-macro (test) - (list 'lambda '(x) - (list 'progn - (list 'proof-shell-invisible-cmd-get-result (list 'format '"Unset Printing All.")) - (list 'if (list 'get-buffer '"*display2*") (list 'with-current-buffer '"*display2*" (list 'delete-window))) - (list 'with-current-buffer '"*display*" (list 'split-window-vertically)) - (list 'switch-to-buffer-other-window '"*display2*") - (list 'with-current-buffer '"*display2*" (list 'erase-buffer)) - (list 'with-current-buffer '"*display2*" - (list 'insert (list 'proof-shell-invisible-cmd-get-result - (list 'format '"Print %s." test)))) - ))) - - - - - - -(defvar ml4pg-times 0) - -(defun ml4pg-print-clusters (res freq) - (interactive) - (setf times (1+ times)) - (if (not (caar res)) - (insert (format "Searching clusters...\n")) - (let* ((temp0 (ml4pg-unzip (ml4pg-quicksort-pair (ml4pg-zip res freq)))) - (res1 (car temp0)) - (freq1 (cadr temp0))) - (insert (format "We have found the following clusters:\n" )) - (insert (format "------------------------------------------------------------------------------------------------------------\n")) - (do ((temp res1 (cdr temp)) - (temp-freq freq1 (cdr temp-freq)) - (i 1 (1+ i))) - ((endp temp) (insert (format "------------------------------------------------------------------------------------------------------------\n")) ) - (progn (insert (format "Cluster %s with frequency %s%%\n" i (car temp-freq))) - (do ((temp2 (car temp) (cdr temp2))) - ((endp temp2) (insert (format "\n"))) - (progn (insert (format "Lemma ")) - (ml4pg-insert-button-lemma - (ml4pg-remove_last_colon - (car (nth (string-to-number (car temp2)) ml4pg-saved-theorems))))))))))) - - -(defun ml4pg-print-clusters-bis (res freq) - (interactive) - (setf times (1+ times)) - (if (not (caar res)) - (insert (format "Searching clusters...\n")) - (let* ((temp0 (ml4pg-unzip (ml4pg-quicksort-pair (ml4pg-zip res freq)))) - (res1 (car temp0)) - (freq1 (cadr temp0))) - (insert (format "We have found the following clusters:\n" )) - (insert (format "------------------------------------------------------------------------------------------------------------\n")) - (do ((temp res1 (cdr temp)) - (temp-freq freq1 (cdr temp-freq)) - (i 1 (1+ i))) - ((endp temp) (insert (format "------------------------------------------------------------------------------------------------------------\n")) ) - (progn (insert (format "Cluster %s with frequency %s%%\n" i (car temp-freq))) - (do ((temp2 (car temp) (cdr temp2))) - ((endp temp2) (insert (format "\n"))) - (if (< (string-to-number (car temp2)) (length ml4pg-saved-theorems)) - (progn (insert (format "Lemma ")) - (ml4pg-insert-button-lemma (ml4pg-remove_last_colon - (car (nth (string-to-number (car temp2)) ml4pg-saved-theorems))))) - (progn (shell-command (concat "cat "(expand-file-name "names_temp.txt") " | sed -n '" - (format "%s" (- (string-to-number (car temp2)) (length ml4pg-saved-theorems))) - "p'")) - (with-current-buffer "*Shell Command Output*" - (beginning-of-buffer) - (read (current-buffer)) - (setf temp-res (format "%s" (read (current-buffer))))) - (insert (format "Lemma " )) - (ml4pg-insert-button-lemma temp-res)) - ))))))) - - -(defun ml4pg-extract_clusters_freq (list) - (do ((temp list (cdr temp)) - (clusters nil) - (freq nil)) - ((endp temp) (list clusters freq)) - (if (not (string= (subseq (car temp) 0 1) "[")) - (setf clusters (append clusters (list (car temp)))) - (setf freq (append freq (list (string-to-number (subseq (car temp) 1 (search "]" (car temp)))))))))) - - - - - - - - - - - -(defun ml4pg-print-clusters-weka (gra) - (let* ((clusters (ml4pg-extract-clusters-from-file gra)) - (res1 (ml4pg-remove-alone (cdr (ml4pg-form-clusters clusters gra))))) - (with-current-buffer "*display*" - (erase-buffer) - (insert (format "We have found the following clusters:\n" )) - (insert (format "------------------------------------------------------------------------------------------------------------\n")) - - (do ((temp res1 (cdr temp)) - (i 1 (1+ i))) - ((endp temp) (insert (format "------------------------------------------------------------------------------------------------------------\n")) ) - (progn (insert (format "Cluster %s\n" i )) - (do ((temp2 (car temp) (cdr temp2))) - ((endp temp2) (insert (format "\n"))) - (if (< (car temp2) (length ml4pg-saved-theorems)) - (progn (insert (format "Lemma ")) - (ml4pg-insert-button-lemma (ml4pg-remove_last_colon - (car (nth (car temp2) ml4pg-saved-theorems))))) - (progn (shell-command (concat "cat "(expand-file-name "names_temp.txt") " | sed -n '" - (format "%s" (- (car temp2) (length ml4pg-saved-theorems))) - "p'")) - (with-current-buffer "*Shell Command Output*" - (beginning-of-buffer) - (read (current-buffer)) - (setf temp-res (format "%s" (read (current-buffer))))) - (insert (format "Lemma " )) - (if (not (search "home" temp-res) )(ml4pg-insert-button-lemma temp-res))) - )))) - - - ))) - - - - - - - -(defun ml4pg-remove_last_colon (str) - (if (string= (subseq str (1- (length str))) ":") - (subseq str 0 (1- (length str))) - str)) - - -;; This functions shows the cluster of a theorem - - -(defun ml4pg-show-clusters-of-theorem-iterative () - (interactive) - (let* ((alg (cond ((string= "g" ml4pg-algorithm) "find_cluster_with_gaussian") (t "find_cluster_with_kmeans"))) - (gra (if (not ml4pg-iterative) - (cond ((eq 2 ml4pg-granularity-level) 5) - ((eq 3 ml4pg-granularity-level) 10) - ((eq 4 ml4pg-granularity-level) 15) - ((eq 5 ml4pg-granularity-level) 20) - (t 3)) - (cond ((eq 2 ml4pg-granularity-level-temp) 5) - ((eq 3 ml4pg-granularity-level-temp) 10) - ((eq 4 ml4pg-granularity-level-temp) 15) - ((eq 5 ml4pg-granularity-level-temp) 20) - (t 3))))) - (progn (setf ml4pg-signal 1) - (shell-command (concat "echo 0 > " (expand-file-name "available.txt"))) - (require 'comint) - (comint-send-string (get-buffer-process "*matlab*") - (concat "load " (expand-file-name "temp.csv") - (format "; %s(temp,%s,%s,'%s'); csvwrite('%s',1)\n" alg gra (1+ (length ml4pg-saved-theorems)) - (expand-file-name "matlab_res.txt") (expand-file-name "available.txt")))) - (ml4pg-print-similarities-matlab) - ))) - -(defun ml4pg-show-clusters-of-theorem () - (interactive) - (let* ((alg (cond ((string= "g" ml4pg-algorithm) "find_cluster_with_gaussian") (t "find_cluster_with_kmeans"))) - (gra (if (not ml4pg-iterative) - (cond ((eq 2 ml4pg-granularity-level) 8) - ((eq 3 ml4pg-granularity-level) 15) - ((eq 4 ml4pg-granularity-level) 25) - ((eq 5 ml4pg-granularity-level) 50) - (t 5)) - (cond ((eq 2 ml4pg-granularity-level-temp) 8) - ((eq 3 ml4pg-granularity-level-temp) 15) - ((eq 4 ml4pg-granularity-level-temp) 25) - ((eq 5 ml4pg-granularity-level-temp) 50) - (t 5))))) - (progn - (setq ml4pg-my-buffer "") - (setf res (ml4pg-extract-info-up-to-here)) - (with-temp-file (expand-file-name "temp.csv") (cond ((string= ml4pg-level "g") (insert (ml4pg-extract-features-1-bis res))) - ((string= ml4pg-level "t") (insert (ml4pg-extract-features-2-bis tactic-temp tactic-level))) - ((string= ml4pg-level "p") (insert (ml4pg-extract-features-2-bis proof-tree-temp proof-tree-level))))) - (if ml4pg-libs-menus - (progn (ml4pg-add-libraries-temp) - (ml4pg-add-names))) - (switch-to-buffer-other-window "*display*") - (cond ((string= ml4pg-ml-system "m") - (progn (setf ml4pg-signal 1) - (shell-command (concat "echo 0 > " (expand-file-name "available.txt"))) - (require 'comint) - (comint-send-string (get-buffer-process "*matlab*") - (concat "load " (expand-file-name "temp.csv") - (format "; %s(temp,%s,%s,'%s'); csvwrite('%s',1)\n" alg gra (1+ (length ml4pg-saved-theorems)) - (expand-file-name "matlab_res.txt") (expand-file-name "available.txt")))) - (ml4pg-print-similarities-matlab) - )) - - ((string= ml4pg-ml-system "w") - (progn (setf ml4pg-signal 5) - (ml4pg-weka gra) - (sleep-for 1) - (ml4pg-print-similarities-weka gra)) - ) - ))) - (proof-shell-invisible-cmd-get-result (format "Unset Printing All"))) - -;; The following function shows all the clusters which have been obtained from all the theorems exported up to now - -(defun ml4pg-show-clusters () - (interactive) - (let* ((alg (cond ((string= "g" ml4pg-algorithm) "gaussian_clusters") (t "kmeans_clusters_and_frequencies"))) - (gra (cond ((eq 2 ml4pg-granularity-level) 5) - ((eq 3 ml4pg-granularity-level) 10) - ((eq 4 ml4pg-granularity-level) 15) - ((eq 5 ml4pg-granularity-level) 20) - (t 3))) - (freq (cond ((eq 2 ml4pg-frequency-precision) 500) - ((eq 3 ml4pg-frequency-precision) 1000) - (t 100)))) - - (progn - (setf ml4pg-signal 2) - (setf ml4pg-my-buffer "") - (progn (with-temp-file (expand-file-name "temp1.csv") (insert (ml4pg-extract-features-1))) - (switch-to-buffer-other-window "*display*") - (require 'comint) - (comint-send-string (get-buffer-process "*matlab*") - (concat "load " (expand-file-name "temp1.csv") (format "; %s(temp1,%s,%s)\n" alg gra freq)))) - ))) - - - -(defun ml4pg-show-clusters-bis () - (interactive) - (let* ((alg (cond ((string= "g" ml4pg-algorithm) "gaussian_clusters") (t "kmeans_clusters_and_frequencies"))) - (gra (cond ((eq 2 ml4pg-granularity-level) 5) - ((eq 3 ml4pg-granularity-level) 10) - ((eq 4 ml4pg-granularity-level) 15) - ((eq 5 ml4pg-granularity-level) 20) - (t 3))) - (freq (cond ((eq 2 ml4pg-frequency-precision) 500) - ((eq 3 ml4pg-frequency-precision) 1000) - (t 100)))) - - (progn - (setf ml4pg-signal 4) - (setf ml4pg-my-buffer "") - (if ml4pg-libs-menus - (progn (with-temp-file (expand-file-name "temp.csv") (cond ((string= ml4pg-level "g") (insert (ml4pg-extract-features-1))) - ((string= ml4pg-level "t") (insert (ml4pg-extract-features-2 tactic-level))) - ((string= ml4pg-level "p") (insert (ml4pg-extract-features-2 proof-tree-level))))) - (ml4pg-add-libraries-temp) - (ml4pg-add-names)) - (with-temp-file (expand-file-name "temp.csv") (insert (ml4pg-extract-features-1)))) - (switch-to-buffer-other-window "*display*") - (cond ((string= ml4pg-ml-system "m") - (progn - (shell-command (concat "echo 0 > " (expand-file-name "available.txt"))) - (require 'comint) - (comint-send-string (get-buffer-process "*matlab*") - (concat "load " (expand-file-name "temp.csv") (format "; %s(temp,%s,%s,'%s'); csvwrite('%s',1)\n" alg gra freq - (expand-file-name "matlab_res.txt") (expand-file-name "available.txt")))) - (ml4pg-print-clusters-matlab))) - ((string= ml4pg-ml-system "w") - (progn (setf ml4pg-signal 5) - (ml4pg-weka gra) - (sleep-for 1) - (ml4pg-print-clusters-weka gra)) - ) - - ))) - (proof-shell-invisible-cmd-get-result (format "Unset Printing All")) -) - - - - -(defun ml4pg-add-libraries () - (do ((temp ml4pg-libs-menus (cdr temp))) - ((endp temp) nil) - (cond ((string= ml4pg-level "g") (shell-command (concat "cat " ml4pg-home-dir "libs/coq/" (car temp) ".csv >> " (expand-file-name "temp1.csv")))) - ((string= ml4pg-level "t") (shell-command (concat "cat " ml4pg-home-dir "libs/coq/" (car temp) "_tactics.csv >> " (expand-file-name "temp1.csv")))) - ((string= ml4pg-level "p") (shell-command (concat "cat " ml4pg-home-dir "libs/coq/" (car temp) "_tree.csv >> " (expand-file-name "temp1.csv"))))))) - -(defun ml4pg-add-libraries-temp () - (do ((temp ml4pg-libs-menus (cdr temp))) - ((endp temp) nil) - (cond ((string= ml4pg-level "g") (shell-command (concat "cat " ml4pg-home-dir "libs/coq/" (car temp) ".csv >> " (expand-file-name "temp.csv")))) - ((string= ml4pg-level "t") (shell-command (concat "cat " ml4pg-home-dir "libs/coq/" (car temp) "_tactics.csv >> " (expand-file-name "temp.csv")))) - ((string= ml4pg-level "p") (shell-command (concat "cat " ml4pg-home-dir "libs/coq/" (car temp) "_tree.csv >> " (expand-file-name "temp.csv"))))))) - -(defun ml4pg-add-names () - (shell-command (concat "rm " (expand-file-name "names_temp.txt"))) - (shell-command (concat "touch " (expand-file-name "names_temp.txt"))) - (do ((temp ml4pg-libs-menus (cdr temp))) - ((endp temp) nil) - (shell-command (concat "cat " ml4pg-home-dir "libs/coq/" (car temp) "_names >> " (expand-file-name "names_temp.txt"))))) - - - - - - - -(defvar ml4pg-names-values nil) - -(defun ml4pg-print-clusters2 (res freq) - (interactive) - (let* ((temp0 (ml4pg-unzip (ml4pg-quicksort-pair (ml4pg-zip res freq)))) - (res1 (car temp0)) - (freq1 (cadr temp0))) - (insert (format "We have found the following clusters:\n")) - (insert (format "------------------------------------------------------------------------------------------------------------\n")) - (do ((temp res1 (cdr temp)) - (temp-freq freq1 (cdr temp-freq)) - (i 1 (1+ i))) - ((endp temp) (insert (format "------------------------------------------------------------------------------------------------------------\n"))) - (progn (insert (format "Cluster %s with frequency %s%%\n" i (car temp-freq))) - (do ((temp2 (car temp) (cdr temp2))) - ((endp temp2) (insert (format "\n"))) - (insert (format "Lemma %s\n" - (ml4pg-remove_last_colon - (car (nth (- (string-to-number (car temp2)) 1) ml4pg-saved-theorems2)))))))))) - - -(defun ml4pg-compute-clusters-and-values (list fr) - (if (not (ml4pg-left-strings ml4pg-saved-theorems2)) - (ml4pg-print-clusters2 list fr) - (progn (setf ml4pg-names-values (ml4pg-extract-names-dynamic)) - (do ((temp list (cdr temp)) - (n 200 (+ n 5))) - ((endp temp) (progn (setf ml4pg-names-values (ml4pg-complete-names-values ml4pg-names-values n)) - (setf ml4pg-saved-theorems2 (ml4pg-recompute-saved-theorems ml4pg-saved-theorems2)) - (setf ml4pg-my-buffer "") - (ml4pg-show-clusters-dynamic-b) - ) -nil -) - (ml4pg-assign-values (car temp) n)) - ))) - -(defvar ml4pg-granularity-dynamic 0) - -(defun ml4pg-show-clusters-dynamic () - (interactive) - (setf ml4pg-granularity-dynamic (read-string "Introduce the granularity level (values from 1 to 5): ")) - (progn - (setf ml4pg-signal 3) - (setf ml4pg-my-buffer "") - (with-temp-file (expand-file-name "temp.csv") (insert (ml4pg-extract-features-dynamic))) - (switch-to-buffer-other-window "*display*") - (require 'comint) - (cond ((string= "1" ml4pg-granularity-dynamic) - (comint-send-string (get-buffer-process "*matlab*") (concat "load " (expand-file-name "temp.csv") "; kmeans_clusters_and_frequencies(temp,3,100)\n"))) - ((string= "2" ml4pg-granularity-dynamic) - (comint-send-string (get-buffer-process "*matlab*") (concat "load " (expand-file-name "temp.csv") "; kmeans_clusters_and_frequencies(temp,5,100)\n"))) - ((string= "3" ml4pg-granularity-dynamic) - (comint-send-string (get-buffer-process "*matlab*") (concat "load " (expand-file-name "temp.csv") "; kmeans_clusters_and_frequencies(temp,10,100)\n"))) - ((string= "4" ml4pg-granularity-dynamic) - (comint-send-string (get-buffer-process "*matlab*") (concat "load " (expand-file-name "temp.csv") "; kmeans_clusters_and_frequencies(temp,15,100)\n"))) - ((string= "5" ml4pg-granularity-dynamic) - (comint-send-string (get-buffer-process "*matlab*") (concat "load " (expand-file-name "temp.csv") "; kmeans_clusters_and_frequencies(temp,20,100)\n"))) - (t (ml4pg-show-clusters-dynamic))) - - )) - -(defun ml4pg-show-clusters-dynamic-b () - (interactive) - (progn - (setf ml4pg-signal 3) - (setf ml4pg-my-buffer "") - (with-temp-file (expand-file-name "temp.csv") (insert (ml4pg-extract-features-dynamic))) - (require 'comint) - (cond ((string= "1" ml4pg-granularity-dynamic) - (comint-send-string (get-buffer-process "*matlab*") (concat "load " (expand-file-name "temp.csv") "; kmeans_clusters_and_frequencies(temp,3,100)\n"))) - ((string= "2" ml4pg-granularity-dynamic) - (comint-send-string (get-buffer-process "*matlab*") (concat "load " (expand-file-name "temp.csv") "; kmeans_clusters_and_frequencies(temp,5,100)\n"))) - ((string= "3" ml4pg-granularity-dynamic) - (comint-send-string (get-buffer-process "*matlab*") (concat "load " (expand-file-name "temp.csv") "; kmeans_clusters_and_frequencies(temp,10,100)\n"))) - ((string= "4" ml4pg-granularity-dynamic) - (comint-send-string (get-buffer-process "*matlab*") (concat "load " (expand-file-name "temp.csv") "; kmeans_clusters_and_frequencies(temp,15,100)\n"))) - ((string= "5" ml4pg-granularity-dynamic) - (comint-send-string (get-buffer-process "*matlab*") (concat "load " (expand-file-name "temp.csv") "; kmeans_clusters_and_frequencies(temp,20,100)\n"))) - (t (ml4pg-show-clusters-dynamic))) - ;(comint-send-string (get-buffer-process "*matlab*") -; (concat "load " (expand-file-name "temp.csv") "; kmeans_clusters_and_frequencies(temp," -; (format "%s" (floor (length (extract-list-without-strings saved-theorems2)) 5) ) ",100)\n")) - ))
\ No newline at end of file diff --git a/contrib/ML4PG/coq/menus.el b/contrib/ML4PG/coq/menus.el deleted file mode 100644 index 97d67963..00000000 --- a/contrib/ML4PG/coq/menus.el +++ /dev/null @@ -1,304 +0,0 @@ -;;; The menu interaction - -(easy-menu-define statistics-menu global-map "Statistics" - '("Statistics" - ("Configuration" - ("Algorithm" - ["K-means" (ml4pg-change-algorithm "k") - :selected (string= ml4pg-algorithm "k") - :style toggle - :help "Use k-means algorithm"] - ["EM" (ml4pg-change-algorithm "e") - :selected (string= ml4pg-algorithm "e") - :style toggle - :active (string= ml4pg-ml-system "w") - :help "Use Simple EM algorithm"] - ["FarthestFirst" (ml4pg-change-algorithm "f") - :selected (string= ml4pg-algorithm "f") - :style toggle - :active (string= ml4pg-ml-system "w") - :help "Use FarhestFirst algorithm"]) - ("Granularity" - ["1" (ml4pg-change-granularity 1) - :selected (eq ml4pg-granularity-level 1) - :style toggle - :help "We will use 3 clusters"] - ["2" (ml4pg-change-granularity 2) - :selected (eq ml4pg-granularity-level 2) - :style toggle - :help "We will use 5 clusters"] - ["3" (ml4pg-change-granularity 3) - :selected (eq ml4pg-granularity-level 3) - :style toggle - :help "We will use 10 clusters"] - ["4" (ml4pg-change-granularity 4) - :selected (eq ml4pg-granularity-level 4) - :style toggle - :help "We will use 15 clusters"] - ["5" (ml4pg-change-granularity 5) - :selected (eq ml4pg-granularity-level 5) - :style toggle - :help "We will use 20 clusters"]) - ("Frequencies" - ["1" (ml4pg-change-frequency 1) - :selected (eq ml4pg-frequency-precision 1) - :style toggle - :help "The experiments will be run 100 times"] - ["2" (ml4pg-change-frequency 2) - :selected (eq ml4pg-frequency-precision 2) - :style toggle - :help "The experiments will be run 500 times"] - ["3" (ml4pg-change-frequency 3) - :selected (eq ml4pg-frequency-precision 3) - :style toggle - :help "The experiments will be run 1000 times"]) -) - ["Extract info up to point" (ml4pg-extract-feature-theorems) - :keys "C-c SPC"] - ["Show clusters" (ml4pg-show-clusters-bis) - :keys "C-c c"] - ["Show similar theorems" (ml4pg-show-clusters-of-theorem) - :keys "C-c m"] - ["Export library" (ml4pg-save-numbers) - :keys "C-c n"] - ["Show cluster libraries" (ml4pg-exported-libraries)] - ["Activate Icons" (ml4pg-activate-icons)] -)) - -(easy-menu-remove-item global-map '("menu-bar") "Statistics") - -(easy-menu-add-item nil nil statistics-menu "help-menu") - -(defun ml4pg-activate-icons () - (interactive) - (progn - (easy-menu-remove-item nil '("Statistics") "Activate Icons") - (define-key coq-mode-map [tool-bar statistical-hint] - (list 'menu-item "Statistical Hint" 'ml4pg-show-clusters-of-theorem - :help "Statistical Hint" - :image (list 'image :type 'xpm - :file (concat ml4pg-home-dir "icons/sh-hint.xpm")))) - (define-key coq-mode-map [tool-bar clustering] - (list 'menu-item "Clustering" 'ml4pg-show-clusters-bis - :help "Clustering" - :image (list 'image :type 'xpm - :file (concat ml4pg-home-dir "icons/clustering.xpm")))))) - - -(defvar ml4pg-ml-system "w") -(defvar ml4pg-algorithm "k") -(defvar ml4pg-granularity-level 3) -(defvar ml4pg-frequency-precision 1) -(defvar ml4pg-iterative nil) -(defvar ml4pg-save-automatically nil) -(defvar ml4pg-level "g") - - -(defun ml4pg-change-level (n) - (setq ml4pg-level n)) - -(defun ml4pg-change-algorithm (s) - (setq ml4pg-algorithm s)) - -(defun ml4pg-change-ml-system (s) - (setq ml4pg-ml-system s) - (setq ml4pg-algorithm "k") - (cond ((string= s "w") - (setq ml4pg-iterative nil) - )) - ) - -(defun ml4pg-change-granularity (n) - (setq ml4pg-granularity-level n)) - -(defun ml4pg-change-frequency (n) - (setq ml4pg-frequency-precision n)) - -(defun ml4pg-change-iterative-search () - (setq ml4pg-iterative (not ml4pg-iterative))) - -(defun ml4pg-change-save () - (setq ml4pg-save-automatically (not ml4pg-save-automatically))) - - -;(easy-menu-add-item nil '("Statistics") statistics-menu "help-menu") - -(defun ml4pg-change-algorithm-interactive () - (interactive) - (let ((alg (read-string - "What algorithm do you want to use (k-means -> k, Gaussian -> g): "))) - (setf ml4pg-algorithm (cond ((string= "g" alg) "g") - ((string= "k" alg) "k") - (t ml4pg-algorithm))))) - -(defun ml4pg-change-granularity-interactive () - (interactive) - (let ((alg (read-string - "Introduce the granularity level (values from 1 to 5): "))) - (setf ml4pg-granularity-level (cond ((string= "1" alg) 1) - ((string= "2" alg) 2) - ((string= "3" alg) 3) - ((string= "4" alg) 4) - ((string= "5" alg) 5) - (t ml4pg-granularity-level))))) - -(defun ml4pg-change-frequency-interactive () - (interactive) - (let ((alg (read-string - "Introduce the precision of the frequencies that you want to obtain (values from 1 to 3): "))) - (setf ml4pg-frequency-precision (cond ((string= "1" alg) 1) - ((string= "2" alg) 2) - ((string= "3" alg) 3) - (t ml4pg-frequency-precision))))) - -(defun ml4pg-change-iterative-interactive () - (interactive) - (let ((alg (read-string - "Do you want to perform iterative search? (yes -> y, no -> n): "))) - (setf ml4pg-iterative (cond ((string= "y" alg) 1) - ((string= "n" alg) 2) - (t ml4pg-iterative))))) - - - -(defun ml4pg-exported-libraries () - (interactive) - (easy-menu-remove-item nil '("Statistics") "Show cluster libraries") - (easy-menu-add-item nil '("Statistics") - (cons "Available libraries for clustering:" - (cons ["Current" nil - :selected t - :style toggle - :help "Use the current library for clustering"] - (ml4pg-select-libraries))))) - - -(defun ml4pg-select-libraries () - (ml4pg-available-libraries) - (ml4pg-available-dirs) - (append (ml4pg-select-libraries-aux ml4pg-libs nil) (ml4pg-libraries-dirs))) - - -(defun ml4pg-select-libraries-aux (temp temp2) - (if (endp temp) - temp2 - (ml4pg-select-libraries-aux (cdr temp) (append temp2 (list (ml4pg-menu-library (car temp))))))) - - - - -(defvar ml4pg-libs nil) - -(defun ml4pg-available-libraries () - (shell-command (concat "ls " ml4pg-home-dir "libs/coq | grep .csv | wc -l")) - (let ((n nil) - (i 0)) - (with-current-buffer "*Shell Command Output*" - (beginning-of-buffer) - (setq n (string-to-number (format "%s" (read (current-buffer)))))) - (shell-command (concat "ls " ml4pg-home-dir "libs/coq | grep .csv")) - (with-current-buffer "*Shell Command Output*" - (progn (beginning-of-buffer) - (while (< i n) - (let ((r (format "%s" (read (current-buffer))))) - (progn (setq i (1+ i)) - (setq ml4pg-libs (append ml4pg-libs (list (subseq r 0 (search "." r)))))))))))) - - - -(defvar ml4pg-dirs nil) - -(defun ml4pg-available-dirs () - (shell-command (concat "ls -d " ml4pg-home-dir "libs/coq/*/ | wc -l")) - (let ((n nil) - (i 0)) - (with-current-buffer "*Shell Command Output*" - (beginning-of-buffer) - (setq n (string-to-number (format "%s" (read (current-buffer)))))) - (shell-command (concat "ls -d " ml4pg-home-dir "libs/coq/*/")) - (with-current-buffer "*Shell Command Output*" - (progn (beginning-of-buffer) - (while (< i n) - (let ((r (format "%s" (read (current-buffer))))) - (progn (setq i (1+ i)) - (setq ml4pg-dirs (append ml4pg-dirs (list (subseq r (length (concat ml4pg-home-dir "libs/coq/")) (1- (length r))))))))))) - )) - - - - -(defun ml4pg-libraries-dirs () - (do ((temp ml4pg-dirs (cdr temp)) - (temp2 nil)) - ((endp temp) temp2) - (setf temp2 (append temp2 (list (append (list (car temp)) (ml4pg-libraries-dir (car temp)))))))) - - - -(defun ml4pg-libraries-dir (dir) - (shell-command (concat "ls " ml4pg-home-dir "libs/coq/" dir "/ | grep _names | wc -l")) - (let ((n nil) - (i 0) - (temp nil)) - (with-current-buffer "*Shell Command Output*" - (beginning-of-buffer) - (setq n (string-to-number (format "%s" (read (current-buffer)))))) - (shell-command (concat "ls " ml4pg-home-dir "libs/coq/" dir "/ | grep _names")) - (with-current-buffer "*Shell Command Output*" - (progn (beginning-of-buffer) - (while (< i n) - (let* ((r1 (format "%s" (read (current-buffer)))) - (r (subseq r1 0 (search "_names" r1)))) - (progn (setq i (1+ i)) - (setq temp (append temp (list (ml4pg-menu-library-dir (subseq r 0 (search "." r)) dir))))))) -)) - temp)) - - - -(defun ml4pg-menu-library-dir (item dir) - (vector item (list 'change-library (concat dir "/" item)) - :selected (list 'string-member (concat dir "/" item) 'ml4pg-libs-menus) - :style 'toggle - :help (format "Use the %s library for clustering" item))) - -(defun ml4pg-menu-library (item) - (vector item (list 'change-library item) - :selected (list 'string-member item 'ml4pg-libs-menus) - :style 'toggle - :help (format "Use the %s library for clustering" item))) - - - -(defvar ml4pg-libs-menus nil) - -(defun ml4pg-string-member (string list) - (do ((temp list (cdr temp)) - (is nil)) - ((or (endp temp) is) is) - (if (string= string (car temp)) - (setf is t)))) - - -(defun ml4pg-change-library (string) - (if (string-member string ml4pg-libs-menus) - (ml4pg-remove-from-menus string) - (setq ml4pg-libs-menus (append ml4pg-libs-menus (list string))))) - - -(defun ml4pg-remove-from-menus (string) - (do ((temp ml4pg-libs-menus (cdr temp)) - (temp2 nil)) - ((endp temp) (setf libs-menus temp2)) - (if (not (string= string (car temp))) - (setf temp2 (append temp2 (list (car temp))))))) - - - - - - - - - - diff --git a/contrib/ML4PG/coq/save_lemmas.el b/contrib/ML4PG/coq/save_lemmas.el deleted file mode 100644 index 70b06cd8..00000000 --- a/contrib/ML4PG/coq/save_lemmas.el +++ /dev/null @@ -1,117 +0,0 @@ -(defun ml4pg-proof-assert-next-command-interactive3 () - (interactive) - (if (get-buffer "*response*") - (if (eq ml4pg-save-automatically 0) - (proof-assert-next-command-interactive) - (progn (with-current-buffer "*response*" - (beginning-of-buffer) - (if (zerop (buffer-size)) - (setf temp nil) - (setf temp (search "No" - (format "%s" (read (current-buffer))))))) - (if temp - (ml4pg-export-previous-lemm) - (proof-assert-next-command-interactive) - )) - - ) - (proof-assert-next-command-interactive))) - - -(defun ml4pg-export-previous-lemm () - (interactive) - (let ((final (point)) - (result nil) - (end nil)) - (search-backward "Proof.") - (proof-goto-point) - (while (< (point) final) - (let* ((semis (save-excursion - (skip-chars-backward " \t\n" - (proof-queue-or-locked-end)) - (proof-segment-up-to-using-cache (point)))) - (comment (caar semis)) - (cmd (cadar semis)) - (ts nil)) - (progn (setf ts (ml4pg-get-top-symbol)) - (setf ng (ml4pg-get-number-of-goals)) - (proof-assert-next-command-interactive) - (setf ng2 (get-number-of-goals)) - (if cmd - (setf result (cons (append (get-numbers cmd) (list ts) (list ng2)) result)) - ) - ) - - ) - ) - (proof-assert-next-command-interactive) - (setf ml4pg-saved-theorems (append ml4pg-saved-theorems - (list (list (format "%s" (get-name)) - (ml4pg-flat (reverse result)))))) - (search-forward "Qed.") - - )) - - -(defun ml4pg-get-name () - (search-backward "Lemma") - (read (current-buffer)) - (read (current-buffer))) - - -(defun ml4pg-list-to-string (list) - (do ((temp list (cdr temp)) - (temp2 "")) - ((endp temp) temp2) - (setf temp2 (concat temp2 (car temp) ", ")))) - - - - - - - -(defun ml4pg-save-numbers () - (interactive) - (progn (beginning-of-buffer) - (proof-goto-point) - (end-of-buffer) - (ml4pg-extract-feature-theorems) - (let ((d (read-string (concat "Where do you want to store this library (" (ml4pg-list-to-string ml4pg-dirs) "n (create new directory)): "))) - (d2 nil)) - (cond ((ml4pg-string-member d ml4pg-dirs) - (progn (with-temp-file - (concat ml4pg-home-dir "libs/coq/" d "/" - (subseq (buffer-name (current-buffer)) 0 - (search "." (buffer-name (current-buffer)))) - ".csv") (insert (ml4pg-extract-features-1))) - - - (with-temp-file (concat ml4pg-home-dir "libs/coq/" d "/" - (subseq (buffer-name (current-buffer)) 0 - (search "." (buffer-name (current-buffer)))) - "_names") (insert (ml4pg-extract-names))))) - ((string= d "n") - (progn - (setf d2 (read-string (concat "Introduce a name for the directory:"))) - (shell-command (concat "mkdir " ml4pg-home-dir "libs/coq/" d2)) - (with-temp-file - (concat ml4pg-home-dir "libs/coq/" d2 "/" - (subseq (buffer-name (current-buffer)) 0 - (search "." (buffer-name (current-buffer)))) - ".csv") (insert (ml4pg-extract-features-1))) - (with-temp-file (concat ml4pg-home-dir "libs/coq/" d2 "/" - (subseq (buffer-name (current-buffer)) 0 - (search "." (buffer-name (current-buffer)))) - "_names") (insert (ml4pg-extract-names))))) - (t - (progn (with-temp-file - (concat ml4pg-home-dir "libs/coq/" - (subseq (buffer-name (current-buffer)) 0 - (search "." (buffer-name (current-buffer)))) - ".csv") (insert (ml4pg-extract-features-1))) - (with-temp-file (concat ml4pg-home-dir "libs/coq/" - (subseq (buffer-name (current-buffer)) 0 - (search "." (buffer-name (current-buffer)))) - "_names") (insert (ml4pg-extract-names)))))) -)))
\ No newline at end of file diff --git a/contrib/ML4PG/coq/shortcuts.el b/contrib/ML4PG/coq/shortcuts.el deleted file mode 100644 index d67a7f50..00000000 --- a/contrib/ML4PG/coq/shortcuts.el +++ /dev/null @@ -1,14 +0,0 @@ -(global-set-key (kbd "C-c C-d") 'ml4pg-export-theorem) -(global-set-key (kbd "C-c C-e") 'ml4pg-save-file-conventions1) -(global-set-key (kbd "C-c m") 'ml4pg-show-clusters-of-theorem) -(global-set-key (kbd "C-c C-SPC") 'ml4pg-extract-feature-theorems) -(global-set-key (kbd "C-c c") 'ml4pg-show-clusters) -(global-set-key (kbd "C-c e") 'ml4pg-extract-feature-theorems-dynamic) -(global-set-key (kbd "C-c d") 'ml4pg-show-clusters-dynamic) -(global-set-key (kbd "C-c a") 'ml4pg-change-algorithm-interactive) -(global-set-key (kbd "C-c g") 'ml4pg-change-granularity-interactive) -(global-set-key (kbd "C-c f") 'ml4pg-change-frequency-interactive) -(global-set-key (kbd "C-c i") 'ml4pg-change-iterative-interactive) -(global-set-key (kbd "C-c C-m") 'ml4pg-proof-assert-next-command-interactive3) -(global-set-key (kbd "C-c n") 'ml4pg-save-numbers) - diff --git a/contrib/ML4PG/coq/storage.el b/contrib/ML4PG/coq/storage.el deleted file mode 100644 index 84f1ddc1..00000000 --- a/contrib/ML4PG/coq/storage.el +++ /dev/null @@ -1,51 +0,0 @@ -(defun ml4pg-save-lemma-aux (string) - (append-to-file string nil (concat ml4pg-home-dir "lemmas.txt")) -) - -(defun ml4pg-save-lemma (name value) - (ml4pg-save-lemma-aux (format "%s&%s$" name value))) - - -(defun ml4pg-save-view-aux (string) - (append-to-file string nil (concat ml4pg-home-dir "views.txt")) -) - -(defun ml4pg-save-view (name value) - (sml4pg-ave-view-aux (format "%s&%s$" name value))) - - -(defun ml4pg-read-lemmas () - (if (file-exists-p (concat ml4pg-home-dir "coq/lemmas.txt")) - (with-temp-buffer - (insert-file-contents (concat ml4pg-home-dir "coq/lemmas.txt")) - (let ((temp (format "%s" (read (current-buffer))))) - (setf ml4pg-theorems_id (ml4pg-extract-info-from-files temp)) - )))) - -(defun ml4pg-read-views () - (if (file-exists-p (concat ml4pg-home-dir "coq/views.txt")) - (with-temp-buffer - (insert-file-contents (concat ml4pg-home-dir "coq/views.txt")) - (let ((temp (format "%s" (read (current-buffer))))) - (setf ml4pg-views_id (ml4pg-extract-info-from-files temp)) - )))) - -(defun ml4pg-extract-info-from-files (string) - (do ((temp string) - (temp2 nil)) - ((not (search "$" temp)) temp2) - (let ((dollar (search "$" temp)) - (amper (search "&" temp))) - (progn - (setf temp2 (append temp2 (list (cons (subseq temp 0 amper) - (string-to-number (subseq temp (1+ amper) dollar)))))) - (setf temp (subseq temp (1+ dollar))))))) - - - - - - - - - diff --git a/contrib/ML4PG/coq/views.txt b/contrib/ML4PG/coq/views.txt deleted file mode 100644 index 1f40a052..00000000 --- a/contrib/ML4PG/coq/views.txt +++ /dev/null @@ -1 +0,0 @@ -all_filterP&102$leq_trans->&103$subnKC&104$addIn&105$rot&106$rotr&107$/eqP&108$eqP&109$hasP&110$negP&111$predU1P&112$eq_in_filter&113$allP&114$all_pred1P&115$index&116$nth_find&117$andP&118$i&119$idPn&120$perm_eqP&121$idP&122$perm_eq_trans&123$perm_eqlP&124$perm_eq_size:&125$eqP->&126$uniq_leq_size&127$/idP&128$ss12&129$rot_to:&130$PcatCA&131$PcatCA/IHs/PcatCA&132$catCA_perm_ind&133$has_mask&134$all_nthP&135$subseqP&136$@all_pred1P&137$perm_to_rem/perm_eq_size->&138$esym&139$rem_filter&140$perm_eq_size&141$mapP&142$/mapP&143$@eq_from_nth&144$eq_in_map->&145$filter_uniq&146$map_inj_uniq->&147$It&148$allpairsP&149$orP&150$hasPn&151$eq_bigl&102$eq_bigr->&103$index_iota&104$nilP->&105$eq_bigl->&106$reducebig&107$big_hasC->&108$index_enum&109$big_nat_widen&110$g&111$G&112$eq_bigr&113$_&114$perm_to_rem/(eq_big_perm _)->&115$eq_big_perm&116$big_rem->&117$rem_filter->&118$IHn&119$familyP&120$ffunP&121$eqP/Df&122$IHr&123$familyP/(_ i)&124$existsP&125$forallP&126$bigmax_leqP&127$eq_card0->&128$perm_to_rem/(eq_big_perm _)->&102$eq_big_perm&103$big_rem->&104$rem_filter->&105$IHn&106$familyP&107$ffunP&108$eqP/Df&109$IHr&110$familyP/(_ i)&111$existsP&112$forallP&113$bigmax_leqP&114$eq_card0->&115$matrixP&102$rowP&103$rowP/(_ j):&104$colP&105$canLR&106$conform_mx&107$ord_inj->&108$addnI/val_inj->&109$bump&110$block_mx&111$ulsubmx&112$ursubmx&113$dlsubmx&114$drsubmx&115$nz_row&116$row_matrixP&117$eqP:&118$negbTE&119$is_scalar_mx&120$is_scalar_mxP&121$negbTE->&122$xcol&123$is_perm_mxP&124$gtn_eqF&102$ltnW&103$implyP&104$leP:&105$eqnP&106$leq_trans&107$subnBA->&108$addnBA&109$subSn&110$leq_sub2r&111$leq_sub2l&112$subnSK&113$maxn&114$maxn_idPl&115$minn&116$minn_idPl&117$minn_idPr/leq_maxl&118$minn_idPl/leq_maxr&119$maxn_idPr/geq_minl&120$maxn_idPl/geq_minr&121$orP:&122$minn_idPr&123$ex_minn&124$ex_maxn&125$prednK&126$leq_pmull&127$leq&128$subnK&129$leqifP&130$monotone_leqif&131$eqP:&132$leqif_refl&133$leq_pmul2l:&134$Mn1:&135$leq_pmul2r:&136$Mm2:&137$contraR&102$negbT&103$contra&104$contraL&105$b_notc/negbTE&106$notb_notc/negbTE&107$contraFN&108$bF_notc/negbTE&109$introNTF&110$introT&111$nP&112$IH&113$mem&114$sym_left_transitive&115$sub1&116$sub2&117$sub3&118$fK<-&119$subD&120$Hf&121$gtn_eqF&102$ltnW&103$implyP&104$leP:&105$eqnP&106$leq_trans&107$subnBA->&108$addnBA&109$subSn&110$leq_sub2r&111$leq_sub2l&112$subnSK&113$maxn&114$maxn_idPl&115$minn&116$minn_idPl&117$minn_idPr/leq_maxl&118$minn_idPl/leq_maxr&119$maxn_idPr/geq_minl&120$maxn_idPl/geq_minr&121$orP:&122$minn_idPr&123$ex_minn&124$ex_maxn&125$gtn_eqF&102$ltnW&103$implyP&104$leP:&105$gtn_eqF&102$ltnW&103$implyP&104$leP:&105$eqnP&106$leq_trans&107$subnBA->&108$addnBA&109$subSn&110$leq_sub2r&111$leq_sub2l&112$subnSK&113$maxn&114$maxn_idPl&115$minn&116$minn_idPl&117$minn_idPr/leq_maxl&118$minn_idPl/leq_maxr&119$maxn_idPr/geq_minl&120$maxn_idPl/geq_minr&121$orP:&122$minn_idPr&123$ex_minn&124$ex_maxn&125$gtn_eqF&102$ltnW&103$implyP&104$leP:&105$eqnP&106$leq_trans&107$subnBA->&108$addnBA&109$subSn&110$leq_sub2r&111$leq_sub2l&112$subnSK&113$maxn&114$maxn_idPl&115$minn&116$minn_idPl&117$minn_idPr/leq_maxl&118$minn_idPl/leq_maxr&119$maxn_idPr/geq_minl&120$maxn_idPl/geq_minr&121$orP:&122$minn_idPr&123$ex_minn&124$ex_maxn&125$prednK&126$leq_pmull&127$leq&128$subnK&129$leqifP&130$monotone_leqif&131$eqP:&132$leqif_refl&133$leq_pmul2l:&134$Mn1:&135$leq_pmul2r:&136$Mm2:&137$perm_to_rem/(eq_big_perm _)->&102$eq_big_perm&103$big_rem->&104$rem_filter->&105$IHn&106$familyP&107$ffunP&108$eqP/Df&109$IHr&110$familyP/(_ i)&111$existsP&112$forallP&113$bigmax_leqP&114$eq_card0->&115$lastP:&116$lastP:&102$perm_to_rem/(eq_big_perm _)->&103$eq_big_perm&104$big_rem->&105$rem_filter->&106$IHn&107$familyP&108$ffunP&109$eqP/Df&110$IHr&111$familyP/(_ i)&112$existsP&113$forallP&114$bigmax_leqP&115$eq_card0->&116$val_inj&102$ffunP&103$matrixP&104$rowP&105$rowP/(_ j):&106$colP&107$canLR&108$conform_mx&109$ord_inj->&110$addnI/val_inj->&111$bump&112$block_mx&113$ulsubmx&114$ursubmx&115$dlsubmx&116$drsubmx&117$nz_row&118$row_matrixP&119$eqP:&120$negbTE&121$is_scalar_mx&122$is_scalar_mxP&123$negbTE->&124$xcol&125$is_perm_mxP&126$\tr&127$lift0_perm&128$row_eq&129$row'_eq&130$negPf->&131$t&132$permP&133$\det&134$subsetP&135$p1&136$ulsf&137$s&138$cofactor&139$invmx&140$matrixP/(_ i j)/eqP:&141$negPf<-&142$rowP/(_ j)/eqP:&143$rowP/(_ (lift j k')):&144$rowP/(_ j)/eqP&145$matrixP/(_ i j):&146$A1&147$k&148$val_inj&102$ffunP&103$matrixP&104$rowP&105$rowP/(_ j):&106$colP&107$canLR&108$conform_mx&109$ord_inj->&110$addnI/val_inj->&111$bump&112$block_mx&113$ulsubmx&114$ursubmx&115$dlsubmx&116$drsubmx&117$nz_row&118$row_matrixP&119$eqP:&120$negbTE&121$is_scalar_mx&122$is_scalar_mxP&123$negbTE->&124$xcol&125$is_perm_mxP&126$\tr&127$lift0_perm&128$row_eq&129$row'_eq&130$negPf->&131$t&132$permP&133$\det&134$subsetP&135$p1&136$ulsf&137$s&138$cofactor&139$invmx&140$matrixP/(_ i j)/eqP:&141$negPf<-&142$rowP/(_ j)/eqP:&143$rowP/(_ (lift j k')):&144$rowP/(_ j)/eqP&145$matrixP/(_ i j):&146$A1&147$k&148$val_inj&102$ffunP&103$matrixP&104$rowP&105$rowP/(_ j):&106$colP&107$canLR&108$conform_mx&109$ord_inj->&110$addnI/val_inj->&111$bump&112$block_mx&113$ulsubmx&114$ursubmx&115$dlsubmx&116$drsubmx&117$nz_row&118$row_matrixP&119$eqP:&120$negbTE&121$is_scalar_mx&122$is_scalar_mxP&123$negbTE->&124$xcol&125$is_perm_mxP&126$\tr&127$lift0_perm&128$row_eq&129$row'_eq&130$negPf->&131$t&132$permP&133$\det&134$subsetP&135$p1&136$ulsf&137$s&138$cofactor&139$invmx&140$matrixP/(_ i j)/eqP:&141$negPf<-&142$rowP/(_ j)/eqP:&143$rowP/(_ (lift j k')):&144$rowP/(_ j)/eqP&145$matrixP/(_ i j):&146$A1&147$k&148$lastP:&102$perm_to_rem/(eq_big_perm _)->&103$eq_big_perm&104$big_rem->&105$rem_filter->&106$IHn&107$familyP&108$ffunP&109$eqP/Df&110$IHr&111$familyP/(_ i)&112$existsP&113$forallP&114$bigmax_leqP&115$eq_card0->&116$fun_of_seqmx&102$rowseqmx&103$seqmx_of_mx&104$matrixP&105$iffP&106$mkseqmx_ord&107$seqmxP&108$addseqmx=>&109$oppseqmx=>&110$subseqmx=>&111$trseqmx&112$fun_of_seqmx&102$rowseqmx&103$seqmx_of_mx&104$matrixP&105$iffP&106$mkseqmx_ord&107$seqmxP&108$addseqmx=>&109$oppseqmx=>&110$subseqmx=>&111$trseqmx&112$seqmx0&113$minn&114$mulseqmx&115$row_seqmx&116$col_seqmx&117$block_seqmx&118$eq_op&119$seqmx1&120$scaleseqmx&121$trans&122$b&102$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$fun_of_seqmx&102$rowseqmx&103$seqmx_of_mx&104$matrixP&105$iffP&106$mkseqmx_ord&107$seqmxP&108$addseqmx=>&109$oppseqmx=>&110$subseqmx=>&111$trseqmx&112$seqmx0&113$minn&114$mulseqmx&115$row_seqmx&116$col_seqmx&117$block_seqmx&118$eq_op&119$seqmx1&120$scaleseqmx&121$trans&122$rowP&102$1&103$rowP&102$1&103$drlower1&104$invmx_uniq&105$rowP&102$1&103$drlower1&104$invmx_uniq&105$rowP&102$1&103$drlower1&104$invmx_uniq&105$matrixP&102$ord_inj&103$bump&104$rowP&105$colP&106$block_mx&107$rowV0P&108$mulIf&109$1&110$ker&111$tool&112$row_freeP&113$kernel&114$eq_row_mx&115$eqP:&116$ker_base&117$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$fact&102$fact&102$exponential&103$fact&102$exponential&103$fact&102$exponential&103$multiplication&104$fact&102$exponential&103$multiplication&104$b&102$a&103$pot_matrix&104$fact&102$exponential&103$multiplication&104$fact&102$exponential&103$multiplication&104$fact&102$exponential&103$multiplication&104$fact&102$exponential&103$multiplication&104$fact&102$exponential&103$multiplication&104$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$fact&102$exponential&103$multiplication&104$fact&102$exponential&103$multiplication&104$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$fact&102$exponential&103$multiplication&104$exponential&102$multiplication&103$fact&104$b&102$a&103$pot_matrix&104$theta_mul&102$fn_mul&103$theta_mul&102$fn_mul&103$theta_mul&102$fn_mul&103$theta_mul&102$fn_mul&103$theta_expt&102$fn_expt&103$theta_fact&102$fn_fact&103$fn_less&102$theta_power&102$fn_power&103$exponential&102$multiplication&103$exponential&102$multiplication&103$exponential&102$multiplication&103$exponential&102$multiplication&103$exponential&102$multiplication&103$exponential&102$multiplication&103$fn_fib&102$fib_locals&103$helper_fib&104$gtn_eqF&102$ltnW&103$implyP&104$leP:&105$eqnP&106$leq_trans&107$subnBA->&108$addnBA&109$subSn&110$leq_sub2r&111$leq_sub2l&112$subnSK&113$maxn&114$maxn_idPl&115$minn&116$minn_idPl&117$minn_idPr/leq_maxl&118$minn_idPl/leq_maxr&119$maxn_idPr/geq_minl&120$maxn_idPl/geq_minr&121$orP:&122$minn_idPr&123$ex_minn&124$ex_maxn&125$prednK&126$leq_pmull&127$leq&128$subnK&129$leqifP&130$monotone_leqif&131$eqP:&132$leqif_refl&133$leq_pmul2l:&134$Mn1:&135$leq_pmul2r:&136$Mm2:&137$gtn_eqF&102$ltnW&103$implyP&104$leP:&105$eqnP&106$leq_trans&107$subnBA->&108$addnBA&109$subSn&110$leq_sub2r&111$leq_sub2l&112$subnSK&113$maxn&114$maxn_idPl&115$minn&116$minn_idPl&117$minn_idPr/leq_maxl&118$minn_idPl/leq_maxr&119$maxn_idPr/geq_minl&120$maxn_idPl/geq_minr&121$orP:&122$minn_idPr&123$ex_minn&124$ex_maxn&125$prednK&126$leq_pmull&127$leq&128$subnK&129$leqifP&130$monotone_leqif&131$gtn_eqF&102$ltnW&103$implyP&104$leP:&105$eqnP&106$leq_trans&107$subnBA->&108$addnBA&109$subSn&110$leq_sub2r&111$leq_sub2l&112$subnSK&113$maxn&114$maxn_idPl&115$minn&116$minn_idPl&117$minn_idPr/leq_maxl&118$minn_idPl/leq_maxr&119$maxn_idPr/geq_minl&120$maxn_idPl/geq_minr&121$orP:&122$minn_idPr&123$ex_minn&124$ex_maxn&125$prednK&126$leq_pmull&127$leq&128$subnK&129$leqifP&130$monotone_leqif&131$eqP:&132$leqif_refl&133$leq_pmul2l:&134$Mn1:&135$leq_pmul2r:&136$Mm2:&137$gtn_eqF&102$ltnW&103$implyP&104$leP:&105$eqnP&106$leq_trans&107$subnBA->&108$addnBA&109$subSn&110$leq_sub2r&111$leq_sub2l&112$subnSK&113$maxn&114$maxn_idPl&115$minn&116$minn_idPl&117$minn_idPr/leq_maxl&118$minn_idPl/leq_maxr&119$maxn_idPr/geq_minl&120$maxn_idPl/geq_minr&121$orP:&122$minn_idPr&123$ex_minn&124$ex_maxn&125$prednK&126$leq_pmull&127$leq&128$subnK&129$leqifP&130$monotone_leqif&131$eqP:&132$leqif_refl&133$leq_pmul2l:&134$Mn1:&135$leq_pmul2r:&136$Mm2:&137$contraR&102$negbT&103$contra&104$contraL&105$b_notc/negbTE&106$notb_notc/negbTE&107$contraFN&108$bF_notc/negbTE&109$introNTF&110$introT&111$nP&112$IH&113$mem&114$sym_left_transitive&115$sub1&116$sub2&117$sub3&118$fK<-&119$subD&120$Hf&121$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$pot_matrix&102$eqP&103$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$lastP:&102$perm_to_rem/(eq_big_perm _)->&103$eq_big_perm&104$big_rem->&105$rem_filter->&106$IHn&107$val_inj&102$ffunP&103$matrixP&104$familyP&108$ffunP&109$eqP/Df&110$IHr&111$familyP/(_ i)&112$existsP&113$forallP&114$bigmax_leqP&115$eq_card0->&116$val_inj&102$ffunP&103$matrixP&104$rowP&105$rowP/(_ j):&106$colP&107$canLR&108$conform_mx&109$ord_inj->&110$addnI/val_inj->&111$bump&112$block_mx&113$ulsubmx&114$ursubmx&115$dlsubmx&116$drsubmx&117$nz_row&118$row_matrixP&119$eqP:&120$negbTE&121$is_scalar_mx&122$is_scalar_mxP&123$negbTE->&124$xcol&125$is_perm_mxP&126$\tr&127$lift0_perm&128$row_eq&129$row'_eq&130$negPf->&131$t&132$permP&133$\det&134$subsetP&135$p1&136$ulsf&137$s&138$cofactor&139$invmx&140$matrixP/(_ i j)/eqP:&141$negPf<-&142$rowP/(_ j)/eqP:&143$rowP/(_ (lift j k')):&144$rowP/(_ j)/eqP&145$matrixP/(_ i j):&146$A1&147$k&148$fun_of_seqmx&102$rowseqmx&103$seqmx_of_mx&104$matrixP&105$iffP&106$mkseqmx_ord&107$seqmxP&108$addseqmx=>&109$oppseqmx=>&110$subseqmx=>&111$trseqmx&112$seqmx0&113$minn&114$mulseqmx&115$row_seqmx&116$col_seqmx&117$block_seqmx&118$eq_op&119$seqmx1&120$scaleseqmx&121$trans&122$theta_expt&102$fn_expt&103$theta_fact&102$fn_fact&103$fn_fib&102$fib_locals&103$helper_fib&104$fn_less&102$theta_mul&102$fn_mul&103$theta_power&102$fn_power&103$theta_sum&102$theta_sum&102$theta_sum&102$b&102$a&103$pot_matrix&104$theta_sum&102$theta_sum&102$exponential&102$multiplication&103$exponential&102$multiplication&103$exponential&102$multiplication&103$theta_sum&102$gtn_eqF&102$ltnW&103$implyP&104$leP:&105$eqnP&106$leq_trans&107$subnBA->&108$addnBA&109$subSn&110$leq_sub2r&111$leq_sub2l&112$subnSK&113$maxn&114$maxn_idPl&115$minn&116$minn_idPl&117$minn_idPr/leq_maxl&118$minn_idPl/leq_maxr&119$maxn_idPr/geq_minl&120$maxn_idPl/geq_minr&121$orP:&122$minn_idPr&123$ex_minn&124$ex_maxn&125$prednK&126$leq_pmull&127$leq&128$subnK&129$leqifP&130$monotone_leqif&131$eqP:&132$leqif_refl&133$leq_pmul2l:&134$Mn1:&135$leq_pmul2r:&136$Mm2:&137$contraR&102$negbT&103$contra&104$contraL&105$b_notc/negbTE&106$notb_notc/negbTE&107$contraFN&108$bF_notc/negbTE&109$introNTF&110$introT&111$nP&112$IH&113$mem&114$sym_left_transitive&115$sub1&116$sub2&117$sub3&118$fK<-&119$subD&120$Hf&121$primeP&102$vFpV&103$dvdn&104$/eqxx&105$ffact_fact&106$eqP:&107$f&108$F&109$injectiveP&110$setP&111$imsetP&112$ffunP&113$ff0'&114$inj_f0&115$subsetP&116$add_mn_nat&117$sub_mn&118$add_mn&119$vs2mx&102$free&103$dimv&104$v2r_inj->&105$vlineP&106$subsetv&107$sU12&108$subvP&109$sVW&110$vs2mxP&111$subv_anti&112$vlinePk&113$subV&114$addv_idPl&115$addv_idPr&116$sub0v&117$subvf&118$sub_addsmxP&119$subv_trans->&120$rpred_sum&121$sumv_sup&122$Uv&123$sub_sumsmxP&124$subV(sameP capmx_idPl eqmxP)&125$capv_idPl&126$capv_idPr&127$eqmxP/matrix_modl&128$val_inj&129$eqmxP/addsmx_diff_cap_eq&130$eq_op&131$dimv_leqif_eq&132$geq_leqif&133$directv_def&134$andP]&135$dxU/(_ i Pi)&136$forall_inP&137$eqP/dxU&138$seq_tnthP&139$span_subvP&140$memv_span&141$subv_sumP&142$leqif_eq&143$dim_span&144$rowP/(_ i):&145$row_free_inj&146$r2v_inj&147$rowV0P&148$rowP&149$row_freeP&150$negPf&151$and3P&152$coord_span&153$sumX&154$k&155$f&156$span_basis&157$basis_of&158$basis_free/free_not0&159$eq_span&160$row_matrixP&161$directvP->&162$/]&163$directvP&164$lfunP&165$submxP&166$memv_imgP&167$lker0P&168$lker0_lfunK&169$eq_map&170$lfun_preim&171$memv_capP&172$canRL&173$rowP/(_ (Ordinal vT_proper))/eqP&174$daddv_pi_id&175$vspaceP&176$sumv_pi_for&177$addv_pi1_pi2&178$iota_uniq&179$val_inj/vsprojK/subvsP&180$p2r&181$r2p&182$fr&183$matrixP&184$ffunP&185$canLR&186$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$b&102$a&103$pot_matrix&104$rowP&102$1&103$drlower1&104$invmx_uniq&105$b&102$a&103$pot_matrix&104$exponential&102$multiplication&103$exponential&102$multiplication&103$exponential&102$multiplication&103$exponential&102$multiplication&103$exponential&102$multiplication&103$exponential&102$multiplication&103$exponential&102$multiplication&103$exponential&102$multiplication&103$index_iota&102$andP&103$index_iota&102$andP&103$b&102$a&103$pot_matrix&104$
\ No newline at end of file diff --git a/contrib/ML4PG/coq/weka.el b/contrib/ML4PG/coq/weka.el deleted file mode 100644 index e21fa35c..00000000 --- a/contrib/ML4PG/coq/weka.el +++ /dev/null @@ -1,81 +0,0 @@ -(defun ml4pg-weka (n) - (let ((alg (cond ((string= "k" ml4pg-algorithm) "SimpleKMeans") - ((string= "e" ml4pg-algorithm) "EM") - ((string= "f" ml4pg-algorithm) "FarthestFirst") - ))) - ;(comint-send-string (get-buffer-process "*matlab*") -; (concat "load " (expand-file-name "temp.csv") "; [t1,X,t3] = princomp(temp); X=normalize(X); csvwrite('" -; (expand-file-name "temp2.csv") "',X); -;")) - - (shell-command (concat "sleep 1; cat " ml4pg-home-dir "aux_files/headers.txt " (expand-file-name "temp.csv") " > " (expand-file-name "temp3.arff"))) - (shell-command (concat "java -classpath " - *weka-dir* - " weka.filters.unsupervised.attribute.AddCluster -W \"weka.clusterers." alg " -N " (format "%s" n) " -S 42\" -I last -i " - (expand-file-name "temp3.arff") " -o " (expand-file-name "out.arff"))) - (shell-command (concat "tail -n +37 " - (expand-file-name "out.arff") " > " (expand-file-name "out_bis.arff"))) - )) - - -(defun ml4pg-0_n (n) - (do ((i 0 (1+ i)) - (temp nil)) - ((= i n) temp) - (setf temp (append temp (list (list i nil)))))) - - -(defun ml4pg-read-lines (file) - "Return a list of lines in FILE." - (with-temp-buffer - (insert-file-contents file) - (split-string - (buffer-string) "\n" t) - )) - - -(defun ml4pg-lines-to-clusters (lines) - (do ((temp lines (cdr temp)) - (temp2 nil)) - ((endp temp) temp2) - (setf temp2 (append temp2 (list (string-to-number (subseq (car temp) (+ 7 (search "cluster" (car temp) :from-end t))))))) - )) - - - -(defun ml4pg-extract-clusters-from-file (clusters) - (let* ((temp (ml4pg-0_n clusters)) - (lines (ml4pg-read-lines (expand-file-name "out_bis.arff")))) - (ml4pg-lines-to-clusters lines))) - - - - - -(defun ml4pg-form-clusters (list n) - (do ((i 0 (1+ i)) - (temp nil)) - ((= i n) temp) - (setf temp (append temp (list (ml4pg-clusters-of-n list i)))))) - - - - -(defun ml4pg-clusters-of-n (list n) - (do ((temp list (cdr temp)) - (i 1 (1+ i)) - (temp2 nil)) - ((endp temp) temp2) - (if (equal (car temp) n) - (setf temp2 (append temp2 (list i)))))) - - -(defun ml4pg-remove-alone (list) - (do ((temp list (cdr temp)) - (temp2 nil)) - ((endp temp) temp2) - (if (not (= (length (car temp)) 1)) - (setf temp2 (append temp2 (list (car temp))))))) - - - |