Computational Semantics, Fall 2023

Welcome to Computational Semantics!

I'm Julian Grove, a post-doc in the FACTS.lab directed by Aaron Steven White. I'm teaching Computational Semantics this semester in order for us to explore how functional programming, and specifically the λ-calculus, can be used as a powerful tool in the semantic analysis of natural language, as well as the computational modeling of linguistic behavior.

We'll make heavy use of the Haskell programming language throughout, as we rely on it as a metalanguage to state our theories. Thus the course is aimed primarily at graduate students in Linguistics or Computer Science; but more broadly, it could be interesting to anyone who meets one of the following descriptions:

• has a background in linguistic semantics and hopes to learn (i) how semantic theory can benefit from the incorporation of functional programming techniques; and (ii) how semanticists can benefit from implementing their theories as runnable code
• has a functional programming background and hopes to find out how functional programming techniques have been useful in the analysis of natural language meaning and inference
• has an experimental linguistics background and wants to learn how semantic theory and functional programming can join forces to help vet linguistic theories against experimental data
• wants to learn Haskell

It'll be easier to approach the course if you already have some programming background, though functional programming, per se, isn't necessary. That said, we'll spend the first few classes going over Haskell basics; but we'll launch into the main topics pretty quickly.

The general trajectory of the course will be as follows. In the first part, we'll cover the untyped λ-calculus and type theory. This will take a little bit of time because we'll be building everything from the ground up, covering the syntax of each, as well as their operational semantics and the so-called ``Curry-Howard correspondence''.

In the second part, we'll use the tools developed in the first part in order to study the compositional semantics of natural language (English) by building fragments. We'll enrich our semantic fragments with theories of computational effects; and finally, things will culminate in an approach to theorizing about human linguistic behavior (in an experimental setting) in terms of Bayesian computational models. As we'll see, the theories of computational effects we'll have investigated will be important here.

We'll rely on the following schedule, which I will tweak throughout the semester (though not in any way that affects the basic structure of the course). My general expectation is that everything will take longer than I think it will now.

This course will be Haskell-based, so if you don't have a Haskell development environment installed on your machine, you'll need to install one.

You have a number of options here. One common way to do install Haskell is using a tool called stack, which provides the following functionality:

• It supplies ghc, the standard Haskell compiler, along with ghci, its associated interactive environment (i.e., a repl).
• It supplies base, the package containing the standard Haskell libraries that go into the default prelude.
• It interacts with the Stackage repository, which provides many libraries that you can use in Haskell projects.
• It can be used as a build tool, i.e., to compile binaries, open a repl, provide code documentation (via Haddock) in HTML format from annotated Haskell code.

You can develop Haskell code using whatever text editor you want! But for Haskell, I would very highly recommend Emacs. I use haskell-mode along with dante and attrap, with the following configuration in my init file:

;; haskell
(require 'haskell-mode)
(custom-set-variables '(haskell-process-type 'cabal-repl))
(require 'haskell-interactive-mode)
(require 'haskell-process)
(custom-set-variables
 '(haskell-process-suggest-remove-import-lines t)
 '(haskell-process-auto-import-loaded-modules t)
 '(haskell-process-log t))
(add-hook 'haskell-mode-hook 'interactive-haskell-mode)

(defun insert-pragma ()
  (interactive)
  (insert "{-# LANGUAGE  #-}\n")
  (backward-char 5))
(defun add-haskell-pragma-binding ()
   (local-set-key (kbd "C-x p") #'insert-pragma))
(add-hook 'haskell-mode-hook #'add-haskell-pragma-binding)

(defun insert-brackets ()
  (interactive)
  (insert "{-#  #-}")
  (backward-char 4))
(defun add-haskell-brackets-binding ()
   (local-set-key (kbd "C-x r") #'insert-brackets))
(add-hook 'haskell-mode-hook #'add-haskell-brackets-binding)

(defun insert-repl ()
  (interactive)
  (insert "-- >>> \n")
  (backward-char 1))
(defun add-haskell-repl-binding ()
   (local-set-key (kbd "C-x i") #'insert-repl))

(use-package dante
  :after haskell-mode
  :commands 'dante-mode
  :init
  (add-hook 'haskell-mode-hook 'flycheck-mode)
  (add-hook 'haskell-mode-hook 'dante-mode)
  (add-hook 'haskell-mode-hook #'add-haskell-repl-binding))
(setq dante-debug '(inputs outputs responses))
(setq dante-repl-command-line '("nix-shell" "--run" "cabal repl"))
(use-package attrap
  :ensure t
  :bind (("C-x /" . attrap-attrap))) ;; use any binding of your choice

Learn You a Haskell

Barendregt, Henk P. (2012). The {Lambda} {Calculus}, its {Syntax} and {Semantics}, College Publications.

Blackburn, Patrick and Bos, Johan (2005). Representation and {Inference} for {Natural} {Language}: {A} {First} {Course} in {Computational} {Semantics}, CSLI Publications.

Jansson, Patrik and Ionescu, Cezar and Bernardy, Jean-Philippe (2022). Domain-{Specific} {Languages} of {Mathematics}, College Publications.

Partee, Barbara H. and ter Meulen, Alice and Wall, Robert E. (1990). Mathematical {Methods} in {Linguistics}, Kluwer Academic Publishers.

Thompson, Simon (1999). Type {Theory} \& {Functional} {Programming}.

van Eijck, Jan and Unger, Christina (2010). Computational {Semantics} with {Functional} {Programming}, Cambridge University Press.