Fall 98, CSE 520: Lectures

The following is the summary of lectures given so far. For each lecture you find the list of topics covered, and the reference material.

  1. Thu, Aug 27: Overview of the Syllabus. Contents of the course. The Lambda Calculus: syntax and alpha-beta conversion. [Barendregt84, 2.1 or Barendregt92, 2.1. Notes]
  2. Tue, Sep 1: The theorem of Kleene (all recursive functions are lambda-definable). [Barendregt84, 6.1-3 or Barendregt92, 2.2. Notes]
  3. Thu, Sep 3: Beta-reduction. The theorem of Church-Rosser (confluence). Consistency of the Lambda Calculus. [Barendregt84, 3.1-2 or Barendregt92, 2.3]. A brief overview of programming languages based on the Lambda Calculus. The type system of Curry. [Barendregt92, 3.1] [Notes]
  4. Tue, Sep 5 Lecture given by Prof. Dale Miller. Sequent calculus; foundations of logic programming; computation as proof search.
  5. Thu, Sep 10: Lecture given by Prof. Dale Miller. Sequent calculus; foundations of logic programming; computation as proof search (Continued). [Miller98, pp. 1-14 (Sections 1-3)] [Gallier93, Section 4]
  6. Tue, Sep 15: Lecture given by Prof. Dale Miller. Proof search with Horn Clauses; introduction to the Terzo implementation of lambda Prolog. Running Terzo. Terzo's home page. Lambda Prolog's home page. Slides used in class: modules in lambda Prolog; syntax of lambda Prolog. [Miller98, Section 4]
  7. Thu, Sep 17: Lecture given by Prof. Dale Miller. Hereditary Harrop Forumulas. Using HHF in lambda Prolog to encode abstractions inside data. Encoding and reasoning with lambda-abstractions. Examples: representing first-order formula and untyped lambda-terms. Slides used in class. [Miller98, Section 5]. Read the short survey paper on the lambda-tree syntax [Miller_Palamidessi98].
  8. Tue, Sep 22: Lecture given by Prof. Dale Miller. Abstract syntax issues and examples. Unification in "L-lambda" (also called higher-order pattern unification). Slides used in class. Some modules and short interaction with Terzo.
  9. Thu, Sep 24: Examples of typing in the Curry's type system. Most general type. First order unification. [Notes]
  10. Tue, Sep 29: The Martelli-Montanari unification algorithm for first-order terms. [Apt_Pellegrini, Section 2] The subject reduction theorem for the system of Curry. The system of Church and the Symply Typed Lambda Calculus. Relation between the system of Church and the system of Curry. [Barendregt92, 3.2] [Notes]
  11. Thu, Oct 1: PCF (Programming Computable Functions): an extension of the Lambda Calculus with integers, booleans, and some primitives. Eager and Lazy evaluation for PCF. Some examples of lazy programs on streams. [Notes][Further (optional) reading: Winskell93, Ch 11, and Mitchell96, Ch 2]
  12. Tue, Oct 6: Soundness and completeness issues for the eager and the lazy semantics. Simulating lazy programs in ML. Constructing lambda Prolog interpreters for the eager and the lazy PCF. [Notes]
  13. Thu, Oct 8: The Polymorphic Typed Lambda Calculus (version a' la Curry) [Barendregt92, 4.1-4]. Weak polymorphism in ML: a restrictions on higher-order types which makes typeability decidable.
    The Curry-Howard isomorphism: types as formulas, terms as proofs, and computation as proof-normalization. [Gallier95]
  14. Tue, Oct 13: Explanation of projects for the course. Illustration of modalities and preliminary list of subjects. [Projects].
  15. Thu, Oct 15: Introduction to the Theory of Concurrency. [Notes] [Milner89, Preface, 1.1-3].
  16. Tue, Oct 20: A Calculus of Communicating Systems. Syntax and transition rules. Example: a system of two processes communicating via a one-cell buffer. Example: implementing a two-cells buffer by using two one-cell buffers. [Milner89, Ch. 2].
  17. Thu, Oct 22: Equivalence of processes. Strong bisimulation. Example: verification of correspondence between the specification and the implementation of a two-cells buffer. Bisimulation is an equivalence relation. Algebraic laws of bisimulation. Expansion law. Bisimulation is a congruence. [Milner89, Ch. 4].
  18. Tue, Oct 27: Examples of strongly bisimilar processes. Synchronization tree semantics. Correspondence between bisimulation and synchronization trees. Examples of processes not strongly bisimilar, but still undistinguishable by any observer. Testing equilavence. Failure semantics. Correspondence between testing equilavence and failure semantics. (Completed) trace equivalence and trace congruence. Correspondence between testing equilavence and trace congruence. [vanGlabbeek90].
  19. Thu, Oct 29: Weak bisimulation and observation congruence. Properties of observation congruence. Towards an equality theory for proving bisimulation and observation congruence. [Milner89, Ch. 3, 5].
  20. Tue, Nov 3: Equations with unique solutions. Axioms for bisimulation and observation congruence. Soundness of the axiomatization. Completeness of the axiomatization for finite and regular processes. Use of axiomatization for proving correctness of intermediate CCS implementation. (Specification in CCS (using choice) -> Intermediate specification in CCS without choice -> Implementation in a "real" language, e.g. Java.) [Milner89, Ch. 3, 5].
  21. Thu, Nov 5: An extended example: Specification and intermediate implementation in CCS of a scheduler, and proof of correctness (= proof of bisimulation between the two definitions). [Milner89, Ch. 5].
  22. Tue, Nov 10: More project proposals: Example of CCS design: The Alternating Bit Protocol. [Milner89, Ch. 6].
  23. Thu, Nov 12: The Alternating Bit Protocol (Cont.ed). [Milner89, Ch. 6]. The pi-calculus. Motivations and syntax. [Milner_Parrow_Walker92 , Milner_Parrow_Walker93 ]
  24. Tue, Nov 17: The pi-calculus. Structural rules and operational semantics. Early and Late bisimulation. [Milner_Parrow_Walker92 , Milner_Parrow_Walker93 ]
  25. Thu, Nov 19: Asynchronous vs. synchronous communication. Motivations for considering a theory of asynchronous communication.
    Calculi for Asynchronous Communication: Expressive power of the asynchronous pi-calculus: the Honda-Tokoro encoding of the output prefix [Notes].
  26. Tue, Nov 24: Expressive power of the asynchronous pi-calculus: the Nestmann-Pierce encoding of the input-guarded choice [Nestmann_Pierce96]. The full pi-calculus is strictly more expressive than the asynchronous pi-calculus. Proof based on the impossibility of the asinchhronous pi-calculus to express a system for leader election in a symmetric network [Palamidessi97].
  27. Thu, Dec 3: Alternative Models of Concurrency The Gamma Language [Banatre_LeMetayer]. The Chemical Abstract Machine [Berry_Boudol]. The Linda paradigm and the coordination languages [Carriero_Gelenter89, Carriero_Gelenter92]. Concurrent Constraint Programming [FGMP97].
  28. Tue, Dec 8: The sigma-calculus (a calculus of Objects). Sintax. Operational semantics (reduction and conversion). Example of "moving points". Encoding of the lambda calculus into the sigma-calculus. Weak reduction semantics. [Abadi_Cardelli96, Ch 6].
  29. Thu, Dec 10: The sigma-calculus. Fixed point operator. Type system for the sigma-calculus. Subject reduction. Unicity of types. Existence of typeable terms not (weakly) normalizing. Subtyping. [Abadi_Cardelli96, Ch 7, 8].