Representing argumentation schemes with Constraint Handling Rules (CHR)

1.1.Argument from expert witness testimony

The expert witness scheme makes use of two domain-dependent predicates:

The numbers indicate the arity of each predicate. In the presentation of the scheme, the predicates are shown using an infix notation close to natural language.

In the scheme, E and P are scheme variables. P is a second-order variable, ranging over propositions. Notice that the conclusion of the scheme is P. The conclusion does not mention a particular predicate. When the scheme is applied, P is instantiated with a particular proposition, with a particular predicate, and an argument for the proposition P is constructed. The argument constructed can be attacked in the usual ways, with a rebuttal (an argument for some proposition which cannot be accepted if P is accepted, for example ¬P), an undercutter (an argument against the applicability of this argument, for example an argument for E being biased), or a premise defeater (an argument for some proposition contrary to a premise, for example an argument con “E is an expert.”).

The second argumentation scheme we want to discuss is defeasible modus ponens.

1.2.Defeasible modus ponens

Defeasible modus ponens has the same form as modus ponens, except that the conclusion is only presumably true, rather than necessarily true. (The modality, “presumably”, is made explicit in the example only for emphasis. The conclusions of all argumentation schemes are presumably true.) An argument constructed by instantiating this scheme can be attacked in the usual ways, for example by a rebuttal, an argument for ¬Q.

Notice that the major premise of defeasible modus ponens, “if P then Q.”, is not an atomic proposition, but rather a compound proposition built by connecting two propositions, P and Q, using an “if-then” (implication) operator. Thus, P and Q here are once again second-order variables ranging over propositions. The conclusion of the defeasible modus ponens scheme is also a second-order variable, as is the conclusion of the expert witness testimony scheme. In addition, the defeasible modus ponens scheme has a minor premise, P, which is a second-order variable.

Argumentation schemes like these, with second-order variables, are quite common. It is particularly common for the conclusion of schemes to be a second-order variable, as in both of these examples. Other examples include schemes for argument from abduction, analogy, established rule, ethos, ignorance, position to know, and precedent.

We are aware of no computational models of argumentation schemes which are capable of automatically constructing (inventing, generating, deriving) arguments by instantiating second-order schemes such as these. Prior computational models of argumentation schemes are more limited. Either they are used to check whether existing arguments match the form of a given scheme, as in Aracauria [18], are restricted to propositional (fully instantiated) schemes, as in ArguMed [21], are not defined in sufficient detail to know whether second-order variables are supported, e.g. Pollock’s OSCAR system [16], are mathematical models which leave too many details unspecified to be sufficient as a specification for implementing an inference engine, such as ASPIC+11 [17], or are based on logic programming methods enabling only first-order argumentation schemes to be used to automatically construct arguments, such as Assumption-Based Argumentation (ABA) [8] and earlier versions of Carneades [10].22

To understand more clearly the difficulties in representing argumentation schemes using Horn clause logic, the subset of first-order logic used by logic programming languages such as Prolog, let us see how far we can get in representing the scheme for arguments from expert witness testimony in Prolog. Let us first represent, as Prolog “facts”, the following assumptions about a case:

expert(john).
asserts(john, caused_by(global_warming, humans)).

Given these facts, the challenge is to represent the expert witness scheme as a single Prolog rule (Horn clause), in such a way that the following query can be proven by Prolog, answering yes:

?- caused_by(global_warming, humans).

The above representation of the assumptions already shows how one hurdle can be overcome. Although Horn clause logic is a subset of first-order logic, it is possible to represent second-order propositions about atomic formulas, such as global warming being caused by humans here, by reifying such atomic formulas as terms. So far, so good.

But how can the expert witness scheme be represented? Here is one approach, suggested to me by Trevor Bench-Capon but also used by ABA [8, 200–201]:

holds(P) :- asserts(E,P), expert(E).

The idea here is to represent the second-order conclusion, P, of the scheme with a first-order atomic formula, holds(P), by introducing a unary holds predicate. This approach attempts to reduce general inference rules, with premises and second-order variables, to first-order axioms, i.e. inference rules with no premises and only first-order variables in the conclusion. That is, strictly speaking there are no premises in this Horn clause representation of the inference rule, because a Horn clause is a first-order formula. The :- symbol in the clause represents the material conditional logical connective, not a deducibility relation.

