Hyperintensional Reasoning based on Natural Language Knowledge Base

TL;DR

This paper introduces a hyperintensional reasoning system based on Tichy's Transparent Intensional Logic, enabling more precise natural language analysis by recognizing different context types and avoiding over- or under-inference.

Contribution

It presents a novel hyperintensional reasoning framework using TIL with context recognition, advancing natural language understanding beyond traditional intensional logic.

Findings

Developed a context recognition algorithm for three context types

Implemented an inference machine for hyperintensional logic

Achieved more accurate reasoning in natural language analysis

Abstract

The success of automated reasoning techniques over large natural-language texts heavily relies on a fine-grained analysis of natural language assumptions. While there is a common agreement that the analysis should be hyperintensional, most of the automatic reasoning systems are still based on an intensional logic, at the best. In this paper, we introduce the system of reasoning based on a fine-grained, hyperintensional analysis. To this end we apply Tichy's Transparent Intensional Logic (TIL) with its procedural semantics. TIL is a higher-order, hyperintensional logic of partial functions, in particular apt for a fine-grained natural-language analysis. Within TIL we recognise three kinds of context, namely extensional, intensional and hyperintensional, in which a particular natural-language term, or rather its meaning, can occur. Having defined the three kinds of context and implemented an algorithm of context recognition, we are in a position to develop and implement an extensional logic of hyperintensions with the inference machine that should neither over-infer nor under-infer.

Equations

$$\frac{Tom\; calculates\; the\; cotangent\; of\pi }{Tom\; calculates\; the\; cotangent\; of\; something}$$

$$\frac{\lambda w\lambda t[[[\text{textsuperscript}0Calculate\; w\left]t\right]\text{textsuperscript}0Tom\text{textsuperscript}0[\text{textsuperscript}0Cot\text{textsuperscript}0\pi ]]}{\lambda w\lambda t[\text{textsuperscript}0\exists \lambda y[[[\text{textsuperscript}0Calculate\; w]t\left]\text{textsuperscript}0Tom\right[\text{textsuperscript}0Sub[\text{textsuperscript}0Tr\; y]\text{textsuperscript}0x\text{textsuperscript}0[\text{textsuperscript}0Cotx]]]]}$$

Full text

{history}

1 Introduction

The family of automatic theorem provers, known today as HOL, is getting more and more interest in logic, mathematics and computer science (see, for instance, [2, 3, 4]). These tools are broadly used in automatic theorem checking and applied as interactive proof assistants. As ‘HOL’ is an acronym for higher-order logic, the underlying logic is usually a version of a simply typed $\lambda$-calculus. This makes it possible to operate both in extensional and intensional contexts, where a value of the denoted function or the function itself, respectively, is an object of predication.

Yet there is another application that is gaining interest, namely reasoning over natural language statements. There are large amounts of text data that we need to analyse and formalize.[5] Not only that, we also want to have question-answer systems which would infer implicit computable knowledge from these large explicit knowledge bases. To this end not only intensional but rather hyperintensional logic (see [6]) is needed, because we need to formally analyse natural language in a fine-grained way so that the underlying inference machine is neither over-inferring (that yields inconsistencies) nor under-inferring (that causes lack of knowledge). We need to properly analyse agents’ attitudes like knowing, believing, seeking, solving, designing, etc., because attitudinal sentences are part and parcel of our everyday vernacular.

Since the substitution of logically equivalent clause for an attitude complement can fail, as already Carnap in [7] knew, we need a fine-grained, hyperintensional analysis here.111Carnap in [7] says that the complements of belief attitudes are neither extensional not intensional. The term ‘hyperintensional’ was introduced by Creswell [8] in order to distinguish hyperintensional contexts from coarse-grained extensional or intensional ones. Before possible-world semantics occupied the term ‘intensional’ for extensionally-individuated functions with the domain in possible world, the term ‘intensional’ was used in the same sense as the current term ‘hyperintensional’, in particular in mathematics. Thus the main reason for introducing hyperintensional contexts was originally to block various invalid interences, and hyperintensional contexts were defined in a negative way, namely as those contexts that do not validate the substitution of equivalent terms denoting the same object (see, e.g. [9]). For instance, if Tilman (explicitly) believes that the Pope is wise he does not have to believe that the Bishop of Rome is wise, though both ‘the Pope’ and ‘the Bishop of Rome’ denote one and the same papal office. Or, when Tilman computes $2+5$ he does not compute $\sqrt{49}$ though both ‘2+5’ and ‘$\sqrt{49}$’ denote the same number 7. He is trying to execute the procedure specified by the term ‘2+5’ rather than by ‘$\sqrt{49}$’.

Yet, there is the other side of the coin, which is the positive topic of which inferences should be validated in hyperintensional contexts. For instance, if Tilman computes $Cotg(\pi)$ then there is a number $x$ such that Tilman computes $Cotg(x)$. Our background theory is Transparent Intensional Logic, or TIL for short (see [10, 11]), with input transformed directly from natural language sentences by means of the Normal Translation Algorithm [12]. TIL definition of hyperintensionality is positive rather than negative. Any context in which the meaning of an expression is displayed rather than executed is hyperintensional. Moreover, our conception of meaning is procedural. Hyperintensions are abstract procedures rigorously defined as TIL constructions which are assigned to expressions as their context-invariant meanings. This entirely anti-contextual and compositional semantics is, to the best of our knowledge, one of rare theories that deals with all kinds of context, whether extensional, intensional or hyperintensional, in a uniform way.222For the disquotation theory of attitudinal sentences see, for instance, [13], where general representation scheme for embedded propositional content is presented. It is however just a scheme, without a full semantic theory. The same extensional logical laws are valid invariably in all kinds of context. In particular, there is no reason why Leibniz’s law of substitution of identicals, and the rule of existential generalisation were not valid. What differ according to the context are not the rules themselves but the types of objects on which these rules are validly applicable. In an extensional context, the value of the function denoted by a given term is an object of predication; hence, procedures producing the same value are mutually substitutable. In an intensional context the denoted function itself is an object of predication; hence, procedures producing the same function are mutually substitutable. Finally, in a hyperintensional context the procedure that is the meanings itself is an object of predication; thus only synonymous terms encoding the same procedure are substitutable. Due to its stratified ontology of entities organised in a ramified hierarchy of types, TIL is a logical framework within which such an extensional logic of hyperintensions has been introduced, see [14, 15].

Reasoning over natural language is usually limited to the textual entailment task [16], which relies on lexical knowledge transfer and stochastic relations rather than deriving logical consequences of facts encoded in these texts. In this paper, we are going to fill this gap. We introduce a system for reasoning based on TIL with natural language input. The task of logical analysis of natural language sentences is connected with advanced formalisms for natural language syntactic analysis, such as the Head-driven Phrase Structure Grammar [17] or Combinatory Categorial Grammars [18, 19]. Even though these formalisms make it possible to transform an input sentence into a logical representation, the expressiveness of the logical formalism is usually within limits of the first-order predicate logic or descriptive logic [20, 21]. In this paper we introduce an algorithm that combines syntactic analysis with logical analysis based on the procedural, i.e. hyperintensional semantics of TIL. This algorithm exploits the TIL type lexicon of 10,500 verb-type assignments and about 30,000 logical schemata for verbs that serve for assigning correct types to verb arguments thus making it possible to discover a fine-grained meaning encoded in the form of a TIL construction. Furthermore, we make use of VerbaLex lexicon of Czech verb valencies containing deep verb frames. These frames are then used to propose TIL types assigned to verbs and verb logical schemata. In order to assign types to verb arguments, we exploit the links to Princeton WordNet. Currently we have the corpus of more than 6,000 TIL constructions that serve for computer-aided analysis of language.

