Relationship to Previous Work

The Stanford Encyclopedia of Philosophy entry on argument and argumentation [[ARGUMENTATION]] lists five types of arguments: deduction, induction, abduction, analogy and fallacies. Argumentation can be adversarial where one person tries to beat down another, or cooperative where people collaborate on seeking a better joint understanding by exploring arguments for and against a given supposition. The latter may further choose to focus on developing a consensus view, with the risk that argumentation may result in group polarisation when people's views become further entrenched.

Studies of argumentation have been made by a long line of philosophers dating back to Ancient Greece, e.g. Carneades and Aristotle. More recently, logicians such as Frege, Hilbert and Russell were primarily interested in mathematical reasoning and argumentation. Stephen Toulmin subsequently criticised the presumption that arguments should be formulated in purely formal deductive terms [[TOULMIN]]. Douglas Walton extended tools from formal logic to cover a wider range of arguments [[WALTON]]. Ulrike Hahn, Mike Oaksford and others applied Bayesian techniques to reasoning and argumentation [[HAHN]], whilst Alan Collins applied a more intuitive approach to plausible reasoning [[COLLINS]].

Aristotle provides guidelines for rhetorical arguments in terms of ethos (establishing credibility), pathos (appeal to emotion), logos (appeal to rationality), kairos (opportune arguments with topical references that the given audience will appreciate) together with rhetorical questions chosen to stimulate a discourse, or to draw attention and emphasise specific points. An effective argument will often involve all of these.

Formal approaches to argumentation such as [[ASPIC+]] build arguments from axioms and premises as well as strict and defeasible rules. Strict rules logically entail their conclusions, whilst defeasible rules create a presumption in favour of their conclusions, which may need to be withdrawn in the light of new information. Arguments in support of, or counter to, some supposition, build upon the facts in the knowledge graph or the conclusions of previous arguments. Preferences between arguments are derived from preferences between rules with additional considerations in respect to consistency. Counter arguments can be classified into three groups. An argument can:

• undermine another argument when the conclusions of the former contradict premises of the latter.
• undercut another argument by casting doubt on the link between the premises and conclusions of the latter argument.
• rebut another argument when their respective conclusions can be shown to be contradictory.

[[AIF]] is an ontology intended to serve as the basis for an interlingua between different argumentation formats. It covers information (such as propositions and sentences) and schemes (general patterns of reasoning). The latter can be used to model lines of reasoning as argument graphs that reference information as justfication. The ontology provides constraints on valid argument graphs, for example:

Conflict schemes model how one argument conflicts with another, e.g. if an expert is deemed unreliable, then we cannot rely on that expert's opinions. Preference schemes define preferences between one argument and another, e.g. that expert opinions are preferred over popular opinions. The AIF Core ontology is available in a number of standard ontology formats (RDF/XML, OWL/XML, Manchester OWL Syntax).

PKN defines a simple notation and model for imperfect knowledge. Arguments for and against a supposition are constructed as chains of plausible inferences that are used to generate explanations. PKN draws upon Alan Collins core theory of plausible reasoning [[COLLINS]] in respect to statement metadata corresponding to intuitions and gut feelings based upon prior experience. This is in contrast to Bayesian techniques that rely on the availability of rich statistics, which are unavailable in many everyday situations.

Recent work on large language models (LLMs), such as [[GPT-4]], have shown impressive capabilities in respect to reasoning and explanations. However, there is a risk of hallucinations, where the system presents convincing yet imaginary results. Symbolic approaches like PKN are expected to play an important and continuing role in supporting semantic interoperability between systems and knowledge graphs. LLMs are trained on very large datasets, and in principle, could be exploited to generate symbolic models in a way that complements traditional approaches to knowledge engineering.

Scalar ranges

Some concepts are characterised by a value that lies in a range. Examples include temperature, age and climate. The temperature of a room may be described as cold, warm or hot. Such terms are imprecise and lack a formally agreed definition. Moreover, the meaning may depend on the context. Someone who is 60 years old will have a very different notion of what "old" means compared to that of an eight year old child.

