*
* Lecture notes by Edward Loper
*
* Course: Ling 554 (Type-Logical Semantics)
* Professor: Bob Carpenter
* Institution: University of Pennsylvania
*

[10/03/00 12:05 PM]

> Review of update semantics

  - distinction between world knowledge & discoures logic.
  - divide world into referential part and propostional part..
  - nonrigid designation
  - extension of scope of \exists, not \forall.
  - We can get de re (belief about object) vs de dicto (belief about
    description) distinctions.

> \lambda calculus and type theory

Define 2 \bot types: e (entity), t (truth value).

Walks: e\to t

Define:
  BasTyp = {Ind, Bool}

interpret concat as modus ponens or functional application.

>> Toy Language
  1. var_\tau: a countably infinite set of type \tau
  2. con_\tau: a set of constants of type \tau
  3. Var = \cup_(\tau \in Typ) Var_\tau
  4. Con = \cup_(\tau \in Typ) Con_\tau

terms:
  1. var_\tau \subset Term_\tau
  2. con_\tau \subset Term_\tau
  3. function application
  4. lambda abstraction: \lambda x.(a) yields the appropriate type.

Free variables vs. bound variables.. 

Substitution: \alpha[x\mapsto\beta]

FreeFor(\alpha,x,\beta): is \alpha free for x in \beta?

A model is:
  M = \langle Dom, \lsemantics \bullet \rsemantics\rangle

We still need the equiv of our g function:
  \theta: Var \to Dom, s.t. \theta(x) \in Dom_\tau if x \in Var_\tau

denotations: \lsemantics\alpha\rsemantics_M^\theta

>> Properties

  * system is sound: if \alpha is type \tau, \lsemantics\alpha\rsemantics \in Dom_\tau, for every \theta
    and M.
  * bound variables' names unimportant
  * logical equivlanance if denotations are equal..

Type of \land is bool\to bool\to bool.

order in which a function recieves its arguments is arbitrary.

consider:
  John loves and Mary hates apple pie.

give "John loves" an interpretation by permuting the lambda variables.

Define composition:
  (\beta \circ \alpha)(\delta) =   \beta(\alpha(\delta))

lets us do things like combining "carefully walk" before applying it..

\alpha reduction = substitute a bound variable
\beta reduction = apply a function
\eta reduction = \lambda x(\alpha(x)) \mapsto \alpha if x not in free(\alpha)

Other properties:
  * reflexivity
  * transitivity
  * congruance: \alpha\mapsto\alpha', \beta\mapsto\beta' \vdash \alpha(\beta)\mapsto\alpha'(\beta')
  * congruance on lambda abstraction..
  * equivalance

reductions are confluent (church-rosser)
reduction eventually halts for any finite expression

we can define notion of proof.

Define normal forms..  \beta normal form means there are no more \beta
reductions that you can do, etc.

If \alpha and \beta are in normal form, \alpha \equiv \beta iff \alpha =_\alpha \beta

completeness: two \lambda-terms \alpha and \beta are logically equivalant only if
\vdash \alpha \Leftrightarrow \beta is provable.

decidability: there is an algorithm for deciding whether 2 terms are
logically equivlant.

[10/10/00 12:11 PM]

Single functor/single term.  But do we only have binary branching?
Functions might take multiple args..

So define product times:
(\sigma \times \tau) \in Typ if \sigma, \tau \in Typ

\lsemantics Give\rsemantics(\lsemantics John\rsemantics, \lsemantics Book\rsemantics)

Define new constants and variables of product type.  Does NL have
product type constants?

Need prrojection functions:
  * \pi_1(\alpha) gives 1st element
  * \pi_2(\alpha) gives 2nd element

Dom_{\sigma \times \tau} = Dom_\sigma \times Dom_\tau 

Define operators on terms.. curry/uncurry, commute and reassociate.

>> Applicative Categorial Grammar

Start with a basic set of categories, BasCat (np, n, s).

Define them as:
  * np: ind
  * n: ind->bool
  * s: bool

Define Cat:
  1. BasCat \subseteq Cat
  2. If A, B \in Cat then (A/B), (A{\textbackslash}B) \in Cat

  * A/B is the forward functor with domain (arg) B and range (result)
    A.
  * B{\textbackslash}A is the backward functor with domain (arg) B and range (result) 
    A.

(B B{\textbackslash}A) \to A
(A/B B) \to A

Typ(A/B) = Typ(B{\textbackslash}A) = Typ(B) \to Typ(A)

VP: Typ(np{\textbackslash}s) = Typ(np) \to Typ(s) = ind \to bool

abbreviate lexical entries as: 
e \Rightarrow \alpha: A = <e, <A, a>>

<kiss, <((np{\textbackslash}s)/np), (ind\to(ind\to bool))>

np{\textbackslash}s: expects an np on the left, gives an s.
np{\textbackslash}s/np: expects an np on left and right, gives an S.
np{\textbackslash}s/np/np: expects 1 np on left, 2 on right, gives s.

Proof tree:
#  Bobb Barr          sneezes
# ----------- Lx     ------------ Lx
# Bobbie: np            
#
#

[10/24/00 12:07 PM]

> Game theoretical semantics

Hintika: the principles of mathmatics revisited

We are given a first-order language L and a model M of L.

Define a two-person game G(S; M)

1. Two players: 
    - myself: the initial verifier
    - nature: the initial falsifier
2. At each stage of the game, the verifier is trying to show S is
   true in M, and the falsifier that it's false.
