Moving ML4PG from coq directory to contrib directory.

11 files changed, 3884 insertions, 0 deletions

diff --git a/contrib/ML4PG/ssreflect/auxiliary_files.el b/contrib/ML4PG/ssreflect/auxiliary_files.el
new file mode 100644
index 00000000..95a4ce0a
--- /dev/null
+++ b/contrib/ML4PG/ssreflect/auxiliary_files.el
@@ -0,0 +1,23 @@
+(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/ssreflect/feature_extraction_2.el b/contrib/ML4PG/ssreflect/feature_extraction_2.el
new file mode 100644
index 00000000..36cc53b2
--- /dev/null
+++ b/contrib/ML4PG/ssreflect/feature_extraction_2.el
@@ -0,0 +1,1282 @@
+;;; This is the feature vector extraction file for SSReflect
+
+;; Different variables which are used to store information about
+;; the numbers associated with tactics, rewrite rules, types, ...
+
+(defvar ml4pg-hypothesis nil)
+
+(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 '(("move"    . 1)
+		    ("case"      . 2)
+		    ("elim"      . 3)
+		    ("apply"     . 4)
+		    ("apply/"    . 5)
+		    ("move/"     . -5)
+		    ("case/"     . 6)
+		    ("rewrite"    . 7)
+		    ("exists"     . 8)
+		    ("[]"         . 0)
+		    ("exact"         . 9)))
+
+
+(defvar ml4pg-move nil)
+(defvar ml4pg-case nil)
+(defvar ml4pg-elim nil)
+(defvar ml4pg-apply nil)
+(defvar ml4pg-apply/ nil)
+(defvar ml4pg-move/ nil)
+(defvar ml4pg-case/ nil)
+(defvar ml4pg-rewrite nil)
+(defvar ml4pg-exists nil)
+(defvar ml4pg-done nil)
+(defvar ml4pg-exact nil)
+
+
+(defvar ml4pg-types_id '(("nat"  . -2)
+		   ("Prop" . -4)
+		   ("bool" . -3)
+		   ("T"  . -1)
+		   ("seq" . -5)))
+
+(defvar ml4pg-types_id_n -6)
+(defvar ml4pg-views_id nil)
+(defvar ml4pg-theorems_id nil)
+
+(defvar ml4pg-top-symbol-id 
+  '(("forall"      . 5)
+    ("@eq"         . 6)
+    ("and"         . 4)
+    ("iff"         . 8)
+    ("or"          . 3)
+    ("is_true"     . 2)
+    ("reflect"     . 9)
+    ))
+
+(defvar ml4pg-top-symbol-n 10)
+
+
+(defvar ml4pg-add_to 0.1)
+(defvar ml4pg-start 100)
+
+(defvar ml4pg-start_view 101)
+(defvar ml4pg-start_thm 101)
+
+
+(defvar ml4pg-init 0)
+
+(defvar ml4pg-current-level 1)
+(defvar ml4pg-dot-level nil) 
+
+;;; Proof tree levels
+
+(defvar ml4pg-tdl1 nil) 
+(defvar ml4pg-tdl2 nil)
+(defvar ml4pg-tdl3 nil)
+(defvar ml4pg-tdl4 nil)
+(defvar ml4pg-tdl5 nil)
+
+(defun ml4pg-add-info-to-level-aux (info list)
+  (if (not list)
+      info
+    (do ((temp list (cdr temp))
+	 (temp1 info (cdr temp1))
+	 (temp2 nil))
+	((endp temp) temp2)
+	(cond ((= (car temp) 0) (setf temp2 (append temp2 (list (car temp1)))))
+	      ((= (car temp1) 0) (setf temp2 (append temp2 (list (car temp)))))
+	      (t (setf temp2 (append temp2 (list (string-to-number (format "%s%s" (car temp) (car temp1)))))))))))
+
+(defun ml4pg-add-info-to-level (info level)
+  (cond ((= level 1) (setf ml4pg-tdl1 (ml4pg-add-info-to-level-aux info ml4pg-tdl1)))
+	((= level 2) (setf ml4pg-tdl2 (ml4pg-add-info-to-level-aux info ml4pg-tdl2)))
+	((= level 3) (setf ml4pg-tdl3 (ml4pg-add-info-to-level-aux info ml4pg-tdl3)))
+	((= level 4) (setf ml4pg-tdl4 (ml4pg-add-info-to-level-aux info ml4pg-tdl4)))
+	((= level 5) (setf ml4pg-tdl5 (ml4pg-add-info-to-level-aux info ml4pg-tdl5)))
+	(t nil)
+  ))
+
+;;; Main function of this file, it is in charge of extracting the
+;;; information associated with a theorem 
+
+
+(defun ml4pg-export-theorem ()
+  (interactive)
+  (progn (setf ml4pg-tdl1 nil 
+	       ml4pg-tdl2 nil
+	       ml4pg-tdl3 nil
+	       ml4pg-tdl4 nil
+	       ml4pg-tdl5 nil
+	       ml4pg-move nil
+	       ml4pg-case nil
+	       ml4pg-elim nil
+	       ml4pg-apply nil
+	       ml4pg-apply/ nil
+	       ml4pg-move/ nil
+	       ml4pg-case/ nil
+	       ml4pg-rewrite nil
+	       ml4pg-exists nil
+	       ml4pg-done nil
+	       ml4pg-exact nil
+	       ml4pg-current-level 1
+	       ml4pg-dot-level nil
+	       ml4pg-hypothesis nil
+	       ml4pg-goal-level nil)
+	 (if (equal ml4pg-init 0)
+	     (progn (ml4pg-read-lemmas)
+		    (ml4pg-read-views)
+		    (setq ml4pg-init 1)))
+	 (ml4pg-export-theorem-aux nil nil)
+	 (proof-shell-invisible-cmd-get-result (format "Unset Printing All"))
+	   ))
+
+
+
+;; A function to obtain the type associated with an object
+
+(defun ml4pg-remove-jumps-aux (string res)
+  (let ((jump (search "
+" string)))
+    (if jump
+	(ml4pg-remove-jumps-aux (subseq string (1+ jump)) (concatenate 'string res (subseq string 0 jump)))
+      (concatenate 'string res string))))
+
+(defun ml4pg-remove-jumps (string)
+  (ml4pg-remove-jumps-aux string ""))
+
+
+(defun ml4pg-get-type-id (object)
+  (if (string= "(" (subseq object 0 1))
+      -4
+  (let* ((a (ml4pg-remove-jumps (proof-shell-invisible-cmd-get-result (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 
+      (progn (setf ml4pg-types_id
+		   (append ml4pg-types_id  (list (cons  (if pos_space
+						      (subseq a (+ 2 (search ": " a)) pos_space)
+						    (subseq a (+ 2 (search ": " a)) pos_jump))
+						  ml4pg-types_id_n))))
+	     
+	     (setf ml4pg-types_id_n (1- ml4pg-types_id_n))
+	     (1+ ml4pg-types_id_n))
+      ))))
+
+(defun ml4pg-get-type-id2 (object)
+  (let* ((a (proof-shell-invisible-cmd-get-result (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 
+      (progn (setf ml4pg-types_id
+		   (append ml4pg-types_id  (list (cons  (if pos_space
+						      (subseq a (+ 2 (search ": " a)) pos_space)
+						    (subseq a (+ 2 (search ": " a)) pos_jump))
+						  ml4pg-types_id_n))))
+	     
+	     (setf ml4pg-types_id_n (1- ml4pg-types_id_n))
+	     (1+ ml4pg-types_id_n))
+      )))
+
+
+;; 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 ((search "->" res2) 7)
+	  (t (let ((is (assoc fst-symbol ml4pg-top-symbol-id)))
+	       (if is
+		   (cdr is)
+		 (progn (setf ml4pg-top-symbol-id
+			      (append  ml4pg-top-symbol-id  (list (cons fst-symbol ml4pg-top-symbol-n))))
+			
+			(setf ml4pg-top-symbol-n (1+ ml4pg-top-symbol-n))
+			(1- ml4pg-top-symbol-n))))))))
+
+
+
+ 
+;; 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
+;; Sobra
+(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)
+    (if (search "_" (car list))
+	(ml4pg-get-types-list (cdr list) res)
+    (ml4pg-get-types-list (cdr list) (+ (* -1 (ml4pg-get-type-id (car list)) (expt 10 (- (length list) 1))) res)))))
+
+
+(defun ml4pg-get-types-list-exists (list res)
+  (if (endp list)
+      (* -1 res)
+    (ml4pg-get-types-list-exists (cdr list) (+ (* -1 (ml4pg-get-type-id2 (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)))))
+
+(defun ml4pg-get-number-list2 (list n)
+  (if (endp list)
+      0
+    (+ (* n (expt 10 (- (length list) 1)))  (ml4pg-get-number-list2 (cdr list) n))))
+
+;; To obtain the value associated with top symbol in the case of move
+
+(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 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)))))
+
+;;; Auxiliary functions 
+
+(defun ml4pg-remove=> (string)
+  (let ((d (search "=>" string)))
+    (if d
+	(ml4pg-remove=> (concatenate 'string (subseq string 0 d) (subseq string (+ 2 d))))
+      string)))
+
+
+(defun ml4pg-extract-views (list)
+  (do ((temp list (cdr temp))
+       (temp2 nil))
+      ((endp temp) temp2)
+      (if (and (string= (subseq (car temp) 0 1) "/") (not (string= (car temp) "//")) (not (string= (car temp) "/=")) (not (string= (car temp) "//=")))
+	  (if (not (string= (subseq (car temp) 0 2) "/("))
+	      (setf temp2 (append temp2 (list (subseq (car temp) 1))))
+	    (setf temp2 (append temp2 (list (subseq (car temp) 2 (search " " (car temp))))))))))
+
+
+(defun ml4pg-extract-real-params (list)
+  (do ((temp list (cdr temp))
+       (temp2 nil))
+      ((endp temp) temp2)
+      (if (not (or (string= (subseq (car temp) 0 1) "/") (string= (car temp) "//") (string= (car temp) "_") 
+		   (search "->" (car temp)) (search "<-" (car temp)) (string= (car temp) "/=") (string= (car temp) "//=")))
+	  (setf temp2 (append temp2 (list (car temp)))))))
+
+(defun ml4pg-extract-rewrites (list)
+  (do ((temp list (cdr temp))
+       (temp2 nil))
+      ((endp temp) temp2)
+      (if (or (search "->" (car temp)) (search "<-" (car temp)))
+	  (setf temp2 (append temp2 (list (car temp)))))))
+
+(defun ml4pg-extract-simplifications (list)
+  (do ((temp list (cdr temp))
+       (temp2 nil))
+      ((endp temp) temp2)
+      (if (or (string= (car temp) "//") (string= (car temp) "/=") (string= (car temp) "//="))
+	  (setf temp2 (append temp2 (list (car temp)))))))
+
+(defun ml4pg-compute-value-simpl (list)
+  (list 0 (length list) 0 0))
+
+
+(defun ml4pg-extract-views-id (list)
+  (do ((temp list (cdr temp))
+       (temp2 ""))
+      ((endp temp) temp2)
+      (if (assoc (car temp) ml4pg-views_id)
+	  (setf temp2 (concatenate 'string temp2 (format "%s" (cdr (assoc (car temp) ml4pg-views_id))) ))
+	(progn (setf ml4pg-start_view (+ ml4pg-start_view 1)) 
+	       (ml4pg-save-view (car temp) ml4pg-start_view)
+	       (setf ml4pg-views_id 
+		     (append ml4pg-views_id (list (cons (car temp) ml4pg-start_view))))
+	       (setf temp2 (concatenate 'string temp2 (format "%s" (cdr (assoc (car temp) ml4pg-views_id)))))))))
+
+
+
+(defun ml4pg-compute-values-rewrite-tactic (list)
+  (do ((temp (ml4pg-extract-real-params list) (cdr temp))
+       (temp2 ""))
+      ((endp temp) (string-to-number temp2))
+      (let* ((obj1 (if (string= "-" (subseq (car temp) 0 1)) (subseq (car temp) 1) (car temp)))
+	     (obj (if (string= "(" (subseq obj1 0 1)) (subseq obj1 1 (search " " obj1)) obj1)))
+      (if (assoc obj ml4pg-theorems_id)
+	  (setf temp2 (concatenate 'string temp2 (format "%s" (cdr (assoc obj ml4pg-theorems_id)))) )
+	(progn (setf ml4pg-start_thm (+ ml4pg-start_thm 1)) 
+	       (ml4pg-save-lemma obj ml4pg-start_thm)
+	       (setf ml4pg-theorems_id 
+		     (append ml4pg-theorems_id (list (cons obj ml4pg-start_thm))))
+	       (setf temp2 (concatenate 'string temp2 (format "%s" (cdr (assoc obj ml4pg-theorems_id))))))))))
+
+
+(defun ml4pg-compute-values-apply-tactic (list)
+  (do ((temp list (cdr temp))
+       (temp2 ""))
+      ((endp temp) (string-to-number temp2))
+      (let ((obj (if (string= "(" (subseq (car temp) 0 1)) (subseq (car temp) 1) (car temp))))
+	(if (member obj ml4pg-hypothesis)
+	    (setf temp2 (concatenate 'string temp2 "1"))
+	  (if (assoc obj ml4pg-theorems_id)
+	      (setf temp2 (concatenate 'string temp2 (format "%s" (cdr (assoc obj ml4pg-theorems_id)))) )
+	    (progn (setf ml4pg-start_thm (+ ml4pg-start_thm 1)) 
+		   (setf ml4pg-theorems_id 
+			 (append ml4pg-theorems_id (list (cons obj ml4pg-start_thm))))
+		   (setf temp2 (concatenate 'string temp2 (format "%s" (cdr (assoc obj ml4pg-theorems_id)))))))))))
+
+
+(defun ml4pg-compute-value-views-move (list)
+  (list (* -1 (ml4pg-get-number-list2 list 5)) (length list) (* -1 (ml4pg-get-number-list2 list 4)) (string-to-number (ml4pg-extract-views-id list))))
+
+(defun ml4pg-compute-value-views-apply (list)
+  (list  (ml4pg-get-number-list2 list 5) (length list) (* -1 (ml4pg-get-number-list2 list 4)) (string-to-number (ml4pg-extract-views-id list))))
+
+(defun ml4pg-compute-value-views-case (list)
+  (list  (ml4pg-get-number-list2 list 6) (length list) (* -1 (ml4pg-get-number-list2 list 4)) (string-to-number (ml4pg-extract-views-id list))))
+
+(defun ml4pg-compute-value-views-exact (list)
+  (list  (ml4pg-get-number-list2 list 9) (length list) (* -1 (ml4pg-get-number-list2 list 4)) (string-to-number (ml4pg-extract-views-id list))))
+
+(defun ml4pg-compute-value-rewrites (list)
+  (list (ml4pg-get-number-list2 list 7) (length list) (* -1 (ml4pg-get-number-list2 list 4)) (ml4pg-get-number-list list)))
+
+
+
+(defun ml4pg-remove-empties (list)
+  (do ((temp list (cdr temp))
+       (temp2 nil))
+      ((endp temp) temp2)
+      (if (not (string= (car temp) ""))
+	  (setf temp2 (append temp2 (list (car temp)))))))
+
+
+
+(defun ml4pg-occurrences (c string)
+  (do ((temp string)
+       (n 0))
+      ((not (search c temp)) n)
+      (progn (setf n (1+ n))
+	     (setf temp (subseq temp (1+ (search c temp)))))))
+       
+
+(defun ml4pg-put-together-parenthesis (list)
+  (do ((temp list (cdr temp))
+       (n 0)
+       (temp2 nil)
+       (aux ""))
+      ((endp temp) temp2)
+      (cond ((search "(" (car temp)) 
+	     (progn (setf n (1+ n))
+		    (setf aux (concatenate 'string aux (car temp) " "))))
+	    ((and (search ")" (car temp)) (not (= (- n (ml4pg-occurrences ")" (car temp))) 0)))
+	     (progn (setf n (- n (ml4pg-occurrences ")" (car temp))))
+		    (setf aux (concatenate 'string aux (car temp) " "))))
+	    ((search ")" (car temp))
+	     (progn (setf n (1- n))
+		    (setf aux (concatenate 'string aux (car temp)))
+		    (setf temp2 (append temp2 (list aux)))
+		    (setf aux "")))
+	    ((not (= n 0))
+	     (progn (setf aux (concatenate 'string aux (car temp) " "))))
+	    (t (setf temp2 (append temp2 (list (car temp))))
+	    ))))
+	    
+		     
+(defun ml4pg-remove-squared-parenthesis (string res)
+  (let ((pos1 (search "[" string))
+	(pos2 (search "{" string)))
+    (cond ((and pos1 pos2)
+	   (if (< pos1 pos2)
+	       (ml4pg-remove-squared-parenthesis
+		(subseq string (1+ (search "]" string :start2 pos1)))
+		(concatenate 'string res (subseq string 0 pos1)))
+	     (ml4pg-remove-squared-parenthesis
+	      (subseq string (1+ (search "}" string :start2 pos2)))
+	      (concatenate 'string res (subseq string 0 pos2)))))
+	  (pos1 (ml4pg-remove-squared-parenthesis
+		(subseq string (1+ (search "]" string :start2 pos1)))
+		(concatenate 'string res (subseq string 0 pos1))))
+	  (pos2 (ml4pg-remove-squared-parenthesis
+		 (subseq string (1+ (search "}" string :start2 pos2)))
+		 (concatenate 'string res (subseq string 0 pos2))))
+	  (t (concatenate 'string res string)))))
+
+
+(defun ml4pg-remove-iterations (string)
+  (do ((temp string)
+       (temp2 ""))
+      ((= (length temp) 0) temp2)
+      (if (or (string= (subseq temp 0 1) "!") (string= (subseq temp 0 1) "?"))
+	  (setf temp (subseq temp 1))
+	(progn (setf temp2 (concatenate 'string temp2 (subseq temp 0 1)))
+	       (setf temp (subseq temp 1))
+	       ))))
+
+
+      
+(defun ml4pg-remove-squared-parenthesis2 (string)
+  (do ((temp string)
+       (temp2 ""))
+      ((= (length temp) 0) temp2)
+      (if (or (string= (subseq temp 0 1) "[") (string= (subseq temp 0 1) "]") (string= (subseq temp 0 1) "|"))
+	  (setf temp (subseq temp 1))
+	(progn (setf temp2 (concatenate 'string temp2 (subseq temp 0 1)))
+	       (setf temp (subseq temp 1))
+	       ))))
+		
+	   
+(defun ml4pg-extract-params3 (cmd)
+ (let* ((res (ml4pg-extract-params2 (ml4pg-remove-iterations (ml4pg-remove-squared-parenthesis cmd "") ) nil))
+	(res1 (ml4pg-remove-empties res)))
+   (ml4pg-put-together-parenthesis res1)))
+
+
+(defun ml4pg-extract-params4 (cmd)
+ (let* ((res (ml4pg-extract-params2 (ml4pg-remove-squared-parenthesis2 cmd) nil))
+	(res1 (ml4pg-remove-empties res)))
+   (ml4pg-put-together-parenthesis res1)))
+
+
+
+;;; The following functions provide the numbers associated with a concrete tactic
+
+
+(defun ml4pg-numbers-move=> (cmd top level)
+  (let* ((params (ml4pg-extract-params3 (ml4pg-remove=> (subseq cmd (+ 2 (search "=>" cmd)))) ))
+	 (views (ml4pg-extract-views params))
+	 (simpl (ml4pg-extract-simplifications params))
+	 (rewrites (ml4pg-extract-rewrites params))
+	 (rewrites-nums (ml4pg-compute-value-rewrites rewrites))
+	 (simpl-nums (ml4pg-compute-value-simpl simpl))
+	 (views-nums (ml4pg-compute-value-views-move views))
+	 (real-params (ml4pg-extract-real-params params))
+	 (foo (setf ml4pg-hypothesis (append ml4pg-hypothesis real-params)))
+	 (types-params (ml4pg-get-types-list real-params 0))
+	 (foo3 (ml4pg-add-info-to-level (list (ml4pg-get-types-list real-params 0) 0 0 0 0 0 0 0 0 0 0 0 0) level))
+	 (foo2 (setf ml4pg-move (append ml4pg-move (list (list (ml4pg-get-types-list (if real-params (list (car real-params)) nil) 0)  (ml4pg-get-types-list (cdr real-params) 0)
+						   (* -1 (ml4pg-get-number-list real-params)) top))))))
+    (append (list (list (ml4pg-get-number-list2 real-params (cdr (assoc "move" ml4pg-tactic_id))) (length real-params) types-params (* -1 (ml4pg-get-number-list real-params))))
+	  (if simpl (list simpl-nums) nil)
+	  (if views (list views-nums) nil)
+	  (if rewrites (list rewrites-nums) nil))))
+
+(defun ml4pg-numbers-move/ (cmd top level)
+  (let* ((params (ml4pg-extract-params3 (ml4pg-remove=> (subseq cmd 4)) ))
+	 (views (ml4pg-extract-views params))
+	 (simpl (ml4pg-extract-simplifications params))
+	 (rewrites (ml4pg-extract-rewrites params))
+	 (rewrites-nums (ml4pg-compute-value-rewrites rewrites))
+	 (simpl-nums (ml4pg-compute-value-simpl simpl))
+	 (views-nums (ml4pg-compute-value-views-move views))
+	 (real-params (ml4pg-extract-real-params params))
+	 (foo (setf ml4pg-hypothesis (append ml4pg-hypothesis real-params)))
+	 (foo3 (ml4pg-add-info-to-level (list 0 0 0 0 0 (nth 2 views-nums) 0 0 0 0 0 0 0) level))
+	 (foo2 (setf ml4pg-move/ (append ml4pg-move/ (list (list -4  (* -4 (ml4pg-get-number-list real-params))  (nth 3 views-nums) top)))))
+	 (types-params (ml4pg-get-types-list real-params 0)))
+    (append (list views-nums) 
+	    (if real-params (list (list (ml4pg-get-number-list2 real-params (cdr (assoc "move" ml4pg-tactic_id))) (length real-params) types-params (* -1 (ml4pg-get-number-list real-params)))))
+	    (if simpl (list simpl-nums) nil)
+	    (if rewrites (list rewrites-nums) nil)))
+)
+
+(defun ml4pg-numbers-move: (cmd top level)
+  (let* ((params (ml4pg-extract-params3 (subseq cmd (+ 1 (search ":" cmd)))) )
+	 (views (ml4pg-extract-views params))
+	 (simpl (ml4pg-extract-simplifications params))
+	 (rewrites (ml4pg-extract-rewrites params))
+	 (rewrites-nums (ml4pg-compute-value-rewrites rewrites))
+	 (simpl-nums (ml4pg-compute-value-simpl simpl))
+	 (views-nums (ml4pg-compute-value-views-move views))
+	 (real-params (ml4pg-extract-real-params params))
+	 (types-params (ml4pg-get-types-list real-params 0))
+	 (foo3 (ml4pg-add-info-to-level (list (ml4pg-get-types-list real-params 0) 0 0 0 0 0 0 0 0 0 0 0 0) level))
+	 (foo2 (setf ml4pg-move (append ml4pg-move (list (list (ml4pg-get-types-list (if real-params (list (car real-params)) nil) 0)  (ml4pg-get-types-list (cdr real-params) 0)
+						   (* 1 (ml4pg-get-number-list real-params)) top))))))
+    (append (list (list (* -1 (ml4pg-get-number-list2 real-params (cdr (assoc "move" ml4pg-tactic_id)))) (length real-params) types-params (* -1 (ml4pg-get-number-list real-params))))
+	    (if views (list views-nums) nil)
+	    (if simpl (list simpl-nums) nil)
+	    (if rewrites (list rewrites-nums) nil)))
+
+)
+
+(defun ml4pg-numbers-move< (cmd top level)
+  (let* ((foo (list (ml4pg-compute-value-rewrites (list 1))))
+	 (foo3 (ml4pg-add-info-to-level (list 0 0 0 0 0 0 0 top 0 0 0 0 0) level))
+	 (foo2 (setf ml4pg-rewrite (append ml4pg-rewrite (list (list 4 0 1 top))))))
+    foo
+    )
+)
+
+(defun ml4pg-numbers-apply: (cmd top level)
+  (if (string= cmd "apply")
+      (list (list (cdr (assoc "apply" ml4pg-tactic_id)) 1 0 0))
+  (let ((moves (search "=>" cmd))
+	(foo3 (ml4pg-add-info-to-level (list 0 0 0 100 0 0 0 0 0 0 0 0 0) level))
+	(foo2 (setf ml4pg-apply (append ml4pg-apply (list (list -4  0 100 top))))))
+    (if (not moves)
+	(list (list (cdr (assoc "apply" ml4pg-tactic_id))
+	      1 
+	      -4
+	      (ml4pg-compute-values-apply-tactic (ml4pg-extract-real-params (ml4pg-extract-params3 (subseq cmd (+ 1 (if (search ":" cmd) (search ":" cmd) (search " " cmd)))))))))
+      (let* ((args0 (ml4pg-extract-params4 (subseq cmd (+ 2 moves))))
+	    (simpl (ml4pg-extract-simplifications args0))
+	    (simpl-nums (ml4pg-compute-value-simpl simpl))
+	    (args (ml4pg-extract-real-params args0))
+	    )
+      (append (list (list (cdr (assoc "apply" ml4pg-tactic_id))
+			  1 -4 
+			  (ml4pg-compute-values-apply-tactic (ml4pg-extract-real-params (ml4pg-extract-params3 (subseq cmd (+ 1 (if (search ":" cmd) (search ":" cmd) (search " " cmd))) moves))))
+			  ))
+	      (list (list (* -1 (ml4pg-get-number-list2 args (cdr (assoc "move" ml4pg-tactic_id)))) (length args) (ml4pg-get-types-list args 0) (* -1 (ml4pg-get-number-list args))))
+	      (if simpl (list simpl-nums) nil)))))
+))
+
+(defun ml4pg-numbers-elim (cmd top level)
+  (let* ((moves (search "=>" cmd))
+	 (foo3 (ml4pg-add-info-to-level (list 0 0 (ml4pg-get-types-list (list (car (ml4pg-extract-real-params (ml4pg-extract-params3 (subseq cmd (+ 1 (search ":" cmd)) moves))))) 0) 0 0 0 0 0 0 0 0 0 0) level))
+	(foo2 (setf ml4pg-elim (append ml4pg-elim (list (list (ml4pg-get-types-list (list (car (ml4pg-extract-real-params (ml4pg-extract-params3 (subseq cmd (+ 1 (search ":" cmd)) moves))))) 0)  0 -1 top))))))
+    (if (not moves)
+	(list (list (cdr (assoc "elim" ml4pg-tactic_id))
+	      1 (ml4pg-get-types-list (ml4pg-extract-real-params (ml4pg-extract-params3 (subseq cmd (+ 1 (search ":" cmd))))) 0) -1))
+      (let* ((args0 (ml4pg-extract-params4 (subseq cmd (+ 2 moves))))
+	    (simpl (ml4pg-extract-simplifications args0))
+	    (simpl-nums (ml4pg-compute-value-simpl simpl))
+	    (args (ml4pg-extract-real-params args0)))
+      (append (list (list (cdr (assoc "elim" ml4pg-tactic_id))
+			  1 (ml4pg-get-types-list (ml4pg-extract-real-params (ml4pg-extract-params3 (subseq cmd (+ 1 (search ":" cmd)) moves))) 0) -1))
+	      (list (list (* -1 (ml4pg-get-number-list2 args (cdr (assoc "move" ml4pg-tactic_id)))) (length args) (ml4pg-get-types-list args 0) (* -1 (ml4pg-get-number-list args))))
+	      (if simpl (list simpl-nums) nil))))))
+
+(defun ml4pg-numbers-case (cmd top level)
+  (if (string= cmd "case")
+      (list (list (cdr (assoc "case" ml4pg-tactic_id)) 1 0 0))
+  (let ((moves (search "=>" cmd))
+	(foo3 (ml4pg-add-info-to-level (list 0 (if (ml4pg-extract-real-params (ml4pg-extract-params3 (if (search ":" cmd) (subseq cmd (+ 1 (search ":" cmd))) (subseq cmd (+ 1 (search " " cmd))))))
+						   (ml4pg-get-types-list (list (car (ml4pg-extract-real-params (ml4pg-extract-params3 (if (search ":" cmd) (subseq cmd (+ 1 (search ":" cmd))) (subseq cmd (+ 1 (search " " cmd)))))))) 0) 1) 0 0 0 0 0 0 0 0 0 0 0) level))
+	(foo2 (setf ml4pg-case (append ml4pg-case (list (list (if (ml4pg-extract-real-params (ml4pg-extract-params3 (if (search ":" cmd) (subseq cmd (+ 1 (search ":" cmd))) (subseq cmd (+ 1 (search " " cmd))))))
+						      (ml4pg-get-types-list (list (car (ml4pg-extract-real-params (ml4pg-extract-params3 (if (search ":" cmd) (subseq cmd (+ 1 (search ":" cmd))) (subseq cmd (+ 1 (search " " cmd)))))))) 0) 1)
+  0 -1 top))))))
+    (if (not moves)
+	(list (list (cdr (assoc "case" ml4pg-tactic_id))
+	      1 (ml4pg-get-types-list (ml4pg-extract-real-params (ml4pg-extract-params3 (if (search ":" cmd) (subseq cmd (+ 1 (search ":" cmd))) (subseq cmd (+ 1 (search " " cmd)))))) 0) -1))
+      (let* ((args0 (ml4pg-extract-params4 (subseq cmd (+ 2 moves))))
+	    (simpl (ml4pg-extract-simplifications args0))
+	    (simpl-nums (ml4pg-compute-value-simpl simpl))
+	    (args (ml4pg-extract-real-params args0)))
+	(if (ml4pg-extract-params3 (if (search ":" cmd) (subseq cmd (+ 1 (search ":" cmd))) (subseq cmd (+ 1 (search " " cmd)))))
+	    (append (list (list (cdr (assoc "case" ml4pg-tactic_id))
+				1 (ml4pg-get-types-list (ml4pg-extract-real-params (ml4pg-extract-params3 (if (search ":" cmd) (subseq cmd (+ 1 (search ":" cmd))) (subseq cmd (+ 1 (search " " cmd)))))) 0) -1))
+		    (list (list (* -1 (ml4pg-get-number-list2 args (cdr (assoc "move" ml4pg-tactic_id)))) (length args) (ml4pg-get-types-list args 0) (* -1 (ml4pg-get-number-list args))))
+		    (if simpl (list simpl-nums) nil))
+	  (append (list (list (cdr (assoc "case" ml4pg-tactic_id))
+				1 0 0))
+		    (list (list (* -1 (ml4pg-get-number-list2 args (cdr (assoc "move" ml4pg-tactic_id)))) (length args) (ml4pg-get-types-list args 0) (* -1 (ml4pg-get-number-list args))))
+		    (if simpl (list simpl-nums) nil))))))))
+
+(defun ml4pg-numbers-case/ (cmd top level)
+  (let* ((params (ml4pg-extract-params4 (ml4pg-separate-/ (ml4pg-remove=> (subseq cmd 5)) "")))
+	 (views (ml4pg-extract-views params))
+	 (simpl (ml4pg-extract-simplifications params))
+	 (rewrites (ml4pg-extract-rewrites params))
+	 (rewrites-nums (ml4pg-compute-value-rewrites rewrites))
+	 (simpl-nums (ml4pg-compute-value-simpl simpl))
+	 (views-nums (ml4pg-compute-value-views-case views))
+	 (real-params (ml4pg-extract-real-params params))
+	 (foo (setf ml4pg-hypothesis (append ml4pg-hypothesis real-params)))
+	 (types-params (ml4pg-get-types-list real-params 0))
+	 (foo3 (ml4pg-add-info-to-level (list 0 0 0 0 0 0 (nth 2 views-nums) 0 0 0 0 0 0) level))
+	 (foo2 (setf ml4pg-case/ (append ml4pg-case/ (list (list -4  (/ (nth 2 views-nums) 10)  (nth 3 views-nums) top))))))
+    (append (list views-nums)
+	    (if real-params (list (list (ml4pg-get-number-list2 real-params (cdr (assoc "move" ml4pg-tactic_id))) (length real-params) types-params (* -1 (ml4pg-get-number-list real-params)))))
+	    (if simpl (list simpl-nums) nil)
+	    (if rewrites (list rewrites-nums) nil)))
+)
+
+(defun ml4pg-separate-/ (string res)
+  (let ((pos (search "/" string)))
+    (if (not pos)
+	(concatenate 'string res string)
+      (cond ((= pos 0) (ml4pg-separate-/ (subseq string (1+ pos)) (concatenate 'string "/" res (subseq string 0 pos))))
+	    ((not (string= " " (subseq string (1- pos) pos))) 
+	     (ml4pg-separate-/ (subseq string (1+ pos)) (concatenate 'string res (subseq string 0 pos) " /")))
+	    (t (ml4pg-separate-/ (subseq string (1+ pos)) (concatenate 'string res (subseq string 0 pos))))))))
+     
+
+(defun ml4pg-numbers-apply/ (cmd top level)
+  (let* ((params (ml4pg-extract-params4 (ml4pg-separate-/ (ml4pg-remove=> (subseq cmd 5)) "")))
+	 (views (ml4pg-extract-views params))
+	 (simpl (ml4pg-extract-simplifications params))
+	 (rewrites (ml4pg-extract-rewrites params))
+	 (rewrites-nums (ml4pg-compute-value-rewrites rewrites))
+	 (simpl-nums (ml4pg-compute-value-simpl simpl))
+	 (views-nums (ml4pg-compute-value-views-apply views))
+	 (real-params (ml4pg-extract-real-params params))
+	 (foo (setf ml4pg-hypothesis (append ml4pg-hypothesis real-params)))
+	 (types-params (ml4pg-get-types-list real-params 0))
+	 (foo3 (ml4pg-add-info-to-level (list 0 0 0 0 (nth 2 views-nums) 0 0 0 0 0 0 0 0) level))
+	 (foo2 (setf ml4pg-apply/ (append ml4pg-apply/ (list (list -4  (/ (nth 2 views-nums) 10)  (nth 3 views-nums) top))))))
+    (append (list views-nums)
+	    (if real-params (list (list (ml4pg-get-number-list2 real-params (cdr (assoc "move" ml4pg-tactic_id))) (length real-params) types-params (* -1 (ml4pg-get-number-list real-params)))))
+	    (if simpl (list simpl-nums) nil)
+	    (if rewrites (list rewrites-nums) nil)))
+)
+
+(defun ml4pg-numbers-exact (cmd top level)
+  (if (string= cmd "exact")
+      (list (list (cdr (assoc "exact" ml4pg-tactic_id)) 1 0 0))
+  (let* ((params (ml4pg-extract-params3 (cond ((search ":" cmd) (subseq cmd (+ 1 (search ":" cmd))))
+					((search "/" cmd) (subseq cmd (search "/" cmd)))
+					(t (subseq cmd (+ 1 (search " " cmd)))))))
+	(views (ml4pg-extract-views params))
+	(views-nums (ml4pg-compute-value-views-exact views))
+	(foo3 (ml4pg-add-info-to-level (list 0 0 0 0 0 0 0 0 0 0 100 0 0) level))
+	(foo2 (setf ml4pg-exact (append ml4pg-exact (list (list -4  0 100 top))))))
+    (if views 
+	(list views-nums)
+    (list (list (cdr (assoc "exact" ml4pg-tactic_id))
+	      1 
+	      -4
+	      (ml4pg-compute-values-apply-tactic (ml4pg-extract-real-params params))))))))
+
+(defun ml4pg-numbers-rewrite (cmd top level)
+  (let* ((params (ml4pg-extract-params3 (subseq cmd (+ 1 (search " " cmd)))) )
+	 (views (ml4pg-extract-views params))
+	 (simpl (ml4pg-extract-simplifications params))
+	 (simpl-nums (ml4pg-compute-value-simpl simpl))
+	 (views-nums (ml4pg-compute-value-views-move views))
+	 (foo3 (ml4pg-add-info-to-level (list 0 0 0 0 0 0 0 (ml4pg-get-number-list2 (cdr params) 4) 0 0 0 0 0) level))
+	 (foo2 (setf ml4pg-rewrite (append ml4pg-rewrite (list (list -4  (ml4pg-get-number-list2 (cdr params) 4) (ml4pg-compute-values-rewrite-tactic params) top))))))
+    (append (list (list (ml4pg-get-number-list2 params (cdr (assoc "rewrite" ml4pg-tactic_id)))
+			(length params)
+			(ml4pg-get-number-list2 params 4)
+			(ml4pg-compute-values-rewrite-tactic params)))
+	    (if simpl (list simpl-nums) nil)
+	    ))  
+)
+
+(defun ml4pg-numbers-exists (cmd top level)
+  (let ((moves (search "=>" cmd))
+	(foo3 (ml4pg-add-info-to-level (list 0 0 0 0 0 0 0 0 1 0 0 0 0) level))
+	(foo2 (setf ml4pg-exists (append ml4pg-exists (list (list 8 0 1 top))))))
+    (if (not moves)
+	(let* ((params (ml4pg-extract-params3 (subseq cmd 7)) )
+	       (types-params (ml4pg-get-types-list-exists params 0))
+	       )
+	  (list (list (cdr (assoc "exists" ml4pg-tactic_id)) 1 types-params 0)))
+      (let* ((args0 (ml4pg-extract-params4 (subseq cmd (+ 2 moves))))
+	    (simpl (ml4pg-extract-simplifications args0))
+	    (simpl-nums (cml4pg-ompute-value-simpl simpl))
+	    (args (ml4pg-extract-real-params args0)))
+      (append (list (list (cdr (assoc "exists" ml4pg-tactic_id))
+			  1 (ml4pg-get-types-list-exists  (ml4pg-extract-params3 (subseq cmd 7 moves)) 0) -1))
+	      (list (list (* -1 (ml4pg-get-number-list2 args (cdr (assoc "move" ml4pg-tactic_id)))) (length args) (ml4pg-get-types-list args 0) (* -1 (ml4pg-get-number-list args))))
+	      (if simpl (list simpl-nums) nil)))))
+  )
+    
+
+(defun ml4pg-numbers-done (cmd top level)
+  (progn 
+    (ml4pg-add-info-to-level (list 0 0 0 0 0 0 0 0 0 top 0 0 0) level)
+    (setf ml4pg-done (append ml4pg-done (list (list 0 0 0 top))))
+    (list (list (cdr (assoc "[]" ml4pg-tactic_id)) 1 0 0) ) )
+)
+
+
+(defun ml4pg-remove-multiple-spaces (string)
+  (let ((d (search "  " string)))
+    (if d
+	(ml4pg-remove-multiple-spaces (concatenate 'string (subseq string 0 d) (subseq string (1+ d))))
+      string)))
+  
+
+
+(defun ml4pg-compute-numbers-cmd (cmd top level)
+  (let* ((cmd1 (ml4pg-remove-multiple-spaces cmd)))
+    (cond ((search "symmetry" cmd) nil)	  
+	  ((search "last by" cmd) (ml4pg-compute-numbers-cmd (subseq cmd (+ 3 (search "by" cmd))) top level))
+	  ((search "first by" cmd) (ml4pg-compute-numbers-cmd (subseq cmd (+ 3 (search "by" cmd))) top level))
+	  ((string= "try" (subseq cmd 0 2)) (ml4pg-compute-numbers-cmd (subseq cmd (+ 4 (search "try" cmd))) top level))
+	  ((string= "do" (subseq cmd 0 2)) (ml4pg-compute-numbers-cmd (subseq cmd (cond ((search "!" cmd) (1+ (search "!" cmd)))
+								    ((search "?" cmd) (1+ (search "?" cmd)))
+								    (t (+ 3 (search "do" cmd))))) top level)) 
+	  ((search "have" cmd) nil)
+	  ((or (search "move=>" cmd1) (search "move =>" cmd1)) (ml4pg-numbers-move=> cmd1 top level))
+	  ((or (search "move:" cmd1) (search "move :" cmd1)) (ml4pg-numbers-move: cmd1 top level))
+	  ((or (search "move/" cmd1) (search "move /" cmd1)) (ml4pg-numbers-move/ cmd1 top level))
+	  ((or (search "move<-" cmd1) (search "move->" cmd1) (search "move ->" cmd1) (search "move <-" cmd1)) (ml4pg-numbers-move< cmd1 top level))
+	  ((or (search "apply/" cmd1) (search "apply /" cmd1)) (ml4pg-numbers-apply/ cmd1 top level))
+	  ((or (search "apply:" cmd1) (search "apply :" cmd1) (search "apply" cmd1)) (ml4pg-numbers-apply: cmd1 top level))
+	  ((or (search "elim:" cmd1) (search "elim :" cmd1)) (ml4pg-numbers-elim cmd1 top level))
+	  ((or (search "case/" cmd1) (search "case /" cmd1)) (ml4pg-numbers-case/ cmd1 top level))
+	  ((or (search "case:" cmd1) (search "case" cmd1)) (ml4pg-numbers-case cmd1 top level))
+	  ((or (search "exact" cmd1) (search "exact :" cmd1)) (ml4pg-numbers-exact cmd1 top level))
+	  ((search "rewrite" cmd1) (ml4pg-numbers-rewrite cmd1 top level))
+	  ((search "exists" cmd1) (ml4pg-numbers-exists cmd1 top level))
+	  ((or (search "[]" cmd1) (search "done" cmd1) (search "constructor" cmd1)) (ml4pg-numbers-done cmd1 top level))
+	  
+	  ((string= (subseq cmd1 0 4) "pose") nil)
+	  ((string= (subseq cmd1 0 3) "set") nil)
+	  ((string= (subseq cmd1 0 4) "left") nil)
+	  ((string= (subseq cmd1 0 4) "righ") nil)
+	  )
+    )  
+  ) 
+
+
+(defun ml4pg-split-command (cmd result end)
+  (if (or (string= " " (subseq cmd 0 1)) (string= "-" (subseq cmd 0 1)))
+	  (ml4pg-split-command (subseq cmd 1) result end)
+  (let ((is_by (string= "by" (subseq cmd 0 2))))
+    (if is_by
+	(ml4pg-split-command (subseq cmd 3) result 1)
+      (let ((comma (search ";" cmd)))
+	(if comma
+	    (ml4pg-split-command (subseq cmd (1+ comma)) (append result (list (subseq cmd 0 comma))) end)
+	  (list (append result (list (subseq cmd 0 (1- (length cmd))))) end)))))))
+
+
+    
+     
+(defun ml4pg-add-tactics (tactics end top level)
+  (do ((temp tactics (cdr temp))
+       (temp2 nil))
+      ((endp temp) (if (> end 0) (append temp2 (list (list 0 1 0 0))) temp2))
+      (let ((res (ml4pg-compute-numbers-cmd (car temp) top level)))
+	(if res (setf temp2 (append temp2 res))))))
+
+
+;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 top level)
+  (let* ((res (ml4pg-split-command cmd nil 0))
+	 (tactics (car res))
+	 (end (cadr res))
+	 (nums (ml4pg-add-tactics tactics end top level)))
+    (if nums (do ((temp (cdr nums) (cdr temp))
+	 (temp2 (list (format "%s" (nth 0 (car nums))) (nth 1 (car nums))   (format "%s" (nth 2 (car nums))) (format "%s" (nth 3 (car nums))))))
+	((endp temp) (list (string-to-number (nth 0 temp2)) (nth 1 temp2)  (string-to-number (nth 2 temp2)) (string-to-number (nth 3 temp2))) )
+	(setf temp2 (list (if (or (< (string-to-number(nth 0 temp2)) 0) (< (nth 0 (car temp)) 0))
+			      (concatenate 'string (format "-%s" (abs (string-to-number(nth 0 temp2)))) (format "%s" (abs (nth 0 (car temp)))))
+			    (concatenate 'string (format "%s" (abs (string-to-number(nth 0 temp2))) ) (format "%s" (abs (nth 0 (car temp))))))
+			  (+ (nth 1 temp2) (nth 1 (car temp)))
+			  (if (or (< (abs (string-to-number(nth 2 temp2))) 0) (< (nth 2 (car temp)) 0))
+			      (concatenate 'string (format "-%s" (abs (abs (string-to-number(nth 2 temp2))))) (format "%s" (abs (nth 2 (car temp)))))
+			    (concatenate 'string (format "%s" (abs (abs (string-to-number(nth 2 temp2))))) (format "%s" (abs (nth 2 (car temp))))))
+			  (if (or (< (string-to-number (nth 3 temp2)) 0) (< (nth 3 (car temp)) 0))
+			      (concatenate 'string (format "-%s" (abs (string-to-number (nth 3 temp2)))) (format "%s" (abs (nth 3 (car temp)))))
+			    (concatenate 'string (format "%s" (abs (string-to-number (nth 3 temp2)))) (format "%s" (abs (nth 3 (car temp))))))
+			 ))
+	)
+    )))
+
+;; Function to obtain the information just about the goals. 
+
+(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 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))))
+      )
+  ))
+
+
+
+
+(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" "Print"))
+
+(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-compute-tactic-value (list)
+  (if (not list) (list 0 0 0 0 0)
+  (let ((len (length list))
+	(arg0 (car (car list)))
+	(arg1 (format "%s" (nth 1 (car list))))
+	(hyp (format "%s" (nth 2 (car list))))
+	(top (format "%s" (nth 3 (car list)))))
+    (do ((temp (cdr list) (cdr temp)))
+	((endp temp) (list arg0 (string-to-number arg1) (string-to-number hyp) (string-to-number top) len))
+	(progn (setf arg1 (format "%s%s%s" arg1 (nth 0 (car temp)) (nth 1 (car temp))))
+	       (setf hyp (format "%s%s" hyp (nth 2 (car temp))))
+	       (setf top (format "%s%s" top (nth 3 (car temp))))
+	      )))))
+
+
+
+(defun ml4pg-compute-tactic-result (name)
+  (append (list name) (list (append
+	(ml4pg-compute-tactic-value ml4pg-move)
+	(ml4pg-compute-tactic-value ml4pg-case)
+	(ml4pg-compute-tactic-value ml4pg-elim)
+	(ml4pg-compute-tactic-value ml4pg-apply/)
+	(ml4pg-compute-tactic-value ml4pg-move/)
+	(ml4pg-compute-tactic-value ml4pg-case/)
+	(ml4pg-compute-tactic-value ml4pg-rewrite)
+	(ml4pg-compute-tactic-value ml4pg-exists)
+	(ml4pg-compute-tactic-value ml4pg-done)
+	(ml4pg-compute-tactic-value ml4pg-exact)))))
+	 
+(defun ml4pg-compute-proof-tree-result (name)
+  (append (list name) (list (append
+	(if ml4pg-tdl1 ml4pg-tdl1 (ml4pg-generate-zeros 13))
+	(if ml4pg-tdl2 ml4pg-tdl2 (ml4pg-generate-zeros 13))
+	(if ml4pg-tdl3 ml4pg-tdl3 (ml4pg-generate-zeros 13))
+	(if ml4pg-tdl4 ml4pg-tdl4 (ml4pg-generate-zeros 13))
+	(if ml4pg-tdl5 ml4pg-tdl5 (ml4pg-generate-zeros 13))))))
+	
+
+
+
+
+(defun ml4pg-export-theorem-aux (result name)
+  (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)))
+	  ((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))))
+				      )))
+	  ((search "Proof" cmd)
+	   (progn (proof-assert-next-command-interactive)
+		  (ml4pg-export-theorem-aux result name )))
+	  ((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))))
+				     )))
+	  ((search "Qed." cmd)
+	   (progn (proof-assert-next-command-interactive)
+		  ; (insert (format "\n(* %s *)\n" (reverse result)))
+		  ;(setf proof-tree-level (append proof-tree-level (list (compute-proof-result)))) 
+		  ;(setf tactic-level (append tactic-level (list (compute-tactic-result))))
+		  (setf ml4pg-tactic-level (append ml4pg-tactic-level (list (ml4pg-compute-tactic-result name))))
+		  (setf ml4pg-proof-tree-level (append ml4pg-proof-tree-level (list (ml4pg-compute-proof-tree-result name))))
+		  (if name
+		   ;   (split-feature-vector name (flat (reverse result)))
+		      (setf ml4pg-saved-theorems (append ml4pg-saved-theorems 
+					       (list (list name (ml4pg-flat (reverse result))))))
+		      )))
+	  (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))
+		    (ml4pg-export-theorem-aux (cons (append (ml4pg-get-numbers cmd ts ml4pg-current-level) (list ts) (list ng2)) result)
+				       name)
+		    (ml4pg-add-info-to-level (list 0 0 0 0 0 0 0 0 0 0 0 ng2 (if (< ng2 ng) 1 0)) ml4pg-current-level)
+		    (setf ml4pg-current-level (1+ ml4pg-current-level))
+		    
+		    ))))))
+     
+
+
+
+(defun ml4pg-split-feature-vector (name fv)
+  (let ((len (1+ (floor (length fv) 30))))
+    (do ((i 0 (+ i 1)))
+	((equal i len) nil)
+	(setf ml4pg-saved-theorems (append ml4pg-saved-theorems 
+				     (list (list name (ml4pg-take-30-from fv i))))))
+    ))
+
+
+(defun ml4pg-take-30-from (list pos)
+  (let ((j (* 30 pos)))
+  (do ((i j (1+ i))
+       (temp2 nil (if (nth i list) (cons (nth i list) temp2) (cons 0 temp2))))
+      ((= i (+ j 30)) (reverse temp2)))))
+
+
+
+
+;;; 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 "_tactics.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 (ml4pg-remove_last_colon (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-last-part-of-lists (list)
+  (do ((temp list (cdr temp))
+       (temp2 nil))
+      ((endp temp) temp2)
+      (setf temp2 (append temp2 (list (cadar temp))))))
+
+
+
+
+(defun ml4pg-extract-features-1 ()
+  (let ((fm (ml4pg-find-max-length)))
+    (do ((temp (ml4pg-last-part-of-lists ml4pg-saved-theorems) (cdr temp))
+	 (temp2 ""))
+	((endp temp) temp2)
+	(setf temp2 (concat temp2 
+			      (format "%s\n"
+				      (ml4pg-print-list  (ml4pg-take-30 (append (car temp) 
+								   (ml4pg-generate-zeros 30))) ))))
+      )
+    ))
+
+
+
+
+
+
+(defun ml4pg-extract-features-2 (list)
+  (do ((temp (ml4pg-last-part-of-lists (cdr 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
+
+(defvar ml4pg-tactic-temp nil)
+(defvar ml4pg-proof-tree-temp nil)
+
+(defun ml4pg-extract-info-up-to-here ()
+  (interactive)
+  (setf ml4pg-move nil
+	ml4pg-case nil
+	ml4pg-elim nil
+	ml4pg-apply nil
+	ml4pg-apply/ nil
+	ml4pg-move/ nil
+	ml4pg-case/ nil
+	ml4pg-rewrite nil
+	ml4pg-exists nil
+	ml4pg-done nil
+	ml4pg-exact nil
+	ml4pg-tactic-temp nil
+	ml4pg-tdl1 nil 
+	ml4pg-tdl2 nil
+	ml4pg-tdl3 nil
+	ml4pg-tdl4 nil
+	ml4pg-tdl5 nil
+	ml4pg-current-level 1
+	ml4pg-dot-level nil)
+  (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 (ml4pg-get-number-of-goals))
+	       (if cmd 
+	       (setf result (cons (append (ml4pg-get-numbers cmd ts ml4pg-current-level) (list ts) (list ng2)) result)))
+	       (ml4pg-add-info-to-level (list 0 0 0 0 0 0 0 0 0 0 0 ng2 (if (< ng2 ng) 1 0)) ml4pg-current-level)
+	       (setf ml4pg-current-level (1+ ml4pg-current-level))
+		    )
+	  
+	)	
+    )
+    (setf ml4pg-tactic-temp (cadr (ml4pg-compute-tactic-result "")))
+    (setf ml4pg-proof-tree-temp (cadr (ml4pg-compute-proof-tree-result "")))
+    (ml4pg-take-30 (append (ml4pg-flat (reverse result)) (ml4pg-generate-zeros 30) ))
+    (proof-shell-invisible-cmd-get-result (format "Unset Printing All"))
+  ))
+
+
+
+(defun ml4pg-extract-features-1-bis (thm)
+  (let ((fm (ml4pg-find-max-length)))
+    (do ((temp (append (ml4pg-last-part-of-lists ml4pg-saved-theorems) (list thm)) (cdr temp))
+	 (temp2 ""))
+	((endp temp) temp2)
+	(setf temp2 (concat temp2 
+			      (format "%s\n"
+				      (ml4pg-print-list (ml4pg-take-30 (append (car temp) 
+								   (ml4pg-generate-zeros 30))) ))))
+      )
+    ))
+
+
+(defun ml4pg-extract-features-2-bis (thm list)
+  (let ((fm (find-max-length)))
+    (do ((temp (append (ml4pg-last-part-of-lists (cdr list)) (list thm)) (cdr temp))
+	 (temp2 ""))
+	((endp temp) temp2)
+	(setf temp2 (concat temp2 
+			      (format "%s\n"
+				      (ml4pg-print-list (car 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)))
+    )
+  
+  )
+    
+
+
+;;; Function to normalize the results
+
+(defun ml4pg-max-two-lists (list1 list2)
+  (do ((temp1 (ml4pg-take-30 (append list1 (ml4pg-generate-zeros 24))) (cdr temp1))
+       (temp2 (ml4pg-take-30 (append list2 (ml4pg-generate-zeros 24))) (cdr temp2))
+       (temp nil))
+      ((endp temp1) temp)
+      (if (< (car temp1) (car temp2))
+	  (setf temp (append temp (list (car temp2))))
+	(setf temp (append temp (list (car temp1))))
+	)))
+
+(defun ml4pg-min-two-lists (list1 list2)
+  (do ((temp1 (ml4pg-take-30 (append list1 (ml4pg-generate-zeros 24))) (cdr temp1))
+       (temp2 (ml4pg-take-30 (append list2 (ml4pg-generate-zeros 24))) (cdr temp2))
+       (temp nil))
+      ((endp temp1) temp)
+      (if (> (car temp1) (car temp2))
+	  (setf temp (append temp (list (car temp2))))
+	(setf temp (append temp (list (car temp1))))
+	)))
+
+(defun ml4pg-max-position (list )
+  (do ((temp list (cdr temp))
+       (max (ml4pg-generate-zeros (length (car list)))))
+      ((endp temp) max)
+      (setf max (ml4pg-max-two-lists max (car temp)))))
+
+(defun ml4pg-min-position (list )
+  (do ((temp list (cdr temp))
+       (min (ml4pg-generate-zeros (length (car list)))))
+      ((endp temp) min)
+      (setf min (ml4pg-min-two-lists min (car temp)))))
+
+
+(defun ml4pg-normalize-list (list max min)
+  (do ((temp (ml4pg-take-30 (append list (ml4pg-generate-zeros 24))) (cdr temp))
+       (temp-max max (cdr temp-max))
+       (temp-min min (cdr temp-min))
+       (temp2 nil))
+      ((endp temp) temp2)
+      (cond ((< 0 (car temp)) (setf temp2 (append temp2 (list (/ (+ (car temp) .0) (car temp-max))))))
+	    ((= 0 (car temp)) (setf temp2 (append temp2 (list 0))))
+	    (t (setf temp2 (append temp2 (list (- (/ (+ (car temp) .0) (car temp-min))))))))))
+
+(defun ml4pg-normalize (list)
+  
+  (let ((max (ml4pg-max-position list))
+	(min (ml4pg-min-position list)))
+   (do ((temp list (cdr temp))
+	 (temp2 nil))
+	((endp temp) temp2)
+	(setf temp2 (append temp2 (list (ml4pg-normalize-list (car temp) max min)))))))
+
+
+
+
+
+
+ 
+    
diff --git a/contrib/ML4PG/ssreflect/feature_extraction_2.el~ b/contrib/ML4PG/ssreflect/feature_extraction_2.el~
new file mode 100644
index 00000000..36cc53b2
--- /dev/null
+++ b/contrib/ML4PG/ssreflect/feature_extraction_2.el~
@@ -0,0 +1,1282 @@
+;;; This is the feature vector extraction file for SSReflect
+
+;; Different variables which are used to store information about
+;; the numbers associated with tactics, rewrite rules, types, ...
+
+(defvar ml4pg-hypothesis nil)
+
+(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 '(("move"    . 1)
+		    ("case"      . 2)
+		    ("elim"      . 3)
+		    ("apply"     . 4)
+		    ("apply/"    . 5)
+		    ("move/"     . -5)
+		    ("case/"     . 6)
+		    ("rewrite"    . 7)
+		    ("exists"     . 8)
+		    ("[]"         . 0)
+		    ("exact"         . 9)))
+
+
+(defvar ml4pg-move nil)
+(defvar ml4pg-case nil)
+(defvar ml4pg-elim nil)
+(defvar ml4pg-apply nil)
+(defvar ml4pg-apply/ nil)
+(defvar ml4pg-move/ nil)
+(defvar ml4pg-case/ nil)
+(defvar ml4pg-rewrite nil)
+(defvar ml4pg-exists nil)
+(defvar ml4pg-done nil)
+(defvar ml4pg-exact nil)
+
+
+(defvar ml4pg-types_id '(("nat"  . -2)
+		   ("Prop" . -4)
+		   ("bool" . -3)
+		   ("T"  . -1)
+		   ("seq" . -5)))
+
+(defvar ml4pg-types_id_n -6)
+(defvar ml4pg-views_id nil)
+(defvar ml4pg-theorems_id nil)
+
+(defvar ml4pg-top-symbol-id 
+  '(("forall"      . 5)
+    ("@eq"         . 6)
+    ("and"         . 4)
+    ("iff"         . 8)
+    ("or"          . 3)
+    ("is_true"     . 2)
+    ("reflect"     . 9)
+    ))
+
+(defvar ml4pg-top-symbol-n 10)
+
+
+(defvar ml4pg-add_to 0.1)
+(defvar ml4pg-start 100)
+
+(defvar ml4pg-start_view 101)
+(defvar ml4pg-start_thm 101)
+
+
+(defvar ml4pg-init 0)
+
+(defvar ml4pg-current-level 1)
+(defvar ml4pg-dot-level nil) 
+
+;;; Proof tree levels
+
+(defvar ml4pg-tdl1 nil) 
+(defvar ml4pg-tdl2 nil)
+(defvar ml4pg-tdl3 nil)
+(defvar ml4pg-tdl4 nil)
+(defvar ml4pg-tdl5 nil)
+
+(defun ml4pg-add-info-to-level-aux (info list)
+  (if (not list)
+      info
+    (do ((temp list (cdr temp))
+	 (temp1 info (cdr temp1))
+	 (temp2 nil))
+	((endp temp) temp2)
+	(cond ((= (car temp) 0) (setf temp2 (append temp2 (list (car temp1)))))
+	      ((= (car temp1) 0) (setf temp2 (append temp2 (list (car temp)))))
+	      (t (setf temp2 (append temp2 (list (string-to-number (format "%s%s" (car temp) (car temp1)))))))))))
+
+(defun ml4pg-add-info-to-level (info level)
+  (cond ((= level 1) (setf ml4pg-tdl1 (ml4pg-add-info-to-level-aux info ml4pg-tdl1)))
+	((= level 2) (setf ml4pg-tdl2 (ml4pg-add-info-to-level-aux info ml4pg-tdl2)))
+	((= level 3) (setf ml4pg-tdl3 (ml4pg-add-info-to-level-aux info ml4pg-tdl3)))
+	((= level 4) (setf ml4pg-tdl4 (ml4pg-add-info-to-level-aux info ml4pg-tdl4)))
+	((= level 5) (setf ml4pg-tdl5 (ml4pg-add-info-to-level-aux info ml4pg-tdl5)))
+	(t nil)
+  ))
+
+;;; Main function of this file, it is in charge of extracting the
+;;; information associated with a theorem 
+
+
+(defun ml4pg-export-theorem ()
+  (interactive)
+  (progn (setf ml4pg-tdl1 nil 
+	       ml4pg-tdl2 nil
+	       ml4pg-tdl3 nil
+	       ml4pg-tdl4 nil
+	       ml4pg-tdl5 nil
+	       ml4pg-move nil
+	       ml4pg-case nil
+	       ml4pg-elim nil
+	       ml4pg-apply nil
+	       ml4pg-apply/ nil
+	       ml4pg-move/ nil
+	       ml4pg-case/ nil
+	       ml4pg-rewrite nil
+	       ml4pg-exists nil
+	       ml4pg-done nil
+	       ml4pg-exact nil
+	       ml4pg-current-level 1
+	       ml4pg-dot-level nil
+	       ml4pg-hypothesis nil
+	       ml4pg-goal-level nil)
+	 (if (equal ml4pg-init 0)
+	     (progn (ml4pg-read-lemmas)
+		    (ml4pg-read-views)
+		    (setq ml4pg-init 1)))
+	 (ml4pg-export-theorem-aux nil nil)
+	 (proof-shell-invisible-cmd-get-result (format "Unset Printing All"))
+	   ))
+
+
+
+;; A function to obtain the type associated with an object
+
+(defun ml4pg-remove-jumps-aux (string res)
+  (let ((jump (search "
+" string)))
+    (if jump
+	(ml4pg-remove-jumps-aux (subseq string (1+ jump)) (concatenate 'string res (subseq string 0 jump)))
+      (concatenate 'string res string))))
+
+(defun ml4pg-remove-jumps (string)
+  (ml4pg-remove-jumps-aux string ""))
+
+
+(defun ml4pg-get-type-id (object)
+  (if (string= "(" (subseq object 0 1))
+      -4
+  (let* ((a (ml4pg-remove-jumps (proof-shell-invisible-cmd-get-result (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 
+      (progn (setf ml4pg-types_id
+		   (append ml4pg-types_id  (list (cons  (if pos_space
+						      (subseq a (+ 2 (search ": " a)) pos_space)
+						    (subseq a (+ 2 (search ": " a)) pos_jump))
+						  ml4pg-types_id_n))))
+	     
+	     (setf ml4pg-types_id_n (1- ml4pg-types_id_n))
+	     (1+ ml4pg-types_id_n))
+      ))))
+
+(defun ml4pg-get-type-id2 (object)
+  (let* ((a (proof-shell-invisible-cmd-get-result (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 
+      (progn (setf ml4pg-types_id
+		   (append ml4pg-types_id  (list (cons  (if pos_space
+						      (subseq a (+ 2 (search ": " a)) pos_space)
+						    (subseq a (+ 2 (search ": " a)) pos_jump))
+						  ml4pg-types_id_n))))
+	     
+	     (setf ml4pg-types_id_n (1- ml4pg-types_id_n))
+	     (1+ ml4pg-types_id_n))
+      )))
+
+
+;; 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 ((search "->" res2) 7)
+	  (t (let ((is (assoc fst-symbol ml4pg-top-symbol-id)))
+	       (if is
+		   (cdr is)
+		 (progn (setf ml4pg-top-symbol-id
+			      (append  ml4pg-top-symbol-id  (list (cons fst-symbol ml4pg-top-symbol-n))))
+			
+			(setf ml4pg-top-symbol-n (1+ ml4pg-top-symbol-n))
+			(1- ml4pg-top-symbol-n))))))))
+
+
+
+ 
+;; 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
+;; Sobra
+(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)
+    (if (search "_" (car list))
+	(ml4pg-get-types-list (cdr list) res)
+    (ml4pg-get-types-list (cdr list) (+ (* -1 (ml4pg-get-type-id (car list)) (expt 10 (- (length list) 1))) res)))))
+
+
+(defun ml4pg-get-types-list-exists (list res)
+  (if (endp list)
+      (* -1 res)
+    (ml4pg-get-types-list-exists (cdr list) (+ (* -1 (ml4pg-get-type-id2 (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)))))
+
+(defun ml4pg-get-number-list2 (list n)
+  (if (endp list)
+      0
+    (+ (* n (expt 10 (- (length list) 1)))  (ml4pg-get-number-list2 (cdr list) n))))
+
+;; To obtain the value associated with top symbol in the case of move
+
+(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 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)))))
+
+;;; Auxiliary functions 
+
+(defun ml4pg-remove=> (string)
+  (let ((d (search "=>" string)))
+    (if d
+	(ml4pg-remove=> (concatenate 'string (subseq string 0 d) (subseq string (+ 2 d))))
+      string)))
+
+
+(defun ml4pg-extract-views (list)
+  (do ((temp list (cdr temp))
+       (temp2 nil))
+      ((endp temp) temp2)
+      (if (and (string= (subseq (car temp) 0 1) "/") (not (string= (car temp) "//")) (not (string= (car temp) "/=")) (not (string= (car temp) "//=")))
+	  (if (not (string= (subseq (car temp) 0 2) "/("))
+	      (setf temp2 (append temp2 (list (subseq (car temp) 1))))
+	    (setf temp2 (append temp2 (list (subseq (car temp) 2 (search " " (car temp))))))))))
+
+
+(defun ml4pg-extract-real-params (list)
+  (do ((temp list (cdr temp))
+       (temp2 nil))
+      ((endp temp) temp2)
+      (if (not (or (string= (subseq (car temp) 0 1) "/") (string= (car temp) "//") (string= (car temp) "_") 
+		   (search "->" (car temp)) (search "<-" (car temp)) (string= (car temp) "/=") (string= (car temp) "//=")))
+	  (setf temp2 (append temp2 (list (car temp)))))))
+
+(defun ml4pg-extract-rewrites (list)
+  (do ((temp list (cdr temp))
+       (temp2 nil))
+      ((endp temp) temp2)
+      (if (or (search "->" (car temp)) (search "<-" (car temp)))
+	  (setf temp2 (append temp2 (list (car temp)))))))
+
+(defun ml4pg-extract-simplifications (list)
+  (do ((temp list (cdr temp))
+       (temp2 nil))
+      ((endp temp) temp2)
+      (if (or (string= (car temp) "//") (string= (car temp) "/=") (string= (car temp) "//="))
+	  (setf temp2 (append temp2 (list (car temp)))))))
+
+(defun ml4pg-compute-value-simpl (list)
+  (list 0 (length list) 0 0))
+
+
+(defun ml4pg-extract-views-id (list)
+  (do ((temp list (cdr temp))
+       (temp2 ""))
+      ((endp temp) temp2)
+      (if (assoc (car temp) ml4pg-views_id)
+	  (setf temp2 (concatenate 'string temp2 (format "%s" (cdr (assoc (car temp) ml4pg-views_id))) ))
+	(progn (setf ml4pg-start_view (+ ml4pg-start_view 1)) 
+	       (ml4pg-save-view (car temp) ml4pg-start_view)
+	       (setf ml4pg-views_id 
+		     (append ml4pg-views_id (list (cons (car temp) ml4pg-start_view))))
+	       (setf temp2 (concatenate 'string temp2 (format "%s" (cdr (assoc (car temp) ml4pg-views_id)))))))))
+
+
+
+(defun ml4pg-compute-values-rewrite-tactic (list)
+  (do ((temp (ml4pg-extract-real-params list) (cdr temp))
+       (temp2 ""))
+      ((endp temp) (string-to-number temp2))
+      (let* ((obj1 (if (string= "-" (subseq (car temp) 0 1)) (subseq (car temp) 1) (car temp)))
+	     (obj (if (string= "(" (subseq obj1 0 1)) (subseq obj1 1 (search " " obj1)) obj1)))
+      (if (assoc obj ml4pg-theorems_id)
+	  (setf temp2 (concatenate 'string temp2 (format "%s" (cdr (assoc obj ml4pg-theorems_id)))) )
+	(progn (setf ml4pg-start_thm (+ ml4pg-start_thm 1)) 
+	       (ml4pg-save-lemma obj ml4pg-start_thm)
+	       (setf ml4pg-theorems_id 
+		     (append ml4pg-theorems_id (list (cons obj ml4pg-start_thm))))
+	       (setf temp2 (concatenate 'string temp2 (format "%s" (cdr (assoc obj ml4pg-theorems_id))))))))))
+
+
+(defun ml4pg-compute-values-apply-tactic (list)
+  (do ((temp list (cdr temp))
+       (temp2 ""))
+      ((endp temp) (string-to-number temp2))
+      (let ((obj (if (string= "(" (subseq (car temp) 0 1)) (subseq (car temp) 1) (car temp))))
+	(if (member obj ml4pg-hypothesis)
+	    (setf temp2 (concatenate 'string temp2 "1"))
+	  (if (assoc obj ml4pg-theorems_id)
+	      (setf temp2 (concatenate 'string temp2 (format "%s" (cdr (assoc obj ml4pg-theorems_id)))) )
+	    (progn (setf ml4pg-start_thm (+ ml4pg-start_thm 1)) 
+		   (setf ml4pg-theorems_id 
+			 (append ml4pg-theorems_id (list (cons obj ml4pg-start_thm))))
+		   (setf temp2 (concatenate 'string temp2 (format "%s" (cdr (assoc obj ml4pg-theorems_id)))))))))))
+
+
+(defun ml4pg-compute-value-views-move (list)
+  (list (* -1 (ml4pg-get-number-list2 list 5)) (length list) (* -1 (ml4pg-get-number-list2 list 4)) (string-to-number (ml4pg-extract-views-id list))))
+
+(defun ml4pg-compute-value-views-apply (list)
+  (list  (ml4pg-get-number-list2 list 5) (length list) (* -1 (ml4pg-get-number-list2 list 4)) (string-to-number (ml4pg-extract-views-id list))))
+
+(defun ml4pg-compute-value-views-case (list)
+  (list  (ml4pg-get-number-list2 list 6) (length list) (* -1 (ml4pg-get-number-list2 list 4)) (string-to-number (ml4pg-extract-views-id list))))
+
+(defun ml4pg-compute-value-views-exact (list)
+  (list  (ml4pg-get-number-list2 list 9) (length list) (* -1 (ml4pg-get-number-list2 list 4)) (string-to-number (ml4pg-extract-views-id list))))
+
+(defun ml4pg-compute-value-rewrites (list)
+  (list (ml4pg-get-number-list2 list 7) (length list) (* -1 (ml4pg-get-number-list2 list 4)) (ml4pg-get-number-list list)))
+
+
+
+(defun ml4pg-remove-empties (list)
+  (do ((temp list (cdr temp))
+       (temp2 nil))
+      ((endp temp) temp2)
+      (if (not (string= (car temp) ""))
+	  (setf temp2 (append temp2 (list (car temp)))))))
+
+
+
+(defun ml4pg-occurrences (c string)
+  (do ((temp string)
+       (n 0))
+      ((not (search c temp)) n)
+      (progn (setf n (1+ n))
+	     (setf temp (subseq temp (1+ (search c temp)))))))
+       
+
+(defun ml4pg-put-together-parenthesis (list)
+  (do ((temp list (cdr temp))
+       (n 0)
+       (temp2 nil)
+       (aux ""))
+      ((endp temp) temp2)
+      (cond ((search "(" (car temp)) 
+	     (progn (setf n (1+ n))
+		    (setf aux (concatenate 'string aux (car temp) " "))))
+	    ((and (search ")" (car temp)) (not (= (- n (ml4pg-occurrences ")" (car temp))) 0)))
+	     (progn (setf n (- n (ml4pg-occurrences ")" (car temp))))
+		    (setf aux (concatenate 'string aux (car temp) " "))))
+	    ((search ")" (car temp))
+	     (progn (setf n (1- n))
+		    (setf aux (concatenate 'string aux (car temp)))
+		    (setf temp2 (append temp2 (list aux)))
+		    (setf aux "")))
+	    ((not (= n 0))
+	     (progn (setf aux (concatenate 'string aux (car temp) " "))))
+	    (t (setf temp2 (append temp2 (list (car temp))))
+	    ))))
+	    
+		     
+(defun ml4pg-remove-squared-parenthesis (string res)
+  (let ((pos1 (search "[" string))
+	(pos2 (search "{" string)))
+    (cond ((and pos1 pos2)
+	   (if (< pos1 pos2)
+	       (ml4pg-remove-squared-parenthesis
+		(subseq string (1+ (search "]" string :start2 pos1)))
+		(concatenate 'string res (subseq string 0 pos1)))
+	     (ml4pg-remove-squared-parenthesis
+	      (subseq string (1+ (search "}" string :start2 pos2)))
+	      (concatenate 'string res (subseq string 0 pos2)))))
+	  (pos1 (ml4pg-remove-squared-parenthesis
+		(subseq string (1+ (search "]" string :start2 pos1)))
+		(concatenate 'string res (subseq string 0 pos1))))
+	  (pos2 (ml4pg-remove-squared-parenthesis
+		 (subseq string (1+ (search "}" string :start2 pos2)))
+		 (concatenate 'string res (subseq string 0 pos2))))
+	  (t (concatenate 'string res string)))))
+
+
+(defun ml4pg-remove-iterations (string)
+  (do ((temp string)
+       (temp2 ""))
+      ((= (length temp) 0) temp2)
+      (if (or (string= (subseq temp 0 1) "!") (string= (subseq temp 0 1) "?"))
+	  (setf temp (subseq temp 1))
+	(progn (setf temp2 (concatenate 'string temp2 (subseq temp 0 1)))
+	       (setf temp (subseq temp 1))
+	       ))))
+
+
+      
+(defun ml4pg-remove-squared-parenthesis2 (string)
+  (do ((temp string)
+       (temp2 ""))
+      ((= (length temp) 0) temp2)
+      (if (or (string= (subseq temp 0 1) "[") (string= (subseq temp 0 1) "]") (string= (subseq temp 0 1) "|"))
+	  (setf temp (subseq temp 1))
+	(progn (setf temp2 (concatenate 'string temp2 (subseq temp 0 1)))
+	       (setf temp (subseq temp 1))
+	       ))))
+		
+	   
+(defun ml4pg-extract-params3 (cmd)
+ (let* ((res (ml4pg-extract-params2 (ml4pg-remove-iterations (ml4pg-remove-squared-parenthesis cmd "") ) nil))
+	(res1 (ml4pg-remove-empties res)))
+   (ml4pg-put-together-parenthesis res1)))
+
+
+(defun ml4pg-extract-params4 (cmd)
+ (let* ((res (ml4pg-extract-params2 (ml4pg-remove-squared-parenthesis2 cmd) nil))
+	(res1 (ml4pg-remove-empties res)))
+   (ml4pg-put-together-parenthesis res1)))
+
+
+
+;;; The following functions provide the numbers associated with a concrete tactic
+
+
+(defun ml4pg-numbers-move=> (cmd top level)
+  (let* ((params (ml4pg-extract-params3 (ml4pg-remove=> (subseq cmd (+ 2 (search "=>" cmd)))) ))
+	 (views (ml4pg-extract-views params))
+	 (simpl (ml4pg-extract-simplifications params))
+	 (rewrites (ml4pg-extract-rewrites params))
+	 (rewrites-nums (ml4pg-compute-value-rewrites rewrites))
+	 (simpl-nums (ml4pg-compute-value-simpl simpl))
+	 (views-nums (ml4pg-compute-value-views-move views))
+	 (real-params (ml4pg-extract-real-params params))
+	 (foo (setf ml4pg-hypothesis (append ml4pg-hypothesis real-params)))
+	 (types-params (ml4pg-get-types-list real-params 0))
+	 (foo3 (ml4pg-add-info-to-level (list (ml4pg-get-types-list real-params 0) 0 0 0 0 0 0 0 0 0 0 0 0) level))
+	 (foo2 (setf ml4pg-move (append ml4pg-move (list (list (ml4pg-get-types-list (if real-params (list (car real-params)) nil) 0)  (ml4pg-get-types-list (cdr real-params) 0)
+						   (* -1 (ml4pg-get-number-list real-params)) top))))))
+    (append (list (list (ml4pg-get-number-list2 real-params (cdr (assoc "move" ml4pg-tactic_id))) (length real-params) types-params (* -1 (ml4pg-get-number-list real-params))))
+	  (if simpl (list simpl-nums) nil)
+	  (if views (list views-nums) nil)
+	  (if rewrites (list rewrites-nums) nil))))
+
+(defun ml4pg-numbers-move/ (cmd top level)
+  (let* ((params (ml4pg-extract-params3 (ml4pg-remove=> (subseq cmd 4)) ))
+	 (views (ml4pg-extract-views params))
+	 (simpl (ml4pg-extract-simplifications params))
+	 (rewrites (ml4pg-extract-rewrites params))
+	 (rewrites-nums (ml4pg-compute-value-rewrites rewrites))
+	 (simpl-nums (ml4pg-compute-value-simpl simpl))
+	 (views-nums (ml4pg-compute-value-views-move views))
+	 (real-params (ml4pg-extract-real-params params))
+	 (foo (setf ml4pg-hypothesis (append ml4pg-hypothesis real-params)))
+	 (foo3 (ml4pg-add-info-to-level (list 0 0 0 0 0 (nth 2 views-nums) 0 0 0 0 0 0 0) level))
+	 (foo2 (setf ml4pg-move/ (append ml4pg-move/ (list (list -4  (* -4 (ml4pg-get-number-list real-params))  (nth 3 views-nums) top)))))
+	 (types-params (ml4pg-get-types-list real-params 0)))
+    (append (list views-nums) 
+	    (if real-params (list (list (ml4pg-get-number-list2 real-params (cdr (assoc "move" ml4pg-tactic_id))) (length real-params) types-params (* -1 (ml4pg-get-number-list real-params)))))
+	    (if simpl (list simpl-nums) nil)
+	    (if rewrites (list rewrites-nums) nil)))
+)
+
+(defun ml4pg-numbers-move: (cmd top level)
+  (let* ((params (ml4pg-extract-params3 (subseq cmd (+ 1 (search ":" cmd)))) )
+	 (views (ml4pg-extract-views params))
+	 (simpl (ml4pg-extract-simplifications params))
+	 (rewrites (ml4pg-extract-rewrites params))
+	 (rewrites-nums (ml4pg-compute-value-rewrites rewrites))
+	 (simpl-nums (ml4pg-compute-value-simpl simpl))
+	 (views-nums (ml4pg-compute-value-views-move views))
+	 (real-params (ml4pg-extract-real-params params))
+	 (types-params (ml4pg-get-types-list real-params 0))
+	 (foo3 (ml4pg-add-info-to-level (list (ml4pg-get-types-list real-params 0) 0 0 0 0 0 0 0 0 0 0 0 0) level))
+	 (foo2 (setf ml4pg-move (append ml4pg-move (list (list (ml4pg-get-types-list (if real-params (list (car real-params)) nil) 0)  (ml4pg-get-types-list (cdr real-params) 0)
+						   (* 1 (ml4pg-get-number-list real-params)) top))))))
+    (append (list (list (* -1 (ml4pg-get-number-list2 real-params (cdr (assoc "move" ml4pg-tactic_id)))) (length real-params) types-params (* -1 (ml4pg-get-number-list real-params))))
+	    (if views (list views-nums) nil)
+	    (if simpl (list simpl-nums) nil)
+	    (if rewrites (list rewrites-nums) nil)))
+
+)
+
+(defun ml4pg-numbers-move< (cmd top level)
+  (let* ((foo (list (ml4pg-compute-value-rewrites (list 1))))
+	 (foo3 (ml4pg-add-info-to-level (list 0 0 0 0 0 0 0 top 0 0 0 0 0) level))
+	 (foo2 (setf ml4pg-rewrite (append ml4pg-rewrite (list (list 4 0 1 top))))))
+    foo
+    )
+)
+
+(defun ml4pg-numbers-apply: (cmd top level)
+  (if (string= cmd "apply")
+      (list (list (cdr (assoc "apply" ml4pg-tactic_id)) 1 0 0))
+  (let ((moves (search "=>" cmd))
+	(foo3 (ml4pg-add-info-to-level (list 0 0 0 100 0 0 0 0 0 0 0 0 0) level))
+	(foo2 (setf ml4pg-apply (append ml4pg-apply (list (list -4  0 100 top))))))
+    (if (not moves)
+	(list (list (cdr (assoc "apply" ml4pg-tactic_id))
+	      1 
+	      -4
+	      (ml4pg-compute-values-apply-tactic (ml4pg-extract-real-params (ml4pg-extract-params3 (subseq cmd (+ 1 (if (search ":" cmd) (search ":" cmd) (search " " cmd)))))))))
+      (let* ((args0 (ml4pg-extract-params4 (subseq cmd (+ 2 moves))))
+	    (simpl (ml4pg-extract-simplifications args0))
+	    (simpl-nums (ml4pg-compute-value-simpl simpl))
+	    (args (ml4pg-extract-real-params args0))
+	    )
+      (append (list (list (cdr (assoc "apply" ml4pg-tactic_id))
+			  1 -4 
+			  (ml4pg-compute-values-apply-tactic (ml4pg-extract-real-params (ml4pg-extract-params3 (subseq cmd (+ 1 (if (search ":" cmd) (search ":" cmd) (search " " cmd))) moves))))
+			  ))
+	      (list (list (* -1 (ml4pg-get-number-list2 args (cdr (assoc "move" ml4pg-tactic_id)))) (length args) (ml4pg-get-types-list args 0) (* -1 (ml4pg-get-number-list args))))
+	      (if simpl (list simpl-nums) nil)))))
+))
+
+(defun ml4pg-numbers-elim (cmd top level)
+  (let* ((moves (search "=>" cmd))
+	 (foo3 (ml4pg-add-info-to-level (list 0 0 (ml4pg-get-types-list (list (car (ml4pg-extract-real-params (ml4pg-extract-params3 (subseq cmd (+ 1 (search ":" cmd)) moves))))) 0) 0 0 0 0 0 0 0 0 0 0) level))
+	(foo2 (setf ml4pg-elim (append ml4pg-elim (list (list (ml4pg-get-types-list (list (car (ml4pg-extract-real-params (ml4pg-extract-params3 (subseq cmd (+ 1 (search ":" cmd)) moves))))) 0)  0 -1 top))))))
+    (if (not moves)
+	(list (list (cdr (assoc "elim" ml4pg-tactic_id))
+	      1 (ml4pg-get-types-list (ml4pg-extract-real-params (ml4pg-extract-params3 (subseq cmd (+ 1 (search ":" cmd))))) 0) -1))
+      (let* ((args0 (ml4pg-extract-params4 (subseq cmd (+ 2 moves))))
+	    (simpl (ml4pg-extract-simplifications args0))
+	    (simpl-nums (ml4pg-compute-value-simpl simpl))
+	    (args (ml4pg-extract-real-params args0)))
+      (append (list (list (cdr (assoc "elim" ml4pg-tactic_id))
+			  1 (ml4pg-get-types-list (ml4pg-extract-real-params (ml4pg-extract-params3 (subseq cmd (+ 1 (search ":" cmd)) moves))) 0) -1))
+	      (list (list (* -1 (ml4pg-get-number-list2 args (cdr (assoc "move" ml4pg-tactic_id)))) (length args) (ml4pg-get-types-list args 0) (* -1 (ml4pg-get-number-list args))))
+	      (if simpl (list simpl-nums) nil))))))
+
+(defun ml4pg-numbers-case (cmd top level)
+  (if (string= cmd "case")
+      (list (list (cdr (assoc "case" ml4pg-tactic_id)) 1 0 0))
+  (let ((moves (search "=>" cmd))
+	(foo3 (ml4pg-add-info-to-level (list 0 (if (ml4pg-extract-real-params (ml4pg-extract-params3 (if (search ":" cmd) (subseq cmd (+ 1 (search ":" cmd))) (subseq cmd (+ 1 (search " " cmd))))))
+						   (ml4pg-get-types-list (list (car (ml4pg-extract-real-params (ml4pg-extract-params3 (if (search ":" cmd) (subseq cmd (+ 1 (search ":" cmd))) (subseq cmd (+ 1 (search " " cmd)))))))) 0) 1) 0 0 0 0 0 0 0 0 0 0 0) level))
+	(foo2 (setf ml4pg-case (append ml4pg-case (list (list (if (ml4pg-extract-real-params (ml4pg-extract-params3 (if (search ":" cmd) (subseq cmd (+ 1 (search ":" cmd))) (subseq cmd (+ 1 (search " " cmd))))))
+						      (ml4pg-get-types-list (list (car (ml4pg-extract-real-params (ml4pg-extract-params3 (if (search ":" cmd) (subseq cmd (+ 1 (search ":" cmd))) (subseq cmd (+ 1 (search " " cmd)))))))) 0) 1)
+  0 -1 top))))))
+    (if (not moves)
+	(list (list (cdr (assoc "case" ml4pg-tactic_id))
+	      1 (ml4pg-get-types-list (ml4pg-extract-real-params (ml4pg-extract-params3 (if (search ":" cmd) (subseq cmd (+ 1 (search ":" cmd))) (subseq cmd (+ 1 (search " " cmd)))))) 0) -1))
+      (let* ((args0 (ml4pg-extract-params4 (subseq cmd (+ 2 moves))))
+	    (simpl (ml4pg-extract-simplifications args0))
+	    (simpl-nums (ml4pg-compute-value-simpl simpl))
+	    (args (ml4pg-extract-real-params args0)))
+	(if (ml4pg-extract-params3 (if (search ":" cmd) (subseq cmd (+ 1 (search ":" cmd))) (subseq cmd (+ 1 (search " " cmd)))))
+	    (append (list (list (cdr (assoc "case" ml4pg-tactic_id))
+				1 (ml4pg-get-types-list (ml4pg-extract-real-params (ml4pg-extract-params3 (if (search ":" cmd) (subseq cmd (+ 1 (search ":" cmd))) (subseq cmd (+ 1 (search " " cmd)))))) 0) -1))
+		    (list (list (* -1 (ml4pg-get-number-list2 args (cdr (assoc "move" ml4pg-tactic_id)))) (length args) (ml4pg-get-types-list args 0) (* -1 (ml4pg-get-number-list args))))
+		    (if simpl (list simpl-nums) nil))
+	  (append (list (list (cdr (assoc "case" ml4pg-tactic_id))
+				1 0 0))
+		    (list (list (* -1 (ml4pg-get-number-list2 args (cdr (assoc "move" ml4pg-tactic_id)))) (length args) (ml4pg-get-types-list args 0) (* -1 (ml4pg-get-number-list args))))
+		    (if simpl (list simpl-nums) nil))))))))
+
+(defun ml4pg-numbers-case/ (cmd top level)
+  (let* ((params (ml4pg-extract-params4 (ml4pg-separate-/ (ml4pg-remove=> (subseq cmd 5)) "")))
+	 (views (ml4pg-extract-views params))
+	 (simpl (ml4pg-extract-simplifications params))
+	 (rewrites (ml4pg-extract-rewrites params))
+	 (rewrites-nums (ml4pg-compute-value-rewrites rewrites))
+	 (simpl-nums (ml4pg-compute-value-simpl simpl))
+	 (views-nums (ml4pg-compute-value-views-case views))
+	 (real-params (ml4pg-extract-real-params params))
+	 (foo (setf ml4pg-hypothesis (append ml4pg-hypothesis real-params)))
+	 (types-params (ml4pg-get-types-list real-params 0))
+	 (foo3 (ml4pg-add-info-to-level (list 0 0 0 0 0 0 (nth 2 views-nums) 0 0 0 0 0 0) level))
+	 (foo2 (setf ml4pg-case/ (append ml4pg-case/ (list (list -4  (/ (nth 2 views-nums) 10)  (nth 3 views-nums) top))))))
+    (append (list views-nums)
+	    (if real-params (list (list (ml4pg-get-number-list2 real-params (cdr (assoc "move" ml4pg-tactic_id))) (length real-params) types-params (* -1 (ml4pg-get-number-list real-params)))))
+	    (if simpl (list simpl-nums) nil)
+	    (if rewrites (list rewrites-nums) nil)))
+)
+
+(defun ml4pg-separate-/ (string res)
+  (let ((pos (search "/" string)))
+    (if (not pos)
+	(concatenate 'string res string)
+      (cond ((= pos 0) (ml4pg-separate-/ (subseq string (1+ pos)) (concatenate 'string "/" res (subseq string 0 pos))))
+	    ((not (string= " " (subseq string (1- pos) pos))) 
+	     (ml4pg-separate-/ (subseq string (1+ pos)) (concatenate 'string res (subseq string 0 pos) " /")))
+	    (t (ml4pg-separate-/ (subseq string (1+ pos)) (concatenate 'string res (subseq string 0 pos))))))))
+     
+
+(defun ml4pg-numbers-apply/ (cmd top level)
+  (let* ((params (ml4pg-extract-params4 (ml4pg-separate-/ (ml4pg-remove=> (subseq cmd 5)) "")))
+	 (views (ml4pg-extract-views params))
+	 (simpl (ml4pg-extract-simplifications params))
+	 (rewrites (ml4pg-extract-rewrites params))
+	 (rewrites-nums (ml4pg-compute-value-rewrites rewrites))
+	 (simpl-nums (ml4pg-compute-value-simpl simpl))
+	 (views-nums (ml4pg-compute-value-views-apply views))
+	 (real-params (ml4pg-extract-real-params params))
+	 (foo (setf ml4pg-hypothesis (append ml4pg-hypothesis real-params)))
+	 (types-params (ml4pg-get-types-list real-params 0))
+	 (foo3 (ml4pg-add-info-to-level (list 0 0 0 0 (nth 2 views-nums) 0 0 0 0 0 0 0 0) level))
+	 (foo2 (setf ml4pg-apply/ (append ml4pg-apply/ (list (list -4  (/ (nth 2 views-nums) 10)  (nth 3 views-nums) top))))))
+    (append (list views-nums)
+	    (if real-params (list (list (ml4pg-get-number-list2 real-params (cdr (assoc "move" ml4pg-tactic_id))) (length real-params) types-params (* -1 (ml4pg-get-number-list real-params)))))
+	    (if simpl (list simpl-nums) nil)
+	    (if rewrites (list rewrites-nums) nil)))
+)
+
+(defun ml4pg-numbers-exact (cmd top level)
+  (if (string= cmd "exact")
+      (list (list (cdr (assoc "exact" ml4pg-tactic_id)) 1 0 0))
+  (let* ((params (ml4pg-extract-params3 (cond ((search ":" cmd) (subseq cmd (+ 1 (search ":" cmd))))
+					((search "/" cmd) (subseq cmd (search "/" cmd)))
+					(t (subseq cmd (+ 1 (search " " cmd)))))))
+	(views (ml4pg-extract-views params))
+	(views-nums (ml4pg-compute-value-views-exact views))
+	(foo3 (ml4pg-add-info-to-level (list 0 0 0 0 0 0 0 0 0 0 100 0 0) level))
+	(foo2 (setf ml4pg-exact (append ml4pg-exact (list (list -4  0 100 top))))))
+    (if views 
+	(list views-nums)
+    (list (list (cdr (assoc "exact" ml4pg-tactic_id))
+	      1 
+	      -4
+	      (ml4pg-compute-values-apply-tactic (ml4pg-extract-real-params params))))))))
+
+(defun ml4pg-numbers-rewrite (cmd top level)
+  (let* ((params (ml4pg-extract-params3 (subseq cmd (+ 1 (search " " cmd)))) )
+	 (views (ml4pg-extract-views params))
+	 (simpl (ml4pg-extract-simplifications params))
+	 (simpl-nums (ml4pg-compute-value-simpl simpl))
+	 (views-nums (ml4pg-compute-value-views-move views))
+	 (foo3 (ml4pg-add-info-to-level (list 0 0 0 0 0 0 0 (ml4pg-get-number-list2 (cdr params) 4) 0 0 0 0 0) level))
+	 (foo2 (setf ml4pg-rewrite (append ml4pg-rewrite (list (list -4  (ml4pg-get-number-list2 (cdr params) 4) (ml4pg-compute-values-rewrite-tactic params) top))))))
+    (append (list (list (ml4pg-get-number-list2 params (cdr (assoc "rewrite" ml4pg-tactic_id)))
+			(length params)
+			(ml4pg-get-number-list2 params 4)
+			(ml4pg-compute-values-rewrite-tactic params)))
+	    (if simpl (list simpl-nums) nil)
+	    ))  
+)
+
+(defun ml4pg-numbers-exists (cmd top level)
+  (let ((moves (search "=>" cmd))
+	(foo3 (ml4pg-add-info-to-level (list 0 0 0 0 0 0 0 0 1 0 0 0 0) level))
+	(foo2 (setf ml4pg-exists (append ml4pg-exists (list (list 8 0 1 top))))))
+    (if (not moves)
+	(let* ((params (ml4pg-extract-params3 (subseq cmd 7)) )
+	       (types-params (ml4pg-get-types-list-exists params 0))
+	       )
+	  (list (list (cdr (assoc "exists" ml4pg-tactic_id)) 1 types-params 0)))
+      (let* ((args0 (ml4pg-extract-params4 (subseq cmd (+ 2 moves))))
+	    (simpl (ml4pg-extract-simplifications args0))
+	    (simpl-nums (cml4pg-ompute-value-simpl simpl))
+	    (args (ml4pg-extract-real-params args0)))
+      (append (list (list (cdr (assoc "exists" ml4pg-tactic_id))
+			  1 (ml4pg-get-types-list-exists  (ml4pg-extract-params3 (subseq cmd 7 moves)) 0) -1))
+	      (list (list (* -1 (ml4pg-get-number-list2 args (cdr (assoc "move" ml4pg-tactic_id)))) (length args) (ml4pg-get-types-list args 0) (* -1 (ml4pg-get-number-list args))))
+	      (if simpl (list simpl-nums) nil)))))
+  )
+    
+
+(defun ml4pg-numbers-done (cmd top level)
+  (progn 
+    (ml4pg-add-info-to-level (list 0 0 0 0 0 0 0 0 0 top 0 0 0) level)
+    (setf ml4pg-done (append ml4pg-done (list (list 0 0 0 top))))
+    (list (list (cdr (assoc "[]" ml4pg-tactic_id)) 1 0 0) ) )
+)
+
+
+(defun ml4pg-remove-multiple-spaces (string)
+  (let ((d (search "  " string)))
+    (if d
+	(ml4pg-remove-multiple-spaces (concatenate 'string (subseq string 0 d) (subseq string (1+ d))))
+      string)))
+  
+
+
+(defun ml4pg-compute-numbers-cmd (cmd top level)
+  (let* ((cmd1 (ml4pg-remove-multiple-spaces cmd)))
+    (cond ((search "symmetry" cmd) nil)	  
+	  ((search "last by" cmd) (ml4pg-compute-numbers-cmd (subseq cmd (+ 3 (search "by" cmd))) top level))
+	  ((search "first by" cmd) (ml4pg-compute-numbers-cmd (subseq cmd (+ 3 (search "by" cmd))) top level))
+	  ((string= "try" (subseq cmd 0 2)) (ml4pg-compute-numbers-cmd (subseq cmd (+ 4 (search "try" cmd))) top level))
+	  ((string= "do" (subseq cmd 0 2)) (ml4pg-compute-numbers-cmd (subseq cmd (cond ((search "!" cmd) (1+ (search "!" cmd)))
+								    ((search "?" cmd) (1+ (search "?" cmd)))
+								    (t (+ 3 (search "do" cmd))))) top level)) 
+	  ((search "have" cmd) nil)
+	  ((or (search "move=>" cmd1) (search "move =>" cmd1)) (ml4pg-numbers-move=> cmd1 top level))
+	  ((or (search "move:" cmd1) (search "move :" cmd1)) (ml4pg-numbers-move: cmd1 top level))
+	  ((or (search "move/" cmd1) (search "move /" cmd1)) (ml4pg-numbers-move/ cmd1 top level))
+	  ((or (search "move<-" cmd1) (search "move->" cmd1) (search "move ->" cmd1) (search "move <-" cmd1)) (ml4pg-numbers-move< cmd1 top level))
+	  ((or (search "apply/" cmd1) (search "apply /" cmd1)) (ml4pg-numbers-apply/ cmd1 top level))
+	  ((or (search "apply:" cmd1) (search "apply :" cmd1) (search "apply" cmd1)) (ml4pg-numbers-apply: cmd1 top level))
+	  ((or (search "elim:" cmd1) (search "elim :" cmd1)) (ml4pg-numbers-elim cmd1 top level))
+	  ((or (search "case/" cmd1) (search "case /" cmd1)) (ml4pg-numbers-case/ cmd1 top level))
+	  ((or (search "case:" cmd1) (search "case" cmd1)) (ml4pg-numbers-case cmd1 top level))
+	  ((or (search "exact" cmd1) (search "exact :" cmd1)) (ml4pg-numbers-exact cmd1 top level))
+	  ((search "rewrite" cmd1) (ml4pg-numbers-rewrite cmd1 top level))
+	  ((search "exists" cmd1) (ml4pg-numbers-exists cmd1 top level))
+	  ((or (search "[]" cmd1) (search "done" cmd1) (search "constructor" cmd1)) (ml4pg-numbers-done cmd1 top level))
+	  
+	  ((string= (subseq cmd1 0 4) "pose") nil)
+	  ((string= (subseq cmd1 0 3) "set") nil)
+	  ((string= (subseq cmd1 0 4) "left") nil)
+	  ((string= (subseq cmd1 0 4) "righ") nil)
+	  )
+    )  
+  ) 
+
+
+(defun ml4pg-split-command (cmd result end)
+  (if (or (string= " " (subseq cmd 0 1)) (string= "-" (subseq cmd 0 1)))
+	  (ml4pg-split-command (subseq cmd 1) result end)
+  (let ((is_by (string= "by" (subseq cmd 0 2))))
+    (if is_by
+	(ml4pg-split-command (subseq cmd 3) result 1)
+      (let ((comma (search ";" cmd)))
+	(if comma
+	    (ml4pg-split-command (subseq cmd (1+ comma)) (append result (list (subseq cmd 0 comma))) end)
+	  (list (append result (list (subseq cmd 0 (1- (length cmd))))) end)))))))
+
+
+    
+     
+(defun ml4pg-add-tactics (tactics end top level)
+  (do ((temp tactics (cdr temp))
+       (temp2 nil))
+      ((endp temp) (if (> end 0) (append temp2 (list (list 0 1 0 0))) temp2))
+      (let ((res (ml4pg-compute-numbers-cmd (car temp) top level)))
+	(if res (setf temp2 (append temp2 res))))))
+
+
+;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 top level)
+  (let* ((res (ml4pg-split-command cmd nil 0))
+	 (tactics (car res))
+	 (end (cadr res))
+	 (nums (ml4pg-add-tactics tactics end top level)))
+    (if nums (do ((temp (cdr nums) (cdr temp))
+	 (temp2 (list (format "%s" (nth 0 (car nums))) (nth 1 (car nums))   (format "%s" (nth 2 (car nums))) (format "%s" (nth 3 (car nums))))))
+	((endp temp) (list (string-to-number (nth 0 temp2)) (nth 1 temp2)  (string-to-number (nth 2 temp2)) (string-to-number (nth 3 temp2))) )
+	(setf temp2 (list (if (or (< (string-to-number(nth 0 temp2)) 0) (< (nth 0 (car temp)) 0))
+			      (concatenate 'string (format "-%s" (abs (string-to-number(nth 0 temp2)))) (format "%s" (abs (nth 0 (car temp)))))
+			    (concatenate 'string (format "%s" (abs (string-to-number(nth 0 temp2))) ) (format "%s" (abs (nth 0 (car temp))))))
+			  (+ (nth 1 temp2) (nth 1 (car temp)))
+			  (if (or (< (abs (string-to-number(nth 2 temp2))) 0) (< (nth 2 (car temp)) 0))
+			      (concatenate 'string (format "-%s" (abs (abs (string-to-number(nth 2 temp2))))) (format "%s" (abs (nth 2 (car temp)))))
+			    (concatenate 'string (format "%s" (abs (abs (string-to-number(nth 2 temp2))))) (format "%s" (abs (nth 2 (car temp))))))
+			  (if (or (< (string-to-number (nth 3 temp2)) 0) (< (nth 3 (car temp)) 0))
+			      (concatenate 'string (format "-%s" (abs (string-to-number (nth 3 temp2)))) (format "%s" (abs (nth 3 (car temp)))))
+			    (concatenate 'string (format "%s" (abs (string-to-number (nth 3 temp2)))) (format "%s" (abs (nth 3 (car temp))))))
+			 ))
+	)
+    )))
+
+;; Function to obtain the information just about the goals. 
+
+(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 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))))
+      )
+  ))
+
+
+
+
+(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" "Print"))
+
+(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-compute-tactic-value (list)
+  (if (not list) (list 0 0 0 0 0)
+  (let ((len (length list))
+	(arg0 (car (car list)))
+	(arg1 (format "%s" (nth 1 (car list))))
+	(hyp (format "%s" (nth 2 (car list))))
+	(top (format "%s" (nth 3 (car list)))))
+    (do ((temp (cdr list) (cdr temp)))
+	((endp temp) (list arg0 (string-to-number arg1) (string-to-number hyp) (string-to-number top) len))
+	(progn (setf arg1 (format "%s%s%s" arg1 (nth 0 (car temp)) (nth 1 (car temp))))
+	       (setf hyp (format "%s%s" hyp (nth 2 (car temp))))
+	       (setf top (format "%s%s" top (nth 3 (car temp))))
+	      )))))
+
+
+
+(defun ml4pg-compute-tactic-result (name)
+  (append (list name) (list (append
+	(ml4pg-compute-tactic-value ml4pg-move)
+	(ml4pg-compute-tactic-value ml4pg-case)
+	(ml4pg-compute-tactic-value ml4pg-elim)
+	(ml4pg-compute-tactic-value ml4pg-apply/)
+	(ml4pg-compute-tactic-value ml4pg-move/)
+	(ml4pg-compute-tactic-value ml4pg-case/)
+	(ml4pg-compute-tactic-value ml4pg-rewrite)
+	(ml4pg-compute-tactic-value ml4pg-exists)
+	(ml4pg-compute-tactic-value ml4pg-done)
+	(ml4pg-compute-tactic-value ml4pg-exact)))))
+	 
+(defun ml4pg-compute-proof-tree-result (name)
+  (append (list name) (list (append
+	(if ml4pg-tdl1 ml4pg-tdl1 (ml4pg-generate-zeros 13))
+	(if ml4pg-tdl2 ml4pg-tdl2 (ml4pg-generate-zeros 13))
+	(if ml4pg-tdl3 ml4pg-tdl3 (ml4pg-generate-zeros 13))
+	(if ml4pg-tdl4 ml4pg-tdl4 (ml4pg-generate-zeros 13))
+	(if ml4pg-tdl5 ml4pg-tdl5 (ml4pg-generate-zeros 13))))))
+	
+
+
+
+
+(defun ml4pg-export-theorem-aux (result name)
+  (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)))
+	  ((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))))
+				      )))
+	  ((search "Proof" cmd)
+	   (progn (proof-assert-next-command-interactive)
+		  (ml4pg-export-theorem-aux result name )))
+	  ((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))))
+				     )))
+	  ((search "Qed." cmd)
+	   (progn (proof-assert-next-command-interactive)
+		  ; (insert (format "\n(* %s *)\n" (reverse result)))
+		  ;(setf proof-tree-level (append proof-tree-level (list (compute-proof-result)))) 
+		  ;(setf tactic-level (append tactic-level (list (compute-tactic-result))))
+		  (setf ml4pg-tactic-level (append ml4pg-tactic-level (list (ml4pg-compute-tactic-result name))))
+		  (setf ml4pg-proof-tree-level (append ml4pg-proof-tree-level (list (ml4pg-compute-proof-tree-result name))))
+		  (if name
+		   ;   (split-feature-vector name (flat (reverse result)))
+		      (setf ml4pg-saved-theorems (append ml4pg-saved-theorems 
+					       (list (list name (ml4pg-flat (reverse result))))))
+		      )))
+	  (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))
+		    (ml4pg-export-theorem-aux (cons (append (ml4pg-get-numbers cmd ts ml4pg-current-level) (list ts) (list ng2)) result)
+				       name)
+		    (ml4pg-add-info-to-level (list 0 0 0 0 0 0 0 0 0 0 0 ng2 (if (< ng2 ng) 1 0)) ml4pg-current-level)
+		    (setf ml4pg-current-level (1+ ml4pg-current-level))
+		    
+		    ))))))
+     
+
+
+
+(defun ml4pg-split-feature-vector (name fv)
+  (let ((len (1+ (floor (length fv) 30))))
+    (do ((i 0 (+ i 1)))
+	((equal i len) nil)
+	(setf ml4pg-saved-theorems (append ml4pg-saved-theorems 
+				     (list (list name (ml4pg-take-30-from fv i))))))
+    ))
+
+
+(defun ml4pg-take-30-from (list pos)
+  (let ((j (* 30 pos)))
+  (do ((i j (1+ i))
+       (temp2 nil (if (nth i list) (cons (nth i list) temp2) (cons 0 temp2))))
+      ((= i (+ j 30)) (reverse temp2)))))
+
+
+
+
+;;; 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 "_tactics.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 (ml4pg-remove_last_colon (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-last-part-of-lists (list)
+  (do ((temp list (cdr temp))
+       (temp2 nil))
+      ((endp temp) temp2)
+      (setf temp2 (append temp2 (list (cadar temp))))))
+
+
+
+
+(defun ml4pg-extract-features-1 ()
+  (let ((fm (ml4pg-find-max-length)))
+    (do ((temp (ml4pg-last-part-of-lists ml4pg-saved-theorems) (cdr temp))
+	 (temp2 ""))
+	((endp temp) temp2)
+	(setf temp2 (concat temp2 
+			      (format "%s\n"
+				      (ml4pg-print-list  (ml4pg-take-30 (append (car temp) 
+								   (ml4pg-generate-zeros 30))) ))))
+      )
+    ))
+
+
+
+
+
+
+(defun ml4pg-extract-features-2 (list)
+  (do ((temp (ml4pg-last-part-of-lists (cdr 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
+
+(defvar ml4pg-tactic-temp nil)
+(defvar ml4pg-proof-tree-temp nil)
+
+(defun ml4pg-extract-info-up-to-here ()
+  (interactive)
+  (setf ml4pg-move nil
+	ml4pg-case nil
+	ml4pg-elim nil
+	ml4pg-apply nil
+	ml4pg-apply/ nil
+	ml4pg-move/ nil
+	ml4pg-case/ nil
+	ml4pg-rewrite nil
+	ml4pg-exists nil
+	ml4pg-done nil
+	ml4pg-exact nil
+	ml4pg-tactic-temp nil
+	ml4pg-tdl1 nil 
+	ml4pg-tdl2 nil
+	ml4pg-tdl3 nil
+	ml4pg-tdl4 nil
+	ml4pg-tdl5 nil
+	ml4pg-current-level 1
+	ml4pg-dot-level nil)
+  (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 (ml4pg-get-number-of-goals))
+	       (if cmd 
+	       (setf result (cons (append (ml4pg-get-numbers cmd ts ml4pg-current-level) (list ts) (list ng2)) result)))
+	       (ml4pg-add-info-to-level (list 0 0 0 0 0 0 0 0 0 0 0 ng2 (if (< ng2 ng) 1 0)) ml4pg-current-level)
+	       (setf ml4pg-current-level (1+ ml4pg-current-level))
+		    )
+	  
+	)	
+    )
+    (setf ml4pg-tactic-temp (cadr (ml4pg-compute-tactic-result "")))
+    (setf ml4pg-proof-tree-temp (cadr (ml4pg-compute-proof-tree-result "")))
+    (ml4pg-take-30 (append (ml4pg-flat (reverse result)) (ml4pg-generate-zeros 30) ))
+    (proof-shell-invisible-cmd-get-result (format "Unset Printing All"))
+  ))
+
+
+
+(defun ml4pg-extract-features-1-bis (thm)
+  (let ((fm (ml4pg-find-max-length)))
+    (do ((temp (append (ml4pg-last-part-of-lists ml4pg-saved-theorems) (list thm)) (cdr temp))
+	 (temp2 ""))
+	((endp temp) temp2)
+	(setf temp2 (concat temp2 
+			      (format "%s\n"
+				      (ml4pg-print-list (ml4pg-take-30 (append (car temp) 
+								   (ml4pg-generate-zeros 30))) ))))
+      )
+    ))
+
+
+(defun ml4pg-extract-features-2-bis (thm list)
+  (let ((fm (find-max-length)))
+    (do ((temp (append (ml4pg-last-part-of-lists (cdr list)) (list thm)) (cdr temp))
+	 (temp2 ""))
+	((endp temp) temp2)
+	(setf temp2 (concat temp2 
+			      (format "%s\n"
+				      (ml4pg-print-list (car 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)))
+    )
+  
+  )
+    
+
+
+;;; Function to normalize the results
+
+(defun ml4pg-max-two-lists (list1 list2)
+  (do ((temp1 (ml4pg-take-30 (append list1 (ml4pg-generate-zeros 24))) (cdr temp1))
+       (temp2 (ml4pg-take-30 (append list2 (ml4pg-generate-zeros 24))) (cdr temp2))
+       (temp nil))
+      ((endp temp1) temp)
+      (if (< (car temp1) (car temp2))
+	  (setf temp (append temp (list (car temp2))))
+	(setf temp (append temp (list (car temp1))))
+	)))
+
+(defun ml4pg-min-two-lists (list1 list2)
+  (do ((temp1 (ml4pg-take-30 (append list1 (ml4pg-generate-zeros 24))) (cdr temp1))
+       (temp2 (ml4pg-take-30 (append list2 (ml4pg-generate-zeros 24))) (cdr temp2))
+       (temp nil))
+      ((endp temp1) temp)
+      (if (> (car temp1) (car temp2))
+	  (setf temp (append temp (list (car temp2))))
+	(setf temp (append temp (list (car temp1))))
+	)))
+
+(defun ml4pg-max-position (list )
+  (do ((temp list (cdr temp))
+       (max (ml4pg-generate-zeros (length (car list)))))
+      ((endp temp) max)
+      (setf max (ml4pg-max-two-lists max (car temp)))))
+
+(defun ml4pg-min-position (list )
+  (do ((temp list (cdr temp))
+       (min (ml4pg-generate-zeros (length (car list)))))
+      ((endp temp) min)
+      (setf min (ml4pg-min-two-lists min (car temp)))))
+
+
+(defun ml4pg-normalize-list (list max min)
+  (do ((temp (ml4pg-take-30 (append list (ml4pg-generate-zeros 24))) (cdr temp))
+       (temp-max max (cdr temp-max))
+       (temp-min min (cdr temp-min))
+       (temp2 nil))
+      ((endp temp) temp2)
+      (cond ((< 0 (car temp)) (setf temp2 (append temp2 (list (/ (+ (car temp) .0) (car temp-max))))))
+	    ((= 0 (car temp)) (setf temp2 (append temp2 (list 0))))
+	    (t (setf temp2 (append temp2 (list (- (/ (+ (car temp) .0) (car temp-min))))))))))
+
+(defun ml4pg-normalize (list)
+  
+  (let ((max (ml4pg-max-position list))
+	(min (ml4pg-min-position list)))
+   (do ((temp list (cdr temp))
+	 (temp2 nil))
+	((endp temp) temp2)
+	(setf temp2 (append temp2 (list (ml4pg-normalize-list (car temp) max min)))))))
+
+
+
+
+
+
+ 
+    
diff --git a/contrib/ML4PG/ssreflect/lemmas.txt b/contrib/ML4PG/ssreflect/lemmas.txt
new file mode 100644
index 00000000..c818e3b0
--- /dev/null
+++ b/contrib/ML4PG/ssreflect/lemmas.txt
@@ -0,0 +1,44 @@
+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/ssreflect/matlab_interaction.el b/contrib/ML4PG/ssreflect/matlab_interaction.el
new file mode 100644
index 00000000..6aab9def
--- /dev/null
+++ b/contrib/ML4PG/ssreflect/matlab_interaction.el
@@ -0,0 +1,646 @@
+;; 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 ml4pg-signal 1) (ml4pg-print-similarities (ml4pg-split-clusters-aux2 ml4pg-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-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 (ml4pg-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+ 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 ml4pg-times (1+ ml4pg-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 ml4pg-times (1+ ml4pg-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-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-freq (ml4pg-extract_clusters_freq (read-lines (expand-file-name "matlab_res.txt"))))
+	  (clu (car clu-freq))
+	  (freq (cadr clu-freq))
+	  (temp0 (ml4pg-unzip (ml4pg-quicksort-pair (ml4pg-zip clu 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 (ml4pg-cluster-string-to-list (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-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 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 ml4pg-tactic-temp ml4pg-tactic-level)))
+							((string= ml4pg-level "p") (insert (ml4pg-extract-features-2-bis ml4pg-proof-tree-temp ml4pg-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 ml4pg-tactic-level)))
+								     ((string= ml4pg-level "p") (insert (ml4pg-extract-features-2 ml4pg-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/ssreflect/" (car temp) ".csv >> " (expand-file-name "temp1.csv"))))
+	    ((string= ml4pg-level "t") (shell-command  (concat "cat " ml4pg-home-dir "libs/ssreflect/" (car temp) "_tactics.csv >> " (expand-file-name "temp1.csv"))))
+	    ((string= ml4pg-level "p") (shell-command  (concat "cat " ml4pg-home-dir "libs/ssreflect/" (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/ssreflect/" (car temp) ".csv >> " (expand-file-name "temp.csv"))))
+	    ((string= ml4pg-level "t") (shell-command  (concat "cat " ml4pg-home-dir "libs/ssreflect/" (car temp) "_tactics.csv >> " (expand-file-name "temp.csv"))))
+	    ((string= ml4pg-level "p") (shell-command  (concat "cat " ml4pg-home-dir "libs/ssreflect/" (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/ssreflect/" (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/ssreflect/menus.el b/contrib/ML4PG/ssreflect/menus.el
new file mode 100644
index 00000000..226c1212
--- /dev/null
+++ b/contrib/ML4PG/ssreflect/menus.el
@@ -0,0 +1,308 @@
+;;; The menu interaction
+
+(easy-menu-define ml4pg-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"]
+       ["Gaussian" (ml4pg-change-algorithm "g")
+	:selected (string= ml4pg-algorithm "g")
+	:style toggle
+	:active (string= ml4pg-ml-system "m")
+	:help "Use Gaussian 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 ml4pg-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 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 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/ssreflect | 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/ssreflect | 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/ssreflect/*/ | 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/ssreflect/*/"))
+  (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/ssreflect/")) (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/ssreflect/" 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/ssreflect/" 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 'ml4pg-change-library (concat dir "/" item)) 
+    :selected (list 'ml4pg-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 'ml4pg-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 (ml4pg-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 ml4pg-libs-menus temp2))
+      (if (not (string= string (car temp)))
+	  (setf temp2 (append temp2 (list (car temp)))))))
+
+
+
+
+  
+
+
+	  
+
+
diff --git a/contrib/ML4PG/ssreflect/save_lemmas.el b/contrib/ML4PG/ssreflect/save_lemmas.el
new file mode 100644
index 00000000..531532fb
--- /dev/null
+++ b/contrib/ML4PG/ssreflect/save_lemmas.el
@@ -0,0 +1,121 @@
+(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 (ml4pg-get-number-of-goals))
+	       (if cmd 
+	       (setf result (cons (append (ml4pg-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" (ml4pg-get-name)) 
+					     (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/ssreflect/" 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/ssreflect/" 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/ssreflect/" d2))
+		 (with-temp-file 
+			  (concat ml4pg-home-dir "libs/ssreflect/" 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/ssreflect/" 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/ssreflect/" 
+				  (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/ssreflect/" 
+					      (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/ssreflect/shortcuts.el b/contrib/ML4PG/ssreflect/shortcuts.el
new file mode 100644
index 00000000..d67a7f50
--- /dev/null
+++ b/contrib/ML4PG/ssreflect/shortcuts.el
@@ -0,0 +1,14 @@
+(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/ssreflect/storage.el b/contrib/ML4PG/ssreflect/storage.el
new file mode 100644
index 00000000..fde72694
--- /dev/null
+++ b/contrib/ML4PG/ssreflect/storage.el
@@ -0,0 +1,51 @@
+(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)
+  (ml4pg-save-view-aux (format "%s&%s$" name value)))
+
+
+(defun ml4pg-read-lemmas ()
+  (if (file-exists-p (concat ml4pg-home-dir "ssreflect/lemmas.txt"))
+      (with-temp-buffer
+	(insert-file-contents (concat ml4pg-home-dir "ssreflect/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 "ssreflect/views.txt"))
+      (with-temp-buffer
+	(insert-file-contents (concat ml4pg-home-dir "ssreflect/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/ssreflect/views.txt b/contrib/ML4PG/ssreflect/views.txt
new file mode 100644
index 00000000..1f40a052
--- /dev/null
+++ b/contrib/ML4PG/ssreflect/views.txt
@@ -0,0 +1 @@
+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/ssreflect/weka.el b/contrib/ML4PG/ssreflect/weka.el
new file mode 100644
index 00000000..ba220c1d
--- /dev/null
+++ b/contrib/ML4PG/ssreflect/weka.el
@@ -0,0 +1,112 @@
+(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")))
+    ;(shell-command (concat "java -classpath " 
+;			 *weka-dir*
+;			 " weka.attributeSelection.CfsSubsetEval -M -s \"weka.attributeSelection.BestFirst -D 1 -N 5\" -i "
+;			 (expand-file-name "temp3.arff") " > " (expand-file-name "res.txt")))
+  ))
+
+
+(defun ml4pg-why-are-similar ()
+  (with-temp-buffer
+    (insert-file-contents (expand-file-name "res.txt"))
+    (setf foo nil)
+    (while (not foo) 
+      (setf foo (string= "attributes:" (format "%s" (read (current-buffer))))))
+    (ml4pg-extract-selected-attributes (format "%s" (read (current-buffer))) nil))
+  )
+
+
+(defun ml4pg-extract-selected-attributes (temp res)
+ (let ((comma (search "," temp)))
+   (if comma
+       (ml4pg-extract-selected-attributes (subseq temp (+ 1 comma)) 
+				    (append res (list (car (read-from-string (subseq temp 0 comma))))))
+     (append res (list (car (read-from-string temp)))))))
+
+
+
+
+
+
+
+
+
+
+
+(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)))))))
+
+
+