A Computational-Hermeneutic Approach for Conceptual Explicitation

TL;DR

This paper introduces a computational hermeneutic method that formalizes natural-language argumentative discourse using higher-order logics, enabling explicit conceptual analysis through iterative, multi-layered reasoning.

Contribution

It presents a novel, automated approach combining formal logic and argumentative networks for explicit conceptual explication in discourse analysis.

Findings

Operates on networks of structured arguments

Iterative two-layered formalization process

Logical theory evolves through inferential adequacy

Abstract

We present a computer-supported approach for the logical analysis and conceptual explicitation of argumentative discourse. Computational hermeneutics harnesses recent progresses in automated reasoning for higher-order logics and aims at formalizing natural-language argumentative discourse using flexible combinations of expressive non-classical logics. In doing so, it allows us to render explicit the tacit conceptualizations implicit in argumentative discursive practices. Our approach operates on networks of structured arguments and is iterative and two-layered. At one layer we search for logically correct formalizations for each of the individual arguments. At the next layer we select among those correct formalizations the ones which honor the argument's dialectic role, i.e. attacking or supporting other arguments as intended. We operate at these two layers in parallel and continuously rate sentences' formalizations by using, primarily, inferential adequacy criteria. An interpretive, logical theory will thus gradually evolve. This theory is composed of meaning postulates serving as explications for concepts playing a role in the analyzed arguments. Such a recursive, iterative approach to interpretation does justice to the inherent circularity of understanding: the whole is understood compositionally on the basis of its parts, while each part is understood only in the context of the whole (hermeneutic circle). We summarily discuss previous work on exemplary applications of human-in-the-loop computational hermeneutics in metaphysical discourse. We also discuss some of the main challenges involved in fully-automating our approach. By sketching some design ideas and reviewing relevant technologies, we argue for the technological feasibility of a highly-automated computational hermeneutics.

Figures

Full text

“…that the same way that the whole is, of course, understood in reference to the individual, so too, the individual can only be understood in reference to the whole.”

Friedrich Schleiermacher (1829)

1 Introduction

Motivated by, and reflecting upon, previous work on the computer-supported assessment of challenging arguments in metaphysics (e.g. [13, 12, 33]), we have engaged in the development of a systematic approach towards the logical analysis of natural-language arguments amenable to (partial) automation with modern theorem proving technology. In previous work [35, 36] we have presented some case studies illustrating a computer-supported approach, termed computational hermeneutics, which has the virtue of addressing argument formalization and assessment in a holistic way: The adequacy of candidate formalizations for sentences in an argument is assessed by computing the logical validity of the argument as a whole (which depends itself on the way we have so far formalized all of its constituent sentences). Computational hermeneutics has been inspired by ideas in the philosophy of language such as semantic holism and Donald Davidson’s radical interpretation [27]. It is grounded on recent progresses in the area of automated reasoning for higher-order logics and integrates techniques from argumentation theory [36].

Drawing on the observation that “every formalization is an interpretation”, our approach has initially aimed at fostering human understanding of argumentative (particularly theological) discourse [35, 7]. In the following sections, aside from presenting a more detailed theoretical account of our approach, we want to explore possibilities for further automation, thus gradually removing the human from the loop. In section 2 we introduce the notions of ontology and conceptualization as defined in the fields of knowledge engineering and artificial intelligence. We use this terminological framework to discuss what it means for us to claim that a logical theory can serve to explicitate a conceptualization. In section 3 we discuss what makes our proposed approach hermeneutical. We briefly present a modified account of Donald Davidson’s theory of radical interpretation and relate it to the logical analysis of natural-language arguments, in particular, to the problem of assessing the adequacy of sentences’ formalizations in the context of an argument (network). We show how an interpretive process grounded on the logical analysis of natural-language argumentative discourse will exhibit a (virtuous) circularity, and thus needs to be approached in a mixed recursive–iterative way.

We also illustrate the fundamental role of computers in supporting this process. In particular, by automating the computation of inferential adequacy criteria of formalization, modern theorem proving technology for higher-order logics can provide the effective and reliable feedback needed to make this approach a viable alternative. In section 4 we briefly present an exemplary case study involving the analysis of a metaphysical argument and discuss some technologies and implementation approaches addressing some of the main challenges concerning a highly-automated computational hermeneutics. In particular, we discuss a key technique termed semantical embeddings [10, 4], which harnesses the expressive power of classical higher-order logic to enable a truly logical-pluralist approach towards representing and reasoning with complex theories by reusing state-of-the-art (higher-order) automated reasoning infrastructure.

2 Explicitating Conceptualizations

Computational hermeneutics helps us make our tacit conceptualizations explicit. In this section we aim at building the necessary background to make best sense of this statement. We start with a cursory presentation of the notion of an ontology as used in the fields of artificial intelligence and knowledge engineering. We introduce some of the definitions of (an) ontology drawing on the concept of conceptualization (this latter notion being the one we are mostly interested in). We then have a deeper look into the notion of conceptualizations and how they can be explicitly represented by means of a logical theory.

2.1 Ontologies and Meaning Postulates

Ontology is a quite overloaded term, not only in its original philosophical scope, but also in computer science. Trying to improve this situation, researchers have made the apt distinction between “Ontology” and “an ontology” [42]. The term “Ontology” refers to the philosophical field of study, which will not be considered in this paper. Regarding the latter term (“an ontology”) several authoritative definitions have been put forward during the nineties. We recall some of them: Tom Gruber originally defines an ontology as “an explicit specification of a conceptualization” [41]. This definition is further elaborated by Studer et al. [54] as “a formal, explicit specification of a shared conceptualization”, thus emphasizing the dimensions of intersubjective conspicuousness and representability by means of a formal language. Nicola Guarino, a pioneer advocate of ontologies in computer science, has depicted an ontology as “a logical theory which gives an explicit, partial account of a conceptualization” [42], thus emphasizing an aspect of insufficiency: an ontology can only give a partial account of a conceptualization.

These definitions duly highlight the aspect of explicitness: By means of the articulation in a formal language, an ontology can become common and conspicuous enough to fulfill its normative role —as public standard— for the kind of systems developed in areas like knowledge engineering and, more recently, the Semantic Web. More technically, we see that an ontology (at least in computer science) can be aptly considered as a kind of logical theory, i.e. as a set of sentences or formulas. The question thus arises: Which particular formal properties should the sentences comprising a logical theory have in order to count as an ontology? To be sure, the logical theory may feature some particular annotation or indexing schema distinguishing ‘ontological’ sentences from ‘non-ontological’ ones. But other than this there is no clear line outlining the ‘ontological’ sentences in a logical theory.111 This is similar to the distinction between TBox and ABox in knowledge bases. Some may claim that ‘ontological’ sentences (TBox) tend to be more permanent and mostly concern types, classes and other universals; while other, ‘non-ontological’ sentences (ABox) mostly concern their instances. The former may be treated as being always true and the latter as subject to on-line revision. However, what counts as a class, what as an instance and what is subject to revision is heavily dependent on the use we intend to give to the theory (knowledge base).

