(defvar *system-is-still-learning*)
(defvar *style*)
(defvar *done-time*)
(defvar *block-size*)
(defvar *jtb-hacked-block-number*)
(defvar *current-focus*)
(defvar *correct-category*)

(defvar *last-guess*)
(defvar *sims*)
(defvar *ebrw-criterion*)
(defvar *lax-criterion*)
(defvar *strict-criterion*)

(defvar *r-time*)
(defvar *r-thresh*)
(defvar *intercept*)
(defvar *counter-thresh*)
(defvar *runs*)
(defvar *text*)
(defvar *graphic*)
(defparameter *v* nil)
(defvar *overlay*)

(defparameter *categories* '(category-a category-b))
(defparameter *egs* (/ 2.2 (sqrt 2)))
(defparameter *noise* .55)

(defparameter *experiment-1-patterns*
  '( (bri1 sat1 nil nil category-b) (bri2 sat2 nil nil category-a) 
     (bri3 sat3 nil nil category-a) (bri4 sat4 nil nil category-a) 
     (bri5 sat5 nil nil category-b) (bri6 sat6 nil nil category-a)
     (bri7 sat7 nil nil category-a) (bri8 sat8 nil nil category-b) 
     (bri9 sat9 nil nil category-a) (bri10 sat10 nil nil category-b) 
     (bri11 sat11 nil nil category-b) (bri12 sat12 nil nil category-b)))


