A **syntax for a formal language**, in philosophical or logical discussions, will usually specify this vocabulary:

what symbols play the role of

*n*-adic predicates, for*n*= 1, 2, … sometimes also*n*= 0: these will be sentence constants like`P`

and`Q`

what symbols (if any) play the role of term constants (for example, numerals in the language of arithmetic)

what symbols play the role of individual term variables (fancier languages may have variables that stand for plurals or other non-individuals, or that stand for arbitrary properties/sets)

logical symbols like

`¬`

,`∨`

,`∧`

,`⊃`

,`=`

,`∀`

,`∃`

, and so on

The **terms** of such a language will include its constants (b) and variables (c). Some languages also have apparatus for constructing complex terms like `2 + x`

. These come in easy versions and more controversial versions. The easy versions are when the complex terms are guaranteed to always have a definite unique value, no matter what their components — here, `2`

and `x`

— designate. The more controversial versions are like definite descriptions where that’s not guaranteed; and there are very different proposals about how to handle these. We won’t use complex terms in this example.

The **atomic formulas** of a language like we’re considering will consist of an *n*-adic predicate combined with *n* terms. The syntax will also specify rules for how formulas can be combined with logical symbols to create more complex formulas. For example, if `φ`

and `ψ`

are two formulas (maybe atomic, maybe not), then `(φ ∨ ψ)`

is also a formula. (Rules like these are usually unsurprising.)

When a variable occurs (one or more times) in a formula, that occurence(s) of the variable counts as **free** unless they are **bound** by some surrounding device like a quantifier. For example, in the formula:

`∀x(Rxy ∨ Ryx)`

the two occurrences of `x`

I don’t count the `x`

in `∀x`

as an occurrence of `x`

, but terminology varies here
are bound, but the two occurrences of `y`

are free. Formulas count as **open** if they have any free variable occurrences in them; else they are **closed**.

Formulas are sometimes instead called “wffs” (for “well-formed formulas”). And closed formulas are usually called “sentences.”

To give a **semantics for a formal language**, one thing that’s needed is to specify how all the primitive non-logical vocabulary works. (These are (a) and (b) in our above vocabulary list.)

Usually this is done by giving a **domain** for the language’s constants (b) to designate, and that its quantified variables will “range over.” Also, the language’s predicates (a) are associated with sets of sequences of objects from the domain, that the predicate should be true of.

A **model** or **interpretation** or **structure** (terminology varies) is a collection of that domain and associations, together with any other apparatus needed to specify meanings for all the language’s primitive non-logical vocabulary. What each kind of expression gets associated with is called its **designation** or **denotation** or **reference** or **semantic value** or **extension** (terminology varies). Depending on the language’s complexity, these designations may be relativized to **contexts** and/or to **possible worlds** and/or **times**.

For example, the predicate `sees`

in a simple language would be associated with sets of pairs of objects from the domain, such that the first counts as seeing the second. If the semantics is sensitive to worlds, then the predicate would usually instead be associated with *a function from worlds to* sets of pairs of objects. But it could instead be a function from pairs of objects to sets of worlds; or could instead be a function from worlds *and* pairs of objects to truth-values; or…

Notation varies for how to write “the specified designation of predicate `swims`

” or “the specified designation of term constant `Julia`

”. There might be a function `V`

or `ℐ`

in the model, and these be written as `ℐ(swims)`

and `ℐ(Julia)`

. Or they might be written as `s̅w̅ı̅m̅s̅`

or `swims′`

or `|Julia|`

.

Armed with a model, the next thing for a formal semantics to do is to give **rules that specify how the meanings of any (arbitrarily complex) formulas are determined** by their syntactic structure and by what the model specifies as the designata of its primitive non-logical vocabulary.

Our vocabulary will be:

A stock of 1-adic (or unary) predicates

`F`

,`F′`

,`F″`

, …; and a stock of 2-adic (or binary) predicates`G`

,`G′`

,`G″`

, …A stock of term constants

`a`

,`a′`

,`a″`

, …A stock of variables

`x`

,`x′`

,`x″`

, …The logical symbols

`¬`

,`∨`

, and`∃`

This will be enough to illustrate the basic ideas. For our semantics, we’ll have a domain of quantification `𝒟`

, and a function `ℐ`

that interprets the primitive vocabulary (a) and (b). We’ll also make the semantics relative to possible worlds, so we’ll need a set `𝒲`

of worlds. A given model then will be a collection of some specific `𝒟`

, `ℐ`

, and `𝒲`

. Call the model `ℳ`

.

The way `ℐ`

works is that:

For any constant

`c`

(vocabulary of type b),`ℐ(c)`

will be some element of`𝒟`

. (On some treatments, we’d instead let`c`

’s designation vary with respect to different possible worlds.)For 1-adic predicates

`Π¹`

,`ℐ(Π¹)`

will be a function from worlds`∈ 𝒲`

to sets of elements of`𝒟`

For 2-adic predicates

`Π²`

,`ℐ(Π²)`

will be a function from worlds`∈ 𝒲`

to sets of pairs of elements of`𝒟`