This issue is reminiscent of the controversy around the old analytic–synthetic distinction in philosophy. We do not want to address this complex debate here. However, we want to draw attention to a related duality introduced by Carnap [24] in his notion of meaning postulates (and its counterpart: empirical postulates). Carnap’s position is that, in order to rigorously specify a language —or a logical theory, for our purposes— one is confronted with a decision concerning which sentences are to be taken as analytic, i.e. which ones we should attach the label “meaning postulate”. For Carnap, meaning postulates are axioms of a definitional nature, which tell us how the meanings of terms are interrelated.222Recalling Carnap’s related notion of explication [23], we can think of a set of meaning postulates as providing a precise characterization for some new, exact concept (explicatum) aimed at “replacing” an inexact, pre-theoretical notion (explicandum), for the purpose of advancing a theory. Thus, in computational hermeneutics, the non-logical terms of our interpretive theory characterize concepts playing the role of explicata aimed at explicitly representing fuzzy, unarticulated explicanda from a tacit conceptualization. They are warranted by an intent to use those terms in a certain way (e.g. to draw some inferences that we accept as valid) rather than by any appeal to facts or observations. In this sense, meaning postulates are to be distinguished from factual assertions, also termed “empirical postulates”. A kind of analytic–synthetic distinction is thus made, but this time by an appeal to pragmatical considerations. Whether a sentence such as “No mammals live in water” is analytic, or not, depends upon a decision about how to use the corresponding concepts in a certain area of discourse; e.g. we may want to favor some inferences and disfavor others (e.g. excluding whales from being considered as mammals). We thus start to see how a listing of meaning postulates can give us some insight into the conceptualization underlying a discourse. Following Carnap, we distinguish in our approach between meaning and empirical postulates. The former are sets of axioms telling us how the meanings of terms are interrelated, and thus constitute our interpretive logical theory. The latter correspond to formalized premises and conclusions of arguments which are to become validated in the context of our theory.

As discussed above, it is rather the intended purpose which lets us consider a logical theory (or a part thereof) as an ontology. We will thus conflate talk of formal ontologies with talk of logical theories for the sake of illustrating our computational-hermeneutic approach.

2.2 Conceptualizations

As seen from the above, definitions of (an) ontology depict a conceptualization, by contrast, as something tacit and unarticulated; as something being hinted at by the use of natural language, instead of being determined by the semantics of a formal one. In the following, we want to evoke this connotation every time we use the term conceptualization simpliciter. Our notion of conceptualization (simpliciter) thus refers to that kind of implicit, unarticulated and to some extent undetermined knowledge being framed by human socio-linguistic practices, and which is to become (partially) represented —and thereby made explicit— by means of a logical theory. In particular, we envisage a certain special —and arguably primordial— kind of socio-linguistic practice: argumentative discourse.

We have a formal definition for the notion of conceptualization starting with Genesereth and Nilsson [39], who state that “the formalization of knowledge in declarative form begins with a conceptualization. This includes the objects presumed or hypothesized to exist in the world and their interrelationships.” In their account, objects “can be anything about which we want to say something.” Genesereth and Nilsson then proceed to formally define a conceptualization as an extensional relational structure: a tuple ${\langle}D,R{\rangle}$ where $D$ is a set called the universe of discourse and $R$ is a collection of relations (as sets of tuples) on $D$. This account of a conceptualization has been called into question because of its restricted extensional nature: A conceptualization, so conceived, concerns only how things in the universe of discourse actually are and not how they could acceptably be interrelated. The structure proposed by Genesereth and Nilsson as a formal characterization of the notion of conceptualization seems to be more appropriate for states of affairs or world-states; a conceptualization having a much more complex (social or mental) nature.

Other, more expressive definitions for the notion of conceptualization have followed. Gruber [41] states that a conceptualization is “an abstract, simplified view of the world that we wish to represent for some purpose”; and Uschold [57] sees a conceptualization as a “world-view”, since it “corresponds to a way of thinking about some domain”. According to the account provided by Guarino and his colleagues [42, 43], a conceptualization “encodes the implicit rules constraining the structure of a piece of reality”. Note that this characterization, in contrast to the one provided by Genesereth and Nilsson, does not talk about how a “piece of reality” actually is, but instead about how it can possibly or acceptably be, according to some constraints set by implicit rules.333 As we see it, those rules are (their tacitness notwithstanding) of a logical nature: they concern which arguments or inferences are endorsed by (a community of) speakers. Guarino has also provided a formal account of conceptualizations, which we reproduce below (taken from [43]). In the following, we distinguish the informal notion of conceptualization simpliciter from the formal, exact concept introduced below. Note that we will always refer to the latter in a qualified form as a formal conceptualization.

Definition 2.1** (Intensional relational structure, or formal conceptualization).**

An intensional relational structure (or a conceptualization according to Guarino) is a triple $C={\langle}D,W,\mathbb{R}{\rangle}$ with

• •

D a universe of discourse, i.e. an arbitrary set of individual entities.

• •

W a set of possible worlds (or world-states). Each world is a maximal observable state of affairs, i.e. a unique assignment of values to all the observable variables that characterize the system.

• •

$\mathbb{R}$* a set of intensional (aka. conceptual) relations. An intensional relation is a function mapping possible worlds to extensional relations on $D$.*

Taking inspiration from Carnap [23] and Montague [28], Guarino takes conceptual (intensional) relations to be functions from worlds to extensional relations (sets of tuples). This account aims at doing justice to the intuition that conceptualizations —being arguably about concepts— should not change when some particular objects in the world become otherwise related. However, formal conceptualizations, while having the virtue of being exactly defined and unambiguous, are just fictional objects useful to clarify the notion of an ontology.

2.3 Representing a Conceptualization by Means of a Theory

For Guarino and his colleagues, the role of formal conceptualizations in the definition of an ontology is that of a touchstone. For them an ontology is —let us recall their definition— “a logical theory which gives an explicit, partial account of a conceptualization” [42]. Thus, an ontology —or more specifically: its models444 When we talk of models of a logical theory or ontology, we always refer to models in a model-theoretical sense, i.e. interpretations: assignments of values (as denoted entities) to non-logical terms.— can only partially represent a conceptualization (formal or simpliciter). In order to evaluate how good a given ontology represents a conceptualization, Guarino has introduced a formal notion of ontological commitment (similar in spirit to the well-known eponymous notion in philosophy). According to Guarino, by using a certain language a speaker commits —even unknowingly— to a certain conceptualization. Such a commitment arises from the fact that, by employing a certain linguistic expression (e.g. a name or an adjective), a language user intends to refer to objects which are part of a conceptualization, i.e. some individual or (conceptual) relation. Those objects may be tacit in the sense that they become presupposed in our inferential practices.555 For instance, the existence of human races may need to be posited for some eugenicist arguments to succeed; or the presupposition of highly-localized specific brain functions may be needed for a phrenology-related argument to get through. When we intuitively accept the conclusions of arguments we may thereby also commit to the existence of their posits (as made explicit in the logical forms of adequate formalizations). Conversely, such arguments can be attacked by calling into question the mere existence of what they posit.

