Procedural Semantics of TIL
Marie Duží
http://www.cs.vsb.cz/duzi/
Semantic schema
Expression
expresses
denotes
meaning (construction)
constructs
object
TIL Ontology of objects: ramified hierarchy of types
Basic notions

Construction






Variables x, y, p, w, t, … v-construct
Trivialization 0X
refers to the object X
Composition [F A1 … An] application of a function
Closure [x1…xn X]
declaration of a function
Execution 1X, Double Execution 2X
Simple theory of types (non-procedural
objects)


Base: {, , , }
Functional types: (1…n)

Partial functions (1 …  n)  
Basic notions


The denoted object can be:





(PWS-)intension: (), frequently (()), or  for short
Extension: a function whose domain is not 
Construction (i.e. meaning of another embedded expression)
nothing (partiality)
Typical extensions:



The denoted object is always a function, possibly of zero
arity, i.e. an atomic object like individual, truth-value, number
-sets are modelled by their characteristic functions: ()
Relations(-in-extension) are of type ()
Typical intensions:

Properties of individuals/(), individual offices (roles)/,
propositions/, relations-in-intension between
individuals/(), attributes/() …
Basic notions, notation

propositional-logic connectives (truth-value functions):
implication (), conjunction (), disjunction () and
equivalence () are functions of type (),
negation () is of type ().



We use infix notation without Trivialization
For instance, instead of ‘[0 [0 p q] [0q]]’ we can write
‘[[p  q]  q]’.
For relations of -identity, =/(), we also use infix
notation without Trivialization and without the subscript .


For instance, let =/() be the identity of individuals, =(())/()
the identity of propositions; a, b v , P v (). Then instead of
[0 [0= a b] [0=(()) [wt [Pwt a]] [wt [Pwt b]]]]
we will simply write
[[a = b]  [wt [Pwt a] = wt [Pwt b]]].
Basic notions, notation

Quantifiers (total functions) ,  / (()).





Let x v , B v , hence x B(x) v (), then
[0 x B(x)] v-constructs T, if x B(x) v-constructs
the whole type , otherwise F,
[0 x B(x)] v-constructs T, if x B(x) v-constructs a
non-empty set of elements of type , otherwise F.
Notation: x B(x), x B(x)
Singularizers (partial functions) I / (()).


[0I x B(x)] v-constructs the only -element of the
set v-constructed by x B(x), if this set is a
singleton, otherwise undefined.
Notation: x B(x) reads „the only x, such that B“
Example

„the only man to run 100 m under 9 s“
Man/(), Time/(()), Run/(), I/(()): the
only…, the whole expression denotes .
wt [0I x [[0Manwt x]  [0Time t [0Runwt x 0100]] < 09]]
() 
()  
(()) ()


() 
(())
 ()

()



Ramified hierarchy of types
T1 (types of order 1) – non-procedural objects, simple theory of types
Cn (constructions of order n)
 Let x be a variable that ranges over a type of order n. Then x is a
construction of order n over B.
 Let X is an object of a type of order n. Then 0X, 1X, 2X are constructions
of order n over B.
 Let X, X1, ..., Xm (m > 0) be constructions of order n over B. Then
[X X1... Xm] is a construction of order n over B.
 Let x1, ..., xm, X (m > 0) be constructions of order n over B. Then
[x1...xm X] is a construction of order n over B.

Nothing else …
Tn+1 (types of order n + 1)
Let n is a collection of all constructions of order n over B. Then
 n and every type of order n are types of order n + 1 over B.
 If , 1,...,m (m > 0) are types of order n + 1 over B, then ( 1 ... m), is
a type of order n + 1 over B.
 Nothing else …
examples, notation: C/ v 
0+/  (), x /  
1
1
v
[0+ x 01]/1 v 
x [0+ x 01]/1 v ()
[x [0+ x 01] 05] /1 v 
[0: x 00]/1 v 
x [0: x 00]/1 v ()


