[
Abstract
Answer set programming is a prominent declarative programming paradigm used in formulating combinatorial search problems and implementing distinct knowledge representation formalisms. It is common that several related and yet substantially different answer set programs exist for a given problem. Sometimes these encodings may display significantly different performance. Uncovering precise formal links between these programs is often important and yet far from trivial. This paper claims the correctness of a number of interesting program rewritings.
]
Strong Equivalence and Program’s Structure in Arguing Essential Equivalence between
Logic Programs Yu. Lierler]
YULIYA LIERLER
6001 Dodge St, Omaha, NE 68182, USA
\jdateMarch 2003
2003
\pagerangeLABEL:firstpage–LABEL:lastpage
\doiS1471068401001193
1 Introduction
Answer set programming (ASP) is a prominent knowledge representation paradigm with roots in logic programming [Brewka et al. (2011)]. It is frequently used for addressing combinatorial search problems. It has also been used to provide implementations and/or translational semantics to other knowledge representation formalisms such as action languages including languages [Gelfond and Lifschitz (1998), Section 5], [Lifschitz and Turner (1999)], [Lee et al. (2013)], [Giunchiglia et al. (2004), Babb and Lee (2013)], an [Gelfond and Kahl (2014), Section 8].
In answer set programming, a given computational problem is represented by a declarative program, also called a problem encoding, that describes the properties of a solution to the problem. Then, an answer set solver is used to generate answer sets for the program. These answer sets correspond to solutions to the original problem. As answer set programming evolves, new language features come to life providing means to reformulations of original problem encodings. Such new formulations often prove to be more intuitive and/or more concise and/or more efficient. Similarly, when a software engineer tackles a problem domain by means of answer set programming it is a common practice to first develop a/some solution to a problem and then rewrite this solution iteratively using such techniques, for example, as projection to gain a better performing encoding [Buddenhagen and Lierler (2015)]. These common processes bring a scientific question to light: what are the formal means to argue the correctness of renewed formulations of the original encodings to problems. In other words, under assumption that the original encoding to a problem is correct how can we argue that a related and yet different encoding is also correct.
It has been long recognized that studying various notions of equivalence between programs under the answer set semantics is of crucial importance. Researchers proposed and studied strong equivalence [Lifschitz et al. (2001), Lifschitz et al. (2007)], uniform equivalence [Eiter and Fink (2003)], relativized strong and uniform equivalences [Woltran (2004)]. Another related approach is the study of forgetting [Leite (2017)]. Also, equivalences relative to specified signatures were considered [Erdoğan and Lifschitz (2004), Eiter et al. (2005), Woltran (2008), Harrison and Lierler (2016)]. In most of the cases the programs considered for studying the distinct forms of equivalence are propositional. Works by \citeNeit06, \citeNeit06a, \citeNlif07a, \citeNoet08, \citeNpea12, and \citeNhar16 are exceptions. These authors consider programs with variables (or, firstorder programs). It is firstorder programs that ASP knowledge engineers develop. Thus, theories on equivalence between programs with variables are especially important as they can lead to more direct arguments about properties of programs used in practice.
In this paper we show how concepts of strong equivalence and and so called conservative extension are of use in illustrating that two programs over different signatures and with significantly different structure are ”essentially the same” in a sense that they capture solutions to the same problem. The paper has two parts. In the first part we consider propositional programs. In the second part, we move to the programs with variables. These parts can be studied separately. The first one is appropriate for researchers who are not yet deeply familiar with answer set programming theory and are interested in learning formal details. The second part is geared towards answer set programming practitioners providing them with theoretical grounds and tools to assist them in program analysis and formal claims about the developed encodings and their relations. In both of these parts we utilize running examples stemming from the literature. For instance, for the case of propositional programs we study two distinct ASP formalizations of action language . In the case of firstorder programs, we study two distinct formalizations of planning modules for action language . In both cases we identify interesting results. We now provide a detailed outline for the tow parts of the paper.
Outline of the first part: propositional programs
We start by presenting the original formalization of action language in the language of logic programs under answer set semantics [Lifschitz and Turner (1999)]. Specifically, \citeNlif99b proposed a translation from an action description in to a logic program so that the answer sets of this program capture all the ”histories” of length in the transition system specified by . Since that original work, languages of answer set programming have incorporated new features such as, for instance, choice rules. At present, these are commonly used by the practitioners of ASP. It is easy to imagine that in a modern formalization of action language , given a system description a resulting program will be different from the original . In fact, \citeNbab13 present a translation of an action language (note how is said to be the immediate predecessor of [Giunchiglia et al. (2004), Section 7.3]) that utilizes modern language features such as choice rules. Here, we present this translation for the case of . In particular, we restrict the language of to boolean, or twovalued, fluents (in general, permits multivalued fluents). We call this translation . Although, and share a lot in common they are substantially different. To begin with, the signatures of these programs are not identical. Also, utilizes choice rules. The programs and are different enough that it is not immediately obvious that their answer sets capture the same entities. There are two ways to argue that the program is ”essentially the same” as program : to illustrate that the answer sets of capture all the ”histories” of length in the transition system specified by by relying