The rest of the paper is organised as follows. In Section 2 we introduce the basic principles of TIL, the algorithm of context recognition, substitution method and $\beta$-conversion ‘by value’. Last but not least, here we also deal with sentences that come attached with a presupposition. Section 3 deals with the method of automatic processing natural language texts. In Section 4 we introduce reasoning in TIL based on a variant of the general resolution method and demonstrate its principles by a simple example. Finally, concluding remarks are presented in Section 5.

2 Fundamentals of TIL

The TIL syntax will be familiar to those who are familiar with the syntax of $\lambda$-calculi with four important exceptions.333For details see [10].

First, TIL $\lambda$-terms denote abstract procedures rigorously defined as constructions, rather than the set-theoretic functions produced by these procedures. Thus, the construction Composition symbolised by $[FA_{1}...A_{m}]$ is the very procedure of applying a function presented by $F$ to an argument presented by $A_{1},...,A_{m}$, and the construction Closure $[\lambda x_{1}x_{2}...x_{n}C]$ is the very procedure of constructing a function by $\lambda$-abstraction in the ordinary manner of $\lambda$-calculi. Second, objects to be operated on by complex constructions must be supplied by atomic constructions. Atomic constructions are one-step procedures that do not contain any other constituents but themselves. They are variables and Trivialization. Variables construct entities of the respective types dependently on valuation, they $v$-construct. For each type (see Def. 2) there are countably many variables assigned that range over this type ($v$-construct entities of this type). Trivialisation ${}^{0}\!X$ of an entity $X$ (of any type even a construction) constructs simply $X$. In order to operate on an entity $X$, the entity must be grabbed first. Trivialisation is such a one-step grabbing mechanism.444In our system Trivialization is implemented as a pointer to $X$. Third, since the product of a construction can be another construction, constructions can be executed twice over. To this end we have Double Execution of $X$, ${}^{2}\!X$, that $v$-constructs what is $v$-constructed by the product of $X$. Finally, since we work with partial functions, constructions can be $v$-improper in the sense of failing to $v$-construct an object for a valuation $v$.

2.1 Constructions and types

Definition 2.1**.**

**(constructions)  

**

1. (i)

Variables x, y, … are constructions that construct objects (elements of their respective ranges) dependently on a valuation v; they v-construct. 2. (ii)

Where X is an object whatsoever (even a construction), 0X is the construction Trivialization that constructs X without any change. 3. (iii)

Let X, Y1,…,Yn be arbitrary constructions. Then Composition [X Y1…Yn] is the following construction. For any v, the Composition [X Y1…Yn] is v-improper if some of the constructions X, Y1,…,Yn is v-improper, or if X does not v-construct a function that is defined at the n-tuple of objects v-constructed by Y1,…,Yn. If X does v-construct such a function then [X Y1…Yn] v-constructs the value of this function at the n-tuple. 4. (iv)

(${\lambda}$-)Closure [$\lambda$x1…xm Y] is the following construction. Let x1, x2, …, xm be pair-wise distinct variables and Y a construction. Then [$\lambda$x1 … xm Y] v-constructs the function f that takes any members B1,…,Bm of the respective ranges of the variables x1,…,xm into the object (if any) that is v(B1/x1,…,Bm/xm)-constructed by Y, where v(B1/x1,…,Bm/xm) is like v except for assigning B1 to x1, …, Bm to xm. 5. (v)

Where X is an object whatsoever, 1X is the construction Execution that v-constructs what X v-constructs. Thus if X is a v-improper construction or not a construction as all, 1X is v-improper. 6. (vi)

Where X is an object whatsoever, 2X is the construction Double Execution. If X is not itself a construction, or if X does not v-construct a construction, or if X v-constructs a v-improper construction, then 2X is v-improper. Otherwise 2X v-constructs what is v-constructed by the construction v-constructed by X. 7. (vii)

Nothing is a construction, unless it so follows from (i) through (vi).

With constructions of constructions, constructions of functions, functions, and functional values in our stratified ontology, we need to keep track of the traffic between multiple logical strata. The ramified type hierarchy does just that. The type of first-order objects includes all objects that are not constructions. The type of second-order objects includes constructions of first-order objects. The type of third-order objects includes constructions of first- and second-order objects. And so on, ad infinitum.

Definition 2.2**.**

(ramified hierarchy of types) Let B be a base, where a base is a collection of pair-wise disjoint, non-empty sets. Then:

T1* (types of order 1).*

1. i)

Every member of B is an elementary type of order 1 over B. 2. ii)

Let $\alpha$, $\beta$1, …, $\beta$m (m > 0) be types of order 1 over B. Then the collection ($\alpha$* $\beta$1 … $\beta$m) of all m-ary partial mappings from $\beta$1 ${\times}$ … ${\times}$ $\beta$m into $\alpha$ is a functional type of order 1 over B.* 3. iii)

Nothing is a type of order 1 over B unless it so follows from (i) and (ii).

Cn* (constructions of order n)*

1. i)

Let x be a variable ranging over a type of order n. Then x is a construction of order n over B. 2. ii)

Let X be a member of a type of order n. Then ${}^{0}\!X$, ${}^{1}\!X$, ${}^{2}\!X$  are constructions of order n over B. 3. iii)

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. 4. iv)

*Let x1, …, xm, X (m

0) be constructions of order n over B. Then [${\lambda}$x1…xm X] is a construction of order n over B.*

5. v)

Nothing is a construction of order n over B unless it so follows from Cn (i)-(iv).

Tn+1* (types of order n + 1)*

Let $*_{n}$ be the collection of all constructions of order n over B. Then

1. i)

$*_{n}$* and every type of order n are types of order n + 1.* 2. ii)

If m > 0 and ${\alpha}$, ${\beta}$1,…,${\beta}$m* are types of order n + 1 over B, then (${\alpha}$ ${\beta}$1 … ${\beta}$m) (see T1 (ii)) is a type of order n + 1 over B.* 3. iii)

Nothing is a type of order n + 1 over B unless it so follows from (i) and (ii).

We model sets and relations by their characteristic functions. Thus, for instance, ($o{\iota}$) is the type of a set of individuals, while ($o{\iota}{\iota}$) is the type of a relation-in-extension between individuals. For the purposes of natural-language analysis, we are assuming the following base of ground types:

[TABLE]

Empirical expressions denote empirical conditions that may or may not be satisfied at some world/time pair of evaluation. We model these empirical conditions as possible-world-semantic (PWS) intensions. PWS intensions are entities of type (${\beta}{\omega}$): mappings from possible worlds to an arbitrary type ${\beta}$. The type ${\beta}$ is frequently the type of a chronology of ${\alpha}$-objects, i.e., a mapping of type (${\alpha}{\tau}$). Thus ${\alpha}$-intensions are frequently functions of type ((${\alpha}{\tau}$)${\omega}$), abbreviated as ‘{\alpha}$${\tau}{\omega}’. Extensional entities are entities of a type ${\alpha}$ where ${\alpha}$ ${\neq}$ (${\beta}{\omega}$) for any type ${\beta}$. Where w ranges over ${\omega}$ and t over ${\tau}$, the following logical form essentially characterizes the logical syntax of empirical language: ${\lambda}$w${\lambda}$t […w…t…]. Examples of frequently used PWS intensions are: propositions of type o$${\tau}{\omega}, properties of individuals of type ($o{\iota}$)${\tau}{\omega}$, binary relations-in-intension between individuals of type ($o{\iota}{\iota}$)${\tau}{\omega}$, individual offices (or roles) of type {\iota}$${\tau}{\omega}, hyperintensional attitudes of type (o{\iota}$$*_{n})${\tau}{\omega}$.