While axioms can be viewed as a basic form of inference rule, the attempt to represent more general inference rules using a holds predicate like this has severe limitations. Since we will want to be able to chain arguments together, by using argumentation schemes to construct arguments for the premises of other arguments, we need some way to convert atoms of the form holds(P) to P, so that premises can be matched (unified) with P. It may seem that one way to achieve this would be to add an additional rule for each predicate, as in the following examples:

expert(P) :- holds(expert(P)).
asserts(E,P) :- holds(asserts(E,P)).
caused_by(X,Y) :- holds(caused_by(X,Y)).

From a knowledge-representation point of view, this seems rather verbose and cumbersome, but presumably these additional rules could be generated automatically, using some kind of preprocessor. However this approach suffers from a more serious problem: Such a rule would need to be generated for every predicate in the application domain, and thus every goal would match the conclusion of every argumentation scheme with a second-order variable as its conclusion, due to Prolog’s goal-directed, backwards-chaining control strategy, causing the search space to become infinite. Thus many (not all) queries will cause the inference engine to enter an endless loop and fail to terminate, depending on the order of facts and rules. Suppose, for example, the Prolog program consists only of the following rules, without any facts:

holds(P) :- asserts(E,P),expert(E).
expert(E) :- holds(expert(E)).
asserts(E,P) :- holds(asserts(E,P)).
caused_by(X,M) :- holds(caused_by(X,M)).

With these clauses, the following query causes an endless loop and runs out of stack space:

?- caused_by(global_warming,humans).
ERROR: Out of local stack

It is clear why this happens: The query causes an endless loop between the holds and asserts rules:

Since this encoding of argumentation schemes requires the definition of every predicate to have an additional holds rule, many queries will not terminate in this way, making this encoding useless in combination with Prolog’s simple depth-first, backwards-chaining control strategy. Notice that the example query will not terminate no matter how the clauses of the program are ordered, because the program contains no facts. While the program can be made to terminate for this particular goal (query) by adding sufficient facts before the rules, this would not be a general solution to the control problem, not even for other queries using the same rules, because one cannot assume that there are sufficient facts to answer every query affirmatively.

The event calculus [14] uses a holds predicate for a similar but more limited purpose, for reasoning about the effects of actions using Prolog. It does not suffer from the control issues discussed here, because the holds predicate is used in a more focused way only for a subset of the predicates, called fluents, which are state-dependent in the domain model. These fluents are queried only using the holds predicate. They are never mapped to object-level predicates in the way suggested above.

There is one final and fatal problem with representing argumentation schemes directly in Prolog this way that is important to mention: no arguments are constructed! Thus there is no way to resolve conflicts among arguments, to balance arguments or to use the arguments to help understand or explain the results, for example using argument diagrams.

All of these problems might be overcome by writing a meta-interpreter for argumentation schemes in Prolog, but this would be using Prolog in its capacity as a general-purpose programming language, rather than as an inference engine for Horn clause logic. Some expert system shells, in particular APES [13], were implemented as meta-interpreters in Prolog. APES was able to generate explanations which can be viewed as arguments from the traces of rule applications [4]. However rules in APES were Horn clauses and could not represent argumentation schemes with second-order variables, for the reasons discussed above, and also did not generate counterarguments or use a structured model of argument to resolve attack relations among arguments. The alternative approach we investigate in this paper, using Constraint Handling Rules to represent argumentation schemes, can also use Prolog as an implementation language. Indeed several implementations of Constraint Handling Rules in Prolog exist and we make use of the one provided by SWI Prolog.

As suggested in the previous paragraph, this paper explores the idea of representing argumentation schemes using another kind of rule-based programming, Constraint Handling Rules, introduced by Thom Frühwirth in 1991 [9], to overcome all of the problems identified above by meeting the following requirements:

The rest of this article is organized as follows. Section 2 introduces Constraint Handling Rules, including examples. Section 3 shows one way to represent argumentation schemes using Constraint Handling Rules, in such as way as to generate arguments and overcome the other problems identified in this introduction. The section also briefly describes two implementations of this approach, one using the Constraint Handling Rules interpreter provided as a library by SWI Prolog and the second based on our custom implementation of Constraint Handling Rules in the Go programming language. Section 4 validates the rule language by demonstrating how to use it to represent twenty argumentation schemes, selected by Douglas Walton as being representative and widely used. Finally, Section 5 presents our conclusions and summarizes the main results.

4.1.Abductive argumentation scheme

    id: abduction
    variables: [S,T,H]
    premises:
      - observed(S)
      - explanation(T,S)
      - in(T,H)
    conclusions:
      - H
    exceptions:
      - more_coherent_explanation(T,S)

4.2.Argument from analogy

    id: analogy
    variables: [C,A]
    premises:
      - similar_case(C)
      - in_case(A,C)
    conclusions:
      - A
    exceptions:
      - relevant_differences(C)
      - more_on_point(A,C)

In our reconstruction of the scheme from analogy, an implicit current case is compared to the precedent case, C. The first premise checks whether the precedent is similar to the current case, and the second premise checks that a given statement, A, is true in the precedent case. The first exception, modelling the first critical question, asks whether there are relevant differences between the current case and the precedent. The second exception asks whether there is a more on point case than C in which A is not true. The second critical question is not modeled explicitly, since it merely reiterates the second premise, asking whether the statement is really true in the precedent.

4.3.Argument from appearance

    id: appearance
    variables: [O,C]
    premises:
      - looks_like(O,C)
    conclusions:
      - instance(O,C)

4.4.Argument from cause to effect

    id: cause_to_effect
    variables: [A,B]
    premises:
      - causes(A,B)
      - has_occurred(A)
    conclusions:
      - will_occur(B)
    exceptions:
      - interference(A)

The first two critical questions are not explicitly included in the reconstruction, because they both attack the first premise, rather than articulating exceptions (undercutters) or assumptions. Premise attacks and rebuttals are modeled with separate argumentation schemes, rather than by exceptions and assumptions of a scheme.

4.5.Argument from correlation to cause

    id: correlation_to_cause
    variables: [E1,E2]
    premises:
      - correlated(E1,E2)
    conclusions:
      - causes(E1,E2)
    assumptions:
      - explanatory_theory(E1,E2)
    exceptions:
      - causes_both(E1,E2)

4.6.Argument from defeasible modus ponens

   id: defeasible_modus_ponens
   variables: [A,B]
   premises:
     - implies(A,B)
     - A
   conclusions:
     - B

In the original version, the ⇒ symbol denotes a defeasible conditional, not a strict (material) conditional. Similarly, in the reconstruction the implies predicate also is intended to denote a defeasible conditional.

4.7.Argument from definition to verbal classification

    id: definition_to_verbal_classification
    variables: [O,G,D]
    premises:
      - satisfies_definition(O,D)
      - classified_as(D,G)
    conclusions:
      - instance(O,G)
    exceptions:
      - inadequate_definition(D,G)

4.8.Argument from established rule

The version of the argument from established rule we use here is from [22]. No critical questions were formulated for this version of the scheme.

    id: established_rule
    variables: [C,R]
    premises:
      - has_conclusion(R,A)
      - applicable(R)
    conclusions:
      - A
    assumptions:
      - valid(R)

In our reconstruction of the scheme for argument from established rule, the facts and case have been abstracted away, using an applicable predicate, which is intended to mean that the rule R applies to the facts of the current case. Notice that we have added an assumption for questioning the validity of the rule, which was not formulated in the original version.

4.9.Ethotic argument

The first scheme for ethotic arguments, ethotic1, has a second-order variable, S, as its conclusion. The conclusion ¬S, of the second scheme, ethotic2, however, is, a first-order atomic proposition, with ¬ being a unary predicate symbol, not a logical operator. Neither CHR nor Carneades has a built-in negation operator, but in Carneades all pairs of atomic propositions of the form P and ¬P can be declared, in a single declaration, to be logical complements, which cannot both be accepted (in) in the same argument graph. If this is done, ethotic1 and ethotic2 can be used to construct rebuttals.