successor function
the number 6
nothing
degenerate function
Let Improper/(1) be the set of constructions of
order 1 which are v-improper for every valuation v.
Hence Improper is an extensional object belonging
to (1), which is a type of order 2.






Then [0Improper 0[0: x 00]] /2  
is an element of 2, which is a type of order 3, though it vconstructs the truth-value T, the object of a type of order 1.
examples




Let Arithmetic be the set of unary arithmetic
functions defined on natural numbers; hence
Arithmetic / (()); and let x v , where  is
the type of natural numbers.
Then the Composition
[0Aritmetic [x [0+ x 01]]]  
belongs to 1, the type of order 2, and it
constructs T, because the Closure
[x [0+ x 01]]  ()
constructs the unary successor function, which is
an arithmetic function.
Examples
Composition [0Aritmetic 2c]/3 v  v-constructs the
truth-value T, if the variable c/2 v 1 v-constructs
for instance the Closure [x [0+ x 01]].





Double Execution 2c v-constructs what is v-constructed by
the Closure, which is an arithmetic successor function;
The Composition [0Aritmetic 2c] is an object belonging to 3,
which is a type of order 4;
variable c v-constructs the Closure [x [0+ x 01]] belonging
to 1, hence c belongs to 2, which is a type of order 3;
Double Execution raises the order of a construction, hence
2c belongs to  , which is a type of order 4. Thus the whole
3
0
Composition [ Aritmetic 2c] belongs to 3, a type of order 4.
Empirical expressions
Empirical expressions denote non-trivial (i.e. non-constant)
intensions
„King of France“, „the prezident of ČR“, „the highest mountain“
denote offices (roles) of type , and actually refer (in this w and t)
to nothing, Miloš Zeman and Mount Everest, respectively.






Yet the referred object must be found out empirically
Predicates like „to be a student“, „to be red“, „to be happy“, „to be of
the age 60“ denote properties of type () and refer to their
population, i.e. to a set of individuals who happen to be students,
red, happy and of the age 60, respectively.
Sentences like „Prague is greater than Brno“ denote propositions of
type  and refer to a truth-value (this sentence to T).
Hence these expressions are empirical, because the object to
which they happen to refer in a given state of the world is beyond
logical analysis; it can be determined only by empirical
investigation of the state of the world at a given time moment.
Analytic expressions






Analytic expressions denote extensions or trivial (i.e.
constant) intensions
The objects they denote can be determined by mere
understanding a given expression, without empirically
investigating the state of the world.
Mathematical and logical expressions are analytical, they
denote extensions
Expressions that contain empirical subexpressions are
analytical, if they denote constant intensions. Hence the
referred object is necessarily, in all worlds w and times t one
and the same.
„No bachelor is married“
„Whales are mammals“
 Denote the constant proposition TRUE, that takes value T in
all w and t
Restricted quantifiers


All students are clever.
Some students are lazy.
wt x [[0Studentwt x]  [0Cleverwt x]]
wt x [[0Studentwt x]  [0Lazywt x]]
These analyses are not literal ones, because they are not in harmony with the
so-called „Parmenides principle“ and with our method of literal analysis: the
sentences do not mention , .




Thus we introduce restricted quantifiers All, Some, No, Most, … of type
((())())
[0All M], M v (), v-constructs the set of all supersets of M
[0Some M], M v (), v-constructs the set of those sets that have a nonempty intersection with M
[0No M], M v (), v-constructs the set of all sets that have an empty
intersection with M
wt [[0All 0Studentwt] 0Cleverwt]
wt [[0Some 0Studentwt] 0Lazywt]
Analytic expressions
“No bachelor is married”  TRUE
 Bachelor, Married/(); No/((())())
wt [[0No 0Bachelorwt] 0Marriedwt]
Let us define and refine:
 m, n/1 v (), x v :
0No = m n x [[m x]  [n x]], [[0No m] n] = x [[m x]  [n x]].
 0Bachelor = wt x [[0Marriedwt x]  [0Manwt x]].
 (to be unmarried and man are requisites of the property of being a
bachelor)
 [[0No 0Bachelorwt] 0Marriedwt] =
