1.1 --- a/.hgignore	Thu Mar 27 17:56:26 2014 -0400
     1.2 +++ b/.hgignore	Thu Mar 27 17:57:01 2014 -0400
     1.3 @@ -15,6 +15,7 @@
     1.4  libbulletjme.so
     1.5  java/build/*
     1.6  java/dist/*
     1.7 +thesis/*.pdf
     1.8  
     1.9  syntax: regexp
    1.10  ^.*blend\d$

     2.1 Binary file assets/Models/test-touch/touch-cube.blend.orig has changed

     3.1 Binary file assets/Models/worm/basic-muscle.png has changed

     4.1 Binary file assets/Models/worm/touch-profile-imag.png has changed

     5.1 Binary file assets/Models/worm/touch-profile-imag.xcf has changed

     6.1 Binary file assets/Models/worm/touch-profile.png has changed

     7.1 Binary file assets/Models/worm/touch-profile.xcf has changed

     8.1 Binary file assets/Models/worm/worm-of-the-imagination.blend has changed

     9.1 Binary file assets/Models/worm/worm-segment.blend has changed

    10.1 Binary file assets/Models/worm/worm-single-segment.blend has changed

    11.1 Binary file assets/Models/worm/worm.blend has changed

    12.1 Binary file assets/Textures/aurellem.png has changed

    13.1 Binary file assets/Textures/greenGrid.png has changed

    14.1 Binary file assets/Textures/greenHexGrid.png has changed

    15.1 Binary file assets/Textures/squareGrid.png has changed

    16.1 Binary file gimp-patterns/film-grain-vertical.pat has changed

    17.1 Binary file gimp-patterns/gb-grid.pat has changed

    18.1 Binary file gimp-patterns/tactile-1.pat has changed

    19.1 Binary file gimp-patterns/tactile-128.pat has changed

    20.1 Binary file gimp-patterns/tactile-16.pat has changed

    21.1 Binary file gimp-patterns/tactile-2.pat has changed

    22.1 Binary file gimp-patterns/tactile-3.pat has changed

    23.1 Binary file gimp-patterns/tactile-32.pat has changed

    24.1 Binary file gimp-patterns/tactile-4.pat has changed

    25.1 Binary file gimp-patterns/tactile-5.pat has changed

    26.1 Binary file gimp-patterns/tactile-6.pat has changed

    27.1 Binary file gimp-patterns/tactile-64.pat has changed

    28.1 Binary file gimp-patterns/tactile-7.pat has changed

    29.1 Binary file gimp-patterns/tactile-8.pat has changed

    30.1 Binary file images/aurellem.xcf has changed

    31.1 --- a/java/build.xml	Thu Mar 27 17:56:26 2014 -0400
    31.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    31.3 @@ -1,32 +0,0 @@
    31.4 -<project name="cortex-opencv" default="dist" basedir="."> 
    31.5 -
    31.6 -  <property name="build" value="build"/>
    31.7 -  <property name="src" value="src"/>
    31.8 -  <property name="dist" value="dist"/>
    31.9 -
   31.10 -  <target name="prepare">
   31.11 -    <mkdir dir="${build}"/>
   31.12 -    <mkdir dir="${dist}"/> 
   31.13 -  </target>
   31.14 -
   31.15 -  <target name="compile" depends="prepare" >
   31.16 -    <javac srcdir="${src}" destdir="${build}"
   31.17 -	   includeantruntime="false"/>
   31.18 -  </target>
   31.19 -
   31.20 -  <target name="dist" depends="compile">
   31.21 -    <jar jarfile="${dist}/cortex-opencv.jar">
   31.22 -      <fileset dir="${build}"/>
   31.23 -      <fileset dir="${src}"/>
   31.24 -    </jar>
   31.25 -  </target>
   31.26 -
   31.27 -  <target name="all" depends="dist"/>
   31.28 -
   31.29 -  <target name="clean" > 
   31.30 -    <delete dir="${build}"/> 
   31.31 -    <delete dir="${dist}"/> 
   31.32 -  </target> 
   31.33 -
   31.34 -</project>
   31.35 -

    32.1 --- a/java/src/com/aurellem/opencv/OpenCV.java	Thu Mar 27 17:56:26 2014 -0400
    32.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    32.3 @@ -1,15 +0,0 @@
    32.4 -package com.aurellem.opencv;
    32.5 -
    32.6 -public class OpenCV {
    32.7 -
    32.8 -    public OpenCV(){}
    32.9 -    
   32.10 -    public static void loadVBA(){
   32.11 -	System.loadLibrary("opencv_java249");
   32.12 -    }
   32.13 -
   32.14 -    public static void absoluteLoadVBA(){
   32.15 -	System.load("/usr/share/OpenCV/java/libopencv_java249.so");
   32.16 -    }
   32.17 -
   32.18 -}

    33.1 --- a/org/ideas.org	Thu Mar 27 17:56:26 2014 -0400
    33.2 +++ b/org/ideas.org	Thu Mar 27 17:57:01 2014 -0400
    33.3 @@ -27,12 +27,12 @@
    33.4  - control of gravity within a certain radius
    33.5  - speed up/slow time
    33.6  - object creation/destruction
    33.7 -- future-sight -- step the simulation forward a few ticks, gather
    33.8 +- prescience -- step the simulation forward a few ticks, gather
    33.9    sensory data, then supply this data for the creature as one of its
   33.10    actual senses.
   33.11  
   33.12  - Symbol Sense
   33.13 -   Where objects in the world can be queried for description /
   33.14 +   Objects in the world can be queried for description /
   33.15     symbols.
   33.16  
   33.17  - Symbol Marking
   33.18 @@ -66,10 +66,6 @@
   33.19   - make a joint that figures out what type of joint it is (range of
   33.20     motion)
   33.21  
   33.22 -   
   33.23 -
   33.24 -
   33.25 -
   33.26  * goals
   33.27  
   33.28  ** have to get done before Winston
   33.29 @@ -104,8 +100,6 @@
   33.30  ** don't have to get done before winston
   33.31   - [X] write tests for integration -- 3 days
   33.32   - [X] usertime/gametime clock HUD display -- day 
   33.33 - - [ ] find papers for each of the senses justifying my own
   33.34 -       representation -- week
   33.35   - [X] show sensor maps in HUD display? -- 4 days
   33.36   - [X] show sensor maps in AWT display? -- 2 days
   33.37   - [X] upgrade to clojure 1.3, replace all defvars with new def
   33.38 @@ -122,10 +116,9 @@
   33.39  ;;Each minute and unseen part;
   33.40  ;;For the Gods see everywhere.
   33.41  
   33.42 -
   33.43  * misc
   33.44    - use object tracking on moving objects to derive good static
   33.45      detectors and achieve background separation
   33.46    - temporal scale pyramids.  this can help in verb recognition by
   33.47      making verb identification time-scale independent (up to a certian
   33.48 -    factor)
   33.49 \ No newline at end of file
   33.50 +    factor)

    34.1 --- a/org/movement.org	Thu Mar 27 17:56:26 2014 -0400
    34.2 +++ b/org/movement.org	Thu Mar 27 17:57:01 2014 -0400
    34.3 @@ -283,7 +283,7 @@
    34.4          muscles (pics "muscles/0")
    34.5          targets (map
    34.6                   #(File. (str base "out/" (format "%07d.png" %)))
    34.7 -                 (range 0 (count main-view)))]
    34.8 +                 (range (count main-view)))]
    34.9      (dorun
   34.10       (pmap
   34.11        (comp

    35.1 --- a/org/proprioception.org	Thu Mar 27 17:56:26 2014 -0400
    35.2 +++ b/org/proprioception.org	Thu Mar 27 17:57:01 2014 -0400
    35.3 @@ -52,7 +52,7 @@
    35.4     system. The three vectors do not have to be normalized or
    35.5     orthogonal."
    35.6    [vec1 vec2 vec3]
    35.7 -  (< 0 (.dot (.cross vec1 vec2) vec3)))
    35.8 +  (pos? (.dot (.cross vec1 vec2) vec3)))
    35.9  
   35.10  (defn absolute-angle
   35.11    "The angle between 'vec1 and 'vec2 around 'axis. In the range 
   35.12 @@ -328,7 +328,7 @@
   35.13          proprioception (pics "proprio/0")
   35.14          targets (map
   35.15                   #(File. (str base "out/" (format "%07d.png" %)))
   35.16 -                 (range 0 (count main-view)))]
   35.17 +                 (range (count main-view)))]
   35.18      (dorun
   35.19       (pmap
   35.20        (comp
   35.21 @@ -385,7 +385,7 @@
   35.22  
   35.23  * Next 
   35.24  
   35.25 -Next time, I'll give the Worm the power to [[./movement.org][move on it's own]].
   35.26 +Next time, I'll give the Worm the power to [[./movement.org][move on its own]].
   35.27  
   35.28  
   35.29  * COMMENT generate source

    36.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    36.2 +++ b/org/self_organizing_touch.clj	Thu Mar 27 17:57:01 2014 -0400
    36.3 @@ -0,0 +1,169 @@
    36.4 +(ns org.aurellem.self-organizing-touch
    36.5 +  "Using free play to automatically organize touch perception into regions."
    36.6 +  {:author "Robert McIntyre"}
    36.7 +  (:use (cortex world util import body sense
    36.8 +                hearing touch vision proprioception movement
    36.9 +                test))
   36.10 +  (:use [clojure set pprint])
   36.11 +  (:import (com.jme3.math ColorRGBA Vector3f))
   36.12 +  (:import java.io.File)
   36.13 +  (:import com.jme3.audio.AudioNode)
   36.14 +  (:import com.aurellem.capture.RatchetTimer)
   36.15 +  (:import (com.aurellem.capture Capture IsoTimer))
   36.16 +  (:import (com.jme3.math Vector3f ColorRGBA)))
   36.17 +
   36.18 +(use 'org.aurellem.worm-learn)
   36.19 +(dorun (cortex.import/mega-import-jme3))
   36.20 +
   36.21 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   36.22 +;; A demonstration of self organiging touch maps through experience. ;
   36.23 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   36.24 +
   36.25 +(def single-worm-segment-view
   36.26 +  [(Vector3f. 2.0681207, -6.1406755, 1.6106138)
   36.27 +   (Quaternion. -0.15558705, 0.843615, -0.3428654, -0.38281822)])
   36.28 +
   36.29 +(def worm-single-segment-muscle-labels
   36.30 +  [:lift-1 :lift-2 :roll-1 :roll-2])
   36.31 +
   36.32 +(defn touch-kinesthetics []
   36.33 +  [[170 :lift-1 40]
   36.34 +   [190 :lift-1 19]
   36.35 +   [206 :lift-1  0]
   36.36 +
   36.37 +   [400 :lift-2 40]
   36.38 +   [410 :lift-2  0]
   36.39 +
   36.40 +   [570 :lift-2 40]
   36.41 +   [590 :lift-2 21]
   36.42 +   [606 :lift-2  0]
   36.43 +
   36.44 +   [800 :lift-1 30]
   36.45 +   [809 :lift-1 0]
   36.46 +
   36.47 +   [900 :roll-2 40]
   36.48 +   [905 :roll-2 20]
   36.49 +   [910 :roll-2  0]
   36.50 +
   36.51 +   [1000 :roll-2 40]
   36.52 +   [1005 :roll-2 20]
   36.53 +   [1010 :roll-2  0]
   36.54 +   
   36.55 +   [1100 :roll-2 40]
   36.56 +   [1105 :roll-2 20]
   36.57 +   [1110 :roll-2  0]
   36.58 +   ])
   36.59 +
   36.60 +(defn single-worm-segment []
   36.61 +  (load-blender-model "Models/worm/worm-single-segment.blend"))
   36.62 +
   36.63 +(defn worm-segment []
   36.64 +  (let [model (single-worm-segment)]
   36.65 +    {:body (doto model (body!))
   36.66 +     :touch (touch! model)
   36.67 +     :proprioception (proprioception! model)
   36.68 +     :muscles (movement! model)}))
   36.69 +
   36.70 +
   36.71 +(defn worm-segment-defaults []
   36.72 +  (let [direct-control (worm-direct-control worm-muscle-labels 40)]
   36.73 +    (merge (worm-world-defaults)
   36.74 +           {:worm worm-segment
   36.75 +            :view single-worm-segment-view
   36.76 +            :experience-watch nil
   36.77 +            :motor-control
   36.78 +            (motor-control-program
   36.79 +             worm-single-segment-muscle-labels
   36.80 +             (touch-kinesthetics))
   36.81 +            :end-frame 1200})))
   36.82 +
   36.83 +(def full-contact [(float 0.0) (float 0.1)])
   36.84 +
   36.85 +(defn pure-touch?
   36.86 +  "This is worm specific code to determine if a large region of touch
   36.87 +   sensors is either all on or all off."
   36.88 +  [[coords touch :as touch-data]]
   36.89 +  (= (set (map first touch)) (set full-contact)))
   36.90 +
   36.91 +(defn remove-similar
   36.92 +  [coll]
   36.93 +  (loop [result () coll (sort-by (comp - count) coll)]
   36.94 +    (if (empty? coll) result
   36.95 +        (let  [[x & xs] coll
   36.96 +               c (count x)]
   36.97 +          (if (some
   36.98 +               (fn [other-set]
   36.99 +                 (let [oc (count other-set)]
  36.100 +                   (< (- (count (union other-set x)) c) (* oc 0.1))))
  36.101 +               xs)
  36.102 +            (recur result xs)
  36.103 +            (recur (cons x result) xs))))))
  36.104 +
  36.105 +(def all-touch-coordinates
  36.106 +  (concat
  36.107 +   (rect-region [0  15] [7  22])
  36.108 +   (rect-region [8   0] [14 29])
  36.109 +   (rect-region [15 15] [22 22])))
  36.110 +
  36.111 +(defn view-touch-region
  36.112 +  ([coords out]
  36.113 +     (let [touched-region
  36.114 +           (reduce
  36.115 +            (fn [m k]
  36.116 +              (assoc m k [0.0 0.1]))
  36.117 +            (zipmap all-touch-coordinates (repeat [0.1 0.1])) coords)
  36.118 +           data
  36.119 +           [[(vec (keys touched-region)) (vec (vals touched-region))]]
  36.120 +           touch-display (view-touch)]
  36.121 +       (touch-display data out)))
  36.122 +  ([coords] (view-touch-region nil)))
  36.123 +
  36.124 +
  36.125 +(defn learn-touch-regions []
  36.126 +  (let [experiences (atom [])
  36.127 +        world (apply-map
  36.128 +               worm-world
  36.129 +               (assoc (worm-segment-defaults)
  36.130 +                 :experiences experiences
  36.131 +                 :record (File. "/home/r/proj/cortex/thesis/video/touch-learn-2/")))]
  36.132 +    (run-world world)
  36.133 +    (->>
  36.134 +     @experiences
  36.135 +     (drop 175)
  36.136 +     ;; access the single segment's touch data
  36.137 +     (map (comp first :touch))
  36.138 +     ;; only deal with "pure" touch data to determine surfaces
  36.139 +     (filter pure-touch?)
  36.140 +     ;; associate coordinates with touch values
  36.141 +     (map (partial apply zipmap))
  36.142 +     ;; select those regions where contact is being made
  36.143 +     (map (partial group-by second))
  36.144 +     (map #(get % full-contact))
  36.145 +     (map (partial map first))
  36.146 +     ;; remove redundant/subset regions
  36.147 +     (map set)
  36.148 +     remove-similar)))
  36.149 +
  36.150 +
  36.151 +(def all-touch-coordinates
  36.152 +  (concat
  36.153 +   (rect-region [0  15] [7  22])
  36.154 +   (rect-region [8   0] [14 29])
  36.155 +   (rect-region [15 15] [22 22])))
  36.156 +
  36.157 +(defn view-touch-region [coords]
  36.158 +  (let [touched-region
  36.159 +        (reduce
  36.160 +         (fn [m k]
  36.161 +           (assoc m k [0.0 0.1]))
  36.162 +         (zipmap all-touch-coordinates (repeat [0.1 0.1])) coords)
  36.163 +        data
  36.164 +        [[(vec (keys touched-region)) (vec (vals touched-region))]]
  36.165 +        touch-display (view-touch)]
  36.166 +    (dorun (repeatedly 5 #(touch-display data)))))
  36.167 +
  36.168 +(defn learn-and-view-touch-regions []
  36.169 +  (map view-touch-region
  36.170 +       (learn-touch-regions)))
  36.171 +
  36.172 +

    37.1 --- a/org/sense.org	Thu Mar 27 17:56:26 2014 -0400
    37.2 +++ b/org/sense.org	Thu Mar 27 17:57:01 2014 -0400
    37.3 @@ -257,7 +257,7 @@
    37.4     Returns a function that accepts a BufferedImage and draws it to the
    37.5     JPanel. If given a directory it will save the images as png files
    37.6     starting at 0000000.png and incrementing from there."
    37.7 -  ([#^File save]
    37.8 +  ([#^File save title]
    37.9       (let [idx (atom -1)
   37.10             image
   37.11             (atom
   37.12 @@ -268,7 +268,7 @@
   37.13                 [graphics]
   37.14                 (proxy-super paintComponent graphics)
   37.15                 (.drawImage graphics @image 0 0 nil)))
   37.16 -           frame (JFrame. "Display Image")]
   37.17 +           frame (JFrame. title)]
   37.18         (SwingUtilities/invokeLater
   37.19          (fn []
   37.20            (doto frame
   37.21 @@ -285,6 +285,8 @@
   37.22             (ImageIO/write
   37.23              i "png"
   37.24              (File. save (format "%07d.png" (swap! idx inc))))))))
   37.25 +  ([#^File save]
   37.26 +     (view-image save "Display Image"))
   37.27    ([] (view-image nil)))
   37.28  
   37.29  (defn view-sense 

    38.1 --- a/org/touch.org	Thu Mar 27 17:56:26 2014 -0400
    38.2 +++ b/org/touch.org	Thu Mar 27 17:57:01 2014 -0400
    38.3 @@ -78,7 +78,7 @@
    38.4  To simulate touch there are three conceptual steps. For each solid
    38.5  object in the creature, you first have to get UV image and scale
    38.6  parameter which define the position and length of the feelers. Then,
    38.7 -you use the triangles which compose the mesh and the UV data stored in
    38.8 +you use the triangles which comprise the mesh and the UV data stored in
    38.9  the mesh to determine the world-space position and orientation of each
   38.10  feeler. Then once every frame, update these positions and orientations
   38.11  to match the current position and orientation of the object, and use
   38.12 @@ -136,7 +136,7 @@
   38.13  A =Mesh= is composed of =Triangles=, and each =Triangle= has three
   38.14  vertices which have coordinates in world space and UV space.
   38.15   
   38.16 -Here, =triangles= gets all the world-space triangles which compose a
   38.17 +Here, =triangles= gets all the world-space triangles which comprise a
   38.18  mesh, while =pixel-triangles= gets those same triangles expressed in
   38.19  pixel coordinates (which are UV coordinates scaled to fit the height
   38.20  and width of the UV image).
   38.21 @@ -152,7 +152,7 @@
   38.22       (.getTriangle (.getMesh geo) triangle-index scratch) scratch)))
   38.23  
   38.24  (defn triangles
   38.25 -  "Return a sequence of all the Triangles which compose a given
   38.26 +  "Return a sequence of all the Triangles which comprise a given
   38.27     Geometry." 
   38.28    [#^Geometry geo]
   38.29    (map (partial triangle geo) (range (.getTriangleCount (.getMesh geo)))))
   38.30 @@ -240,7 +240,7 @@
   38.31    [#^Triangle t]
   38.32    (let [mat (Matrix4f.)
   38.33          [vert-1 vert-2 vert-3]
   38.34 -        ((comp vec map) #(.get t %) (range 3))
   38.35 +        (mapv #(.get t %) (range 3))
   38.36          unit-normal (do (.calculateNormal t)(.getNormal t))
   38.37          vertices [vert-1 vert-2 vert-3 unit-normal]]
   38.38      (dorun 

    39.1 --- a/org/util.org	Thu Mar 27 17:56:26 2014 -0400
    39.2 +++ b/org/util.org	Thu Mar 27 17:57:01 2014 -0400
    39.3 @@ -129,10 +129,13 @@
    39.4  
    39.5  (defn position-camera
    39.6    "Change the position of the in-world camera."
    39.7 -  [world #^Vector3f position #^Quaternion rotation]
    39.8 +  ([world #^Vector3f position #^Quaternion rotation]
    39.9       (doto (.getCamera world)
   39.10         (.setLocation position)
   39.11         (.setRotation rotation)))
   39.12 +  ([world [position rotation]]
   39.13 +     (position-camera world position rotation)))
   39.14 +     
   39.15  
   39.16  (defn enable-debug 
   39.17    "Turn on debug wireframes for every object in this simulation."
   39.18 @@ -146,13 +149,13 @@
   39.19  
   39.20  (defn speed-up 
   39.21    "Increase the dismally slow speed of the world's camera."
   39.22 -  [world]
   39.23 -  (.setMoveSpeed (.getFlyByCamera world)
   39.24 -                 (float 60))
   39.25 -  (.setRotationSpeed (.getFlyByCamera world)
   39.26 -                     (float 3))
   39.27 -  world)
   39.28 -
   39.29 +  ([world] (speed-up world 1))
   39.30 +  ([world amount]
   39.31 +     (.setMoveSpeed (.getFlyByCamera world)
   39.32 +                    (float (* amount 60)))
   39.33 +     (.setRotationSpeed (.getFlyByCamera world)
   39.34 +                        (float (* amount 3)))
   39.35 +     world))
   39.36  
   39.37  (defn no-logging 
   39.38    "Disable all of jMonkeyEngine's logging."
   39.39 @@ -682,7 +685,7 @@
   39.40  #+end_src
   39.41  
   39.42  
   39.43 -* COMMENT code generation
   39.44 +* code generation
   39.45  #+begin_src clojure :tangle ../src/cortex/import.clj
   39.46  <<import>>
   39.47  #+end_src

    40.1 --- a/org/world.org	Thu Mar 27 17:56:26 2014 -0400
    40.2 +++ b/org/world.org	Thu Mar 27 17:57:01 2014 -0400
    40.3 @@ -177,7 +177,7 @@
    40.4  
    40.5  (defn initialize-inputs
    40.6    "Establish key-bindings for a particular virtual world."
    40.7 -  [game  input-manager key-map]
    40.8 +  [game input-manager key-map]
    40.9    (doall
   40.10     (map (fn [[name trigger]]
   40.11            (.addMapping
   40.12 @@ -192,9 +192,6 @@
   40.13  
   40.14  #+end_src
   40.15  
   40.16 -#+results: input
   40.17 -: #'cortex.world/initialize-inputs
   40.18 -
   40.19  These functions are for controlling the world through the keyboard and
   40.20  mouse.
   40.21  
   40.22 @@ -247,7 +244,7 @@
   40.23    "the =world= function takes care of the details of initializing a
   40.24    SimpleApplication.
   40.25  
   40.26 -   ***** Arguments:
   40.27 +   ,***** Arguments:
   40.28  
   40.29     - root-node : a com.jme3.scene.Node object which contains all of
   40.30         the objects that should be in the simulation.

    41.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    41.2 +++ b/org/worm_learn.clj	Thu Mar 27 17:57:01 2014 -0400
    41.3 @@ -0,0 +1,562 @@
    41.4 +(ns org.aurellem.worm-learn
    41.5 +  "General worm creation framework."
    41.6 +  {:author "Robert McIntyre"}
    41.7 +  (:use (cortex world util import body sense
    41.8 +                hearing touch vision proprioception movement
    41.9 +                test))
   41.10 +  (:import (com.jme3.math ColorRGBA Vector3f))
   41.11 +  (:import java.io.File)
   41.12 +  (:import com.jme3.audio.AudioNode)
   41.13 +  (:import com.aurellem.capture.RatchetTimer)
   41.14 +  (:import (com.aurellem.capture Capture IsoTimer))
   41.15 +  (:import (com.jme3.math Vector3f ColorRGBA)))
   41.16 +
   41.17 +(import org.apache.commons.math3.transform.TransformType)
   41.18 +(import org.apache.commons.math3.transform.FastFourierTransformer)
   41.19 +(import org.apache.commons.math3.transform.DftNormalization)
   41.20 +
   41.21 +(use 'clojure.pprint)
   41.22 +(use 'clojure.set)
   41.23 +(dorun (cortex.import/mega-import-jme3))
   41.24 +(rlm.rlm-commands/help)
   41.25 +
   41.26 +(load-bullet)
   41.27 +
   41.28 +(def hand "Models/test-creature/hand.blend")
   41.29 +
   41.30 +(defn worm-model []
   41.31 +  (load-blender-model "Models/worm/worm.blend"))
   41.32 +
   41.33 +(defn worm []
   41.34 +  (let [model (load-blender-model "Models/worm/worm.blend")]
   41.35 +    {:body (doto model (body!))
   41.36 +     :touch (touch! model)
   41.37 +     :proprioception (proprioception! model)
   41.38 +     :muscles (movement! model)}))
   41.39 +
   41.40 +(defn worm* []
   41.41 +  (let [model (load-blender-model "Models/worm/worm-of-the-imagination.blend")]
   41.42 +    {:body (doto model (body!))
   41.43 +     :touch (touch! model)
   41.44 +     :proprioception (proprioception! model)
   41.45 +     :muscles (movement! model)}))
   41.46 +
   41.47 +
   41.48 +(def output-base (File. "/home/r/proj/cortex/render/worm-learn/curl"))
   41.49 +
   41.50 +
   41.51 +(defn motor-control-program
   41.52 +  "Create a function which will execute the motor script"
   41.53 +  [muscle-labels
   41.54 +   script]
   41.55 +  (let [current-frame (atom -1)
   41.56 +        keyed-script (group-by first script)
   41.57 +        current-forces (atom {}) ]
   41.58 +    (fn [effectors]
   41.59 +      (let [indexed-effectors (vec effectors)]
   41.60 +        (dorun 
   41.61 +         (for [[_ part force] (keyed-script (swap! current-frame inc))]
   41.62 +           (swap! current-forces (fn [m] (assoc m part force)))))
   41.63 +        (doall (map (fn [effector power]
   41.64 +                      (effector (int power)))
   41.65 +                    effectors
   41.66 +                    (map #(@current-forces % 0) muscle-labels)))))))
   41.67 +
   41.68 +(defn worm-direct-control
   41.69 +  "Create keybindings and a muscle control program that will enable
   41.70 +   the user to control the worm via the keyboard."
   41.71 +  [muscle-labels activation-strength]
   41.72 +  (let [strengths (mapv (fn [_] (atom 0)) muscle-labels)
   41.73 +        activator
   41.74 +        (fn [n]
   41.75 +          (fn [world pressed?]
   41.76 +            (let [strength (if pressed? activation-strength 0)]
   41.77 +              (swap! (nth strengths n) (constantly strength)))))
   41.78 +        activators
   41.79 +        (map activator (range (count muscle-labels)))
   41.80 +        worm-keys
   41.81 +        ["key-f" "key-r"
   41.82 +         "key-g" "key-t"
   41.83 +         "key-h" "key-y"
   41.84 +         "key-j" "key-u"
   41.85 +         "key-k" "key-i"
   41.86 +         "key-l" "key-o"]]
   41.87 +    {:motor-control
   41.88 +     (fn [effectors]
   41.89 +      (doall
   41.90 +       (map (fn [strength effector]
   41.91 +              (effector (deref strength)))
   41.92 +            strengths effectors)))
   41.93 +     :keybindings
   41.94 +     ;; assume muscles are listed in pairs and map them to keys.
   41.95 +     (zipmap worm-keys activators)}))
   41.96 +
   41.97 +;; These are scripts that direct the worm to move in two radically
   41.98 +;; different patterns -- a sinusoidal wiggling motion, and a curling
   41.99 +;; motions that causes the worm to form a circle.
  41.100 +
  41.101 +(def curl-script
  41.102 +  [[150 :d-flex 40]
  41.103 +   [250 :d-flex 0]])
  41.104 +
  41.105 +(def period 18)
  41.106 +
  41.107 +(def worm-muscle-labels
  41.108 +  [:base-ex :base-flex
  41.109 +   :a-ex :a-flex
  41.110 +   :b-ex :b-flex
  41.111 +   :c-ex :c-flex
  41.112 +   :d-ex :d-flex])
  41.113 +
  41.114 +(defn gen-wiggle [[flexor extensor :as muscle-pair] time-base]
  41.115 +  (let [period period
  41.116 +        power 45]
  41.117 +    [[time-base flexor power]
  41.118 +     [(+ time-base period) flexor 0]
  41.119 +     [(+ time-base period 1) extensor power]
  41.120 +     [(+ time-base (+ (* 2 period) 2))  extensor 0]]))
  41.121 +  
  41.122 +(def wiggle-script
  41.123 +  (mapcat gen-wiggle (repeat 4000 [:a-ex :a-flex])
  41.124 +                     (range 100 1000000 (+ 3 (* period 2)))))
  41.125 +
  41.126 +
  41.127 +(defn shift-script [shift script]
  41.128 +  (map (fn [[time label power]] [(+ time shift) label power])
  41.129 +       script))
  41.130 +
  41.131 +(def do-all-the-things 
  41.132 +  (concat
  41.133 +   curl-script
  41.134 +   [[300 :d-ex 40]
  41.135 +    [320 :d-ex 0]]
  41.136 +   (shift-script 280 (take 16 wiggle-script))))
  41.137 +
  41.138 +;; Normally, we'd use unsupervised/supervised machine learning to pick
  41.139 +;; out the defining features of the different actions available to the
  41.140 +;; worm. For this project, I am going to explicitely define functions
  41.141 +;; that recognize curling and wiggling respectively. These functions
  41.142 +;; are defined using all the information available from an embodied
  41.143 +;; simulation of the action. Note how much easier they are to define
  41.144 +;; than if I only had vision to work with. Things like scale/position
  41.145 +;; invariance are complete non-issues here. This is the advantage of
  41.146 +;; body-centered action recognition and what I hope to show with this
  41.147 +;; thesis.
  41.148 +
  41.149 +
  41.150 +;; curled? relies on proprioception, resting? relies on touch,
  41.151 +;; wiggling? relies on a fourier analysis of muscle contraction, and
  41.152 +;; grand-circle? relies on touch and reuses curled? as a gaurd.
  41.153 +
  41.154 +(defn curled?
  41.155 +  "Is the worm curled up?"
  41.156 +  [experiences]
  41.157 +  (every?
  41.158 +   (fn [[_ _ bend]]
  41.159 +     (> (Math/sin bend) 0.64))
  41.160 +   (:proprioception (peek experiences))))
  41.161 +
  41.162 +(defn rect-region [[x0 y0] [x1 y1]]
  41.163 +  (vec
  41.164 +   (for [x (range x0 (inc x1))
  41.165 +         y (range y0 (inc y1))]
  41.166 +     [x y])))
  41.167 +
  41.168 +(def worm-segment-bottom (rect-region [8 15] [14 22]))
  41.169 +
  41.170 +(defn contact
  41.171 +  "Determine how much contact a particular worm segment has with
  41.172 +   other objects. Returns a value between 0 and 1, where 1 is full
  41.173 +   contact and 0 is no contact."
  41.174 +  [touch-region [coords contact :as touch]]
  41.175 +  (-> (zipmap coords contact)
  41.176 +      (select-keys touch-region)
  41.177 +      (vals)
  41.178 +      (#(map first %))
  41.179 +      (average)
  41.180 +      (* 10)
  41.181 +      (- 1)
  41.182 +      (Math/abs)))
  41.183 +
  41.184 +(defn resting?
  41.185 +  "Is the worm resting on the ground?"
  41.186 +  [experiences]
  41.187 +  (every?
  41.188 +   (fn [touch-data]
  41.189 +     (< 0.9 (contact worm-segment-bottom touch-data)))
  41.190 +   (:touch (peek experiences))))
  41.191 +
  41.192 +(defn vector:last-n [v n]
  41.193 +  (let [c (count v)]
  41.194 +    (if (< c n) v
  41.195 +        (subvec v (- c n) c))))
  41.196 +
  41.197 +(defn fft [nums]
  41.198 +  (map
  41.199 +   #(.getReal %)
  41.200 +   (.transform
  41.201 +    (FastFourierTransformer. DftNormalization/STANDARD)
  41.202 +    (double-array nums) TransformType/FORWARD)))
  41.203 +
  41.204 +(def indexed (partial map-indexed vector))
  41.205 +
  41.206 +(defn max-indexed [s]
  41.207 +  (first (sort-by (comp - second) (indexed s))))
  41.208 +
  41.209 +(defn wiggling?
  41.210 +  "Is the worm wiggling?"
  41.211 +  [experiences]
  41.212 +  (let [analysis-interval 96]
  41.213 +    (when (> (count experiences) analysis-interval)
  41.214 +      (let [a-flex 3
  41.215 +            a-ex   2
  41.216 +            muscle-activity
  41.217 +            (map :muscle (vector:last-n experiences analysis-interval))
  41.218 +            base-activity
  41.219 +            (map #(- (% a-flex) (% a-ex)) muscle-activity)
  41.220 +            accept?
  41.221 +            (fn [activity]
  41.222 +              (->> activity (fft) (take 20) (map #(Math/abs %))
  41.223 +                   (max-indexed) (first) (<= 2)))]
  41.224 +        (or (accept? (take 64 base-activity))
  41.225 +            (accept? (take 64 (drop 20 base-activity))))))))
  41.226 +
  41.227 +
  41.228 +
  41.229 +(def worm-segment-bottom-tip (rect-region [15 15] [22 22]))
  41.230 +
  41.231 +(def worm-segment-top-tip (rect-region [0 15] [7 22]))
  41.232 +
  41.233 +(defn grand-circle?
  41.234 +  "Does the worm form a majestic circle (one end touching the other)?"
  41.235 +  [experiences]
  41.236 +  (and (curled? experiences)
  41.237 +       (let [worm-touch (:touch (peek experiences))
  41.238 +             tail-touch (worm-touch 0)
  41.239 +             head-touch (worm-touch 4)]
  41.240 +         (and (< 0.1 (contact worm-segment-bottom-tip tail-touch))
  41.241 +              (< 0.1 (contact worm-segment-top-tip    head-touch))))))
  41.242 +
  41.243 +
  41.244 +(declare phi-space phi-scan debug-experience) 
  41.245 +
  41.246 +
  41.247 +
  41.248 +(def standard-world-view
  41.249 +  [(Vector3f. 4.207176, -3.7366982, 3.0816958)
  41.250 +   (Quaternion. 0.11118768, 0.87678415, 0.24434438, -0.3989771)])
  41.251 +
  41.252 +(def worm-side-view
  41.253 +  [(Vector3f. 4.207176, -3.7366982, 3.0816958)
  41.254 +   (Quaternion. -0.11555642, 0.88188726, -0.2854942, -0.3569518)])
  41.255 +
  41.256 +(def degenerate-worm-view
  41.257 +  [(Vector3f. -0.0708936, -8.570261, 2.6487997)
  41.258 +   (Quaternion. -2.318909E-4, 0.9985348, 0.053941682, 0.004291452)])
  41.259 +
  41.260 +(defn worm-world-defaults []
  41.261 +  (let [direct-control (worm-direct-control worm-muscle-labels 40)]
  41.262 +    (merge direct-control     
  41.263 +           {:view worm-side-view
  41.264 +            :record nil
  41.265 +            :experiences (atom [])
  41.266 +            :experience-watch debug-experience
  41.267 +            :worm worm
  41.268 +            :end-frame nil})))
  41.269 +
  41.270 +(defn dir! [file]
  41.271 +  (if-not (.exists file)
  41.272 +    (.mkdir file))
  41.273 +  file)
  41.274 +
  41.275 +(defn record-experience! [experiences data]
  41.276 +  (swap! experiences #(conj % data)))
  41.277 +
  41.278 +(defn enable-shadows [world]
  41.279 +  (let [bsr (doto
  41.280 +                (BasicShadowRenderer. (asset-manager) 512)
  41.281 +              (.setDirection (.normalizeLocal (Vector3f. 1 -1 -1))))]
  41.282 +    (.addProcessor (.getViewPort world) bsr)))
  41.283 +
  41.284 +(defn enable-good-shadows [world]
  41.285 +  (let [pssm
  41.286 +        (doto (PssmShadowRenderer. (asset-manager) 1024 3)
  41.287 +          (.setDirection  (.normalizeLocal (Vector3f. -1 -3 -1)))
  41.288 +          (.setLambda (float 0.55))
  41.289 +          (.setShadowIntensity (float 0.6))
  41.290 +          (.setCompareMode PssmShadowRenderer$CompareMode/Software)
  41.291 +          (.setFilterMode  PssmShadowRenderer$FilterMode/Bilinear))]
  41.292 +    (.addProcessor (.getViewPort world) pssm)))
  41.293 +        
  41.294 +(defn debug-experience
  41.295 +  [experiences text]
  41.296 +  (cond
  41.297 +   (grand-circle? experiences) (.setText text "Grand Circle")
  41.298 +   (curled? experiences)       (.setText text "Curled")
  41.299 +   (wiggling? experiences)     (.setText text "Wiggling")
  41.300 +   (resting? experiences)      (.setText text "Resting")
  41.301 +   :else                       (.setText text "Unknown")))
  41.302 +
  41.303 +
  41.304 +(defn worm-world
  41.305 +  [& {:keys    [record motor-control keybindings view experiences
  41.306 +                worm end-frame experience-watch] :as settings}]
  41.307 +  (let [{:keys [record motor-control keybindings view experiences
  41.308 +                worm end-frame experience-watch]}
  41.309 +        (merge (worm-world-defaults) settings)
  41.310 +       
  41.311 +        touch-display  (view-touch)
  41.312 +        prop-display   (view-proprioception)
  41.313 +        muscle-display (view-movement)
  41.314 +        {:keys [proprioception touch muscles body]} (worm)
  41.315 +        
  41.316 +        floor
  41.317 +        (box 5 1 5 :position (Vector3f. 0 -10 0)
  41.318 +             :mass 0
  41.319 +             :texture "Textures/aurellem.png"
  41.320 +             :material "Common/MatDefs/Misc/Unshaded.j3md")
  41.321 +        timer (IsoTimer. 60)
  41.322 +
  41.323 +        font (.loadFont (asset-manager) "Interface/Fonts/Console.fnt")
  41.324 +        worm-action (doto (BitmapText. font false)
  41.325 +                      (.setSize 35)
  41.326 +                      (.setColor (ColorRGBA/Black)))]
  41.327 +
  41.328 +    (world
  41.329 +     (nodify [body floor])
  41.330 +       (merge standard-debug-controls keybindings)
  41.331 +       (fn [world]
  41.332 +         (.setLocalTranslation
  41.333 +          worm-action 20 470 0)
  41.334 +         (.attachChild (.getGuiNode world) worm-action)
  41.335 +         
  41.336 +         (enable-good-shadows world)
  41.337 +         (.setShadowMode body RenderQueue$ShadowMode/CastAndReceive)
  41.338 +         (.setShadowMode floor RenderQueue$ShadowMode/Receive)
  41.339 +                  
  41.340 +         (.setBackgroundColor (.getViewPort world) (ColorRGBA/White))
  41.341 +         (.setDisplayStatView world false)
  41.342 +         (.setDisplayFps world false)
  41.343 +         (position-camera world view)
  41.344 +         (.setTimer world timer)
  41.345 +         ;;(display-dilated-time world timer)
  41.346 +         (when record
  41.347 +           (dir! record)
  41.348 +           (Capture/captureVideo
  41.349 +            world
  41.350 +            (dir! (File. record "main-view"))))
  41.351 +         (speed-up world 0.5)
  41.352 +         ;;(light-up-everything world)
  41.353 +         )
  41.354 +       (fn [world tpf]
  41.355 +         (if (and end-frame (> (.getTime timer) end-frame))
  41.356 +           (.stop world))
  41.357 +         (let [muscle-data (vec (motor-control muscles))
  41.358 +               proprioception-data (proprioception)
  41.359 +               touch-data (mapv #(% (.getRootNode world)) touch)]
  41.360 +           (when experiences
  41.361 +             (record-experience!
  41.362 +              experiences {:touch touch-data
  41.363 +                           :proprioception proprioception-data
  41.364 +                           :muscle muscle-data}))
  41.365 +           (when experience-watch
  41.366 +             (experience-watch @experiences worm-action))
  41.367 +           (muscle-display
  41.368 +            muscle-data
  41.369 +            (when record (dir! (File. record "muscle"))))
  41.370 +           (prop-display
  41.371 +            proprioception-data
  41.372 +            (when record (dir! (File. record "proprio"))))
  41.373 +           (touch-display 
  41.374 +            touch-data
  41.375 +            (when record (dir! (File. record "touch")))))))))
  41.376 +
  41.377 +
  41.378 +
  41.379 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  41.380 +;;;;;;;;   Phi-Space   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  41.381 +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  41.382 +
  41.383 +(defn generate-phi-space []
  41.384 +  (let [experiences (atom [])]
  41.385 +    (run-world
  41.386 +     (apply-map 
  41.387 +      worm-world
  41.388 +      (merge
  41.389 +       (worm-world-defaults)
  41.390 +       {:end-frame 700
  41.391 +        :motor-control
  41.392 +        (motor-control-program worm-muscle-labels do-all-the-things)
  41.393 +        :experiences experiences})))
  41.394 +    @experiences))
  41.395 +
  41.396 +(defn bin [digits]
  41.397 +  (fn [angles]
  41.398 +    (->> angles
  41.399 +         (flatten)
  41.400 +         (map (juxt #(Math/sin %) #(Math/cos %)))
  41.401 +         (flatten)
  41.402 +         (mapv #(Math/round (* % (Math/pow 10 (dec digits))))))))
  41.403 +
  41.404 +;; k-nearest neighbors with spatial binning. Only returns a result if
  41.405 +;; the propriceptive data is within 10% of a previously recorded
  41.406 +;; result in all dimensions.
  41.407 +(defn gen-phi-scan [phi-space]
  41.408 +  (let [bin-keys (map bin [3 2 1])
  41.409 +        bin-maps
  41.410 +        (map (fn [bin-key]
  41.411 +               (group-by
  41.412 +                (comp bin-key :proprioception phi-space)
  41.413 +                (range (count phi-space)))) bin-keys)
  41.414 +        lookups (map (fn [bin-key bin-map]
  41.415 +                      (fn [proprio] (bin-map (bin-key proprio))))
  41.416 +                    bin-keys bin-maps)]
  41.417 +    (fn lookup [proprio-data]
  41.418 +      (set (some #(% proprio-data) lookups)))))
  41.419 +
  41.420 +
  41.421 +(defn longest-thread
  41.422 +  "Find the longest thread from phi-index-sets. The index sets should
  41.423 +   be ordered from most recent to least recent."
  41.424 +  [phi-index-sets]
  41.425 +  (loop [result '()
  41.426 +         [thread-bases & remaining :as phi-index-sets] phi-index-sets]
  41.427 +    (if (empty? phi-index-sets)
  41.428 +      (vec result)
  41.429 +      (let [threads
  41.430 +            (for [thread-base thread-bases]
  41.431 +              (loop [thread (list thread-base)
  41.432 +                     remaining remaining]
  41.433 +                (let [next-index (dec (first thread))]
  41.434 +                  (cond (empty? remaining) thread
  41.435 +                        (contains? (first remaining) next-index)
  41.436 +                        (recur
  41.437 +                         (cons next-index thread) (rest remaining))
  41.438 +                        :else thread))))
  41.439 +            longest-thread
  41.440 +            (reduce (fn [thread-a thread-b]
  41.441 +                      (if (> (count thread-a) (count thread-b))
  41.442 +                        thread-a thread-b))
  41.443 +                    '(nil)
  41.444 +                    threads)]
  41.445 +        (recur (concat longest-thread result)
  41.446 +               (drop (count longest-thread) phi-index-sets))))))
  41.447 +
  41.448 +
  41.449 +(defn init []
  41.450 +  (def phi-space (generate-phi-space))
  41.451 +  (def phi-scan (gen-phi-scan phi-space))
  41.452 +  )
  41.453 +
  41.454 +;; (defn infer-nils-dyl [s]
  41.455 +;;   (loop [closed ()
  41.456 +;;          open s
  41.457 +;;          anchor 0]
  41.458 +;;     (if-not (empty? open)
  41.459 +;;       (recur (conj closed
  41.460 +;;                    (or (peek open)
  41.461 +;;                        anchor))
  41.462 +;;              (pop open)
  41.463 +;;              (or (peek open) anchor))
  41.464 +;;        closed)))
  41.465 +      
  41.466 +;; (defn infer-nils [s]
  41.467 +;;   (for [i (range (count s))]
  41.468 +;;     (or (get s i)
  41.469 +;;         (some (comp not nil?) (vector:last-n (- (count s) i)))
  41.470 +;;         0)))
  41.471 +
  41.472 +
  41.473 +(defn infer-nils
  41.474 +  "Replace nils with the next available non-nil element in the
  41.475 +   sequence, or barring that, 0."
  41.476 +  [s]
  41.477 +  (loop [i (dec (count s))
  41.478 +         v (transient s)]
  41.479 +    (if (zero? i) (persistent! v)
  41.480 +        (if-let [cur (v i)]
  41.481 +          (if (get v (dec i) 0)
  41.482 +            (recur (dec i) v)
  41.483 +            (recur (dec i) (assoc! v (dec i) cur)))
  41.484 +          (recur i (assoc! v i 0))))))
  41.485 +
  41.486 +;; tests
  41.487 +
  41.488 +;;(infer-nils [1 nil 1 1]) [1 1 1 1]
  41.489 +;;(infer-nils [1 1 1 nil]) [1 1 1 0]
  41.490 +;;(infer-nils [nil 2 1 1]) [2 2 1 1]       
  41.491 +  
  41.492 +
  41.493 +(defn empathy-demonstration []
  41.494 +  (let [proprio (atom ())]
  41.495 +    (fn
  41.496 +      [experiences text]
  41.497 +      (let [phi-indices (phi-scan (:proprioception (peek experiences)))]
  41.498 +        (swap! proprio (partial cons phi-indices))
  41.499 +        (let [exp-thread (longest-thread (take 300 @proprio))
  41.500 +              empathy (mapv phi-space (infer-nils exp-thread))]
  41.501 +          (println-repl (vector:last-n exp-thread 22))
  41.502 +          (cond
  41.503 +           (grand-circle? empathy) (.setText text "Grand Circle")
  41.504 +           (curled? empathy)       (.setText text "Curled")
  41.505 +           (wiggling? empathy)     (.setText text "Wiggling")
  41.506 +           (resting? empathy)      (.setText text "Resting")
  41.507 +           :else                   (.setText text "Unknown")))))))
  41.508 +
  41.509 +(defn init-interactive []
  41.510 +  (def phi-space
  41.511 +    (let [experiences (atom [])]
  41.512 +      (run-world
  41.513 +       (apply-map 
  41.514 +        worm-world
  41.515 +        (merge
  41.516 +         (worm-world-defaults)
  41.517 +         {:experiences experiences})))
  41.518 +      @experiences))
  41.519 +  (def phi-scan (gen-phi-scan phi-space)))
  41.520 +
  41.521 +(defn empathy-experiment-1 [record]
  41.522 +  (.start (worm-world :experience-watch (empathy-demonstration)
  41.523 +                      :record record :worm worm*)))
  41.524 +
  41.525 +
  41.526 +(def worm-action-label
  41.527 +  (juxt grand-circle? curled? wiggling?))
  41.528 +
  41.529 +(defn compare-empathy-with-baseline [accuracy]
  41.530 +  (let [proprio (atom ())]
  41.531 +    (fn
  41.532 +      [experiences text]
  41.533 +      (let [phi-indices (phi-scan (:proprioception (peek experiences)))]
  41.534 +        (swap! proprio (partial cons phi-indices))
  41.535 +        (let [exp-thread (longest-thread (take 300 @proprio))
  41.536 +              empathy (mapv phi-space (infer-nils exp-thread))
  41.537 +              experience-matches-empathy
  41.538 +              (= (worm-action-label experiences)
  41.539 +                 (worm-action-label empathy))]
  41.540 +          (cond
  41.541 +           (grand-circle? empathy) (.setText text "Grand Circle")
  41.542 +           (curled? empathy)       (.setText text "Curled")
  41.543 +           (wiggling? empathy)     (.setText text "Wiggling")
  41.544 +           (resting? empathy)      (.setText text "Resting")
  41.545 +           :else                   (.setText text "Unknown"))
  41.546 +
  41.547 +          (println-repl experience-matches-empathy)
  41.548 +          (swap! accuracy #(conj % experience-matches-empathy)))))))
  41.549 +              
  41.550 +(defn accuracy [v]
  41.551 +  (float (/ (count (filter true? v)) (count v))))
  41.552 +
  41.553 +(defn test-empathy-accuracy []
  41.554 +  (let [res (atom [])]
  41.555 +    (run-world
  41.556 +     (worm-world :experience-watch
  41.557 +                 (compare-empathy-with-baseline res)
  41.558 +                 :worm worm*))
  41.559 +    (accuracy @res)))
  41.560 +
  41.561 +
  41.562 +
  41.563 +
  41.564 +
  41.565 +

    42.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    42.2 +++ b/thesis/Makefile	Thu Mar 27 17:57:01 2014 -0400
    42.3 @@ -0,0 +1,16 @@
    42.4 +#INVOKE_LATEX = pdflatex -shell-escape thesis.tex;
    42.5 +THESIS_NAME  = rlm-cortex-meng
    42.6 +INVOKE_LATEX = texi2dvi --shell-escape --pdf -V --batch $(THESIS_NAME).tex;
    42.7 +#INVOKE_LATEX = texi2dvi --shell-escape --pdf -V  $(THESIS_NAME).tex;
    42.8 +
    42.9 +all:
   42.10 +	./weave-thesis.sh cortex
   42.11 +	rsync -avz --delete --exclude "video" \
   42.12 +		/home/r/proj/cortex/thesis "r@aurellem.org:~"
   42.13 +	ssh r@aurellem.org cd "~/thesis; $(INVOKE_LATEX)"
   42.14 +	scp "r@aurellem.org:/home/r/thesis/$(THESIS_NAME).pdf" .
   42.15 +	rm cortex.tex abstract.tex user-guide.tex
   42.16 +
   42.17 +
   42.18 +
   42.19 +

    43.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    43.2 +++ b/thesis/abstract.org	Thu Mar 27 17:57:01 2014 -0400
    43.3 @@ -0,0 +1,23 @@
    43.4 +Here I demonstrate the power of using embodied artificial intelligence
    43.5 +to attack the /action recognition/ problem, which is the challenge of
    43.6 +recognizing actions performed by a creature given limited data about
    43.7 +the creature's actions, such as a video recording. I solve this
    43.8 +problem in the case of a worm-like creature performing actions such as
    43.9 +curling and wiggling.
   43.10 +
   43.11 +To attack the action recognition problem, I developed a computational
   43.12 +model of empathy (=EMPATH=) which allows me to recognize actions using
   43.13 +simple, embodied representations of actions (which require rich
   43.14 +sensory data), even when that sensory data is not actually
   43.15 +available. The missing sense data is ``imagined'' by the system by
   43.16 +combining previous experiences gained from unsupervised free play.
   43.17 +
   43.18 +In order to build this empathic, action-recognizing system, I created
   43.19 +a program called =CORTEX=, which is a complete platform for embodied
   43.20 +AI research. It provides multiple senses for simulated creatures,
   43.21 +including vision, touch, proprioception, muscle tension, and
   43.22 +hearing. Each of these senses provides a wealth of parameters that are
   43.23 +biologically inspired. =CORTEX= is able to simulate any number of
   43.24 +creatures and senses, and provides facilities for easily modeling and
   43.25 +creating new creatures. As a research platform it is more complete
   43.26 +than any other system currently available.

    44.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    44.2 +++ b/thesis/aux/mitthesis/README.bibliography	Thu Mar 27 17:57:01 2014 -0400
    44.3 @@ -0,0 +1,28 @@
    44.4 +This file gives an overview on what you will need to do to create a
    44.5 +bibliographic database for references, as well as create the actual
    44.6 +bibliography for your thesis.
    44.7 +
    44.8 +You should not need to touch the file biblio.tex.  This merely tells
    44.9 +latex to look for the file with the bibliographic info.  The file you
   44.10 +want to edit is main.bib.  For each entry, use the appropriate style
   44.11 +as designated in the file.
   44.12 +
   44.13 +Citing your references:
   44.14 +
   44.15 +When you cite a reference, you need to use the ``key'' you declare in
   44.16 +main.bib for the entry.  No one ever sees the keys, but you'll want to
   44.17 +use something you will easily remember.  For instance, if you had an
   44.18 +entry with:
   44.19 +
   44.20 +	key=geer1
   44.21 +
   44.22 +Then you would use \cite{geer1} to reference it within your thesis.
   44.23 +
   44.24 +NOTE: You can not include references in your bibliography that are
   44.25 +never cited in your paper by default. If you need to do this, create a
   44.26 +key for the entry and at the end of your thesis include the line:
   44.27 +
   44.28 +\nocite{key}
   44.29 +
   44.30 +This should be done for every entry which is not explicitly cited.
   44.31 +

    45.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    45.2 +++ b/thesis/aux/mitthesis/README.main	Thu Mar 27 17:57:01 2014 -0400
    45.3 @@ -0,0 +1,54 @@
    45.4 +This file explains the options available to you for editting the file
    45.5 +main.tex.
    45.6 +
    45.7 +The commands in the this file allow you to specify options such as
    45.8 +spacing, double-sided printing, a draft copy, etc.   By default, 12pt
    45.9 +and lgrind are included; lgrind is the 2e style for including code in
   45.10 +your thesis.
   45.11 +
   45.12 +\documentclass[12pt]{mitthesis}
   45.13 +\usepackage{lgrind}
   45.14 +\pagestyle{plain}
   45.15 +
   45.16 +You can add options in the documentclass line as follows:
   45.17 +
   45.18 +	o  singlespace
   45.19 +
   45.20 +	\documentclass[12pt,singlespace]{mitthesis}
   45.21 +	
   45.22 +	o  twoside
   45.23 +
   45.24 +	\documentclass[12pt,twoside]{mitthesis}
   45.25 +
   45.26 +	o  draft   (make sure to change the pagestyle to drafthead as
   45.27 +			well)
   45.28 +
   45.29 +	\documentclass[12pt,draft]{mitthesis}
   45.30 +	\usepackage{lgrind}
   45.31 +	\pagestyle{drafthead}
   45.32 +
   45.33 +	o vi   (for course vi and course viii theses)
   45.34 +
   45.35 +	\documentclass[12pt,vi]{mitthesis}
   45.36 +
   45.37 +Any options you would use for report.sty will work here as well.
   45.38 +
   45.39 +
   45.40 +You should not need to change the first three lines and last two lines
   45.41 +below.  Be sure to include an \include command for each file you are
   45.42 +including in your thesis.
   45.43 +  
   45.44 +\include{cover}
   45.45 +\pagestyle{plain}
   45.46 +\include{contents}
   45.47 +\include{chap1}
   45.48 +\include{chap2}
   45.49 +\appendix
   45.50 +\include{appa}
   45.51 +\include{appb}
   45.52 +\include{biblio}
   45.53 +\end{document}
   45.54 +
   45.55 +Comment: to include appendices use a single \appendix command followed by
   45.56 +a number of \include{} commands as many files as needed, each of which
   45.57 +should contain a \chapter{} command for the appendix title.

    46.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    46.2 +++ b/thesis/aux/mitthesis/README.text	Thu Mar 27 17:57:01 2014 -0400
    46.3 @@ -0,0 +1,34 @@
    46.4 +This file includes the basic commands you will need to use within each
    46.5 +chapter of your thesis.
    46.6 +
    46.7 +The file chap1.tex is a sample first chapter.  To get started, you may
    46.8 +just want to replace the text and commands in that file as needed.  In
    46.9 +general though, for each new chapter you want to do the following:
   46.10 +
   46.11 +	o Make sure the name has the extension .tex .  Otherwise, you
   46.12 +	can call it anything you want.  For ease of use, all the
   46.13 +	examples use chap1, chap2, etc.
   46.14 +
   46.15 +	o Add a line to the file main.tex that reads:
   46.16 +
   46.17 +	\include{yourfilename}
   46.18 +
   46.19 +	This should not include the .tex extension, because latex
   46.20 +	assumes that is there.
   46.21 +
   46.22 +Basic syntax:
   46.23 +
   46.24 +	o The first line of each chapter should be:
   46.25 +
   46.26 +	\chapter{Chapter Title}
   46.27 +
   46.28 +	o To start a new section (labeled chap#.sec# -- as in 1.1,
   46.29 +	1.2, etc):
   46.30 +
   46.31 +	\section{Section Heading}
   46.32 +
   46.33 +	You can also include subsections:
   46.34 +
   46.35 +	\subsection{Heading}
   46.36 +
   46.37 +

    47.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    47.2 +++ b/thesis/aux/mitthesis/abstract.tex	Thu Mar 27 17:57:01 2014 -0400
    47.3 @@ -0,0 +1,22 @@
    47.4 +% $Log: abstract.tex,v $
    47.5 +% Revision 1.1  93/05/14  14:56:25  starflt
    47.6 +% Initial revision
    47.7 +% 
    47.8 +% Revision 1.1  90/05/04  10:41:01  lwvanels
    47.9 +% Initial revision
   47.10 +% 
   47.11 +%
   47.12 +%% The text of your abstract and nothing else (other than comments) goes here.
   47.13 +%% It will be single-spaced and the rest of the text that is supposed to go on
   47.14 +%% the abstract page will be generated by the abstractpage environment.  This
   47.15 +%% file should be \input (not \include 'd) from cover.tex.
   47.16 +In this thesis, I designed and implemented a compiler which performs
   47.17 +optimizations that reduce the number of low-level floating point operations
   47.18 +necessary for a specific task; this involves the optimization of chains of
   47.19 +floating point operations as well as the implementation of a ``fixed'' point
   47.20 +data type that allows some floating point operations to simulated with integer
   47.21 +arithmetic.  The source language of the compiler is a subset of C, and the
   47.22 +destination language is assembly language for a micro-floating point CPU.  An
   47.23 +instruction-level simulator of the CPU was written to allow testing of the
   47.24 +code.  A series of test pieces of codes was compiled, both with and without
   47.25 +optimization, to determine how effective these optimizations were.

    48.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    48.2 +++ b/thesis/aux/mitthesis/biblio.tex	Thu Mar 27 17:57:01 2014 -0400
    48.3 @@ -0,0 +1,8 @@
    48.4 +%% This defines the bibliography file (main.bib) and the bibliography style.
    48.5 +%% If you want to create a bibliography file by hand, change the contents of
    48.6 +%% this file to a `thebibliography' environment.  For more information 
    48.7 +%% see section 4.3 of the LaTeX manual.
    48.8 +\begin{singlespace}
    48.9 +\bibliography{main}
   48.10 +\bibliographystyle{plain}
   48.11 +\end{singlespace}

    49.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    49.2 +++ b/thesis/aux/mitthesis/chap1.tex	Thu Mar 27 17:57:01 2014 -0400
    49.3 @@ -0,0 +1,250 @@
    49.4 +%% This is an example first chapter.  You should put chapter/appendix that you
    49.5 +%% write into a separate file, and add a line \include{yourfilename} to
    49.6 +%% main.tex, where `yourfilename.tex' is the name of the chapter/appendix file.
    49.7 +%% You can process specific files by typing their names in at the 
    49.8 +%% \files=
    49.9 +%% prompt when you run the file main.tex through LaTeX.
   49.10 +\chapter{Introduction}
   49.11 +
   49.12 +Micro-optimization is a technique to reduce the overall operation count of
   49.13 +floating point operations.  In a standard floating point unit, floating
   49.14 +point operations are fairly high level, such as ``multiply'' and ``add'';
   49.15 +in a micro floating point unit ($\mu$FPU), these have been broken down into
   49.16 +their constituent low-level floating point operations on the mantissas and
   49.17 +exponents of the floating point numbers.
   49.18 +
   49.19 +Chapter two describes the architecture of the $\mu$FPU unit, and the
   49.20 +motivations for the design decisions made.
   49.21 +
   49.22 +Chapter three describes the design of the compiler, as well as how the
   49.23 +optimizations discussed in section~\ref{ch1:opts} were implemented.
   49.24 +
   49.25 +Chapter four describes the purpose of test code that was compiled, and which
   49.26 +statistics were gathered by running it through the simulator.  The purpose
   49.27 +is to measure what effect the micro-optimizations had, compared to
   49.28 +unoptimized code.  Possible future expansions to the project are also
   49.29 +discussed.
   49.30 +
   49.31 +\section{Motivations for micro-optimization}
   49.32 +
   49.33 +The idea of micro-optimization is motivated by the recent trends in computer
   49.34 +architecture towards low-level parallelism and small, pipelineable
   49.35 +instruction sets \cite{patterson:risc,rad83}.  By getting rid of more
   49.36 +complex instructions and concentrating on optimizing frequently used
   49.37 +instructions, substantial increases in performance were realized.
   49.38 +
   49.39 +Another important motivation was the trend towards placing more of the
   49.40 +burden of performance on the compiler.  Many of the new architectures depend
   49.41 +on an intelligent, optimizing compiler in order to realize anywhere near
   49.42 +their peak performance
   49.43 +\cite{ellis:bulldog,pet87,coutant:precision-compilers}.  In these cases, the
   49.44 +compiler not only is responsible for faithfully generating native code to
   49.45 +match the source language, but also must be aware of instruction latencies,
   49.46 +delayed branches, pipeline stages, and a multitude of other factors in order
   49.47 +to generate fast code \cite{gib86}.
   49.48 +
   49.49 +Taking these ideas one step further, it seems that the floating point
   49.50 +operations that are normally single, large instructions can be further broken
   49.51 +down into smaller, simpler, faster instructions, with more control in the
   49.52 +compiler and less in the hardware.  This is the idea behind a
   49.53 +micro-optimizing FPU; break the floating point instructions down into their
   49.54 +basic components and use a small, fast implementation, with a large part of
   49.55 +the burden of hardware allocation and optimization shifted towards
   49.56 +compile-time.
   49.57 +
   49.58 +Along with the hardware speedups possible by using a $\mu$FPU, there are
   49.59 +also optimizations that the compiler can perform on the code that is
   49.60 +generated.  In a normal sequence of floating point operations, there are
   49.61 +many hidden redundancies that can be eliminated by allowing the compiler to
   49.62 +control the floating point operations down to their lowest level.  These
   49.63 +optimizations are described in detail in section~\ref{ch1:opts}.
   49.64 +
   49.65 +\section{Description of micro-optimization}\label{ch1:opts}
   49.66 +
   49.67 +In order to perform a sequence of floating point operations, a normal FPU
   49.68 +performs many redundant internal shifts and normalizations in the process of
   49.69 +performing a sequence of operations.  However, if a compiler can
   49.70 +decompose the floating point operations it needs down to the lowest level,
   49.71 +it then can optimize away many of these redundant operations.  
   49.72 +
   49.73 +If there is some additional hardware support specifically for
   49.74 +micro-optimization, there are additional optimizations that can be
   49.75 +performed.  This hardware support entails extra ``guard bits'' on the
   49.76 +standard floating point formats, to allow several unnormalized operations to
   49.77 +be performed in a row without the loss information\footnote{A description of
   49.78 +the floating point format used is shown in figures~\ref{exponent-format}
   49.79 +and~\ref{mantissa-format}.}.  A discussion of the mathematics behind
   49.80 +unnormalized arithmetic is in appendix~\ref{unnorm-math}.
   49.81 +
   49.82 +The optimizations that the compiler can perform fall into several categories:
   49.83 +
   49.84 +\subsection{Post Multiply Normalization}
   49.85 +
   49.86 +When more than two multiplications are performed in a row, the intermediate
   49.87 +normalization of the results between multiplications can be eliminated.
   49.88 +This is because with each multiplication, the mantissa can become
   49.89 +denormalized by at most one bit.  If there are guard bits on the mantissas
   49.90 +to prevent bits from ``falling off'' the end during multiplications, the
   49.91 +normalization can be postponed until after a sequence of several
   49.92 +multiplies\footnote{Using unnormalized numbers for math is not a new idea; a
   49.93 +good example of it is the Control Data CDC 6600, designed by Seymour Cray.
   49.94 +\cite{thornton:cdc6600} The CDC 6600 had all of its instructions performing
   49.95 +unnormalized arithmetic, with a separate {\tt NORMALIZE} instruction.}.
   49.96 +
   49.97 +% This is an example of how you would use tgrind to include an example
   49.98 +% of source code; it is commented out in this template since the code
   49.99 +% example file does not exist.  To use it, you need to remove the '%' on the
  49.100 +% beginning of the line, and insert your own information in the call.
  49.101 +%
  49.102 +%\tagrind[htbp]{code/pmn.s.tex}{Post Multiply Normalization}{opt:pmn}
  49.103 +
  49.104 +As you can see, the intermediate results can be multiplied together, with no
  49.105 +need for intermediate normalizations due to the guard bit.  It is only at
  49.106 +the end of the operation that the normalization must be performed, in order
  49.107 +to get it into a format suitable for storing in memory\footnote{Note that
  49.108 +for purposed of clarity, the pipeline delays were considered to be 0, and
  49.109 +the branches were not delayed.}.
  49.110 +
  49.111 +\subsection{Block Exponent}
  49.112 +
  49.113 +In a unoptimized sequence of additions, the sequence of operations is as
  49.114 +follows for each pair of numbers ($m_1$,$e_1$) and ($m_2$,$e_2$).
  49.115 +\begin{enumerate}
  49.116 +  \item Compare $e_1$ and $e_2$.
  49.117 +  \item Shift the mantissa associated with the smaller exponent $|e_1-e_2|$
  49.118 +        places to the right.
  49.119 +  \item Add $m_1$ and $m_2$.
  49.120 +  \item Find the first one in the resulting mantissa.
  49.121 +  \item Shift the resulting mantissa so that normalized
  49.122 +  \item Adjust the exponent accordingly.
  49.123 +\end{enumerate}
  49.124 +
  49.125 +Out of 6 steps, only one is the actual addition, and the rest are involved
  49.126 +in aligning the mantissas prior to the add, and then normalizing the result
  49.127 +afterward.  In the block exponent optimization, the largest mantissa is
  49.128 +found to start with, and all the mantissa's shifted before any additions
  49.129 +take place.  Once the mantissas have been shifted, the additions can take
  49.130 +place one after another\footnote{This requires that for n consecutive
  49.131 +additions, there are $\log_{2}n$ high guard bits to prevent overflow.  In
  49.132 +the $\mu$FPU, there are 3 guard bits, making up to 8 consecutive additions
  49.133 +possible.}.  An example of the Block Exponent optimization on the expression
  49.134 +X = A + B + C is given in figure~\ref{opt:be}.
  49.135 +
  49.136 +% This is an example of how you would use tgrind to include an example
  49.137 +% of source code; it is commented out in this template since the code
  49.138 +% example file does not exist.  To use it, you need to remove the '%' on the
  49.139 +% beginning of the line, and insert your own information in the call.
  49.140 +%
  49.141 +%\tgrind[htbp]{code/be.s.tex}{Block Exponent}{opt:be}
  49.142 +
  49.143 +\section{Integer optimizations}
  49.144 +
  49.145 +As well as the floating point optimizations described above, there are
  49.146 +also integer optimizations that can be used in the $\mu$FPU.  In concert
  49.147 +with the floating point optimizations, these can provide a significant
  49.148 +speedup.  
  49.149 +
  49.150 +\subsection{Conversion to fixed point}
  49.151 +
  49.152 +Integer operations are much faster than floating point operations; if it is
  49.153 +possible to replace floating point operations with fixed point operations,
  49.154 +this would provide a significant increase in speed.
  49.155 +
  49.156 +This conversion can either take place automatically or or based on a
  49.157 +specific request from the programmer.  To do this automatically, the
  49.158 +compiler must either be very smart, or play fast and loose with the accuracy
  49.159 +and precision of the programmer's variables.  To be ``smart'', the computer
  49.160 +must track the ranges of all the floating point variables through the
  49.161 +program, and then see if there are any potential candidates for conversion
  49.162 +to floating point.  This technique is discussed further in
  49.163 +section~\ref{range-tracking}, where it was implemented.
  49.164 +
  49.165 +The other way to do this is to rely on specific hints from the programmer
  49.166 +that a certain value will only assume a specific range, and that only a
  49.167 +specific precision is desired.  This is somewhat more taxing on the
  49.168 +programmer, in that he has to know the ranges that his values will take at
  49.169 +declaration time (something normally abstracted away), but it does provide
  49.170 +the opportunity for fine-tuning already working code.
  49.171 +
  49.172 +Potential applications of this would be simulation programs, where the
  49.173 +variable represents some physical quantity; the constraints of the physical
  49.174 +system may provide bounds on the range the variable can take.
  49.175 +\subsection{Small Constant Multiplications}
  49.176 +
  49.177 +One other class of optimizations that can be done is to replace
  49.178 +multiplications by small integer constants into some combination of
  49.179 +additions and shifts.  Addition and shifting can be significantly faster
  49.180 +than multiplication.  This is done by using some combination of
  49.181 +\begin{eqnarray*}
  49.182 +a_i & = & a_j + a_k \\
  49.183 +a_i & = & 2a_j + a_k \\
  49.184 +a_i & = & 4a_j + a_k \\
  49.185 +a_i & = & 8a_j + a_k \\
  49.186 +a_i & = & a_j - a_k \\
  49.187 +a_i & = & a_j \ll m \mbox{shift}
  49.188 +\end{eqnarray*}
  49.189 +instead of the multiplication.  For example, to multiply $s$ by 10 and store
  49.190 +the result in $r$, you could use:
  49.191 +\begin{eqnarray*}
  49.192 +r & = & 4s + s\\
  49.193 +r & = & r + r
  49.194 +\end{eqnarray*}
  49.195 +Or by 59:
  49.196 +\begin{eqnarray*}
  49.197 +t & = & 2s + s \\
  49.198 +r & = & 2t + s \\
  49.199 +r & = & 8r + t
  49.200 +\end{eqnarray*}
  49.201 +Similar combinations can be found for almost all of the smaller
  49.202 +integers\footnote{This optimization is only an ``optimization'', of course,
  49.203 +when the amount of time spent on the shifts and adds is less than the time
  49.204 +that would be spent doing the multiplication.  Since the time costs of these
  49.205 +operations are known to the compiler in order for it to do scheduling, it is
  49.206 +easy for the compiler to determine when this optimization is worth using.}.
  49.207 +\cite{magenheimer:precision}
  49.208 +
  49.209 +\section{Other optimizations}
  49.210 +
  49.211 +\subsection{Low-level parallelism}
  49.212 +
  49.213 +The current trend is towards duplicating hardware at the lowest level to
  49.214 +provide parallelism\footnote{This can been seen in the i860; floating point
  49.215 +additions and multiplications can proceed at the same time, and the RISC
  49.216 +core be moving data in and out of the floating point registers and providing
  49.217 +flow control at the same time the floating point units are active. \cite{byte:i860}}
  49.218 +
  49.219 +Conceptually, it is easy to take advantage to low-level parallelism in the
  49.220 +instruction stream by simply adding more functional units to the $\mu$FPU,
  49.221 +widening the instruction word to control them, and then scheduling as many
  49.222 +operations to take place at one time as possible.
  49.223 +
  49.224 +However, simply adding more functional units can only be done so many times;
  49.225 +there is only a limited amount of parallelism directly available in the
  49.226 +instruction stream, and without it, much of the extra resources will go to
  49.227 +waste.  One process used to make more instructions potentially schedulable
  49.228 +at any given time is ``trace scheduling''.  This technique originated in the
  49.229 +Bulldog compiler for the original VLIW machine, the ELI-512.
  49.230 +\cite{ellis:bulldog,colwell:vliw}  In trace scheduling, code can be
  49.231 +scheduled through many basic blocks at one time, following a single
  49.232 +potential ``trace'' of program execution.  In this way, instructions that
  49.233 +{\em might\/} be executed depending on a conditional branch further down in
  49.234 +the instruction stream are scheduled, allowing an increase in the potential
  49.235 +parallelism.  To account for the cases where the expected branch wasn't
  49.236 +taken, correction code is inserted after the branches to undo the effects of
  49.237 +any prematurely executed instructions.
  49.238 +
  49.239 +\subsection{Pipeline optimizations}
  49.240 +
  49.241 +In addition to having operations going on in parallel across functional
  49.242 +units, it is also typical to have several operations in various stages of
  49.243 +completion in each unit.  This pipelining allows the throughput of the
  49.244 +functional units to be increased, with no increase in latency.
  49.245 +
  49.246 +There are several ways pipelined operations can be optimized.  On the
  49.247 +hardware side, support can be added to allow data to be recirculated back
  49.248 +into the beginning of the pipeline from the end, saving a trip through the
  49.249 +registers.  On the software side, the compiler can utilize several tricks to
  49.250 +try to fill up as many of the pipeline delay slots as possible, as
  49.251 +seendescribed by Gibbons. \cite{gib86}
  49.252 +
  49.253 +

    50.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    50.2 +++ b/thesis/aux/mitthesis/contents.tex	Thu Mar 27 17:57:01 2014 -0400
    50.3 @@ -0,0 +1,11 @@
    50.4 +  % -*- Mode:TeX -*-
    50.5 +%% This file simply contains the commands that actually generate the table of
    50.6 +%% contents and lists of figures and tables.  You can omit any or all of
    50.7 +%% these files by simply taking out the appropriate command.  For more
    50.8 +%% information on these files, see appendix C.3.3 of the LaTeX manual. 
    50.9 +\tableofcontents
   50.10 +\newpage
   50.11 +\listoffigures
   50.12 +\newpage
   50.13 +\listoftables
   50.14 +

    51.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    51.2 +++ b/thesis/aux/mitthesis/cover.tex	Thu Mar 27 17:57:01 2014 -0400
    51.3 @@ -0,0 +1,132 @@
    51.4 +% -*-latex-*-
    51.5 +% 
    51.6 +% For questions, comments, concerns or complaints:
    51.7 +% thesis@mit.edu
    51.8 +% 
    51.9 +%
   51.10 +% $Log: cover.tex,v $
   51.11 +% Revision 1.8  2008/05/13 15:02:15  jdreed
   51.12 +% Degree month is June, not May.  Added note about prevdegrees.
   51.13 +% Arthur Smith's title updated
   51.14 +%
   51.15 +% Revision 1.7  2001/02/08 18:53:16  boojum
   51.16 +% changed some \newpages to \cleardoublepages
   51.17 +%
   51.18 +% Revision 1.6  1999/10/21 14:49:31  boojum
   51.19 +% changed comment referring to documentstyle
   51.20 +%
   51.21 +% Revision 1.5  1999/10/21 14:39:04  boojum
   51.22 +% *** empty log message ***
   51.23 +%
   51.24 +% Revision 1.4  1997/04/18  17:54:10  othomas
   51.25 +% added page numbers on abstract and cover, and made 1 abstract
   51.26 +% page the default rather than 2.  (anne hunter tells me this
   51.27 +% is the new institute standard.)
   51.28 +%
   51.29 +% Revision 1.4  1997/04/18  17:54:10  othomas
   51.30 +% added page numbers on abstract and cover, and made 1 abstract
   51.31 +% page the default rather than 2.  (anne hunter tells me this
   51.32 +% is the new institute standard.)
   51.33 +%
   51.34 +% Revision 1.3  93/05/17  17:06:29  starflt
   51.35 +% Added acknowledgements section (suggested by tompalka)
   51.36 +% 
   51.37 +% Revision 1.2  92/04/22  13:13:13  epeisach
   51.38 +% Fixes for 1991 course 6 requirements
   51.39 +% Phrase "and to grant others the right to do so" has been added to 
   51.40 +% permission clause
   51.41 +% Second copy of abstract is not counted as separate pages so numbering works
   51.42 +% out
   51.43 +% 
   51.44 +% Revision 1.1  92/04/22  13:08:20  epeisach
   51.45 +
   51.46 +% NOTE:
   51.47 +% These templates make an effort to conform to the MIT Thesis specifications,
   51.48 +% however the specifications can change.  We recommend that you verify the
   51.49 +% layout of your title page with your thesis advisor and/or the MIT 
   51.50 +% Libraries before printing your final copy.
   51.51 +\title{An Optimizing Compiler for Low-Level Floating Point Operations}
   51.52 +
   51.53 +\author{Robert McIntyre}
   51.54 +% If you wish to list your previous degrees on the cover page, use the 
   51.55 +% previous degrees command:
   51.56 +%       \prevdegrees{A.A., Harvard University (1985)}
   51.57 +% You can use the \\ command to list multiple previous degrees
   51.58 +%       \prevdegrees{B.S., University of California (1978) \\
   51.59 +%                    S.M., Massachusetts Institute of Technology (1981)}
   51.60 +\department{Department of Electrical Engineering and Computer Science}
   51.61 +
   51.62 +% If the thesis is for two degrees simultaneously, list them both
   51.63 +% separated by \and like this:
   51.64 +% \degree{Doctor of Philosophy \and Master of Science}
   51.65 +\degree{Bachelor of Science in Computer Science and Engineering}
   51.66 +
   51.67 +% As of the 2007-08 academic year, valid degree months are September, 
   51.68 +% February, or June.  The default is June.
   51.69 +\degreemonth{June}
   51.70 +\degreeyear{1990}
   51.71 +\thesisdate{May 18, 1990}
   51.72 +
   51.73 +%% By default, the thesis will be copyrighted to MIT.  If you need to copyright
   51.74 +%% the thesis to yourself, just specify the `vi' documentclass option.  If for
   51.75 +%% some reason you want to exactly specify the copyright notice text, you can
   51.76 +%% use the \copyrightnoticetext command.  
   51.77 +%\copyrightnoticetext{\copyright IBM, 1990.  Do not open till Xmas.}
   51.78 +
   51.79 +% If there is more than one supervisor, use the \supervisor command
   51.80 +% once for each.
   51.81 +\supervisor{William J. Dally}{Associate Professor}
   51.82 +
   51.83 +% This is the department committee chairman, not the thesis committee
   51.84 +% chairman.  You should replace this with your Department's Committee
   51.85 +% Chairman.
   51.86 +\chairman{Arthur C. Smith}{Chairman, Department Committee on Graduate Theses}
   51.87 +
   51.88 +% Make the titlepage based on the above information.  If you need
   51.89 +% something special and can't use the standard form, you can specify
   51.90 +% the exact text of the titlepage yourself.  Put it in a titlepage
   51.91 +% environment and leave blank lines where you want vertical space.
   51.92 +% The spaces will be adjusted to fill the entire page.  The dotted
   51.93 +% lines for the signatures are made with the \signature command.
   51.94 +\maketitle
   51.95 +
   51.96 +% The abstractpage environment sets up everything on the page except
   51.97 +% the text itself.  The title and other header material are put at the
   51.98 +% top of the page, and the supervisors are listed at the bottom.  A
   51.99 +% new page is begun both before and after.  Of course, an abstract may
  51.100 +% be more than one page itself.  If you need more control over the
  51.101 +% format of the page, you can use the abstract environment, which puts
  51.102 +% the word "Abstract" at the beginning and single spaces its text.
  51.103 +
  51.104 +%% You can either \input (*not* \include) your abstract file, or you can put
  51.105 +%% the text of the abstract directly between the \begin{abstractpage} and
  51.106 +%% \end{abstractpage} commands.
  51.107 +
  51.108 +% First copy: start a new page, and save the page number.
  51.109 +\cleardoublepage
  51.110 +% Uncomment the next line if you do NOT want a page number on your
  51.111 +% abstract and acknowledgments pages.
  51.112 +\pagestyle{empty}
  51.113 +\setcounter{savepage}{\thepage}
  51.114 +\begin{abstractpage}
  51.115 +\input{abstract}
  51.116 +\end{abstractpage}
  51.117 +
  51.118 +% Additional copy: start a new page, and reset the page number.  This way,
  51.119 +% the second copy of the abstract is not counted as separate pages.
  51.120 +% Uncomment the next 6 lines if you need two copies of the abstract
  51.121 +% page.
  51.122 +% \setcounter{page}{\thesavepage}
  51.123 +% \begin{abstractpage}
  51.124 +% \input{abstract}
  51.125 +% \end{abstractpage}
  51.126 +
  51.127 +\cleardoublepage
  51.128 +
  51.129 +\section*{Acknowledgments}
  51.130 +
  51.131 +This is the acknowledgements section.  You should replace this with your
  51.132 +own acknowledgements.
  51.133 +
  51.134 +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  51.135 +% -*-latex-*-

    52.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    52.2 +++ b/thesis/aux/mitthesis/main.bib	Thu Mar 27 17:57:01 2014 -0400
    52.3 @@ -0,0 +1,356 @@
    52.4 +@preamble{ "\newcommand{\noopsort}[1]{} "
    52.5 +	# "\newcommand{\printfirst}[2]{#1} "
    52.6 +	# "\newcommand{\singleletter}[1]{#1} "
    52.7 +	# "\newcommand{\switchargs}[2]{#2#1} " }
    52.8 +
    52.9 +@ARTICLE{article-minimal,
   52.10 +   author = {L[eslie] A. Aamport},
   52.11 +   title = {The Gnats and Gnus Document Preparation System},
   52.12 +   journal = {\mbox{G-Animal's} Journal},
   52.13 +   year = 1986,
   52.14 +}
   52.15 +
   52.16 +@ARTICLE{article-full,
   52.17 +   author = {L[eslie] A. Aamport},
   52.18 +   title = {The Gnats and Gnus Document Preparation System},
   52.19 +   journal = {\mbox{G-Animal's} Journal},
   52.20 +   year = 1986,
   52.21 +   volume = 41,
   52.22 +   number = 7,
   52.23 +   pages = "73+",
   52.24 +   month = jul,
   52.25 +   note = "This is a full ARTICLE entry",
   52.26 +}
   52.27 +
   52.28 +The KEY field is here to override the KEY field in the journal being
   52.29 +cross referenced (so is the NOTE field, in addition to its imparting
   52.30 +information).
   52.31 +
   52.32 +@ARTICLE{article-crossref,
   52.33 +   crossref = {WHOLE-JOURNAL},
   52.34 +   key = "",
   52.35 +   author = {L[eslie] A. Aamport},
   52.36 +   title = {The Gnats and Gnus Document Preparation System},
   52.37 +   pages = "73+",
   52.38 +   note = "This is a cross-referencing ARTICLE entry",
   52.39 +}
   52.40 +
   52.41 +@ARTICLE{whole-journal,
   52.42 +   key = "GAJ",
   52.43 +   journal = {\mbox{G-Animal's} Journal},
   52.44 +   year = 1986,
   52.45 +   volume = 41,
   52.46 +   number = 7,
   52.47 +   month = jul,
   52.48 +   note = {The entire issue is devoted to gnats and gnus
   52.49 +		(this entry is a cross-referenced ARTICLE (journal))},
   52.50 +}
   52.51 +
   52.52 +@INBOOK{inbook-minimal,
   52.53 +   author = "Donald E. Knuth",
   52.54 +   title = "Fundamental Algorithms",
   52.55 +   publisher = "Addison-Wesley",
   52.56 +   year = "{\noopsort{1973b}}1973",
   52.57 +   chapter = "1.2",
   52.58 +}
   52.59 +
   52.60 +@INBOOK{inbook-full,
   52.61 +   author = "Donald E. Knuth",
   52.62 +   title = "Fundamental Algorithms",
   52.63 +   volume = 1,
   52.64 +   series = "The Art of Computer Programming",
   52.65 +   publisher = "Addison-Wesley",
   52.66 +   address = "Reading, Massachusetts",
   52.67 +   edition = "Second",
   52.68 +   month = "10~" # jan,
   52.69 +   year = "{\noopsort{1973b}}1973",
   52.70 +   type = "Section",
   52.71 +   chapter = "1.2",
   52.72 +   pages = "10--119",
   52.73 +   note = "This is a full INBOOK entry",
   52.74 +}
   52.75 +
   52.76 +@INBOOK{inbook-crossref,
   52.77 +   crossref = "whole-set",
   52.78 +   title = "Fundamental Algorithms",
   52.79 +   volume = 1,
   52.80 +   series = "The Art of Computer Programming",
   52.81 +   edition = "Second",
   52.82 +   year = "{\noopsort{1973b}}1973",
   52.83 +   type = "Section",
   52.84 +   chapter = "1.2",
   52.85 +   note = "This is a cross-referencing INBOOK entry",
   52.86 +}
   52.87 +
   52.88 +@BOOK{book-minimal,
   52.89 +   author = "Donald E. Knuth",
   52.90 +   title = "Seminumerical Algorithms",
   52.91 +   publisher = "Addison-Wesley",
   52.92 +   year = "{\noopsort{1973c}}1981",
   52.93 +}
   52.94 +
   52.95 +@BOOK{book-full,
   52.96 +   author = "Donald E. Knuth",
   52.97 +   title = "Seminumerical Algorithms",
   52.98 +   volume = 2,
   52.99 +   series = "The Art of Computer Programming",
  52.100 +   publisher = "Addison-Wesley",
  52.101 +   address = "Reading, Massachusetts",
  52.102 +   edition = "Second",
  52.103 +   month = "10~" # jan,
  52.104 +   year = "{\noopsort{1973c}}1981",
  52.105 +   note = "This is a full BOOK entry",
  52.106 +}
  52.107 +
  52.108 +@BOOK{book-crossref,
  52.109 +   crossref = "whole-set",
  52.110 +   title = "Seminumerical Algorithms",
  52.111 +   volume = 2,
  52.112 +   series = "The Art of Computer Programming",
  52.113 +   edition = "Second",
  52.114 +   year = "{\noopsort{1973c}}1981",
  52.115 +   note = "This is a cross-referencing BOOK entry",
  52.116 +}
  52.117 +
  52.118 +@BOOK{whole-set,
  52.119 +   author = "Donald E. Knuth",
  52.120 +   publisher = "Addison-Wesley",
  52.121 +   title = "The Art of Computer Programming",
  52.122 +   series = "Four volumes",
  52.123 +   year = "{\noopsort{1973a}}{\switchargs{--90}{1968}}",
  52.124 +   note = "Seven volumes planned (this is a cross-referenced set of BOOKs)",
  52.125 +}
  52.126 +
  52.127 +@BOOKLET{booklet-minimal,
  52.128 +   key = "Kn{\printfirst{v}{1987}}",
  52.129 +   title = "The Programming of Computer Art",
  52.130 +}
  52.131 +
  52.132 +@BOOKLET{booklet-full,
  52.133 +   author = "Jill C. Knvth",
  52.134 +   title = "The Programming of Computer Art",
  52.135 +   howpublished = "Vernier Art Center",
  52.136 +   address = "Stanford, California",
  52.137 +   month = feb,
  52.138 +   year = 1988,
  52.139 +   note = "This is a full BOOKLET entry",
  52.140 +}
  52.141 +
  52.142 +@INCOLLECTION{incollection-minimal,
  52.143 +   author = "Daniel D. Lincoll",
  52.144 +   title = "Semigroups of Recurrences",
  52.145 +   booktitle = "High Speed Computer and Algorithm Organization",
  52.146 +   publisher = "Academic Press",
  52.147 +   year = 1977,
  52.148 +}
  52.149 +
  52.150 +@INCOLLECTION{incollection-full,
  52.151 +   author = "Daniel D. Lincoll",
  52.152 +   title = "Semigroups of Recurrences",
  52.153 +   editor = "David J. Lipcoll and D. H. Lawrie and A. H. Sameh",
  52.154 +   booktitle = "High Speed Computer and Algorithm Organization",
  52.155 +   number = 23,
  52.156 +   series = "Fast Computers",
  52.157 +   chapter = 3,
  52.158 +   type = "Part",
  52.159 +   pages = "179--183",
  52.160 +   publisher = "Academic Press",
  52.161 +   address = "New York",
  52.162 +   edition = "Third",
  52.163 +   month = sep,
  52.164 +   year = 1977,
  52.165 +   note = "This is a full INCOLLECTION entry",
  52.166 +}
  52.167 +
  52.168 +@INCOLLECTION{incollection-crossref,
  52.169 +   crossref = "whole-collection",
  52.170 +   author = "Daniel D. Lincoll",
  52.171 +   title = "Semigroups of Recurrences",
  52.172 +   pages = "179--183",
  52.173 +   note = "This is a cross-referencing INCOLLECTION entry",
  52.174 +}
  52.175 +
  52.176 +@BOOK{whole-collection,
  52.177 +   editor = "David J. Lipcoll and D. H. Lawrie and A. H. Sameh",
  52.178 +   title = "High Speed Computer and Algorithm Organization",
  52.179 +   booktitle = "High Speed Computer and Algorithm Organization",
  52.180 +   number = 23,
  52.181 +   series = "Fast Computers",
  52.182 +   publisher = "Academic Press",
  52.183 +   address = "New York",
  52.184 +   edition = "Third",
  52.185 +   month = sep,
  52.186 +   year = 1977,
  52.187 +   note = "This is a cross-referenced BOOK (collection) entry",
  52.188 +}
  52.189 +
  52.190 +@MANUAL{manual-minimal,
  52.191 +   key = "Manmaker",
  52.192 +   title = "The Definitive Computer Manual",
  52.193 +}
  52.194 +
  52.195 +@MANUAL{manual-full,
  52.196 +   author = "Larry Manmaker",
  52.197 +   title = "The Definitive Computer Manual",
  52.198 +   organization = "Chips-R-Us",
  52.199 +   address = "Silicon Valley",
  52.200 +   edition = "Silver",
  52.201 +   month = apr # "-" # may,
  52.202 +   year = 1986,
  52.203 +   note = "This is a full MANUAL entry",
  52.204 +}
  52.205 +
  52.206 +@MASTERSTHESIS{mastersthesis-minimal,
  52.207 +   author = "{\'{E}}douard Masterly",
  52.208 +   title = "Mastering Thesis Writing",
  52.209 +   school = "Stanford University",
  52.210 +   year = 1988,
  52.211 +}
  52.212 +
  52.213 +@MASTERSTHESIS{mastersthesis-full,
  52.214 +   author = "{\'{E}}douard Masterly",
  52.215 +   title = "Mastering Thesis Writing",
  52.216 +   school = "Stanford University",
  52.217 +   type = "Master's project",
  52.218 +   address = "English Department",
  52.219 +   month = jun # "-" # aug,
  52.220 +   year = 1988,
  52.221 +   note = "This is a full MASTERSTHESIS entry",
  52.222 +}
  52.223 +
  52.224 +@MISC{misc-minimal,
  52.225 +   key = "Missilany",
  52.226 +   note = "This is a minimal MISC entry",
  52.227 +}
  52.228 +
  52.229 +@MISC{misc-full,
  52.230 +   author = "Joe-Bob Missilany",
  52.231 +   title = "Handing out random pamphlets in airports",
  52.232 +   howpublished = "Handed out at O'Hare",
  52.233 +   month = oct,
  52.234 +   year = 1984,
  52.235 +   note = "This is a full MISC entry",
  52.236 +}
  52.237 +
  52.238 +@STRING{STOC-key = "OX{\singleletter{stoc}}"}
  52.239 +
  52.240 +@STRING{ACM = "The OX Association for Computing Machinery"}
  52.241 +
  52.242 +@STRING{STOC = " Symposium on the Theory of Computing"}
  52.243 +
  52.244 +@INPROCEEDINGS{inproceedings-minimal,
  52.245 +   author = "Alfred V. Oaho and Jeffrey D. Ullman and Mihalis Yannakakis",
  52.246 +   title = "On Notions of Information Transfer in {VLSI} Circuits",
  52.247 +   booktitle = "Proc. Fifteenth Annual ACM" # STOC,
  52.248 +   year = 1983,
  52.249 +}
  52.250 +
  52.251 +@INPROCEEDINGS{inproceedings-full,
  52.252 +   author = "Alfred V. Oaho and Jeffrey D. Ullman and Mihalis Yannakakis",
  52.253 +   title = "On Notions of Information Transfer in {VLSI} Circuits",
  52.254 +   editor = "Wizard V. Oz and Mihalis Yannakakis",
  52.255 +   booktitle = "Proc. Fifteenth Annual ACM" # STOC,
  52.256 +   number = 17,
  52.257 +   series = "All ACM Conferences",
  52.258 +   pages = "133--139",
  52.259 +   month = mar,
  52.260 +   year = 1983,
  52.261 +   address = "Boston",
  52.262 +   organization = ACM,
  52.263 +   publisher = "Academic Press",
  52.264 +   note = "This is a full INPROCEDINGS entry",
  52.265 +}
  52.266 +
  52.267 +@INPROCEEDINGS{inproceedings-crossref,
  52.268 +   crossref = "whole-proceedings",
  52.269 +   author = "Alfred V. Oaho and Jeffrey D. Ullman and Mihalis Yannakakis",
  52.270 +   title = "On Notions of Information Transfer in {VLSI} Circuits",
  52.271 +   organization = "",
  52.272 +   pages = "133--139",
  52.273 +   note = "This is a cross-referencing INPROCEEDINGS entry",
  52.274 +}
  52.275 +
  52.276 +@PROCEEDINGS{proceedings-minimal,
  52.277 +   key = STOC-key,
  52.278 +   title = "Proc. Fifteenth Annual" # STOC,
  52.279 +   year = 1983,
  52.280 +}
  52.281 +
  52.282 +@PROCEEDINGS{proceedings-full,
  52.283 +   editor = "Wizard V. Oz and Mihalis Yannakakis",
  52.284 +   title = "Proc. Fifteenth Annual" # STOC,
  52.285 +   number = 17,
  52.286 +   series = "All ACM Conferences",
  52.287 +   month = mar,
  52.288 +   year = 1983,
  52.289 +   address = "Boston",
  52.290 +   organization = ACM,
  52.291 +   publisher = "Academic Press",
  52.292 +   note = "This is a full PROCEEDINGS entry",
  52.293 +}
  52.294 +
  52.295 +@PROCEEDINGS{whole-proceedings,
  52.296 +   key = STOC-key,
  52.297 +   organization = ACM,
  52.298 +   title = "Proc. Fifteenth Annual" # STOC,
  52.299 +   address = "Boston",
  52.300 +   year = 1983,
  52.301 +   booktitle = "Proc. Fifteenth Annual ACM" # STOC,
  52.302 +   note = "This is a cross-referenced PROCEEDINGS",
  52.303 +}
  52.304 +
  52.305 +@PHDTHESIS{phdthesis-minimal,
  52.306 +   author = "F. Phidias Phony-Baloney",
  52.307 +   title = "Fighting Fire with Fire: Festooning {F}rench Phrases",
  52.308 +   school = "Fanstord University",
  52.309 +   year = 1988,
  52.310 +}
  52.311 +
  52.312 +@PHDTHESIS{phdthesis-full,
  52.313 +   author = "F. Phidias Phony-Baloney",
  52.314 +   title = "Fighting Fire with Fire: Festooning {F}rench Phrases",
  52.315 +   school = "Fanstord University",
  52.316 +   type = "{PhD} Dissertation",
  52.317 +   address = "Department of French",
  52.318 +   month = jun # "-" # aug,
  52.319 +   year = 1988,
  52.320 +   note = "This is a full PHDTHESIS entry",
  52.321 +}
  52.322 +
  52.323 +@TECHREPORT{techreport-minimal,
  52.324 +   author = "Tom Terrific",
  52.325 +   title = "An {$O(n \log n / \! \log\log n)$} Sorting Algorithm",
  52.326 +   institution = "Fanstord University",
  52.327 +   year = 1988,
  52.328 +}
  52.329 +
  52.330 +@TECHREPORT{techreport-full,
  52.331 +   author = "Tom T{\'{e}}rrific",
  52.332 +   title = "An {$O(n \log n / \! \log\log n)$} Sorting Algorithm",
  52.333 +   institution = "Fanstord University",
  52.334 +   type = "Wishful Research Result",
  52.335 +   number = "7",
  52.336 +   address = "Computer Science Department, Fanstord, California",
  52.337 +   month = oct,
  52.338 +   year = 1988,
  52.339 +   note = "This is a full TECHREPORT entry",
  52.340 +}
  52.341 +
  52.342 +@UNPUBLISHED{unpublished-minimal,
  52.343 +   author = "Ulrich {\"{U}}nderwood and Ned {\~N}et and Paul {\={P}}ot",
  52.344 +   title = "Lower Bounds for Wishful Research Results",
  52.345 +   note = "Talk at Fanstord University (this is a minimal UNPUBLISHED entry)",
  52.346 +}
  52.347 +
  52.348 +@UNPUBLISHED{unpublished-full,
  52.349 +   author = "Ulrich {\"{U}}nderwood and Ned {\~N}et and Paul {\={P}}ot",
  52.350 +   title = "Lower Bounds for Wishful Research Results",
  52.351 +   month = nov # ", " # dec,
  52.352 +   year = 1988,
  52.353 +   note = "Talk at Fanstord University (this is a full UNPUBLISHED entry)",
  52.354 +}
  52.355 +
  52.356 +@MISC{random-note-crossref,
  52.357 +   key = {Volume-2},
  52.358 +   note = "Volume~2 is listed under Knuth \cite{book-full}"
  52.359 +}

    53.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    53.2 +++ b/thesis/aux/mitthesis/main.tex	Thu Mar 27 17:57:01 2014 -0400
    53.3 @@ -0,0 +1,46 @@
    53.4 +% -*- Mode:TeX -*-
    53.5 +
    53.6 +%% IMPORTANT: The official thesis specifications are available at:
    53.7 +%%            http://libraries.mit.edu/archives/thesis-specs/
    53.8 +%%
    53.9 +%%            Please verify your thesis' formatting and copyright
   53.10 +%%            assignment before submission.  If you notice any
   53.11 +%%            discrepancies between these templates and the 
   53.12 +%%            MIT Libraries' specs, please let us know
   53.13 +%%            by e-mailing thesis@mit.edu
   53.14 +
   53.15 +%% The documentclass options along with the pagestyle can be used to generate
   53.16 +%% a technical report, a draft copy, or a regular thesis.  You may need to
   53.17 +%% re-specify the pagestyle after you \include  cover.tex.  For more
   53.18 +%% information, see the first few lines of mitthesis.cls. 
   53.19 +
   53.20 +%\documentclass[12pt,vi,twoside]{mitthesis}
   53.21 +%%
   53.22 +%%  If you want your thesis copyright to you instead of MIT, use the
   53.23 +%%  ``vi'' option, as above.
   53.24 +%%
   53.25 +%\documentclass[12pt,twoside,leftblank]{mitthesis}
   53.26 +%%
   53.27 +%% If you want blank pages before new chapters to be labelled ``This
   53.28 +%% Page Intentionally Left Blank'', use the ``leftblank'' option, as
   53.29 +%% above. 
   53.30 +
   53.31 +\documentclass[12pt,twoside]{mitthesis}
   53.32 +%\usepackage{lgrind}
   53.33 +\pagestyle{plain}
   53.34 +
   53.35 +\begin{document}
   53.36 +
   53.37 +\include{cover}
   53.38 +% Some departments (e.g. 5) require an additional signature page.  See
   53.39 +% signature.tex for more information and uncomment the following line if
   53.40 +% applicable.
   53.41 +% \include{signature}
   53.42 +\pagestyle{plain}
   53.43 +\include{contents}
   53.44 +\include{chap1}
   53.45 +\include{chap2}
   53.46 +\appendix
   53.47 +\include{biblio}
   53.48 +\end{document}
   53.49 +

    54.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    54.2 +++ b/thesis/aux/mitthesis/mitthesis.cls	Thu Mar 27 17:57:01 2014 -0400
    54.3 @@ -0,0 +1,535 @@
    54.4 +% $Log: mitthesis.cls,v $
    54.5 +% Revision 1.9  2012/02/15 15:48:16  jdreed
    54.6 +% Tweak the "permission" statement per the Libraries' specs
    54.7 +% retrieved 15-Feb-2012
    54.8 +%
    54.9 +% Revision 1.8  2009/07/27 14:23:50  boojum
   54.10 +% added changing draft mark
   54.11 +%
   54.12 +% Revision 1.6  2005/05/13 19:57:40  boojum
   54.13 +% added leftblank option
   54.14 +%
   54.15 +% Revision 1.5  2002/04/18 14:10:08  boojum
   54.16 +% changed doublespace into setspace for 2e compliance
   54.17 +%
   54.18 +% Revision 1.4  2001/02/08 18:57:13  boojum
   54.19 +% turned two newpages into cleardoublepages
   54.20 +%
   54.21 +% Revision 1.3  2000/08/14 14:53:29  boojum
   54.22 +% commented out footheight, which is relevant for drafthead
   54.23 +%
   54.24 +% Revision 1.2  1999/10/21 14:51:33  boojum
   54.25 +% changed references to documentstyle to documentclass in comments
   54.26 +%
   54.27 +% Revision 1.1  1999/10/21 14:39:31  boojum
   54.28 +% Initial revision
   54.29 +%
   54.30 +%Revision 1.7  1998/04/01  20:45:34  othomas
   54.31 +%removed offending phrase ", and to grant others the right to do so" from copyright notice.
   54.32 +%
   54.33 +%Revision 1.6  96/06/26  15:07:29  othomas
   54.34 +%safety checkin.
   54.35 +%
   54.36 +%Revision 1.5  93/06/07  15:38:50  starflt
   54.37 +%Altered 'vi' option copyright wording to comply with new Institute
   54.38 +%Archives requirements and MIT lawyers.
   54.39 +%
   54.40 +%Revision 1.4  92/08/19  16:51:06  lwvanels
   54.41 +%Updated Course 6 title page for new permissions.
   54.42 +%
   54.43 +%Revision 1.3  92/04/23  10:16:15  epeisach
   54.44 +%Fixed comment character in rcs file
   54.45 +%
   54.46 +%Revision 1.2  92/04/22  13:12:02  epeisach
   54.47 +%Fixes for 1991 course 6 requirements
   54.48 +%Phrase "and to grant others the right to do so" has been added to 
   54.49 +%permission clause
   54.50 +%Second copy of abstract is not counted as separate pages so numbering works
   54.51 +%out
   54.52 +%
   54.53 +%Revision 1.1  90/05/04  11:45:53  lwvanels
   54.54 +%Initial revision
   54.55 +
   54.56 +%
   54.57 +% LaTeX format for theses at MIT
   54.58 +% Based on "Specifications for Thesis Preparation" 
   54.59 +
   54.60 +% `vi' and `upcase' options by Krishna Sethuraman - krishna@athena.mit.edu
   54.61 +% Margins and heading types by Peter Nuth  - nuth@ai.mit.edu
   54.62 +% Title and abstract page by Stephen Gildea - gildea@erl.mit.edu
   54.63 +% Look in this directory for example file mitthesis.doc
   54.64 +% Also for propcover.tex - Boilerplate for PHD proposal.
   54.65 +
   54.66 +% To use this style - say something like:
   54.67 +%  for dull, boring thesis format:
   54.68 +%	\documentclass[12pt]{mitthesis}
   54.69 +%       \pagestyle{plain}
   54.70 +% OR for fast drafts: 
   54.71 +%	\documentclass[11pt,singlespace,draft]{mitthesis}
   54.72 +%	\pagestyle{drafthead}
   54.73 +% OR for Tech Reports:
   54.74 +%	\documentclass[12pt,twoside]{mitthesis}	
   54.75 +%	\pagestyle{headings}
   54.76 +% OR
   54.77 +%  some other combination...
   54.78 +%
   54.79 +%%%% New options:
   54.80 +% 
   54.81 +% Option `twoside':
   54.82 +%   Good for producing Tech Reports.
   54.83 +%   The default is single-sided printing, which is what M.I.T. wants on the
   54.84 +%   thesis document itself.
   54.85 +%
   54.86 +% Option `singlespace':
   54.87 +%   Good for drafts.
   54.88 +%   Double-spaced theses are the default.
   54.89 +%   That is what M.I.T. asks for in the formal specifications.
   54.90 +%
   54.91 +% 	Note that MIT does not REQUIRE all theses to be double-spaced anymore.
   54.92 +% 	Someone in the library system said that it's OK to be single-spaced.
   54.93 +% 	(Regardless of what the specs. say...)
   54.94 +%   To get singlespacing in an area - Use  the 'singlespace' environment. 
   54.95 +%
   54.96 +% Option `draft':
   54.97 +%   Puts `overfull' boxes at the end of lines that are too long. 
   54.98 +%
   54.99 +% Pagestyle `drafthead':
  54.100 +%   Puts the date and the label ``*DRAFT*'' in the footer.
  54.101 +%
  54.102 +%%%%%%%%%%
  54.103 +%
  54.104 +%%%% Parameters to initialize for boilerplate page:
  54.105 +%
  54.106 +%	\title{Mixed Circular Cylindrical Shells}
  54.107 +% 	\author{J. Casey Salas}
  54.108 +% 	\prevdegrees{B.S., University of California (1978) \\
  54.109 +%		     S.M., Massachusetts Institute of Technology (1981)}
  54.110 +% 	\department{Department of Electrical Engineering and Computer Science}
  54.111 +% 	\degree{Doctor of Philosophy}
  54.112 +%% If the thesis is for two degrees simultaneously, list them both
  54.113 +%% separated by \and like this:
  54.114 +% 	\degree{Doctor of Philosophy \and Master of Science}
  54.115 +% 	\degreemonth{February}
  54.116 +% 	\degreeyear{1987}
  54.117 +% 	\thesisdate{December 10, 1986}
  54.118 +%% If the thesis is copyright by the Institute, leave this line out and
  54.119 +%% the standard copyright line will be used instead.
  54.120 +% 	\copyrightnotice{J. Casey Salas, 1986}
  54.121 +%% If there is more than one supervisor, use the \supervisor command
  54.122 +%% once for each.
  54.123 +% 	\supervisor{John D. Galli}{Director, Sound Instrument Laboratory}
  54.124 +%% This is the department committee chairman, not the thesis committee chairman
  54.125 +% 	\chairman{Arthur C. Smith}
  54.126 +%		 {Chairman, Departmental Committee on Graduate Students}
  54.127 +%% Make the titlepage based on the above information.  If you need
  54.128 +%% something special and can't use the standard form, you can specify
  54.129 +%% the exact text of the titlepage yourself.  Put it in a titlepage
  54.130 +%% environment and leave blank lines where you want vertical space.
  54.131 +%% The spaces will be adjusted to fill the entire page.  The dotted
  54.132 +%% lines for the signatures are made with the \signature command.
  54.133 +%
  54.134 +%% The abstractpage environment sets up everything on the page except
  54.135 +%% the text itself.  The title and other header material are put at the
  54.136 +%% top of the page, and the supervisors are listed at the bottom.  A
  54.137 +%% new page is begun both before and after.  Of course, an abstract may
  54.138 +%% be more than one page itself.  If you need more control over the
  54.139 +%% format of the page, you can use the abstract environment, which puts
  54.140 +%% the word "Abstract" at the beginning and single spaces its text.
  54.141 +%
  54.142 +% 	\begin{abstractpage}
  54.143 +%	    Abstract goes here.
  54.144 +%	\end{abstractpage}
  54.145 +%
  54.146 +%%%%%%%% Newer additions 
  54.147 +%
  54.148 +% documentclass options - 
  54.149 +% vi		For MIT course VI or VIII thesis - will copyright the thesis to
  54.150 +% 		you while giving MIT permission to copy and distribute it.
  54.151 +% upcase	Will put much of the cover page in uppercase, as per the
  54.152 +% 		example on page 17 of the *Specifications for Thesis
  54.153 +% 		Preparation*, (revised 1989)
  54.154 +% Also added ``All Rights Reserved'' to default copyright notice.
  54.155 +%
  54.156 +%%%%%%%%%%%
  54.157 +% 
  54.158 +% Documentclass options (vi and upcase) and changes to copyright notice
  54.159 +%	Copyright (c) 1990, by Krishna Sethuraman.
  54.160 +%
  54.161 +% Pagestyle and header generation
  54.162 +%	Copyright (c) 1987, 1988 by Peter Nuth
  54.163 +%
  54.164 +% Original version
  54.165 +%	 Copyright (c) 1987 by Stephen Gildea
  54.166 +% Permission to copy all or part of this work is granted, provided
  54.167 +% that the copies are not made or distributed for resale, and that
  54.168 +% the copyright notice and this notice are retained.
  54.169 +% 
  54.170 +% THIS WORK IS PROVIDED ON AN "AS IS" BASIS.  THE AUTHOR PROVIDES NO
  54.171 +% WARRANTY WHATSOEVER, EITHER EXPRESS OR IMPLIED, REGARDING THE WORK,
  54.172 +% INCLUDING WARRANTIES WITH RESPECT TO ITS MERCHANTABILITY OR FITNESS
  54.173 +% FOR ANY PARTICULAR PURPOSE.
  54.174 +%%%%%%%%
  54.175 +
  54.176 +\NeedsTeXFormat{LaTeX2e}
  54.177 +\ProvidesClass{mitthesis}[1999/10/20]
  54.178 +
  54.179 +\def\mystretch{1.5}		% Double spacing hack
  54.180 +\DeclareOption{doublespace}{}	% This is default
  54.181 +				% So we do not read this style twice
  54.182 +\DeclareOption{singlespace}{		% If he explicitly wants single spacing
  54.183 +    \typeout{Single spaced}
  54.184 +    \def\mystretch{1}}	
  54.185 +
  54.186 +%% `vi' and `upcase' document style options.  Krishna Sethuraman (1990)
  54.187 +\newcount\vithesis
  54.188 +\DeclareOption{vi}{\typeout{Course VI/VIII thesis style.}\advance\vithesis by1}
  54.189 +\vithesis=0
  54.190 +
  54.191 +\DeclareOption{upcase}{\typeout{Uppercase cover page.}
  54.192 +	\gdef\choosecase#1{\uppercase\expandafter{#1}}}
  54.193 +\def\choosecase#1{#1}
  54.194 +
  54.195 +%% leftblank option by Kevin Fu
  54.196 +\newif\if@leftblank \@leftblankfalse
  54.197 +
  54.198 +\DeclareOption{leftblank}{\typeout{Intentionally Leaving Pages Blank}
  54.199 +\@leftblanktrue}
  54.200 +
  54.201 +%  Thesis looks much like report
  54.202 +\DeclareOption*{\PassOptionsToClass{\CurrentOption}{report}}
  54.203 +\ProcessOptions
  54.204 +\LoadClass{report}
  54.205 +
  54.206 +% If the user wants single spacing, set baselinestretch=1.
  54.207 +
  54.208 +\usepackage{setspace}
  54.209 +
  54.210 +% Note - doublespace.sty has some float-related troubles in
  54.211 +% combination with graphics or color, and is not officially compliant
  54.212 +% with 2e.  setspace is a replacement which is 2e-compliant.
  54.213 +
  54.214 +% Read the doublespace style that we got from Rochester:
  54.215 +%\input setdoublespace.sty 		
  54.216 +
  54.217 +\def\baselinestretch{\mystretch}	% Double spacing hack
  54.218 +
  54.219 +%%%%%%%  Set up margins and formatting params %%%
  54.220 +
  54.221 +% Margins.
  54.222 +%  Note we want 1in top margin assuming no header line, so push header
  54.223 +%	into 1in margin.
  54.224 +%  Draft mode brings the header back down.
  54.225 +
  54.226 +\setlength{\oddsidemargin}{0.25in}	% 1.25in left margin 
  54.227 +\setlength{\evensidemargin}{0.25in}	% 1.25in left margin (even pages)
  54.228 +\setlength{\topmargin}{0.0in}		% 1in top margin
  54.229 +\setlength{\textwidth}{6.0in}		% 6.0in text - 1.25in rt margin
  54.230 +\setlength{\textheight}{9in}		% Body ht for 1in margins
  54.231 +\addtolength{\topmargin}{-\headheight}	% No header, so compensate
  54.232 +\addtolength{\topmargin}{-\headsep}	% for header height and separation
  54.233 +
  54.234 +% The next two macros compensate page style for headers and footers
  54.235 +% We only need them in page styles that USE headers and footers.
  54.236 +    % If we have a header, it must be 1in from top of page.
  54.237 +\def\pulldownheader{			% Shift header down 1in from top
  54.238 +    \addtolength{\topmargin}{\headheight}	
  54.239 +    \addtolength{\topmargin}{\headsep}	
  54.240 +    \addtolength{\textheight}{-\headheight}
  54.241 +    \addtolength{\textheight}{-\headsep}
  54.242 +}
  54.243 +    % If we have a footer, put it 1in up from bottom
  54.244 +\def\pullupfooter{				% Shift footer up
  54.245 +    \addtolength{\textheight}{-\footskip}
  54.246 +%    \addtolength{\textheight}{-\footheight}  %footheight doesn't
  54.247 +%    						exist in 2e
  54.248 +}
  54.249 +
  54.250 +%%%%%%%  End of margins and formatting params %%%
  54.251 +
  54.252 +%%%%%%%  Fix various header and footer problems %%%
  54.253 +
  54.254 +% Draft mark on the right side of left pages (outside)
  54.255 +% this mark is also the only one visible on single sided.
  54.256 +\newcommand{\draftrmark}{**DRAFT**} 
  54.257 +% Draft mark on the left side of right pages (outside)
  54.258 +\newcommand{\draftlmark}{**DRAFT**} % 
  54.259 +
  54.260 +% Macros to make changing the Draft easier
  54.261 +\newcommand{\drmark}[1]{\renewcommand{\draftrmark}{#1}}
  54.262 +\newcommand{\dlmark}[1]{\renewcommand{\draftlmark}{#1}}
  54.263 +\newcommand{\dmark}[1]{\drmark{#1}\dlmark{#1}}
  54.264 +
  54.265 +% Format for draft of thesis.  Define our own PageStyle -
  54.266 +% Just like headings, but has foot lines with the date and warning
  54.267 +
  54.268 +\if@twoside         % If two-sided printing.
  54.269 +\def\ps@drafthead{
  54.270 +    \let\@mkboth\markboth
  54.271 +    \def\@oddfoot{\rm \today \hfil \sc \draftrmark}
  54.272 +    \def\@evenfoot{\sc \draftlmark \hfil \rm \today }
  54.273 +    \def\@evenhead{\rm \thepage\hfil \sl \leftmark}
  54.274 +    \def\@oddhead{\hbox{}\sl \rightmark \hfil \rm\thepage}
  54.275 +    \def\chaptermark##1{\markboth {\uppercase{\ifnum \c@secnumdepth >\m@ne
  54.276 +	\@chapapp\ \thechapter. \ \fi ##1}}{}}
  54.277 +    \def\sectionmark##1{\markright {\uppercase{\ifnum \c@secnumdepth >\z@
  54.278 +	\thesection. \ \fi ##1}}}
  54.279 +    \pulldownheader				% Bring header down from edge
  54.280 +    \pullupfooter				% Bring footer up
  54.281 +}
  54.282 +\else               % If one-sided printing.
  54.283 +\def\ps@drafthead{
  54.284 +    \let\@mkboth\markboth
  54.285 +    \def\@oddfoot{\rm \today \hfil \sc \draftrmark}
  54.286 +    \def\@oddhead{\hbox{}\sl \rightmark \hfil \rm\thepage}
  54.287 +    \def\chaptermark##1{\markright {\uppercase{\ifnum \c@secnumdepth >\m@ne
  54.288 +	\@chapapp\ \thechapter. \ \fi ##1}}}
  54.289 +    \pulldownheader				% Bring header down from edge
  54.290 +    \pullupfooter				% Bring footer up
  54.291 +}
  54.292 +\fi
  54.293 +
  54.294 +% I redefine these formats that were defined in report.sty
  54.295 +% Definition of 'headings' page style 
  54.296 +%  Note the use of ##1 for parameter of \def\chaptermark inside the
  54.297 +%  \def\ps@headings.
  54.298 +%
  54.299 +
  54.300 +\if@twoside					% If two-sided printing.
  54.301 +\def\ps@headings{\let\@mkboth\markboth
  54.302 +    \def\@oddfoot{}
  54.303 +    \def\@evenfoot{}		% No feet.
  54.304 +    \def\@evenhead{\rm \thepage\hfil \sl \leftmark}	% Left heading.
  54.305 +    \def\@oddhead{\hbox{}\sl \rightmark \hfil \rm\thepage}	% Right heading.
  54.306 +    \def\chaptermark##1{\markboth {\uppercase{\ifnum \c@secnumdepth >\m@ne
  54.307 +	\@chapapp\ \thechapter. \ \fi ##1}}{}}	
  54.308 +    \def\sectionmark##1{\markright {\uppercase{\ifnum \c@secnumdepth >\z@
  54.309 +	\thesection. \ \fi ##1}}}
  54.310 +    \pulldownheader				% Bring header down from edge
  54.311 +}
  54.312 +\else						% If one-sided printing.
  54.313 +\def\ps@headings{\let\@mkboth\markboth
  54.314 +    \def\@oddfoot{}
  54.315 +    \def\@evenfoot{}		%     No feet.
  54.316 +    \def\@oddhead{\hbox {}\sl \rightmark \hfil \rm\thepage}	% Heading.
  54.317 +    \def\chaptermark##1{\markright {\uppercase{\ifnum \c@secnumdepth >\m@ne
  54.318 +	\@chapapp\ \thechapter. \ \fi ##1}}}
  54.319 +    \pulldownheader				% Bring header down from edge
  54.320 +}
  54.321 +\fi
  54.322 +
  54.323 +% Redefinition of 'myheadings' page style.  
  54.324 +%
  54.325 +\def\ps@myheadings{\let\@mkboth\@gobbletwo
  54.326 +    \def\@oddfoot{}
  54.327 +    \def\@evenfoot{}
  54.328 +    \def\sectionmark##1{}
  54.329 +    \def\subsectionmark##1{}
  54.330 +    \def\@evenhead{\rm \thepage\hfil\sl\leftmark\hbox {}}	%
  54.331 +    \def\@oddhead{\hbox{}\sl\rightmark \hfil \rm\thepage}	%
  54.332 +    \pulldownheader				% Bring header down from edge
  54.333 +}						
  54.334 +
  54.335 +% Redefine '/chapter' to always start on an odd page.
  54.336 +% Should make no difference in singleside mode.
  54.337 +%
  54.338 +\if@leftblank
  54.339 +% Prints "THIS PAGE INTENTIONALLY LEFT BLANK" on blank pages.
  54.340 +\def\chapter{\clearpage\ifodd\c@page\else
  54.341 +   \hbox{}\par\vfill\centerline%
  54.342 +   {THIS PAGE INTENTIONALLY LEFT BLANK}%
  54.343 +   \vfill\newpage\fi
  54.344 +   \thispagestyle{plain}	% Page style of chapter page is 'plain'
  54.345 +   \global\@topnum\z@		% Prevents figures from going at top of page.
  54.346 +   \@afterindentfalse		% Suppresses indent in first paragraph.  Change
  54.347 +   \secdef\@chapter\@schapter}	% to \@afterindenttrue to have indent.
  54.348 +\else
  54.349 +\def\chapter{\cleardoublepage	% Starts new page.
  54.350 +   \thispagestyle{plain}	% Page style of chapter page is 'plain'
  54.351 +   \global\@topnum\z@		% Prevents figures from going at top of page.
  54.352 +   \@afterindentfalse		% Suppresses indent in first paragraph.  Change
  54.353 +   \secdef\@chapter\@schapter}	% to \@afterindenttrue to have indent.
  54.354 +\fi
  54.355 +% If using the report style, use - instead of . in the figure number.
  54.356 +\@ifundefined{thechapter}{}{\def\thefigure{\thechapter-\arabic{figure}}}
  54.357 +
  54.358 +
  54.359 +%%%%%%%%%  End of Style parameters %%%%
  54.360 +
  54.361 +% Here's Gildea's Boilerplate Stuff.
  54.362 +% Copyright (c) 1987 by Stephen Gildea
  54.363 +% Permission to copy all or part of this work is granted, provided
  54.364 +% that the copies are not made or distributed for resale, and that
  54.365 +% the copyright notice and this notice are retained.
  54.366 +
  54.367 +%% Define all the pieces that go on the title page and the abstract.
  54.368 +
  54.369 +% \title and \author already exist
  54.370 +
  54.371 +\def\prevdegrees#1{\gdef\@prevdegrees{#1}}
  54.372 +\def\@prevdegrees{}
  54.373 +
  54.374 +\def\department#1{\gdef\@department{#1}}
  54.375 +
  54.376 +% If you are getting two degrees, use \and between the names.
  54.377 +\def\degree#1{\setbox0\hbox{#1}	 %for side effect of setting \@degreeword
  54.378 +  \gdef\@degree{#1}}
  54.379 +
  54.380 +% \and is used inside the \degree argument to separate two degrees
  54.381 +\def\and{\gdef\@degreeword{degrees} \par and \par}
  54.382 +\def\@degreeword{degree}
  54.383 +
  54.384 +% The copyright notice stuff is a tremendous mess.
  54.385 +%
  54.386 +% \@copyrightnotice is used by \maketitle to actually put text on the
  54.387 +% page; it defaults to ``Copyright MIT 19xx.  All rights reserved.''
  54.388 +% \copyrightnoticetext takes an argument and defined \@copyrightnotice
  54.389 +% to that argument.  \copyrightnotice takes an argument, and calls
  54.390 +% \copyrightnoticetext with that argument, preceeded by a copyright
  54.391 +% symbol and followed by ``All rights reserved.'' and the standard
  54.392 +% permission notice.
  54.393 +% 
  54.394 +% If you use the 'vi' option, \copyrightnoticetext is used to set the
  54.395 +% copyright to ``(C) Your Name, Current Year in Roman Numerals.''
  54.396 +% followed by the permission notice.
  54.397 +
  54.398 +% If there is no \copyrightnotice command, it is asssumed that MIT
  54.399 +% holds the copyright.  This commands adds the copyright symbol to the
  54.400 +% beginning, and puts the standard permission notice below.
  54.401 +%% ``All rights reserved'' added.  Krishna Sethuraman (1990)
  54.402 +\def\copyrightnotice#1{\copyrightnoticetext{\copyright\ #1.  All rights
  54.403 +reserved.\par\permission}}
  54.404 +
  54.405 +% Occacionally you will need to exactly specify the text of the 
  54.406 +% copyright notice.  The \copyrightnoticetext command is then useful.
  54.407 +\long\def\copyrightnoticetext#1{\gdef\@copyrightnotice{#1}}
  54.408 +\def\@copyrightnotice{\copyright\ \Mit\ \@degreeyear.  All rights reserved.}
  54.409 +
  54.410 +%% `vi' documentclass option: Specifying this option automatically
  54.411 +%% copyrights the thesis to the author and gives MIT permission to copy and
  54.412 +%% distribute the document.  If you want, you can still specify
  54.413 +%% \copyrightnotice{stuff} to copyright to someone else, or
  54.414 +%% \copyrightnoticetext{stuff} to specify the exact text of the copyright
  54.415 +%% notice.
  54.416 +\ifodd\vithesis \copyrightnoticetext{\copyright\ \@author,
  54.417 +\uppercase\expandafter{\romannumeral\@degreeyear}.  All rights reserved.\par\permission}
  54.418 +%% or just
  54.419 +%%\@degreeyear}}
  54.420 +\typeout{Copyright given to author,
  54.421 +	permission to copy/distribute given to MIT.}
  54.422 +\else \typeout{Thesis document copyright MIT unless otherwise (manually) specified}
  54.423 +\fi
  54.424 +
  54.425 +\def\thesisdate#1{\gdef\@thesisdate{#1}}
  54.426 +
  54.427 +% typically just a month and year
  54.428 +\def\degreemonth#1{\gdef\@degreemonth{#1}}
  54.429 +\def\degreeyear#1{\gdef\@degreeyear{#1}}
  54.430 +
  54.431 +% Usage: \supervisor{name}{title}
  54.432 +%        \chairman{name}{title}
  54.433 +
  54.434 +% since there can be more than one supervisor,
  54.435 +% we build the appropriate boxes for the titlepage and
  54.436 +% the abstractpage as the user makes multiple calls
  54.437 +% to \supervisor
  54.438 +\newbox\@titlesupervisor 	\newbox\@abstractsupervisor
  54.439 +
  54.440 +\def\supervisor#1#2{\setbox\@titlesupervisor\vbox
  54.441 +  {\unvbox\@titlesupervisor \vskip 10pt% plus 1fil minus 1fil
  54.442 +  \def\baselinestretch{1}\large
  54.443 +  \signature{Certified by}{#1 \\ #2 \\ Thesis Supervisor}}
  54.444 +  \setbox\@abstractsupervisor\vbox{\unvbox\@abstractsupervisor
  54.445 +  \vskip\baselineskip \def\baselinestretch{1}\@normalsize 
  54.446 +  \par\noindent Thesis Supervisor: #1 \\ Title: #2}}
  54.447 +
  54.448 +% department chairman, not thesis committee chairman
  54.449 +\def\chairman#1#2{\gdef\@chairmanname{#1}\gdef\@chairmantitle{#2}}
  54.450 +
  54.451 +%% `upcase' documentclass option: \choosecase is defined either as a dummy or
  54.452 +%% a macro to change the (expanded) argument to uppercase.
  54.453 +\def\maketitle{\begin{titlepage}
  54.454 +\large
  54.455 +{\def\baselinestretch{1.2}\Large\bf \choosecase{\@title} \par}
  54.456 +by\par
  54.457 +{\Large  \choosecase{\@author}}
  54.458 +\par
  54.459 +\@prevdegrees
  54.460 +\par
  54.461 +\choosecase{Submitted to the} \choosecase{\@department} \\
  54.462 +\choosecase{in partial fulfillment of the requirements for the}
  54.463 +\choosecase{\@degreeword} 
  54.464 +\choosecase{of}
  54.465 +\par
  54.466 +\choosecase{\@degree}
  54.467 +\par
  54.468 +at the
  54.469 +\par\MIT\par
  54.470 +\@degreemonth\ \@degreeyear
  54.471 +\par
  54.472 +\@copyrightnotice
  54.473 +\par
  54.474 +\vskip 3\baselineskip
  54.475 +\signature{Author}{\@department \\ \@thesisdate}
  54.476 +\par
  54.477 +\vfill
  54.478 +\unvbox\@titlesupervisor
  54.479 +\par
  54.480 +\vfill
  54.481 +\signature{Accepted by}{\@chairmanname \\ \@chairmantitle}
  54.482 +\vfill
  54.483 +\end{titlepage}}
  54.484 +
  54.485 +% this environment should probably be called abstract,
  54.486 +% but we want people to also be able to get at the more
  54.487 +% basic abstract environment
  54.488 +\def\abstractpage{\cleardoublepage
  54.489 +\begin{center}{\large{\bf \@title} \\
  54.490 +by \\
  54.491 +\@author \\[\baselineskip]}
  54.492 +\par
  54.493 +\def\baselinestretch{1}\@normalsize
  54.494 +Submitted to the \@department \\
  54.495 +on \@thesisdate, in partial fulfillment of the \\
  54.496 +requirements for the \@degreeword\ of \\
  54.497 +\@degree
  54.498 +\end{center}
  54.499 +\par
  54.500 +\begin{abstract}}
  54.501 +
  54.502 +%% Changed from \unvbox to \unvcopy for use with multiple copies of abstract
  54.503 +%% page.
  54.504 +%% Krishna Sethuraman (1990)
  54.505 +\def\endabstractpage{\end{abstract}\noindent
  54.506 + \unvcopy\@abstractsupervisor \newpage}
  54.507 +
  54.508 +%% This counter is used to save the page number for the second copy of
  54.509 +%% the abstract.
  54.510 +\newcounter{savepage}
  54.511 +
  54.512 +% You can use the titlepage environment to do it all yourself if you
  54.513 +% don't want to use \maketitle.  If the titlepage environment, the
  54.514 +% paragraph skip is infinitely stretchable, so if you leave a blank line
  54.515 +% between lines that you want space between, the space will stretch so
  54.516 +% that the title page fills up the entire page.
  54.517 +\def\titlepage{\cleardoublepage\centering
  54.518 +  \thispagestyle{empty}
  54.519 +  \parindent 0pt \parskip 10pt plus 1fil minus 1fil
  54.520 +  \def\baselinestretch{1}\@normalsize\vbox to \vsize\bgroup\vbox to 9in\bgroup}
  54.521 +% The \kern0pt pushes any depth into the height.  Thanks to Richard Stone.
  54.522 +\def\endtitlepage{\par\kern 0pt\egroup\vss\egroup\newpage}
  54.523 +
  54.524 +\def\MIT{MASSACHUSETTS INSTITUTE OF TECHNOLOGY}
  54.525 +\def\Mit{Massachusetts Institute of Technology}
  54.526 +
  54.527 +\def\permission{\par\noindent{\centering
  54.528 +   The author hereby grants to MIT permission to reproduce and to
  54.529 +   distribute publicly paper and electronic copies of this thesis
  54.530 +   document in whole or in part in any medium now known or hereafter
  54.531 +   created.}\par}
  54.532 +
  54.533 +\def\signature#1#2{\par\noindent#1\dotfill\null\\*
  54.534 +  {\raggedleft #2\par}}
  54.535 +
  54.536 +\def\abstract{\subsection*{Abstract}\small\def\baselinestretch{1}\@normalsize}
  54.537 +\def\endabstract{\par}
  54.538 +

    55.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    55.2 +++ b/thesis/aux/mitthesis/sample.org	Thu Mar 27 17:57:01 2014 -0400
    55.3 @@ -0,0 +1,7 @@
    55.4 +#+TITLE: asdhfklasdfkljasdf
    55.5 +#+AUTHOR: asdhfkjasdhfkljdasf
    55.6 +
    55.7 +* Section one
    55.8 +asdfasdfasdf
    55.9 +* Another section
   55.10 +aqghowahaoshfwhowehorwer
   55.11 \ No newline at end of file

    56.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    56.2 +++ b/thesis/aux/mitthesis/sample.tex	Thu Mar 27 17:57:01 2014 -0400
    56.3 @@ -0,0 +1,40 @@
    56.4 +% Created 2014-03-20 Thu 23:12
    56.5 +\documentclass[11pt]{article}
    56.6 +\usepackage[utf8]{inputenc}
    56.7 +\usepackage[T1]{fontenc}
    56.8 +\usepackage{fixltx2e}
    56.9 +\usepackage{graphicx}
   56.10 +\usepackage{longtable}
   56.11 +\usepackage{float}
   56.12 +\usepackage{wrapfig}
   56.13 +\usepackage{rotating}
   56.14 +\usepackage[normalem]{ulem}
   56.15 +\usepackage{amsmath}
   56.16 +\usepackage{textcomp}
   56.17 +\usepackage{marvosym}
   56.18 +\usepackage{wasysym}
   56.19 +\usepackage{amssymb}
   56.20 +\usepackage{hyperref}
   56.21 +\tolerance=1000
   56.22 +\author{asdhfkjasdhfkljdasf}
   56.23 +\date{\today}
   56.24 +\title{asdhfklasdfkljasdf}
   56.25 +\hypersetup{
   56.26 +  pdfkeywords={},
   56.27 +  pdfsubject={},
   56.28 +  pdfcreator={Emacs 24.2.1 (Org mode 8.2.5h)}}
   56.29 +\begin{document}
   56.30 +
   56.31 +\maketitle
   56.32 +\tableofcontents
   56.33 +
   56.34 +
   56.35 +\section{Section one}
   56.36 +\label{sec-1}
   56.37 +asdfasdfasdf
   56.38 +
   56.39 +\section{Another section}
   56.40 +\label{sec-2}
   56.41 +aqghowahaoshfwhowehorwer
   56.42 +% Emacs 24.2.1 (Org mode 8.2.5h)
   56.43 +\end{document}
   56.44 \ No newline at end of file

    57.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    57.2 +++ b/thesis/aux/mitthesis/signature.tex	Thu Mar 27 17:57:01 2014 -0400
    57.3 @@ -0,0 +1,31 @@
    57.4 +% -*- Mode:TeX -*-
    57.5 +%
    57.6 +% Some departments (e.g. Chemistry) require an additional cover page
    57.7 +% with signatures of the thesis committee.  Please check with your
    57.8 +% thesis advisor or other appropriate person to determine if such a 
    57.9 +% page is required for your thesis.  
   57.10 +%
   57.11 +% If you choose not to use the "titlepage" environment, a \newpage
   57.12 +% commands, and several \vspace{\fill} commands may be necessary to
   57.13 +% achieve the required spacing.  The \signature command is defined in
   57.14 +% the "mitthesis" class
   57.15 +%
   57.16 +% The following sample appears courtesy of Ben Kaduk <kaduk@mit.edu> and
   57.17 +% was used in his June 2012 doctoral thesis in Chemistry. 
   57.18 +
   57.19 +\begin{titlepage}
   57.20 +\begin{large}
   57.21 +This doctoral thesis has been examined by a Committee of the Department
   57.22 +of Chemistry as follows:
   57.23 +
   57.24 +\signature{Professor Jianshu Cao}{Chairman, Thesis Committee \\
   57.25 +   Professor of Chemistry}
   57.26 +
   57.27 +\signature{Professor Troy Van Voorhis}{Thesis Supervisor \\
   57.28 +   Associate Professor of Chemistry}
   57.29 +
   57.30 +\signature{Professor Robert W. Field}{Member, Thesis Committee \\
   57.31 +   Haslam and Dewey Professor of Chemistry}
   57.32 +\end{large}
   57.33 +\end{titlepage}
   57.34 +

    58.1 Binary file thesis/aux/mitthesis/templates.zip has changed

    59.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    59.2 +++ b/thesis/comp.pl	Thu Mar 27 17:57:01 2014 -0400
    59.3 @@ -0,0 +1,19 @@
    59.4 +#!/bin/perl
    59.5 +
    59.6 +use List::Flatten;
    59.7 +
    59.8 +$target = shift(@ARGV);
    59.9 +
   59.10 +$frames = shift(@ARGV);
   59.11 +
   59.12 +@numbers = split(/,/, $frames);
   59.13 +@images = map {sprintf("$target/%07d.png", $_)} @numbers;
   59.14 +
   59.15 +
   59.16 +$output = $target.".png";
   59.17 +
   59.18 +@imagemagick_command = flat("montage", @images, "-geometry", "+2+2", $output);
   59.19 +
   59.20 +print "@imagemagick_command\n";
   59.21 +
   59.22 +system(@imagemagick_command);

    60.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    60.2 +++ b/thesis/cortex.bib	Thu Mar 27 17:57:01 2014 -0400
    60.3 @@ -0,0 +1,15 @@
    60.4 +@incollection {Tappert77,
    60.5 +AUTHOR = {Tappert, Fred D.},
    60.6 +TITLE = {The parabolic approximation method},
    60.7 +BOOKTITLE = {Wave propagation and underwater acoustics ({W}orkshop,
    60.8 +              {M}ystic, {C}onn., 1974)},
    60.9 +PAGES = {224--287. Lecture Notes in Phys., Vol. 70},
   60.10 +PUBLISHER = {Springer},
   60.11 +ADDRESS = {Berlin},
   60.12 +YEAR = {1977},
   60.13 +MRCLASS = {76.41 (86.41)},
   60.14 +ADDENDUM = {\why{This is a cool paper that really helped me out. It's
   60.15 +                  related to the thesis because they talk about
   60.16 +                  manifolds and other types of pure, unrefined
   60.17 +                  bullshit.}}
   60.18 +}

    61.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    61.2 +++ b/thesis/cortex.org	Thu Mar 27 17:57:01 2014 -0400
    61.3 @@ -0,0 +1,1154 @@
    61.4 +#+title: =CORTEX=
    61.5 +#+author: Robert McIntyre
    61.6 +#+email: rlm@mit.edu
    61.7 +#+description: Using embodied AI to facilitate Artificial Imagination.
    61.8 +#+keywords: AI, clojure, embodiment
    61.9 +#+LaTeX_CLASS_OPTIONS: [nofloat]
   61.10 +
   61.11 +* Empathy and Embodiment as problem solving strategies
   61.12 +  
   61.13 +  By the end of this thesis, you will have seen a novel approach to
   61.14 +  interpreting video using embodiment and empathy. You will have also
   61.15 +  seen one way to efficiently implement empathy for embodied
   61.16 +  creatures. Finally, you will become familiar with =CORTEX=, a system
   61.17 +  for designing and simulating creatures with rich senses, which you
   61.18 +  may choose to use in your own research.
   61.19 +  
   61.20 +  This is the core vision of my thesis: That one of the important ways
   61.21 +  in which we understand others is by imagining ourselves in their
   61.22 +  position and emphatically feeling experiences relative to our own
   61.23 +  bodies. By understanding events in terms of our own previous
   61.24 +  corporeal experience, we greatly constrain the possibilities of what
   61.25 +  would otherwise be an unwieldy exponential search. This extra
   61.26 +  constraint can be the difference between easily understanding what
   61.27 +  is happening in a video and being completely lost in a sea of
   61.28 +  incomprehensible color and movement.
   61.29 +
   61.30 +** Recognizing actions in video is extremely difficult
   61.31 +
   61.32 +   Consider for example the problem of determining what is happening
   61.33 +   in a video of which this is one frame:
   61.34 +
   61.35 +   #+caption: A cat drinking some water. Identifying this action is 
   61.36 +   #+caption: beyond the state of the art for computers.
   61.37 +   #+ATTR_LaTeX: :width 7cm
   61.38 +   [[./images/cat-drinking.jpg]]
   61.39 +   
   61.40 +   It is currently impossible for any computer program to reliably
   61.41 +   label such a video as ``drinking''. And rightly so -- it is a very
   61.42 +   hard problem! What features can you describe in terms of low level
   61.43 +   functions of pixels that can even begin to describe at a high level
   61.44 +   what is happening here?
   61.45 +  
   61.46 +   Or suppose that you are building a program that recognizes chairs.
   61.47 +   How could you ``see'' the chair in figure \ref{hidden-chair}?
   61.48 +   
   61.49 +   #+caption: The chair in this image is quite obvious to humans, but I 
   61.50 +   #+caption: doubt that any modern computer vision program can find it.
   61.51 +   #+name: hidden-chair
   61.52 +   #+ATTR_LaTeX: :width 10cm
   61.53 +   [[./images/fat-person-sitting-at-desk.jpg]]
   61.54 +   
   61.55 +   Finally, how is it that you can easily tell the difference between
   61.56 +   how the girls /muscles/ are working in figure \ref{girl}?
   61.57 +   
   61.58 +   #+caption: The mysterious ``common sense'' appears here as you are able 
   61.59 +   #+caption: to discern the difference in how the girl's arm muscles
   61.60 +   #+caption: are activated between the two images.
   61.61 +   #+name: girl
   61.62 +   #+ATTR_LaTeX: :width 7cm
   61.63 +   [[./images/wall-push.png]]
   61.64 +  
   61.65 +   Each of these examples tells us something about what might be going
   61.66 +   on in our minds as we easily solve these recognition problems.
   61.67 +   
   61.68 +   The hidden chairs show us that we are strongly triggered by cues
   61.69 +   relating to the position of human bodies, and that we can determine
   61.70 +   the overall physical configuration of a human body even if much of
   61.71 +   that body is occluded.
   61.72 +
   61.73 +   The picture of the girl pushing against the wall tells us that we
   61.74 +   have common sense knowledge about the kinetics of our own bodies.
   61.75 +   We know well how our muscles would have to work to maintain us in
   61.76 +   most positions, and we can easily project this self-knowledge to
   61.77 +   imagined positions triggered by images of the human body.
   61.78 +
   61.79 +** =EMPATH= neatly solves recognition problems  
   61.80 +   
   61.81 +   I propose a system that can express the types of recognition
   61.82 +   problems above in a form amenable to computation. It is split into
   61.83 +   four parts:
   61.84 +
   61.85 +   - Free/Guided Play :: The creature moves around and experiences the
   61.86 +        world through its unique perspective. Many otherwise
   61.87 +        complicated actions are easily described in the language of a
   61.88 +        full suite of body-centered, rich senses. For example,
   61.89 +        drinking is the feeling of water sliding down your throat, and
   61.90 +        cooling your insides. It's often accompanied by bringing your
   61.91 +        hand close to your face, or bringing your face close to water.
   61.92 +        Sitting down is the feeling of bending your knees, activating
   61.93 +        your quadriceps, then feeling a surface with your bottom and
   61.94 +        relaxing your legs. These body-centered action descriptions
   61.95 +        can be either learned or hard coded.
   61.96 +   - Posture Imitation :: When trying to interpret a video or image,
   61.97 +        the creature takes a model of itself and aligns it with
   61.98 +        whatever it sees. This alignment can even cross species, as
   61.99 +        when humans try to align themselves with things like ponies,
  61.100 +        dogs, or other humans with a different body type.
  61.101 +   - Empathy         :: The alignment triggers associations with
  61.102 +        sensory data from prior experiences. For example, the
  61.103 +        alignment itself easily maps to proprioceptive data. Any
  61.104 +        sounds or obvious skin contact in the video can to a lesser
  61.105 +        extent trigger previous experience. Segments of previous
  61.106 +        experiences are stitched together to form a coherent and
  61.107 +        complete sensory portrait of the scene.
  61.108 +   - Recognition      :: With the scene described in terms of first
  61.109 +        person sensory events, the creature can now run its
  61.110 +        action-identification programs on this synthesized sensory
  61.111 +        data, just as it would if it were actually experiencing the
  61.112 +        scene first-hand. If previous experience has been accurately
  61.113 +        retrieved, and if it is analogous enough to the scene, then
  61.114 +        the creature will correctly identify the action in the scene.
  61.115 +   
  61.116 +   For example, I think humans are able to label the cat video as
  61.117 +   ``drinking'' because they imagine /themselves/ as the cat, and
  61.118 +   imagine putting their face up against a stream of water and
  61.119 +   sticking out their tongue. In that imagined world, they can feel
  61.120 +   the cool water hitting their tongue, and feel the water entering
  61.121 +   their body, and are able to recognize that /feeling/ as drinking.
  61.122 +   So, the label of the action is not really in the pixels of the
  61.123 +   image, but is found clearly in a simulation inspired by those
  61.124 +   pixels. An imaginative system, having been trained on drinking and
  61.125 +   non-drinking examples and learning that the most important
  61.126 +   component of drinking is the feeling of water sliding down one's
  61.127 +   throat, would analyze a video of a cat drinking in the following
  61.128 +   manner:
  61.129 +   
  61.130 +   1. Create a physical model of the video by putting a ``fuzzy''
  61.131 +      model of its own body in place of the cat. Possibly also create
  61.132 +      a simulation of the stream of water.
  61.133 +
  61.134 +   2. Play out this simulated scene and generate imagined sensory
  61.135 +      experience. This will include relevant muscle contractions, a
  61.136 +      close up view of the stream from the cat's perspective, and most
  61.137 +      importantly, the imagined feeling of water entering the
  61.138 +      mouth. The imagined sensory experience can come from a
  61.139 +      simulation of the event, but can also be pattern-matched from
  61.140 +      previous, similar embodied experience.
  61.141 +
  61.142 +   3. The action is now easily identified as drinking by the sense of
  61.143 +      taste alone. The other senses (such as the tongue moving in and
  61.144 +      out) help to give plausibility to the simulated action. Note that
  61.145 +      the sense of vision, while critical in creating the simulation,
  61.146 +      is not critical for identifying the action from the simulation.
  61.147 +
  61.148 +   For the chair examples, the process is even easier:
  61.149 +
  61.150 +    1. Align a model of your body to the person in the image.
  61.151 +
  61.152 +    2. Generate proprioceptive sensory data from this alignment.
  61.153 +  
  61.154 +    3. Use the imagined proprioceptive data as a key to lookup related
  61.155 +       sensory experience associated with that particular proproceptive
  61.156 +       feeling.
  61.157 +
  61.158 +    4. Retrieve the feeling of your bottom resting on a surface, your
  61.159 +       knees bent, and your leg muscles relaxed.
  61.160 +
  61.161 +    5. This sensory information is consistent with the =sitting?=
  61.162 +       sensory predicate, so you (and the entity in the image) must be
  61.163 +       sitting.
  61.164 +
  61.165 +    6. There must be a chair-like object since you are sitting.
  61.166 +
  61.167 +   Empathy offers yet another alternative to the age-old AI
  61.168 +   representation question: ``What is a chair?'' --- A chair is the
  61.169 +   feeling of sitting.
  61.170 +
  61.171 +   My program, =EMPATH= uses this empathic problem solving technique
  61.172 +   to interpret the actions of a simple, worm-like creature. 
  61.173 +   
  61.174 +   #+caption: The worm performs many actions during free play such as 
  61.175 +   #+caption: curling, wiggling, and resting.
  61.176 +   #+name: worm-intro
  61.177 +   #+ATTR_LaTeX: :width 15cm
  61.178 +   [[./images/worm-intro-white.png]]
  61.179 +
  61.180 +   #+caption: =EMPATH= recognized and classified each of these poses by
  61.181 +   #+caption: inferring the complete sensory experience from 
  61.182 +   #+caption: proprioceptive data.
  61.183 +   #+name: worm-recognition-intro
  61.184 +   #+ATTR_LaTeX: :width 15cm
  61.185 +   [[./images/worm-poses.png]]
  61.186 +   
  61.187 +   One powerful advantage of empathic problem solving is that it
  61.188 +   factors the action recognition problem into two easier problems. To
  61.189 +   use empathy, you need an /aligner/, which takes the video and a
  61.190 +   model of your body, and aligns the model with the video. Then, you
  61.191 +   need a /recognizer/, which uses the aligned model to interpret the
  61.192 +   action. The power in this method lies in the fact that you describe
  61.193 +   all actions form a body-centered viewpoint. You are less tied to
  61.194 +   the particulars of any visual representation of the actions. If you
  61.195 +   teach the system what ``running'' is, and you have a good enough
  61.196 +   aligner, the system will from then on be able to recognize running
  61.197 +   from any point of view, even strange points of view like above or
  61.198 +   underneath the runner. This is in contrast to action recognition
  61.199 +   schemes that try to identify actions using a non-embodied approach.
  61.200 +   If these systems learn about running as viewed from the side, they
  61.201 +   will not automatically be able to recognize running from any other
  61.202 +   viewpoint.
  61.203 +
  61.204 +   Another powerful advantage is that using the language of multiple
  61.205 +   body-centered rich senses to describe body-centerd actions offers a
  61.206 +   massive boost in descriptive capability. Consider how difficult it
  61.207 +   would be to compose a set of HOG filters to describe the action of
  61.208 +   a simple worm-creature ``curling'' so that its head touches its
  61.209 +   tail, and then behold the simplicity of describing thus action in a
  61.210 +   language designed for the task (listing \ref{grand-circle-intro}):
  61.211 +
  61.212 +   #+caption: Body-centerd actions are best expressed in a body-centered 
  61.213 +   #+caption: language. This code detects when the worm has curled into a 
  61.214 +   #+caption: full circle. Imagine how you would replicate this functionality
  61.215 +   #+caption: using low-level pixel features such as HOG filters!
  61.216 +   #+name: grand-circle-intro
  61.217 +   #+attr_latex: [htpb]
  61.218 +#+begin_listing clojure
  61.219 +   #+begin_src clojure
  61.220 +(defn grand-circle?
  61.221 +  "Does the worm form a majestic circle (one end touching the other)?"
  61.222 +  [experiences]
  61.223 +  (and (curled? experiences)
  61.224 +       (let [worm-touch (:touch (peek experiences))
  61.225 +             tail-touch (worm-touch 0)
  61.226 +             head-touch (worm-touch 4)]
  61.227 +         (and (< 0.55 (contact worm-segment-bottom-tip tail-touch))
  61.228 +              (< 0.55 (contact worm-segment-top-tip    head-touch))))))
  61.229 +   #+end_src
  61.230 +   #+end_listing
  61.231 +
  61.232 +
  61.233 +**  =CORTEX= is a toolkit for building sensate creatures
  61.234 +
  61.235 +   I built =CORTEX= to be a general AI research platform for doing
  61.236 +   experiments involving multiple rich senses and a wide variety and
  61.237 +   number of creatures. I intend it to be useful as a library for many
  61.238 +   more projects than just this one. =CORTEX= was necessary to meet a
  61.239 +   need among AI researchers at CSAIL and beyond, which is that people
  61.240 +   often will invent neat ideas that are best expressed in the
  61.241 +   language of creatures and senses, but in order to explore those
  61.242 +   ideas they must first build a platform in which they can create
  61.243 +   simulated creatures with rich senses! There are many ideas that
  61.244 +   would be simple to execute (such as =EMPATH=), but attached to them
  61.245 +   is the multi-month effort to make a good creature simulator. Often,
  61.246 +   that initial investment of time proves to be too much, and the
  61.247 +   project must make do with a lesser environment.
  61.248 +
  61.249 +   =CORTEX= is well suited as an environment for embodied AI research
  61.250 +   for three reasons:
  61.251 +
  61.252 +   - You can create new creatures using Blender, a popular 3D modeling
  61.253 +     program. Each sense can be specified using special blender nodes
  61.254 +     with biologically inspired paramaters. You need not write any
  61.255 +     code to create a creature, and can use a wide library of
  61.256 +     pre-existing blender models as a base for your own creatures.
  61.257 +
  61.258 +   - =CORTEX= implements a wide variety of senses, including touch,
  61.259 +     proprioception, vision, hearing, and muscle tension. Complicated
  61.260 +     senses like touch, and vision involve multiple sensory elements
  61.261 +     embedded in a 2D surface. You have complete control over the
  61.262 +     distribution of these sensor elements through the use of simple
  61.263 +     png image files. In particular, =CORTEX= implements more
  61.264 +     comprehensive hearing than any other creature simulation system
  61.265 +     available. 
  61.266 +
  61.267 +   - =CORTEX= supports any number of creatures and any number of
  61.268 +     senses. Time in =CORTEX= dialates so that the simulated creatures
  61.269 +     always precieve a perfectly smooth flow of time, regardless of
  61.270 +     the actual computational load.
  61.271 +
  61.272 +   =CORTEX= is built on top of =jMonkeyEngine3=, which is a video game
  61.273 +   engine designed to create cross-platform 3D desktop games. =CORTEX=
  61.274 +   is mainly written in clojure, a dialect of =LISP= that runs on the
  61.275 +   java virtual machine (JVM). The API for creating and simulating
  61.276 +   creatures and senses is entirely expressed in clojure, though many
  61.277 +   senses are implemented at the layer of jMonkeyEngine or below. For
  61.278 +   example, for the sense of hearing I use a layer of clojure code on
  61.279 +   top of a layer of java JNI bindings that drive a layer of =C++=
  61.280 +   code which implements a modified version of =OpenAL= to support
  61.281 +   multiple listeners. =CORTEX= is the only simulation environment
  61.282 +   that I know of that can support multiple entities that can each
  61.283 +   hear the world from their own perspective. Other senses also
  61.284 +   require a small layer of Java code. =CORTEX= also uses =bullet=, a
  61.285 +   physics simulator written in =C=.
  61.286 +
  61.287 +   #+caption: Here is the worm from above modeled in Blender, a free 
  61.288 +   #+caption: 3D-modeling program. Senses and joints are described
  61.289 +   #+caption: using special nodes in Blender.
  61.290 +   #+name: worm-recognition-intro
  61.291 +   #+ATTR_LaTeX: :width 12cm
  61.292 +   [[./images/blender-worm.png]]
  61.293 +
  61.294 +   Here are some thing I anticipate that =CORTEX= might be used for:
  61.295 +
  61.296 +   - exploring new ideas about sensory integration
  61.297 +   - distributed communication among swarm creatures
  61.298 +   - self-learning using free exploration, 
  61.299 +   - evolutionary algorithms involving creature construction
  61.300 +   - exploration of exoitic senses and effectors that are not possible
  61.301 +     in the real world (such as telekenisis or a semantic sense)
  61.302 +   - imagination using subworlds
  61.303 +
  61.304 +   During one test with =CORTEX=, I created 3,000 creatures each with
  61.305 +   their own independent senses and ran them all at only 1/80 real
  61.306 +   time. In another test, I created a detailed model of my own hand,
  61.307 +   equipped with a realistic distribution of touch (more sensitive at
  61.308 +   the fingertips), as well as eyes and ears, and it ran at around 1/4
  61.309 +   real time.
  61.310 +
  61.311 +#+BEGIN_LaTeX
  61.312 +   \begin{sidewaysfigure}
  61.313 +   \includegraphics[width=9.5in]{images/full-hand.png}
  61.314 +   \caption{
  61.315 +   I modeled my own right hand in Blender and rigged it with all the
  61.316 +   senses that {\tt CORTEX} supports. My simulated hand has a
  61.317 +   biologically inspired distribution of touch sensors. The senses are
  61.318 +   displayed on the right, and the simulation is displayed on the
  61.319 +   left. Notice that my hand is curling its fingers, that it can see
  61.320 +   its own finger from the eye in its palm, and that it can feel its
  61.321 +   own thumb touching its palm.}
  61.322 +   \end{sidewaysfigure}
  61.323 +#+END_LaTeX
  61.324 +
  61.325 +** Contributions
  61.326 +
  61.327 +   - I built =CORTEX=, a comprehensive platform for embodied AI
  61.328 +     experiments. =CORTEX= supports many features lacking in other
  61.329 +     systems, such proper simulation of hearing. It is easy to create
  61.330 +     new =CORTEX= creatures using Blender, a free 3D modeling program.
  61.331 +
  61.332 +   - I built =EMPATH=, which uses =CORTEX= to identify the actions of
  61.333 +     a worm-like creature using a computational model of empathy.
  61.334 +   
  61.335 +* Building =CORTEX=
  61.336 +
  61.337 +** To explore embodiment, we need a world, body, and senses
  61.338 +
  61.339 +** Because of Time, simulation is perferable to reality
  61.340 +
  61.341 +** Video game engines are a great starting point
  61.342 +
  61.343 +** Bodies are composed of segments connected by joints
  61.344 +
  61.345 +** Eyes reuse standard video game components
  61.346 +
  61.347 +** Hearing is hard; =CORTEX= does it right
  61.348 +
  61.349 +** Touch uses hundreds of hair-like elements
  61.350 +
  61.351 +** Proprioception is the sense that makes everything ``real''
  61.352 +
  61.353 +** Muscles are both effectors and sensors
  61.354 +
  61.355 +** =CORTEX= brings complex creatures to life!
  61.356 +
  61.357 +** =CORTEX= enables many possiblities for further research
  61.358 +
  61.359 +* Empathy in a simulated worm
  61.360 +
  61.361 +  Here I develop a computational model of empathy, using =CORTEX= as a
  61.362 +  base. Empathy in this context is the ability to observe another
  61.363 +  creature and infer what sorts of sensations that creature is
  61.364 +  feeling. My empathy algorithm involves multiple phases. First is
  61.365 +  free-play, where the creature moves around and gains sensory
  61.366 +  experience. From this experience I construct a representation of the
  61.367 +  creature's sensory state space, which I call \Phi-space. Using
  61.368 +  \Phi-space, I construct an efficient function which takes the
  61.369 +  limited data that comes from observing another creature and enriches
  61.370 +  it full compliment of imagined sensory data. I can then use the
  61.371 +  imagined sensory data to recognize what the observed creature is
  61.372 +  doing and feeling, using straightforward embodied action predicates.
  61.373 +  This is all demonstrated with using a simple worm-like creature, and
  61.374 +  recognizing worm-actions based on limited data.
  61.375 +
  61.376 +  #+caption: Here is the worm with which we will be working. 
  61.377 +  #+caption: It is composed of 5 segments. Each segment has a 
  61.378 +  #+caption: pair of extensor and flexor muscles. Each of the 
  61.379 +  #+caption: worm's four joints is a hinge joint which allows 
  61.380 +  #+caption: about 30 degrees of rotation to either side. Each segment
  61.381 +  #+caption: of the worm is touch-capable and has a uniform 
  61.382 +  #+caption: distribution of touch sensors on each of its faces.
  61.383 +  #+caption: Each joint has a proprioceptive sense to detect 
  61.384 +  #+caption: relative positions. The worm segments are all the 
  61.385 +  #+caption: same except for the first one, which has a much
  61.386 +  #+caption: higher weight than the others to allow for easy 
  61.387 +  #+caption: manual motor control.
  61.388 +  #+name: basic-worm-view
  61.389 +  #+ATTR_LaTeX: :width 10cm
  61.390 +  [[./images/basic-worm-view.png]]
  61.391 +
  61.392 +  #+caption: Program for reading a worm from a blender file and 
  61.393 +  #+caption: outfitting it with the senses of proprioception, 
  61.394 +  #+caption: touch, and the ability to move, as specified in the 
  61.395 +  #+caption: blender file.
  61.396 +  #+name: get-worm
  61.397 +  #+begin_listing clojure
  61.398 +  #+begin_src clojure
  61.399 +(defn worm []
  61.400 +  (let [model (load-blender-model "Models/worm/worm.blend")]
  61.401 +    {:body (doto model (body!))
  61.402 +     :touch (touch! model)
  61.403 +     :proprioception (proprioception! model)
  61.404 +     :muscles (movement! model)}))
  61.405 +  #+end_src
  61.406 +  #+end_listing
  61.407 +
  61.408 +** Embodiment factors action recognition into managable parts
  61.409 +
  61.410 +   Using empathy, I divide the problem of action recognition into a
  61.411 +   recognition process expressed in the language of a full compliment
  61.412 +   of senses, and an imaganitive process that generates full sensory
  61.413 +   data from partial sensory data. Splitting the action recognition
  61.414 +   problem in this manner greatly reduces the total amount of work to
  61.415 +   recognize actions: The imaganitive process is mostly just matching
  61.416 +   previous experience, and the recognition process gets to use all
  61.417 +   the senses to directly describe any action.
  61.418 +
  61.419 +** Action recognition is easy with a full gamut of senses
  61.420 +
  61.421 +   Embodied representations using multiple senses such as touch,
  61.422 +   proprioception, and muscle tension turns out be be exceedingly
  61.423 +   efficient at describing body-centered actions. It is the ``right
  61.424 +   language for the job''. For example, it takes only around 5 lines
  61.425 +   of LISP code to describe the action of ``curling'' using embodied
  61.426 +   primitives. It takes about 10 lines to describe the seemingly
  61.427 +   complicated action of wiggling.
  61.428 +
  61.429 +   The following action predicates each take a stream of sensory
  61.430 +   experience, observe however much of it they desire, and decide
  61.431 +   whether the worm is doing the action they describe. =curled?=
  61.432 +   relies on proprioception, =resting?= relies on touch, =wiggling?=
  61.433 +   relies on a fourier analysis of muscle contraction, and
  61.434 +   =grand-circle?= relies on touch and reuses =curled?= as a gaurd.
  61.435 +   
  61.436 +   #+caption: Program for detecting whether the worm is curled. This is the 
  61.437 +   #+caption: simplest action predicate, because it only uses the last frame 
  61.438 +   #+caption: of sensory experience, and only uses proprioceptive data. Even 
  61.439 +   #+caption: this simple predicate, however, is automatically frame 
  61.440 +   #+caption: independent and ignores vermopomorphic differences such as 
  61.441 +   #+caption: worm textures and colors.
  61.442 +   #+name: curled
  61.443 +   #+attr_latex: [htpb]
  61.444 +#+begin_listing clojure
  61.445 +   #+begin_src clojure
  61.446 +(defn curled?
  61.447 +  "Is the worm curled up?"
  61.448 +  [experiences]
  61.449 +  (every?
  61.450 +   (fn [[_ _ bend]]
  61.451 +     (> (Math/sin bend) 0.64))
  61.452 +   (:proprioception (peek experiences))))
  61.453 +   #+end_src
  61.454 +   #+end_listing
  61.455 +
  61.456 +   #+caption: Program for summarizing the touch information in a patch 
  61.457 +   #+caption: of skin.
  61.458 +   #+name: touch-summary
  61.459 +   #+attr_latex: [htpb]
  61.460 +
  61.461 +#+begin_listing clojure
  61.462 +   #+begin_src clojure
  61.463 +(defn contact
  61.464 +  "Determine how much contact a particular worm segment has with
  61.465 +   other objects. Returns a value between 0 and 1, where 1 is full
  61.466 +   contact and 0 is no contact."
  61.467 +  [touch-region [coords contact :as touch]]
  61.468 +  (-> (zipmap coords contact)
  61.469 +      (select-keys touch-region)
  61.470 +      (vals)
  61.471 +      (#(map first %))
  61.472 +      (average)
  61.473 +      (* 10)
  61.474 +      (- 1)
  61.475 +      (Math/abs)))
  61.476 +   #+end_src
  61.477 +   #+end_listing
  61.478 +
  61.479 +
  61.480 +   #+caption: Program for detecting whether the worm is at rest. This program
  61.481 +   #+caption: uses a summary of the tactile information from the underbelly 
  61.482 +   #+caption: of the worm, and is only true if every segment is touching the 
  61.483 +   #+caption: floor. Note that this function contains no references to 
  61.484 +   #+caption: proprioction at all.
  61.485 +   #+name: resting
  61.486 +   #+attr_latex: [htpb]
  61.487 +#+begin_listing clojure
  61.488 +   #+begin_src clojure
  61.489 +(def worm-segment-bottom (rect-region [8 15] [14 22]))
  61.490 +
  61.491 +(defn resting?
  61.492 +  "Is the worm resting on the ground?"
  61.493 +  [experiences]
  61.494 +  (every?
  61.495 +   (fn [touch-data]
  61.496 +     (< 0.9 (contact worm-segment-bottom touch-data)))
  61.497 +   (:touch (peek experiences))))
  61.498 +   #+end_src
  61.499 +   #+end_listing
  61.500 +
  61.501 +   #+caption: Program for detecting whether the worm is curled up into a 
  61.502 +   #+caption: full circle. Here the embodied approach begins to shine, as
  61.503 +   #+caption: I am able to both use a previous action predicate (=curled?=)
  61.504 +   #+caption: as well as the direct tactile experience of the head and tail.
  61.505 +   #+name: grand-circle
  61.506 +   #+attr_latex: [htpb]
  61.507 +#+begin_listing clojure
  61.508 +   #+begin_src clojure
  61.509 +(def worm-segment-bottom-tip (rect-region [15 15] [22 22]))
  61.510 +
  61.511 +(def worm-segment-top-tip (rect-region [0 15] [7 22]))
  61.512 +
  61.513 +(defn grand-circle?
  61.514 +  "Does the worm form a majestic circle (one end touching the other)?"
  61.515 +  [experiences]
  61.516 +  (and (curled? experiences)
  61.517 +       (let [worm-touch (:touch (peek experiences))
  61.518 +             tail-touch (worm-touch 0)
  61.519 +             head-touch (worm-touch 4)]
  61.520 +         (and (< 0.55 (contact worm-segment-bottom-tip tail-touch))
  61.521 +              (< 0.55 (contact worm-segment-top-tip    head-touch))))))
  61.522 +   #+end_src
  61.523 +   #+end_listing
  61.524 +
  61.525 +
  61.526 +   #+caption: Program for detecting whether the worm has been wiggling for 
  61.527 +   #+caption: the last few frames. It uses a fourier analysis of the muscle 
  61.528 +   #+caption: contractions of the worm's tail to determine wiggling. This is 
  61.529 +   #+caption: signigicant because there is no particular frame that clearly 
  61.530 +   #+caption: indicates that the worm is wiggling --- only when multiple frames 
  61.531 +   #+caption: are analyzed together is the wiggling revealed. Defining 
  61.532 +   #+caption: wiggling this way also gives the worm an opportunity to learn 
  61.533 +   #+caption: and recognize ``frustrated wiggling'', where the worm tries to 
  61.534 +   #+caption: wiggle but can't. Frustrated wiggling is very visually different 
  61.535 +   #+caption: from actual wiggling, but this definition gives it to us for free.
  61.536 +   #+name: wiggling
  61.537 +   #+attr_latex: [htpb]
  61.538 +#+begin_listing clojure
  61.539 +   #+begin_src clojure
  61.540 +(defn fft [nums]
  61.541 +  (map
  61.542 +   #(.getReal %)
  61.543 +   (.transform
  61.544 +    (FastFourierTransformer. DftNormalization/STANDARD)
  61.545 +    (double-array nums) TransformType/FORWARD)))
  61.546 +
  61.547 +(def indexed (partial map-indexed vector))
  61.548 +
  61.549 +(defn max-indexed [s]
  61.550 +  (first (sort-by (comp - second) (indexed s))))
  61.551 +
  61.552 +(defn wiggling?
  61.553 +  "Is the worm wiggling?"
  61.554 +  [experiences]
  61.555 +  (let [analysis-interval 0x40]
  61.556 +    (when (> (count experiences) analysis-interval)
  61.557 +      (let [a-flex 3
  61.558 +            a-ex   2
  61.559 +            muscle-activity
  61.560 +            (map :muscle (vector:last-n experiences analysis-interval))
  61.561 +            base-activity
  61.562 +            (map #(- (% a-flex) (% a-ex)) muscle-activity)]
  61.563 +        (= 2
  61.564 +           (first
  61.565 +            (max-indexed
  61.566 +             (map #(Math/abs %)
  61.567 +                  (take 20 (fft base-activity))))))))))
  61.568 +   #+end_src
  61.569 +   #+end_listing
  61.570 +
  61.571 +   With these action predicates, I can now recognize the actions of
  61.572 +   the worm while it is moving under my control and I have access to
  61.573 +   all the worm's senses.
  61.574 +
  61.575 +   #+caption: Use the action predicates defined earlier to report on 
  61.576 +   #+caption: what the worm is doing while in simulation.
  61.577 +   #+name: report-worm-activity
  61.578 +   #+attr_latex: [htpb]
  61.579 +#+begin_listing clojure
  61.580 +   #+begin_src clojure
  61.581 +(defn debug-experience
  61.582 +  [experiences text]
  61.583 +  (cond
  61.584 +   (grand-circle? experiences) (.setText text "Grand Circle")
  61.585 +   (curled? experiences)       (.setText text "Curled")
  61.586 +   (wiggling? experiences)     (.setText text "Wiggling")
  61.587 +   (resting? experiences)      (.setText text "Resting")))
  61.588 +   #+end_src
  61.589 +   #+end_listing
  61.590 +
  61.591 +   #+caption: Using =debug-experience=, the body-centered predicates
  61.592 +   #+caption: work together to classify the behaviour of the worm. 
  61.593 +   #+caption: the predicates are operating with access to the worm's
  61.594 +   #+caption: full sensory data.
  61.595 +   #+name: basic-worm-view
  61.596 +   #+ATTR_LaTeX: :width 10cm
  61.597 +   [[./images/worm-identify-init.png]]
  61.598 +
  61.599 +   These action predicates satisfy the recognition requirement of an
  61.600 +   empathic recognition system. There is power in the simplicity of
  61.601 +   the action predicates. They describe their actions without getting
  61.602 +   confused in visual details of the worm. Each one is frame
  61.603 +   independent, but more than that, they are each indepent of
  61.604 +   irrelevant visual details of the worm and the environment. They
  61.605 +   will work regardless of whether the worm is a different color or
  61.606 +   hevaily textured, or if the environment has strange lighting.
  61.607 +
  61.608 +   The trick now is to make the action predicates work even when the
  61.609 +   sensory data on which they depend is absent. If I can do that, then
  61.610 +   I will have gained much,
  61.611 +
  61.612 +** \Phi-space describes the worm's experiences
  61.613 +   
  61.614 +   As a first step towards building empathy, I need to gather all of
  61.615 +   the worm's experiences during free play. I use a simple vector to
  61.616 +   store all the experiences. 
  61.617 +
  61.618 +   Each element of the experience vector exists in the vast space of
  61.619 +   all possible worm-experiences. Most of this vast space is actually
  61.620 +   unreachable due to physical constraints of the worm's body. For
  61.621 +   example, the worm's segments are connected by hinge joints that put
  61.622 +   a practical limit on the worm's range of motions without limiting
  61.623 +   its degrees of freedom. Some groupings of senses are impossible;
  61.624 +   the worm can not be bent into a circle so that its ends are
  61.625 +   touching and at the same time not also experience the sensation of
  61.626 +   touching itself.
  61.627 +
  61.628 +   As the worm moves around during free play and its experience vector
  61.629 +   grows larger, the vector begins to define a subspace which is all
  61.630 +   the sensations the worm can practicaly experience during normal
  61.631 +   operation. I call this subspace \Phi-space, short for
  61.632 +   physical-space. The experience vector defines a path through
  61.633 +   \Phi-space. This path has interesting properties that all derive
  61.634 +   from physical embodiment. The proprioceptive components are
  61.635 +   completely smooth, because in order for the worm to move from one
  61.636 +   position to another, it must pass through the intermediate
  61.637 +   positions. The path invariably forms loops as actions are repeated.
  61.638 +   Finally and most importantly, proprioception actually gives very
  61.639 +   strong inference about the other senses. For example, when the worm
  61.640 +   is flat, you can infer that it is touching the ground and that its
  61.641 +   muscles are not active, because if the muscles were active, the
  61.642 +   worm would be moving and would not be perfectly flat. In order to
  61.643 +   stay flat, the worm has to be touching the ground, or it would
  61.644 +   again be moving out of the flat position due to gravity. If the
  61.645 +   worm is positioned in such a way that it interacts with itself,
  61.646 +   then it is very likely to be feeling the same tactile feelings as
  61.647 +   the last time it was in that position, because it has the same body
  61.648 +   as then. If you observe multiple frames of proprioceptive data,
  61.649 +   then you can become increasingly confident about the exact
  61.650 +   activations of the worm's muscles, because it generally takes a
  61.651 +   unique combination of muscle contractions to transform the worm's
  61.652 +   body along a specific path through \Phi-space.
  61.653 +
  61.654 +   There is a simple way of taking \Phi-space and the total ordering
  61.655 +   provided by an experience vector and reliably infering the rest of
  61.656 +   the senses.
  61.657 +
  61.658 +** Empathy is the process of tracing though \Phi-space 
  61.659 +
  61.660 +   Here is the core of a basic empathy algorithm, starting with an
  61.661 +   experience vector:
  61.662 +
  61.663 +   First, group the experiences into tiered proprioceptive bins. I use
  61.664 +   powers of 10 and 3 bins, and the smallest bin has an approximate
  61.665 +   size of 0.001 radians in all proprioceptive dimensions.
  61.666 +   
  61.667 +   Then, given a sequence of proprioceptive input, generate a set of
  61.668 +   matching experience records for each input, using the tiered
  61.669 +   proprioceptive bins. 
  61.670 +
  61.671 +   Finally, to infer sensory data, select the longest consective chain
  61.672 +   of experiences. Conecutive experience means that the experiences
  61.673 +   appear next to each other in the experience vector.
  61.674 +
  61.675 +   This algorithm has three advantages: 
  61.676 +
  61.677 +   1. It's simple
  61.678 +
  61.679 +   3. It's very fast -- retrieving possible interpretations takes
  61.680 +      constant time. Tracing through chains of interpretations takes
  61.681 +      time proportional to the average number of experiences in a
  61.682 +      proprioceptive bin. Redundant experiences in \Phi-space can be
  61.683 +      merged to save computation.
  61.684 +
  61.685 +   2. It protects from wrong interpretations of transient ambiguous
  61.686 +      proprioceptive data. For example, if the worm is flat for just
  61.687 +      an instant, this flattness will not be interpreted as implying
  61.688 +      that the worm has its muscles relaxed, since the flattness is
  61.689 +      part of a longer chain which includes a distinct pattern of
  61.690 +      muscle activation. Markov chains or other memoryless statistical
  61.691 +      models that operate on individual frames may very well make this
  61.692 +      mistake.
  61.693 +
  61.694 +   #+caption: Program to convert an experience vector into a 
  61.695 +   #+caption: proprioceptively binned lookup function.
  61.696 +   #+name: bin
  61.697 +   #+attr_latex: [htpb]
  61.698 +#+begin_listing clojure
  61.699 +   #+begin_src clojure
  61.700 +(defn bin [digits]
  61.701 +  (fn [angles]
  61.702 +    (->> angles
  61.703 +         (flatten)
  61.704 +         (map (juxt #(Math/sin %) #(Math/cos %)))
  61.705 +         (flatten)
  61.706 +         (mapv #(Math/round (* % (Math/pow 10 (dec digits))))))))
  61.707 +
  61.708 +(defn gen-phi-scan 
  61.709 +  "Nearest-neighbors with binning. Only returns a result if
  61.710 +   the propriceptive data is within 10% of a previously recorded
  61.711 +   result in all dimensions."
  61.712 +  [phi-space]
  61.713 +  (let [bin-keys (map bin [3 2 1])
  61.714 +        bin-maps
  61.715 +        (map (fn [bin-key]
  61.716 +               (group-by
  61.717 +                (comp bin-key :proprioception phi-space)
  61.718 +                (range (count phi-space)))) bin-keys)
  61.719 +        lookups (map (fn [bin-key bin-map]
  61.720 +                       (fn [proprio] (bin-map (bin-key proprio))))
  61.721 +                     bin-keys bin-maps)]
  61.722 +    (fn lookup [proprio-data]
  61.723 +      (set (some #(% proprio-data) lookups)))))
  61.724 +   #+end_src
  61.725 +   #+end_listing
  61.726 +
  61.727 +   #+caption: =longest-thread= finds the longest path of consecutive 
  61.728 +   #+caption: experiences to explain proprioceptive worm data.
  61.729 +   #+name: phi-space-history-scan
  61.730 +   #+ATTR_LaTeX: :width 10cm
  61.731 +   [[./images/aurellem-gray.png]]
  61.732 +
  61.733 +   =longest-thread= infers sensory data by stitching together pieces
  61.734 +   from previous experience. It prefers longer chains of previous
  61.735 +   experience to shorter ones. For example, during training the worm
  61.736 +   might rest on the ground for one second before it performs its
  61.737 +   excercises. If during recognition the worm rests on the ground for
  61.738 +   five seconds, =longest-thread= will accomodate this five second
  61.739 +   rest period by looping the one second rest chain five times.
  61.740 +
  61.741 +   =longest-thread= takes time proportinal to the average number of
  61.742 +   entries in a proprioceptive bin, because for each element in the
  61.743 +   starting bin it performes a series of set lookups in the preceeding
  61.744 +   bins. If the total history is limited, then this is only a constant
  61.745 +   multiple times the number of entries in the starting bin. This
  61.746 +   analysis also applies even if the action requires multiple longest
  61.747 +   chains -- it's still the average number of entries in a
  61.748 +   proprioceptive bin times the desired chain length. Because
  61.749 +   =longest-thread= is so efficient and simple, I can interpret
  61.750 +   worm-actions in real time.
  61.751 +
  61.752 +   #+caption: Program to calculate empathy by tracing though \Phi-space
  61.753 +   #+caption: and finding the longest (ie. most coherent) interpretation
  61.754 +   #+caption: of the data.
  61.755 +   #+name: longest-thread
  61.756 +   #+attr_latex: [htpb]
  61.757 +#+begin_listing clojure
  61.758 +   #+begin_src clojure
  61.759 +(defn longest-thread
  61.760 +  "Find the longest thread from phi-index-sets. The index sets should
  61.761 +   be ordered from most recent to least recent."
  61.762 +  [phi-index-sets]
  61.763 +  (loop [result '()
  61.764 +         [thread-bases & remaining :as phi-index-sets] phi-index-sets]
  61.765 +    (if (empty? phi-index-sets)
  61.766 +      (vec result)
  61.767 +      (let [threads
  61.768 +            (for [thread-base thread-bases]
  61.769 +              (loop [thread (list thread-base)
  61.770 +                     remaining remaining]
  61.771 +                (let [next-index (dec (first thread))]
  61.772 +                  (cond (empty? remaining) thread
  61.773 +                        (contains? (first remaining) next-index)
  61.774 +                        (recur
  61.775 +                         (cons next-index thread) (rest remaining))
  61.776 +                        :else thread))))
  61.777 +            longest-thread
  61.778 +            (reduce (fn [thread-a thread-b]
  61.779 +                      (if (> (count thread-a) (count thread-b))
  61.780 +                        thread-a thread-b))
  61.781 +                    '(nil)
  61.782 +                    threads)]
  61.783 +        (recur (concat longest-thread result)
  61.784 +               (drop (count longest-thread) phi-index-sets))))))
  61.785 +   #+end_src
  61.786 +   #+end_listing
  61.787 +
  61.788 +   There is one final piece, which is to replace missing sensory data
  61.789 +   with a best-guess estimate. While I could fill in missing data by
  61.790 +   using a gradient over the closest known sensory data points,
  61.791 +   averages can be misleading. It is certainly possible to create an
  61.792 +   impossible sensory state by averaging two possible sensory states.
  61.793 +   Therefore, I simply replicate the most recent sensory experience to
  61.794 +   fill in the gaps.
  61.795 +
  61.796 +   #+caption: Fill in blanks in sensory experience by replicating the most 
  61.797 +   #+caption: recent experience.
  61.798 +   #+name: infer-nils
  61.799 +   #+attr_latex: [htpb]
  61.800 +#+begin_listing clojure
  61.801 +   #+begin_src clojure
  61.802 +(defn infer-nils
  61.803 +  "Replace nils with the next available non-nil element in the
  61.804 +   sequence, or barring that, 0."
  61.805 +  [s]
  61.806 +  (loop [i (dec (count s))
  61.807 +         v (transient s)]
  61.808 +    (if (zero? i) (persistent! v)
  61.809 +        (if-let [cur (v i)]
  61.810 +          (if (get v (dec i) 0)
  61.811 +            (recur (dec i) v)
  61.812 +            (recur (dec i) (assoc! v (dec i) cur)))
  61.813 +          (recur i (assoc! v i 0))))))
  61.814 +   #+end_src
  61.815 +   #+end_listing
  61.816 +  
  61.817 +** Efficient action recognition with =EMPATH=
  61.818 +   
  61.819 +   To use =EMPATH= with the worm, I first need to gather a set of
  61.820 +   experiences from the worm that includes the actions I want to
  61.821 +   recognize. The =generate-phi-space= program (listing
  61.822 +   \ref{generate-phi-space} runs the worm through a series of
  61.823 +   exercices and gatheres those experiences into a vector. The
  61.824 +   =do-all-the-things= program is a routine expressed in a simple
  61.825 +   muscle contraction script language for automated worm control. It
  61.826 +   causes the worm to rest, curl, and wiggle over about 700 frames
  61.827 +   (approx. 11 seconds).
  61.828 +
  61.829 +   #+caption: Program to gather the worm's experiences into a vector for 
  61.830 +   #+caption: further processing. The =motor-control-program= line uses
  61.831 +   #+caption: a motor control script that causes the worm to execute a series
  61.832 +   #+caption: of ``exercices'' that include all the action predicates.
  61.833 +   #+name: generate-phi-space
  61.834 +   #+attr_latex: [htpb]
  61.835 +#+begin_listing clojure 
  61.836 +   #+begin_src clojure
  61.837 +(def do-all-the-things 
  61.838 +  (concat
  61.839 +   curl-script
  61.840 +   [[300 :d-ex 40]
  61.841 +    [320 :d-ex 0]]
  61.842 +   (shift-script 280 (take 16 wiggle-script))))
  61.843 +
  61.844 +(defn generate-phi-space []
  61.845 +  (let [experiences (atom [])]
  61.846 +    (run-world
  61.847 +     (apply-map 
  61.848 +      worm-world
  61.849 +      (merge
  61.850 +       (worm-world-defaults)
  61.851 +       {:end-frame 700
  61.852 +        :motor-control
  61.853 +        (motor-control-program worm-muscle-labels do-all-the-things)
  61.854 +        :experiences experiences})))
  61.855 +    @experiences))
  61.856 +   #+end_src
  61.857 +   #+end_listing
  61.858 +
  61.859 +   #+caption: Use longest thread and a phi-space generated from a short
  61.860 +   #+caption: exercise routine to interpret actions during free play.
  61.861 +   #+name: empathy-debug
  61.862 +   #+attr_latex: [htpb]
  61.863 +#+begin_listing clojure
  61.864 +   #+begin_src clojure
  61.865 +(defn init []
  61.866 +  (def phi-space (generate-phi-space))
  61.867 +  (def phi-scan (gen-phi-scan phi-space)))
  61.868 +
  61.869 +(defn empathy-demonstration []
  61.870 +  (let [proprio (atom ())]
  61.871 +    (fn
  61.872 +      [experiences text]
  61.873 +      (let [phi-indices (phi-scan (:proprioception (peek experiences)))]
  61.874 +        (swap! proprio (partial cons phi-indices))
  61.875 +        (let [exp-thread (longest-thread (take 300 @proprio))
  61.876 +              empathy (mapv phi-space (infer-nils exp-thread))]
  61.877 +          (println-repl (vector:last-n exp-thread 22))
  61.878 +          (cond
  61.879 +           (grand-circle? empathy) (.setText text "Grand Circle")
  61.880 +           (curled? empathy)       (.setText text "Curled")
  61.881 +           (wiggling? empathy)     (.setText text "Wiggling")
  61.882 +           (resting? empathy)      (.setText text "Resting")
  61.883 +           :else                       (.setText text "Unknown")))))))
  61.884 +
  61.885 +(defn empathy-experiment [record]
  61.886 +  (.start (worm-world :experience-watch (debug-experience-phi)
  61.887 +                      :record record :worm worm*)))
  61.888 +   #+end_src
  61.889 +   #+end_listing
  61.890 +   
  61.891 +   The result of running =empathy-experiment= is that the system is
  61.892 +   generally able to interpret worm actions using the action-predicates
  61.893 +   on simulated sensory data just as well as with actual data. Figure
  61.894 +   \ref{empathy-debug-image} was generated using =empathy-experiment=:
  61.895 +
  61.896 +  #+caption: From only proprioceptive data, =EMPATH= was able to infer 
  61.897 +  #+caption: the complete sensory experience and classify four poses
  61.898 +  #+caption: (The last panel shows a composite image of \emph{wriggling}, 
  61.899 +  #+caption: a dynamic pose.)
  61.900 +  #+name: empathy-debug-image
  61.901 +  #+ATTR_LaTeX: :width 10cm :placement [H]
  61.902 +  [[./images/empathy-1.png]]
  61.903 +
  61.904 +  One way to measure the performance of =EMPATH= is to compare the
  61.905 +  sutiability of the imagined sense experience to trigger the same
  61.906 +  action predicates as the real sensory experience. 
  61.907 +  
  61.908 +   #+caption: Determine how closely empathy approximates actual 
  61.909 +   #+caption: sensory data.
  61.910 +   #+name: test-empathy-accuracy
  61.911 +   #+attr_latex: [htpb]
  61.912 +#+begin_listing clojure
  61.913 +   #+begin_src clojure
  61.914 +(def worm-action-label
  61.915 +  (juxt grand-circle? curled? wiggling?))
  61.916 +
  61.917 +(defn compare-empathy-with-baseline [matches]
  61.918 +  (let [proprio (atom ())]
  61.919 +    (fn
  61.920 +      [experiences text]
  61.921 +      (let [phi-indices (phi-scan (:proprioception (peek experiences)))]
  61.922 +        (swap! proprio (partial cons phi-indices))
  61.923 +        (let [exp-thread (longest-thread (take 300 @proprio))
  61.924 +              empathy (mapv phi-space (infer-nils exp-thread))
  61.925 +              experience-matches-empathy
  61.926 +              (= (worm-action-label experiences)
  61.927 +                 (worm-action-label empathy))]
  61.928 +          (println-repl experience-matches-empathy)
  61.929 +          (swap! matches #(conj % experience-matches-empathy)))))))
  61.930 +              
  61.931 +(defn accuracy [v]
  61.932 +  (float (/ (count (filter true? v)) (count v))))
  61.933 +
  61.934 +(defn test-empathy-accuracy []
  61.935 +  (let [res (atom [])]
  61.936 +    (run-world
  61.937 +     (worm-world :experience-watch
  61.938 +                 (compare-empathy-with-baseline res)
  61.939 +                 :worm worm*))
  61.940 +    (accuracy @res)))
  61.941 +   #+end_src
  61.942 +   #+end_listing
  61.943 +
  61.944 +  Running =test-empathy-accuracy= using the very short exercise
  61.945 +  program defined in listing \ref{generate-phi-space}, and then doing
  61.946 +  a similar pattern of activity manually yeilds an accuracy of around
  61.947 +  73%. This is based on very limited worm experience. By training the
  61.948 +  worm for longer, the accuracy dramatically improves.
  61.949 +
  61.950 +   #+caption: Program to generate \Phi-space using manual training.
  61.951 +   #+name: manual-phi-space
  61.952 +   #+attr_latex: [htpb]
  61.953 +   #+begin_listing clojure
  61.954 +   #+begin_src clojure
  61.955 +(defn init-interactive []
  61.956 +  (def phi-space
  61.957 +    (let [experiences (atom [])]
  61.958 +      (run-world
  61.959 +       (apply-map 
  61.960 +        worm-world
  61.961 +        (merge
  61.962 +         (worm-world-defaults)
  61.963 +         {:experiences experiences})))
  61.964 +      @experiences))
  61.965 +  (def phi-scan (gen-phi-scan phi-space)))
  61.966 +   #+end_src
  61.967 +   #+end_listing
  61.968 +
  61.969 +  After about 1 minute of manual training, I was able to achieve 95%
  61.970 +  accuracy on manual testing of the worm using =init-interactive= and
  61.971 +  =test-empathy-accuracy=. The majority of errors are near the
  61.972 +  boundaries of transitioning from one type of action to another.
  61.973 +  During these transitions the exact label for the action is more open
  61.974 +  to interpretation, and dissaggrement between empathy and experience
  61.975 +  is more excusable.
  61.976 +
  61.977 +** Digression: bootstrapping touch using free exploration
  61.978 +
  61.979 +   In the previous section I showed how to compute actions in terms of
  61.980 +   body-centered predicates which relied averate touch activation of
  61.981 +   pre-defined regions of the worm's skin. What if, instead of recieving
  61.982 +   touch pre-grouped into the six faces of each worm segment, the true
  61.983 +   topology of the worm's skin was unknown? This is more similiar to how
  61.984 +   a nerve fiber bundle might be arranged. While two fibers that are
  61.985 +   close in a nerve bundle /might/ correspond to two touch sensors that
  61.986 +   are close together on the skin, the process of taking a complicated
  61.987 +   surface and forcing it into essentially a circle requires some cuts
  61.988 +   and rerragenments.
  61.989 +   
  61.990 +   In this section I show how to automatically learn the skin-topology of
  61.991 +   a worm segment by free exploration. As the worm rolls around on the
  61.992 +   floor, large sections of its surface get activated. If the worm has
  61.993 +   stopped moving, then whatever region of skin that is touching the
  61.994 +   floor is probably an important region, and should be recorded.
  61.995 +   
  61.996 +   #+caption: Program to detect whether the worm is in a resting state 
  61.997 +   #+caption: with one face touching the floor.
  61.998 +   #+name: pure-touch
  61.999 +   #+begin_listing clojure
 61.1000 +   #+begin_src clojure
 61.1001 +(def full-contact [(float 0.0) (float 0.1)])
 61.1002 +
 61.1003 +(defn pure-touch?
 61.1004 +  "This is worm specific code to determine if a large region of touch
 61.1005 +   sensors is either all on or all off."
 61.1006 +  [[coords touch :as touch-data]]
 61.1007 +  (= (set (map first touch)) (set full-contact)))
 61.1008 +   #+end_src
 61.1009 +   #+end_listing
 61.1010 +
 61.1011 +   After collecting these important regions, there will many nearly
 61.1012 +   similiar touch regions. While for some purposes the subtle
 61.1013 +   differences between these regions will be important, for my
 61.1014 +   purposes I colapse them into mostly non-overlapping sets using
 61.1015 +   =remove-similiar= in listing \ref{remove-similiar}
 61.1016 +
 61.1017 +   #+caption: Program to take a lits of set of points and ``collapse them''
 61.1018 +   #+caption: so that the remaining sets in the list are siginificantly 
 61.1019 +   #+caption: different from each other. Prefer smaller sets to larger ones.
 61.1020 +   #+name: remove-similiar
 61.1021 +   #+begin_listing clojure
 61.1022 +   #+begin_src clojure
 61.1023 +(defn remove-similar
 61.1024 +  [coll]
 61.1025 +  (loop [result () coll (sort-by (comp - count) coll)]
 61.1026 +    (if (empty? coll) result
 61.1027 +        (let  [[x & xs] coll
 61.1028 +               c (count x)]
 61.1029 +          (if (some
 61.1030 +               (fn [other-set]
 61.1031 +                 (let [oc (count other-set)]
 61.1032 +                   (< (- (count (union other-set x)) c) (* oc 0.1))))
 61.1033 +               xs)
 61.1034 +            (recur result xs)
 61.1035 +            (recur (cons x result) xs))))))
 61.1036 +   #+end_src
 61.1037 +   #+end_listing
 61.1038 +
 61.1039 +   Actually running this simulation is easy given =CORTEX='s facilities.
 61.1040 +
 61.1041 +   #+caption: Collect experiences while the worm moves around. Filter the touch 
 61.1042 +   #+caption: sensations by stable ones, collapse similiar ones together, 
 61.1043 +   #+caption: and report the regions learned.
 61.1044 +   #+name: learn-touch
 61.1045 +   #+begin_listing clojure
 61.1046 +   #+begin_src clojure
 61.1047 +(defn learn-touch-regions []
 61.1048 +  (let [experiences (atom [])
 61.1049 +        world (apply-map
 61.1050 +               worm-world
 61.1051 +               (assoc (worm-segment-defaults)
 61.1052 +                 :experiences experiences))]
 61.1053 +    (run-world world)
 61.1054 +    (->>
 61.1055 +     @experiences
 61.1056 +     (drop 175)
 61.1057 +     ;; access the single segment's touch data
 61.1058 +     (map (comp first :touch))
 61.1059 +     ;; only deal with "pure" touch data to determine surfaces
 61.1060 +     (filter pure-touch?)
 61.1061 +     ;; associate coordinates with touch values
 61.1062 +     (map (partial apply zipmap))
 61.1063 +     ;; select those regions where contact is being made
 61.1064 +     (map (partial group-by second))
 61.1065 +     (map #(get % full-contact))
 61.1066 +     (map (partial map first))
 61.1067 +     ;; remove redundant/subset regions
 61.1068 +     (map set)
 61.1069 +     remove-similar)))
 61.1070 +
 61.1071 +(defn learn-and-view-touch-regions []
 61.1072 +  (map view-touch-region
 61.1073 +       (learn-touch-regions)))
 61.1074 +   #+end_src
 61.1075 +   #+end_listing
 61.1076 +
 61.1077 +   The only thing remining to define is the particular motion the worm
 61.1078 +   must take. I accomplish this with a simple motor control program.
 61.1079 +
 61.1080 +   #+caption: Motor control program for making the worm roll on the ground.
 61.1081 +   #+caption: This could also be replaced with random motion.
 61.1082 +   #+name: worm-roll
 61.1083 +   #+begin_listing clojure
 61.1084 +   #+begin_src clojure
 61.1085 +(defn touch-kinesthetics []
 61.1086 +  [[170 :lift-1 40]
 61.1087 +   [190 :lift-1 19]
 61.1088 +   [206 :lift-1  0]
 61.1089 +
 61.1090 +   [400 :lift-2 40]
 61.1091 +   [410 :lift-2  0]
 61.1092 +
 61.1093 +   [570 :lift-2 40]
 61.1094 +   [590 :lift-2 21]
 61.1095 +   [606 :lift-2  0]
 61.1096 +
 61.1097 +   [800 :lift-1 30]
 61.1098 +   [809 :lift-1 0]
 61.1099 +
 61.1100 +   [900 :roll-2 40]
 61.1101 +   [905 :roll-2 20]
 61.1102 +   [910 :roll-2  0]
 61.1103 +
 61.1104 +   [1000 :roll-2 40]
 61.1105 +   [1005 :roll-2 20]
 61.1106 +   [1010 :roll-2  0]
 61.1107 +   
 61.1108 +   [1100 :roll-2 40]
 61.1109 +   [1105 :roll-2 20]
 61.1110 +   [1110 :roll-2  0]
 61.1111 +   ])
 61.1112 +   #+end_src
 61.1113 +   #+end_listing
 61.1114 +
 61.1115 +
 61.1116 +   #+caption: The small worm rolls around on the floor, driven
 61.1117 +   #+caption: by the motor control program in listing \ref{worm-roll}.
 61.1118 +   #+name: worm-roll
 61.1119 +   #+ATTR_LaTeX: :width 12cm
 61.1120 +   [[./images/worm-roll.png]]
 61.1121 +
 61.1122 +
 61.1123 +   #+caption: After completing its adventures, the worm now knows 
 61.1124 +   #+caption: how its touch sensors are arranged along its skin. These 
 61.1125 +   #+caption: are the regions that were deemed important by 
 61.1126 +   #+caption: =learn-touch-regions=. Note that the worm has discovered
 61.1127 +   #+caption: that it has six sides.
 61.1128 +   #+name: worm-touch-map
 61.1129 +   #+ATTR_LaTeX: :width 12cm
 61.1130 +   [[./images/touch-learn.png]]
 61.1131 +
 61.1132 +   While simple, =learn-touch-regions= exploits regularities in both
 61.1133 +   the worm's physiology and the worm's environment to correctly
 61.1134 +   deduce that the worm has six sides. Note that =learn-touch-regions=
 61.1135 +   would work just as well even if the worm's touch sense data were
 61.1136 +   completely scrambled. The cross shape is just for convienence. This
 61.1137 +   example justifies the use of pre-defined touch regions in =EMPATH=.
 61.1138 +
 61.1139 +* Contributions
 61.1140 +  
 61.1141 +  I created =CORTEX=, a complete environment for creating simulated
 61.1142 +  creatures. Creatures can use biologically inspired senses including
 61.1143 +  touch, proprioception, hearing, vision, and muscle tension. Each
 61.1144 +  sense has a uniform API that is well documented. =CORTEX= comes with
 61.1145 +  multiple example creatures and a large test suite. You can create
 61.1146 +  new creatures using blender, a free 3D modeling tool. I hope that
 61.1147 +  =CORTEX= will prove useful for research ranging from distributed
 61.1148 +  swarm creature simulation to further research in sensory
 61.1149 +  integration. 
 61.1150 +
 61.1151 +
 61.1152 +
 61.1153 +# An anatomical joke:
 61.1154 +# - Training
 61.1155 +# - Skeletal imitation
 61.1156 +# - Sensory fleshing-out
 61.1157 +# - Classification