4.10.Argument from expert opinion

    id: expert_opinion
    variables: [W,D,S]
    premises:
      - expert(W,D)
      - in_domain(S,D)
      - asserts(W,S)
    conclusions:
      - S
    exceptions:
      - untrustworthy(W)
      - inconsistent_with_other_experts(S)
    assumptions:
      - based_on_evidence(asserts(W,S))

4.11.Argument from ignorance

This version of the scheme from ignorance is in the 2008 compendium [25], but the two critical questions of the scheme were added later, in [24].

In the reconstruction, the two critical questions are modeled by a single exception, where the uninvestigated predicate is intended to mean that the statement A has not been sufficiently investigated.

4.12.Argument from negative consequences

The critical questions are not modeled as exceptions or assumptions in the reconstruction. The first critical question asks about the weight of the argument. Weighing arguments is built in to the model of structured argument we are applying [12] and applies to all schemes, without the need for explicit exceptions or assumptions. We have interpreted the second critical question as merely challenging the first premise. Every premise can be questioned in our model of structured argument, without needing to explicitly enumerate critical questions for each premise. Alternatively, this critical question could have been interpreted as meaning that the premise is actually an assumption, not requiring proof until the question is asked. The final critical question asks whether there are any rebuttals. Rebuttals too are handled directly by the model of structured argument, without needing to add an explicit critical question asking for possible rebuttals to each scheme.

4.13.Argument from position to know

    id: position_to_know
    variables: [W,S,A]
    premises:
      - position_to_know(W,S)
      - in_domain(A,S)
      - asserts(W,A)
    conclusions:
      - A
    exceptions:
      - dishonest(W)

In the reconstruction, the source is denoted by W (for witness) instead of a, because schema variables must begin with an uppercase letter and the variable A is already used, to denote the statement being asserted. The first premise of the source version is split into two premises in the reconstruction. The first states that W is in a position to know things in the domain S. The second states that A is in the domain S.

Only one of the critical questions is explicitly modeled in the reconstruction, with an exception asking whether W is dishonest, modeling the second critical question in the source version. The other two critical questions simply ask whether the premises are true.

4.14.Argument from positive consequences

    id: positive_consequences
    variables: [A,G]
    premises:
      - brings_about(A,G)
      - good(G)
    conclusions:
      - should_be_performed(A)

The critical questions of the scheme for argument from positive consequences are the same as for the scheme for arguments from negative consequences. The reasons for not including exceptions or assumptions for these critical questions in the reconstruction are the same.

4.15.Argument from practical reasoning

Here we present two schemes for practical reasoning, from Atkinson and Bench-Capon [2] and Walton et al. [25]. We show how to represent both, simply because they have both been influential in the literature.

Atkinson and Bench-Capon’s value-based version is:

Notice that Atkinson and Bench-Capon do not distinguish premises and conclusions of the scheme. They do however list critical questions:

Here is are reconstruction of Atkinson and Bench-Capon’s scheme for practical reasoning:

    id: value_based_practical_reasoning
    variables: [A,S1,S2,G,V]
    premises:
      - current_circumstances(S1)
      - would_bring_about(A,S1,S2)
      - would_be_realized(G,S2)
      - would_promote_value(G,V)
    conclusions:
      - should_be_performed(A)
    assumptions:
      - legitimate_value(V)
      - worthy_goal(G)
      - possible(A)
    exceptions:
      - bring_about_more_effectively(S2,A)
      - realize_more_effectively(G,A)
      - promote_more_effectively(V,A)
      - side_effects(A,S1)

Now, here is Walton’s scheme for instrumental practical reasoning, called “practical inference” in [25]:

    id: instrumental_practical_reasoning
    variables: [A,S1,S2,G]
    premises:
      - current_circumstances(S1)
      - would_bring_about(A,S1,S2)
      - would_be_realized(G,S2)
    conclusions:
      - should_be_performed(A)
    assumptions:
      - possible(A)
      - possible(G)
    exceptions:
      - bring_about_more_effectively(S2,A)
      - realize_more_effectively(G,A)
      - intervening_actions(A,G)
      - side_effects(A,S1)
      - incompatible_goal(G)