on the definitions of action language ;

on the properties of programs and that establish a onetoone correspondence between their answer sets.
Here we take the second way into consideration. We illustrate how the concepts of strong equivalence and conservative extension together with formal results previously discovered about these prove to be of essence in this argument. Thus, we showcase a proof technique for arguing on the correctness of a logic program. This proof technique assumes the existence of a ”gold standard” logic program formalizing a problem at hand, in a sense that this gold standard is trusted to produce correct results. It is a common practice in development of answer set programming solutions to obtain a final formalization of a problem by first producing such a gold standard program and then applying a number of rewriting procedures to that program to enhance its performance. The benefits of the proposed method are twofold. First, this methodology can be used by software engineers during a formal analysis of their solutions. Second, we trust that this methodology paves a way for a general framework for arguing correctness of common program rewritings so that they can be automated for the gain of performance. This is a question for investigation in the future.
Our work, which illustrates that logic programs and are essentially the same, also uncovers a precise formal link between the action description languages and . Although, the authors of claimed that is an immediate predecessor of , the exact formal link between the two languages has not been stated, to the best of our knowledge. Thus, prior one could view as a generalization of only informally alluding to the fact that allows the same intuitive interpretation of syntactic expressions of , but generalizes these to allow multivalued fluents in place of boolean ones. These languages share the same syntactic constructs such as, for example, a dynamic law of the form
that we intuitively read as after the concurrent execution of actions the fluent expression holds in case if fluents expressions were the case at the time when aforementioned actions took place. Both languages provide interpretations for such expressions that meet our intuitions of this informal reading. Yet, if one studies the semantics of these languages it is not trivial to establish a specific formal link between them. For example, the semantics of relies on the concepts of causal theories [Giunchiglia et al. (2004)]. The semantics of makes no reference to these theories. Here we recall the translations of and to logic programs, whose answer sets correspond to their key semantic objects. We then state the precise relation between the two by means of relating the relevant translations. In conclusion, can be viewed as a true generalization of the language to the case of multivalued fluents.
Detailed outline of the second part: programs with variables
On the one hand, this part of the paper can be seen as a continuation of work by \citeNeit06, where we consider common program rewritings using a more complex dialect of logic programs. On the other hand, it grounds the concept of program’s synonymity studied by \citeNpea12 in a number of practical examples. Namely, we illustrate how formal results on strong equivalence developed earlier and in this work help us to construct precise claims about programs in practice.
In this part of the paper, we systematically study some common rewritings on firstorder programs utilized by ASP practitioners. As a running and motivating example that grounds general theoretical presentation of this work into specific context, we consider two formalizations of a planning module given in [Gelfond and Kahl (2014), Section 9]. Namely,

a Planchoice formalization that utilizes choice rules and aggregate expressions,

a Plandisj formalization that utilizes disjunctive rules.
Such a planning module is meant to be augmented with an ASP representation of a dynamic system description expressed in action language . \citeNgel14 formally state in Proposition 9.1.1 that the answer sets of program Plandisj augmented with a given system description encode all the “histories/plans” of a specified length in the transition system captured by the system description. Although both Planchoice and Plandisj programs intuitively encode the same knowledge the exact connection between them is not immediate. In fact, these programs

do not share the same signature, and

