CS378 A Formal Model of the Java Virtual Machine -- Auxiliary Material

Many lectures will be interactive demos. Lecture material will not always be available, since we'll deviate from the ``script.'' But I will post here such material as I think helpful. Homework assignments will be announced in class; I will try to update the links here as we go but do not assume you can pass this course by just doing the work mentioned here!.

• Assignment 0:
  • Purchase Computer-Aided Reasoning: An Approach ($15 cash -- no checks or credit cards are accepted), from Carol Hyink in Taylor 2.116. I will cite this book as ``[ACL2]''.
  • Start learning to use ACL2 by doing the exercises in Getting Started with ACL2 Programming in ACL2s.
  • For reference, you might look at The Hyper-Card for ACL2 Programming in ACL2s.
    
    
• Lecture 1: Here are the slides I used during class Thu, Jan 18:
  Lecture 1
  Here is the log of the ACL2 session I ran:
  Session Log
  Here is the log of the Linux shell I ran:
  Linux Log
  Note: The ACL2 session log is about 1MB of material, most of which is consumed by my printing the ACL2 object that corresponds to the M6 model of Demo.class in the Linux Log. Even that statement is a little misleading: the vast majority of the space consumed by the ACL2 model of Demo.class is the representation of all the available CLDI API, most of which is totally irrelevant to Demo.class.
  
  
• Assignment 1 (Due before class Tuesday, Jan 23)
  problem-set-1.lisp
  FYI: I believe any computer science junior or senior ought to be able to do this assignment without reading any of the material above! The problem set contains a brief description of the available ACL2 primitives and a few examples of function definitions. But there are 27 problems to do, most asking you to define simple, informally described functions. None of the answers require more than a few lines of code. Mainly this problem set will get you thinking about how to do all your iteration with recursion and how to build data structures with ordered pairs.
  
  Here are my answers problem-set-1-answers.lisp
  
  
• Assignment 2 (Due before class Tuesday, Jan 30)
  Use ACL2s to define all of the functions mentioned in problem-set-1.lisp above. Turnin the .lisp file with your series of defuns in it. Some of the functions you must define are already defined as functions in the "ACL2" package. You should just change the names of your functions. For example, when you're asked to define update-nth, you may define instead my-update-nth.
  
  
• Lecture 2 (Thursday, Jan 25)
  Here is the script I used with ACL2s. By advancing the todo line through it you will see the definition of M1, a simple M1 program to compute factorial, and the use of that program to compute some factorials. During the lecture I frequently visited that portion of Sun's online JVM specification dealing with the bytecode instructions that begin with the letter I, namely this file.
  
  
• Lecture 3 (Tuesday, Jan 30)
  I presented the material in Recursion and Induction, pages 9-17, with special attention to the Axioms (page 10) and Induction (page 15). You may assume as additional axioms anything that is true about the arithmetic functions zp, natp, +, -, *, mod, etc. I discussed Problem 39 (page 15), the tree-copy proof (page 16), and Problem 41 (page 17) and the theorem that (equal (len (app a b)) (+ (len a) (len b))).
  
  I have written out the text of today's lecture. I will not normally do this! But I wanted to put down on paper some sample proofs to act as examples for you when you do your proofs.
  
  I urge you to do Problems 42 and 43, where the definition of mapnil is

  (defun mapnil (x)
    (if (consp x)
        (cons nil (mapnil (cdr x)))
        nil))
  

• Lecture 4 (Thursday, Feb 1)
  I presented proofs of Problem 44 and Problem 61. Our proofs are so schematic -- induct, simplify, use the IH and appeal to lemmas -- that I'm now prepared to accept as an ``abbreviated proof'' just a description of what the induction scheme is and what lemmas you use in the proof.
  
  You may find the abbreviated proofs as Problem-44 and Problem-61 in the Recursion and Induction Solutions. You will note that the proofs involve some lemmas, specifically the lemmas identified in the :in-theory hints.
  
  