x [[0Bachelorwt x]  [0Marriedwt x]] =
x [[0Marriedwt x]  [0Manwt x]  [0Marriedwt x]].
 For any valuation v-constructs T, thus we can generalize:
 wt x [[0Marriedwt x]  [0Manwt x]  [0Marriedwt x]].
Analytic vs. empirical expressions
Necessarily, 8 > 5
The number of planets = 8

Necessarily, the number of planets > 5
???
wt [0> 08 05]
w t [[0Number_of 0Planetwt] = 08]
(analytical necessity)
(empirical fact)
w t [0> [0Number_of 0Planetwt] 05]
(empirical fact)

Types. Number_of/(()): the number of elements of a set, Planet/(),
>, =/()
Proof:
1)
[0> 08 05]
2)
[[0Number_of 0Planetwt] = 08]
3)
[0> [0Number_of 0Planetwt] 05]
4)
wt [0> [0Number_of 0Planetwt] 05]
1. assumption, E
2. assumption, E
1, 2 Leibniz
3, I
Partiality, v-improper constructions

Incoherent typing





If X is not a construction of order n (n  1), then 1X is improper; (a nonprocedural object cannot be executed)
If X is not a construction of order n (n  2), then 2X is improper; (a nonprocedural object cannot be executed)
If X, X1, …, Xn are not constructions typed to produce objects of types
according to Def., then [X X1…Xn] is improper by failing to v-construct anything
for any valuation v.
Example. Tom/; 5/; Student/()
1Tom, 15, wt [0Student 05], 2[wt [0Student 0Tom]]
wt
wt
Application of a function f to the argument a such that f is not defined
at a




[0: x 00] is v-improper for any valuation v
x [0: x 00] is not v-improper, as it constructs a degenerate function
0[0: x 00] is not v-improper, as it constructs the Composition [0: x 00]
[0Improper 0[0: x 00]] constructs T

Improper/(1): the class of constructions v-improper for any v.
Partiality and Compositionality

„If five divided by zero equals five, then Tom is the
Pope“


denotes the degenerate proposition undefined at all w,t !
wt [[[0: 05 00] = 05]  [0Tom = 0Popewt]]  .




0, 5/; :/(); Tom/; Pope/; [0: 05 00]  ; [[0: 05 00] = 05]
 ; 0Tom  ; 0Popewt v ; [0Tom = 0Popewt] v ; [[[0: 05
00] = 05]  [0Tom = 0Pope ]]  .
wt
v
The relation = does not obtain the first argument, hence the
implication truth-function also does not obtain the first
argument; therefore, the whole Composition is v-improper
by failing to construct anything.
Partiality is propagated up.
The Closure  degenerate proposition
Partiality and Compositionality



If you intuitively feel that the sentence could be true,
because the speaker wanted to say that it is not true that
five divided by zero is five, we must analyse this sentence:
„If it is true that five divided by zero equals five, then
Tom is the Pope“.
True*/(n): the class of those constructions that vconstruct T for every valuation v.
[0True* 0C] v-constructs T, iff C v-constructs T for any
valuation v, otherwise F.
wt [[0True* 0[[0: 05 00] = 05]]  [0Tom = 0Papežwt]] 

Now the Closure constructs the proposition TRUE.
The sentence is analytically true
Partiality and Compositionality
False*/(n) and Improper*/(n) are classes
of constructions that v-construct F or are vimproper for all valuations v, respectively:
 [0True* 0C] = [0False* 0C]  [0Improper* 0C]
 [0False* 0C] = [0True* 0C]  [0Improper* 0C]
 [0Improper* 0C] = [0True* 0C]  [0False* 0C]
Similarly, we often need these properties of
propositions: True, False, Undef/()

The rule of -conversion