Guarino’s account leaves some room for partiality (incompleteness) in our representations. By interpreting natural language, suitably represented as a logical theory, an interpreter can indeed end up referring to entities other than those originally intended or conceiving them in undesired ways. In such case we would say that some of the models (interpretations) of the theory are not among its intended models (see Fig. 1). In Guarino’s view, what is intended becomes prescribed by the target conceptualization. For instance —to put it in informal terms— the conceptualization I commit to could prescribe that all fishes live in water. However, in one of the possible interpretations (models) of some theory of us (e.g. about pets), which includes the sentence “Nemo lives in the bucket”, the term “Nemo” may refer to an object falling under the “fish” predicate and the expression “the bucket” may refer to some kind of waterless cage. If, in spite of this rather clumsy interpretation, the theory is still consistent, we would say that the theory somehow ‘underperforms’: it does not place enough constraints as to preclude undesired interpretations, i.e. has models which are not intended. Underperforming theories (ontologies) in this sense are more the rule than the exception. Now let us put the previous discussion in formal terms (taken from Guarino et al. [43]):

Definition 2.2** (Extensional relational structure).**

An extensional relational structure, (or a conceptualization according to Genesereth and Nilsson [39]), is a tuple ${\langle}D,R{\rangle}$ where $D$ is a set called the universe of discourse and $R$ is a set of (extensional) relations on $D$.

Definition 2.3** (Extensional first-order structure, or model).**

Let $L$ be a first-order logical language with vocabulary $V$ and $S={\langle}D,R{\rangle}$ an extensional relational structure. An extensional first-order structure (also called model for $L$) is a tuple $M={\langle}S,I{\rangle}$, where $I$ (called extensional interpretation function) is a total function $I:V\rightarrow D\cup R$ that maps each vocabulary symbol of $V$ to either an element of $D$ or an extensional relation belonging to the set $R$.

Definition 2.4** (Intensional first-order structure, or ontological commitment).**

Let $L$ be a first-order logical language with vocabulary $V$ and $C={\langle}D,W,\mathbb{R}{\rangle}$ an intensional relational structure (i.e. a conceptualization). An intensional first-order structure (also called ontological commitment) for $L$ is a tuple $K={\langle}C,\mathbb{I}{\rangle}$, where $\mathbb{I}$ (called intensional interpretation function) is a total function $\mathbb{I}:V\rightarrow D\cup\mathbb{R}$ that maps each vocabulary symbol of $V$ to either an element of $D$ or an intensional relation belonging to the set $\mathbb{R}$.

Definition 2.5** (Intended models of a theory w.r.t. a formal conceptualization).**

Let $C={\langle}D,W,\mathbb{R}{\rangle}$ be a conceptualization, $L$ a first-order logical language with vocabulary $V$ and ontological commitment $K={\langle}C,\mathbb{I}{\rangle}$. A model $M={\langle}S,I{\rangle}$, with $S={\langle}D,R{\rangle}$, is called an intended model of $L$ according to $K$ iff

For all constant symbols $c\in V$ we have $I(c)=\mathbb{I}(c)$ 2. 2.

There exists a world $w\in W$ such that, for each predicate symbol $v\in V$ there exists an intensional relation $\rho\in\mathbb{R}$ such that $\mathbb{I}(v)=\rho$ and $I(v)=\rho(w)$

The set $I_{K}(L)$ of all models of $L$ that are compatible with $K$ is called the set of intended models of $L$ according to $K$.

Definition 2.6** (An ontology).**

Let $C$ be a conceptualization, and $L$ a logical language with vocabulary $V$ and ontological commitment $K$. An ontology $O_{K}$ for $C$ with vocabulary $V$ and ontological commitment $K$ is a logical theory consisting of a set of formulas of $L$, designed so that the set of its models approximates the set $I_{K}(L)$ of intended models of $L$ according to $K$ (see Fig. 1).

Given the definitions above we might conclude, following Guarino, that an ideal ontology is one whose models exactly coincide (modulo isomorphism) with the intended ones. Variations to this ideal would entail (with respect to a formal conceptualization) either (i) incompleteness: the ontology has models that are non-intended, and thus truth in the conceptualization does not entail validity in the ontology (logical theory); or (ii) unsoundness: the ontology rules out intended models. This latter situation is the most critical, since the ontology qua logical theory would license inferences that are not valid in the target conceptualization.666 Guarino further considers factors like language expressivity (richness of logical and non-logical vocabulary) and scope of the domain of discourse in having a bearing on the degree to which an ontology specifies a conceptualization. (See Fig. 1 for a diagrammatic illustration.)

Back to the idea of computational hermeneutics, we concede that there are no means of mechanically verifying coherence with a conceptualization simpliciter, the latter being something tacit, fuzzy and unarticulated. However, we do have the means of deducing and checking consequences drawn from a logical theory, and this is indeed the reason why computational hermeneutics relies on the use of automated theorem proving. Regarding formal conceptualizations, we may have the means of mechanically verifying coherence with them (since they are well-defined mathematical structures), but this would not bring us much further. As mentioned before, a formal conceptualization is a fictional mathematical object, which might at best serve as a model (in the sense of being an approximated representation) for some real —though unarticulated— conceptualization. The notion of formal conceptualization has been brought forth in order to enable the previous theoretical analysis and foster understanding. Hopefully, we can now make better sense of the claim that computational hermeneutics works by iteratively evolving a logical theory towards adequately approximating a conceptualization, thus making the latter explicit.

2.4 An Idealized Interpretive Approach

As illustrated above, in artificial intelligence and knowledge engineering, ontologies correspond to logical theories and introduce a vocabulary (logical and non-logical) together with a set of formalized sentences (formulas). Some of these formulas: axioms, directly aim at ruling out unintended interpretations of the vocabulary so that as many models as possible correspond to those worlds (i.e. maximal states of affairs) compatible with our target (formal) conceptualization. Theorems also do this, but indirectly, by constraining axioms (since the former have to follow from the latter). Hence, an ontology qua logical theory delimits what is possible ‘from the outside’, i.e. it tells us which interpretations of the given symbols (vocabulary) are not acceptable with respect to the way we intuitively understand them. Every time we add a new sentence to the theory we are rejecting those symbols’ interpretations (i.e. models) which render the (now augmented) theory non-valid. Conversely, when removing a sentence some interpretations (models) become acceptable again. We can thus think of a mechanism to iteratively evolve a logical theory by adding and removing axioms and theorems, while getting appropriate feedback about the adequacy of our theory changes. Such a mechanism would converge towards an optimal solution insofar as we can get some kind of quantitative feedback regarding how well the models of our theory are approximating the intended ones (i.e. the target formal conceptualization). As discussed more fully below, this is a quite simplistic assumption. However, it is still worth depicting for analysis purposes as we did for (fictional) formal conceptualizations. This is shown in Fig. 2.

