CS 15-317: Constructive Logic (Spring 2012)

• Home
• Assignments
• About
• Schedule

About this course  [  Description  |  Prerequisites  |  Feedback  |  Readings  |  Software  |  Grading  |  Assessment  ]

Description

• We begin by giving a basic vocabulary and tool set to talk about logics (and to a large extent programming languages). This includes the judgmental infrastructure of rules and derivations, and the elementary properties that a logical system should have. We use them to study propositional and predicate logic in their natural deduction and sequent calculus presentations.
• We then observe that, in some logics, derivations look just like functional programs, a correspondence known as the Curry-Howard isomorphism. Under this proof-as-program interpretation, computation is carried out as a form of proof reduction.
• Next, we show that, in some logics, formulas can themselves be understood as programs, while proof search is the vehicle of computation. This formula-as-programs interpretation underlies logic programming. We examine languages based on both top-down search, such as Prolog and λ-Prolog, and bottom-up search, e.g., Datalog.
• We dedicate the final weeks of the course to sampling some advanced logics, which support special purpose forms of computation. These include linear logic (stateful transformations), lax logic (effectful algorithms), and authorization logic (security guarantees).

Prerequisites

Readings

This course assumes proficiency with informal logic and logical reasoning. If you feel you need a review or are otherwise unsure, you may want to read through Discovering Logic, by Iliano Cervesato.

Feedback

Software

Tutch

Tutch (short for Tutorial Proof Checker) is a tool that checks the validity of formal proofs that users provide. We will use version 0.52 beta. To run Tutch,

• either install it on your personal computer from the Tutch home page,
• or log on unix.qatar.cmu.edu;
• then, type tutch filename.tut where filename.tut contains your proof or proofs.

See the documentation for further information on running Tutch. The examples from the overview are available here.

Prolog

We will gain experience with top-down logic programming using GNU Prolog, version 1.3.0 or later. To run Prolog,

• either install GNU Prolog on your personal computer from the GNU Prolog web site,
• or log on unix.qatar.cmu.edu;
• then, type gprolog.
  Most installations of vim and Emacs have editing modes for Prolog code, but the default is to treat .pl files as Perl code. To switch to the Prolog mode in vim, use the command :setf prolog. To switch to the Prolog mode in Emacs, use the command M-x prolog-mode.

See the GNU Prolog manual for further information.

Lollibot

To explore bottom-up logic programming we will be using Lollibot, a linear logic programming language which is a custom fragment of Ollibot.

Lollibot is installed on unix.qatar.cmu.edu. You can run it on a file filename.lob with the command

  $ lollibot filename.lob

See the Lollibot primer by William Lovas for a quick introduction. Several examples from lecture are available here.

Grading

Tasks and Percentages

• Daily homework and class participation: 5%
  • At the end of every lecture, you will be given daily homework, a couple of simple exercises or questions collected in the next class. Each will be graded, with negative points for missing or sloppy work.
  • Do the readings ahead of time and volunteer to answer questions asked in class
• 10 weekly homework assignments: 40% (4% each)
  
  • Handed out on Thursdays
  • Due on Thursday 7 days later at 23:59 Doha time. Submit on Blackboard.
  • No joint assignments
• Midterm 1: 15%, in class on February 19th, closed notes
• Midterm 2: 15%, in class on March 25th, closed notes
• Final exam: 25%, 3 hours, open notes

Evaluation Criteria

• Correctness: your arguments should make sense, your proofs should be valid, and your program should work in the reference environments
• Specification: say what you want to do before doing it. In the case of programs, use structured comments describing inputs and outputs, invariants, and side-effects
• Elegance: written material should be of the same quality as what a professional would write. No typos, no bad grammar, clarity is paramount.

• Bonus points: up to 10% for particularly elegant solutions
• Negative points: no less than -100% if caught cheating
• Don't cheat!

Late Policy

Academic Integrity

Collaboration is regulated by the whiteboard policy: you can bounce ideas about an assignment, but when it comes to typing it down for submission, you are on your own — no notes, snapshots, etc., you can at most reconstruct the reasoning from memory.

Assessment

Course Objectives

1. demonstrate a high level of proficiency with logic fundamentals
2. are familiar with algorithmic uses of computational logic
3. are experienced with a non-declarative programming paradigm
4. approach problems logically and create innovative solutions relying on proven techniques
5. have foundational knowledge and an attitude of career-long learning to remain current as technologies evolve
6. communicate orally and in writing in effective and appropriate ways within the discipline

Learning Outcomes

1. know and appreciate advanced concepts in logic. Namely, students will
   1. have a deep understanding of propositional and predicate logic, be familiar with the distinction between intuitionistic and classical logic, and have had exposure to some advanced logics
   2. correctly use a natural deduction or sequent calculus presentation in appropriate situations
   3. be familiar with fundamental properties such as soundness, completeness and consistency, as well as with cut-elimination
   4. be able to use structural induction to prove elementary properties of logical systems
2. have a clear understanding of the logical mechanisms underlying several forms of computation. Namely, they will
   1. be acquainted with the proofs-as-programs correspondence, both for intuitionistic and for classical logic
   2. be familiar with the formulas-as-programs paradigm and computation as proof search
   3. understand the concept of abstract logic programming language and uniform proof
   4. distinguish backward-chaining and forward-chaining modes of computation
   5. extract algorithms from constructive proofs, for example a compiler from a proof of soundness
3. be able to write programs in a variety of styles within the logic programming paradigm. Specifically, they will
   1. be familiar with the fundamental algorithms of top-down logic programming including resolution and unification
   2. be able to write medium-sized programs in Prolog and related languages
   3. understand the principles and applications of bottom-up logic programming as found in Datalog
   4. have had exposure to elementary forms of rewriting logic as found in forward-chaining linear logic programming
4. are able to think abstractly and to combine methods to solve a problem. Namely, they will be able to
   1. apply abstractions to solve problems
   2. develop a systematic analysis method for solving problems
   3. logically break down a problem into logical components
5. have the ability to use learned concepts to remain current in their field. Specifically, they will be able to
   1. reformat information from one way to another
   2. recognize how to apply the fundamentals learned to new or emerging technologies
6. be able to communicate clearly and effectively ideas, concepts and intentions within the field of computational logic, namely
   1. be able to describe technical constructs (concepts) clearly, so as to be readily understood by their peers
   2. be able to give an individual presentation on a technical subject to audience of peers within the discipline of computational logic
   3. form a cogent, logical argument asserting and reiterating all technical concepts that lie within the bounds of the taught curriculum or their research within that curriculum