3. Everything gets named

A sentence is true if the verifier has a winning strategy.
A sentence is false if the falsifier has a winning strategy.

Theorem: for any 1st-order sentene, tarski-type truth and GTS truth
coincide.

A sigma(1,1) sentence is a second order existential sentence.  
e.g., (\exists f1, f2)(\forall x)[[f2(x)=0\land R(\ldots)]]

In \forall x\exists yRxy, choice of y depends on x.

Introduce: (\exists y/\forall x) means the choice of y is independant of x. 

Consider: some representative from every village met some relative of
every townsman.

>> Partiality
Assign expressions one of 3 values: 0, 1, and ?.  Use positive and
negative extensions of predicates:
  1. P(A) = 1 if a \in P+
  2. P(A) = 0 if a \in P-
  3. P(A) = ? if (a \notin P+) and (a \notin P-)

Strong Kleene: (1\lor? = 1)
Bochvar: (1\lor? = ?)

it's important to prove that we'll never get a sentence that's both
true and false..

>> Consequences
IF logic is not compositional in the ordinary sense!  When we get down
to (\exists x/\forall y)S[x], we need to know about y\ldots  We can't just use
substitution..  

>> Epistemic Logic

Define Ka as an operator, intuitively interpreted as "a knows that
\ldots".  

Each world M_0 \in W and each person b existing in M_0 is associated
with a set of worlds, the epistemic b-alternatives to M_0.

Let \Omega be a model structure and M_0\in\Omega..  Then Ka(S) in M_0 iff for
each epistemic a-alternative M_1 to M_0 in \Omega, S is true\ldots

(R.K) The game G(Ka(S); M_0) begins with a choice by the falsifier of
an epistemic a-alternative M_1 to M_0.  Continue as G(S; M_1)

>> Natural Language

Assert that there are no overt quantifier-variable pairings..  Modify
game rules so names for individuals are substituted for entire
generalized quantifiers (= Det N).

Treat interpretation of sentences as subgames.  Individuals used for a 
subgame G(S;M) ust be selected from a choice set Is..

[11/07/00 12:11 PM]

> Sequent Calculus

Treat proof rules as arrays: record the entailment relations as you go 
along.  Each node records a set of premises and a conclusion.

You can treat \Gamma as a finite conjunction of formulas.

>> Semantic Tableaux

"branches close" \to inconsistant
# \Gamma \models \varphi

Either show that a branch closes (inconsistancy) or no branch closes.

Use rules to keep rewriting the set, until we get to the end.

Contradiction:
# \Gamma \models \bot

Consistant:
# \Gamma \models something
# \Gamma \lnot\models \bot

Rules:
# \Gamma, \phi \land \psi consistant
# ---------------------
# \Gamma, \phi \land \psi, \phi, \psi consistant

# \Gamma, \lnot(\phi \land \psi) consistant
# ---------------------
# \Gamma, \lnot(\phi \land \psi), \lnot \psi consistant OR \Gamma, \lnot(\phi \land \psi), \lnot\phi, consistant

At any point, we're keeping track of a set of possible consistant
assertions.

Simplify by eliminating repeating conjunctions:
# \Gamma, \phi \land \psi consistant
# ---------------------
# \Gamma, \phi, \psi consistant

Turn it up side down and invert consistant:
# \Gamma, \phi \land \psi, \phi, \psi \models\bot 
# ---------------------
# \Gamma, \phi \land \psi  \models\bot 

We can write \models\bot as \Rightarrow with nothing on the right

>> Rules

Closing:
#
# ----------- (basic segment)
# \Gamma, \phi, \lnot\phi \Rightarrow 

# \Gamma, \phi, \psi \Rightarrow
# --------------
# \Gamma, \phi\land\psi \Rightarrow

# \Gamma, \phi, \psi \Rightarrow
# --------------
# \Gamma, \phi\land\psi \Rightarrow

# \Gamma,\phi \Rightarrow   \Gamma,\psi \Rightarrow
# ----------------
#   \Gamma, \phi\lor\psi \Rightarrow

# \Gamma,\lnot\phi \Rightarrow    \Gamma,\psi \Rightarrow
# -----------------
#    \Gamma, \phi\to\psi \Rightarrow

# \Gamma, \phi, \lnot\psi
# --------------
# \Gamma, \lnot(\phi\to\psi) \Rightarrow

# \Gamma, \phi \Rightarrow
# ---------
# \Gamma, \lnot \lnot \phi \Rightarrow

For Tableaux:
#      \Gamma, \forall x\phi \Rightarrow
# ------------------
# \Gamma, \forall x\phi, \phi(x/x) \Rightarrow

The following are equivlanat:
#  \Gamma \Rightarrow \phi
# ---------
# \Gamma, \lnot\phi \Rightarrow

Use that to simplify to things like: 

# \Gamma \Rightarrow \phi     \Gamma \Rightarrow \psi
# -------------------
#      \Gamma \Rightarrow \phi\land\psi

In a linguistics domain, rules will be things like:
# NP VP \Rightarrow S

Which means that basically we have a CFG here (it's equivalant)..

>> Gentzen Sequents

Allow sequents to have any finite number of formulas on both the left
AND the right side:
# \Gamma \Rightarrow \Delta

Means that if all formulas in \Gamma are true, then at least one formula
in \Delta is true.

see slides p. 12

Now, sequents are no longer equivalant to rewrite rules, since there
can be more than one thing on the right..