As mentioned before, formal conceptualizations do not exist in real life. We do not start our interpretive endeavors with a listing of all individual entities in the domain of discourse together with the relations that may acceptably hold among them. We have therefore no way to actually determine which are our intended models. In the situation depicted in Fig. 2 we were chasing a ghost. Moreover —to make things more interesting— our conceptualization indeed changes as we move through our interpretive process: We learn more about the concepts involved and about the consequences of our beliefs. We can even call some of them into question and change our minds. Fig. 3 shows a more realistic view of the problem, where we are chasing a moving target.

However, not all hope is lost. In the context of argumentative discourse, we still believe in the possibility of devising a feedback mechanism which can account for the adequacy of our interpretive logical theories. Instead of contrasting sets of models with formal conceptualizations, we will be putting sets of formalized sentences and (extracts from) natural-language arguments side-by-side and then comparing them among different dimensions. Thus, we will be reversing the account given by Guarino and his colleagues, by arguing that conceptualizations first originate (i.e. come into existence in an explicit and articulated way) in the process of developing an interpretive theory. Conceptualizations correspond with ‘objective reality’ to a greater or lesser extent as they license inferential moves which are endorsed by a linguistic community in the context of some argumentative discourse (seen as a network of arguments). The diagram shown in Fig. 4 gives a general idea of our interpretive approach.

3 A Hermeneutic Approach

Argumentative discourse and conceptualizations are two sides of a coin. In the previous section we briefly mentioned the idea of putting logical theories and natural-language arguments side-by-side and then comparing them among different dimensions. One of those dimensions —indeed, the main one— is truth, or more appropriately for arguments: logical correctness.777 Logical correctness encompasses, among others, the more traditional concept of logical validity. Our working notion of logical correctness also encompasses axioms/premises consistency and lack of circularity (no petitio principii) as well as avoiding idle premises. Other accounts may consider different criteria. We have restricted ourselves to the ones that can be efficiently computed with today’s automated reasoning technology. See [50] for an interesting discussion of logical (in)correctness. This idea has been inspired by Donald Davidson philosophy of language, in particular, his notion of radical interpretation. In this section we aim at showing how the problem of formalizing argumentative discourse, understood as networks of arguments mutually attacking and supporting each other, relates to the problem of adequately representing a conceptualization. We share with the supporters of logical expressivism (see e.g. [18, 48]) the view that logical theories are means to explicitly articulate the rules implicit in discursive practices.

3.1 Hermeneutic Circle

Previously, we hinted at the possibility of a feedback mechanism that can account for the adequacy of our interpretive logical theories. We commented on the impossibility of directly contrasting the models of our theories with the target conceptualization (determining the theory’s intended models), which would have given us a straightforward search path for the ‘best’ theory (see Fig. 2). The main difficulty is that, aside from their complex tacit nature, conceptualizations are also a moving target (as shown in Fig. 3). Our conceptualizations are work in progress and continually change as we take part in socio-linguistic practices, especially argumentation. We may thus call them working conceptualizations, since they are invariably subject to revision. This can be seen both at the individual and societal level. For instance, when we as understanding agents become more aware of (or even learn something new about) our concepts and beliefs. As a community of speakers, through interpretive reconstruction of public discourse, we can become more self-conscious of our tacit conceptualizations as framed by prevalent discursive practices, thus enabling their critical assessment and eventual revision.888Sharing a similar background and motivation, computational hermeneutics might support a technological implementation of contemporary approaches for the revisionary philosophical analysis of public discourse like ameliorative analysis (in particular, as presented in [47]), conceptual ethics [22], and conceptual engineering (e.g. as discussed in [20]).

Adhering to the slogan: “Every formalization is an interpretation”, the logical analysis of arguments becomes essentially an interpretive endeavor. A characteristic of this endeavor is its recursive, holistic nature. The logical forms —as well as the meanings— of the individual statements comprising an argument (network) are holistically interconnected. At any point in our interpretive process, the adequacy of the formalization of some statement (sentence) will hinge on the way other related sentences have been formalized so far, and thus depend on the current state of our interpretive theory, i.e. on our working conceptualization. Donald Davidson aptly illustrates this situation in the following passage [26, p. 140].

“…much of the interest in logical form comes from an interest in logical geography: to give the logical form of a sentence is to give its logical location in the totality of sentences, to describe it in a way that explicitly determines what sentences it entails and what sentences it is entailed by. The location must be given relative to a specific deductive theory; so logical form itself is relative to a theory.”

We thus conceive this hermeneutic interpretive endeavor as a holistic, iterative enterprise. We start with tentative, simple candidate formalizations of an argument’s statements and iteratively use them as stepping stones on the way to the (improved) formalization of others. The adequacy of any sentence’s formalization becomes tested by evaluating the logical correctness of the formalized arguments (from which it is a component). Importantly, evaluating logical correctness is a holistic operation that involves all of an argument’s constituent sentences. That is, the result of any formalization’s adequacy test becomes dependent not only upon the choice of the particular formula that is put to the test, but also upon previous formalization choices for its companion sentences in the arguments composing a discourse (i.e. an argument network). Moreover, the formalization of any individual sentence depends (by compositionality) on the way its constituent terms have been explicated (using meaning postulates). Thus, our approach does justice to the inherent circularity of interpretation, where the whole is understood compositionally on the basis of its parts, while each part can only be understood in the context of the whole. In the philosophical literature (particularly in [37]) this recursive nature of interpretation has been termed: the hermeneutic circle.

3.2 Radical Interpretation

By putting ourselves in the shoes of an interpreter aiming at ‘translating’ some natural-language argument into a formal representation, we have had recourse to Donald Davidson’s philosophical theory of radical interpretation [27]. Davidson builds upon Quine’s account of radical translation [51], which is an account of how it is possible for an interpreter to understand someone’s words and actions without relying on any prior understanding of them.999 In this sense, Davidson has emphatically made clear that he does not aim at showing how humans actually interpret let alone acquire natural language. This being rather a subject of empirical research (e.g. in cognitive science and linguistics) [25]. However, Davidson’s philosophical point becomes particularly interesting in artificial intelligence, as regards the design of artificial language-capable machines. Since the radical interpreter cannot count on a shared language for communication nor the help of a translator, she cannot directly ask for any kind of explanations. She is thus obliged to conceive interpretation hypotheses (theories) and put them to the test by gathering ‘external-world’ evidence regarding their validity. She does this by observing the speaker’s use of language in context and also by engaging in some basic dialectical exchange with him/her (e.g. by making utterances while pointing to objects and asking yes–no kind of questions).