For the moment, let’s assume we know what the designation of a variable is (this will be relative to some parameters, which we’ll discuss below).
Then we can say that the designation of an arbitrary term `α`

(relative to whatever parameters we need) is:

- when
`α`

is a constant, then`ℐ(α)`

- else when
`α`

is a variable, whatever we say later (see item 7, below)

And we can define the designation of an atomic formula with a 2-adic predicate `Π²`

like this:

`Π²(α, β)`

is true relative to`ℳ`

(which supplies`ℐ`

), a world`w ∈ 𝒲`

, (and any other parameters needed), iff the pair of what terms`α`

and`β`

designate relative to the supplied parameters is an element of`ℐ(Π²)(w)`

Similarly for 1-adic predicates. Usually there’s an explicit rule for the logical predicate `=`

.

The rules for complex formulas are unsurprising:

if

`φ`

is a formula, then`¬φ`

is true relative to`ℳ`

,`w`

, (and any other parameters needed), iff`φ`

is false relative to those parametersif

`φ`

and`ψ`

are formulas, then`(φ ∨ ψ)`

is true relative to`ℳ`

,`w`

, (and any other parameters needed), iff either`φ`

or`ψ`

is true relative to those parameters

And so on… Once you’ve understood what these rules are saying, they should seem straightforward and unsurprising. In a language of this sort, the only issues that are somewhat complex are the rules for quantifiers, which will have to coordinate with our rules for interpreting variables. There are several ways to handle these; and for *many* of the options there is no interesting theoretical difference between them. It’s a matter of taste or convenience.

The nowadays dominant way to handle quantifiers and variables is to say that among the extra parameters needed to settle the designations of arbitrary expressions is an **assignment function**. This is a function that maps the language’s variables to elements of `𝒟`

. Often these functions are *total* (they have a defined value for every variable), but you can also let them be *partial* (you may only have defined values for some variables). Given an assignment function `𝒻`

, we’ll want to talk about **variant assignment functions** that are just like `𝒻`

in most of their mappings, except that the variant is stipulated to map some variable `v`

to a specific element `d ∈ 𝒟`

. (If `𝒻`

already maps `v`

to `d`

, then it will itself be the variant assignment function we’re after.) There are many different notations for this. Richard, for example, writes the variant assignment function as 𝒻^{v}_{d}. I prefer to write it as `𝒻[v ↦ d]`

or `𝒻[v:=d]`

.

The language we’re working with in this example is not sensitive to contexts or times or anything else, so an assignment function is the only extra parameter our semantics needs to add to the model and world. We can say:

if

`v`

is a variable, then the designation of`v`

relative to`ℳ`

,`w`

, and an assignment function`𝒻`

, is`𝒻(v)`

here the world`w`

plays no role, and neither do any parts of`ℳ`

except that`𝒻`

will be defined to map variables into`𝒟`

, which is part of`ℳ`

if

`φ`

is a formula and`v`

is a variable, then the designation of`∃vφ`

relative to`ℳ`

,`w`

, and an assignment function`𝒻`

, is true iff there’s any element`d ∈ 𝒟`

such that the designation of`φ`

relative to`ℳ`

,`w`

, and`𝒻[v ↦ d]`

is true

As an example, consider a model with the domain `{`

Alex, Barb, Carla`}`

. Suppose the model’s function `ℐ`

maps the individual constant `b`

to Barb. Suppose that relative to a world `w`

, it also maps the verb `sees`

to a set containing every pair of Alex and another object from the domain (Alex sees everyone). Now consider the sentence `∃x sees(x, b)`

. Our semantic rules tell us that will be true on our model relative to world `w`

and assignment function `𝒻`

iff `sees(x, b)`

is true for any of the variant assignment functions based on `𝒻`

but mapping `x`

to the various objects in the domain. Since our formula has no free variables, nothing matters about these variant assignment functions except what they map `x`

to.
Since `b`

is interpreted to designate Barb, this will be true because the pair `(`

Alex, Barb`)`

is in the interpretation of `sees`

for world `w`

.

To say that “the designation of formula `φ`

relative to model `ℳ`

, world `w`

, and assignment function `𝒻`

is true,” I would write:

⟦`φ`

⟧_{ℳ 𝒻 w} = true

Other authors use different notation. `ℳ`

may be left implicit. If `φ`

has no free variables, then it will not matter which assignment function `𝒻`

is used and that will sometimes be omitted too.
Instead of making the designation be relativized to a world and result in a truth-value, some authors will make the designation instead just result in *a function from* worlds to truth values, or equivalently, to *a set of* worlds.

In Richard’s article, he writes:

`c 𝒻 [φ] w`

(He uses different brackets than me, adds a context parameter `c`

and moves the parameters around, leaves the `ℳ`

implicit, and doesn’t write “= true.”)

One alternative notation you sometimes see is:

`ℳ w 𝒻 ⊨ φ`

This is unfortunate, as `⊨`

is also used (even by the same authors) to represent the **semantic entailment relation**, where what appears on the left-hand side is a *list of formulas* understood as premises, rather than semantic parameters like `ℳ`

, `w`

, and `𝒻`

.