Computational Semantics with Haskell

Some information

• Course takes place on Wednesday 14:30-18:00 in 25.41.00.41
• Course book: Computational Semantics with Functional Programming by Jan van Eijck and Christina Unger

Tentative course schedule

• 19 October -- Slides from the first class https://goo.gl/forms/dQtRgCOtuTA45v8h2">A background questionnaire; German Plural
• 26 October -- Lambda calculus, Functional Programming Slides from the second and third sessions
• 2 November -- Lambda calculus (cont.), first experiments with Haskell
• 9 November -- Introduction to Haskell
• 16 November -- Test on lambda-calculus (conversion + type-assignment). To prepare, check this link: reduce expressions and check yourself. And look at the bottom of this page for the typing exercise.
• 23 November -- Further Haskell, Homework 1
• 30 November -- Formal syntax for games. Slides from three synax-related sessions
• 7 December -- Formal syntax for fragments, propositional logic, Homework 1 due
• 14 December -- Formal syntax for fragments, predicate logic, Homework 2
• 21 December -- Class canceled due to child's illness, homework for this class: complete the code for checking whether a given formula is closed. See below for the part written in class.
• 11 January -- Formal semantics for Sea Battle and propositional logic first class in 2017, Homework 2 due
• 18 January -- Formal semantics for natural language inference system and Mastermind, Slides, Homework 3, due 1.02
• 25 January -- Model checking with predicate logic, Slides
• 1 February -- In-class assignment (Haskell task, start with this syntax and this semantics) + an option to write or rewrite the first in-class test on lambda-calculus
• 8 February -- last class, discussion of the last homework, test, and APs. Please bring AP registration forms.

Grading

Attendance and active participation:

• Attend at least 50% of the theoretical sessions;
• when you attend, please participate:
  • comments and questions during the class;
  • answering questions (even incorrectly, does not matter)
• This brings you extra 10 points.

Assignments and tests:

• There will be 3 graded assignments and 2 tests graded with 14 points each (total of 70 points, for a BN you need 50)

AP:

• First option: cumulative effort
  • For a cumulative effort AP (in-class work + homework), there will be one more homework that can bring you the last 20 points.
• Second option (also for a BN): exam
  • If you want to write an AP separately or are not satisfied with your results during the semester, there will be a possibility to write an exam
  • This exam will be graded out of 100 points
  • The exam will be written and cover the topics of the class (theory) + include a task to write a programm in Haskell.
  • You can also obtain a BN by writing this exam and earning at least 50 points (out of 100).

Grades:

• for a BN you need 50 points (out of 80 points without the final project);
• AP Grade/points correspondence:
  • 1.0: 95 -- 100
  • 1.3: 91 -- 94
  • 1.7: 87 -- 90
  • 2.0: 83 -- 86
  • 2.3: 80 -- 82
  • 2.7: 75 -- 79
  • 3.0: 70 -- 74
  • 3.3: 65 -- 69
  • 3.7: 60 -- 65
  • 4.0: 50 -- 59

  Lambda calculus: typing
  Here are the types for the variables:

  • Proper nouns (like John, Mary, Bob) are of type e (entity)
  • Common nouns (like cat, table) are of type e -> t (entity to truth value)
  • Sentence (S node) is of type t (truth value)
  Given this, provide the types for
  • a two place predicate, such as love. To check, try "John loves Mary" (you should get something of type t after conversion)
  • intransitive predicate, such as wals. To check, try "John walks"
  • the verb is. To check, try "John is a cat"
  • *(harder!) three possible types of noun phrases. You already have two types above, but think about "Every woman loves John", "Every man loves a cat", "Every man loves every woman". Can you make it work?
  To check yourself, open this and have a look on page 6.
  
  Check whether the formula is closed. Complete the code (insert into FSynF):
  isEmpty :: [Variable] -> Bool
  isEmpty [] = True
  isEmpty(x:xs) = False
  
  sentence :: Formula Variable -> Bool
  sentence f = isEmpty (listVariable f)
  
  merge :: [a] -> [a] -> [a]
  merge xs [] = xs
  merge [] ys = ys
  merge (x:xs) (y:ys) = x : y : merge xs ys
  
  listVariable :: Formula Variable -> [Variable]
  listVariable (Atom s []) = []
  listVariable (Atom s xs) = xs
  listVariable (Eq t1 t2) = t1 : t2 : []
  listVariable (Neg form) = listVariable form
  listVariable (Impl f1 f2) = merge (listVariable f1) (listVariable f2)
  listVariable (Equi f1 f2) = merge (listVariable f1) (listVariable f2)
  listVariable (Conj []) = []
  listVariable (Disj []) = []
  listVariable (Conj (f:fs))= listVariable f