Logical objects like truth-functions and quantifiers are extensional: ${\wedge}$ (conjunction), ${\vee}$ (disjunction) and ${\supset}$ (implication) are of type ($ooo$), and ${\lnot}$ (negation) of type ($oo$). Quantifiers {\forall}$${\alpha}, {\exists}$${\alpha} are type-theoretically polymorphous total functions of type ($o$($o{\alpha}$)), for an arbitrary type ${\alpha}$, defined as follows. The universal quantifier {\forall}$${\alpha} is a function that associates a class A of ${\alpha}$-elements with T if A contains all elements of the type ${\alpha}$, otherwise with F. The existential quantifier {\exists}$${\alpha} is a function that associates a class A of ${\alpha}$-elements with T if A is a non-empty class, otherwise with F.

Below all type indications will be provided outside the formulae in order not to clutter the notation. The outermost brackets of the Closure will be omitted whenever no confusion can arise. Furthermore, ‘X/$\alpha$’ means that an object X is (a member) of type $\alpha$. ‘X $\rightarrow_{v}\alpha$’ means that X is typed to v-construct an object of type $\alpha$, if any. We write ‘X $\rightarrow\alpha$’ if what is v-constructed does not depend on a valuation v. Throughout, it holds that the variables $w\rightarrow_{v}\omega$ and $t\rightarrow_{v}\tau$. If $C\rightarrow_{v}\alpha_{\tau\omega}$ then the frequently used Composition [[C w] t], which is the intensional descent (a.k.a. extensionalization) of the $\alpha$-intension v-constructed by C, will be encoded as ‘$C_{wt}$’. Whenever no confusion arises, we use traditional infix notation without Trivialisation for truth-functions and the identity relation, to make the terms denoting constructions easier to read.

A simple example of the analysis of the sentence “Tom calculates cotangent of the number ${\pi}$” followed by its derivation tree with type assignment is presented in Figure 1.

The resulting type is the type of the proposition that Tom calculates Cotangent of ${\pi}$. The types of the objects constructed by 0$\!{\pi}$, ${}^{0}\!$Cot and [${}^{0}\!$Cot 0$\!{\pi}$], that is ${\tau}$, (${\tau}{\tau}$) and ${\tau}$, respectively, are irrelevant here, because these constructions are not constituents of the whole construction. They occur only displayed by Trivialization 0[${}^{0}\!$Cot 0$\!{\pi}$], that is hyperintensionally. We are going to deal with this issue in the next section.

2.2 Context Recognition

The algorithm of context recognition is based on definitional rules presented in [10]. Since these definitions are rather complicated, here we introduce just the main principles which are quite simple. TIL operates with a fundamental dichotomy between hyperintensions (procedures) and their products, i.e. functions. This dichotomy corresponds to two fundamental ways in which a construction (meaning) can occur, to wit, displayed or executed. If the construction is displayed then the construction itself becomes an object of predication (or an object to operate on); we say that it occurs hyperintensionally. If the construction occurs in the execution mode, then it is a constituent of another construction, and an additional distinction can be found at this level. The constituent presenting a function may occur either intensionally or extensionally. If intensionally, then the whole function is an object of predication (or to operate on); if extensionally, then a functional value is an object of predication (to operate on). The two distinctions, between displayed/executed and intensional/extensional occurrence, enable us to distinguish between three kinds of context:

• •

hyperintensional context: a construction occurs in a displayed mode though another construction at least one order higher needs to be executed in order to produce the displayed construction. In principle, constructions are displayed by Trivialization. It is important to realize that all the sub-constructions of a displayed construction occur also displayed.

• •

intensional context: a construction occurs in an executed mode in order to produce a function but not its value; moreover, the executed construction does not occur within another hyperintensional context

• •

extensional context: a construction occurs in an executed mode in order to produce particular* value* of a function at a given argument; moreover, the executed construction does not occur within another intensional or hyperintensional context.

The basic idea underlying the above trifurcation is that the same set of logical rules applies to all three kinds of context, but these rules operate on different complements: procedures, produced functions, and functional values, respectively. A substitution is, of course, invalid if something coarser-grained is substituted for something finer-grained.

The mechanism to display a construction is Trivialisation that raises the context up to the hyperintensional level. However, we have to take into account that Double Execution decreases the context down, because ${}^{20}\!C$ is equivalent to C in the sense of *v-*constructing the same object (or being *v-*improper) for the same valuations v. According to Def. 1 the Trivialisation ${}^{0}\!C$ constructs just the construction C which is afterwards executed. Thus ${}^{20}\!C$ *v-*constructs the same object as does C, or both constructions are *v-*improper. Moreover, a higher-level context is dominant over a lower-level one. Thus, if C occurs in D hyperintensionally, then all the subconstructions of C occur hyperintensionally in D as well. If C occurs in the execution mode as a constituent of D, then the object that C v-constructs (if any) plays the role of an argument to operate on. In such a case, we have to distinguish whether C occurs intensionally or extensionally. To this end we first distinguish between extensional and intensional supposition of C. Since C occurs executed, it is typed to v-constructs a function f of type (${\alpha}{\beta}$1…${\beta}$n), n possibly equal to zero. Now C may be composed within D with constructions D1, …, Dn which *v-*construct the arguments of the function f, that is Composition [C D1…Dn] is a constituent of D. In such a case we say that C occurs in D with extensional supposition. Otherwise C occurs in D with intensional supposition that is intensionally. Yet this is still not the whole story. If C occurs in D with extensional supposition, it may still occur intensionally, because Composition and ${\lambda}$-Closure are dual operations. While Composition decreases the context down, Closure raises the context up to the intensional level. To take this issue into account, we define a ${\lambda}$-generic context induced by a ${\lambda}$-Closure. Then C occurs extensionally within D if C occurs with extensional supposition in a non-generic context.

Figure 2 shows an example of the result of automatic syntactic analysis of a construction including context-recognition.

2.3 Substitution Method and ${\beta}$-Conversion by Value

Having defined the three kinds of context, we are in a position to specify an extensional logic of hyperintensions that flouts none of the extensional logical principles like Leibniz’s Law of substitution of identicals or the rule of existential generalization. First, we have defined valid rules of substitution. In an extensional context, substitution is validated by so-called v-congruent constructions that *v-*construct the same value of (possibly) different functions. In an intensional context, equivalent constructions (constructions that are v-congruent for every valuation v and thus *v-*construct the same function) are substitutable. In a hyperintensional context where the very construction occurs as an argument, substitution is validated by identical procedures that are procedurally isomorphic constructions. But operating in a hyperintensional context requires the ability to operate directly on constructions, which is technically not easy. To this end we have developed a well-tested method based on substitution ‘by value’. The technical complications we are confronted with are rooted in displayed constructions. For instance, a variable occurring in a hyperintensional context is displayed, i.e. Trivialization-bound, which means being bound in a manner that overrides ${\lambda}$-binding. In particular, since a displayed construction cannot at the same time be executed, valuation does not play any role in such a context. Yet an argument of the form

[TABLE]

is obviously valid. In order to validly infer the conclusion, we need to pre-process the hyperintensional occurrence of the Composition [0Cot x] and substitute the Trivialization of ${\pi}$ for x. Only then can the conclusion be inferred. In order to solve the problem, we deploy the polymorphic functions Subn/(*_{n}$$*_{n}$$*_{n}$$*_{n}) and Tr${\alpha}$/(*_{n}$${\alpha}) that operate on constructions in this manner.