• Assignment 3 (Due before class Tuesday, Feb 6)
  problem-set-3.lisp. Note that I have skipped ``Problem Set 2.'' It is best if you you show the steps in your proof -- the induction scheme, the major steps along the way in your simplications, and the lemmas you use. But if you write the ``abbreviated proof'' and you're right then you'll get full credit.
  
  Here are my answers. To process them, you'll need to put this, m1.lisp, in your workspace and certify it. Then you can process my answers:
  problem-set-3-answers.lisp
  Note that you must process my answers in ACL2s' Recursion and Induction mode
  
  
• Lecture 5 (Tuesday, Feb 6)
  I lectured on M1. We wrote some simple programs for M1, including the program to determine whether a natural number is even (leave 1 on the stack) or odd (leave 0 on the stack).
  
  If you want to experiment with M1 you should put these two files,
  
  problem-set-1-answers.lisp
  m1-story.lisp
  
  in your workspace and then certify the first one as a book using ACL2s. Then you will be able to advance your way through the second one, defining the M1 machine, the compiler, and proving a couple of theorems. We will be exploring this file for some time so I recommend you get this working in your ACL2s.
  
  
• Lecture 6 (Thursday, Feb 8)
  I finished the presentation of the compiler in m1-story.lisp.
  
  
• Assignment 4 (Due before class Tuesday, Feb 13)
  problem-set-4.lisp.
  
  Here are my answers: problem-set-4-answers.lisp
  
  
• Lecture 7 (Tuesday, Feb 13)
  Students presented their solutions to Problems 3-1, 3-2, and 3-3 from Homework 3.
  
  
• Lecture 8 (Thursday, Feb 15)
  We went over Problem 3-4 from Homework 3. Alex demonstrated the ACL2s "Recursion and Induction" mode and the theorem macro. We discussed proving theorems about accumulator-using functions and proved (len x) = (len1 x 0) by first proving (natp n) -> (+ (len x) n) = (len1 x n).
  
  
• Assignment 5 (Due before class Tuesday, Feb 20)
  Problems 61, 62, and 64 from the Recursion and Induction notes. You may turn in either typed proof steps (as you did for Assignment 3) or an ACL2s script that will prove these theorems in "Recursion and Induction" mode, demonstrated in class.
  
  
• Lecture 9 (Tuesday, Feb 20)
  We went over the proofs of theorems in m1-story.lisp leading up to the proof of correctness of factorial, starting with stacks and ending with nth-update-nth (lines 692 - 756).
  
  
• Lecture 10 (Thursday, Feb 22)
  I lectured on how to prove theorems about M1 programs. I followed a methodology laid out in m1-story.lisp
  
  
• Assignment 6 (Due before class Tuesday, Feb 27)
  problem-set-6.lisp
  You will need the lemmas I showed you during the lecture. They may be found in m1-lemmas.lisp.
  
  Here are my answers: problem-set-6-answers.lisp
  
  
• Assignment 7 (Due before class, Tuesday, Mar 6)
  problem-set-7.lisp
  
  Here are my answers: problem-set-7-answers.lisp
  
  
• Lecture 11 (Tuesday, Feb 27)
  Alex and the class interactively proved the M1 exponential program correct.
  
  
• Lecture 12 (Thursday, March 1)
  Today I lectured on the concepts of total versus partial correctness and the use of inductive invariants. Here are the slides I used. These slides are actually taken from a conference presentation of this work, but I will relate them to M1.
  
  
• Practice Midterm
  The Midterm exam will be held in class on Thursday, March 8. Here is a practice exam. The actual midterm will be very similar to this. This assignment will not be graded. But you should come to class on Tuesday prepared to present your answers. We will discuss them in preparation for the midterm.
  My answers to the practice midterm: practice-midterm-answers.lisp
  
  
• Midterm
  The midterm exam with my answers: midterm.lisp
  
  
• Midterm histogram
  The grades on the midterm were distributed as follows:

                  X  X        X  X
         X  X     X  X  X  X  X  X
  
  50 55 60 65 70 75 80 85 90 95 100
  

