 # Agent-Based Proof Design via Lemma Flow Diagram

We discuss an agent-based approach to proof design and implementation, which we call Lemma Flow Diagram (LFD). This approach is based on the multicut rule with shared cuts. This approach is modular and easy to use, read and automate. Thus, we consider LFD an appealing alternative to `flow proof' which is popular in mathematical education. Some examples are provided.

## Authors

##### This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

## 1 Introduction

Proofs typically have a great level of complexity and therefore require a careful proof design to reduce their complexity. Despite its importance, proof design has received little attention. This is in contrast to the situation where proof procedures – natural deduction, resolution and sequent systems, etc – are well-studied.

In this paper, we introduce a new proof design tool called Lemma Flow Diagram (LFD). The most central aspect of proof design is a set of well-chosen lemmas. A set of well-chosen lemmas is important in two aspects:

• It improves the readability of the proof.

• It improves the search for the proof in automated reasoning.

In fact, it is a set of lemmas that makes proofs reative, diverse and interesting. In contrast, proofs without lemmas are rather mechanical, unimaginative and quite awkward.

As we shall see, our design tool is natural and very easy to use, read and automate. This is analogous to the situation where people have introduced software design tools – UML, etc – to design complex software. LFD is modeled after the interactive computing model of Computability Logic  and its distributed variant with agent parameters .

Our starting point for building lemma-based proofs is the multicut(MC) rule. The MC rule expresses a form of modus pones – or lemma-based reasoning – which is the key element in compact proof design.

Suppose we have well chosen lemmas . Then the (distributed version of) MC rule is of the form:

 Δ1⊢m1B1…Δn⊢mnBnB1,…,Bn,Γ⊢mCΔ1,…,Δn,Γ⊢mC

Here, are a set of formulas, are formulas, and each is an agent/machine. That is, each tries to prove with respect to .

The premise of the above rule is easy to implement by distributedly processing each sequent in the premise but there is some unnaturalness in the above rule. That is, each can be “shared” between two agents but there is no indication of this fact.

A second, alternative way is to represent the MC rule with “sharing”. This rule, which we call the MC’ rule, is shown below:

 Δ1⊢m1…Δn⊢mnB1m1,…,Bnmn,Γ⊢mCΔ1,…,Δn,Γ⊢mC

Here, acts as the knowledgebase of and acts as a query to .

This MC’ rule leads to the diagram in Figure 1.

In the diagram, note that each lemma is shared between and . We call this diagram LFD with the following features:

• A regular arrow to box B with circle F means that some unknown identity (e.g. Nature) provides a regular service to B. Regular services include or .

• A regular arrow from box A to box B with circle F in the middle means that A provides a querying service F to B.

• Knowledgebase(KB) of an agent is marked with s. In contrast, queries to the agent is marked without s.

• We assume that the top-level operator associated with an agent is . That is, an agent with multiple KB services and a query services should be understood as an agent with a query service .

LFD can be seen as a modular alternative to the “flow proof” which is popular in mathematical education.

## 2 Examples

As an example of LFD, we will look at Peano Arithmetic (PA). PA is formulated with the usual . This is shown below.

 PA rules. (1)∀x∀y(x+1=y+1\small→x=y). (2)∀x(x+1≠0). (3)0+1=1. (4)∀x(x+0=x). (5)∀x∀y(x+(y+1)=(x+y)+1). (6)∀x(x×0=0). (7)∀x∀y(x×(y+1)=(x+y)+x). (8)∀Q((Q(0)\small∧∀x(Q(x)\small→Q(x+1)))\small→∀xQ(x)).

Rule (8) is called the Induction rule.

Now we want to prove the following:

 ∀x(x+1=1+x)

The proof requires mathematical induction with being . The base case which is follows from axiom 3 and 4. The induction step follows from induction hypothesis and axiom 5.

We display the LFD of the above example in Figure 2. This diagram is straightforward to understand.

## 3 Distributed first-order logic

To represent the ‘querying’ formulas in the MC’ rule, we need a new representation language, because they are not allowed in classical logic. For this reason, we introduce FOL which provides an elegant solution in this regard.

FOL is based on the game semantics. For this reason, we review the the game-semantical meanings of first-order logic.

First of all, classical propositions are viewed as special, elementary sorts of games that have no moves and are automatically won by the machine if true, and lost if false. For example, the proposition is true and is automatically won by the machine.

There are two special atoms and . is always true, and is always false.

Negation is a role-switch operation: is obtained from by turning ’s moves and wins into ’s moves and wins, and vice versa. For example, if Chess means the game of chess from the view of the black player, then Chess is the same game from the of view of the white player.

The parallel operations deal with concurrent computations. Playing or means playing, in parallel, the two games and . In , is considered the winner if it wins in both of the components, while in it is sufficient to win in one of the components.

The reduction operation is understood as .

The blind quantifiers and model information hiding with meaning ’s choices, and meaning choices by . In both cases, the value of is unknown or invisible to the opponent.

Following the ideas in , we introduce FOL, a slight extension to FOL with agent parameters. Let be a formula in first-order logic. We introduce a new env-annotated formula which reads as ‘play against an agent . For , we say is the matching environment of .

In introducing agent parameters to a formula , some formulas turn out to be difficult to process. ‘Environment-switching’ formulas are such examples. In them, the machine initially provides a service against agent and then switches to provide another service to another agent inside . This kind of formulas are difficult to process. This leads to the following definition:

###### Definition 3.1

The class of FOL-formulas is defined as the smallest set of expressions such that (a) For any FOL-formula and any agent , is in it and, (b) if and are in it, then so are .

Given a FOL-formula , the diagram of can be easily obtained.

###### Definition 3.2

Given a FOL-formula , the diagram of – denoted by – is obtained by the rules in Figure 3. There, is a FOL-formula and are FOL-formulas. Further, is the current machine, is an environment.

## 4 An Example: Encoding the Peano Axiom

The diagram in Section 2 corresponds to the following FOL. The (KB of) agent is shown below.

 agent m1. ∀x∀y(x+1=y+1\small→x=y). ∀x(x+1≠0). 0+1=1. ∀x(x+0=x). ∀x∀y(x+(y+1)=(x+y)+1). ∀x(x×0=0). ∀x∀y(x×(y+1)=(x+y)+x).

Our language permits ‘querying knowledge’ of the form in KB. This requires the current machine to invoke the query to the agent . Now let us consider the agent which handles mathematical induction. It contains the induction rule and two querying knowledges and . Note that the induction rule is technically not first-order but it does not affect our main argument.

 agent m. Q(0)m1. (∀x(Q(x)\small→Q(x+1)))m1. ∀Q((Q(0)\small∧∀x(Q(x)\small→Q(x+1)))\small→∀xQ(x)).

Last, the theorem to prove corresponds to the query ?- with respect to the agent.

It can be easily observed that the above code can be automated. This leads to the notion of Lemma Flow Theorem Proving. Now, solving the above goal has the following strategy: first solve both the query and with respect to and then solve with respect to . Note that all three attempts must succeed for to be true.

## 5 Conclusion

In this paper, we have considered a proof design tool called LFD and a distributed first-order logic FOL. Our diagram allows modular, distributed proof design. It is therefore useful for reading/writing/automating proofs. FOL has a simple syntax and semantics and is well-suited to representing distributed KB .

## 6 Acknowledgements

This work was supported by DongA University Research Fund.