Davidson’s account of radical interpretation builds upon the idea of taking the concept of truth as basic and extracting from it an account of interpretation satisfying two general requirements: (i) it must reveal the compositional structure of language, and (ii) it can be assessed using evidence available to the interpreter. The first requirement (i) is addressed by noting that a theory of truth in Tarski’s style [56] (modified to apply to natural language) can be used as a theory of interpretation. This implies that, for every sentence s of some object language L, a sentence of the form: ¡¡“$s$” is true in $L$ iff $p$¿¿ (aka. T-schema) can be derived, where p acts as a translation of s into a sufficiently expressive language used for interpretation (note that in the T-schema the sentence $p$ is being used, while $s$ is only being mentioned). Thus, by virtue of the recursive nature of Tarski’s definition of truth, the compositional structure of the object-language sentences becomes revealed. From the point of view of computational hermeneutics, the sentence s is to be interpreted in the context of a given argument (or a network of mutually attacking/supporting arguments). The language L thereby corresponds to the idiolect of the speaker (natural language), and the target language is constituted by formulas of our chosen logic of formalization (some expressive logic XY) plus the meta-logical turnstyle symbol  $\vdash_{\rm XY}$ signifying that an inference (argument or argument step) is valid in logic XY. As an illustration, consider the following instance of the T-schema:

¡¡“Fishes are necessarily vertebrates” is true [in English, in the context of argument A] iff $A_{1},A_{2},...,A_{n}\ \vdash_{\rm MLS4}$ “${\forall}x{.}\ \textit{Fish(x)}\ {\rightarrow}\ {\Box}\textit{Vertebrate(x)}$”¿¿

where $A_{1},A_{2},...,A_{n}$ correspond to the formalization of the premises of argument A and the turnstyle $\vdash_{\rm MLS4}$ corresponds to the standard logical consequence relation in the chosen logic of formalization, e.g. a modal logic S4 (MLS4).101010 As will be described in section 4.1, the semantical embeddings approach [10, 4] allows us to embed different non-classical logics (modal, deontic, intuitionistic, etc.) in higher-order logic (as meta-language), and to combine them dynamically by adding and removing axioms. This toy example aims at illustrating how the interpretation of a statement relates to its logic of formalization and to the inferential role it plays in a single argument. Moreover, the same approach can be extended to argument networks. In such cases, instead of using the notion of logical consequence (represented above as the parameterized logical turnstyle $\vdash_{\rm XY}$), we can work with the notion of argument support. It is indeed possible to parameterize the notions of support and attack common in argumentation theory with the logic used for argument’s formalization [36].

The second general requirement (ii) of Davidson’s account of radical interpretation states that the interpreter has access to objective evidence in order to judge the appropriateness of her interpretation hypotheses, i.e., access to the events and objects in the ‘external world’ that cause statements to be true —or, in our case, arguments to be valid. In our approach, formal logic serves as a common ground for understanding. For instance, computing the logical validity (or a counterexample) of a formalized argument constitutes the kind of objective —or more appropriately: intersubjective— evidence needed to ground the adequacy of our interpretations, under the charitable assumption that the speaker (i.e. whoever originated the argument) follows, or at least accepts, similar logical rules as we do. In computational hermeneutics, the computer acts as an (arguably unbiased) arbiter deciding on the correctness of arguments in the context of some encompassing argumentative discourse —which itself tacitly frames the conceptualization that we aim at explicitating.

3.3 The Principle of Charity

A central notion in Davidson’s account of radical interpretation is the principle of charity, which he holds as a condition for the possibility of engaging in any kind of interpretive endeavor. The principle of charity has been summarized by Davidson by stating that “we make maximum sense of the words and thoughts of others when we interpret in a way that optimizes agreement” [27, p. 197]. Hence the principle builds upon the possibility of intersubjective agreement about external facts among speaker and interpreter. The principle of charity can be invoked to make sense of a speaker’s ambiguous utterances and, in our case, to presume (and foster) the correctness of an argument. Consequently, in computational hermeneutics we assume from the outset that the argument’s conclusions indeed follow from its premises and disregard formalizations that do not do justice to this postulate. Other criteria like avoiding inconsistency and petitio principii are also taken into account. At the argument network level, we foster formalizations which honor the intended dialectic role of arguments, i.e. attacking or supporting other arguments as intended.

3.4 Adequacy Criteria of Formalization

We start to see how the problem of formalizing natural-language arguments relates to the problem of explicitating a conceptualization. The interpretive theory that gradually evolves in the holistic, iterative computational-hermeneutic process is composed of those meaning postulates which have become ‘settled’ during the (many) iterations involving arguments’ formalization and assessment: It is a logical theory. Not surprisingly, the quality of our resulting theory will be subordinate to the adequacy of the involved argument formalizations. Since arguments are composed of statements (sentences), the question thus arises: What makes a certain sentence’s formalization better than another? This topic has indeed been discussed sporadically in the philosophical literature during the last decades (see e.g. [16, 53, 32, 19, 3]). More recently, the work of Peregrin and Svoboda [49, 50] has emphasized the role of inferential criteria for assessing the adequacy of argument formalizations. These criteria are quite in tune, because of their inferential nature, with the holistic picture of meaning we present here. Furthermore, they lend themselves to mechanization with today’s automated reasoning technologies. We recall these inferential criteria below (from [50]):

(i) The principle of reliability: “$\phi$ counts as an adequate formalization of the sentence S in the logical system L only if the following holds: If an argument form in which $\phi$ occurs as a premise or as the conclusion is valid in L, then all its perspicuous natural language instances in which S appears as a natural language instance of $\phi$ are intuitively correct arguments.”

(ii) The principle of ambitiousness: “$\phi$ is the more adequate formalization of the sentence S in the logical system L the more natural language arguments in which S occurs as a premise or as the conclusion, which fall into the intended scope of L and which are intuitively perspicuous and correct, are instances of valid argument forms of S in which $\phi$ appears as the formalization of S.” [50, pp. 70-71].

