In modern mathematical logic this is a function that maps between the language and semantics associated with a logic. Also sometimes referred to as an assignment, but not to be confused with a valuation. (You confused yet?)

The syntax of a formal language can contain the following kinds of objects variables, functional symbols and relational symbols. Each of the last two has associated with it an arity, which can be thought of as the number of arguments these symbols take. E.g. a symbol σ which has arity *n* can take *n* variables (x_{1},...,x_{n}), so in the language it will generally be written as σ(x_{1},...,x_{n}). Now here's the difference from how we are used to working with these things, this σ doesn't have a value yet, in fact none of the variables have values yet. That gets dealt with by the interpretation function.

In mathematical jargon the language is called the domain of the interpretation function (let's use the symbol *I* for this function), i.e. where it maps "from". So where does it map "to", i.e. what is its range/codomain of *I* and how does it do the mapping? Well, it maps to some specified structure like a group, ring or Boolean algebra.

So we need a language and a structure. As an example we will let our syntax *S* have the symbols +, - and *id* where + and - have arity 2 and *id* has arity 0, our syntax also contains the variables x and y. The semantic structure we're working with will be *N*, the integers.

So our interpretation function *I* maps from *S* to *N*. Let's give some examples:

*I*(*id*)=0
*I*(x+y)=*I*(x)+*I*(y)
*I*(x-y)=*I*(x)-*I*(y)

Well that all

very nice! But what the hell is

*I*(x) and

*I*(y)?? Well let's make

*I*(x)=2 and

*I*(y)=3. Then we get

*I*(x+y)=2+3=5,

*I*(x-y)=2-3=-1 and

*I*(x+id)=2+0=2. (Note that to be consistent we should have written

*I*(+(x,y)) but I've decided used to + and - in this way since we're generally quite used to writing functions in

infix notation.) Obviously this language can have many different interpretation functions each assigning different values to x and y or even changing the "interpretation" of +, - and

*id*.

The symbols +, - and *id* are very special in that we assume they have a single result given particular arguments when being interpreted (well *id* has no arguments, but it will always have one result anyway). Such symbols are called functional symbols. As mentioned above we also get relational symbols, one such example is < "less than", since in *N* we have want 1<2, 1<3, 1<4, etc. Sometimes the functional symbols that take no arguments (i.e. that have arity 0) are destinguished from the rest by referring to them asconstants or nullary functional symbols.

This function gets used mostly in model theory, universal algebra, algebraic logic and modal logic. For nodes on the relation between formal languages and semantics see 1, 2 and 3.