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 wellstudied.
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 wellchosen lemmas. A set of wellchosen 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 [1]–[5] and its distributed variant with agent parameters [6].
Our starting point for building lemmabased proofs is the multicut(MC) rule. The MC rule expresses a form of modus pones – or lemmabased 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 toplevel 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.
rules. 
(1). 
(2). 
(3). 
(4). 
(5). 
(6). 
(7). 
(8). 
Rule (8) is called the Induction rule.
Now we want to prove the following:
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 firstorder 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 gamesemantical meanings of firstorder logic[3].
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 roleswitch 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 [6], we introduce FOL, a slight extension to FOL with agent parameters. Let be a formula in firstorder logic. We introduce a new envannotated 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. ‘Environmentswitching’ 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 FOLformulas is defined as the smallest set of expressions such that (a) For any FOLformula and any agent , is in it and, (b) if and are in it, then so are .
Given a FOLformula , the diagram of can be easily obtained.
Definition 3.2
Given a FOLformula , the diagram of – denoted by – is obtained by the rules in Figure 3. There, is a FOLformula and are FOLformulas. 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.
. 
. 
. 
. 
. 
. 
. 
. 
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 firstorder but it does not affect our main argument.
. 
. 
. 
. 
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 firstorder 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 wellsuited to representing distributed KB [7].
6 Acknowledgements
This work was supported by DongA University Research Fund.
References
 [1] Japaridze G. Introduction to computability logic. Annals of Pure and Applied Logic, 2003, 123(1/3): 199.
 [2] Japaridze G. Computability logic: a formal theory of interaction. In Interactive Computation: The New Paradigm, Goldin D, Smolka S A, Wegner P (eds.), Springer, 2006, pp. 183223.
 [3] Japaridze G. In the beginning was game semantics. In Games: Unifying Logic, Language and Philosophy, Majer O, Pietarinen A V, Tulenheimo T (eds.), Springer, 2009, pp. 249350.
 [4] Japaridze G. Towards applied theories based on computability logic. Journal of Symbolic Logic, 2010, 75(2): 565601.
 [5] Japaridze G. On the system CL12 of computability logic. http://arxiv.org/abs/1203.0103, June 2013.
 [6] Kwon K. Towards distributed logic programming based on computability logic. http://arxiv.org/abs/1909.07036, 2019.

[7]
S.W. Loke and A. Davison: LogicWeb: Enhancing the Web with Logic Programming.
Journal of Logic Programming, 1998, 36(3): 195240.
Comments
There are no comments yet.