The first principle (i) can be seen as a kind of ‘soundness’ criterion: Adequate formalizations must not validate intuitively incorrect arguments. The second principle (ii) has an analogous function to that of ‘completeness’ criteria: We should always aim at the inferentially most fruitful formalization, i.e. the one which renders as logically valid (correct) the highest number of intuitively correct arguments. Peregrin and Svoboda have proposed further adequacy criteria of a more syntactic nature, considering similarity of grammatical structure and simplicity (e.g. number of occurrences of logical symbols). They are not considered in-depth here. Moreover, many of the ‘settled’ formulas which constitute our interpretive (logical) theory will have no direct counterpart in the original natural-language arguments. They are mostly implicit, unstated premises and often of a definitional nature (meaning postulates). More importantly, Peregrin and Svoboda have framed their approach to logical analysis as a holistic, give-and-take process aiming at reaching a state of reflective equilibrium.111111 The notion of reflective equilibrium has been initially proposed by Nelson Goodman [40] as an account for the justification of the principles of (inductive) logic and has been popularized years later in political philosophy and ethics by John Rawls [52] for the justification of moral principles. In Rawls’ account, “reflective equilibrium” refers to a state of balance or coherence between a set of general principles and particular judgments (where the latter follow from the former). We arrive at such a state through a deliberative give-and-take process of mutual adjustment between principles and judgments. More recent methodical accounts of reflective equilibrium have been proposed as a justification condition for scientific theories [31] and objectual understanding [2], and as a methodology for conceptual engineering [20]. Our work on computational hermeneutics can be seen, relatively speaking, as sketching a possible technological implementation of Peregrin and Svoboda’s (and also Brun’s [20]) ideas. We are however careful in invoking the notion of reflective equilibrium for other than illustrative purposes as we strive towards clearly defined and computationally amenable termination criteria for our interpretive process.121212 There are ongoing efforts on our part to frame the problem of finding an adequate interpretive theory as an optimization problem to be approached by appropriate heuristic methods.

Not surprisingly, such a holistic approach involves, even for the simplest cases, a search over a vast combinatoric of candidate formalizations, whose adequacy has to be assessed at least several hundreds of times, particularly if we take the logic of formalization as an additional degree of freedom (as we do). An effective evaluation of the above inferential criteria would thus involve automatically computing the logical validity and consistency of formalized arguments (i.e. proofs). This is the kind of work automated theorem provers and model finders are built for. The recent improvements in automated reasoning technology (in particular for higher-order logics) constitute the main enabling factor for computational hermeneutics, which would otherwise remain unfeasible if attempted manually (e.g. carrying out proofs by hand using natural deduction or tableaux calculi).

3.5 Computational Hermeneutics

As concerns human-in-the-loop computational hermeneutics, the dialectical exchange between interpreter and speaker depicted above takes place between humans and interactive proof assistants (think of a philosopher-logician seeking to translate ‘unfamiliar’ metaphysical discourse into a ‘familiar’ logical formalism). At any instant during our iterative, hermeneutic process, we will have an evolving set of meaning postulates and a set of further, disposable formulas. We start each new iteration by extending our working interpretive theory with some additional axioms and theorems corresponding to the candidate formalization of some chosen argument.131313 Recall that we think of discourses as networks of mutually supporting/attacking arguments. Each formalized argument can be seen as a collection of axioms and theorems; the latter being intended to logically follow from a combination of the former plus some further axioms of a definitional nature (meaning postulates). This view is in tune with prominent structured approaches to argumentation in artificial intelligence (cf. [14, 30]). In other words, our theory has been temporarily extended with additional axioms and (possible) theorems corresponding to the formalizations of an argument’s premises and conclusion(s) respectively. This (extended) theory is most likely to not be logically correct. It is now our task as (human or machine) interpreters to come up with the missing axioms that would validate it without rendering it inconsistent or question-begging, among others. By doing so, we engage in a dialectical exchange with the computer. The questions we ask concern, among others, the logical correctness (validity, consistency, non-circularity, etc.) of the so extended formal arguments. Harnessing the latest developments in (higher-order) theorem proving, such questions can get answered automatically in milliseconds.

During the process of securing logically correct formalizations for each of the arguments in the network, we continuously select among the collected formulas the ones most adequate for our purposes. For this we draw upon the inferential adequacy criteria presented above —eventually resorting to further discretionary qualitative criteria. A subset of the formulas will thus qualify for meaning postulates and are kept for future iterations, i.e. they become ‘settled’.141414 As mentioned in section 2.1, there is no definitive criteria for distinguishing meaning postulates from others (cf. ontological vs. non-ontological or TBox vs. ABox sentences). The heuristics for labeling sentences as meaning postulates thus constitute another degree of freedom in our interpretive process, which we address primarily (but not exclusively) by means of inferential adequacy criteria. Moreover, our set of meaning postulates can at some point become inconsistent, thus urging us to mark some of them for controlled removal. In this aspect, our approach resembles reason-maintenance and belief-revision frameworks (cf. [29]). Those meaning postulates can be identified with an ontology as described in section 2.1. They introduce semantic constraints aimed at ensuring that any instantiation of the non-logical vocabulary is in line with our working conceptualization (i.e. with our tacit understanding of the real-world counterparts these symbols are intended to denote). This is the way argument analysis helps our interpretive theories evolve towards better representing the conceptualization implicit in argumentative discourse.

Removing the human from the loop would, arguably, leave us with an artificial language-capable system. However, to get there we first need to find a replacement for human ingenuity in the most important ‘manual’ steps currently involved in the human-in-the-loop process: (i) generating a rough and ready initial formalization for arguments (which we may call “bootstrapping”); and (ii) the abductive process of coming up with improved candidate formalizations and implicit premises. Not surprisingly, these are very difficult tasks; however, they do not belong to science-fiction. Current developments in natural language processing and machine learning are important enablers for pursuing this ambitious goal. Another important aspect for both human-in-the-loop and fully-automated computational hermeneutics is the availability of databases of natural-language arguments tagged as either correct or incorrect, as the case may be. After choosing the area of discourse whose conceptualization we are interested in, we proceed to gather relevant arguments from the relevant databases and form an argument network with them.151515 Argument databases and arguments extracted from text sources usually provide information on support and attack relations (see [21, 44] and references therein). Another alternative is to dynamically construct the needed arguments by using the working theory plus hypothetical premises and conclusions as building stones. Those arguments would then be presented, in an interactive way, to the user for rejection or endorsement. This mode of operation would correspond to a kind of inverted (we could call it ‘Socratic’) question-answering system. Note that, in contrast to highly quantitative, big-data approaches, computational hermeneutics engages in deep semantic analysis of natural-language, and thus needs far less data to generate interesting results. As previous case studies for human-in-the-loop computational hermeneutics applied to ontological arguments have shown (see e.g. [35, 36] and section 4.2 below), working with a handful of sentences already provides interesting characterizations (as meaning postulates) for the metaphysical concepts involved, e.g. (necessary) existence, contingency, abstractness/concreteness, Godlikeness, essence, dependence, among others.

4 Examples and Implementation Approaches

In this section we summarily discuss previous case studies and depict technological solutions for the implementation of computational hermeneutics. We start by highlighting the essential role of higher-order automated theorem proving and the related technique of semantical embeddings. We then depict a landscape of different tools and technologies which are currently being tested and integrated to pursue an (increasingly) automated computational hermeneutics.

4.1 Semantical Embeddings