• Lecture 13 (Tuesday, March 20)
  We have spent the first half of the semester studying a simple JVM-like machine called M1. We will spend most of the rest of the semester studying a more accurate model called M5. In this lecture, I started by introducing the shape of the M5 state, contrasting it to the M1 state. Because of the complexity of the M5 state, we need to introduce notation to make the machine's presentation simpler. Then I showed how ACL2 macros work, using the examples in lecture13.lisp. In those examples, together with the alternative definition of M1 in new-m1.lisp, I showed how macros can be used to simplify the presentation of M1. We'll be using those techniques to to make the presentation of M5 succinct enough to comprehend.
  
  
• Lecture 14 (Thursday, March 22)
  I presented the examples in problem-set-8.lisp. I would recommend that you create a new project in your ACL2s Eclipse workspace, called M5. Then import into it the following files:
  • primitives.lisp
  • primitive-lemmas.lisp
  • keytuples.lisp
  Then re-certify each of the files above as a book. You will then be able to replay in ACL2s the material in this lecture, which presents a new data structure called ``keytuples'' which will be used to represent many parts of the M5 state.
  
  
• Assignment 8 (Due before class, Tuesday, Mar 27)
  The lecture notes above, problem-set-8.lisp are actually the next problem set.
  
  
• Lecture 15 (Tuesday, March 27)
  I presented m5.lisp. I recommend you put this file into your ACL2s workspace and re-certify it. In this lecture I focus on the basics like the answers to Problem Set 8 (which are embedded in the m5.lisp file) and the primitives for dealing with the heap.
  
  
• Lecture 16 (Thursday, March 29)
  I continued to present M5, but now using a simple ACL2 tool for running it.
  • diff.lisp
  • irun.lisp
  You should download these files to your ACL2s m5 project and re-certify them. Here are my lecture notes, lecture16.lisp.
  
  
• Assignment 9 (Due before class, Tuesday, Apr 3)
  problem-set-9.lisp
  problem-set-9-answers.lisp
  
  
• Lecture 17 (Tuesday, Apr 3)
  Members of the class presented their solutions to Problem Set 9 and Alex showed a solution involving method invocation.
  
  
• Lecture 18 (Thursday, Apr 5)
  I lectured on M5's INVOKESTATIC, RETURN, XRETURN, and INVOKEVIRTUAL. and them to the JVM's. The main difference is involement of type signatures in the JVM versions
  
  
• Problem Set 10 (Due before class, Tuesday, Apr 10)
  problem-set-10.lisp
  problem-set-10-answers.lisp
  
  
• I decided to add INVOKESPECIAL to our M5. To do the subsequent examples, you should reload and recertify
  
  • m5.lisp
  • m5-lemmas.lisp
  • diff.lisp
  • irun.lisp
  
  
  
• Lecture 19 (Tuesday, Apr 10)
  I started by using irun to step through my solution to Problem Set 10. Then I discussed INVOKEVIRTUAL, following the script in lecture19.lisp
  
  
• Lecture 20 (Thursday, Apr 12)
  I lectured on threads, lecture20.lisp
  
  
• Problem Set 11 (Due before class, Tuesday, Apr 17; extension: Thursday, Apr 19)
  problem-set-11.lisp
  problem-set-11-answers.lisp
  
  
• Lecture 21 (Tuesday, Apr 17)
  I lectured on threads, apprentice.pdf
  
  
• Lecture 22 (Thursday, Apr 19)
  I lectured on exceptions. See the definition of THROW in m5.lisp. The example I used is in lecture22.lisp
  
  
• Problem Set 12 (Due before class, Tuesday, Apr 24)
  problem-set-12.lisp
  problem-set-12.lisp
  
  
• Lecure 23 (Tuesday, Apr 24)
  Hanbing Liu (of AMD, Austin) lectured on the bytecode verifier
  
  
• Lecture 24 (Thursday, Apr 26)
  I showed how to do proofs about M5 bytecode programs.
  m5-lemmas.lisp
  m5-fact.lisp
  
  
• Lecture 25 (Tuesday, May 1)
  practice-final.lisp
  practice-final-answers.lisp