4.16.Argument from precedent

The version of argument from precedent we have chosen is from [23]. The critical questions included here are new. They were not explicated in [23].

    id: precedent
    variables: [F,C,R]
    premises:
      - similar_case(C)
      - rule_of_case(R,C)
      - has_conclusion(R,F)
    conclusions:
      - F
    exceptions:
      - relevant_differences(R,F)
      - inapplicable_rule(R)

In our reconstruction of the argument from precedent, the second case, C2, representing the current case, is left implicit. This is because we want the conclusion to be that F is true, rather than F is true in case C2, so that the argument can be used to support arguments having F as a premise. Since there is only one case mentioned in the reconstruction, we have renamed C1 to C. We have reduced the four premises to three, by combining the first and fourth premises into a single premise, the first in the reconstruction, meaning that C is a previously decided case which is similar to the current case.

4.17.Slippery slope arguments

    id: slippery_slope1
    variables: [A,E]
    premises:
      - would_realize(A,E)
      - horrible_costs(E)
    conclusions:
      - negative_consequences(A)

    id: slippery_slope2
    variables: [E1,E2]
    premises:
      - causes(E1,E2)
      - horrible_costs(E2)
    conclusions:
      - horrible_costs(E1)

Notice that our reconstruction of the slippery slope scheme splits the scheme into two, where the second scheme represents an inductive step in a recursive argument for proving that events which cause events with horrible costs also have, indirectly, horrible costs. The base case in such a recursive argument would be covered by facts or assumptions stating that some particular events have horrible costs.

The reconstruction does not explicitly model the critical questions, using exceptions and assumptions. The first two critical questions are handled by the recursive (second) scheme, which chains together a sequence of events. The third critical question merely attacks the causality premise of the second scheme. Premise attacks are built into the model of structured argument and do not require critical questions to be expressed or represented.

4.18.Argument from sunk costs

The version of the scheme for argument from sunk costs below is from [25], except for the critical questions, which are new. No critical questions for the scheme were formulated in [25].

In the following scheme, let t1 be the time of the proponent’s commitment to a certain action (pre-commitment) and t2 be the time of proponent’s confrontation with the decision of whether to carry out the pre-commitment or not.

    id: sunk_costs
    variables: [A,C]
    premises:
      - sunk_costs(A,C)
      - too_high_to_waste(C)
    conclusions:
      - should_be_performed(A)
    assumptions:
      - feasible(A)
    exceptions:
      - future_losses_outweigh(A)

In the reconstruction, we have not modeled the first premise, which states there is a choice to be made between A and ¬A. This premise only makes explicit that there is a choice to be made between accepting and not accepting the conclusion of the scheme. Such premise could be added to every scheme, but is not really necessary or useful, since this choice is built-in to the underlying framework or logic of structured argumentation. The second premise, about being precommitted to the action, has been split into two in the reconstruction, one fixing the amount of the sunk costs, C, and the other claiming that these costs are too high to waste.

The first critical question, about there being some hope to complete the course of action, has been modeled in the reconstruction as an assumption, feasible(A), which is intended to mean that it is still feasible to complete the course of action. The other critical questions have been combined into a single exception in the reconstruction, future_losses_outweigh(A), which is intended to mean that projected future losses outweigh the sunk costs and the value of completing the project, in a cost-benefit analysis.

4.19.Argument from verbal classification

    id: verbal_classification
    variables: [O,F,G]
    premises:
      - instance(O,F)
      - subclass(F,G)
    conclusions:
      - instance(O,G)

4.20.Argument from witness testimony

    id: witness_testimony
    variables: [W,D,S]
    premises:
      - position_to_know(W,D)
      - in_domain(D,S)
      - believes(W,S)
      - asserts(W,S)
    conclusions:
      - S
    assumptions:
      - internally_consistent(S)
    exceptions:
      - inconsistent_with_known_facts(S)
      - inconsistent_with_other_witnesses(S)
      - biased(W)
      - implausible(S)

Figure 1 shows a simple example of how these schemes can be used by Carneades 4 to automatically generate, evaluate and visualize an argument graph, given the following assumptions:

Fig. 1.

Global warming example.