Our focus on theorem provers for higher-order logics is motivated by the notion of logical pluralism: the view that logics are theories of argument’s validity, where different yet legitimate logics may disagree about which argument forms are valid. In order to pursue a truly logical-pluralist approach in computational hermeneutics, it becomes essential that the (candidate) logics of formalization also form part of our evolving logical theory. That is, the logic of formalization needs to find its way into the sentences constituting our interpretive theory. More specifically, the (meta-logical) definitions for the logical vocabulary used to encode argument’s sentences become a further set of axioms which can also be iteratively varied, added and removed as we go. Thus, computational hermeneutics targets the flexible combination of different kinds of classical and non-classical logics (modal, temporal, deontic, intuitionistic, etc.) through the technique of semantical embeddings [10, 4].

The semantical embeddings approach161616Note that this approach is not related to the similarly named notion of word embeddings in natural language processing (NLP). harnesses the expressive power of classical higher-order logic (HOL) —also Church’s type theory [5]— as a meta-language in order to embed the syntax and semantics of another logic as an object language, thereby turning theorem proving systems for HOL into universal reasoning engines [4]. HOL is a logic of functions formulated on top of the simply typed $\lambda$-calculus, which also provides a foundation for functional programming. The semantics of HOL is well understood [6]. A variant of this approach, termed shallow semantical embeddings (SSE), involves the definition of the logical vocabulary of a target logic in terms of the non-logical vocabulary (lambda expressions) of our expressive meta-language (HOL). This technique has been successfully implemented using the interactive proof assistant Isabelle [46].

SSE has been exploited in previous work for the evaluation of arguments in philosophy, particularly in metaphysics [13, 12, 33, 35, 36]. The formal representation of metaphysical arguments poses a challenging task that requires the combination of different kinds of expressive higher-order non-classical logics, currently not supported by state-of-the-art automated reasoning technology. In particular, two of the most well-known higher-order proof assistants: Isabelle and Coq do not support off-the-shelf reasoning with modal logics. Thus, in order to turn Isabelle into a flexible modal logic reasoner we have adopted the SSE approach. Isabelle’s logic (HOL) supports the encoding of sets via their characteristic functions represented as $\lambda$-terms. In this sense, HOL comes with a in-built notion of (typed) sets that is exploited in our work for the explicit encoding of the truth-sets that are associated with the formulas of higher-order modal logic.171717 Note that since Isabelle-specific extensions of HOL (except for prefix polymorphism) are not exploited in our work, the technical framework we depict here can easily be transferred to other HOL theorem proving environments.

As illustrated in Fig. 5 (lines 21-23), we can embed a modal logic in HOL by defining the modal $\Box$ and $\Diamond$ operators as meta-logical predicates in HOL and using quantification over sets of objects of a definite type w, representing the type of possible worlds or world-states. Formula $\Box\varphi$, for example, is modeled as an abbreviation (syntactic sugar) for the truth-set $\lambda w.\forall v.w~{}R~{}v\longrightarrow\varphi v$, where $R$ denotes the accessibility relation associated with the modal $\Box$ operator. All presented equations exploit the idea that truth-sets in Kripke-style semantics can be directly encoded as predicates (i.e. sets) in HOL. Modal formulas $\varphi$ are thus identified with their corresponding truth sets $\varphi_{w\rightarrow o}$ of predicate type $w\rightarrow o$. In a similar vein, first-order predicates (i.e. operating on individuals of type $e$) have type $e{\rightarrow}w{\rightarrow}o$.

The semantic embeddings approach gives us two important benefits: (i) we can reuse existing automated theorem proving technology for HOL and apply it for automated reasoning in non-classical logics (e.g. free [11], modal [10], intuitionistic [9] and deontic [8] logics); and (ii) the logic of formalization becomes another degree of freedom in the development of a logical theory and thus can be fine-tuned dynamically by adding or removing axioms (which are encoded using HOL as a meta-language).

4.2 Example: Logical Analysis of a Metaphysical Argument

A first application of computational hermeneutics for the logical analysis of arguments has been presented in [35] (with its corresponding Isabelle/HOL sources available in [34]). In that work, a modal variant of the ontological argument for the existence of God, introduced in natural language by the philosopher E. J. Lowe [45], has been iteratively analyzed using our computational-hermeneutic approach in a human-in-the-loop fashion and, as a result, a ‘most’ adequate formalization has been found. In each series of iterations (seven in total) Lowe’s argument has been formally reconstructed in Isabelle/HOL employing varying sets of premises and logics, and the partial results have been compiled and presented each time as a new variant of the original argument (starting from Fig. 6 and ending with Fig. 7). In this fashion, Lowe’s argument, as well as our understanding of it, gradually evolves as we experiment with different combinations of definitions, premises and logics for formalization.

Our computational-hermeneutic process starts with an initial, ‘bootstrapped’ formalization. As expected, such a first formalization is often non-well-formed and in most cases logically non-valid; it is generated by manually encoding in an interactive proof assistant (e.g. Isabelle) the author’s natural-language formulation using our logically-educated intuition (and with some help from semantic parsers). After this first step, an interpretive give-and-take process is set in motion, and after a few iterations our candidate formalization starts taking shape, as shown in Fig. 6 where we have validated some of the argument’s partial conclusions, though not the main one (where we get a countermodel from model finder Nitpick[15] in line 51). During this process we apply our human ingenuity to the abductive task of coming up with new formalization hypotheses (i.e. adding, removing and replacing axioms or definitions) and harness the power of Isabelle’s automated reasoning tools to assess their adequacy.

Following the principle of charity, our tentative formalizations (logical theories) should become logically valid and meet some inferential (and sometimes syntactical) criteria to our satisfaction. In our case study, this has happened after the seventh iteration series, as shown in Fig. 7, where the now simplified argument181818In [35] we have produced and discussed other more (or less) complex valid formalizations of this argument before finally settling with the one shown in Fig. 7. is not only logically valid (this happened already after the second iteration series), but also exhibits other desirable features of a more philosophical nature (as discussed in [35]); we speak here of arriving at a state of reflective equilibrium (e.g. following [50, 20]).

In Fig. 7 we can also see how our set of axioms has become split into argument’s premises (lines 26-30) and meaning postulates for its featuring concepts (lines 18-23). Here is also shown (line 23) how one of these postulates corresponds to a (meta-logical) axiom constraining the accessibility relation $R$, thus further framing the logic of formalization (modal logic KB). Note that the (meta-logical) definitions shown in Fig. 5, corresponding to the semantical embedding of modal logic $K$ in Isabelle/HOL, can also be seen as further meaning postulates. This embedding has, indeed, also evolved during the interpretive process. For instance, we had to add at some point the formulas that embed restricted (so-called “actualist”) first-order quantifiers (Fig. 5, lines 30-34), in order to adequately represent the argument (by not trivializing it, as explained in [35]). As a result of this computational-hermeneutic process, we can see how the meanings of some (rather obscure) metaphysical concepts, like “necessary existence”, “contingency”, “abstractness/concreteness”, “metaphysical explanation” and “dependence”, have become explicitated in the form of logical formulas.