Fundamental computational rule of -calculi and functional
programming languages
It specifies how to apply of a function f to the argument A to obtain
the value of f at A.
Example. [x [0+ x 01] 03] – we want the value of the
successor function at the number 3:
-reduction (sometimes also -reduction) „by name“:
[x [0+ x 01] 03]  [0+ 03 01]
(= 04)
-expansion (or -expansion):
[0+ 03 01]  [x [0+ x 01] 03]
 In general: [[x1…xm Y] D1…Dm]┣ Y(Di/xi)
where Y(Di/xi) arises from Y by a collision-less substitution of Di for
all the occurrences of the variable xi (1  i  m)
-conversion: [x C(x) A] | C(A/x)



Procedure of applying the function presented by
x C(x) to an argument presented by A.
The fundamental computational rule of -calculi and
functional programming languages
The fundamental inference rule of HOL (higherorder logics)
‘by name’; the procedure A is substituted for all the
occurrences of x

not operationally equivalent, less efficient, loss of info
‘by value’; the value presented by A is substituted for all
the occurrences of x
-conversion: [x C(x) A] | C(A/x)

In programming languages the difference between
‘by value’ and ‘by name’ revolves around the
programmer’s choice of evaluation strategy.





Algol’60: “call-by-value” and “call-by-name”
Java: manipulates objects “by name”, however, procedures
are called “by-value”
Clean and Haskell: “call-by-name”
Similar work has been done since the early 1970s;
for instance, Plotkin (1975) proved that the two
strategies are not operationally equivalent.
Chang & Felleisen (2012)’s call-by-need reduction
by value. But their work is couched in an untyped calculus.
[x C(x) A] | C(A/x)

Conversion by name  three problems.
1. conversion of this kind is not guaranteed to be an
equivalent transformation as soon as partial
functions are involved.
2. even in those cases when -reduction is an
equivalent transformation, it can yield a loss of
analytic information of which function has been
applied to which argument
3. In practice less efficient than ‘by value’
Problems with -reduction ‘by name’
1) non-equivalence
[x [y [0+ x y]] [0Cotg 0]]
is an improper construction; it does not construct
anything, because there is no value of the cotangent
function at 
but its -reduced Composition
[y [0+ [0Cotg 0] y]]
constructs a degenerate function

The improper construction [0Cotg 0] has been drawn
into the intensional context of the Closure [y [0+ x y]].
-conversion by name:
2) loss of analytic information
[x [x + 1] 3]

[3 + 1]
[y [3 + y] 1]
which function has been applied to which argument?
No ‘backward path’. Does it matter?
Problems with -reduction
2) Loss of analytic information
 “John loves his wife, and so does Peter”
 exemplary husbands (sloppy reading)
 “loving one’s own wife” vs. “loving John’s wife”
Lown (John): wt [x [0Lovewt x [0Wife_ofwt x]] 0John]
LJohn (John): wt [x [0Lovewt x [0Wife_ofwt 0John]]
0John]
Both -reduce to LJohn (John):
wt [0Lovewt 0John [0Wife_ofwt 0John]]
 “so does Peter”
 Peter loves John’s wife  trouble on the horizon
-conversion by name: loss of info
(1)
(2)
wt [x [0Lovewt x [0Wife_ofwt 0John]] 0John]
wt [x [0Lovewt x [0Wife_ofwt x]] 0John]
(3)
wt [0Lovewt 0John [0Wife_ofwt 0John]]
It is uncontroversial that the contractum (3) can be
equivalently expanded back both to (1) and (2).
The problem is, of course, that there is no way to
reconstruct which of (1), (2) would be the correct
redex
Does it matter?




HOL tools are broadly used in automatic theorem
checking and applied as interactive proof assistants.
The underlying logic is usually a version of simply
typed -calculus of total functions.
However, there is another application  natural
language processing  hyperintensional logic is
needed so that the underlying inference machine is
neither over-inferring (that yields inconsistencies) nor
under-inferring (that causes lack of knowledge).
agents’ attitudes like knowing, believing, seeking,
solving, designing, etc., because attitudinal sentences
are part and parcel of our everyday vernacular.
Hyperintensionality