(defparameter *exp-data-catds11* 
  '(0.815 0.795 1.159 0.725 0.967 1.068 0.706 0.931 1.346 0.744 0.911 1.208))


(defparameter *ebrw-data-catds11* 
  '(0.971 0.831 1.04 0.797 0.907 0.945 0.779 0.908 1.257 0.767 0.826 1.341))

(defparameter *exp-learning-data-catds11* '(1.85 1.41 1.25 1.05 1.05 0.9 1.11 0.95 0.96 0.91 0.92 0.86 1.12 0.9 1.05	
                                                1.03 0.9 0.934 0.931 0.95 0.926 0.924 0.922 0.9 0.94 0.85 0.85 0.87 0.94 0.95 ))

(defparameter *ebrw-learning-data-catds11*
  '(1.86	1.364	1.201	1.12	1.072	1.04	1.017	1	0.986	0.976	0.967	0.96	0.954	0.949	0.944	0.94	0.937	0.934	0.931	0.929	0.926	0.924	0.922	0.921	0.919	0.918	0.916	0.915	0.914	0.913))




;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; This section contains the interface for the WWW using the
;;; ACT-R on the Web application by Elmar Schwarz
(defvar *www-interface*)

(setf  *WWW-interface* 
      '((:heading "Categorization Model of Nosofsky & Palmeri, 1997 Participant 1" 2)
        (:table)
        
        (:table)
        "Retrieval Time: "        (:string :sy *r-time*  .10)   (:new-row)
        "Retrieval Threshold: "   (:string :sy *r-thresh*  -.3)  (:new-row)
        "Intercept Parameter: "   (:string :sy *intercept*  .18)     (:new-row)
        "Counter Threshold: "     (:string :sy *counter-thresh* 4)     (:new-row)
        "Number of runs (1-20): " (:string :sy *runs* 1)
        (:table-end)
        
        (:table)
       (:checkbox "Trace (NOT recommended, see below)" :sy *v*  nil)  (:new-row)
        (:checkbox "Text output" :sy *text*  t) (:new-row)
        (:checkbox "Graphic output" :sy *graphic*  nil) (:new-row)
        (:checkbox "Show simulation and experiment data on one graph" :sy *overlay*  nil) 
        (:table-end)
        
        (:table-end)
        (:hidden :sy *categories* (category-a category-b))
        (:hidden :sy *egs* 1.56)
        (:hidden :sy *noise* .55)

        (:hidden :sy *experiment-1-patterns*
                 ((bri1 sat1 nil nil category-b)     (bri2 sat2 nil nil category-a) 
                    (bri3 sat3 nil nil category-a)   (bri4 sat4 nil nil category-a) 
                    (bri5 sat5 nil nil category-b)   (bri6 sat6 nil nil category-a)
                    (bri7 sat7 nil nil category-a)   (bri8 sat8 nil nil category-b) 
                    (bri9 sat9 nil nil category-a)   (bri10 sat10 nil nil category-b) 
                    (bri11 sat11 nil nil category-b) (bri12 sat12 nil nil category-b)))
        


        (:new-para)
        
        (:button "Show Experimental and EBRW Results" "(display-catds11 nil 
                                                                       (list *exp-learning-data-catds11* *exp-data-catds11*) 
                                                                       (list *ebrw-learning-data-catds11* *ebrw-data-catds11*)
                                                                       )")
           
        (:new-para)
        
        (:button "Run model" "(if (and (numberp *r-time*) (numberp *r-thresh*)
                                       (numberp *intercept*) (numberp *counter-thresh*)
                                       (numberp *runs*))
                                   (display-catds11 (doit-1-catds11 (min 20 (max 1 *runs*)) *r-time* *r-thresh* *intercept* *counter-thresh*)
                                                     (list *exp-learning-data-catds11* *exp-data-catds11*) 
                                                     (list *ebrw-learning-data-catds11* *ebrw-data-catds11*)
                                                                       )
                                   ;(dolist (x *experiment-1-patterns*)(pprint x))
                                   (format *standard-output* \"All parameters must be numbers~%\"))")
        (:reset "Default values")
        (:button "Production Rules" "(let ((prods (no-output (pp))))
                                       (dolist (x prods)
                                         (pp-fct (list x))
                                         (spp-fct (list x))
                                         (format *standard-output* \"~%\")))")
        (:button "Chunk types" "(chunk-type)")
        (:button "Chunks" "(dm)")
        (:new-para)
         "TIME and SIZE:"
        (:new-para)
        "- It usually takes about 1 minute for 1 run of the model"
        (:new-line)
        "- The trace of 1 run is approximatly 2 MEGABYTES (1000 pages) in size"
        (:new-para)))


;(defun display-catds11 (model expri ebrw)
; 
;  (pprint model)
;  (pprint expri)
;  (pprint ebrw))

(defun display-catds11 (model experi ebrw)
  (when model 
    (format *standard-output* "~%~%Parameters for run: (~S ~S ~S ~S ~S)~%" 
            *r-time* *r-thresh* *intercept* *counter-thresh* (min 20 (max 1 *runs*))))
  
  (when *text*
    (when model
      (format *standard-output* "~%~%ACT-R learning data:~%")
      (format *standard-output* "~%Block   RT (sec.)~%")
      (dotimes (i 30)
        (format *standard-output* "~3s~10,3f~%" (* 5 (1+ i)) (nth i (car model))))
      (format *standard-output* "~%~%ACT-R stimulus data:~%")
      (format *standard-output* "~%Stimulus   RT (sec.)~%")
      (dotimes (i 12)
        (format *standard-output* "~3s~13,3f~%" (1+ i) (nth i (cadr model))))
      (format *standard-output* "~%"))
      
      (when (or (null model) *overlay*)
        (format *standard-output* "~%~%EBRW learning data:~%")
        (format *standard-output* "~%Block   RT (sec.)~%")
        (dotimes (i 30)
          (format *standard-output* "~3s~10,3f~%" (* 5 (1+ i)) (nth i (car ebrw))))
        (format *standard-output* "~%~%EBRW stimulus data:~%")
        (format *standard-output* "~%Stimulus   RT (sec.)~%")
        (dotimes (i 12)
          (format *standard-output* "~3s~13,3f~%" (1+ i) (nth i (cadr ebrw))))

        (format *standard-output* "~%~%Experimental learning data:~%")
        (format *standard-output* "~%Block   RT (sec.)~%")
        (dotimes (i 30)
          (format *standard-output* "~3s~10,3f~%" (* 5 (1+ i)) (nth i (car experi))))
        (format *standard-output* "~%~%Experimental stimulus data:~%")
        (format *standard-output* "~%Stimulus   RT (sec.)~%")
        (dotimes (i 12)
          (format *standard-output* "~3s~13,3f~%" (1+ i) (nth i (cadr experi))))
        (format *standard-output* "~%")
)
      
      (unless *graphic* (format *standard-output* 
                                "~%</pre>If your browser supports JAVA, you 
                               can display the data in a graph by checking 
                               the Graphic output box on the interface page.<pre>~%~%")))


  (when *graphic* 
    (let ((num-lines (cond ((and model (not *overlay*)) 1)
                 ((null model) 2)
                 (t 3))))

      (format *standard-output* " 
        <applet 
        code = \"DansGraphs.class\" 
        width = 600 
        height = 400> 
        <PARAM name=\"title\" value=\"Learning Data\">
        <PARAM name=\"xmin\" value=\"0\">
        <PARAM name=\"xmax\" value=\"150\">
        <PARAM name=\"ymax\" value=\"2.0\">
        <PARAM name=\"ymin\" value=\"0\">
        <PARAM name=\"longestline\" value=\"30\">
        <PARAM name=\"numlines\" value=\"~S\">
        <PARAM name=\"xspacing\" value=\"10\">
        <PARAM name=\"ydiv\" value=\"0.25\">
        <PARAM name=\"xdiv\" value=\"5\">
        <PARAM name=\"yspacing\" value=\"1\">
        <PARAM name=\"xval0\" value=\"5;10;15;20;25;30;35;40;45;50;55;60;65;70;75;80;85;90;95;100;105;110;115;120;125;130;135;140;145;150;\">
        <PARAM name=\"lcolor0\" value=\"0\">
        <PARAM name=\"lstyle0\" value=\"2\">
" 
           
              num-lines
            )
    
    (dotimes (i (1- num-lines))
      (format *standard-output* "<PARAM name=\"lcolor~s\" value=\"~s\">
                                 <PARAM name=\"lstyle~s\" value=\"2\">
                                 <PARAM name=\"xval~s\" value=\"5;10;15;20;25;30;35;40;45;50;55;60;65;70;75;80;85;90;95;100;105;110;115;120;125;130;135;140;145;150;\">"

              (1+ i) (1+ i) (1+ i) (1+ i)))
    
    (format *standard-output* "
        <PARAM name=\"xname\" value=\"Block\">
        <PARAM name=\"yname\" value=\"RT (sec)\">")
    (dotimes (i num-lines)
      (format *standard-output* "<PARAM name=\"name~s\" value=\"~a\">" 
              i (case i
                  (0 (case num-lines
                       (1 "ACT-R")
                       (2 "EBRW")
                       (3 "ACT-R")))
                  (1 (case num-lines
                       (2 "Experimental Data")
                       (3 "EBRW")))
                  (2 "Experimental Data"))))
    
    (dotimes (i num-lines)
      (format *standard-output* "<PARAM name=\"yval~s\" value=\"" i)
      (dotimes (x 30)
        (format *standard-output* "~5,2f;" (nth x (case i
                                                    (0 (case num-lines
                                                         (1 (car model))
                                                         (2 (car ebrw))
                                                         (3 (car model))))
                                                    (1 (case num-lines
                                                         (2 (car experi))
                                                         (3 (car ebrw))))
                                                    (2 (car experi)))
                                                         )))
    
    (format *standard-output* "\">"))
    
      
    (format *standard-output* "
             <HR> Either your browser does not support JAVA or this graph has scrolled off the top of the display.~%
             </HR></applet>")


(format *standard-output* " 
        <p>
        <applet 
        code = \"DansGraphs.class\" 
        width = 600 
        height = 400> 
        <PARAM name=\"title\" value=\"Stimulus Data\">
        <PARAM name=\"xmin\" value=\"0\">
        <PARAM name=\"xmax\" value=\"12\">
        <PARAM name=\"ymax\" value=\"1.5\">
        <PARAM name=\"ymin\" value=\"0\">
        <PARAM name=\"longestline\" value=\"12\">
        <PARAM name=\"numlines\" value=\"~S\">
        <PARAM name=\"xspacing\" value=\"1\">
        <PARAM name=\"ydiv\" value=\"0.25\">
        <PARAM name=\"yspacing\" value=\".5\">
        <PARAM name=\"xval0\" value=\"1;2;3;4;5;6;7;8;9;10;11;12;\">
        <PARAM name=\"lcolor0\" value=\"0\">
        <PARAM name=\"lstyle0\" value=\"2\">
" 
           
              num-lines
            )
    
    (dotimes (i (1- num-lines))
      (format *standard-output* "<PARAM name=\"lcolor~s\" value=\"~s\">
                                 <PARAM name=\"lstyle~s\" value=\"2\">
                                 <PARAM name=\"xval~s\" value=\"1;2;3;4;5;6;7;8;9;10;11;12;\">"

              (1+ i) (1+ i) (1+ i) (1+ i)))
    
    (format *standard-output* "
        <PARAM name=\"xname\" value=\"Stimulus\">
        <PARAM name=\"yname\" value=\"RT (sec)\">")
    (dotimes (i num-lines)
      (format *standard-output* "<PARAM name=\"name~s\" value=\"~a\">" 
              i (case i
                  (0 (case num-lines
                       (1 "ACT-R")
                       (2 "EBRW")
                       (3 "ACT-R")))
                  (1 (case num-lines
                       (2 "Experimental Data")
                       (3 "EBRW")))
                  (2 "Experimental Data"))))
    
    (dotimes (i num-lines)
      (format *standard-output* "<PARAM name=\"yval~s\" value=\"" i)
      (dotimes (x 12)
        (format *standard-output* "~5,2f;" (nth x (case i
                                                    (0 (case num-lines
                                                         (1 (cadr model))
                                                         (2 (cadr ebrw))
                                                         (3 (cadr model))))
                                                    (1 (case num-lines
                                                         (2 (cadr experi))
                                                         (3 (cadr ebrw))))
                                                    (2 (cadr experi)))
                                                         )))
    
    (format *standard-output* "\">"))
    
      
    (format *standard-output* "
             <HR> Either your browser does not support JAVA or this graph has scrolled off the top of the display.~%
             </HR></applet>")

)))


(defun correct-category-catds11 (blah)
  (declare (ignore blah))
  (if (equal *done-time* nil) (setq *done-time* (actr-time)))
  (setq *last-guess* (chunk-slot-value-fct *current-focus* 'category)) 
  (if *system-is-still-learning* *correct-category* (chunk-slot-value-fct *current-focus* 'category))
  )

(defun winner-catds11 (stimulus)
  (let (numA numB numC numD) 
    (setq numA (chunk-slot-value-fct stimulus 'countA))
    (setq numB (chunk-slot-value-fct stimulus 'countB))
    (setq numC (chunk-slot-value-fct stimulus 'countC))
    (setq numD (chunk-slot-value-fct stimulus 'countD))
    (if (and (>= (- numA numB) *ebrw-criterion*)
             (>= (- numA numC) *ebrw-criterion*)
             (>= (- numA numD) *ebrw-criterion*)) 'category-A
        (if (and (>= (- numB numA) *ebrw-criterion*)
                 (>= (- numB numC) *ebrw-criterion*)
                 (>= (- numB numD) *ebrw-criterion*)) 'category-B
            (if (and (>= (- numC numA) *ebrw-criterion*)
                     (>= (- numC numB) *ebrw-criterion*)
                     (>= (- numC numD) *ebrw-criterion*)) 'category-C
                (if (and (>= (- numD numA) *ebrw-criterion*)
                         (>= (- numD numB) *ebrw-criterion*)
                         (>= (- numD numC) *ebrw-criterion*)) 'category-D))))
    )
  
  )

(defun rule-category-catds11 (rule stim)
  (if (and 
       (or (and (chunk-slot-value-fct rule 'feature1) 
                (< (chunk-slot-value-fct rule 'feature1) 
                   (chunk-slot-value-fct (chunk-slot-value-fct stim 'feature1) 'value)))
           (not (chunk-slot-value-fct rule 'feature1)))
       
       
       (or (and (chunk-slot-value-fct rule 'feature2) 
                (< (chunk-slot-value-fct rule 'feature2) 
                   (chunk-slot-value-fct (chunk-slot-value-fct stim 'feature2) 'value)))
           (not (chunk-slot-value-fct rule 'feature2)))
       
       
       (or (and (chunk-slot-value-fct rule 'feature3) 
                (< (chunk-slot-value-fct rule 'feature3) 
                   (chunk-slot-value-fct (chunk-slot-value-fct stim 'feature3) 'value)))
           (not (chunk-slot-value-fct rule 'feature3)))
       
       (or (and (chunk-slot-value-fct rule 'feature4) 
                (< (chunk-slot-value-fct rule 'feature4) 
                   (chunk-slot-value-fct (chunk-slot-value-fct stim 'feature4) 'value)))
           (not (chunk-slot-value-fct rule 'feature4))))
    
    (chunk-slot-value-fct stim 'category)
    (nth (random (1- (length *categories*))) (remove (chunk-slot-value-fct stim 'category) *categories*)))
  )


(defun random-category-catds11 ()
  (nth (random (length *categories*)) *categories*)
  )

(defun increment-category-count (classify-goal category)
  (if (equal category 'category-A)
    (modwme-fct classify-goal 
                (list 'countA (+ 1 (chunk-slot-value-fct classify-goal 'countA))))
    (if (equal category 'category-B)
      (modwme-fct classify-goal
                  (list 'countB (+ 1 (chunk-slot-value-fct classify-goal 'countB))))
      (if (equal category 'category-C)
        (modwme-fct classify-goal
                    (list 'countC (+ 1 (chunk-slot-value-fct classify-goal 'countC))))
        (if (equal category 'category-D)
          (modwme-fct classify-goal
                      (list 'countD (+ 1 (chunk-slot-value-fct classify-goal 'countD))))))))
  )



(defun experiment-1-present-pattern-catds11 (pattern)
  (let (name cycles start-time)
    (setq name (gentemp "ITEM"))
    (if (car (no-output (sgp :v))) (print pattern))
    (add-dm-fct (list (list name 'isa 'presentation 'feature1 (first pattern) 
                            'feature2 (second pattern) 'feature3 (third pattern) 'feature4 (fourth pattern))))
    (setq *correct-category* (fifth pattern))
    (setq *current-focus* name)
    (setq start-time (actr-time))
    (setq *done-time* nil)
    (setq *style* nil)
    (goal-focus-fct (list *current-focus*))
    (multiple-value-setq (cycles) (run))
    (if (null *done-time*) (setq *done-time* (actr-time)))
    (list (- *done-time* start-time) *last-guess* (* 1.0 cycles)))
  )


(defun experiment-1-get-pattern-data-catds11 (patnum trial-data)
  (mapcar #'(lambda(x) (assoc patnum x)) trial-data)
  )

(defun randomize-catds11 (list)
  (let ((n (length list))
        (result nil))
    (setf list (copy-tree list))
    (dotimes (i n result)
      (let ((data (nth (random (- n i)) list)))
        (push data result)
        (setf list (delete data list))))))


(defun experiment-1-present-block-catds11 ()
  (setq *jtb-hacked-block-number* (+ 2 *jtb-hacked-block-number*))
  (mapcar #'(lambda (x) (eval `(sdp ,x :references ,*jtb-hacked-block-number*))) 
          (no-output (sdm isa stimulus)))
  (let (pb-res)
    (setq pb-res '())
    
    (dolist (itm (randomize-catds11 '(0 1 2 3 4 5 6 7 8 9 10 11)))
      (setq pb-res (cons (cons itm (experiment-1-present-pattern-catds11 (nth itm *experiment-1-patterns*))) pb-res)))
    
    (reverse pb-res)
    )
  )

(defun list-average*-catds11 (x) (list-average-catds11 (nthcdr 6 (reverse x))))

(defun summa-catds11 (lis)
  (if (equal (length lis) 0) 0 (+ (car lis) (summa-catds11 (cdr lis))))) 

(defun list-average-catds11 (lis)
  (/ (summa-catds11 lis) (length lis))
  )

(defun experiment-1-average-pattern-times-catds11 (patnum trial-data)
  (list-average-catds11 (mapcar #'second (experiment-1-get-pattern-data-catds11 patnum trial-data)))
  )

(defun experiment-1-average-pattern-cycles-catds11 (patnum trial-data)
  (list-average-catds11 (mapcar #'fourth (experiment-1-get-pattern-data-catds11 patnum trial-data)))
  )

(defun experiment-1-probability-correct-catds11 (patnum trial-data)
  (list-average-catds11 (mapcar #'(lambda(x) (if (equal (third x) (fifth (nth patnum *experiment-1-patterns*))) 1 0)) (experiment-1-get-pattern-data-catds11 patnum trial-data)))
  )


(defun experiment-1-present-n-blocks-catds11 (n)
  (if (equal n 0) NIL
      (cons (experiment-1-present-block-catds11) (experiment-1-present-n-blocks-catds11 (- n 1))))
  )

(defun experiment-1-setup-catds11 (rt ga effort intercept)
  (reset)
  (add-dm
   (one ISA feature-value value 1)
   (two ISA feature-value value 2)
   (bri1 ISA feature-value) (bri2 ISA feature-value) (bri3 ISA feature-value) (bri4 ISA feature-value)
   (bri5 ISA feature-value) (bri6 ISA feature-value) (bri7 ISA feature-value) (bri8 ISA feature-value)
   (bri9 ISA feature-value) (bri10 ISA feature-value) (bri11 ISA feature-value) (bri12 ISA feature-value)
   (sat1 ISA feature-value) (sat2 ISA feature-value) (sat3 ISA feature-value) (sat4 ISA feature-value)
   (sat5 ISA feature-value) (sat6 ISA feature-value) (sat7 ISA feature-value) (sat8 ISA feature-value)
   (sat9 ISA feature-value) (sat10 ISA feature-value) (sat11 ISA feature-value) (sat12 ISA feature-value)
   
   (category-a ISA category opposite category-b)
   (category-b ISA category opposite category-a)
   )
  (eval *sims*)
  
  (setq *block-size* 12) ; not actually necessary, but heck, let's be consistent
  (setq *lax-criterion* 0.55)
  (setq *strict-criterion* 0.7)
  (setq *system-is-still-learning* T)
  
  
  (sgp-fct (list :ga ga))
  (sgp-fct (list :rt rt))
  (sgp :ans 0.5)
  (spp-fct (list 'recall-2feature :effort effort))
  
  (spp-fct (list 'done-classifying-by-exemplar :effort intercept))
  (sgp :lf 0.9)
  )

(defun experiment-1-run-once-catds11 (rt ga effort intercept)
  (setf *categories* '(category-a category-b))
  (setq *jtb-hacked-block-number* 0)
  (experiment-1-setup-catds11 rt ga effort intercept)
  (let (results-5 results-total)
    (do ((n 0 (+ 1 n))) ((equal n 30))
      (setq results-5 (experiment-1-present-n-blocks-catds11 5))
      (setq results-total 
            (cons (list 
                   (list-average-catds11 (mapcar #'(lambda(x) (experiment-1-average-pattern-times-catds11 x results-5)) '(0 1 2 3 4 5 6 7 8 9 10 11)))
                   (mapcar #'(lambda(x) (experiment-1-average-pattern-times-catds11 x results-5)) '(0 1 2 3 4 5 6 7 8 9 10 11))
                   (mapcar #'(lambda(x) (experiment-1-probability-correct-catds11 x results-5)) '(0 1 2 3 4 5 6 7 8 9 10 11))
                   (mapcar #'(lambda(x) (experiment-1-average-pattern-cycles-catds11 x results-5)) '(0 1 2 3 4 5 6 7 8 9 10 11))
                   )
                  results-total))
      )
    (list (reverse (mapcar #'first results-total))
          (mapcar #'list-average*-catds11 (mapcar #'(lambda(y) (mapcar #'(lambda(x) (nth y x)) (mapcar #'second results-total))) '(0 1 2 3 4 5 6 7 8 9 10 11)))
          (mapcar #'list-average*-catds11 (mapcar #'(lambda(y) (mapcar #'(lambda(x) (nth y x)) (mapcar #'third results-total))) '(0 1 2 3 4 5 6 7 8 9 10 11)))
          (mapcar #'list-average*-catds11 (mapcar #'(lambda(y) (mapcar #'(lambda(x) (nth y x)) (mapcar #'fourth results-total))) '(0 1 2 3 4 5 6 7 8 9 10 11)))
          
          )
    )
  )

(defun experiment-1-test-catds11 (rt ga effort intercept)
  (experiment-1-run-once-catds11 rt ga effort intercept))


(defun average-a-lol-catds11 (lol)
  (do ((temp lol (mapcar 'cdr temp))
       (result nil (append result (do ((temp1 temp (cdr temp1))
                                       (ans 0.0 (+ ans (caar temp1))))
                                      ((null temp1) (list (/ ans (length lol))))))))
      ((null (car temp)) result)))

(defun run-1-n-catds11 (n rt effort intercept)
  (do ((count 0 (1+ count))
       (result nil (cons (experiment-1-test-catds11 rt 0 effort intercept) result)))
      ((equal count n) (list (average-a-lol-catds11 (mapcar 'first result))
                             (average-a-lol-catds11 (mapcar 'second result))))))

(defun doit-1-catds11 (n time tau intercept counter)
  (setq *ebrw-criterion* counter)
  (setf *sims* '(set-similarities
                 (bri2 bri1	0.993797325	)																				
                 (bri3 bri1	0.982425753	)(bri3 bri2	0.988628428	)																		
                 (bri4 bri1	0.985527091	)(bri4 bri2	0.991729766	)(bri4 bri3	0.996898662	)																
                 (bri5 bri1	0.961750168	)(bri5 bri2	0.967952843	)(bri5 bri3	0.979324415	)(bri5 bri4	0.976223077	)														
                 (bri6 bri1	0.97312174	)(bri6 bri2	0.979324415	)(bri6 bri3	0.990695987	)(bri6 bri4	0.987594649	)(bri6 bri5	0.988628428	)												
                 (bri7 bri1	0.979324415	)(bri7 bri2	0.985527091	)(bri7 bri3	0.996898662	)(bri7 bri4	0.993797325	)(bri7 bri5	0.982425753	)(bri7 bri6	0.993797325	)										
                 (bri8 bri1	0.954513713	)(bri8 bri2	0.960716389	)(bri8 bri3	0.97208796	)(bri8 bri4	0.968986623	)(bri8 bri5	0.992763545	)(bri8 bri6	0.981391974	)(bri8 bri7	0.975189298	)								
                 (bri9 bri1	0.95864883	)(bri9 bri2	0.964851506	)(bri9 bri3	0.976223077	)(bri9 bri4	0.97312174	)(bri9 bri5	0.996898662	)(bri9 bri6	0.985527091	)(bri9 bri7	0.979324415	)(bri9 bri8	0.995864883	)						
                 (bri10 bri1	0.93177057	)(bri10 bri2	0.937973245	)(bri10 bri3	0.949344817	)(bri10 bri4	0.946243479	)(bri10 bri5	0.970020402	)(bri10 bri6	0.95864883	)(bri10 bri7	0.952446155	)(bri10 bri8	0.977256857	)(bri10 bri9	0.97312174	)				
                 (bri11 bri1	0.940040804	)(bri11 bri2	0.946243479	)(bri11 bri3	0.957615051	)(bri11 bri4	0.954513713	)(bri11 bri5	0.978290636	)(bri11 bri6	0.966919064	)(bri11 bri7	0.960716389	)(bri11 bri8	0.985527091	)(bri11 bri9	0.981391974	)(bri11 bri10	0.991729766	)		
                 (bri12 bri1	0.952446155	)(bri12 bri2	0.95864883	)(bri12 bri3	0.970020402	)(bri12 bri4	0.966919064	)(bri12 bri5	0.990695987	)(bri12 bri6	0.979324415	)(bri12 bri7	0.97312174	)(bri12 bri8	0.997932442	)(bri12 bri9	0.993797325	)(bri12 bri10	0.979324415	)(bri12 bri11	0.987594649	)
                 
                 
                 
                 (sat2 sat1	0.971118455	)																				
                 (sat3 sat1	0.987484664	)(sat3 sat2	0.983633791	)																		
                 (sat4 sat1	0.957640401	)(sat4 sat2	0.986521946	)(sat4 sat3	0.970155737	)																
                 (sat5 sat1	0.997111846	)(sat5 sat2	0.97400661	)(sat5 sat3	0.990372818	)(sat5 sat4	0.960528555	)														
                 (sat6 sat1	0.965342146	)(sat6 sat2	0.994223691	)(sat6 sat3	0.977857482	)(sat6 sat4	0.992298255	)(sat6 sat5	0.968230301	)												
                 (sat7 sat1	0.936460601	)(sat7 sat2	0.965342146	)(sat7 sat3	0.948975937	)(sat7 sat4	0.9788202	)(sat7 sat5	0.939348756	)(sat7 sat6	0.971118455	)										
                 (sat8 sat1	0.984596509	)(sat8 sat2	0.986521946	)(sat8 sat3	0.997111846	)(sat8 sat4	0.973043891	)(sat8 sat5	0.987484664	)(sat8 sat6	0.980745637	)(sat8 sat7	0.951864092	)								
                 (sat9 sat1	0.951864092	)(sat9 sat2	0.980745637	)(sat9 sat3	0.964379428	)(sat9 sat4	0.994223691	)(sat9 sat5	0.954752246	)(sat9 sat6	0.986521946	)(sat9 sat7	0.984596509	)(sat9 sat8	0.967267582	)						
                 (sat10 sat1	0.990372818	)(sat10 sat2	0.980745637	)(sat10 sat3	0.997111846	)(sat10 sat4	0.967267582	)(sat10 sat5	0.993260973	)(sat10 sat6	0.974969328	)(sat10 sat7	0.946087783	)(sat10 sat8	0.994223691	)(sat10 sat9	0.961491273	)				
                 (sat11 sat1	0.973043891	)(sat11 sat2	0.998074564	)(sat11 sat3	0.985559228	)(sat11 sat4	0.984596509	)(sat11 sat5	0.975932046	)(sat11 sat6	0.992298255	)(sat11 sat7	0.96341671	)(sat11 sat8	0.988447382	)(sat11 sat9	0.9788202	)(sat11 sat10	0.982671073	)		
                 (sat12 sat1	0.961491273	)(sat12 sat2	0.990372818	)(sat12 sat3	0.97400661	)(sat12 sat4	0.996149127	)(sat12 sat5	0.964379428	)(sat12 sat6	0.996149127	)(sat12 sat7	0.974969328	)(sat12 sat8	0.976894764	)(sat12 sat9	0.990372818	)(sat12 sat10	0.971118455	)(sat12 sat11	0.988447382	)
                 ))
  (run-1-n-catds11 n tau time intercept))





;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;




;;;
;;; The ACT-R model


(clear-all)
(sgp-fct (list :lt nil :pct nil :pmt nil :v *v* :pm t :era t :er t :pl t :bll 0.5 :ans *noise* :egs *egs* :ga 1 :lf 1 :mp 45 :rt 0.0 :ut -20))

(chunk-type presentation feature1 feature2 feature3 feature4 category choice exn-used evaluated)
(chunk-type stimulus feature1 feature2 feature3 feature4 category)
(chunk-type feature-value value)
(chunk-type category opposite)
(chunk-type clean-up)
(chunk-type rule feature1 feature2 feature3 feature4 guess viable current type correct incorrect)
(chunk-type classify-by-rule presentation category exceptions-checked exn-used)
(chunk-type apply-rule-to-presentation rule presentation checked category)
(chunk-type classify-by-exemplar presentation category counta countb countc countd feature1 feature2 feature3 feature4)
(chunk-type exception feature1 feature2 feature3 feature4 category)
(chunk-type rule-type)
(chunk-type find-rule presentation)
(chunk-type evaluate classification-style presentation count last-result exn-used)
(chunk-type classification-style)

(add-dm
   (perfect ISA rule-type)
   (imperfect ISA rule-type)
   (conjunctive ISA rule-type)
   (rule-2 isa chunk)
   (rule ISA classification-style)
   (exemplar ISA classification-style))

(P choose-to-classify-by-rule
   =goal>
      ISA         presentation
      category    nil
   =rule>
      ISA         rule
      viable      t
==>
   =classify-by-rule-goal>
      ISA         classify-by-rule
      presentation =goal
      category    =c
      exn-used    =exn
   =goal>
      category    =c
      choice      rule
      exn-used    =exn
  !eval!          (setq *STYLE* 'RULE)
   !push!         =classify-by-rule-goal
)

(P cant-do-jack
   =goal>
      ISA         presentation
      category    nil
==>
   =goal>
      category    (!eval! (random-category-catds11))
      choice      random
)

(P random-guess-was-right
   =goal>
      ISA         presentation
      choice      random
      category    =c
   !eval!         (equal =c (correct-category-catds11 =goal))
==>
   =goal>
      evaluated   right
      choice      rule
)

(P random-guess-was-wrong
   =goal>
      ISA         presentation
      choice      random
      category    =c
   !eval!         (not (equal =c (correct-category-catds11 =goal)))
==>
   =goal>
      evaluated   wrong
      category    (!eval! (correct-category-catds11 =goal))
      choice      rule
)



(P choose-to-classify-by-exemplar-4feature
   =goal>
      ISA         presentation
      category    nil
      feature1    =f1
      feature2    =f2
      feature3    =f3
      feature4    =f4
      choice      nil
   =recall-stimulus>
      ISA         stimulus
      feature1    =f1
      feature2    =f2
      feature3    =f3
      feature4    =f4
      category    =c
==>
   =classify-by-exemplar-goal>
      ISA         classify-by-exemplar
      presentation =goal
      counta      0
      countb      0
      countc      0
      countd      0
      category    =cat
      feature1    =f1
      feature2    =f2
      feature3    =f3
      feature4    =f4
   =goal>
      category    =cat
      choice      exemplar
    !eval!          (setq *STYLE* 'EXEM4)
   !push!         =classify-by-exemplar-goal
)

(P choose-to-classify-by-exemplar-2feature
   =goal>
      ISA         presentation
      category    nil
      feature1    =f1
      feature2    =f2
      feature3    nil
      feature4    nil
      choice      nil
   =recall-stimulus>
      ISA         stimulus
      feature1    =f1
      feature2    =f2
      feature3    nil
      feature4    nil
      category    =c
==>
   =classify-by-exemplar-goal>
      ISA         classify-by-exemplar
      presentation =goal
      counta      0
      countb      0
      countc      0
      countd      0
      category    =cat
      feature1    =f1
      feature2    =f2
      feature3    nil
      feature4    nil
   =goal>
      category    =cat
      choice      exemplar
   !eval!         (setq *STYLE* 'EXEM2)
   !push!         =classify-by-exemplar-goal
)

(P cover-for-failed-classify
   =goal>
      ISA         presentation
      category    failure
==>
   =goal>
      category    (!eval! (random-category-catds11))
)

(P general-rule-match
   =goal>
      ISA         classify-by-rule
      presentation =pres
      category   nil
   =rule>
      ISA         rule
      current     t
   =pres>
      ISA         presentation
==>
!output! =rule
   =apply-rule-goal>
      ISA         apply-rule-to-presentation
      presentation =pres
      rule        =rule
      checked     0
      category    =c
   =goal>
      category    =c
      exn-used    nil
   !push!         =apply-rule-goal
)

(P done-classifying-by-rule
   =goal>
      ISA         classify-by-rule
      category    =c
    - category    failure
==>
   !pop!
)

(P feature1-with-rule
   =goal>
      ISA         apply-rule-to-presentation
      rule        =rule
      presentation =pres
      checked     0
      category    nil
   =rule>
      ISA         rule
      feature1    =cutoff
      guess       =cat
   =pres>
      ISA         presentation
      feature1    =actual
   =actual>
      ISA         feature-value
      value       =val
   !eval!         (< =cutoff =val)
==>
   =goal>
      checked     1
      category    =cat
)

(P feature2-with-rule-v1
   =goal>
      ISA         apply-rule-to-presentation
      rule        =rule
      presentation =pres
      checked     1
      category    nil
   =rule>
      ISA         rule
      feature2    =cutoff
      guess       =cat
   =pres>
      ISA         presentation
      feature2    =actual
   =actual>
      ISA         feature-value
      value       =val
   !eval!         (< =cutoff =val)
==>
   =goal>
      checked     2
      category    =cat
)

(P feature2-with-rule-v2
   =goal>
      ISA         apply-rule-to-presentation
      rule        =rule
      presentation =pres
      checked     1
      category    =cat
   =rule>
      ISA         rule
      feature2    =cutoff
      guess       =cat
   =pres>
      ISA         presentation
      feature2    =actual
   =actual>
      ISA         feature-value
      value       =val
   !eval!         (< =cutoff =val)
==>
   =goal>
      checked     2
      category    =cat
)

(P feature3-with-rule-v1
   =goal>
      ISA         apply-rule-to-presentation
      rule        =rule
      presentation =pres
      checked     2
      category    nil
   =rule>
      ISA         rule
      feature3    =cutoff
      guess       =cat
   =pres>
      ISA         presentation
      feature3    =actual
   =actual>
      ISA         feature-value
      value       =val
   !eval!         (< =cutoff =val)
==>
   =goal>
      checked     3
      category    =cat
)

(P feature3-with-rule-v2
   =goal>
      ISA         apply-rule-to-presentation
      rule        =rule
      presentation =pres
      checked     2
      category    =cat
   =rule>
      ISA         rule
      feature3    =cutoff
      guess       =cat
   =pres>
      ISA         presentation
      feature3    =actual
   =actual>
      ISA         feature-value
      value       =val
   !eval!         (< =cutoff =val)
==>
   =goal>
      checked     3
      category    =cat
)

(P feature4-with-rule-v1
   =goal>
      ISA         apply-rule-to-presentation
      rule        =rule
      presentation =pres
      checked     3
      category    nil
   =rule>
      ISA         rule
      feature4    =cutoff
      guess       =cat
   =pres>
      ISA         presentation
      feature4    =actual
   =actual>
      ISA         feature-value
      value       =val
   !eval!         (< =cutoff =val)
==>
   =goal>
      checked     4
      category    =cat
)

(P feature4-with-rule-v2
   =goal>
      ISA         apply-rule-to-presentation
      rule        =rule
      presentation =pres
      checked     3
      category    =cat
   =rule>
      ISA         rule
      feature4    =cutoff
      guess       =cat
   =pres>
      ISA         presentation
      feature4    =actual
   =actual>
      ISA         feature-value
      value       =val
   !eval!         (< =cutoff =val)
==>
   =goal>
      checked     4
      category    =cat
)

(P feature1-against-rule
   =goal>
      ISA         apply-rule-to-presentation
      rule        =rule
      presentation =pres
      checked     0
      category    nil
   =rule>
      ISA         rule
      feature1    =cutoff
      guess       =cat
   =pres>
      ISA         presentation
      feature1    =actual
   =cat>
      ISA         category
      opposite    =opp
   =actual>
      ISA         feature-value
      value       =val
   !eval!         (> =cutoff =val)
==>
   =goal>
      checked     1
      category    =opp
)

(P feature2-against-rule-v1
   =goal>
      ISA         apply-rule-to-presentation
      rule        =rule
      presentation =pres
      checked     1
   =rule>
      ISA         rule
      feature2    =cutoff
      guess       =cat
   =pres>
      ISA         presentation
      feature2    =actual
   =cat>
      ISA         category
      opposite    =opp
   =actual>
      ISA         feature-value
      value       =val
   !eval!         (> =cutoff =val)
==>
   =goal>
      checked     2
      category    =opp
)

(P feature2-against-rule-v2
   =goal>
      ISA         apply-rule-to-presentation
      rule        =rule
      presentation =pres
      checked     1
      category    =cat
   =rule>
      ISA         rule
      feature2    =cutoff
    - guess       =cat
==>
   =goal>
      checked     2
)

(P feature3-against-rule-v1
   =goal>
      ISA         apply-rule-to-presentation
      rule        =rule
      presentation =pres
      checked     2
   =rule>
      ISA         rule
      feature3    =cutoff
      guess       =cat
   =pres>
      ISA         presentation
      feature3    =actual
   =cat>
      ISA         category
      opposite    =opp
   =actual>
      ISA         feature-value
      value       =val
   !eval!         (> =cutoff =val)
==>
   =goal>
      checked     3
      category    =opp
)

(P feature3-against-rule-v2
   =goal>
      ISA         apply-rule-to-presentation
      rule        =rule
      presentation =pres
      checked     2
      category    =cat
   =rule>
      ISA         rule
      feature3    =cutoff
    - guess       =cat
==>
   =goal>
      checked     3
)

(P feature4-against-rule-v1
   =goal>
      ISA         apply-rule-to-presentation
      rule        =rule
      presentation =pres
      checked     3
   =rule>
      ISA         rule
      feature4    =cutoff
      guess       =cat
   =pres>
      ISA         presentation
      feature4    =actual
   =cat>
      ISA         category
      opposite    =opp
   =actual>
      ISA         feature-value
      value       =val
   !eval!         (> =cutoff =val)
==>
   =goal>
      checked     4
      category    =opp
)

(P feature4-against-rule-v2
   =goal>
      ISA         apply-rule-to-presentation
      rule        =rule
      presentation =pres
      checked     3
      category    =cat
   =rule>
      ISA         rule
      feature4    =cutoff
    - guess       =cat
==>
   =goal>
      checked     4
)

(P feature1-is-nil
   =goal>
      ISA         apply-rule-to-presentation
      rule        =rule
      checked     0
   =rule>
      ISA         rule
      feature1    nil
==>
   =goal>
      checked     1
)

(P feature2-is-nil
   =goal>
      ISA         apply-rule-to-presentation
      rule        =rule
      checked     1
   =rule>
      ISA         rule
      feature2    nil
==>
   =goal>
      checked     2
)

(P feature3-is-nil
   =goal>
      ISA         apply-rule-to-presentation
      rule        =rule
      checked     2
   =rule>
      ISA         rule
      feature3    nil
==>
   =goal>
      checked     3
)

(P feature4-is-nil
   =goal>
      ISA         apply-rule-to-presentation
      rule        =rule
      checked     3
   =rule>
      ISA         rule
      feature4    nil
==>
   =goal>
      checked     4
)

(P done-applying-presentation
   =goal>
      ISA         apply-rule-to-presentation
      rule        =rule
      checked     4
==>
   !pop!
)

(P move-on-with-rule
   =goal>
      ISA         apply-rule-to-presentation
      rule        =rule
      checked     =n
!eval! (< =n 4)
==>
   =goal>
      checked (!eval! (1+ =n))
)

(P wild-flaming-leap-of-faith-guess
   =goal>
      ISA         classify-by-rule
      presentation =pres
==>
   =goal>
      category    (!eval! (random-category-catds11))
      exn-used    wildleapoffaith
   !pop!
)

(P check-for-exception-4
   =goal>
      ISA         classify-by-rule
      presentation =pres
   =pres>
      isa presentation
      feature1 =f1
      feature2 =f2
      feature3 =f3
      feature4 =f4
   =exception>
      isa exception
      feature1 =f1
      feature2 =f2
      feature3 =f3
      feature4 =f4
      category =c
==>
   =goal>
      category    =c
!pop!
)


(P check-for-exception-2
   =goal>
      ISA         classify-by-rule
      presentation =pres
   =pres>
      isa presentation
      feature1 =f1
      feature2 =f2
   =exception>
      isa exception
      feature1 =f1
      feature1 =f3
      feature2 =f2
      feature2 =f4
      category =c
   !eval! (and (equal =f1 =f3) (equal =f2 =f4))
==>
   =goal>
      category    =c
!pop!
)

(P recall-4feature
   =goal>
      ISA         classify-by-exemplar
      feature1    =f1
      feature2    =f2
      feature3    =f3
      feature4    =f4
      category    nil
   =recall-stim>
      ISA         stimulus
      feature1    =f1
      feature2    =f2
      feature3    =f3
      feature4    =f4
      category    =cat
==>
   !eval!         (increment-category-count =goal =cat)
   =goal>
      category    (!eval! (winner-catds11 =goal))
   !output!       ("I recall ~s" =recall-stim)
)

(P recall-continue-a
   =goal>
      isa classify-by-exemplar
==>
   !eval!         (increment-category-count =goal 'category-a)
   =goal>
      category    (!eval! (winner-catds11 =goal))
)

(P recall-continue-b
   =goal>
      isa classify-by-exemplar
==>
   !eval!         (increment-category-count =goal 'category-b)
   =goal>
      category    (!eval! (winner-catds11 =goal))
)


(P recall-2feature
   =goal>
      ISA         classify-by-exemplar
      feature1    =f1
      feature2    =f2
      feature3    nil
      feature4    nil
      category    nil
      counta      =a
   =recall-stim>
      ISA         stimulus
      feature1    =f1
      feature2    =f2
      feature3    nil
      feature4    nil
      category    =cat
==>
   !eval!         (increment-category-count =goal =cat)
   =goal>
      category    (!eval! (winner-catds11 =goal))
   !output!       ("I recall ~s" =recall-stim)
)

(P done-classifying-by-exemplar
   =goal>
      ISA         classify-by-exemplar
      category    =cat
==>
   !pop!
)

(P correct-finish-from-exemplar
   =goal>
      ISA         presentation
      category    =c
    - category    failure
      choice      exemplar
      evaluated   nil
   !eval!         (equal =c (correct-category-catds11 =goal))
==>
   =goal>
      evaluated   right
      choice      rule
)

(P incorrect-finish-by-exemplar
   =goal>
      ISA         presentation
      category    =c
    - category    failure
      choice      exemplar
      evaluated   nil
   !eval!         (not (equal =c (correct-category-catds11 =goal)))
==>
   =goal>
      evaluated   wrong
      category    (!eval! (correct-category-catds11 =goal))
   =evaluate-goal>
      ISA         evaluate
      classification-style exemplar
      last-result wrong
      presentation =goal
      count       0
   !push!         =evaluate-goal
)


(P classification-by-rule-is-right
   =goal>
      ISA         presentation
      category    =c
      choice      rule
      exn-used    nil
      evaluated   nil
   !eval!         (equal =c (correct-category-catds11 =goal))
==>
   =goal>
      evaluated   right
   =evaluate-goal>
      ISA         evaluate
      classification-style rule
      last-result right
      presentation =goal
   !push!         =evaluate-goal
)

(P classification-by-rule-is-wrong
   =goal>
      ISA         presentation
      category    =c
    - category    failure
      choice      rule
      exn-used    nil
      evaluated   nil
   !eval!         (not (equal =c (correct-category-catds11 =goal)))
==>
   =goal>
      category    (!eval! (correct-category-catds11 =goal))
      evaluated   wrong
   =evaluate-goal>
      ISA         evaluate
      classification-style rule
      presentation =goal
      last-result wrong
   !push!         =evaluate-goal
)

(P it-was-a-wild-leap-of-faith-so-find-a-rule
   =goal>
      ISA         presentation
      category    =c
      choice      rule
      exn-used    wildleapoffaith
      evaluated   nil
==>
   =goal>
      category    (!eval! (correct-category-catds11 =goal))
      evaluated   wrong
   =newgoal>
      isa clean-up
   =find-rule-goal>
      ISA         find-rule
      presentation =goal
   !push!         =find-rule-goal
   !push!         =newgoal
)

(P it-was-a-wild-leap-of-faith-so-update-rule
   =goal>
      ISA         presentation
      category    =c
      choice      rule
      exn-used    wildleapoffaith
      evaluated   nil
   =rule>
      ISA         rule
      current     t
==>
   =goal>
      category    (!eval! (correct-category-catds11 =goal))
      evaluated   wrong)

(p nothing-to-clean-up
   =goal>
      isa clean-up
==>
!pop!)


(P one-more-study-2feature-version
   =goal>
      ISA         presentation
    - evaluated   nil
      feature1    =f1
      feature2    =f2
      feature3    nil
      feature4    nil
      category    =c
      choice      rule
   !eval!         *system-is-still-learning*
==>
   =goal>
      choice      done
   =stimulus-goal>
      ISA         stimulus
      feature1    =f1
      feature2    =f2
      category    =c
   !push!         =stimulus-goal
)

(P one-more-study-4feature-version
   =goal>
      ISA         presentation
    - evaluated   nil
      feature1    =f1
      feature2    =f2
      feature3    =f3
      feature4    =f4
      category    =c
      choice      rule
   !eval!         *system-is-still-learning*
==>
   =goal>
      choice      done
   =stimulus-goal>
      ISA         stimulus
      feature1    =f1
      feature2    =f2
      feature3    =f3
      feature4    =f4
      category    =c
   !push!         =stimulus-goal
)

(P cant-study
   =goal>
      ISA         presentation
    - evaluated   nil
      choice      rule
   !eval!         (not *system-is-still-learning*)
==>
   =goal>
      choice      done
)

(P done-wrong
   =goal>
      ISA         presentation
    - choice      rule
      evaluated   wrong
==>
   !pop!
)

(P done-right
   =goal>
      ISA         presentation
    - choice      rule
      evaluated   right
==>
   !pop!
)

(P set-study-goal-4feature
   =goal>
      ISA         evaluate
      classification-style exemplar
    - count       5
      count       =count
      presentation =pres
   =pres>
      ISA         presentation
      feature1    =f1
      feature2    =f2
      feature3    =f3
      feature4    =f4
      category    =c
   !eval!         *system-is-still-learning*
==>
   =goal>
      count       (!eval! (+ 1 =count))
   =study-stimulus>
      ISA         stimulus
      feature1    =f1
      feature2    =f2
      feature3    =f3
      feature4    =f4
      category    =c
   !push!         =study-stimulus
)

(P set-study-goal-2feature
   =goal>
      ISA         evaluate
      classification-style exemplar
    - count       5
      count       =count
      presentation =pres
   =pres>
      ISA         presentation
      feature1    =f1
      feature2    =f2
      feature3    nil
      feature4    nil
      category    =c
   !eval!         *system-is-still-learning*
==>
   =goal>
      count       (!eval! (+ 1 =count))
   =study-stimulus>
      ISA         stimulus
      feature1    =f1
      feature2    =f2
      feature3    nil
      feature4    nil
      category    =c
   !push!         =study-stimulus
)

(P pop-on-study
   =goal>
      ISA         stimulus
==>
   !pop!
)

(P done-studying
   =goal>
      ISA         evaluate
      classification-style exemplar
      count       5
==>
   !pop!
)

(P no-more-learning
   =goal>
      ISA         evaluate
   !eval!         (not *system-is-still-learning*)
==>
   !pop!
)

(P perfect-rule-is-okay
   =goal>
      ISA         evaluate
      last-result right
   =rule>
      ISA         rule
      current     t
      type        perfect
   !eval!         *system-is-still-learning*
==>
   !pop!
)

(P throw-out-perfect-rule
   =goal>
      ISA         evaluate
      classification-style rule
      last-result wrong
      presentation =pres
   =rule>
      ISA         rule
      current     t
      type        perfect
      viable      t
   !eval!         *system-is-still-learning*
==>
   =rule>
      current     nil
      viable      nil
   =find-rule-goal>
      ISA         find-rule
      presentation =pres
   !focus-on!     =find-rule-goal
)

(P increment-incorrect-count
   =goal>
      ISA         evaluate
      classification-style rule
      last-result wrong
   =rule>
      ISA         rule
      current     t
    - type        perfect
      incorrect   =ic
   !eval!         *system-is-still-learning*
==>
   =rule>
      incorrect   (!eval! (+ 1 =ic))
   =goal>
      last-result nil
)

(P increment-correct-count
   =goal>
      ISA         evaluate
      classification-style rule
      last-result right
   =rule>
      ISA         rule
      current     t
    - type        perfect
      correct     =c
   !eval!         *system-is-still-learning*
==>
   =rule>
      correct     (!eval! (+ 1 =c))
   =goal>
      last-result nil
)

(P learn-exception-to-imperfect-rule-4
   =goal>
      ISA         evaluate
      classification-style rule
      last-result wrong
      presentation =pres
      exn-used    nil
   =rule>
      ISA         rule
      correct     =c
      incorrect   =ic
      type        imperfect
      current     t
   !eval!         (>= (+ =c =ic) (* 2 *block-size*))
   !eval!         (>= (/ =c (+ =c =ic)) *strict-criterion*)
   !eval!         *system-is-still-learning*
   =pres>
      ISA         presentation
      category    =cat
      feature1    =f1
      feature2    =f2
      feature3    =f3
      feature4    =f4
==>
   =goal>
      exn-used t
   =exception-goal>
      ISA         exception
      feature1    =f1
      feature2    =f2
      feature3    =f3
      feature4    =f4
      category    =cat
   !focus-on!     =exception-goal
)

(P learn-exception-to-imperfect-rule-2
   =goal>
      ISA         evaluate
      classification-style rule
      last-result wrong
      presentation =pres
      exn-used    nil
   =rule>
      ISA         rule
      correct     =c
      incorrect   =ic
      type        imperfect
      current     t
   !eval!         (>= (+ =c =ic) (* 2 *block-size*))
   !eval!         (>= (/ =c (+ =c =ic)) *strict-criterion*)
   !eval!         *system-is-still-learning*
   =pres>
      ISA         presentation
      category    =cat
      feature1    =f1
      feature2    =f2
==>
   =goal>
      exn-used t
   =exception-goal>
      ISA         exception
      feature1    =f1
      feature2    =f2
      category    =cat
   !focus-on!     =exception-goal
)

(p pop-exception
   =goal>
     isa exception
==>
!pop!)

(P imperfect-rule-not-yet-to-lower-window
   =goal>
      ISA         evaluate
      classification-style rule
      last-result nil
   =rule>
      ISA         rule
      current     t
      correct     =c
      incorrect   =ic
   !eval!         (< (+ =c =ic) *block-size*)
   !eval!         *system-is-still-learning*
==>
   !pop!
)

(P keep-rule-at-lower-window
   =goal>
      ISA         evaluate
      classification-style rule
      last-result nil
   =rule>
      ISA         rule
      correct     =c
      incorrect   =ic
    - type        perfect
      current     t
   !eval!         (>= (+ =c =ic) *block-size*)
   !eval!         (< (+ =c =ic) (* 2 *block-size*))
   !eval!         (>= (/ =c (+ =c =ic)) *lax-criterion*)
   !eval!         *system-is-still-learning*
==>
   !pop!
)

(P drop-rule-at-lower-window
   =goal>
      ISA         evaluate
      classification-style rule
      last-result nil
      presentation =pres
   =rule>
      ISA         rule
      correct     =c
      incorrect   =ic
    - type        perfect
      current     t
   !eval!         (>= (+ =c =ic) *block-size*)
   !eval!         (< (+ =c =ic) (* 2 *block-size*))
   !eval!         (< (/ =c (+ =c =ic)) *lax-criterion*)
   !eval!         *system-is-still-learning*
==>
   =rule>
      current     nil
      viable      nil
   =find-rule-goal>
      ISA         find-rule
      presentation =pres
   !focus-on!     =find-rule-goal
)

(P keep-imperfect-rule-at-upper-window
   =goal>
      ISA         evaluate
      classification-style rule
      last-result nil
      presentation =pres
   =rule>
      ISA         rule
      correct     =c
      incorrect   =ic
      type        imperfect
      current     t
   !eval!         (>= (+ =c =ic) (* 2 *block-size*))
   !eval!         (>= (/ =c (+ =c =ic)) *strict-criterion*)
   !eval!         *system-is-still-learning*
==>
   !pop!
)


(P drop-imperfect-rule-at-uwindow
   =goal>
      ISA         evaluate
      classification-style rule
      last-result nil
      presentation =pres
   =rule>
      ISA         rule
      correct     =c
      incorrect   =ic
      type        imperfect
      current     t
   !eval!         (= (+ =c =ic) (* 2 *block-size*))
   !eval!         (< (/ =c (+ =c =ic)) *strict-criterion*)
   !eval!         *system-is-still-learning*
==>
   =rule>
      current     nil
      viable      nil
   =find-rule-goal>
      ISA         find-rule
      presentation =pres
   !focus-on!     =find-rule-goal
)





(P select-perfect-rule
   =goal>
      ISA         find-rule
      presentation =pres
   =rule>
      ISA         rule
      viable      t
      current     nil
      type        perfect
   =pres>
      ISA         presentation
   !eval!         *system-is-still-learning*
==>
   =rule>
      current     t
      guess       (!eval! (rule-category-catds11 =rule =pres))
   !pop!
)

(P select-imperfect-rule
   =goal>
      ISA         find-rule
      presentation =pres
   =rule>
      ISA         rule
      viable      t
      current     nil
      type        imperfect
   =pres>
      ISA         presentation
   !eval!         *system-is-still-learning*
==>
   =rule>
      current     t
      guess       (!eval! (rule-category-catds11 =rule =pres))
      correct     1
   !pop!
)




(spp SELECT-PERFECT-RULE :SUCCESSES 1000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 1000 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 1000)
(spp SELECT-IMPERFECT-RULE :SUCCESSES 1000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 750 :EVENTUAL-FAILURES 250 :EVENTUAL-EFFORTS 1000)
(spp SET-STUDY-GOAL-4FEATURE :SUCCESSES 1000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 1000 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 1000)
(spp SET-STUDY-GOAL-2FEATURE :SUCCESSES 1000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 1000 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 1000)
(spp NO-MORE-LEARNING :SUCCESSES 1000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 1000 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 1000)
(spp RECALL-4FEATURE :SUCCESSES 1000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 1000 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 1000)
(spp RECALL-2FEATURE :STRENGTH 10 :SUCCESSES 1000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 1000 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 1000)
(spp DONE-CLASSIFYING-BY-EXEMPLAR :EFFORT 0.20 :SUCCESSES 1000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 1000 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 1000)
(spp WILD-FLAMING-LEAP-OF-FAITH-GUESS  :SUCCESSES 1000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 250 :EVENTUAL-FAILURES 750 :EVENTUAL-EFFORTS 1000)
(spp GENERAL-RULE-MATCH :SUCCESSES 10000 :FAILURES 0 :EFFORTS 500 :EVENTUAL-SUCCESSES 8000 :EVENTUAL-FAILURES 2000 :EVENTUAL-EFFORTS 10000)
(spp DONE-CLASSIFYING-BY-RULE :EFFORT 0.20 :SUCCESSES 1000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 1000 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 1000)
(spp POP-ON-STUDY :SUCCESSES 1000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 1000 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 1000)
(spp keep-imperfect-rule-at-upper-window :SUCCESSES 1000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 500 :EVENTUAL-FAILURES 500 :EVENTUAL-EFFORTS 1000)
(spp recall-continue-a :SUCCESSES 10000 :FAILURES 0 :EFFORTS 500 :EVENTUAL-SUCCESSES 2500 :EVENTUAL-FAILURES 7500 :EVENTUAL-EFFORTS 10000)
(spp recall-continue-b :SUCCESSES 10000 :FAILURES 0 :EFFORTS 500 :EVENTUAL-SUCCESSES 2500 :EVENTUAL-FAILURES 7500 :EVENTUAL-EFFORTS 10000)
(spp increment-incorrect-count :SUCCESSES 1000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 750 :EVENTUAL-FAILURES 250 :EVENTUAL-EFFORTS 1000)
(spp increment-correct-count :SUCCESSES 1000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 750 :EVENTUAL-FAILURES 250 :EVENTUAL-EFFORTS 1000)
(spp learn-exception-to-imperfect-rule-2 :SUCCESSES 1000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 1000 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 1000)
(spp learn-exception-to-imperfect-rule-4 :SUCCESSES 1000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 1000 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 1000)
(spp pop-exception :SUCCESSES 1000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 1000 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 1000)
(spp check-for-exception-2 :SUCCESSES 1000000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 1000 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 1000)
(spp check-for-exception-4 :SUCCESSES 1000000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 1000 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 1000)
(spp RANDOM-GUESS-WAS-RIGHT :SUCCESSES 1000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 1000 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 1000)
(spp ONE-MORE-STUDY-4FEATURE-VERSION :SUCCESSES 1000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 1000 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 1000)
(spp ONE-MORE-STUDY-2FEATURE-VERSION :SUCCESSES 1000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 1000 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 1000)
(spp IT-WAS-A-WILD-LEAP-OF-FAITH-SO-FIND-A-RULE :SUCCESSES 1000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 500 :eventual-failures 500 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 1000)
(spp it-was-a-wild-leap-of-faith-so-update-rule :SUCCESSES 1000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 1000 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 1000)

(spp INCORRECT-FINISH-BY-EXEMPLAR :SUCCESSES 1000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 1000 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 1000)
(spp DONE-RIGHT :SUCCESSES 1000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 1000 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 1000)
(spp COVER-FOR-FAILED-CLASSIFY :SUCCESSES 1000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 1000 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 1000)
(spp CORRECT-FINISH-FROM-EXEMPLAR :SUCCESSES 1000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 1000 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 1000)
(spp CLASSIFICATION-BY-RULE-IS-WRONG :SUCCESSES 1000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 1000 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 1000)
(spp CLASSIFICATION-BY-RULE-IS-RIGHT :SUCCESSES 1000 :FAILURES 0 :EFFORTS 50 :EVENTUAL-SUCCESSES 1000 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 1000)
(spp CHOOSE-TO-CLASSIFY-BY-RULE :SUCCESSES 20 :FAILURES 0 :EFFORTS 1 :EVENTUAL-SUCCESSES 30 :EVENTUAL-EFFORTS 30)
(spp CHOOSE-TO-CLASSIFY-BY-EXEMPLAR-4FEATURE :SUCCESSES 2400 :EFFORTS 120 :EVENTUAL-SUCCESSES 30 :EVENTUAL-FAILURES 50 :EVENTUAL-EFFORTS 80)
(spp DONE-WRONG :EVENTUAL-EFFORTS 1000 :EVENTUAL-FAILURES 0 :EFFORTS 50 :SUCCESSES 1000 :EVENTUAL-SUCCESSES 1000 :FAILURE T)
(spp CHOOSE-TO-CLASSIFY-BY-EXEMPLAR-2FEATURE :EFFORT 0.1  :FAILURES 0 :SUCCESSES 2400 :EFFORTS 120 :EVENTUAL-SUCCESSES 30 :EVENTUAL-FAILURES 50 :EVENTUAL-EFFORTS 80)
(spp CANT-DO-JACK :SUCCESSES 10000 :EFFORTS 500 :EVENTUAL-SUCCESSES 12500 :EVENTUAL-FAILURES 87500 :EVENTUAL-EFFORTS 100000)

(spp FEATURE1-AGAINST-RULE :EFFORT 0.05 :SUCCESSES 100 :EFFORTS 5 :EVENTUAL-SUCCESSES 100 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 100)
(spp FEATURE1-WITH-RULE :EFFORT 0.05 :SUCCESSES 100 :EFFORTS 5 :EVENTUAL-SUCCESSES 100 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 100)
(spp FEATURE1-IS-NIL :EFFORT 0.05 :SUCCESSES 100 :EFFORTS 5 :EVENTUAL-SUCCESSES 100 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 100)

(spp FEATURE2-AGAINST-RULE-V1 :EFFORT 0.05 :SUCCESSES 100 :EFFORTS 5 :EVENTUAL-SUCCESSES 100 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 100)
(spp FEATURE2-AGAINST-RULE-V2 :EFFORT 0.05 :SUCCESSES 100 :EFFORTS 5 :EVENTUAL-SUCCESSES 100 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 100)
(spp FEATURE2-WITH-RULE-V1 :EFFORT 0.05 :SUCCESSES 100 :EFFORTS 5 :EVENTUAL-SUCCESSES 100 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 100)
(spp FEATURE2-WITH-RULE-V2 :EFFORT 0.05 :SUCCESSES 100 :EFFORTS 5 :EVENTUAL-SUCCESSES 100 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 100)
(spp FEATURE2-IS-NIL :EFFORT 0.05 :SUCCESSES 100 :EFFORTS 5 :EVENTUAL-SUCCESSES 100 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 100)
(spp move-on-with-rule :EFFORT 0.05 :SUCCESSES 100 :EFFORTS 5 :EVENTUAL-SUCCESSES 100 :EVENTUAL-FAILURES 300 :EVENTUAL-EFFORTS 400)
(spp FEATURE3-AGAINST-RULE-V1 :EFFORT 0.05 :SUCCESSES 100 :EFFORTS 5 :EVENTUAL-SUCCESSES 100 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 100)
(spp FEATURE3-AGAINST-RULE-V2 :EFFORT 0.05 :SUCCESSES 100 :EFFORTS 5 :EVENTUAL-SUCCESSES 100 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 100)
(spp FEATURE3-WITH-RULE-V1 :EFFORT 0.05 :SUCCESSES 100 :EFFORTS 5 :EVENTUAL-SUCCESSES 100 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 100)
(spp FEATURE3-WITH-RULE-V2 :EFFORT 0.05 :SUCCESSES 100 :EFFORTS 5 :EVENTUAL-SUCCESSES 100 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 100)
(spp FEATURE3-IS-NIL :EFFORT 0.05 :SUCCESSES 100 :EFFORTS 5 :EVENTUAL-SUCCESSES 100 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 100)

(spp FEATURE4-AGAINST-RULE-V1 :EFFORT 0.05 :SUCCESSES 100 :EFFORTS 5 :EVENTUAL-SUCCESSES 100 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 100)
(spp FEATURE4-AGAINST-RULE-V2 :EFFORT 0.05 :SUCCESSES 100 :EFFORTS 5 :EVENTUAL-SUCCESSES 100 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 100)
(spp FEATURE4-WITH-RULE-V1 :EFFORT 0.05 :SUCCESSES 100 :EFFORTS 5 :EVENTUAL-SUCCESSES 100 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 100)
(spp FEATURE4-WITH-RULE-V2 :EFFORT 0.05 :SUCCESSES 100 :EFFORTS 5 :EVENTUAL-SUCCESSES 100 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 100)
(spp FEATURE4-IS-NIL :EFFORT 0.05 :SUCCESSES 100 :EFFORTS 5 :EVENTUAL-SUCCESSES 100 :EVENTUAL-FAILURES 0 :EVENTUAL-EFFORTS 100)