In follow-up work [36], we have extended the approach to logical analysis previously sketched in [35] by augmenting it with methods as developed in argumentation theory. The idea is now to consider the dialectic role an argument plays in some larger area of discourse (represented as a network of arguments). We have analyzed the contemporary debate around different variants of Gödel’s ontological argument obtaining some interesting conceptual insights.

4.3 Technological Feasibility and Implementation Approaches

In this last section we want to briefly discuss some design ideas and challenges for a software system aimed at automating our computational-hermeneutic approach. These ideas are currently under development. By sketching a preliminary technological landscape, we argue for the technological feasibility of highly-automated computational hermeneutics in practice. In particular, we want to highlight some of the challenges involved. In Fig. 8, the main component of the system is the so-called “hermeneutic engine” (which will be expanded below in Fig. 9). For the time being let us see it as a black box and discuss its inputs and outputs.

$\bullet$ Input 1: A collection of formalized arguments, i.e. sets of (labeled) formulas. We bootstrap the interpretive process with some initial rough and ready formalizations encoded in a special format for use with automated reasoning tools. We consider in particular the TPTP syntax [55] as it is well supported in most higher-order theorem provers. In order to arrive at these collections of (bootstrapped) formulas from our initial natural-language arguments, we rely on argumentation mining technology [21, 44] and semantic parsers (e.g. the well-known Boxer system [17]). Depending on the technological choices, the output format of such tools will most probably be some kind of first-order representation, e.g. Discourse Representation Structures (DRS) (as in Boxer). We rely on existing tools supporting the conversion between those first-order representations and TPTP syntax.

$\bullet$ Input 2: Abstract argument network, i.e. a graph whose nodes are the labels of the formalized arguments provided in Input 1 and whose edges correspond to attack or support relations. This kind of structures usually constitute the output of argumentation mining software [21, 44].

$\bullet$ Input 3: Lexicons and ontologies play an important role in current approaches to semantic parsing and argumentation mining (e.g. the Boxer system has been extended with entity linking to external ontologies [1, 38]). Furthermore, existing ontologies can serve as sources during the abductive step of coming up with candidate meaning postulates.

$\bullet$ Output: A collection of (improved) argument formalizations, encoded using appropriate expressive logics. Importantly, these formalizations have to be logically correct (in contrast to the initial, bootstrapped ones) and are not restricted to the kind of less-expressive first-order outputs of current semantic parsing technology. During the process, we maintain a set of sentences common to most formalized arguments and scoring well according to our (mostly inferential) adequacy criteria. These sentences are then labeled as meaning postulates. (Recall from section 2.1 that the heuristic to differentiate between meaning and empirical postulates is yet another degree of freedom, which is to be determined on the basis of pragmatic considerations.) In section 2.1 we saw that an ontology (in computer science) can be thought of as a collection of meaning postulates. Thus, the output of our interpretive process can serve to create new domain-specific ontologies or extend existing ones.

Having discussed the inputs and outputs of our core component, we proceed to roughly outlining its operation in Fig. 9.

In a nutshell, the engine adds, removes and modifies the arguments’ formalized sentences (Input 1) so that each argument in the network becomes logically correct, while still fulfilling its intended dialectic role in the network (Input 2). Formalized sentences are continuously rated (and picked out) using the adequacy criteria described above. Computational hermeneutics is thus an iterative and two-layered approach. In one layer we apply a formalization procedure to each individual argument in parallel, which consists in temporarily fixing truth-values and inferential relations among its sentences, and then, after choosing a logic for formalization (i.e. the set of axioms constituting the respective semantical embedding in HOL), working back and forth on the formalization of its premises and conclusions while getting automatic feedback about the adequacy of the current formalization candidate. An adequate formalization is one which renders the argument as logically correct and scores high in some additional criteria (syntactic and inferential). In the next layer we operate at the network level, we continuously choose among the many different combinations of adequate argument formalizations those which honor their intended dialectic roles, i.e. those which render the arguments as successfully attacking or supporting other arguments in the network as intended. Importantly, we work at these two layers in parallel (or by continuously switching between them). In this fashion, by engaging in a methodical ‘trial-and-error’ interaction with the computer, we work our way towards a proper interpretation of a piece of argumentative discourse by circular movements between its parts and the whole. As shown in Fig. 9, the output (and usefulness) of our process consists in generating adequate, logically correct formalizations of natural-language arguments, while at the same time articulating logical formulas serving as meaning postulates for those concepts framed by the argumentative discourse in question. These formulas, following Carnap [23], can be seen as conceptual explications, thereby fulfilling the task of making the discourse’s implicit conceptualization explicit.

5 Conclusion

Guarino et al. [42, 43] saw in their notion of a (formal) conceptualization a touchstone for evaluating how good a given logical theory (i.e. an ontology) models or approximates our conception of reality. As a result of this correspondence with the ‘real world’, inferences drawn using the theory will lead to intuitively correct conclusions. Drawing on Guarino’s exposition and terminology, we have inverted the situation and argued for the thesis that a conceptualization first becomes articulated by explicitly stating a theory. We can even put it more dramatically and say that a conceptualization first comes into existence by its being disclosed through an adequate logical theory (or more specifically: its models).191919 Such a reading would be in tune with strong conceptions of existence drawing on the Quinean slogan “no entity without identity”. For the sake of our self-conscious analysis of socio-linguistic practices, we can at any point during an interpretive endeavor equate a conceptualization with the collection of models of the logical theory under consideration, provided that this theory satisfies certain adequacy criteria. This has lead us to discuss what makes an interpretive, logical theory “adequate” in this sense. Drawing upon a holistic view of meaning and logical form, we have approached this issue by considering intersubjective argumentative practices (instead of ‘objective reality’) as our touchstone. That is, the inferences licensed by our adequate theory are to correspond in a way with the inferences (arguments) endorsed by a community of speakers (and always in the context of some specific discourse). We briefly presented Donald Davidson’s account of radical interpretation [27] together with some inferential adequacy criteria of formalization recently proposed in the philosophical literature [50] and discussed how they relate to our approach. In the last section we have presented an exemplary application of (human-in-the-loop) computational hermeneutics and sketched some technical implementation approaches towards its further automation. We showed how current technologies in computational linguistics and automated reasoning enable us to automate many of the tasks involved in our (currently human-supported) computational-hermeneutic approach. Other, difficult to automate tasks, in particular those concerned with abductive reasoning (in higher-order and/or non-classical logics), pose interesting challenges that we will be addressing in future work. There are ongoing efforts to frame our approach in terms of a combinatorial optimization problem. Given the underdetermined, inexact nature of the problem of logical analysis (and the undecidability of theorem proving in higher-order logics), we do not expect exact algorithms to be found and focus primarily on (highly-parallelizable) metaheuristics. The integration of machine learning techniques into our approach, in particular regarding the abductive task of suggesting missing (implicit) argument premises, is also being contemplated.