was born out of a negative need, to block invalid inferences




Carnap (1947, §§13ff); there are contexts that are neither
extensional nor intensional (attitudes)
Cresswell; any context in which substitution of necessary equivalent
terms fails is hyperintensional
Yet, which inferences are valid in hyperintensional
contexts?
How hyper are hyperintensions?  procedural
isomorphism

Which contexts are hyperintensional?

TIL definition is positive: a context is hyperintensional if the
very meaning procedure is an object of predication; TIL is a
hyperintensional, partial typed -calculus
30
-reduction by value
[x C(x) A] |– C(A/x)
underspecified:

a)
b)
How to execute C(A/x)?
‘by name’: construction A is substituted for
x  problems
‘by value’: execute A first, and only if it does
not fail, substitute the produced value for x
– substitution method  bingo, no
problems !!! 
Substitution ‘by value’
[x F(x) A] = 2[0Sub [0Tr A] 0x 0F(x)]
1. A: execute A in order to obtain the value a;
if A is v-improper, then the whole
Composition is v-improper (stop); else:
2. [0Tr A]: obtain Trivialization of (“pointer at”)
the argument a
3. [0Sub [0Tr A] 0x 0F]: substitute this
Trivialization for x into ‘the body’ F
4. 2[0Sub [0Tr A] 0x 0F]: execute the result
Substitution ‘by value’
Sub/(nnnn) operates on constructions in this way:
[0Sub C1 C2
C3]
what for-what
into-what
Let
C1 v-construct D1,
C2 v-construct D2,
C3 v-construct D3,
then Sub v-constructs the construction D, that is the
result of substituting D1 for D2 into D3
Tr/(n ) v-constructs the Trivialization of an -object
[0Tr x] v-constructs the Trivialization of the object vconstructed by the variable x; x is free
0x constructs x regardless of a valuation, the variable x is
bound by Trivialization, o-bound
Substitution ‘by value’
Example
[0Sub [0Tr 0] 0x 0[0Sin x]]
constructs the Composition [0Sin 0]
2[0Sub [0Tr 0] 0x 0[0Sin x]]
constructs the value of the function Sine at ,
i.e. the number 0
[0Sub [0Tr y] 0x 0[0Sin x]]
v(/y)-constructs the Composition [0Sin 0]
Substitution method;





broadly applied
Application of a function to an argument
(-reduction by value)
Existential quantification into
hyperintensional contexts
Hyperintensional attitudes de re
Anaphoric preprocessing
Topic/focus articulation; presuppositions;
active vs. passive
Substitution method;
broadly applied
de re attitudes
Tilman believes of the Pope that he is wise
wt [0Believewt 0Tilman 2[0Of [0Tr 0Popewt] 0he
0[w*t* [0Wise
w*t* he]]]
Of = Sub operates on the (hyper)intensional
context of “that he is wise”
Substitution method;
broadly applied
Quantifying into …
 Tom is seeking the last decimal of 

There is a number such that Tom is seeking its last
decimal

wt [0Seek*wt 0Tom 0[0Last_Dec 0]]

wt [0x [0Seek*wt 0Tom
[0Sub [0Tr x] 0y 0[0Last_Dec y]]]]
How hyper are hyperintensions 
procedural isomorphism



Maybe that it is philosophically wise to adopt
several notions of procedural isomorphism.
It is not improbable that several degrees of
hyperintensional individuation are called for,
depending on which sort of discourse happens to
be analysed.
What appears to be synonymous in an ordinary
vernacular might not be synonymous in a
professional language like the language of logic,
mathematics, computer science or physics.
Procedural isomorphism
Ordinary vernacular – no -bound variables

(A1’’’): -conversion + -conversion by value
+ restricted -conversion by name;
[x [0+ x 00] y]  [0+ y 00]
+ pairs of simple synonyms

Programming language – variables matter 
(A0’): -conversion + pairs of simple synonyms
