1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
|
---
layout: linguistics
title: linguistics/semantics
---
# notes on semantics
Semantics is the study of **meaning**.
How do we know what sentences are true and which are false?<br>
What does it *mean* for a sentence to be true?<br>
What conditions must hold for a sentence to be true?
Formal semantics attempts to answer those questions by providing a *framework* for determining what *conditions* must hold for a sentence to be true.
This framework is [first-order/predicate logic](../mathematics/logic) and the [simply-typed lambda calculus](../plt/lambda-calculus). On top of this, we often build set theory, relying on *characteristic functions* of the lambda calculus as denotations of *set membership*.
## Basic Principles
### Compositionality
### Predicate Logic & The Lambda Calculus
Formal semantics begets a formal system for such semantics, and *first-order logic* and *the lambda calculus* are a natural fit. Semantics is the study of meaning - and what is logic but a system for expressing meaning? As discussed above, language functions by composition - and what are functions but their property of composition?
[*An Invitation to Formal Semantics*](https://eecoppock.info/bootcamp/semantics-boot-camp.pdf) covers basic logic and the lambda calculus well in its first six chapters. Otherwise, for a worse introduction, see [logic](../mathematics/logic), and [the lambda calculus](../plt/lambda-calculus).
## Denotational Semantics
With basic logic and the lambda calculus under our belt, we may simply get straight to assigning *meaning* to language. We consider two *basic types* to start: the type of entities, $e$, and the type of truth values, $t$. Our function types we denote by ordered pairs: that is, a function from $e$ to $t$ is of type $⟨e,t⟩$. This is perhaps clunkier notation than the type-theoretic $e→t$, but it is what it is. (And does avoid issues of precedence.)
### Entities and Functions
> *I am Alice.* <br>
> *Alice is bad.* <br>
> *The blue pigeon flew away.*
- Noun: $⟨e,t⟩ ↝ λx.Noun(x)$
- Verb (intransitive): $⟨e,t⟩ ↝ λx.Verb(x)$
- Verb (transitive): $⟨e,⟨e,t⟩⟩ ↝ λy.λx.Verb(x, y)$
- Verb (meaningless): $⟨⟨e,t⟩,⟨e,t⟩⟩ ↝ λP.λx.P(x)$
- Adj: $⟨⟨e,t⟩,⟨e,t⟩⟩ ↝ λNoun.λx.[Adj(x) ∧ Noun(x)]$
- or (clausal): $⟨t,⟨t,t⟩⟩ ↝ λq.λp.[p ∨ q]$
- and (clausal): $⟨t,⟨t,t⟩⟩ ↝ λq.λp.[p ∧ q]$
- or (verbal): $⟨⟨e,t⟩,⟨⟨e,t⟩,⟨e,t⟩⟩⟩ ↝ λQ.λP.λx.[P(x) ∨ Q(x)]$
- and (verbal): $⟨⟨e,t⟩,⟨⟨e,t⟩,⟨e,t⟩⟩⟩ ↝ λQ.λP.λx.[P(x) ∧ Q(x)]$
- or (quantifiers): $⟨⟨e,⟨e,t⟩⟩,⟨⟨e,⟨e,t⟩⟩,⟨e,⟨e,t⟩⟩⟩⟩ ↝ λQ.λP.λy.λx.[P(x,y) ∨ Q(x,y)]$
- and (quantifiers): $⟨⟨e,⟨e,t⟩⟩,⟨⟨e,⟨e,t⟩⟩,⟨e,⟨e,t⟩⟩⟩⟩ ↝ λQ.λP.λy.λx.[P(x,y) ∧ Q(x,y)]$
- not: $⟨⟨e,t⟩,⟨e,t⟩⟩ ↝ λP.λx.¬P(x)$
### Quantification
- every: $⟨⟨e,t⟩,⟨⟨e,t⟩,t⟩⟩ ↝ λQ.λP.∀x.[P(x) → Q(x)]$
- everything: $⟨⟨e,t⟩,t⟩ ↝ λP.∀x.P(x)$
- some: $⟨⟨e,t⟩,⟨⟨e,t⟩,t⟩⟩ ↝ λQ.λP.∃x.[P(x) ∧ Q(x)]$
- something: $⟨⟨e,t⟩,t⟩ ↝ λP.∃x.P(x)$
- no: $⟨⟨e,t⟩,⟨⟨e,t⟩,t⟩⟩ ↝ λQ.λP.∀x.[P(x) → ¬Q(x)] (or λQ.λP.¬∃x.[P(x) ∧ Q(x)])$
- nothing: $⟨⟨e,t⟩,t⟩ ↝ λP.¬∃x.P(x)$ (or $λP.∀x.¬P(x))$
### Reference
### Numbers and Plurality
### Event Semantics
### Tense and Aspect
## Beyond Truth
### Necessity and Possibility
### Command, Request, Obligation
> *Alice, run!* <br>
> *Alice, please run.* <br>
> *Alice should run.*
### Questions
## Resources
- ✨ [Invitation to Formal Semantics](https://eecoppock.info/bootcamp/semantics-boot-camp.pdf)
|