The function Sub when applied to constructions C1, C2 and C3 returns as its value construction D that results from C3 by substituting C1 for all occurrences of C2 in C3. The function Tr returns as its value the Trivialisation of its argument.

For instance, let variable y range over type ${\tau}$. Then [0Tr y] v(${\pi}$/y)-constructs 0${\pi}$. (Recall that v(${\pi}$/y) is the valuation identical to v up to assigning the number ${\pi}$ to the variable y.) The Composition [0Sub [0Tr y] 0x 0[0Cot x]] v(${\pi}$/y)-constructs the Composition [0Cot 0${\pi}$].

It should be clear now how to validly derive that Tom calculates the cotangent of something if Tom calculates the cotangent of ${\pi}$. The valid argument is this:

[TABLE]

Existential quantifier ${\exists}$ is here a function of type ($o$($o{\tau}$)) that associates non-empty sets of numbers with the truth-value T. The complete set of rules for quantifying into hyperintensional attitudinal contexts has been specified and their validity proved in [9].

The substitution method is applied whenever we need to operate in a hyperintensional context. But its application is much broader. In particular, it is also applied in anaphora pre-processing (for details see [22]) and the specification of ${\beta}$-conversion.

Though ${\beta}$-conversion is the fundamental computational rule of ${\lambda}$-calculi and functional programming languages, it is underspecified by the commonly accepted rule

$[{\lambda}$x C(x) A$]\quad{}\vdash{}$ C(A/x).

The problem is this. Procedure of applying the function constructed by ${\lambda}$x C(x) to the argument constructed by A can be executed in two different, mutually non-equivalent ways, to wit (a) by value or (b) by name.555See also [23, 24, 25]. If by name then the procedure A is substituted for all the occurrences of x into C. In this case there are two problems. First, conversion of this kind is not guaranteed to be a logically equivalent transformation as soon as partial functions are involved. Second, it may yield loss of analytic information of which function has been applied to which argument.666For the notion of analytic information see [26]. Strangely enough, purely functional languages such as Clean and Haskell use conversion by name. However, in our *TIL-*based system conversion by value is applied. Its idea is simple. Execute the procedure A first, and only if A does not fail to produce an argument value on which C is to operate, substitute this value for x. The rule of ${\beta}$-conversion by value adapted to TIL is this.

[[${\lambda}$x1…xn Y] D1…Dn] ${}\rightarrow_{\beta}{}$ 2[0Sub [0Tr D1] 0x1 … [0Sub [0Tr Dn] 0xn 0Y]…]

This rule preserves logical equivalence, avoids the problem of loss of analytic information, and moreover, in practice it is more efficient. The efficiency is guaranteed by the fact that procedures D1, …, Dn are executed only once, whereas if these procedures are substituted for all the occurrences of the ${\lambda}$-bound variables they can subsequently be executed more than once.

For these reasons in our system we apply ${\beta}$-conversion by value. The only exception is the so-called restricted ${\beta}$-conversion by name that consists in substituting variables for ${\lambda}$-bound variables (ranging over the same type). This is a technical simplification of a given construction rather than the procedure of applying a function to its argument. To adduce an example, we frequently apply the procedure of extensionalization of an intension. For instance, the analysis of the sentence “The Mayor of Ostrava is a computer scientist” comes down to two procedurally isomorphic constructions:

${\lambda}$w${\lambda}$t [[0Computer 0Scientist]wt ${\lambda}w^{\prime}\lambda t^{\prime}$ [0Mayor_of${}_{w^{\prime}t^{\prime}}$ 0Ostrava]wt]

${\lambda}$w${\lambda}$t [[0Computer 0Scientist]wt [0Mayor_ofwt 0Ostrava]]

The latter construction is a ${\beta}$-reduced contractum of the former.

2.4 Partiality and presuppositions

TIL is one of the few logics that deal with partial functions, see also [27, 25]. Partiality, as we all know well, yields technical complications. But we have to work with partial functions, because in an ordinary vernacular we use non-denoting yet meaningful terms like ‘the King of France’ or ‘the greatest prime’. And reducing the domain of a partial function so that to obtain a total function is not applicable here, because the domain reduction often cannot be specified in a recursive way and we would end up with a non-computable explosion of domains. There are two basic sources of improperness. Either a construction is a procedure of applying a function f to an argument a such that f is not defined at a, or a construction is type-theoretically incoherent. For instance, Composition [0Cotg 0$\!\pi$] is v-improper for any valuation v, because the function cotangent is not defined at the number ${\pi}$ in the domain of real numbers. Single Execution 1X is improper for any valuation v in case X is not a construction, because non-procedural object cannot be executed.

Sentences often come attached with a presupposition that is entailed by the positive as well as negated form of a given sentence. Thus, if a presupposition of a sentence S is not true, the sentence S can be neither true nor false. We follow Frege and Strawson in treating survival under negation as the most important test for presupposition. Moreover, we take into account that there are two kinds of negation, namely Strawsonian narrow-scope and Russellian wide-scope negation. While the former is presupposition-preserving, the latter is presupposition-denying. Anyway, when dealing with sentences that come attached with a presupposition, we need a general analytic schema for such sentences that we are going to introduce now.

A sentence S with a presupposition P encodes as its meaning this procedure:

In any ${\langle}$w, t${\rangle}$-pair of evaluation,

if Pwt is true

then evaluate Swt to produce a truth-value,

else fail to produce a truth-value.

To formulate this schema rigorously, we need to define the If-then-else-fail function. Here is how. The procedure encoded by “If P (${\rightarrow}$ $o$) then C (${\rightarrow}$ $\alpha$), else D (${\rightarrow}$ $\alpha$)” behaves as follows:

1. a)

If *P v-*constructs T then execute C (and return the result of type ${\alpha}$, provided C is not v-improper). 2. b)

If *P v-*constructs F then execute D (and return the result of type ${\alpha}$, provided D is not v-improper). 3. c)

If P is *v-*improper then no result.

Hence, If-then-else is seen to be a function of type $(\alpha o*_{n}*_{n})$, and its definition decomposes into two phases.

First, select a construction to be executed on the basis of a specific condition P. The choice between C and D comes down to this Composition:

[0I* ${\lambda}$c [[P ${\wedge}$ [c = 0C]] ${\vee}$ [${\lnot}$P ${\wedge}$ [c = 0D]]]]