use distinct syntactic constructs such as choice, disjunction, aggregates in the specification of a problem.
Here, we establish a onetoone correspondence between the answer sets of these programs using their properties. Thus, the aforementioned formal claim about Plandisj translates into the same claim for Planchoice. It is due to remark that although \citeNgel14 use the word “module” when encoding a planning domain, they utilize this term only informally to refer to a collection of rules responsible for formalizing “planning”.
Here we use a dialect of ASP language called RASPL1 [Lee et al. (2008)]. Notably, this language combines choice, aggregate, and disjunction constructs. Its semantics is given in terms of the SM operator, which exemplifies the approach to the semantics of firstorder programs that bypasses grounding. Relying on SMbased semantics allows us to refer to earlier work that study the formal properties of firstorder programs [Ferraris et al. (2011), Ferraris et al. (2009)] using this operator. We state a sequence of formal results on programs rewritings and/or programs’ properties. Some discussed rewritings are well known and frequently used in practice. Often, their correctness is an immediate consequence of well known properties about logic programs (e.g., relation between intuitionistically provable firstorder formulas and strongly equivalent programs viewed as such formulas). Other discussed rewritings are far less straightforward and require elaborations on previous theoretical findings about the operator SM. It is well known that propositional headcyclefree disjunctive programs [BenEliyahu and Dechter (1994)] can be rewritten to nondisjunctive programs by means of simple syntactic transformation. Here we not only generalize this result to the case of firstorder programs, but also illustrate that at times we can remove disjunction from parts of a program even though the program is not headcyclefree. This result is relevant to local shifting and componentwise shifting discussed in [Eiter et al. (2006)] and [Janhunen et al. (2007)], respectively. We also generalize so called Completion Lemma and Lemma on Explicit Definitions stated in [Ferraris (2005), Ferraris and Lifschitz (2005)] for the case of propositional theories and propositional logic programs. These generalizations are applicable to firstorder programs.
This part of the paper is a substantially extended version of the paper presented at PADL 2019 [Lierler (2019)].
Summary. We view this paper as an important step towards bringing theories about program’s equivalence to providing practical solutions in the realm of ASP as it is used by knowledge engineers. A portfolio of formal results on program rewritings stated in this paper can serve as a solid theoretical basis for

a portfolio of program rewritings;

a software system that may automatically produce new variants of logic programs (some of these encodings will often exhibit better performance) by utilizing studied rewritings;

a proof technique for arguing the correctness of a logic program. This proof technique assumes the existence of a “gold standard” logic program formalizing a problem at hand, in a sense that this gold standard is trusted to produce correct results. A proper portfolio of known program rewritings and their properties equips ASP practitioners with powerful tools to argue that another encoding is essentially the same to the gold standard.
Paper Outline. The paper is structured as follows. We start by reviewing action language in Section 2.1. Section 2.2 presents the concepts of (i) a propositional logic program, (ii) strong equivalence between propositional logic programs, and (iii) a propositional logic program being a conservative extension of another one. We also review a weak natural deduction system that is later used to formally argue the strong equivalence between groups of logic rules. Section 2.3 introduces a rewriting technique frequently used by ASP developers when a new auxiliary proposition is introduced in order to denote a conjunction of other propositions. Then these conjunctions are safely renamed by the auxiliary atom. We refer to this process as explicit definition rewriting and illustrate its correctness. In Section 2.4, we present an original, or gold standard, translation of language to a logic program. Section 2.5 states a modern formalization stemming from the translation of a syntactically restricted . At last, in Section 2.6 we showcase how we can argue on the correctness of a modern formalization by illustrating the formal relation between the original and modern translations of language . We utilize reasoning by weak natural deduction and a formal result on explicit definition rewriting in this illustration.
We start the second part of the paper by presenting the Planchoice and Plandisj programs at the onset of Section 3. We then introduce a logic program language called RASPL1 in Section 3.2. The semantics of this language is given in terms of the SM operator in Section 3.2.2. In Section 3.2.3, we review the concept of strong equivalence for first order programs. Section 3.3 is devoted to a sequence of formal results on program’s rewritings. In conclusion, in Section 3.4 we review a frequently used rewriting technique called projection that often translates into better performing encodings. We illustrate the utility of the presented theoretical results as they can be used to argue the correctness of distinct versions of projection.
2 Propositional Programs
2.1 Review of Action Language C
This review of action language follows [Lifschitz and Turner (1999)].
We consider a set of propositional symbols partitioned into the fluent names and the elementary action names . An action is an interpretation of . Here we only consider what \citeNlif99b call definite action descriptions so that we only define this special class of action descriptions.
Syntactically, a action description is a set of static and dynamic laws. Static laws are of the form
(1) 
and dynamic laws are of the form
(2) 
where

is either a literal over or the symbol ,

() is a literal in ,

() is a literal in , and