The choice of scales for a range may depend on the application. Here are some examples of scales for different types of climate:

• dry, temperate, continental and polar
• polar, temperate, arid, tropical, mediterranean, mountain
• Hot: equatorial, tropical, subtropical; Temperate: mediterranean. chinese, oceanic, continental; Cold: polar, highland

Each of these terms is associated with typical weather patterns for that climate, e.g. in cities like Shanghai, Buenos Aires, Sydney, and Hong Kong there is a so called Chinese climate with mild winters and humid summers with tropical rain.

This can be modelled using the range property along with a scope. The value of this property is a list of climates. These climates can be treated as arguments for properties that characterise that climate, e.g. in terms of their span on a numerical scale.

Note that descriptions may involve terms describing different aspects, e.g. temperature and humidity, that belong to separate ranges, e.g. cold and wet in contrast to hot and dry.

Here is an example for age that lists terms for describing someone's age, along with the associate span in years:

Fuzzy Modifiers

PKN allows terms to be combined with one or more fuzzy modifiers, e.g. very:old where very acts like an adjective when applied to a noun. The meaning of modifiers can be expressed using PKN statements for relations and implications, together with scopes for context sensitivity. In respect to old, "very" could either be defined by reference to a term such as "geriatric" as part of a range for "age", or with respect to the numerical value, e.g. greater than 75 years old.

Fuzzy Quantifiers

