 |
 |
 |
 |
 |
Forschung > Plan-a-Day > Plan-a-Day ACT-R model
Plan-a-Day ACT-R model
In our attempt to model the planning processes of subjects working on the task Plan-a-Day (PAD), an ACT-R model has been developed by Stefani Nellen.
THE PAD is a computer-based interactive task which was designed to measure and analyze the quality and characteristics of people’s planning behavior, their choice, modification and abundance of different strategies, and ultimately the efficacy of these stategies. Providing only minimum feedback, PAD allows for the subjects to reconsider and change their strategies. Thus, the resulting data mirror the vast variety of planning behavior. This includes (e.g.) biases towards certain strategies, the effects of mistakes past, and the (in)ability to learn from them, and also, to a lesser degree, motivational differences.
Our model describes this variety of strategies by modelling them (and their results) within the framework of the ACT theory (using the ACT-Environment, version 4.0). It is our ambition to provide a procedurally detailed, and plausible, yet theoretically still general account of subject’s cognitive and actual performance while working on PAD.
The interface from PAD (i.e., what subjects see on the screen of their PC) can be seen here, together with a short excerpt from the instruction.
Reference
ACT-R Source Code
(defvar *moni* nil)
(defvar *expl* nil)
(defparameter *possible* t)
(defvar *model-data* nil)
(defvar *move-sequence* nil)
(defvar *subtask-list* nil)
(defvar *collection* nil)
(defparameter *systime* 0)
(defparameter *time-est* 0)
(defun firstseq (lis)
(car lis))
(defun firstsubtask (lis)
(car (firstseq lis)))
(defun lastseq (lis)
(car (reverse lis)))
(defun modifications (lis)
(mapcar #'(lambda (x)
(- (length x) 1)) lis))
(defun sequence-length (lis)
(mapcar #'(lambda (x)
(truncate (my-mean
(mapcar #'length x)))) lis))
(defun mod-ms (mod ms)
(mapcar #'- mod ms))
(defun switch-count (lis)
(mapcar #'(lambda (x)
(- (apply #'+
(maplist
#'(lambda (y)
(if (not (equal
(caar y)
(caadr y)))
1
0)) x)) 1)) lis))
(defun map-remove-cars (lis)
(defun remove-car (lis)
(remove-if #'(lambda (i) (equal i 'car)) lis))
(defun remove-all-cars (lis)
(mapcar #'remove-car lis))
(mapcar #'remove-all-cars lis))
(defun how-often-sequence-of-this-length? (elem lis)
(defun compare (el lis)
(cond ((endp lis) 0)
((= (car lis) el) (+ 1 (compare el (cdr lis))))
(t (compare el (cdr lis)))))
(let ((lengthmapping
(mapcar #'(lambda (x)
(mapcar #'length x)) lis)))
(mapcar #'(lambda (y)
(compare elem y)) lengthmapping)))
(defun sequences-of-each-length (n lis)
(dotimes (i (+ 1 n))
(format t "~%~%Number of sequences of length ~s"
i)
(my-display (how-often-sequence-of-this-length? i lis))))
(defun my-member (item lis)
(cond ((endp lis) nil)
((equal item (car lis)) t)
(t (member item (cdr lis)))))
(defun map-repetition-counter (lis)
(mapcar #'(lambda (x)
(apply #'+
(maplist
#'(lambda (x)
(if (my-member (car x) (cdr x)) 1
0)) x))) lis))
(defun first-last (subtask solution)
(let ((temp (append *moni* *expl*)))
(apply '+
(mapcar #'(lambda (x) (if (and (equal (firstsubtask x) subtask) (equal (lastseq x) solution))
1 0)) temp))))
(defun seq-last (seq solution)
(let* ((concat (append *moni* *expl*))
(temp (remove-if-not #'(lambda (x) (equal (lastseq x) solution)) concat)))
(print temp)
(print concat)
(apply '+
(mapcar #'(lambda (x) (if (and (my-member seq x) (equal (lastseq x) solution))
(defun repetitions ()
(let* ((concat (append *moni* *expl*))
(temp (remove-if-not #'(lambda (x) (>= (length x) 2)) concat)))
(print concat)
(print temp)
(apply '+
(mapcar #'(lambda (x) (if (equal (lastseq x) (cadr (reverse x)))
1 0)) temp))))
(defun firsts (subtask)
(format t "~%Number of monitorers who chose ~s as first subtask: ~s"
subtask
(apply '+
(mapcar #'(lambda (x) (if (equal (firstsubtask x) subtask)
1 0)) *moni*)))
(format t "~%Number of Explorers who chose ~s as first subtask: ~s"
subtask
(apply '+
(mapcar #'(lambda (x) (if (equal (firstsubtask x) subtask)
1 0)) *expl*)))))
(defun length-of-last-sequence ()
(my-display (append (mapcar #'length (mapcar #'lastseq *moni*))
(mapcar #'length (mapcar #'lastseq *expl*)))))
(defun undone-subtasks ()
(swm isa subtask status nil))
(defun undo-move (t1 t2 t3)
(decf *systime* (+ t1 t2 t3))
(pop *subtask-list*))
(defun undo-move-car (t1 t2 t3)
(decf *systime* (+ t1 t2 t3))
(pop *subtask-list*)
(pop *subtask-list*))
(defun undo-monitoring (t1 t2 t3)
(decf *time-est* (+ T1 T2 T3)))
(defun update-moves ()
(if (consp *subtask-list*)
(push *subtask-list* *move-sequence*)))
(defun number-of-undone-subtasks ()
(length (no-output (swm isa subtask status nil))))
(defun count-correction (lis)
(if (member 'car lis) (- (length lis) 1)
(length lis)))
(defun show-moves ()
(mapcar #'reverse (reverse *move-sequence*)))
(defun show-model-data ()
(mapcar #'reverse (reverse *model-data*)))
(defun update-selection (subtask distance)
(push subtask *subtask-list*)
(incf *systime* distance ))
(defun update-selection-car (subtask distance)
(push 'car *subtask-list*)
(push subtask *subtask-list*)
(incf *systime* distance ))
(defun mental-update-selection (subtask distance)
(push subtask *collection*)
(incf *time-est* distance ))
(defun calculate-wait (start-time)
(if (equal *level* 'execute)
(let ((result (- start-time *systime*)))
(if (< result 0)
0
result))
(let ((result (- start-time *time-est*)))
(if (< result 0)
0
result))))
(defun print-state ()
(format t "~%Systime: ~17d, Possible: ~4a, State: ~s"
(truncate *systime*) *possible* (reverse *subtask-list*)))
(defun monitoring-state ()
(format t "~%Time-est: ~17d, Possible?: ~4a, State: ~s"
(truncate *time-est*) *possible* (reverse *collection*)))
(defun execute? ()
(if (equal *level* 'execute) T
nil))
(defun monitoring? ()
(if (equal *level* 'im) T
nil))
(defun revert-to-monitoring ()
(setf *level* 'im)
(setf *time-est* *systime*))
(defun execute-now ()
(setf *level* 'execute)
(setf *collection* nil))
(defun priority-check ()
(mapcar #'(lambda (x) (chunk-slot-value-fct x 'priority))
(no-output (swm isa subtask status nil))))
(defun done-the-important-stuff? ()
(not (member 1 (priority-check))))
(defun impossible-subtask-chunk ()
(let* ((items (no-output (swm isa subtask status nil))))
(dolist (x items)
(when (< (chunk-slot-value-fct x 'end-time) *systime*)
(return x)))))
(defun impossible-subtask-priority-chunk ()
(let* ((items (no-output (swm isa subtask status nil))))
(dolist (x items)
(when (and (< (chunk-slot-value-fct x 'end-time) *systime*)
(< (chunk-slot-value-fct x 'priority) 3))
(return x)))))
(defun is-possible? (end-time)
(>= end-time *systime*))
(defun is-possible-in-the-brain? (end-time)
(>= end-time *time-est*))
(defun my-mean (list)
(let ((count 0))
(dolist (x list)
(incf count x))
(/ count (length list))))
(defun convert-timepoints (lis)
(let* ((newlis (reverse lis))
(start 0)
(result nil))
(dolist (x newlis)
(push (- x start) result)
(setf start x))
(reverse result)))
(defun test-run-1 ()
(reset)
(sgp :v nil)
(setf *possible* t)
(setf *subtask-list* nil)
(setf *systime* 0)
(setf *time-est* 0)
(setf *move-sequence* nil)
(run)
(sgp :v t)
(push (mapcar #'reverse (reverse *move-sequence*)) *model-data*)
(show-moves))
(defun my-display (lis)
(format t "~%mean: ~s"
(truncate (my-mean lis)))
(format t "~%max.: ~s"
(apply #'max lis))
(format t "~%min.: ~s"
(apply #'min lis)))
(defun model-test (n)
(setf *model-data* nil)
(dotimes (i n)
(test-run-1))
(format t "~%~%Number of repetitions")
(my-display (map-repetition-counter *model-data*))
(format t "~%~%Repetitions of last two subtasks")
(my-display (repetition-counter-last-two *model-data*))
(format t "~%~%Repetitions-of-first-two-subtasks")
(my-display (repetition-counter-first-two *model-data*))
(format t "~%~%Number of switches")
(my-display (switch-count *model-data*))
(format t "~%~%Sequence-length")
(my-display (sequence-length *model-data*))
(terpri)
(show-model-data))
(defun find-best-st ()
(let* ((items (no-output (swm isa subtask status nil)))
(best (list (first items)))
(best-score (chunk-slot-value-fct (first items) 'start-time)))
(dolist (x (rest items))
(cond ((equal best-score (chunk-slot-value-fct x 'start-time))
(push x best))
((< (chunk-slot-value-fct x 'start-time) best-score)
(setf best-score (chunk-slot-value-fct x 'start-time))
(setf best (list x)))))
(cond ((equal (length best) 1)
(first best))
(t
(elt best (random (length best)))))))
(defun find-best-et ()
(let* ((items (no-output (swm isa subtask status nil)))
(best (list (first items)))
(best-score (chunk-slot-value-fct (first items) 'end-time)))
(dolist (x (rest items))
(cond ((equal best-score (chunk-slot-value-fct x 'end-time))
(push x best))
((and (< (chunk-slot-value-fct x 'end-time) best-score)
(<= *systime* (chunk-slot-value-fct x 'end-time)))
(setf best-score (chunk-slot-value-fct x 'start-time))
(setf best (list x)))))
(cond ((< best-score 0)
nil)
((= (length best) 1)
(first best))
(t
(elt best (random (length best)))))))
(defun find-best-priority ()
(let* ((items (no-output (swm isa subtask status nil)))
(best (list (first items)))
(best-score (chunk-slot-value-fct (first items) 'priority)))
(dolist (x (rest items))
(cond ((equal best-score (chunk-slot-value-fct x 'priority))
(push x best))
((< (chunk-slot-value-fct x 'priority) best-score)
(setf best-score (chunk-slot-value-fct x 'priority))
(setf best (list x)))))
(cond ((equal (length best) 1)
(first best))
(t
(elt best (random (length best)))))))
(defun find-best-start-time-priority ()
(let* ((items (no-output (swm isa subtask status nil)))
(best (list (first items)))
(best-score (chunk-slot-value-fct (first items) 'priority)))
(dolist (x (rest items))
(cond ((equal best-score (chunk-slot-value-fct x 'priority))
(push x best))
((< (chunk-slot-value-fct x 'priority) best-score)
(setf best-score (chunk-slot-value-fct x 'priority))
(setf best (list x)))))
(cond ((equal (length best) 1)
(first best))
(t
(elt best (random (length best)))))))
(defun find-best-start-time-distance ()
(let ((items (no-output (swm isa subtask status nil)))
(current (chunk-slot-value-fct 'foo 'name))
(best nil)
(best-score 9999))
(dolist (x items)
(let* ((distance-fact
(first (no-output (funcall #'swm-fct
`(isa distance-fact subtask1 ,current subtask2 ,x)))))
(distance (chunk-slot-value-fct distance-fact 'distance)))
(cond ((equal best-score distance) (push x best))
((< distance best-score) (setf best-score distance)
(setf best (list x))))))
(cond ((equal (length best) 1) (first best))
(t (elt best (random (length best)))))))
(defun max-distance (start-location)
(let* ((items (no-output
(funcall #'swm-fct
`(isa distance-fact subtask1
,start-location)))))
(setf items (remove-if
#'(lambda (x)
(not (null (chunk-slot-value-fct
(chunk-slot-value-fct x 'subtask2)
'status))))
items))
(let ((best-score (chunk-slot-value-fct (first items) 'distance)))
(dolist (x (rest items))
(when (> (chunk-slot-value-fct x 'distance) best-score)
(setf best-score (chunk-slot-value-fct x 'distance))))
best-score)))
(defun find-best (type)
(case type
(start-time (find-best-st))
(end-time (find-best-et))
(priority (find-best-priority))
(start-time-d (find-best-start-time-distance))
(start-time-p (find-best-start-time-priority))))
(defun pick-new-strategy (old)
(let ((items (remove old
'(start-time
end-time
priority
start-time-d
start-time-p))))
(elt items (random (length items)))))
(clear-all)
(sgp :era t :er t :ol nil :egs 0.5 :rt 0.0)
(sgp :pct nil)
(chunk-type distance-fact subtask1 subtask2 distance)
(chunk-type subtask name start-time end-time priority duration status travel from how waiting effective-duration)
(chunk-type apply-st main-type subtype temp)
(chunk-type current-point name)
(chunk-type icp name)
(chunk-type update-selection subtask)
(chunk-type imaginary-update-selection subtask)
(chunk-type imaginary-update-selection-car subtask)
(chunk-type update-selection-car subtask)
(chunk-type evaluation subtask)
(chunk-type pre-evaluation subtask)
(chunk-type pad status strategy prev-strategy size)
(chunk-type undo-move subtask level)
(chunk-type reorder s1 s2 level)
(chunk-type undo-multiple count level)
(chunk-type update-multiple subtasks prev count success)
(chunk-type car status)
(add-dm
(start-time ISA chunk)
(k ISA subtask end-time 180 name k start-time 180 priority 1 duration 60)
(l ISA subtask end-time 135 name l start-time 0 priority 2 duration 10)
(s ISA subtask end-time 360 name s start-time 60 priority 3 duration 10)
(v ISA subtask end-time 270 name v start-time 0 duration 90 priority 1)
(d ISA subtask end-time 360 name d start-time 0 duration 90 priority 1)
(foo ISA current-point name b)
(pittsburgh ISA icp name b)
(car ISA car status nil)
(b-d ISA distance-fact subtask1 b subtask2 d distance 64)
(b-k ISA distance-fact subtask1 b subtask2 k distance 76)
(b-l ISA distance-fact subtask1 b subtask2 l distance 40)
(b-s ISA distance-fact subtask1 b subtask2 s distance 26)
(b-v ISA distance-fact subtask1 b subtask2 v distance 21)
(l-v ISA distance-fact subtask1 l subtask2 v distance 38)
(l-d ISA distance-fact subtask1 l subtask2 d distance 25)
(l-s ISA distance-fact subtask1 l subtask2 s distance 14)
(l-k ISA distance-fact subtask1 l subtask2 k distance 36)
(v-l ISA distance-fact subtask1 v subtask2 l distance 38)
(v-k ISA distance-fact subtask1 v subtask2 k distance 74)
(v-s ISA distance-fact subtask1 v subtask2 s distance 24)
(v-d ISA distance-fact subtask1 v subtask2 d distance 62)
(d-k ISA distance-fact subtask1 d subtask2 k distance 12)
(d-l ISA distance-fact subtask1 d subtask2 l distance 25)
(d-s ISA distance-fact subtask1 d subtask2 s distance 39)
(d-v ISA distance-fact subtask1 d subtask2 v distance 62)
(s-d ISA distance-fact subtask1 s subtask2 d distance 39)
(s-l ISA distance-fact subtask1 s subtask2 l distance 14)
(s-v ISA distance-fact subtask1 s subtask2 v distance 24)
(s-k ISA distance-fact subtask1 s subtask2 k distance 50)
(k-l ISA distance-fact subtask1 k subtask2 l distance 36)
(k-s ISA distance-fact subtask1 k subtask2 s distance 50)
(k-v ISA distance-fact subtask1 k subtask2 v distance 74)
(k-d ISA distance-fact subtask1 k subtask2 d distance 12)
(goal ISA pad strategy no-strategy prev-strategy no-strategy size 5))
(P pick-any-strategy
=goal>
ISA pad
strategy no-strategy
!eval! *possible*
!eval! (monitoring?)
==>
=goal>
strategy (!eval! (pick-new-strategy nil))
)
(P revert-to-monitoring
=goal>
ISA pad
strategy =strategy
=co>
ISA current-point
name =name
=icp>
ISA icp
name =othername
!eval! (execute?)
!eval! *possible*
==>
!eval! (revert-to-monitoring)
=goal>
strategy (!eval! (pick-new-strategy =strategy))
=icp>
name =name
)
(P start-execute-one-subtask
=goal>
ISA pad
!eval! *possible*
!eval! (monitoring?)
!eval! (= (count-correction *collection*) 1)
==>
=newgoal>
ISA update-multiple
subtasks (!eval! (reverse *collection*))
prev nil
count (!eval! (count-correction *collection*))
!eval! (execute-now)
!push! =newgoal
)
(P start-execute-two-subtasks
=goal>
ISA pad
!eval! *possible*
!eval! (= (count-correction *collection*) 2)
!eval! (monitoring?)
==>
=newgoal>
ISA update-multiple
subtasks (!eval! (reverse *collection*))
prev nil
count (!eval! (count-correction *collection*))
!eval! (execute-now)
!push! =newgoal
)
(P start-execute-three-subtasks
=goal>
ISA pad
!eval! *possible*
!eval! (= (count-correction *collection*) 3)
!eval! (monitoring?)
==>
=newgoal>
ISA update-multiple
subtasks (!eval! (reverse *collection*))
prev nil
count (!eval! (count-correction *collection*))
!eval! (execute-now)
!push! =newgoal
)
(P start-execute-four-subtasks
=goal>
ISA pad
!eval! *possible*
!eval! (= (count-correction *collection*) 4)
!eval! (monitoring?)
==>
=newgoal>
ISA update-multiple
subtasks (!eval! (reverse *collection*))
prev nil
count (!eval! (count-correction *collection*))
!eval! (execute-now)
!push! =newgoal
)
(P start-execute-remember-failure
=goal>
ISA pad
!eval! *possible*
!eval! (consp *collection*)
=experience>
ISA update-multiple
subtasks =subtasks
prev =prev
success no
!eval! (equal (append (reverse =prev) =subtasks) *collection*)
==>
=newgoal>
ISA undo-multiple
level imagine
count (!eval! (count-correction *collection*))
!push! =newgoal
)
(P task-done
=goal>
ISA pad
size =size
!eval! (equal (length *subtask-list*) =size)
!eval! *possible*
==>
!pop!
!output! ( yes we are done!)
!eval! (update-moves)
)
(P task-done-enough-lazy
=goal>
ISA pad
!eval! (<= (number-of-undone-subtasks) 2)
!eval! (consp *move-sequence*)
==>
!pop!
!output! ( i have done enough)
!eval! (update-moves)
)
(P task-done-enough-pragmatic
=goal>
ISA pad
!eval! (= (number-of-undone-subtasks) 1)
!eval! (done-the-important-stuff?)
!eval! (consp *move-sequence*)
==>
!pop!
!output! ( i have done enough)
!eval! (update-moves)
)
(P task-dome-also-quite-pragmatic
=goal>
ISA pad
!eval! (>= (length *move-sequence*) 2)
==>
!pop!
!output! ( i do not want anymore)
!eval! (update-moves)
)
(P task-give-up
=goal>
ISA pad
==>
!pop!
!output! ( i hate this damn task)
!eval! (update-moves)
)
(P task-stop-discard-irrelevant-subtask
=goal>
ISA pad
size =size
=cp>
ISA current-point
name =s1
=s1>
ISA subtask
priority 3
status selected
!eval! (not *possible*)
==>
!pop!
!output! ( f*** the secretary)
!eval! (update-moves)
)
(P task-stop-discard-last-subtask
=goal>
ISA pad
size =size
!eval! (= 1 (number-of-undone-subtasks))
=cp>
ISA current-point
name =s1
=s1>
ISA subtask
status selected
!eval! *possible*
==>
!pop!
!output! ( f*** the ***)
!eval! (update-moves)
)
(P task-stop-discard-subtask
=goal>
ISA pad
size =size
!eval! (= 1 (number-of-undone-subtasks))
=cp>
ISA current-point
name =s1
=s1>
ISA subtask
status selected
!eval! (not *possible*)
==>
!pop!
!output! ( f*** whatever comes after)
!eval! (update-moves)
)
(P pick-start-time-strategy
=goal>
ISA pad
strategy start-time
!eval! *possible*
!eval! (monitoring?)
==>
=goal>
strategy start-time
=apply-strategy-goal>
ISA apply-st
main-type start-time
!push! =apply-strategy-goal
)
(P pick-start-time-priority-strategy
=goal>
ISA pad
strategy start-time-p
!eval! *possible*
!eval! (monitoring?)
==>
=goal>
strategy start-time-p
=apply-strategy-goal>
ISA apply-st
main-type start-time
subtype priority
!push! =apply-strategy-goal
)
(P pick-start-time-distance-strategy
=goal>
ISA pad
strategy start-time-d
!eval! *possible*
!eval! (monitoring?)
==>
=goal>
strategy start-time-d
=apply-strategy-goal>
ISA apply-st
main-type start-time
subtype distance
!push! =apply-strategy-goal
)
(P pick-end-time-strategy
=goal>
ISA pad
strategy end-time
!eval! *possible*
!eval! (monitoring?)
==>
=goal>
strategy end-time
=apply-strategy-goal>
ISA apply-st
main-type end-time
!push! =apply-strategy-goal
)
(P pick-priority-strategy
=goal>
ISA pad
strategy priority
!eval! *possible*
!eval! (monitoring?)
==>
=goal>
strategy priority
=apply-strategy-goal>
ISA apply-st
main-type priority
!push! =apply-strategy-goal
)
(P pick-crossover-when-failed
=goal>
ISA pad
strategy =strategy
- strategy crossover
!eval! (not *possible*)
!eval! (execute?)
!eval! (>= (count-correction *subtask-list*) 2)
==>
=goal>
strategy crossover
prev-strategy =strategy
=reorder>
ISA reorder
s1 nil
s2 nil
!push! =reorder
!eval! (update-moves)
)
(P pick-crossover-when-failed-imaginary
=goal>
ISA pad
strategy =strategy
- strategy crossover
!eval! (not *possible*)
!eval! (monitoring?)
!eval! (>= (count-correction *collection*) 2)
==>
=goal>
strategy crossover
prev-strategy =strategy
=reorder>
ISA reorder
level imagine
s1 nil
s2 nil
!push! =reorder
)
(P time-economy-normal
=goal>
ISA pad
!bind! =s2 (impossible-subtask-chunk)
!eval! *possible*
!eval! (execute?)
==>
=newgoal>
ISA update-selection
subtask =s2
!push! =newgoal
=undo>
ISA undo-move
!push! =undo
!eval! (update-moves)
)
(P time-economy-imaginary
=goal>
ISA pad
!bind! =s2 (impossible-subtask-chunk)
!eval! *possible*
!eval! (consp *collection*)
!eval! (monitoring?)
==>
=newgoal>
ISA imaginary-update-selection
subtask =s2
!push! =newgoal
=undo>
ISA undo-move
level imagine
!push! =undo
)
(P time-economy-priority
=goal>
ISA pad
!bind! =s2 (impossible-subtask-priority-chunk)
!eval! *possible*
!eval! (execute?)
==>
=newgoal>
ISA update-selection
subtask =s2
!push! =newgoal
=undo>
ISA undo-move
!push! =undo
!eval! (update-moves)
)
(P time-economy-priority-imaginary
=goal>
ISA pad
!bind! =s2 (impossible-subtask-priority-chunk)
!eval! *possible*
!eval! (consp *collection*)
!eval! (monitoring?)
==>
=newgoal>
ISA imaginary-update-selection
subtask =s2
!push! =newgoal
=undo>
ISA undo-move
level imagine
!push! =undo
)
(P use-car-when-sophisticated
=goal>
ISA pad
strategy =strategy
=cp>
ISA current-point
name =s1
=s1>
ISA subtask
from =from
travel =distance
=car>
ISA car
- status nolongeravailable
!eval! (execute?)
!eval! (equal =distance (max-distance =from))
==>
=new-goal>
ISA apply-st
main-type use-car
subtype =strategy
!push! =new-goal
)
(P use-car-when-sophisticated-imagine
=goal>
ISA pad
strategy =strategy
!eval! (monitoring?)
=icp>
ISA icp
name =s1
=s1>
ISA subtask
from =from
travel =distance
=car>
ISA car
status nil
!eval! (equal =distance (max-distance =from))
==>
=new-goal>
ISA apply-st
main-type use-car
subtype =strategy
temp imagine
!push! =new-goal
)
(P use-car-when-failed
=goal>
ISA pad
strategy =strategy
=car>
ISA car
status nil
- status nolongeravailable
!eval! (not *possible*)
!eval! (execute?)
==>
=new-goal>
ISA apply-st
main-type use-car
subtype simple
!push! =new-goal
!eval! (update-moves)
)
(P use-car-when-failed-imagine
=goal>
ISA pad
strategy =strategy
!eval! (monitoring?)
=car>
ISA car
status nil
!eval! (not *possible*)
==>
=new-goal>
ISA apply-st
main-type use-car
subtype simple
temp imagine
!push! =new-goal
)
(P continue-with-previous-after-use-car
=goal>
ISA pad
strategy use-car
prev-strategy =previous
!eval! *possible*
==>
=goal>
strategy =previous
prev-strategy use-car
)
(P continue-with-different-after-use-car
=goal>
ISA pad
strategy use-car
prev-strategy =previous
!eval! *possible*
==>
=goal>
strategy (!eval! (pick-new-strategy =previous))
prev-strategy use-car
)
(P switch-to-new-strategy-when-failed-crossover
=goal>
ISA pad
prev-strategy =prev-strat
strategy crossover
!eval! (not *possible*)
!eval! (execute?)
==>
=goal>
strategy (!eval! (pick-new-strategy =prev-strat))
prev-strategy crossover
=new-undo-m>
ISA undo-multiple
count (!eval! (count-correction *subtask-list*))
!eval! (update-moves)
!push! =new-undo-m
)
(P switch-to-new-strategy-when-failed-crossover-imaginary
=goal>
ISA pad
prev-strategy =prev-strat
strategy crossover
!eval! (monitoring?)
!eval! (not *possible*)
==>
=goal>
strategy (!eval! (pick-new-strategy =prev-strat))
prev-strategy crossover
=new-undo-m>
ISA undo-multiple
level imagine
count (!eval! (count-correction *collection*))
!push! =new-undo-m
)
(P switch-to-new-strategy-when-failed-generic
=goal>
ISA pad
strategy =strategy
!eval! (not *possible*)
!eval! (execute?)
==>
=goal>
strategy (!eval! (pick-new-strategy =strategy))
prev-strategy =strategy
=new-undo-m>
ISA undo-multiple
count (!eval! (count-correction *subtask-list*))
!eval! (update-moves)
!push! =new-undo-m
)
(P switch-to-new-strategy-when-failed-generic-imaginary
=goal>
ISA pad
strategy =strategy
!eval! (monitoring?)
!eval! (not *possible*)
==>
=goal>
strategy (!eval! (pick-new-strategy =strategy))
prev-strategy =strategy
=new-undo-m>
ISA undo-multiple
level imagine
count (!eval! (count-correction *collection*))
!push! =new-undo-m
)
(P switch-generic
=goal>
ISA pad
strategy =strategy
!eval! *possible*
!eval! (execute?)
!eval! (consp *move-sequence*)
==>
=goal>
strategy (!eval! (pick-new-strategy =strategy))
prev-strategy =strategy
=new-undo-m>
ISA undo-multiple
count (!eval! (count-correction *subtask-list*))
!eval! (update-moves)
!push! =new-undo-m
)
(P switch-generic-imaginary
=goal>
ISA pad
strategy =strategy
!eval! (monitoring?)
!eval! (consp *collection*)
!eval! *possible*
==>
=goal>
strategy (!eval! (pick-new-strategy =strategy))
prev-strategy =strategy
=new-undo-m>
ISA undo-multiple
level imagine
count (!eval! (count-correction *collection*))
!push! =new-undo-m
)
(P apply-strategy-start-time
=goal>
ISA apply-st
main-type start-time
subtype nil
=s1>
ISA subtask
status nil
==>
!bind! =best (find-best 'start-time)
=newgoal>
ISA imaginary-update-selection
subtask =best
!focus-on! =newgoal
)
(P apply-strategy-start-time-with-car
=goal>
ISA apply-st
main-type use-car
subtype start-time
=s1>
ISA subtask
status nil
==>
!bind! =best (find-best 'start-time)
=newgoal>
ISA imaginary-update-selection-car
subtask =best
!focus-on! =newgoal
)
(P apply-strategy-start-time-priority
=goal>
ISA apply-st
main-type start-time
subtype priority
=s1>
ISA subtask
status nil
==>
!bind! =best (find-best 'start-time-p)
=newgoal>
ISA imaginary-update-selection
subtask =best
!focus-on! =newgoal
)
(P apply-strategy-start-time-priority-with-car
=goal>
ISA apply-st
main-type use-car
subtype start-time-p
=s1>
ISA subtask
status nil
==>
!bind! =best (find-best 'start-time-p)
=newgoal>
ISA imaginary-update-selection-car
subtask =best
!focus-on! =newgoal
)
(P apply-strategy-start-time-distance
=goal>
ISA apply-st
main-type start-time
subtype distance
=icp>
ISA icp
name =current
=s1>
ISA subtask
status nil
==>
!bind! =best (find-best 'start-time-d)
=newgoal>
ISA imaginary-update-selection
subtask =best
!focus-on! =newgoal
)
(P apply-strategy-start-time-distance-with-car
=goal>
ISA apply-st
main-type use-car
subtype start-time-distance
=icp>
ISA icp
name =current
=s1>
ISA subtask
status nil
=car>
ISA car
- status nolongeravailable
==>
!bind! =best (find-best 'start-time-d)
=newgoal>
ISA imaginary-update-selection-car
subtask =best
!focus-on! =newgoal
)
(P apply-strategy-end-time
=goal>
ISA apply-st
main-type end-time
subtype nil
=s1>
ISA subtask
status nil
==>
!bind! =best (find-best 'end-time)
=newgoal>
ISA imaginary-update-selection
subtask =best
!focus-on! =newgoal
)
(P apply-strategy-end-time-with-car
=goal>
ISA apply-st
main-type use-car
subtype end-time
=s1>
ISA subtask
status nil
==>
!bind! =best (find-best 'end-time)
=newgoal>
ISA imaginary-update-selection-car
subtask =best
!focus-on! =newgoal
)
(P apply-strategy-priority
=goal>
ISA apply-st
main-type priority
subtype nil
=s1>
ISA subtask
status nil
==>
!bind! =best (find-best 'priority)
=newgoal>
ISA imaginary-update-selection
subtask =best
!focus-on! =newgoal
)
(P apply-strategy-priority-with-car
=goal>
ISA apply-st
main-type use-car
subtype priority
=s1>
ISA subtask
status nil
==>
!bind! =best (find-best 'priority)
=goal>
=newgoal>
ISA imaginary-update-selection-car
subtask =best
!focus-on! =newgoal
)
(P apply-strategy-use-car-simple
=goal>
ISA apply-st
main-type use-car
subtype simple
temp nil
=car>
ISA car
- status nolongeravailable
==>
=new-undo>
ISA undo-move
subtask =s1
=goal>
temp =s1
!push! =new-undo
)
(P apply-strategy-use-car-simple-imagine
=goal>
ISA apply-st
main-type use-car
subtype simple
temp imagine
=car>
ISA car
- status nolongeravailable
==>
=new-undo>
ISA undo-move
level imagine
subtask =s1
=goal>
temp =s1
subtype imagine
!push! =new-undo
)
(P apply-strategy-use-car-doit
=goal>
ISA apply-st
main-type use-car
- subtype imagine
temp =s1
!eval! *possible*
==>
=newgoal>
ISA update-selection-car
subtask =s1
!focus-on! =newgoal
)
(P apply-strategy-use-car-doit-imagine
=goal>
ISA apply-st
main-type use-car
subtype imagine
temp =s1
!eval! (monitoring?)
!eval! *possible*
==>
=newgoal>
ISA imaginary-update-selection-car
subtask =s1
!focus-on! =newgoal
)
(P update-multiple
=goal>
ISA update-multiple
subtasks =collected
prev nil
count =count
success nil
!eval! (not (equal (first =collected) 'car))
==>
!bind! =current (first =collected)
!bind! =prev (list (first =collected))
!bind! =new-subtasks (cdr =collected)
=newgoal>
ISA update-selection
subtask =current
=goal>
count (!eval! (- =count 1))
subtasks =new-subtasks
prev =prev
!push! =newgoal
)
(P update-multiple-cont
=goal>
ISA update-multiple
subtasks =collected
prev =prev
count =count
success nil
!eval! (not (equal (first =collected) 'car))
==>
!bind! =current (first =collected)
!bind! =new-prev (cons (first =collected) =prev)
!bind! =new-subtasks (cdr =collected)
=newgoal>
ISA update-selection
subtask =current
=goal>
count (!eval! (- =count 1))
subtasks =new-subtasks
prev =new-prev
!push! =newgoal
)
(P update-multiple-car
=goal>
ISA update-multiple
subtasks =collected
prev nil
count =count
- count 0
success nil
!eval! (equal (first =collected) 'car)
==>
!bind! =current (second =collected)
!bind! =prev (cons (second =collected) (cons 'car =collected))
!bind! =new-subtasks (cddr =collected)
=goal>
count (!eval! (- =count 1))
subtasks =new-subtasks
prev =prev
=newgoal>
ISA update-selection-car
subtask =current
!push! =newgoal
)
(P update-multiple-car-cont
=goal>
ISA update-multiple
subtasks =collected
prev =prev
count =count
- count 0
success nil
!eval! (equal (first =collected) 'car)
==>
!bind! =current (second =collected)
!bind! =new-prev (cons (second =collected) (cons 'car =collected))
!bind! =new-subtasks (cddr =collected)
=goal>
count (!eval! (- =count 1))
subtasks =new-subtasks
prev =new-prev
=newgoal>
ISA update-selection-car
subtask =current
!push! =newgoal
)
(P update-multiple-stop
=goal>
ISA update-multiple
subtasks nil
prev =prev
count 0
==>
=goal>
success yes
!pop!
)
(P update-multiple-stop-failure
=goal>
ISA update-multiple
subtasks =collected
prev =prev
!eval! (not *possible*)
==>
=goal>
success no
!pop!
)
(P move-to-location
=goal>
ISA update-selection
subtask =s1
=s1>
ISA subtask
=cp>
ISA current-point
name =s
=dist>
ISA distance-fact
subtask1 =s
subtask2 =s1
distance =distance
==>
=s1>
status selected
travel =distance
from =s
=cp>
name =s1
=new-eval>
ISA evaluation
subtask =s1
!eval! (update-selection =s1 =distance)
!eval! (print-state)
!focus-on! =new-eval
)
(P move-to-location-imaginary
=goal>
ISA imaginary-update-selection
subtask =s1
=s1>
ISA subtask
=icp>
ISA icp
name =s
=dist>
ISA distance-fact
subtask1 =s
subtask2 =s1
distance =distance
==>
=s1>
travel =distance
from =s
status selected
=icp>
name =s1
=new-eval>
ISA pre-evaluation
subtask =s1
!eval! (mental-update-selection =s1 =distance)
!eval! (monitoring-state)
!focus-on! =new-eval
)
(P move-to-location-with-car
=goal>
ISA update-selection-car
subtask =s1
=s1>
ISA subtask
=car>
ISA car
- status nolongeravailable
=cp>
ISA current-point
name =s
=dist>
ISA distance-fact
subtask1 =s
subtask2 =s1
distance =distance
==>
!bind! =new-distance (* 1/3 =distance)
=s1>
status selected
travel =new-distance
from =s
how car
=car>
status nolongeravailable
=cp>
name =s1
=new-eval>
ISA evaluation
subtask =s1
!eval! (update-selection-car =s1 =distance)
!eval! (print-state)
!focus-on! =new-eval
)
(P move-to-location-with-car-imaginary
=goal>
ISA imaginary-update-selection-car
subtask =s1
=s1>
ISA subtask
=car>
ISA car
status nil
=icp>
ISA icp
name =s
=dist>
ISA distance-fact
subtask1 =s
subtask2 =s1
distance =distance
==>
!bind! =new-distance (* 1/3 =distance)
=s1>
travel =new-distance
from =s
how car
status selected
=car>
status checked
=icp>
name =s1
=new-eval>
ISA pre-evaluation
subtask =s1
!eval! (mental-update-selection =s1 =new-distance)
!eval! (monitoring-state)
!eval! (setf *collection* (cons =s1 (cons 'car (cdr *collection*))))
!focus-on! =new-eval
)
(P evaluate-move-good
=goal>
ISA evaluation
subtask =s1
=s1>
ISA subtask
end-time =end-time
start-time =start-time
duration =duration
!eval! (is-possible? =end-time)
==>
!bind! =wait (calculate-wait =start-time)
=s1>
waiting =wait
effective-duration =duration
!eval! (incf *systime* =duration)
!eval! (incf *systime* =wait)
!eval! (setf *possible* t)
!eval! (print-state)
!pop!
)
(P pre-eval-good
=goal>
ISA pre-evaluation
subtask =s1
=s1>
ISA subtask
end-time =end-time
start-time =start-time
duration =duration
!eval! (is-possible-in-the-brain? =end-time)
==>
!bind! =wait (calculate-wait =start-time)
=s1>
waiting =wait
effective-duration =duration
!eval! (incf *time-est* =duration)
!eval! (incf *time-est* =wait)
!eval! (setf *possible* t)
!eval! (monitoring-state)
!pop!
)
(P evaluate-move-bad
=goal>
ISA evaluation
subtask =s1
=s1>
ISA subtask
end-time =end-time
start-time =start-time
duration =duration
!eval! (not (is-possible? =end-time))
==>
!eval! (setf *possible* nil)
!eval! (print-state)
=s1>
waiting 0
effective-duration 0
!pop!
)
(P pre-eval-bad
=goal>
ISA pre-evaluation
subtask =s1
=s1>
ISA subtask
end-time =end-time
start-time =start-time
duration =duration
!eval! (not (is-possible-in-the-brain? =end-time))
==>
!eval! (monitoring-state)
!eval! (setf *possible* nil)
=s1>
waiting 0
effective-duration 0
!pop!
)
(P undo-move
=goal>
ISA undo-move
- level imagine
=cp>
ISA current-point
name =s1
=s1>
ISA subtask
duration =duration
travel =t
from =from-location
waiting =w
effective-duration =ed
how nil
==>
!eval! (undo-move =t =w =ed)
!eval! (undo-monitoring =t =w =ed)
!eval! (setf *possible* t)
!eval! (print-state)
=cp>
name =from-location
=s1>
travel nil
from nil
status nil
waiting 0
effective-duration 0
how nil
=goal>
subtask =s1
!pop!
)
(P undo-move-imaginary
=goal>
ISA undo-move
level imagine
=icp>
ISA icp
name =s1
=s1>
ISA subtask
duration =duration
travel =t
from =from-location
waiting =w
effective-duration =ed
how nil
==>
!eval! (undo-monitoring =t =w =ed)
!eval! (pop *collection*)
!eval! (setf *possible* t)
!eval! (monitoring-state)
=icp>
name =from-location
=s1>
travel nil
from nil
status nil
waiting 0
effective-duration 0
how nil
=goal>
subtask =s1
!pop!
)
(P undo-move-car
=goal>
ISA undo-move
=cp>
ISA current-point
name =s1
=car>
ISA car
=s1>
ISA subtask
duration =duration
travel =t
from =from-location
waiting =w
effective-duration =ed
how car
==>
!eval! (undo-move-car =t =w =ed)
!eval! (undo-monitoring =t =w =ed)
!eval! (setf *possible* t)
!eval! (print-state)
=cp>
name =from-location
=car>
status nil
=s1>
travel nil
from nil
status nil
waiting 0
effective-duration 0
how nil
=goal>
subtask =s1
!pop!
)
(P undo-move-car-imaginary
=goal>
ISA undo-move
level imagine
=icp>
ISA icp
name =s1
=car>
ISA car
=s1>
ISA subtask
duration =duration
travel =t
from =from-location
waiting =w
effective-duration =ed
how car
==>
!eval! (undo-monitoring =t =w =ed)
!eval! (pop *collection*)
!eval! (pop *collection*)
!eval! (setf *possible* t)
!eval! (monitoring-state)
=icp>
name =from-location
=car>
status nil
=s1>
travel nil
from nil
status nil
waiting 0
effective-duration 0
how nil
=goal>
subtask =s1
!pop!
)
(P reorder-start
=goal>
ISA reorder
s1 nil
s2 nil
- level imagine
==>
=newundo>
ISA undo-move
subtask =subtask
=goal>
s2 =subtask
!push! =newundo
)
(P reorder-start-imaginary
=goal>
ISA reorder
level imagine
s1 nil
s2 nil
==>
=newundo>
ISA undo-move
level imagine
subtask =subtask
=goal>
s2 =subtask
!push! =newundo
)
(P reorder-continue
=goal>
ISA reorder
s1 nil
s2 =s2
- level imagine
==>
=newundo>
ISA undo-move
subtask =subtask
=goal>
s1 =subtask
!push! =newundo
)
(P reorder-continue-imaginary
=goal>
ISA reorder
level imagine
s1 nil
s2 =s2
==>
=newundo>
ISA undo-move
level imagine
subtask =subtask
=goal>
s1 =subtask
!push! =newundo
)
(P reorder
=goal>
ISA reorder
s1 =s1
s2 =s2
- level imagine
==>
=secondmove>
ISA update-selection
subtask =s1
=firstmove>
ISA update-selection
subtask =s2
!focus-on! =secondmove
!push! =firstmove
)
(P reorder-imaginary
=goal>
ISA reorder
level imagine
s1 =s1
s2 =s2
==>
=secondmove>
ISA imaginary-update-selection
subtask =s1
=firstmove>
ISA imaginary-update-selection
subtask =s2
!focus-on! =secondmove
!push! =firstmove
)
(P undo-multiple
=goal>
ISA undo-multiple
count =count
- level imagine
- count 0
==>
=goal>
count (!eval! (1- =count))
=new-undo>
ISA undo-move
!push! =new-undo
)
(P undo-multiple-imaginary
=goal>
ISA undo-multiple
level imagine
count =count
- count 0
==>
=goal>
count (!eval! (1- =count))
=new-undo>
ISA undo-move
level imagine
!push! =new-undo
)
(P undo-multiple-stop-imagine
=goal>
ISA undo-multiple
count 0
level imagine
==>
!pop!
)
(P undo-multiple-stop
=goal>
ISA undo-multiple
- level imagine
count 0
==>
!pop!
)
(spp TASK-DONE-ENOUGH-PRAGMATIC :R 0.8)
(spp USE-CAR-WHEN-FAILED :R 0.9)
(spp PICK-END-TIME-STRATEGY :R 0.9)
(spp PICK-PRIORITY-STRATEGY :R 0.7)
(spp PICK-CROSSOVER-WHEN-FAILED :R 0.85)
(spp SWITCH-TO-NEW-STRATEGY-WHEN-FAILED-GENERIC :R 0.9)
(spp TASK-STOP-DISCARD-IRRELEVANT-SUBTASK :R 1.0)
(spp TASK-GIVE-UP :R 0.4)
(spp TASK-DONE :R 1.0)
(spp DELETE-TWO :A 0.3 :R 0.21)
(spp DELETE-ONE :A 0.5 :R 0.3)
(spp TASK-DONE-ENOUGH :R 0.3)
(spp SWITCH-GENERIC :R 0.4)
(spp CONTINUE-WITH-PREVIOUS-AFTER-USE-CAR :R 0.7)
(spp SWITCH-GENERIC-IMAGINARY :R 0.4)
(spp PICK-CROSSOVER-WHEN-FAILED-IMAGINARY :R 0.85)
(spp START-EXECUTE-ONE-SUBTASK :R 1.0)
(spp START-EXECUTE-THREE-SUBTASKS :R 1.0)
(spp START-EXECUTE-TWO-SUBTASKS :R 1.0)
(spp SWITCH-TO-NEW-STRATEGY-WHEN-FAILED-GENERIC-IMAGINARY :R 0.8)
(spp USE-CAR-WHEN-FAILED-IMAGINE :R 0.9)
(spp TASK-DONE-ENOUGH-EXTREMELY-PRAGMATIC :R 0.75)
(spp TASK-DONE-ENOUGH-LAZY :R 0.7)
(spp TASK-DOME-ALSO-QUITE-PRAGMATIC :R 0.75)
(setf *moni*
'(((V CAR L K D S))
((V CAR L K D S))
((L D K CAR V S) (L D K CAR V S))
((L S D K CAR V) (L D K CAR V S))
((L D K CAR V S))
((V CAR L K D S) (V CAR L S K) (V) (L D K CAR V S))
((V L) (L D V S K) (L D K CAR V S) (V CAR L S K))
((V L) (V CAR L S) (V CAR L K D S) (V CAR L K S D))
((L D K) (L S) (L D K CAR V S) (L D K CAR V S))
((L D K CAR V S) (L S D) (CAR D L) (L CAR V) (L D K CAR V S))
((D) (CAR D L) (V CAR L S K))
((V CAR L S) (V CAR L K D S) (V CAR L K S D))
((CAR D L) (L D K CAR V S))
((CAR L D K) (L D K CAR V S))
((L S CAR D K) (L S K CAR V D) (L D K CAR V S) (L D K CAR V S))))
(setf *expl*
'(((L S D) (V L) (S) (L V CAR K) (L K) (V CAR L S K) (V CAR L K D S) (V CAR L K D) (V CAR L K) (V CAR L K S D))
((L V S) (L V CAR K) (L K) (L S K) (L S K) (L V CAR K D S) (L V CAR K) (L K) (V L) (V CAR L K D S) (V CAR L K D S))
((S) (V S) (V L) (V L) (V CAR L S K) (V CAR L K D S) (V CAR L K S D))
((L S D K CAR V) (V L) (L S V) (L V) (D) (V CAR L K D S) (V CAR L K S D))
((D K CAR V S) (V K) (V D) (V K) (D K CAR V S) (L D K CAR V S))
((S) (L S V) (L V) (L D K CAR V S) (L D K S) (L D K CAR S V) (L D K CAR V S))
((CAR L D S) (CAR L D K) (CAR L D V) (L D K CAR V S) (L S CAR K V) (L S K) (L S V CAR K) (L D K CAR S V) (L D K CAR V S))
((L D) (L S V) (L S D) (L S CAR V K) (L S K CAR V D) (L S K D) (L S K V) (L V CAR K) (L D K CAR V S))
((K) (S) (L S D) (L D K CAR V S))
((CAR L S D) (V S L) (L D K CAR V S) (V CAR L K D S) (V S L) (CAR L D K) (V L) (V CAR L K S D))
((L V CAR K) (L D K CAR V) (L D K CAR S) (L S V) (L S CAR D K) (L S CAR K) (S) (V L) (V CAR L K D S) (V CAR L K D S))
((V S) (V L) (L D V) (L D CAR V) (L V CAR K) (L K) (L S CAR K) (L S V) (L S K) (V L) (L V) (L K CAR V) (V CAR) (V CAR L K S D))
((CAR L S D) (CAR L S V) (CAR L S K V) (CAR L S V) (CAR L S K V) (CAR L V K) (CAR L D K V) (CAR V L K) (CAR V L) (CAR V L)
(CAR V L) (CAR V) (V CAR L K D S) (V CAR L K D S) (V CAR L K D S))
((CAR L S V) (V CAR L K D S) (CAR V S) (CAR V L K) (V CAR L K D S) (V L) (V CAR L K) (V CAR L S) (CAR V K) (CAR V) (V CAR S)
(V CAR S) (CAR L V) (V CAR L K) (V CAR L S K) (V CAR L K D S))
((CAR D L) (CAR D L) (V S) (L S V CAR K) (L S K CAR V D) (L V S) (L D K) (V L) (S) (L D K) (L D S) (L D K CAR V S)
(L D K CAR V S))
((D L) (L D K S) (L D K CAR V S) (L S D) (L S K CAR V) (D L K) (CAR D L) (CAR L D K) (V S CAR K) (V L) (V CAR L K D) (L K CAR V)
(V L) (CAR V L K) (L S) (L D K CAR V S) (CAR L S D) (CAR L S K) (V S CAR K) (V L) (V CAR L K D S))
((V CAR K) (V S CAR K) (V S CAR L) (V L) (V CAR L K) (V CAR L S K) (V S) (V L) (V CAR) (V L CAR K) (V CAR L K D S) (V CAR L S K)
(V L CAR K) (V L) (V L CAR K) (V L) (V CAR L K D S) (V L CAR K) (V CAR L K D S))
((L V) (L CAR V) (L D K CAR V S) (V S CAR K) (V S D) (V S L) (V L) (L) (CAR L S) (CAR L V K) (L V K) (L V CAR K) (L D K V) (L V)
(V L) (V L) (V D K S L) (L D) (L S D CAR V) (L V) (L D K CAR V S))
((V CAR K) (V CAR D) (V L) (V CAR L K D) (V S CAR K) (V S) (V L) (L V) (L S CAR D) (L S D) (L S V) (L S D) (L S V) (L S CAR V)
(CAR L S) (CAR L V) (CAR L D K V) (V K) (V CAR D) (V CAR D K) (V S CAR K) (V L) (L D K CAR V S) (L D K CAR V S) (L D K CAR V S))))
(setf *possible* t)
(setf *collection* nil)
(setf *level* 'im)
(goal-focus goal)
(dolist (x (no-output (sdm isa distance-fact)))
(sdp-fct (list x :base-level 5)))
(set-base-levels (foo 5) (car 2))
(defvar *level*)
 Top |
Zuletzt bearbeitet am 30.08.2007 von JF. |