Types: P ${\rightarrow}$v $o$ *v-constructs the condition of the choice between the execution of C or D, C/$*_{n}$, D/*_{n}$${\rightarrow}v ${\alpha}$; c ${\rightarrow}$v $*_{n}$; I/($*_{n}$(o$$*_{n})): the singularizer function (‘the only one’) that associates a singleton of constructions with the construction that is the only element of this singleton, and is otherwise (i.e. if the set is empty or many-valued) undefined.

If *P v-*constructs T then the variable *c v-*constructs the construction C, and if *P v-*constructs F then the variable *c v-*constructs the construction D. In either case, the set constructed by

${\lambda}$c [[P ${\wedge}$ [c = 0C]] ${\vee}$ [${\lnot}$P ${\wedge}$ [c = 0D]]]

is a singleton and the singularizer I* returns as its value either the construction C or the construction D.777Note that in this phase C and D are not constituents to be executed; rather they are merely displayed as objects to be selected by the variable c. This is to say that in TIL constructions themselves can be objects to be operated on, and without this hyperintensional approach we would not be able to define the strict function if-then-else.

Second, the selected construction is executed; therefore, Double Execution must be applied:

2[0I* ${\lambda}$c [[P ${\wedge}$ [c = 0C]] ${\vee}$ [${\lnot}$P ${\wedge}$ [c = 0D]]]]

As a special case of P being a presupposition, no construction D is to be selected whenever P is not satisfied. Thus the definition of the if-then-else-fail function of type ({\alpha}o$$*_{n}) is this:

2[0I* ${\lambda}$c [P ${\wedge}$ [c = 0C]]]

Now we can apply this definition to the case of a presupposition. Let P/*_{n}$${\rightarrow} o$${\tau}{\omega} be a construction of a presupposition of S/*_{n}$${\rightarrow} o$${\tau}{\omega}. Moreover, let c/$*_{n+1}$ ${\rightarrow}$v $*_{n}$, 2c ${\rightarrow}$v $o$. Then the type of the if-then-else-fail function is (oo$$*_{n}) and its definition is:

${\lambda}$w${\lambda}$t [0if-then-else-fail Pwt 0[Swt]] = ${\lambda}$w${\lambda}$t 2[0I* ${\lambda}$c [Pwt ${\wedge}$ [c = 0[Swt]]]]

Gloss. In the first phase the construction Swt is selected, provided Pwt *v-*constructs T. In the second phase Swt is executed. In case Pwt does not *v-construct T, no construction is selected and executed, hence 2[0I ${\lambda}$c [Pwt ${\wedge}$ [c = 0[Swt]]]] is *v-*improper and the so constructed proposition has a truth-value gap, as it should have.

In what follows, instead of the above definition we will use this abbreviated notation as the general analytic schema:

${\lambda}$w${\lambda}$t [if Pwt then Swt else fail].

For illustration, let us analyse Strawson’s example [28]

All John’s children are asleep.

If the topic of the sentence is ‘John’s children’ then there is a presupposition to the effect that John has children.888Hence the situation is this. We are talking about John’s children, and just want to know what they are doing right now. The other option would be, for instance, the scenario of talking about those who are asleep, and the sentence would be offered as an answer, “Among those who are asleep are all of John’s children”. On this reading the sentence would merely entail but not presuppose that John has children. Hence the truth-conditions of this reading can be formulated like this:

If John has any children

then check whether each and every one of them is asleep

else fail to produce a truth-value.

Thus, we have:

${\lambda}$w${\lambda}$t [if [0${\exists}$ [0Children_ofwt 0John] then [[0All [0Children_ofwt 0John]] 0Sleepwt]

else fail ]

Types: Children_of(($o{\iota}$)${\iota}$)${\tau}{\omega}$: the empirical function (attribute) that dependently on a state of affairs associates an individual with the set of those individuals who are his or her children; John/${\iota}$; Sleep/($o{\iota}$)${\tau}{\omega}$; ${\exists}$/($o$($o{\iota}$)); All/(($o$($o{\iota}$))($o{\iota}$)): restricted quantifier that associates a set S of individuals with all the superset of S.

Remark. Here we use the restricted quantifier All, because we want to arrive at the literal analysis of the sentence. Such an analysis follows Frege’s principle [29]: It is simply not possible to speak about an object without somehow denoting or naming it.999The German original goes, “Überhaupt ist es nicht möglich von einem Gegenstand zu sprechen, ohne ihn irgendwie zu bezeichnen oder benennen.” If the unrestricted general quantifier were used the resulting construction would be:

${\lambda}$w${\lambda}$t [if [0${\exists}$ [0Children_ofwt 0John] then

[0${\forall}{\lambda}$x [[[0Children_ofwt 0John] x] ${\supset}$ [0Sleepwt x]]] else fail]

This is an equivalent construction producing the same proposition as the above one, yet it is not the literal analysis of our sentence, because the truth-function of implication is not mentioned in the sentence.101010For more details on the method of arriving at the best literal meaning of a sentence, see [10].

3 Automated Processing of Natural Language Input

Applying the Normal Translation Algorithm (NTA [12]) to natural language sentences allows the system to exploit the full expressiveness of the natural language on the input side. In this section, we first briefly describe the syntactic analysis part of the NTA module, which builds the core of the logical analysis, then we show the main components of the logical construction building process. Practically, the translation from natural language to logical construction is implemented as a self-contained tool denoted as AST111111Automatic Semantic analysis Tool [30], which can produce the logical analysis for different input languages via specific language-dependent setup files.121212The current implementation can handle the input in the Czech and English languages.

The semantic processing of a natural language sentence builds upon the result of structural syntactic analysis or parsing. As a prevalent way of presenting the hierarchical organization of the input sentence, most parsers are able to provide a comprehensive representation in a form of a syntactic tree, which is also the form processed by the AST tool.

The current version of the AST tool is able to process input in the form of two basic types of syntactic trees – a phrasal tree and a dependency tree (see Figure 3 for an example). The employed parsers (the synt parser [31, 32] and the SET parser [33]) are rule-based parsers with different approaches to analysis: one is developed with the meta-grammar concept, the core of the parser uses a context-free grammar with contextual actions and it performs a stochastic agenda-based head-driven chart analysis. Its internal representation concentrates on fast processing of very ambiguous syntactic structures. The parser is able to process sentences with syntactic combinations resulting in potentially thousands of possible syntactic trees ordered by a tree score with an average processing time of 0.07 s per sentence.

The second parser is also a rule-based one but it is based on straightforward pattern-matching dependency rules. Its grammar consists of a set of pattern matching specifications that compete with each other in the process of dependency analysis. From the best matches, the parser builds a full coverage syntactic dependency tree of the input sentence. Currently, the system includes grammars for Czech, Slovak and English, each with a few dozens of rules that sufficiently model the syntax of the particular language, which is due to the expressive character of the formalism.

The logical analysis then proceeds in interlinked modules of AST, which process the output of a syntactic analyser and build the resulting logical construction in a bottom-up manner. The core of AST is language independent, but it needs four specific lexicons covering the logical analysis of particular words and syntactic structures.

3.1 The Syntactic-Semantic Grammar

The bottom-up processing is driven by the hierarchical structure of the input syntactic tree provided by the syntactic parser and by a semantic extension of the actual grammar used in the parsing process. To know which rule was used by the parser, AST needs a semantic grammar specification, which contains the lists of semantic actions that need to be done before propagation of particular node constructions to the higher level in the syntactic tree. The semantic actions define what logical functions correspond to each particular syntactic rule. For instance, the <np> node (a noun phrase) in Figure 3 corresponds to the rule and action:

np -> left_modif np
  rule_schema ( "[#1,#2]" )

which says that the resulting logical construction of the left-hand side np is obtained as a (logical) application of the left_modif (sub)construction to the right-hand side np (sub)construction. An example of processing such grammar rule is in Figure 4.

3.2 Typology of Lexical Items

The second language dependent file defines lexical items and their TIL types. The types are hierarchically built from four TIL ground types [10].

AST contains rules for deriving implicit types based on Part-of-Speech (PoS) categories of the input words, so as the lexicon must prescribe the type only for cases that differ from the implicit definition. The PoS categories are derived from the full morphological database Majka [34] and disambiguated with context-based stochastic tagger Desamb [35]. General approaches in this respect can exploit unsupervised techniques such as [36], however, the required exact logical object specification in AST makes use of detailed PoS category information determined by means of the large word forms database of the respective language. A lexical item example for the verb “(to) pay” is:

pay /k5/otriv $((({o}({o}{o}_{\tau\omega})({o}{o}_{\tau\omega}))\omega)\iota\iota)$

The lexicon assigns the logical types based on PoS tag filters, i.e. the type can differentiate for the exact category of the word within the context of the input sentence. In this example, the verb (category k5) is assigned a logical object via the object-trivialisation construction schema and the corresponding logical type (here a verbal object with two $\iota$-arguments meaning “to pay something to somebody”).

3.2.1 Verb Subcategorization Features

An important part of the predicate construction process consists in determining the main verb and its arguments (subject, object, …) within the sentence. In some languages this process can be driven by the word order, but an authoritative resource for this procedure always needs to lean on detailed information about particular verb subcategorization features of verb valencies.

The next language dependent lexicon is thus a file that defines verb valencies and schema and type information for building the resulting construction from the corresponding valency frame. An example for the verb “(to) pay” is as follows

pay hTc4-hPc3 :exists:V(v):V(v):and:V(v)=[[#0,try(#1),try(#2)],V(w)]

This record defines the valency of $\langle$somebody$\rangle$ pays $\langle$something$\rangle$ to $\langle$somebody$\rangle$, given by the brief valency frame expressions hTc4 of the object (an inanimate noun phrase in accusative) and hPc3 of the patient (an animate noun phrase in dative), and the resulting construction of the verbal object (V(v)) derived as an application of the verb (#0) to its arguments (the sentence objects) with possible extensification (try(#1) and try(#2)) and the appropriate possible world variable (V(w)).

3.2.2 Phrasal and Sentence Combinatory Expressions

Last two lexicons involved in the AST logical analysis allow to specify semantic schemata of combinations on the phrasal and sentence level. For example, in the case of Czech the phrasal Combinatory expressions include a list of semantic mappings of prepositional phrases to valency expressions based on the head preposition. The file contains for each combination of a preposition and a grammatical case of the included noun phrase all possible valency slots corresponding to the prepositional phrase.

For instance, the record for the preposition “k” (to) is displayed as

k 3 hA hH

saying that “k” can introduce a datival prepositional phrase of a where-to direction hA (e.g. “k lesu” – ”to a forest”), or a modal how/what specification hH (e.g. “k večeři” – “to a dinner”).

The combinatory expressions on the sentence level are used when the sentence structure contains subordination or coordination clauses. The sentence schemata are classified by the conjunctions used between clauses. An example for the conjunction “but” is:

("";"but") : "lwt(awt(#1) and awt(#2))"

The resulting construction builds a logical conjunction (clause1 and clause2) of the two clauses.

These lexicons and schema lists then drive the whole process of standard translation of a natural language sentence into a structured logical construction suitable for processing by the TIL inference mechanism.

4 Reasoning in TIL

Having defined $\beta$-conversion by value, substitution method, the If-then-else-fail function and the rules for existential quantification into hyperintensional contexts, we were in a position to define the inference machine based on TIL. Tichý in [37, 38] specified the deduction system for TIL by applying sequent calculus. Tichý’s version was specified for pre-1988 TIL, i.e. TIL based on the simple theory of types. Duží extended this version for TIL as of 2010, and formulated the results as an extensional logic of hyperintensions in two papers [14, 15]. In our system of questions, answers and reasoning over natural language texts we decided to apply the general resolution method (GRM) adjusted for TIL. There are two main reasons for this option. First, deduction by applying the resolution method is goal/question driven. And second, more importantly, this method is specified in an algorithmic way and thus easy to implement. The first version was implemented in Prolog [39] and later extended to the general resolution.

The idea to implement intelligent reasoning in Prolog or more generally by the resolution method is not a new one. For instance, Flach in [40] aims to make the reader familiar with the implementation of the intelligent reasoning with natural language using Prolog programs. Our novel contribution is both theoretical and practical. From the theoretical point of view, the novelty consists in a fine-grained logical analysis of natural language in TIL, as described above. In our opinion, in a multi-agent world of the Semantic Web, information and communication technologies, artificial intelligence, and other such facilities, there is a pressing need for a universal framework informed by one logic making all the semantically salient features of natural language explicit. And TIL with its procedural semantics and hyperintensional typing is such a universal framework. From the practical point of view, we have been developing an inference machine that neither over-infers (which yields inconsistences) nor under-infers (which yields a lack of knowledge).

The transition from TIL into GRM and vice versa has been specified in a near to equivalent way, i.e., without the loss of important information encoded by TIL constructions. The algorithm of transferring closed constructions that are typed to construct propositions into the clausal form appropriate for GRM decomposes into the following steps.

1. i)

Eliminate the left-most $\lambda$w$\lambda$t:   $[\lambda w\lambda t\,C(w,t)]\Rightarrow C(w,t)$ 2. ii)

Eliminate unnecessary quantifiers that do not quantify any variable 3. iii)

Apply the rule of $\alpha$-conversion so that different $\lambda$-bound variables have different names 4. iv)

Eliminate truth functions ${\supset}$ (implication) and ${\equiv}$ (equivalence) by applying these rules: [C ${\supset}$ D] ${}\vdash{}$ [${\lnot}$C ${\vee}$ D] and [C ${\equiv}$ D] ${}\vdash{}$ [[${\lnot}$C ${\vee}$ D] ${\wedge}$ [${\lnot}$D ${\vee}$ C]] 5. v)

Apply de Morgan laws 6. vi)

If the construction contains existential quantifiers, eliminate them by applying Skolemization 7. vii)

Move general quantifiers to the left 8. viii)

Apply distributive laws:

[[C $\wedge$ D] $\vee$ E] ${}\vdash{}$ [[C $\vee$ E] $\wedge$ [D $\vee$ E], [C $\vee$ [D $\wedge$ E]] ${}\vdash{}$ [[C $\vee$ D] $\wedge$ [C $\vee$ E]

The result is a construction in the clausal form proper for GRM.

4.1 Example of Question Answering in TIL

Here is an example of the analysis of a few natural language sentences and answering questions over this mini knowledge base.

Scenario.

Tom, Peter and John are members of a sport club. Every member of the club is a skier or a climber. No climber likes raining. All skiers like snow. Peter does not like what Tom likes, and does like what Tom does not like. Tom likes snow and raining.

Question: Is there in the club a sportsman who is a climber but not a skier? If so, who is it?

Analysis.

Types. Tom, Peter, SC/${\iota}$; Member-of/($o{\iota}{\iota}$)${\tau}{\omega}$; Skier, Climber/($o{\iota}$)${\tau}{\omega}$; Rain, Snow/${\alpha}$; Like/($o{\iota}{\alpha}$)${\tau}{\omega}$.

1. a)

$\lambda w\lambda t$ $[[^{0}\!$Member-of$\!{}_{wt}$ ${}^{0}\!$Tom ${}^{0}\!$SC$]$ $\wedge$ $[^{0}\!$Member-of$\!{}_{wt}$ ${}^{0}\!$Peter ${}^{0}\!$SC$]$ $\wedge$

                                           $[^{0}\!$Member-of$\!{}_{wt}$ ${}^{0}\!$John ${}^{0}\!$SC$]]$ 2. b)

$\lambda w\lambda t$ $[^{0}{\forall}{\lambda}x\,[[^{0}\!$Member-of$\!{}_{wt}$ $x$ ${}^{0}\!$SC$]$ $\supset$ $[[^{0}\!$Skier**wt $x]$ $\vee$ $[^{0}\!$Climber${}_{wt}\,x]]]]$ 3. c)

$\lambda w\lambda t\,[^{0}{\forall}{\lambda}x\,[[^{0}\!$Climber**wt $x]$ $\supset$ ${\neg}[^{0}\!$Like**wt $x$ ${}^{0}\!$Rain$]]]$ 4. d)

$\lambda w\lambda t$ $[^{0}{\forall}{\lambda}x\,[[^{0}\!$Skier**wt $x$] $\supset$ $[^{0}\!$Like**wt $x$ ${}^{0}\!$Snow$]]]$ 5. e)

$\lambda w\lambda t$ $[^{0}{\forall}{\lambda}x\,[[[^{0}\!$Like**wt ${}^{0}\!$Tom $x]$ $\supset\neg[^{0}\!$Like**wt ${}^{0}\!$Peter $x]]$ $\wedge$

                  $[\neg[^{0}\!$Like**wt ${}^{0}\!$Tom $x]$ $\supset$ $[^{0}\!$Like**wt ${}^{0}\!$Peter $x]]]]$ 6. f)

$\lambda w\lambda t$ $[[^{0}\!$Like**wt ${}^{0}\!$Tom ${}^{0}\!$Snow$]$ $\wedge$ $[^{0}\!$Like**wt ${}^{0}\!$Tom ${}^{0}\!$Rain$]]$ 7. Q)

$\lambda w\lambda t$ $[^{0}{\exists}{\lambda}x\,[[^{0}\!$Member-of$\!{}_{wt}$ $x$ ${}^{0}\!$SC$]$ $\wedge$ $[^{0}\!$Climber**wt $x]$ $\wedge$ $\neg[^{0}\!$Skier**wt $x]]]$

Solution.

eliminate left-most $\lambda w\lambda t$ + $\alpha$-conversion:

1. a)

$[[^{0}\!$Member-of$\!{}_{wt}$ ${}^{0}\!$Tom ${}^{0}\!$SC$]$ $\wedge$ $[^{0}\!$Member-of$\!{}_{wt}$ ${}^{0}\!$Peter ${}^{0}\!$SC$]$ $\wedge$

$[^{0}\!$Member-of$\!{}_{wt}$ ${}^{0}\!$John ${}^{0}\!$SC$]]$ 2. b)

$[^{0}{\forall}{\lambda}x\,[[^{0}\!$Member-of$\!{}_{wt}$ $x$ ${}^{0}\!$SC$]$ $\supset$ $[[^{0}\!$Skier**wt $x]$ $\vee$ $[^{0}\!$Climber${}_{wt}\,x]]]]$ 3. c)

$[^{0}{\forall}{\lambda}y\,[[^{0}\!$Climber**wt $y]$ $\supset$ ${\neg}[^{0}\!$Like**wt $y$ ${}^{0}\!$Rain$]]]$ 4. d)

$[^{0}{\forall}{\lambda}z\,[[^{0}\!$Skier**wt $z]$ $\supset$ $[^{0}\!$Like**wt $z$ ${}^{0}\!$Snow $]]]$ 5. e)

$[^{0}{\forall}{\lambda}u\,[[[^{0}\!$Like**wt ${}^{0}\!$Tom $u]$ $\supset\neg[^{0}\!$Like**wt ${}^{0}\!$Peter $u]]$ $\wedge$

$[\neg[^{0}\!$Like**wt ${}^{0}\!$Tom $u]$ $\supset$ $[^{0}\!$Like**wt ${}^{0}\!$Peter $u]]]]$ 6. f)

$[[^{0}\!$Like**wt ${}^{0}\!$Tom ${}^{0}\!$Snow$]$ $\wedge$ $[^{0}\!$Like**wt ${}^{0}\!$Tom ${}^{0}\!$Rain$]]$ 7. Q)

$[^{0}{\exists}{\lambda}q\,[[^{0}\!$Member-of$\!{}_{wt}$ $q$ ${}^{0}\!$SC$]$ $\wedge$ $[^{0}\!$Climber**wt $q]$ $\wedge$ $\neg[^{0}\!$Skier${}_{wt}\,q]]]$ 2. 2)

negate the question Q)

1. G)

$[^{0}{\forall}{\lambda}q\,[{\neg}[^{0}\!$Member-of$\!{}_{wt}$ $q$ ${}^{0}\!$SC$]$ $\vee$ $\neg[^{0}\!$Climber**wt $q$ $]$ $\vee$ $[^{0}\!$Skier${}_{wt}\,q]]]$ 3. 3)

eliminate $\forall$

1. a)

$[[^{0}\!$Member-of$\!{}_{wt}$ ${}^{0}\!$Tom ${}^{0}\!$SC$]$ $\wedge$ $[^{0}\!$Member-of$\!{}_{wt}$ ${}^{0}\!$Peter ${}^{0}\!$SC$]$ $\wedge$

$[^{0}\!$Member-of$\!{}_{wt}$ ${}^{0}\!$John ${}^{0}\!$SC$]]$ 2. b)

$[[^{0}\!$Member-of$\!{}_{wt}$ $x$ ${}^{0}\!$SC$]$ $\supset$ $[[^{0}\!$Skier**wt $x]$ $\vee$ $[^{0}\!$Climber${}_{wt}\,x]]]$ 3. c)

$[[^{0}\!$Climber**wt $y]$ $\supset$ ${\neg}[^{0}\!$Like**wt $y$ ${}^{0}\!$Rain$]]$ 4. d)

$[[^{0}\!$Skier**wt $z]$ $\supset$ $[^{0}\!$Like**wt $z$ ${}^{0}\!$Snow$]]$ 5. e)

$[[[^{0}\!$Like**wt ${}^{0}\!$Tom $u]$ $\supset\neg[^{0}\!$Like**wt ${}^{0}\!$Peter $u]$ $\wedge$

$[\neg[^{0}\!$Like**wt ${}^{0}\!$Tom $u]$ $\supset$ $[^{0}\!$Like**wt ${}^{0}\!$Peter $u]]]$ 6. f)

$[[^{0}\!$Like**wt ${}^{0}\!$Tom ${}^{0}\!$Snow$]$ $\wedge$ $[^{0}\!$Like**wt ${}^{0}\!$Tom ${}^{0}\!$Rain$]]$ 7. G)

$[{\neg}[^{0}\!$Member-of$\!{}_{wt}$ $q$ ${}^{0}\!$SC$]$ $\vee$ $\neg[^{0}\!$Climber**wt $q$ $]$ $\vee$ $[^{0}\!$Skier${}_{wt}\,q]]$ 4. 4)

eliminate $\supset$ from b), c), d), e)

1. a)

$[[^{0}\!$Member-of$\!{}_{wt}$ ${}^{0}\!$Tom ${}^{0}\!$SC$]$ $\wedge$ $[^{0}\!$Member-of$\!{}_{wt}$ ${}^{0}\!$Peter ${}^{0}\!$SC$]$ $\wedge$

$[^{0}\!$Member-of$\!{}_{wt}$ ${}^{0}\!$John ${}^{0}\!$SC$]]$ 2. b)

$[\neg[^{0}\!$Member-of$\!{}_{wt}$ $x$ ${}^{0}\!$SC$]$ $\vee$ $[[^{0}\!$Skier**wt $x]$ $\vee$ $[^{0}\!$Climber${}_{wt}\,x]]]$ 3. c)

$[\neg[^{0}\!$Climber**wt $y]$ $\vee$ ${\neg}[^{0}\!$Like**wt $y$ ${}^{0}\!$Rain$]]$ 4. d)

$[\neg[^{0}\!$Skier**wt $z]$ $\vee$ $[^{0}\!$Like**wt $z$ ${}^{0}\!$Snow$]]$ 5. e)

$[[\neg[^{0}\!$Like**wt ${}^{0}\!$Tom $u]$ $\vee$ $\neg[^{0}\!$Like**wt ${}^{0}\!$Peter $u]$ $\wedge$

$[[^{0}\!$Like**wt ${}^{0}\!$Tom $u]$ $\vee$ $[^{0}\!$Like**wt ${}^{0}\!$Peter $u]]]$ 6. f)

$[[^{0}\!$Like**wt ${}^{0}\!$Tom ${}^{0}\!$Snow$]$ $\wedge$ $[^{0}\!$Like**wt ${}^{0}\!$Tom ${}^{0}\!$Rain$]]$ 7. G)

$[{\neg}[^{0}\!$Member-of$\!{}_{wt}$ $q$ ${}^{0}\!$SC$]$ $\vee$ $\neg[^{0}\!$Climber**wt $q$ $]$ $\vee$ $[^{0}\!$Skier${}_{wt}\,q]]$ 5. 5)

eliminate $\wedge$ from a), e), f); and write down the clauses

1. A1)

$[^{0}\!$Member-of$\!{}_{wt}$ ${}^{0}\!$Tom ${}^{0}\!$SC$]$ 2. A2)

$[^{0}\!$Member-of$\!{}_{wt}$ ${}^{0}\!$Peter ${}^{0}\!$SC$]$ 3. A3)

$[^{0}\!$Member-of$\!{}_{wt}$ ${}^{0}\!$John ${}^{0}\!$SC$]$ 4. B)

$[\neg[^{0}\!$Member-of$\!{}_{wt}$ $x$ ${}^{0}\!$SC$]$ $\vee$ $[^{0}\!$Skier**wt $x]$ $\vee$ $[^{0}\!$Climber**wt $x]]$ 5. C)

$[\neg[^{0}\!$Climber**wt $y]$ $\vee$ $\neg[^{0}\!$Like**wt $y$ ${}^{0}\!$Rain$]]$ 6. D)

$[\neg[^{0}\!$Skier**wt $z]$ $\vee$ $[^{0}\!$Like**wt $z$ ${}^{0}\!$Snow$]]$ 7. E1)

$[\neg[^{0}\!$Like**wt ${}^{0}\!$Tom $u]$ $\vee$ $\neg[^{0}\!$Like**wt ${}^{0}\!$Peter $u]]$ 8. E2)

$[[^{0}\!$Like**wt ${}^{0}\!$Tom $u]$ $\vee$ $[^{0}\!$Like**wt ${}^{0}\!$Peter $u]]$ 9. F1)

$[^{0}\!$Like**wt ${}^{0}\!$Tom ${}^{0}\!$Snow$]$ 10. F2)

$[^{0}\!$Like**wt ${}^{0}\!$Tom ${}^{0}\!$Rain$]$ 11. G)

$[\neg[^{0}\!$Member-of$\!{}_{wt}$ $q$ ${}^{0}\!$SC$]$ $\vee$ $\neg[^{0}\!$Climber**wt $q]$ $\vee$ $[^{0}\!$Skier**wt $q]]$ 6. 6)

goal driven resolution

1. R1)

$\neg[^{0}\!$Climber**wt ${}^{0}\!$Tom$]$ $\vee$ $[^{0}\!$Skier**wt ${}^{0}\!$Tom$]$ G + A1, ${}^{0}\!$Tom/$q$ 2. R11)

$\neg[^{0}\!$Member-of**wt ${}^{0}\!$Tom ${}^{0}\!$SC$]$ $\vee$ $[^{0}\!$Skier**wt ${}^{0}\!$Tom$]$ R1 + B 3. R12)

$[^{0}\!$Skier**wt ${}^{0}\!$Tom$]$ R11) + A1) 4. R13)

$[^{0}\!$Like**wt ${}^{0}\!$Tom ${}^{0}\!$Snow$]$ R12 + D, ${}^{0}\!$Tom/$z$ 5. R14)

$\neg[^{0}\!$Like**wt ${}^{0}\!$Peter ${}^{0}\!$Snow$]$ R13) + E1), ${}^{0}\!$Snow/$u$ 6. R2)

$\neg[^{0}\!$Climber**wt ${}^{0}\!$Peter$]$ $\vee$ $[^{0}\!$Skier**wt ${}^{0}\!$Peter$]$ G + A2, ${}^{0}\!$Peter/$q$ 7. R21)

$\neg[^{0}\!$Member-of**wt ${}^{0}\!$Peter ${}^{0}\!$SC$]$ $\vee$ $[^{0}\!$Skier**wt ${}^{0}\!$Peter$]$ R2 + B 8. R22)

$[^{0}\!$Skier**wt ${}^{0}\!$Peter$]$ R21 + A2) 9. R23)

$[^{0}\!$Like**wt ${}^{0}\!$Peter ${}^{0}\!$Snow$]$ R22 + D, ${}^{0}\!$Peter/$z$

YES R14 + R23

Second Question; Who?

$[\lambda q[[^{0}\!$Like**wt $q$ ${}^{0}\!$Snow$]$ $\wedge$ $\neg[^{0}\!$Like**wt $q$ ${}^{0}\!$Snow$]]$ ${}^{0}\!$Peter$]$ $\lambda$-abstraction of Yes, $q=^{0}\!$Peter

Answer.

Yes, there is a sportsman in the club who is a climber but not a skier. He is Peter.

5 Conclusions

In this paper, we described the hyperintensional system of reasoning over natural language texts. The system makes use of a close cooperation between computational linguistics and logic. We concentrated on two main issues, which to the best of our knowledge are not satisfactorily dealt with in current reasoning systems. First, a fine-grained linguistic and logical analysis of questions and underlying texts is a necessary condition for a high-quality reasoning and answering over the texts. To this end we have applied the Normal Translation Algorithm (NTA), which is a method that integrates logical analysis of sentences with the linguistic approach to semantics. The result of NTA is a corpus of 6,272 TIL constructions analyzed from newspaper text sentences that serve as an input for TIL inference machine. We have applied the procedural approach of TIL together with the algorithm of context recognition in order to implement TIL extensional logic of hyperintensions so that to be able to derive inferential knowledge from explicit knowledge encoded in a wide-range of natural-language resources.

The work is still in progress and the direction for future research is clear. We plan to extend the coverage of the obtained techniques for two languages, Czech and English so that to obtain a bi-lingual system. Here we make use of the definition of procedural isomorphism. Since we explicate structured meanings procedurally, any two terms or expressions, even in different languages, are synonymous whenever they are furnished with procedurally isomorphic constructions as meanings. Yet the clarity of this direction does not imply its triviality. The complexity of the work going into building such a system is almost certain to guarantee that complications we are currently unaware of will crop up. For instance, the rule of co-hyperintensionality, hence of synonymy, has been formulated only conditionally. We define a series of criteria for procedural isomorphism partially ordered according to the degree of their being permissive with respect to synonymy, from the strongest (most restrictive) to the weakest (most liberal), depending on the area and language under scrutiny. Furthermore, we provide good reasons for each of these criteria and specify conditions under which this or that criterion is applicable, for details, see [41].

Acknowledgements

This research has been supported by the Grant Agency of the Czech Republic, project No. 18-23891S, “Hyperintensional Reasoning over Natural Language Texts”, and also by the internal grant agency of VSB-TU Ostrava, project SGS No. SP2018/172, “Application of Formal Methods in Knowledge Modelling and Software Engineering”.