These are quantifiers, such as few, many and most, with an imprecise meaning. See Section [[[#queries]]]. Their meaning can be defined in terms of the length of the list of query variable bindings that satisfy the conditions. few signifies a small number, many signifies a large number, and most signifies that the number of bindings for the where clause is a large proportion of the number of bindings for the from clause.

Add some examples for how to express the meaning of fuzzy modifiers and fuzzy quantifiers.

Is it necessary to predefine the operational meaning of fuzzy quantifiers and fuzzy modifiers? It may be preferable to require applications to define the meaning according to their needs as the meaning is likely to be context sensitive.

Generating Explanations

The inference engine can start with the premise in question and look for direct evidence, and after that, indirect evidence involving inferences using different kinds of PKN statements that pose intermediate premises for consideration. The reasoning process generates a graph that starts from the premises and works back to direct evidence in the knowledge graph. The reasoning graph can then be scanned in the reverse direction to generate explanations that start with the facts and progressively justify the premise via a series of inferences.

The reasoning process can try to support an argument via finding additional evidence, or it can try to generate counter arguments that undermine, undercut or rebut other arguments. The explanation then needs to put these arguments into context using the appropriate templates.

Estimating Certainty

The next few sections describe how PKN statements can be used to compute inferences along with their estimated certainty, as the basis for constructing arguments both for and against a given premise, in terms of chains of inferences.

In probability theory the conditional probability of event A occurring given an occurrence of event B can be expressed using Bayes theorem:

When applied to inferences, this requires the gathering of lots of statistics which is very challenging from a practical perspective. In the absence of comprehensive statistics, the certainty to which the conclusions hold true can be informally modelled as a number in the range 0 to 1. Qualitative terms such as low, medium and high can be mapped to such numbers for use in estimation algorithms, and later when needed, mapped back into qualitative terms.

One such algorithm is where a premise directly matches multiple properties with non-exclusive values, which can then be combined as a set. The more matches, the greater the certainty for establishing the goal.

If c is the average certainty and n is the number of matches, the combined certainty is 1.0 - (1.0 - c)/n. If c = 0.5 and n = 1 we get 0.5. If n = 2, we get 0.75. If n = 4, we get 0.85, If n = 256, we get 0.998.

Collins et al. suggest a simplified approach to modelling the effects of the various metadata parameters in which each parameter strengthens, weakens or has no effect on the estimated certainty, and using the same algorithm for all such parameters.

If the original certainty is zero, the parameters should have no effect, and likewise, the effect of a parameter should be smaller as the parameter’s value tends to zero.

Treating the effect of a parameter as a multiplier m on the certainty, the number should be in the range 0 to 1/c, where c > 0. If we want to boost c by 25% when c = 0.5, m = 1.25, but this should shrink to 1 when c = 1.

How much should m increase as c tends to 0? One idea is to use linear interpolation, i.e., 1.5 when c = 0, 1.25 when c = 0.5 and 1 when c = 1. This multiplier shrinks to 1 as the value of the parameter tends to 0 and when c tends to 0. Thus m = 1 + p/2 - p*c/2, where m is the multiplier, p is the parameter value (0 to 1) and c is the certainty (0 to 1).

We also need to deal with multiple lines of argument for and against the premise in question. If the arguments agree, we can aggregate their certainties using the first algorithm above. We are then left with a fuzzy set for the different conclusions, e.g. (true 0.8, false 0.2). Note that arguments may present multiple conclusions rather than true or false, as depending on the query posed to the reasoner.

Reasoning with Properties and Relations

The reasoner can be given a property or relationship as a premise that we want to find evidence for and against, for instance, here is a premise expressed as a property:

Its inverse would be:

The reasoner first checks if the premise is a known fact, and if not looks for other ways to gather evidence. One tactic is to generalize the property referent, e.g., by replacing it with a variable as in the following:

The knowledge graph provides a matching property statement:

We then look for ways to relate daffodils to temperate flowers, finding a matching relation statement:

So, we have inferred that daffodils grow in England. Another tactic is to generalize the property argument as in the following:

We can then look for ways to relate England to similar countries, for example:

We find then a match, for example:

Thus, providing us with a second way to infer that daffodils grow in England. The certainty depends on the parameters, and the [=similarity=] parameter in respect to the similar-to relation. A further tactic is to generalise the descriptor, i.e. replacing flowers by ?flowers, and then look for evidence that relates to flowers.

If the premise is a property whose referent is a variable, then its binding may combine values from lines of evidence, e.g. roses from one line of reasoning, and daffodils and tulips from another. This depends on the property operator, e.g. [=includes=] supports such combination, whereas [=excludes=] precludes combination.

Whilst the above uses a property as a premise, you can also use relations as premises, for instance:

The reasoner will then look for relevant knowledge on whether Peter is, or is not, young, e.g., Peter’s age, and whether that implies he is a child or an adult, based upon pertinent range statements and associated definitions for their values.

In a small knowledge graph, it is practical to exhaustively consider all potentially relevant inferences. This becomes increasingly costly as the size of the knowledge graph increases. One way to address this challenge is to prioritize inferences that seem more certain, and to ignore those that are deemed too weak.

See [[[#inferences]]] for an illustration of how properties and relations can be plausibly inferred across relation statements such as kind-of depending on the associated metadata. An instance or subclass of a class can plausibly share properties of that class as a specialisation, especially if that instance or subclass is annotated as being typical of that class, see [=typicality=]. Likewise, a class can plausibly share properties of a subclass as a generalisation.

If two concept are similar, then they are likely to share the same properties according to their degree of [=similarity=]. You can restrict this to a named context, e.g. as in:

Here are some examples of PKN relationships with their meaning, and whether the meaning is symmetric or asymmetric.

The reasoner can exploit built-in tactics for reasoning, but it would also be interesting to provide a declarative means to describe such tactics, for instance, as an enabler for machine learning.

Reasoning with Implications

Implication rules are conditioned on conjunctions of antecedents, which can be properties or relations, see the folowing example.

Disjunctions can be modelled using multiple implications. Negatives can expressed using antonyms (terms with an opposite meaning to a given term). The [=strength=] parameter describes the conditional likelihood of the consequents given the antecedents, whilst [=inverse=] describes the conditional likelihood of the antecedents given the consequents.

An implication can be chosen for consideration when one of its consequents matches a premise in question, the reasoner then needs to seek evidence to establish all of the antecedents before binding any variables in that premise and updating its estimated certainty. A similar process applies when using the implication in reverse.

Reasoning with Analogies

Analogies involve comparisons between things or objects where similarities in some respects can suggest the likelihood of similarities in other respects, for instance, in their respective properties and relationships, or in ways to solve related problems. Gentner and Markman proposed a basis for modelling analogies in terms of establishing a structural alignment based on common relational structure for two representations, where the stronger the match, the better the analogy, see [[[GENTNER]]].

In some cases, the objects may have the same properties, in other cases, there is a systematic mapping between different properties, e.g., relating electric current to the flow of a liquid in a pipe, and correspondingly, voltage to pressure. If you know that flow increases with pressure, you can infer that current increases with voltage.

Analogical reasoning tests often take the form of A is to B as X is to —, where students are asked to supply the missing term. This can be readily modelled using PKN, for example consider the query:

when applied to the knowledge:

The reasoner finds that leaf is related to tree via the part-of relationship, and can then use that to look for a part-of relationship involving petal, yielding the result flower. Now consider:

when applied to the knowledge:

This gives the answer hate by matching the object of the relationship rather than the subject. Here is a more complex example showing the output from the reasoner:

PKN also allows you to reason from known analogies, e.g. given:

The reasoner can then infer the following:

Analogies involve a form of inductive reasoning, and is related to learning from examples, and being able to apply past experience to a new situation based upon noticing the similarities and reasoning about the differences. Such reasoning can be simple as in the above examples or more complicated, for instance, when involving causal modelling.

Reasoning with Queries

Query statements are loosely analogous to SPARQL for RDF graphs. The reasoner seeks evidence to bind the quantified variables and applies the quantifier to generate the query results. Consider the example:

when applied to the following facts:

The variable ?x binds to 3 kinds of yellow roses out of a total of 10 known varieties of roses, so for this dataset at least, the query evaluates to true as 3 is small compared to 10. For more details, see Section [[[#queries]]].

Further work is needed to support queries involving superlatives, e.g. what is the highest mountain in the world?. The associated scalars (in this case "height") may be associated with antonyms, e.g. low/high, short/tall, small/large. A counter example is "sweetness", i.e. how sugary some drink or food is perceived to be. We can ask which is the sweetest fruit, but there is no word that describes its opposite. In principle, such queries could be enabled through statements that declare the superlative for a given term, e.g. shortest is-superlative-for short.

Reasoning about Graphs

Consider the statement: "Mary thinks John loves Joan". We can model this using a graph for Mary's beliefs as the object of a relation:

Here is a more complicated example "Mary thinks John is lying when he says he loves Joan"

Sometimes it will be more convenient to define a named collection of statements, and use the name to refer to them from PKN statements.

Here is an example of a query involving a graph:

where the answer “Sue” is found by searching through the graph named “g2”.

A more complex case is where reasoning is in the context of a fictional world in which some things are specific to that world whilst most things are the same as in our world. An example is the world of the Harry Potter novels where magic is real, but only some people can use it. This then involves reasoning across multiple graphs according to their relationships. This is also the case for reasoning about the future, e.g. when developing plans for how to achieve a goal, and for abductive reasoning about the likely causes of some observations, where we need to deal with what might be true given some plausible assumptions.

Assessing Multiple Lines of Argumentation

PKN reasoners can generate arguments for and against a given premise, where each argument is formed from a chain of plausible inferences. The reasoning process estimates the certainty of each argument. Arguments can be grouped for the purposes of generating explanations from the argument graph. If the certainties for and against the premise are roughly similar, then the users are left to draw their own conclusions. The reasoner should provide further details when asked.

Where Next?

An open challenge is how to declaratively model strategies and tactics for reasoning rather than needing to hard code them as part of the reasoner's implementation. Further work is needed to clarify the requirements and to evaluate different ways to fulfil those requirements using an intuitively understandable syntax. The [[AIF]] ontology would be a useful source of inspiration.

This raises the question of how enable machine learning for both knowledge graphs and reasoning strategies and tactics.

Advances in large language models have shown impressive reasoning capabilities and can readily handle complex higher order statements, such as above. This suggests that large scale machine learning is much more tractable using vector space representations instead of symbolic graphs. On the other hand, symbolic knowledge has a continuing role in relation to transparency and semantic interoperability. How can the two approaches be combined to support collaborative knowledge engineering using neurosymbolic information systems?