conjunctions and are possibly empty and understood as in this case.
In both laws, the literal is called the head.
Semantically, an action description defines a graph or a transition system. We call nodes of this graph states and directed edges transitions. We now define these concepts precisely. Consider an action description . A state is an interpretation of that satisfies implication
for every static law (1) in . A transition is any triple , where , are states and is an action; is the initial state of the transition, and is its resulting state. A literal is caused in a transition if it is

the head of a static law (1) from such that satisfies , or
A transition is causally explained by if its resulting state is the set of literals caused in this transition.
The transition system described by an action description is the directed graph, which has the states of as nodes, and which includes an edge from state to state labeled for every transition that is causally explained by .
We now present an example from [Lifschitz and Turner (1999)] that formalizes the effects of putting an object in water. We use this domain as a running example. It uses the fluent names and and the elementary action name . In the notation introduced in [Gelfond and Lifschitz (1998), Section 6], the action description for water domain follows^{1}^{1}1We remark on the key word inertial. It intuitively suggests that a fluent declared to be inertial is such that its value can be changed by actions only. If no actions, which directly or indirectly affect such a fluent, occur then the value of the inertial fluent remains unchanged.
Written in full this action description contains six laws:
The corresponding transition system has 3 states:
and 6 causally explained transitions
(3) 
We depict this transition system in Figure 1.
2.2 Traditional Logic Programs and their Equivalences
A (traditional logic) program is a finite set of rules of the form
(3) 
, where each is an atom or and each () is an atom, , or . The expression containing atoms through is called the body of the rule. Atom is called a head.
We define the answer sets of a traditional program following [Lifschitz et al. (1999)]. We say that a program is basic, when it does not contain connective . In other words a basic program consists of the rules of the form
(4) 
where each is an atom or and each () is an atom, , or . We say that a set of atoms satisfies rule (4) if it satisfies the implication
We say that a set of atoms is an answer set of a basic program if is a minimal set among sets satisfying all rules of .
A reduct of a program with respect to a set of atoms, denoted by , is constructed as follows. For each rule (3) in

when () is such that , replace this expression with , otherwise replace it with ,

when () is such that , replace this expression with , otherwise replace it with .
It is easy to see that a reduct of a program forms a basic program. We say that a set of atoms is an answer set of a traditional program if it is an answer set for the reduct .
In the later part of the paper we present the definition of an answer set for programs with variables by means of operator SM [Ferraris et al. (2011)]. \citeNfer09 show in which sense SM operator captures the semantics of answer sets presented here.
According to [Ferraris and Lifschitz (2005)] and [Ferraris (2005)], rules of the form (3) are sufficient to capture the meaning of the choice rule construct commonly used in answer set programming. For instance, the choice rule is understood as the rule
We use choice rule notation in the sequel.
2.2.1 Strong Equivalence and ”Weak” Natural Deduction
Traditional programs and are strongly equivalent [Lifschitz et al. (2001)] when for every program , programs and have the same answer sets. In addition to introducing the strong equivalence, \citeNlif01 also illustrated that traditional programs can be associated with the propositional formulas and a question whether the programs are strongly equivalent can be turned into a question whether the respective propositional formulas are equivalent in the logic of hereandthere (HTlogic), an intermediate logic between classical and intuitionistic one.
We follow the steps of [Lifschitz et al. (2001)] and identify a rule (3) with the propositional formula
(5) 
lif01 state that every formula provable in the natural deduction system, where the axiom of the law of the excluded middle () is replaced by the weak law of the excluded middle (), is a theorem of HT. We call this system weak natural deduction system. Since we use this observation in providing formal arguments, we review the weak natural deduction system next. We denote this system by N. Its review follows the lines of [Lifschitz (2016)] to a large extent. For another reference to natural deductions system we refer the reader to [Lifschitz et al. (2008)]. We note that \citeNmin10 introduced an alternative sequent calculus for logic of HT that was further generalized to firstorder case.
A sequent is an expression of the form
(6) 
(“ under assumptions ”), where is a propositional formula that allows connectives
and is a finite set of formulas. If is written as , we drop the braces and write (6) as Intuitively, this sequent is understood as the formula if , and as if .
The axioms of N are sequents of the forms
In the list of inference rules presented in Figure 2, , , are finite sets of formulas, and are formulas. The inference rules of N except for the two rules at the last row are classified into introduction rules and elimination rules ; the exceptions are the contradiction rule and the weakening rule .
A proof/derivation is a list of sequents such that each is either an axiom or can be derived from some of the sequents in by one of the inference rules. To prove a sequent means to find a proof with the last sequent . To prove a formula means to prove the sequent .
The De Morgan’s law
is provable intuitionistically (where we understand formula as an abbreviation for ). Thus, formulas and are intuitionistically equivalent. The other De Morgan’s law
is such that its one half is provable intuitionistically, while the other one is provable in HT (thus, formulas and are equivalent in HTlogic). We illustrate the latter fact in Figure 3 using system N. In other words, we prove sequent in N. It is convenient to introduce abbreviations for the assumptions used in the proofs so that abbreviates assumption in Figure 3.
It is easy to show that the propositional formulas and are equivalent using N, so that in the sequel we often identify rules of the form
with the propositional formula
2.2.2 Conservative Extensions
\citeNhar16 defined the notion of a conservative extension for the case of logic programs. Similarly to strong equivalence, it attempts to capture the conditions under which we can rewrite parts of the program and yet guarantee that the resulting program is not different in an essential way from the original one. Conservative extensions allow us to reason about rewritings even when the rules in question have different signatures.
For a program , by we denote the set of atoms occurring in . Let and be programs such that . We say that program is a conservative extension of if is a 11 correspondence between the answer sets of and the answer sets of . For instance, program
(7) 
is a conservative extension of program containing a single choice rule
Furthermore, given program such that (i) it contains rule and (ii) , a program constructed from by replacing with (7) is a conservative extension of .
2.3 On Explicit Definition Rewriting
We now turn our attention to a common rewriting technique based on explicit definitions and illustrate its correctness. This technique introduces an auxiliary proposition in order to denote a conjunction of other propositions. Then these conjunctions are safely renamed by the auxiliary atom in the remainder of the program.
We call a formula basic conjunction when it is of the form
(8) 
where each () is an atom, , or . For example, the body of any rule in a traditional program is a basic conjunction.
Let be a program, be a set of atoms that do not occur in . For an atom , let denote a basic conjunction (8) where () in . We say that is an explicit definition of in terms of . By we denote a set of formulas for each atom . We assume that all these formulas are distinct. Program is constructed from as follows:

all occurrences of all formulas from in some body of are replaced by respective ,

for every atom a rule of the form
is added to the program.
For instance, let be a program
then follows
The proposition below supports the fact that the latter program is a conservative extension of the former.
Proposition 1
Let be a program, be a set of atoms that do not occur in , and be a set composed of explicit definitions for each element in in terms of . Program is a conservative extension of .
To prove Proposition 1 several earlier results from the literature are of use.
Proposition 2 (Replacement Theorem I in [Mints (2000)], Section 2.8)
If is a formula containing a subformula and is the result of replacing that subformula by then intuitionistically implies .
To rely on formal results stated earlier in the literature, we now consider the case of programs that are more general than traditional logic programs. We call such programs definitional. In other words, traditional programs are their special case. A definitional program consists of rules of the form (5) (recall that we identify rule (3) with the propositional formula (5)) and rules of the form , where is an atom and is a basic conjunction. If a program contains two rules and we abbreviate that by a single expression . A definitional program is a special case of propositional theories presented in [Ferraris (2005)]. We understand the notion of answer sets for such programs as presented in that work. \citeN[Section 2]fer05 illustrates that in application to any traditional program the definition from [Lifschitz et al. (1999)], presented here, and their definition are equivalent.
We now restate the results that immediately follow from Lemma on Explicit Definitions and Completion Lemma presented in [Ferraris (2005)] for the case of definitional programs.
Proposition 3 (Proposition 4 [Ferraris (2005)])
Let be a definitional program and be a set of atoms that do not occur in . For each , let be a basic conjunction that does not contain any atom in . Then, is a 11 correspondence between the answer sets if and the answer sets of .
Proposition 4 (Proposition 5 [Ferraris (2005)])
Let be a definitional program and be a set of atoms that do not occur in . For each , let be a basic conjunction that does not contain any atom in . Then, and have the answer sets of .
[Proof of Proposition 1] By we denote a program constructed from by adding a rule for every atom . By Proposition 3, is a conservative extension of . By Proposition 4, traditional program has the same answer sets as the definitional program constructed from by replacing a rule with a rule . Similarly, traditional program has the same answer sets as the definitional program constructed from it by replacing a rule with a rule . By Replacement Theorem I, and are strongly equivalent.
2.4 Review of Basic Translation
Let be an action description. \citeNlif99b defined a translation from action description to a logic program parametrized with a positive integer that intuitively represents a time horizon. The remarkable property of logic program that its answer sets correspond to ”histories” – path of length in the transition system described by .
Recall that by we denote fluent names of and by we denote elementary action names of . Let us construct ”complementary” vocabularies to and as follows
and
For a literal , we define
and
The language of has atoms of four kinds:

fluent atoms–the fluent names of followed by where ,

action atoms–the action names of followed by where ,

complement fluent atoms–the elements of followed by where ,

complement action atoms–the elements of followed by where .
Program consists of the following rules:

for every atom that is a fluent or action atom of the language of
(9) and
(10) 
the rules
(13) for all fluent names in and

for every atom that is an action atom of the language of the rules
Proposition 5 (Proposition 1 in [Lifschitz and Turner (1999)])
For a set of atoms, is an answer set for if and only if it has the form
for some path in the transition system described by .
We note that [Lifschitz and Turner (1999)] presented translation and Proposition 1 using both default negation and classical negation in the program. Yet, classical negation can always be eliminated from a program by means of auxiliary atoms and additional constraints as it is done here. In particular, auxiliary atoms have the form (where intuitively stands for literal ), while the additional constraints have the form (9).
2.5 Simplified Modern Translation
As in the previous section, let be an action description and a positive integer. In this section we define a translation from action description to a logic program inspired by and the advances in answer set programming languages. The main property of logic program is as in case of that its answer sets correspond to ”histories” captured by the transition system described by . This translation is a special case of a translation by [Babb and Lee (2013)] for an action language that is limited to twovalued fluents.
The language of has atoms of three kinds that coincide with the three first groups (13) of atoms identified in the language of .
For a literal , we define
Program consists of the following rules:

for every static law (1) in , contains the rules of the form
(14) for all ^{2}^{2}2\citeNbab13 allow rules with arbitrary formulas in their bodies so that in place of (14) they consider rule . Yet, it is well known that such a rule is strongly equivalent to (14). Furthermore, more answer set solvers allow rules of the form (14) than more general rules considered in [Babb and Lee (2013)].,

for every dynamic law (2) in , the rules
for all ,

the rules
(15) for all fluent names in and

for every atom that is an action atom of the language of , the choice rules Here we note that the language assumes every action to be exogenous, whereas this is not the case in , where it has to be explicitly stated whether an action has this property. Thus, in [Babb and Lee (2013)] rules of this group only appear for the case of actions that have been stated exogenous.
The translation of action description (3) consists of all rules of the form
2.6 On the Relation Between Programs and
Proposition 6 stated in this section is the key result of this part of the paper. Its proof outlines the essential steps that we take in arguing that two logic programs and formalizing the action language are essentially the same. The key claim of the proof is that logic program is a conservative extension of .
The argument of this claim requires some close attention to groups of rules in program. In particular, we establish by means of weak natural deduction that

the rules in group 1 and 2 of are strongly equivalent to the rules in group 1 and 2 of and

the rules in group 1 and 4 of are strongly equivalent to the rules in group 1 and 4 of .
Similarly, we show that

the rules in group 1 and 3 of are strongly equivalent to the rules in group 1 of and the rules structurally similar to rules in group 3 of and yet not the same.
These arguments allow us to construct a program , whose answer sets are the same as these of . Program is a conservative extension of due to explicit definition rewriting. Proposition 1 helps us to uncover this fact.
Recall that the language of includes the action atoms–the action names of followed by where . We denote the action atoms by .
Proposition 6
For a set of atoms, is an answer set for if and only if set has the form
for some path in the transition system described by .
We now state auxiliary lemmas that are useful in the argument of Proposition 6. It is constructed by uncovering the formal link between logic programs and , where serves the role of a gold standard by the virtue of Proposition 5.
Lemma 2.1
If is a formula containing a subformula and is the result of replacing that subformula by then the sequent
is provable in N, where is arbitrary set of assumptions.
Trivially follows from the Replacement Theorem I stated as Proposition 2 here.
Lemma 2.2
The sequent
is provable in N.
We illustrate the proof in N for the sequent
We allow ourselves a freedom to use De Morgan’s Laws as if they were given to us as additional inference rules in N.
Similar proofs in structure are available for the sequents
Several applications of will allow us to conclude the proof in N for the sequent in the statement of this lemma.
[Proof of Proposition 6] It is easy to see that the signatures of and differ by complement action atoms present in . What we show next is the fact that is a conservative extension of . Then the claim of this proposition follows from Proposition 5.
Claim 1: The set of rules from groups 1 and 3 of are strongly equivalent to the set of rules from group 1 of and the rules