CS 15-317: Constructive Logic
(Fall 2015)

Course Information  [  Logistics  |  Course Links  |  Calendar of Classes  |  Coursework Calendar  ]

(Your comments will be sent anonymously to the instructors)


Lectures:Su,Tu16:30 - 17:50(1030)
Recitations: Th16:30 - 17:20(1030)
Class Webpage: http://qatar.cmu.edu/cs/15317

Office hours:
       Iliano Cervesato
by appointment
CMU-Q 1008
         Edmund Lam
by appointment
CMU-Q 1017

Course Links

Calendar of Classes

Click on a class day to go to that particular lecture or recitation. Due dates for homeworks are set in bold. The due date of the next homework blinks.

Coursework Calendar

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


This course is about logics that express algorithms or computation. These constructive logics permeate Computer Science, both as a foundation for the discipline and as concrete languages with eminently practical uses. Indeed, logical languages, tools and methods play an essential role in the design, specification and verification of computer hardware and software, a role that is growing as systems become more complex. The course provides a general exposure to the ideas underlying constructive logic and examines some specific logics and their applications. It is organized into four parts: This course is a gateway to the fascinating and multifaceted world of computational logic. If you find it enjoyable, you may also like 15-312 Foundations of Programming Languages (a systematic, logic-based investigation to programming languages), 15-414 Bug Catching: Automated Program Verification and Testing (the use of a logical technique known as model-checking to verify complex systems), and 80-311 Computability and Incompleteness (a study of the logical foundations of Computer Science).


This course targets primarily (but not exclusively) Computer Science undergraduate students in their junior or senior year. To enroll, students may have completed CS 15-210 (Principles of Programming) or received explicit permission from the instructor.


There is no textbook for this class. However, each lecture is covered by a handout or an article (see schedule). Readings are required unless explicitly flagged as optional.

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.


We will use several languages and software tools in the various parts of the course.

Logic programming languages and applications

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.

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

See the GNU Prolog manual for further information.

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.

Standard ML

Some homework assignments will have you write a intepreter for a logic programming language. While you are free to use whatever language you want for this, we will be providing starter code in Standard ML. Refer to the 15-150 software page to remind yourself about how to install and run SML.


We strongly encourage you to typeset the written part of your homeworks in LaTeX (we will take this into account as part of your participation grade). It takes some getting used to it, especially if MS Word is all you've been exposed to, but it enormously simplifies producing pleasant mathematics. Here are some useful references: You may find this Latex template for homeworks useful.


This is a 9 unit course.

Tasks and Percentages

Evaluation Criteria

Your assignments and exams are evaluated on the basis of:

Late Policy

There are no late days. Assignments submitted past the deadline will get a grade of 0.

Academic Integrity

You are expected to comply with the University Policy on Academic Integrity and Plagiarism (see also The Word and Understanding Academic Integrity). Note that the policy now requires that students acknowledge any help received from the Academic Resource Center (ARC).

Collaboration is regulated by the whiteboard policy: you can bounce ideas about a homework with other students, but when it comes to typing it down for submission, you are on your own — no notes, files, snapshots, etc. Morever, you must wait at least 4 hours before writing down the solution.


It is my goal to make this course successful, stimulating and enjoyable. If at any time you feel that the course is not meeting your expectations or you want to provide feedback on how the course is progressing for you, please contact me. If you would like to provide anonymous comments, please use the feedback form on the course home page or slide a note under my door. Comments of general interest will be answered on the course discussion board.


Course Objectives

This course seeks to develop students who:
  1. demonstrate a high level of proficiency with logic fundamentals
  2. are familiar with algorithmic uses of computational logic
  3. are experienced with a 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

Upon successful completion of this course, students will:
  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
    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

Schedule of Classes

At a glance ...

Bird-eye view

This part of the course provides the basic vocabulary to talk and reason about logic.
Proofs as programs
In this part, we briefly make a connection between natural deduction proofs and functional programming.
Proof search
This part of the course sets the foundations of efficient search for derivations, both for theorem proving and for using logic as a programming device.
Forward chaining
This part of the course explores a different approach to using logic to do computation, an approach that is particularly amenable to parallel and concurrent computation.
Backward chaining
This part of the course explores one way of using logic for computation, both by exploring its theoretical foundations, using an actual language that follows this paradigm, and implementing such a language.
Advanced topics
The end of the course will be dedicated to whatever topic ticks our imagination.

2015 Iliano Cervesato